//! Command-line interface for the makima CLI.
pub mod config;
pub mod contract;
pub mod daemon;
pub mod red_team;
pub mod server;
pub mod supervisor;
pub mod view;
use clap::{Args, Parser, Subcommand};
use uuid::Uuid;
pub use config::CliConfig;
pub use contract::ContractArgs;
pub use contract::{PauseArgs, ResumeArgs, AdvanceArgs, RestartSupervisorArgs, ShowArgs, HealthArgs};
pub use daemon::DaemonArgs;
pub use red_team::handle_notify;
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),
/// 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),
/// Red team commands for adversarial monitoring
#[command(name = "red-team", subcommand)]
RedTeam(RedTeamCommand),
/// Contract management helper commands
///
/// User-facing commands for managing contracts (pause, resume, show, etc.)
#[command(subcommand)]
Contracts(ContractsCommand),
}
/// 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),
}
/// Red team subcommands for adversarial monitoring.
#[derive(Subcommand, Debug)]
pub enum RedTeamCommand {
/// Send a notification to the supervisor about a detected issue.
/// Only available to red team tasks.
Notify(RedTeamNotifyArgs),
}
/// Contract management helper subcommands.
#[derive(Subcommand, Debug)]
pub enum ContractsCommand {
/// Pause a contract
///
/// Sets the contract status to paused, optionally with a reason.
/// The supervisor will be stopped and tasks will not be picked up.
Pause(contract::PauseArgs),
/// Resume a paused contract
///
/// Sets the contract status back to active and restarts the supervisor.
Resume(contract::ResumeArgs),
/// Manually advance a contract to a specific phase
///
/// Use --force to skip deliverable validation.
Advance(contract::AdvanceArgs),
/// Restart the supervisor for a contract
///
/// Useful when the supervisor is stuck or needs to be refreshed.
RestartSupervisor(contract::RestartSupervisorArgs),
/// Show detailed contract information
///
/// Use --verbose for all details including tasks and files.
Show(contract::ShowArgs),
/// Check contract and supervisor health
///
/// Returns health status including supervisor state, task counts, and staleness.
Health(contract::HealthArgs),
}
/// Arguments for red-team notify command.
#[derive(Args, Debug)]
pub struct RedTeamNotifyArgs {
/// API URL
#[arg(long, env = "MAKIMA_API_URL", default_value = "https://api.makima.jp")]
pub api_url: String,
/// API key for authentication
#[arg(long, env = "MAKIMA_API_KEY")]
pub api_key: String,
/// Current task ID (must be a red team task)
#[arg(long, env = "MAKIMA_TASK_ID")]
pub task_id: Uuid,
/// Contract ID
#[arg(long, env = "MAKIMA_CONTRACT_ID")]
pub contract_id: Uuid,
/// The notification message
#[arg(index = 1)]
pub message: String,
/// Severity level: low, medium, high, critical
#[arg(long, default_value = "medium")]
pub severity: String,
/// Related task ID (optional)
#[arg(long)]
pub task: Option<Uuid>,
/// Related file path (optional)
#[arg(long)]
pub file: Option<String>,
/// Additional context (optional)
#[arg(long)]
pub context: Option<String>,
}
impl Cli {
/// Parse command-line arguments
pub fn parse_args() -> Self {
Self::parse()
}
}
