Enum Commands 

pub enum Commands {
    Run {
        task: String,
        json: bool,
    },
    Plan {
        task: String,
        json: bool,
    },
    Chat,
    Tui,
    Launch {
        port: u16,
        tui: bool,
    },
    Console {
        port: u16,
    },
    Daemon,
    Agent {
        action: AgentAction,
    },
    Swarm {
        task: String,
    },
    Schedule {
        task: String,
        cron: String,
        autonomy: Option<String>,
        report: Vec<String>,
    },
    Model {
        set: Option<String>,
        list: bool,
    },
    Route {
        action: RouteAction,
    },
    Auth {
        action: AuthAction,
    },
    Skills {
        action: SkillsAction,
    },
    Plugins {
        action: PluginsAction,
    },
    Tools {
        action: ToolsAction,
    },
    Security {
        action: SecurityAction,
    },
    Github {
        action: GithubAction,
    },
    Compact {
        task: Option<String>,
        out: Option<PathBuf>,
        json: bool,
    },
    Mcp {
        action: McpAction,
    },
    Checkpoint {
        action: CheckpointAction,
    },
    Rewind {
        id: String,
    },
    Replay {
        run_id: String,
        scrub: bool,
    },
    Gateway {
        action: GatewayAction,
    },
    Sessions {
        action: SessionAction,
    },
    Learn,
    Init,
    Status,
    Memory {
        action: MemoryAction,
    },
    Permissions {
        action: PermissionAction,
    },
    Profile {
        action: ProfileAction,
    },
    Import {
        source: ImportSource,
    },
    Config {
        edit: bool,
    },
    Update,
    Doctor,
    Setup,
    Demo,
    Share,
    Hook {
        action: HookAction,
    },
}

Variants

Run

Run a single agentic task

Fields

task: String

Task description

json: bool

Emit NDJSON event stream (same as the global –json flag, but may follow the task: sparrow run "..." --json)

Plan

Create a read-only execution plan for a task

Fields

task: String

Task description

json: bool

Emit JSON instead of Markdown

Chat

Interactive multi-turn chat

Tui

Launch TUI

Launch

Launch first-run setup, then the WebView cockpit

Fields

port: u16

TCP port for the WebView HTTP/WS server

tui: bool

Launch the terminal TUI instead of the WebView cockpit

Console

Launch webview console (HTTP + WebSocket)

Fields

port: u16

TCP port for the webview HTTP/WS server

Daemon

Run headless Sparrow runtime daemon

Agent

Manage persistent agents

Fields

action: AgentAction

Swarm

Run swarm: planner → coder → verifier

Fields

task: String

Task or plan file

Schedule

Schedule periodic jobs

Fields

task: String

Task description

cron: String

Cron expression

autonomy: Option<String>

Autonomy level for scheduled jobs

report: Vec<String>

Report to surfaces

Model

Manage model routing

Fields

set: Option<String>

Set active route

list: bool

List available models

Route

Configure intelligent auto-routing provider

Fields

action: RouteAction

Auth

Manage provider credentials

Fields

action: AuthAction

Skills

Manage skill library

Fields

action: SkillsAction

Plugins

Manage local Sparrow plugins

Fields

action: PluginsAction

Tools

Inspect and gate toolsets

Fields

action: ToolsAction

Security

Security audit of config, permissions, plugins, hooks, secrets

Fields

action: SecurityAction

Github

GitHub Action / remote PR workflow

Fields

action: GithubAction

Compact

Compact context and write a durable handoff doc

Fields

task: Option<String>

Task description (recorded in the handoff)

out: Option<PathBuf>

Output path (default: .sparrow/handoff/.md)

json: bool

Emit JSON instead of Markdown to stdout (the file is always Markdown)

Mcp

Manage MCP connectors

Fields

action: McpAction

Checkpoint

List checkpoints

Fields

action: CheckpointAction

Rewind

Rewind to a checkpoint

Fields

id: String

Checkpoint ID or number

Replay

Replay a transcript

Fields

run_id: String

Run ID to replay

scrub: bool

Open an interactive TUI scrubber (←/→ to step through events)

Gateway

Start/stop gateway daemon

Fields

action: GatewayAction

Sessions

Manage saved sessions

Fields

action: SessionAction

Learn

Interactive tutorial

Init

Initialize a project with .sparrow/ config

Status

Show live status (active runs, budget, session)

Memory

Manage persistent memory

Fields

action: MemoryAction

Permissions

Inspect and update permission policy

Fields

action: PermissionAction

Profile

Profile management

Fields

action: ProfileAction

Import

Migrate from OpenClaw

Fields

source: ImportSource

Config

Edit configuration

Fields

edit: bool

Open config.toml in editor

Update

Self-update

Doctor

Run diagnostics

Setup

(Re)run conversational setup

Demo

Run a self-contained demo (snake game)

Share

Share latest session as GitHub Gist

Hook

Install or scan security pre-commit hooks

Fields

action: HookAction

Trait Implementations

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand