netsky 0.1.6

//! clap command tree for the `netsky` binary.

use clap::{Parser, Subcommand, ValueEnum};

use crate::cmd;
use netsky_io::IoCommand;

#[derive(Parser, Debug)]
#[command(name = "netsky", version, about = "Netsky launcher")]
pub struct Cli {
    #[command(subcommand)]
    pub command: Option<Command>,
}

#[derive(Subcommand, Debug)]
pub enum Command {
    /// Start the constellation.
    Up {
        /// Number of clones to start.
        #[arg(default_value_t = netsky_core::consts::DEFAULT_CLONE_COUNT)]
        n: u32,
        /// Runtime flavor for the constellation.
        #[arg(long = "type", value_enum, default_value_t = AgentType::Codex)]
        agent_type: AgentType,
    },
    /// Stop the constellation.
    Down,
    /// Restart the constellation.
    Restart {
        /// Number of clones to start.
        #[arg(default_value_t = netsky_core::consts::DEFAULT_CLONE_COUNT)]
        n: u32,
        /// Handoff file for the new agent0.
        #[arg(long)]
        handoff: Option<String>,
    },
    /// Run one agent.
    Agent {
        #[arg(value_name = "N")]
        n: u32,
        /// Runtime type for this agent.
        #[arg(long = "type", value_enum, default_value_t = AgentType::Codex)]
        agent_type: AgentType,
        /// Start from a clean session.
        #[arg(long)]
        fresh: bool,
    },
    /// Run one Codex turn.
    Codex {
        #[arg(value_name = "N")]
        n: u32,
        /// Start from a clean sidecar session.
        #[arg(long)]
        fresh: bool,
        /// Send a direct prompt.
        #[arg(long)]
        prompt: Option<String>,
        /// Drain one inbox envelope.
        #[arg(long)]
        drain: bool,
        /// Override the Codex model.
        #[arg(long)]
        model: Option<String>,
    },
    /// Attach to a tmux session.
    #[command(alias = "a")]
    Attach {
        #[arg(value_name = "TARGET")]
        target: String,
    },
    /// Start the watchdog.
    Agentinfinity,
    /// Run the agentinit gate.
    Agentinit {
        /// Target tmux session name.
        #[arg(default_value = netsky_core::consts::AGENTINFINITY_NAME)]
        session: String,
    },
    /// Run one watchdog tick.
    #[command(subcommand)]
    Watchdog(WatchdogCommand),
    /// Manage status ticks.
    #[command(subcommand)]
    Tick(TickCommand),
    /// Manage launchd plists.
    #[command(subcommand)]
    Launchd(LaunchdCommand),
    /// Inspect handoffs.
    Handoffs {
        #[arg(value_name = "WHICH", default_value = "list")]
        which: String,
        /// Max entries in list mode.
        #[arg(short = 'n', long, default_value_t = 50)]
        limit: usize,
    },
    /// Send an escalation.
    Escalate {
        /// Subject line.
        subject: String,
        /// Optional body text.
        body: Option<String>,
    },
    /// Bootstrap ~/netsky from embedded files.
    Init {
        /// Refresh skills and prompts from the binary.
        #[arg(long)]
        update: bool,
        /// Target directory.
        #[arg(long, value_name = "DIR")]
        path: Option<std::path::PathBuf>,
    },
    /// Print system status.
    Status,
    /// Query the pure Rust HTAP observability store with DataFusion SQL.
    Query {
        #[arg(value_name = "SQL")]
        sql: String,
    },
    /// Run a health check.
    Doctor {
        /// Print brief status.
        #[arg(long)]
        brief: bool,
        /// Suppress non-essential output.
        #[arg(long)]
        quiet: bool,
    },
    /// Print the morning summary.
    Morning {
        /// Include a send-requested note.
        #[arg(long)]
        send: bool,
    },
    /// Arm a quiet sentinel.
    Quiet {
        /// Quiet window in seconds.
        #[arg(value_name = "SECONDS")]
        seconds: u64,
        /// Optional reason text.
        #[arg(long)]
        reason: Option<String>,
    },
    /// Prepare a quiet sentinel before a long ScheduleWakeup nap.
    Nap {
        /// Nap window in seconds.
        #[arg(value_name = "SECONDS")]
        seconds: u64,
        /// Optional reason text.
        #[arg(long)]
        reason: Option<String>,
    },
    /// Run a resilience drill.
    Drill {
        #[arg(value_name = "N")]
        n: u8,
    },
    /// Run netsky tests.
    Test {
        /// Test suite to run.
        #[arg(default_value = "all")]
        suite: String,
    },
    /// Configure channel sources.
    #[command(subcommand)]
    Setup(SetupCommand),
    /// Manage the pre-push hook.
    #[command(subcommand)]
    Hooks(HooksCommand),
    /// Manage agent envelopes.
    #[command(subcommand)]
    Channel(ChannelCommand),
    /// Run the I/O stack.
    #[command(subcommand)]
    Io(IoCommand),
}

#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
pub enum AgentType {
    Claude,
    Codex,
}

#[derive(Subcommand, Debug)]
pub enum WatchdogCommand {
    /// Run one watchdog tick.
    Tick,
}

#[derive(Subcommand, Debug)]
pub enum TickCommand {
    /// Enable status ticks.
    Enable {
        #[arg(value_name = "SECONDS")]
        seconds: u64,
    },
    /// Disable status ticks.
    Disable,
    /// Request one status tick.
    Request,
    /// Run the ticker loop.
    Ticker,
    /// Start the ticker session.
    TickerStart,
}

#[derive(Subcommand, Debug)]
pub enum LaunchdCommand {
    /// Install launchd plists.
    Install,
    /// Remove launchd plists.
    Uninstall,
    /// Print launchd status.
    Status,
    /// Reinstall launchd plists.
    Reinstall,
}

#[derive(Subcommand, Debug)]
pub enum SetupCommand {
    /// Set up Gmail OAuth.
    Email {
        /// Primary account address.
        account: Option<String>,
    },
}

#[derive(Subcommand, Debug)]
pub enum ChannelCommand {
    /// Drain an agent inbox.
    Drain {
        /// Agent name.
        #[arg(value_name = "AGENT")]
        agent: String,
    },
    /// Send one agent envelope.
    Send {
        #[arg(value_name = "TARGET")]
        target: String,
        #[arg(value_name = "TEXT")]
        text: String,
        /// Sender identity.
        #[arg(long)]
        from: Option<String>,
    },
    /// Inspect quarantined envelopes.
    Quarantine {
        /// Agent name.
        #[arg(value_name = "AGENT")]
        agent: String,
        /// List quarantined paths.
        #[arg(long)]
        list: bool,
    },
}

#[derive(Subcommand, Debug)]
pub enum HooksCommand {
    /// Install the pre-push hook.
    Install {
        /// Overwrite a drifted hook.
        #[arg(long)]
        force: bool,
    },
    /// Remove the pre-push hook.
    Uninstall,
    /// Print hook status.
    Status,
}

pub fn dispatch(cli: Cli) -> netsky_core::Result<()> {
    // Hard-exit gate for user-invoked constellation orchestration. Only
    // applies to commands that orchestrate agents directly; read-only,
    // launchd-spawned, and config-editing commands stay permissive so
    // they keep working from anywhere (which is critical for `doctor`
    // and `escalate` invoked under the watchdog tick from cwd `/`).
    if let Some(name) = command_requires_netsky_cwd(&cli.command) {
        netsky_core::paths::require_netsky_cwd(name)?;
    }
    match cli.command {
        None => {
            // Bare `netsky` = help.
            use clap::CommandFactory;
            Cli::command().print_help()?;
            println!();
            Ok(())
        }
        Some(Command::Up { n, agent_type }) => cmd::up::run(n, agent_type),
        Some(Command::Down) => cmd::down::run(),
        Some(Command::Restart { n, handoff }) => cmd::restart::run(n, handoff.as_deref()),
        Some(Command::Agent {
            n,
            agent_type,
            fresh,
        }) => {
            if n == 0 {
                cmd::agent::run(n, fresh)
            } else {
                match agent_type {
                    AgentType::Claude => cmd::agent::run(n, fresh),
                    AgentType::Codex => cmd::agent::run_codex_resident(n, fresh),
                }
            }
        }
        Some(Command::Codex {
            n,
            fresh,
            prompt,
            drain,
            model,
        }) => cmd::codex_agent::run(n, prompt.as_deref(), drain, model.as_deref(), fresh),
        Some(Command::Attach { target }) => cmd::attach::run(&target),
        Some(Command::Agentinfinity) => cmd::agentinfinity::run(),
        Some(Command::Agentinit { session }) => cmd::agentinit::run(&session),
        Some(Command::Watchdog(WatchdogCommand::Tick)) => cmd::watchdog::tick(),
        Some(Command::Tick(sub)) => cmd::tick::run(sub),
        Some(Command::Launchd(sub)) => cmd::launchd::run(sub),
        Some(Command::Handoffs { which, limit }) => cmd::handoffs::run(&which, limit),
        Some(Command::Escalate { subject, body }) => cmd::escalate::run(&subject, body.as_deref()),
        Some(Command::Init { update, path }) => cmd::init::run(path, update),
        Some(Command::Status) => cmd::status::run(),
        Some(Command::Query { sql }) => cmd::query::run(&sql),
        Some(Command::Doctor { brief, quiet }) => cmd::doctor::run(brief, quiet),
        Some(Command::Morning { send }) => cmd::morning::run(send),
        Some(Command::Quiet { seconds, reason }) => cmd::quiet::run(seconds, reason.as_deref()),
        Some(Command::Nap { seconds, reason }) => cmd::nap::run(seconds, reason.as_deref()),
        Some(Command::Drill { n }) => cmd::drill::run(n),
        Some(Command::Test { suite }) => cmd::test::run(&suite),
        Some(Command::Setup(sub)) => cmd::setup::run(sub),
        Some(Command::Hooks(sub)) => cmd::hooks::run(sub),
        Some(Command::Channel(sub)) => cmd::channel::run(sub),
        Some(Command::Io(sub)) => cmd::io::run(sub),
    }
}

/// Returns the command name (for the error message) when the command
/// orchestrates the constellation directly and must run from inside a
/// netsky checkout. Returns None for read-only, launchd-spawned, or
/// config-editing commands.
///
/// Gated set is deliberately narrow:
/// - `up` / `down` / `restart`: spawn or tear down agent tmux sessions
///   that read repo files (skills, prompts, mcp config).
/// - `agent`: spawns a single agent the same way.
/// - `drill`: runs scripted constellation flows that exercise the same paths.
///
/// Not gated:
/// - `watchdog` / `agentinit`: launchd-spawned with cwd `/`. Resilience
///   primitives that must work regardless of cwd. Plist
///   `WorkingDirectory` will pin them to NETSKY_DIR in a follow-up.
/// - `escalate`: the failsafe owner-page path; runs under launchd ticks.
/// - `doctor` / `morning` / `handoffs` / `attach` / `launchd status` /
///   `hooks status`: read-only diagnostics, must work from anywhere so
///   the operator can investigate a misconfigured machine.
/// - `setup` / `hooks install|uninstall` / `launchd install|uninstall|reinstall` /
///   `tick *` / `agentinfinity` / `test`: edit user config or run
///   subprocesses; deferred to follow-up alongside per-command audits.
fn command_requires_netsky_cwd(cmd: &Option<Command>) -> Option<&'static str> {
    match cmd {
        Some(Command::Up { .. }) => Some("up"),
        Some(Command::Down) => Some("down"),
        Some(Command::Restart { .. }) => Some("restart"),
        Some(Command::Agent { .. }) => Some("agent"),
        Some(Command::Codex { .. }) => Some("codex"),
        Some(Command::Drill { .. }) => Some("drill"),
        _ => None,
    }
}

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

    #[test]
    fn gated_commands_return_their_name() {
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Up {
                n: 0,
                agent_type: AgentType::Claude,
            })),
            Some("up")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Down)),
            Some("down")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Restart {
                n: 0,
                handoff: None,
            })),
            Some("restart")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Agent {
                n: 1,
                agent_type: AgentType::Claude,
                fresh: false,
            })),
            Some("agent")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Agent {
                n: 1,
                agent_type: AgentType::Codex,
                fresh: false,
            })),
            Some("agent")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Codex {
                n: 1,
                fresh: false,
                prompt: None,
                drain: true,
                model: None,
            })),
            Some("codex")
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Drill { n: 1 })),
            Some("drill")
        );
    }

    #[test]
    fn ungated_commands_pass() {
        // Bare netsky (no subcommand) is the help path; never gated.
        assert_eq!(command_requires_netsky_cwd(&None), None);
        // Read-only diagnostics.
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Doctor {
                brief: false,
                quiet: true,
            })),
            None
        );
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Morning { send: false })),
            None
        );
        // Watchdog runs under launchd from cwd `/`; never gated.
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Watchdog(WatchdogCommand::Tick))),
            None
        );
        // Escalate is the failsafe page; runs under launchd ticks.
        assert_eq!(
            command_requires_netsky_cwd(&Some(Command::Escalate {
                subject: "x".into(),
                body: None,
            })),
            None
        );
    }
}