agentlink-cli 0.0.1

One brain for every AI coding agent — shared rules and skills with zero file duplication
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! `agentlink` — one brain for every AI coding agent.

#![forbid(unsafe_code)]

mod app;
mod commands;
mod render;
mod ui;

use std::path::PathBuf;

use clap::{Parser, Subcommand};

use crate::ui::{ColorChoice, Ui};

/// Give every AI coding agent in a repository the same rules and skills, without
/// copying a single file.
#[derive(Debug, Parser)]
#[command(
    name = "agentlink",
    version,
    about,
    long_about = None,
    after_help = "Learn more: https://github.com/fialhosoft/agentlink"
)]
struct Cli {
    /// Operate on this directory instead of the current one.
    #[arg(short = 'C', long = "dir", global = true, value_name = "PATH")]
    dir: Option<PathBuf>,

    /// When to colourise output.
    #[arg(long, global = true, value_enum, default_value_t = ColorChoice::Auto)]
    color: ColorChoice,

    /// Suppress informational output.
    #[arg(short, long, global = true)]
    quiet: bool,

    #[command(subcommand)]
    command: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Create the canonical layout and link every agent to it.
    Init,

    /// Materialise anything that is missing or out of date.
    #[command(alias = "sync")]
    Apply {
        /// Show what would happen without writing anything.
        #[arg(long)]
        dry_run: bool,

        /// Also move agent-owned content into the canonical layout.
        #[arg(long)]
        adopt: bool,
    },

    /// Show what `apply` would do.
    Status {
        /// Exit with code 2 if anything is pending or blocked. For CI.
        #[arg(long)]
        check: bool,
    },

    /// Move content from an agent's directory into the canonical layout, then
    /// link it back so that agent keeps reading its usual path.
    Adopt {
        /// Show what would move without writing anything.
        #[arg(long)]
        dry_run: bool,
    },

    /// Check the environment and report anything that needs attention.
    Doctor,

    /// List every known agent and how each one is served.
    Providers,

    /// Remove everything agentlink created, leaving the canonical layout intact.
    Clean {
        /// Show what would be removed without writing anything.
        #[arg(long)]
        dry_run: bool,
    },
}

fn main() -> std::process::ExitCode {
    let cli = Cli::parse();
    let ui = Ui::new(cli.color, cli.quiet);

    let result = match cli.command {
        Command::Init => commands::init(ui, cli.dir),
        Command::Apply { dry_run, adopt } => commands::apply(ui, cli.dir, dry_run, adopt),
        Command::Status { check } => commands::status(ui, cli.dir, check),
        Command::Adopt { dry_run } => commands::adopt(ui, cli.dir, dry_run),
        Command::Doctor => commands::doctor(ui, cli.dir),
        Command::Providers => commands::providers(ui, cli.dir),
        Command::Clean { dry_run } => commands::clean(ui, cli.dir, dry_run),
    };

    match result {
        Ok(code) => std::process::ExitCode::from(u8::try_from(code).unwrap_or(1)),
        Err(err) => {
            eprintln!("{} {err}", ui.red("error:"));
            for cause in err.chain().skip(1) {
                eprintln!("       {}", ui.dim(&cause.to_string()));
            }
            std::process::ExitCode::FAILURE
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use clap::CommandFactory;

    #[test]
    fn cli_definition_is_valid() {
        Cli::command().debug_assert();
    }
}