use std::io;
use std::path::PathBuf;
use clap::{Args, CommandFactory, Parser, Subcommand};
use clap_complete::{Shell, generate};
use clap_mangen::Man;
use crate::adopt;
use crate::catalog;
use crate::doctor;
use crate::error::{DaloError, DaloResult};
use crate::instructions;
use crate::lockfile;
use crate::materialize;
use crate::resolver;
use crate::source;
use crate::status;
use crate::store;
use crate::target;
#[derive(Debug, Parser)]
#[command(name = "dalo")]
#[command(version, about = "Git-backed skill management for AI agents.")]
pub struct Cli {
#[arg(long, global = true, value_name = "PATH")]
pub store: Option<PathBuf>,
#[arg(long, global = true)]
pub json: bool,
#[arg(long, global = true)]
pub yes: bool,
#[arg(long, global = true)]
pub dry_run: bool,
#[command(subcommand)]
pub command: Option<Command>,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct GlobalOptions {
pub store: PathBuf,
pub json: bool,
pub yes: bool,
pub dry_run: bool,
}
impl GlobalOptions {
fn resolve(
store: Option<&std::path::Path>,
json: bool,
yes: bool,
dry_run: bool,
) -> DaloResult<Self> {
Ok(Self {
store: store::resolve_store_path(store)?,
json,
yes,
dry_run,
})
}
}
impl Cli {
#[must_use]
pub fn parse_args() -> Self {
Self::parse()
}
}
#[derive(Debug, Subcommand)]
pub enum Command {
Init,
Target(TargetCommand),
Source(SourceCommand),
Status,
Sync,
Adopt(AdoptCommand),
Resolve(ResolveCommand),
Doctor,
Instructions(InstructionsCommand),
#[command(hide = true)]
Completions(CompletionsCommand),
#[command(hide = true)]
Manpage,
}
#[derive(Debug, Args)]
pub struct CompletionsCommand {
pub shell: Shell,
}
#[derive(Debug, Args)]
pub struct InstructionsCommand {
#[command(subcommand)]
pub command: InstructionsSubcommand,
}
#[derive(Debug, Subcommand)]
pub enum InstructionsSubcommand {
Enable(InstructionsFileArgs),
Disable(InstructionsFileArgs),
List,
}
#[derive(Debug, Args)]
pub struct InstructionsFileArgs {
pub pack: String,
pub file: PathBuf,
}
#[derive(Debug, Args)]
pub struct TargetCommand {
#[command(subcommand)]
pub command: TargetSubcommand,
}
#[derive(Debug, Subcommand)]
pub enum TargetSubcommand {
Detect,
Link(TargetLinkArgs),
Unlink(TargetIdArg),
}
#[derive(Debug, Args)]
pub struct TargetLinkArgs {
pub target: String,
pub path: Option<PathBuf>,
}
#[derive(Debug, Args)]
pub struct TargetIdArg {
pub target: String,
}
#[derive(Debug, Args)]
pub struct SourceCommand {
#[command(subcommand)]
pub command: SourceSubcommand,
}
#[derive(Debug, Subcommand)]
pub enum SourceSubcommand {
Add(SourceAddArgs),
AddCatalog(SourceAddArgs),
List,
Priority(SourcePriorityArgs),
Inspect(SourceInspectArgs),
Select(SourceSelectArgs),
Refresh(SourceRefreshArgs),
}
#[derive(Debug, Args)]
pub struct SourceAddArgs {
pub id: String,
pub location: String,
}
#[derive(Debug, Args)]
pub struct SourcePriorityArgs {
pub id: String,
pub priority: i32,
}
#[derive(Debug, Args)]
pub struct SourceInspectArgs {
pub id: String,
}
#[derive(Debug, Args)]
pub struct SourceSelectArgs {
pub id: String,
#[arg(required = true)]
pub skills: Vec<String>,
#[arg(long)]
pub unselect: bool,
}
#[derive(Debug, Args)]
pub struct SourceRefreshArgs {
pub id: String,
#[arg(long)]
pub check: bool,
}
#[derive(Debug, Args)]
pub struct AdoptCommand {
pub skill: String,
#[arg(long)]
pub replace: bool,
}
#[derive(Debug, Args)]
pub struct ResolveCommand {
#[command(subcommand)]
pub command: ResolveSubcommand,
}
#[derive(Debug, Subcommand)]
pub enum ResolveSubcommand {
List,
Adopt(ResolveAdoptArgs),
Keep(ResolveIdArg),
RemoveOwned(ResolveIdArg),
}
#[derive(Debug, Args)]
pub struct ResolveAdoptArgs {
pub id: String,
#[arg(long)]
pub replace: bool,
}
#[derive(Debug, Args)]
pub struct ResolveIdArg {
pub id: String,
}
pub fn run_cli(cli: Cli) -> DaloResult<()> {
let Cli {
store,
json,
yes,
dry_run,
command,
} = cli;
let Some(command) = command else {
Cli::command().print_help()?;
println!();
return Ok(());
};
match command {
Command::Completions(command) => return run_completions(command),
Command::Manpage => return run_manpage(),
_ => {}
}
let options = GlobalOptions::resolve(store.as_deref(), json, yes, dry_run)?;
match command {
Command::Init => run_init(&options),
Command::Target(command) => run_target(&options, command),
Command::Source(command) => run_source(&options, command),
Command::Status => run_status(&options),
Command::Sync => run_sync(&options),
Command::Adopt(command) => run_adopt(&options, command),
Command::Resolve(command) => run_resolve(&options, command),
Command::Doctor => run_doctor(&options),
Command::Instructions(command) => run_instructions(&options, command),
Command::Completions(_) | Command::Manpage => {
unreachable!("handled before store resolution")
}
}
}
fn run_completions(command: CompletionsCommand) -> DaloResult<()> {
let mut clap_command = Cli::command();
generate(command.shell, &mut clap_command, "dalo", &mut io::stdout());
Ok(())
}
fn run_manpage() -> DaloResult<()> {
let mut buffer = Vec::new();
Man::new(Cli::command()).render(&mut buffer)?;
io::copy(&mut buffer.as_slice(), &mut io::stdout())?;
Ok(())
}
fn run_instructions(options: &GlobalOptions, command: InstructionsCommand) -> DaloResult<()> {
let paths = store::StorePaths::new(options.store.clone());
match command.command {
InstructionsSubcommand::Enable(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report =
instructions::enable_pack(&paths, &args.pack, &args.file, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_instruction_pack_report(&report);
}
Ok(())
}
InstructionsSubcommand::Disable(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report =
instructions::disable_pack(&paths, &args.pack, &args.file, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_instruction_pack_report(&report);
}
Ok(())
}
InstructionsSubcommand::List => {
let lock = store::read_user_lock(&paths)?;
if options.json {
print_json(&lock.active_instruction_packs)?;
} else if lock.active_instruction_packs.is_empty() {
println!("no active instruction packs");
} else {
for pack in &lock.active_instruction_packs {
println!("{} -> {}", pack.pack_id, pack.target.display());
}
}
Ok(())
}
}
}
fn run_init(options: &GlobalOptions) -> DaloResult<()> {
let report = store::init_store(options.store.clone(), options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_init_report(&report);
}
Ok(())
}
fn run_status(options: &GlobalOptions) -> DaloResult<()> {
let report = status::build_status_report(&options.store)?;
if options.json {
print_json(&report)?;
} else {
status::print_status_report(&report);
}
Ok(())
}
fn run_sync(options: &GlobalOptions) -> DaloResult<()> {
let paths = store::StorePaths::new(options.store.clone());
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let config = store::read_config(&paths)?;
if !options.dry_run {
source::refresh_tracking_team_sources_from_config(&config)?;
}
let approvals = store::read_approvals(&paths)?;
let live = resolver::resolve_from_config(&config, approvals.approvals);
let degraded_sources = live
.scans
.iter()
.filter(|scan| scan.error.is_some())
.map(|scan| materialize::DegradedSource {
id: scan.source.id.clone(),
path: scan.source.path.clone(),
})
.collect::<Vec<_>>();
let report = materialize::materialize_with_degraded_sources(
&paths,
&live.resolution,
options.dry_run,
°raded_sources,
)?;
if !options.dry_run {
let previous =
store::read_user_lock(&paths).unwrap_or_else(|_| lockfile::UserLock::empty());
let mut lock = lockfile::build_user_lock(&config.sources, &live.resolution, Some(&report));
lock.active_instruction_packs = previous.active_instruction_packs;
store::write_user_lock(&paths, &lock)?;
}
if options.json {
print_json(&report)?;
} else {
status::print_sync_report(&report);
}
Ok(())
}
fn run_source(options: &GlobalOptions, command: SourceCommand) -> DaloResult<()> {
let paths = store::StorePaths::new(options.store.clone());
match command.command {
SourceSubcommand::Add(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report =
source::add_team_source(&paths, &args.id, &args.location, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_source_add_report(&report);
}
Ok(())
}
SourceSubcommand::AddCatalog(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let source =
catalog::add_catalog_source(&paths, &args.id, &args.location, options.dry_run)?;
if options.json {
print_json(&source)?;
} else {
status::print_catalog_add_report(&source, options.dry_run);
}
Ok(())
}
SourceSubcommand::List => {
let report = source::list_sources(&paths)?;
if options.json {
print_json(&report)?;
} else {
status::print_source_list_report(&report);
}
Ok(())
}
SourceSubcommand::Inspect(args) => {
let report = catalog::inspect_catalog(&paths, &args.id)?;
if options.json {
print_json(&report)?;
} else {
status::print_catalog_inspect_report(&report);
}
Ok(())
}
SourceSubcommand::Select(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = catalog::select_skills(
&paths,
&args.id,
&args.skills,
args.unselect,
options.dry_run,
)?;
if options.json {
print_json(&report)?;
} else {
status::print_catalog_select_report(&report);
}
Ok(())
}
SourceSubcommand::Refresh(args) => {
if !args.check {
return Err(DaloError::NotImplemented {
command: "source refresh (advancing the pin)".to_owned(),
});
}
let _lock = store::StoreLock::acquire(&paths)?;
let report = catalog::check_catalog_drift(&paths, &args.id)?;
if options.json {
print_json(&report)?;
} else {
status::print_catalog_drift_report(&report);
}
Ok(())
}
SourceSubcommand::Priority(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report =
source::set_source_priority(&paths, &args.id, args.priority, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_source_priority_report(&report);
}
Ok(())
}
}
}
fn run_adopt(options: &GlobalOptions, command: AdoptCommand) -> DaloResult<()> {
let paths = store::StorePaths::new(options.store.clone());
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = adopt::adopt_skill(&paths, &command.skill, command.replace, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_adopt_report(&report);
}
Ok(())
}
fn run_resolve(options: &GlobalOptions, command: ResolveCommand) -> DaloResult<()> {
let paths = store::StorePaths::new(options.store.clone());
match command.command {
ResolveSubcommand::List => {
let report = adopt::list_resolve_items(&paths)?;
if options.json {
print_json(&report)?;
} else {
status::print_resolve_list_report(&report);
}
Ok(())
}
ResolveSubcommand::Adopt(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = adopt::adopt_skill(&paths, &args.id, args.replace, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_adopt_report(&report);
}
Ok(())
}
ResolveSubcommand::Keep(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = adopt::keep_unmanaged_skill(&paths, &args.id, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_keep_report(&report);
}
Ok(())
}
ResolveSubcommand::RemoveOwned(args) => {
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = adopt::remove_owned_skill(&paths, &args.id, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_remove_owned_report(&report);
}
Ok(())
}
}
}
fn run_doctor(options: &GlobalOptions) -> DaloResult<()> {
let report = doctor::run_doctor(&options.store);
if options.json {
print_json(&report)?;
} else {
status::print_doctor_report(&report);
}
Ok(())
}
fn run_target(options: &GlobalOptions, command: TargetCommand) -> DaloResult<()> {
match command.command {
TargetSubcommand::Detect => {
let report = target::detect_targets(&options.store)?;
if options.json {
print_json(&report)?;
} else {
status::print_target_detect_report(&report);
}
Ok(())
}
TargetSubcommand::Link(args) => {
let paths = store::StorePaths::new(options.store.clone());
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = target::link_target(
&options.store,
&args.target,
args.path.as_deref(),
options.dry_run,
)?;
if options.json {
print_json(&report)?;
} else {
status::print_target_link_report(&report);
}
Ok(())
}
TargetSubcommand::Unlink(args) => {
let paths = store::StorePaths::new(options.store.clone());
let _lock = if options.dry_run {
None
} else {
Some(store::StoreLock::acquire(&paths)?)
};
let report = target::unlink_target(&options.store, &args.target, options.dry_run)?;
if options.json {
print_json(&report)?;
} else {
status::print_target_unlink_report(&report);
}
Ok(())
}
}
}
fn print_json<T>(value: &T) -> DaloResult<()>
where
T: serde::Serialize,
{
serde_json::to_writer_pretty(std::io::stdout(), value)?;
println!();
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn run_cli_should_succeed_when_no_command_is_provided() {
let cli = Cli {
store: None,
json: false,
yes: false,
dry_run: false,
command: None,
};
assert!(run_cli(cli).is_ok());
}
}