mod artifact;
mod cmd;
mod compiler;
mod error;
mod project;
mod result_json;
mod safety;
mod targets;
mod tools_leo;
use clap::{Args, Parser, Subcommand};
use error::PfResult;
use std::path::PathBuf;
#[derive(Parser)]
#[command(
name = "pf",
version,
about = "ProofForge developer CLI (cargo-like)",
long_about = "Project-oriented wrapper around proof-forge-next and official chain tools.\n\
\n\
Typical flow:\n pf new hello && cd hello\n pf build\n pf run -- initialize 5u64\n pf deploy --network testnet\n\
\n\
Defaults come from pf.toml (default-target=aleo, out-dir=build/<target>/)."
)]
struct Cli {
#[arg(long, global = true)]
json: bool,
#[arg(long, short = 'y', global = true)]
yes: bool,
#[command(subcommand)]
command: Commands,
}
#[derive(Subcommand)]
enum Commands {
New {
name: String,
#[arg(long, default_value = "aleo")]
target: String,
#[arg(long)]
path: Option<PathBuf>,
},
Setup {
#[arg(long)]
target: Option<String>,
},
Doctor {
#[arg(long)]
target: Vec<String>,
},
Build(BuildArgs),
Clean,
Check(CheckArgs),
Inspect {
#[arg(long)]
artifact: Option<PathBuf>,
#[arg(long)]
target: Option<String>,
},
Verify {
#[arg(long, short = 't')]
target: Option<String>,
#[arg(long)]
artifact: Option<PathBuf>,
#[arg(long)]
adapter: Option<String>,
},
Test {
#[arg(long, short = 't')]
target: Option<String>,
#[arg(long)]
artifact: Option<PathBuf>,
},
Run(RunArgs),
Local {
#[command(subcommand)]
command: LocalCommands,
},
Deploy(NetworkArgs),
Execute(ExecuteArgs),
Version,
ListTargets,
}
#[derive(Args)]
struct BuildArgs {
source: Option<PathBuf>,
#[arg(long)]
module: Option<String>,
#[arg(long, short = 't')]
target: Option<String>,
#[arg(long)]
root: Option<PathBuf>,
#[arg(short = 'o', long)]
output: Option<PathBuf>,
#[arg(long)]
profile: Option<String>,
}
#[derive(Args)]
struct CheckArgs {
source: Option<PathBuf>,
#[arg(long)]
module: Option<String>,
#[arg(long)]
root: Option<PathBuf>,
}
#[derive(Subcommand)]
enum LocalCommands {
Run(RunArgs),
}
#[derive(Args)]
struct RunArgs {
#[arg(long, short = 't')]
target: Option<String>,
#[arg(long)]
artifact: Option<PathBuf>,
#[arg(long, short = 'v')]
verbose: bool,
#[arg(required = true, trailing_var_arg = true, allow_hyphen_values = true)]
args: Vec<String>,
}
#[derive(Args)]
struct NetworkArgs {
#[arg(long, short = 't')]
target: Option<String>,
#[arg(long)]
artifact: Option<PathBuf>,
#[arg(long, short = 'n')]
network: Option<String>,
#[arg(long)]
endpoint: Option<String>,
#[arg(long)]
broadcast: bool,
#[arg(long)]
private_key_env: Option<String>,
#[arg(long)]
save: Option<PathBuf>,
}
#[derive(Args)]
struct ExecuteArgs {
#[command(flatten)]
network: NetworkArgs,
#[arg(required = true, trailing_var_arg = true, allow_hyphen_values = true)]
args: Vec<String>,
}
fn main() {
let cli = Cli::parse();
let json = cli.json;
let command_name = command_name(&cli.command);
if let Err(error) = dispatch(cli) {
if json {
result_json::print_err(command_name, &error);
} else {
eprintln!("error: {error}");
}
std::process::exit(if error.exit_code() == std::process::ExitCode::from(2) {
2
} else {
1
});
}
}
fn command_name(command: &Commands) -> &'static str {
match command {
Commands::New { .. } => "new",
Commands::Setup { .. } => "setup",
Commands::Doctor { .. } => "doctor",
Commands::Build(_) => "build",
Commands::Clean => "clean",
Commands::Check(_) => "check",
Commands::Inspect { .. } => "inspect",
Commands::Verify { .. } => "verify",
Commands::Test { .. } => "test",
Commands::Run(_) | Commands::Local { .. } => "run",
Commands::Deploy(_) => "deploy",
Commands::Execute(_) => "execute",
Commands::Version => "version",
Commands::ListTargets => "list-targets",
}
}
fn dispatch(cli: Cli) -> PfResult<()> {
let json = cli.json;
match cli.command {
Commands::New { name, target, path } => {
cmd::new::run(&name, Some(&target), path.as_ref(), json)
}
Commands::Setup { target } => {
let t = target.unwrap_or_else(|| project::DEFAULT_TARGET.into());
cmd::doctor::setup(&t, cli.yes, json)
}
Commands::Doctor { target } => {
let targets = if target.is_empty() {
vec![project::DEFAULT_TARGET.to_string()]
} else {
target
};
cmd::doctor::run(&targets, json)
}
Commands::Build(a) => cmd::build::run(cmd::build::BuildOpts {
source: a.source.as_deref(),
module: a.module.as_deref(),
target: a.target.as_deref(),
root: a.root.as_deref(),
output: a.output.as_deref(),
profile: a.profile.as_deref(),
json,
}),
Commands::Clean => cmd::clean::run(json),
Commands::Check(a) => cmd::check::run(
a.source.as_deref(),
a.module.as_deref(),
a.root.as_deref(),
json,
),
Commands::Inspect { artifact, target } => {
cmd::inspect::run(artifact.as_deref(), target.as_deref(), json)
}
Commands::Verify {
target,
artifact,
adapter,
} => cmd::verify::run(
target.as_deref(),
artifact.as_deref(),
adapter.as_deref(),
json,
),
Commands::Test { target, artifact } => {
cmd::test::run(target.as_deref(), artifact.as_deref(), json)
}
Commands::Run(a) => cmd::local_run::run(
a.target.as_deref(),
a.artifact.as_deref(),
&a.args,
json,
a.verbose,
),
Commands::Local {
command: LocalCommands::Run(a),
} => cmd::local_run::run(
a.target.as_deref(),
a.artifact.as_deref(),
&a.args,
json,
a.verbose,
),
Commands::Deploy(a) => cmd::deploy::run(
a.target.as_deref(),
a.artifact.as_deref(),
a.network.as_deref(),
a.endpoint.as_deref(),
a.broadcast,
a.private_key_env.as_deref(),
a.save.as_deref(),
json,
),
Commands::Execute(a) => cmd::execute::run(
a.network.target.as_deref(),
a.network.artifact.as_deref(),
a.network.network.as_deref(),
a.network.endpoint.as_deref(),
a.network.broadcast,
a.network.private_key_env.as_deref(),
a.network.save.as_deref(),
&a.args,
json,
),
Commands::Version => cmd::version::run(json),
Commands::ListTargets => cmd::list_targets::run(json),
}
}