cellstate/

main.rs

//! CELLSTATE CLI — Universal installer and local development tool.
//!
//! Install:
//!   curl -fsSL https://cellstate.batterypack.dev/install | sh
//!
//! Commands:
//!   cellstate setup      <- Interactive first-run installer (detect env, install SDKs)
//!   cellstate init       <- Scaffold .cellstate/ config in current project
//!   cellstate start      <- Start local CELLSTATE server (Docker)
//!   cellstate stop       <- Stop local CELLSTATE server
//!   cellstate inspect    <- View live memory state
//!   cellstate use        <- Set or display session scope
//!   cellstate status     <- Show session state and server connectivity
//!   cellstate trajectory <- Manage trajectories
//!   cellstate agent      <- Manage agents
//!   cellstate note       <- Manage notes
//!   cellstate context    <- Context commit and recall

mod commands;
pub(crate) mod entity;
pub(crate) mod http;
pub(crate) mod session;
mod ui;

use clap::{CommandFactory, FromArgMatches, Parser, Subcommand};

// ============================================================================
// CLI definition (derive-based infra commands)
// ============================================================================

#[derive(Parser)]
#[command(
    name = "cellstate",
    about = "Agent memory that doesn't forget, lie, or black-box you.",
    long_about = None,
    version,
    propagate_version = true,
)]
struct Cli {
    /// Output as JSON (for agent/script consumption)
    #[arg(long, global = true)]
    json: bool,

    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    /// Interactive first-run setup: detect environment, install SDKs, start server.
    ///
    /// Run this first. It detects Python, Node, Rust, and Docker,
    /// asks what you're building with, installs only what you need,
    /// and optionally starts a local CELLSTATE server.
    Setup,

    /// Scaffold a CELLSTATE project in the current directory.
    ///
    /// Creates .cellstate/config.toml, .env.example, and cellstate.lock.
    Init,

    /// Start the local CELLSTATE server (PostgreSQL + API) via Docker.
    ///
    /// Equivalent to docker compose up with a minimal production-like stack.
    /// Runs in the background. Use `cellstate stop` to shut down.
    Start,

    /// Stop the local CELLSTATE server.
    Stop,

    /// View live memory state from a running CELLSTATE instance.
    ///
    /// Polls the API and displays active memories with Blake3 receipts.
    /// For streaming TUI: see `cellstate watch` (coming soon).
    Inspect(commands::inspect::InspectArgs),

    /// Pack compilation and AAIF convergence output commands.
    ///
    /// Compile a CELLSTATE pack and emit convergence outputs: AGENTS.md,
    /// llms.txt, A2A Agent Card, SKILL.md, A2UI schema.
    Pack(commands::pack::PackArgs),

    /// Set or display session scope (tenant, agent, trajectory, scope).
    ///
    /// Persists scope selections so they don't need to be passed as flags
    /// on every command. Use `cellstate use tenant <uuid>` to set scope,
    /// `cellstate use --clear` to reset, or `cellstate use` to display.
    #[command(name = "use")]
    Use(commands::use_cmd::UseArgs),

    /// Show session state and server connectivity.
    ///
    /// Displays current scope, server health, version, and auth status.
    Status,
}

// ============================================================================
// Known entity command names (Phase 3 pilot)
// ============================================================================

/// Entity command names that are handled by the builder-API entity module.
const ENTITY_COMMANDS: &[&str] = &[
    "trajectory",
    "agent",
    "scope",
    "artifact",
    "note",
    "turn",
    "context",
    "lock",
    "message",
    "delegation",
    "handoff",
    "edge",
    "team",
    "tenant",
    "api-key",
    "event-dag",
    "search",
    "batch",
    "summarization-policy",
    "summarization-request",
    "deployment",
    "working-set",
    "config",
    "gates",
    "models",
];

fn is_entity_command(name: &str) -> bool {
    ENTITY_COMMANDS.contains(&name)
}

// ============================================================================
// Entry point
// ============================================================================

#[tokio::main]
async fn main() {
    // Build the full command tree: derive commands + builder entity commands.
    // This lets `cellstate --help` show both infra and entity commands.
    let mut app = Cli::command();
    for cmd in entity::build_entity_commands() {
        app = app.subcommand(cmd);
    }
    let mut matches = app.get_matches();

    // Extract global --json flag before dispatching
    let json = matches.get_flag("json");

    // Try derive-based infra commands first.
    // from_arg_matches may fail if the subcommand is a builder entity command,
    // which is expected — we fall through to entity dispatch.
    if let Ok(cli) = Cli::from_arg_matches_mut(&mut matches) {
        // Infra commands are sync and some use reqwest::blocking::Client which
        // creates its own tokio runtime. We must run them on a blocking thread
        // to avoid "cannot drop a runtime in async context" panics.
        let result = tokio::task::spawn_blocking(move || match cli.command {
            Some(Commands::Setup) | None => commands::setup::run(),
            Some(Commands::Init) => commands::init::run(),
            Some(Commands::Start) => commands::start::run(),
            Some(Commands::Stop) => commands::start::stop(),
            Some(Commands::Inspect(args)) => commands::inspect::run(&args),
            Some(Commands::Pack(args)) => commands::pack::run(&args),
            Some(Commands::Use(args)) => commands::use_cmd::run_with_json(&args, cli.json),
            Some(Commands::Status) => commands::status::run_with_json(cli.json),
        })
        .await;
        match result {
            Ok(Ok(())) => {}
            Ok(Err(e)) => {
                eprintln!("{} {}", console::style("error:").red().bold(), e);
                std::process::exit(1);
            }
            Err(e) => {
                eprintln!("{} {}", console::style("error:").red().bold(), e);
                std::process::exit(1);
            }
        }
        return;
    }

    // Try entity commands (builder-API, async)
    if let Some((sub_name, sub_matches)) = matches.subcommand() {
        if is_entity_command(sub_name) {
            let session = match session::CliSession::load() {
                Ok(s) => s,
                Err(e) => {
                    eprintln!("{} {}", console::style("error:").red().bold(), e);
                    std::process::exit(1);
                }
            };
            let client = entity::client::ApiClient::new(
                session.effective_base_url(None),
                session.effective_api_key(None),
                session.tenant_id.clone(),
            );
            let output = entity::output::OutputConfig { json };
            if let Err(e) =
                entity::dispatch(sub_name, sub_matches, &client, &output, &session).await
            {
                eprintln!("{} {}", console::style("error:").red().bold(), e);
                std::process::exit(1);
            }
            return;
        }
    }

    // No command matched — show help
    let _ = Cli::command().print_help();
}