path: root/makima/src/daemon/cli/mod.rs

//! Command-line interface for the makima CLI.

pub mod config;
pub mod contract;
pub mod daemon;
pub mod directive;
pub mod server;
pub mod supervisor;
pub mod view;

use clap::{Parser, Subcommand};

pub use config::CliConfig;
pub use contract::ContractArgs;
pub use daemon::DaemonArgs;
pub use directive::DirectiveArgs;
pub use server::ServerArgs;
pub use supervisor::SupervisorArgs;
pub use view::ViewArgs;

/// Makima - unified CLI for server, daemon, and task management.
#[derive(Parser, Debug)]
#[command(name = "makima")]
#[command(version, about = "Makima CLI - server, daemon, and task management", long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Subcommand, Debug)]
pub enum Commands {
    /// Run the makima server
    Server(ServerArgs),

    /// Run the daemon (connect to server, manage tasks)
    Daemon(DaemonArgs),

    /// Supervisor commands for contract orchestration
    #[command(subcommand)]
    Supervisor(SupervisorCommand),

    /// Contract commands for task-contract interaction
    #[command(subcommand)]
    Contract(ContractCommand),

    /// Directive commands for DAG-based project management
    #[command(subcommand)]
    Directive(DirectiveCommand),

    /// Interactive TUI browser for contracts and tasks
    ///
    /// Provides a drill-down interface for browsing contracts, viewing their
    /// tasks, and streaming real-time task output.
    ///
    /// Keyboard shortcuts:
    ///   ↑/k: Move up    ↓/j: Move down    Enter/l: Drill in
    ///   Esc/h: Go back  /: Search         q: Quit
    ///   e: Edit         d: Delete         c: cd to worktree
    ///   n: New contract
    View(ViewArgs),

    /// Configure CLI settings (API key, server URL)
    ///
    /// Saves configuration to ~/.makima/config.toml for use by CLI commands.
    #[command(subcommand)]
    Config(ConfigCommand),
}

/// Config subcommands for CLI configuration.
#[derive(Subcommand, Debug)]
pub enum ConfigCommand {
    /// Set the API key
    ///
    /// Saves the API key to ~/.makima/config.toml
    SetKey(config::SetKeyArgs),

    /// Set the API URL
    ///
    /// Saves the API URL to ~/.makima/config.toml
    SetUrl(config::SetUrlArgs),

    /// Show current configuration
    Show,

    /// Show the config file path
    Path,
}

/// Supervisor subcommands for contract orchestration.
#[derive(Subcommand, Debug)]
pub enum SupervisorCommand {
    /// List all tasks in the contract
    Tasks(SupervisorArgs),

    /// Get the task tree structure
    Tree(SupervisorArgs),

    /// Create and start a new task
    Spawn(supervisor::SpawnArgs),

    /// Wait for a task to complete
    Wait(supervisor::WaitArgs),

    /// Read a file from a task's worktree
    ReadFile(supervisor::ReadFileArgs),

    /// Create a git branch
    Branch(supervisor::BranchArgs),

    /// Merge a task's changes to a branch
    Merge(supervisor::MergeArgs),

    /// Create a pull request
    Pr(supervisor::PrArgs),

    /// View task diff
    Diff(supervisor::DiffArgs),

    /// Create a checkpoint
    Checkpoint(supervisor::CheckpointArgs),

    /// List checkpoints
    Checkpoints(SupervisorArgs),

    /// Get contract status
    Status(SupervisorArgs),

    /// Advance the contract to the next phase
    AdvancePhase(supervisor::AdvancePhaseArgs),

    /// Ask a question and wait for user feedback
    Ask(supervisor::AskArgs),

    /// Get individual task details
    Task(supervisor::GetTaskArgs),

    /// Get task output/claude log
    Output(supervisor::GetTaskOutputArgs),

    /// View task conversation history
    TaskHistory(supervisor::TaskHistoryArgs),

    /// List task checkpoints (with optional diff)
    TaskCheckpoints(supervisor::TaskCheckpointsArgs),

    /// Resume supervisor after interruption
    Resume(supervisor::ResumeArgs),

    /// Resume task from checkpoint
    TaskResumeFrom(supervisor::TaskResumeFromArgs),

    /// Rewind task code to checkpoint
    TaskRewind(supervisor::TaskRewindArgs),

    /// Fork task from historical point
    TaskFork(supervisor::TaskForkArgs),

    /// Rewind supervisor conversation
    RewindConversation(supervisor::ConversationRewindArgs),

    /// Mark the contract as complete and stop the supervisor
    Complete(supervisor::CompleteArgs),

    /// Resume a completed contract (reactivate it)
    ResumeContract(supervisor::ResumeContractArgs),

    /// Mark a deliverable as complete
    MarkDeliverable(supervisor::MarkDeliverableArgs),
}

/// Contract subcommands for task-contract interaction.
#[derive(Subcommand, Debug)]
pub enum ContractCommand {
    /// Get contract status
    Status(ContractArgs),

    /// Get the phase checklist
    Checklist(ContractArgs),

    /// Get contract goals
    Goals(ContractArgs),

    /// List contract files
    Files(ContractArgs),

    /// Get a specific file's content
    File(contract::FileArgs),

    /// Report progress on the contract
    Report(contract::ReportArgs),

    /// Get suggested next action
    SuggestAction(ContractArgs),

    /// Get completion recommendation
    CompletionAction(contract::CompletionActionArgs),

    /// Update a file (reads content from stdin)
    UpdateFile(contract::UpdateFileArgs),

    /// Create a new file (reads content from stdin)
    CreateFile(contract::CreateFileArgs),
}

/// Directive subcommands for DAG-based project management.
#[derive(Subcommand, Debug)]
pub enum DirectiveCommand {
    /// List all directives
    List(directive::DirectiveListArgs),

    /// Get directive status with steps
    Get(DirectiveArgs),

    /// Get directive status (alias for get)
    Status(DirectiveArgs),

    /// Add a step to the directive
    AddStep(directive::AddStepArgs),

    /// Remove a step from the directive
    RemoveStep(directive::RemoveStepArgs),

    /// Set dependencies for a step
    SetDeps(directive::SetDepsArgs),

    /// Start the directive (begin executing steps)
    Start(DirectiveArgs),

    /// Pause the directive
    Pause(DirectiveArgs),

    /// Advance the DAG (find newly-ready steps)
    Advance(DirectiveArgs),

    /// Mark a step as completed
    CompleteStep(directive::StepActionArgs),

    /// Mark a step as failed
    FailStep(directive::StepActionArgs),

    /// Mark a step as skipped
    SkipStep(directive::StepActionArgs),

    /// Update the directive's goal (triggers re-planning)
    UpdateGoal(directive::UpdateGoalArgs),

    /// Batch add multiple steps from JSON
    BatchAddSteps(directive::BatchAddStepsArgs),

    /// Update directive metadata (PR URL, etc.)
    Update(directive::UpdateArgs),

    /// Ask a question and wait for user feedback
    Ask(directive::AskArgs),

    /// Create an order for future work (spike or chore only)
    CreateOrder(directive::CreateOrderArgs),

    /// Verify the current worktree merges cleanly into the directive's base branch.
    ///
    /// Mandatory pre-flight before creating or pushing a directive PR — fails
    /// with a non-zero exit code (and a list of conflicting files) if the merge
    /// would conflict with the base branch.
    Verify(directive::VerifyArgs),
}

impl Cli {
    /// Parse command-line arguments
    pub fn parse_args() -> Self {
        Self::parse()
    }
}