Enum Command 

pub enum Command {
    Init {
        force: bool,
        no_detect: bool,
        gitignore_targets: bool,
    },
    Sync {
        check: bool,
        force: bool,
        rule: Option<String>,
        adopt: bool,
        ignore_fetch_failures: bool,
    },
    Status {
        rule: Option<String>,
        verbose: bool,
        ignore_fetch_failures: bool,
    },
    Wander {
        targets: Vec<String>,
        ignore_fetch_failures: bool,
    },
    Own {
        path: PathBuf,
        rule_id: Option<String>,
        clear: bool,
    },
    Add {

        id: String,
        local: Option<PathBuf>,
        repo: Option<String>,
        skill: bool,
        agent: bool,
        skill_set: bool,
        agent_set: bool,
        system: bool,
        collection_kind: bool,
        schema: Option<String>,
        name: Option<String>,
        description: Option<String>,
        allowed_tools: Option<String>,
        include: Vec<String>,
        exclude: Vec<String>,
    
},
}

Variants

Init

Scan project and create .rtango/spec.yaml + .rtango/lock.yaml

Fields

force: bool

Overwrite existing spec

no_detect: bool

Skip auto-detection, create an empty spec skeleton

gitignore_targets: bool

Keep generated targets in a managed .gitignore block

Sync

Bring target files in sync with the spec

Fields

check: bool

Dry-run: exit 1 if out of sync (for CI)

force: bool

Ignore on_target_modified: fail

rule: Option<String>

Only process a single rule

adopt: bool

Adopt existing target files on first sync

ignore_fetch_failures: bool

Skip GitHub rules whose fetch fails and continue with the rest

Status

Show sync plan without writing anything

Fields

rule: Option<String>

Only show a single rule

verbose: bool

Show up-to-date items too

ignore_fetch_failures: bool

Skip GitHub rules whose fetch fails and continue with the rest

Wander

Run init + sync in-memory: render target files without creating .rtango/

Fields

targets: Vec<String>

Additional target agent to render for (repeatable)

ignore_fetch_failures: bool

Skip GitHub rules whose fetch fails and continue with the rest

Own

Record or clear a manual ownership decision for a contested path

Fields

path: PathBuf

Target path (absolute, or relative to the project root)

rule_id: Option<String>

Rule id that should own the path (omit with –clear)

clear: bool

Remove any recorded ownership for this path

Add

Append a rule to the spec (mechanical — no validation beyond id/source/kind)

Fields

id: String

Rule id (must be unique within the spec)

local: Option<PathBuf>

Local source path (directory or file, relative to root). Combine with –collection-kind/–col to treat a local directory as a collection.

repo: Option<String>

GitHub source: owner/repo[@ref][:path]. Combine with –collection-kind/–col to treat a GitHub repo as a collection.

skill: bool

Kind is a single skill

agent: bool

Kind is a single agent

skill_set: bool

Kind is skill-set

agent_set: bool

Kind is agent-set

system: bool

Kind is a system instruction file (CLAUDE.md / AGENTS.md / etc.)

collection_kind: bool

Kind is a remote rtango collection (imports rules from a remote spec.yaml)

schema: Option<String>

Schema agent for the rule (required when spec has >1 agent) For collections, overrides the schema_agent for all imported rules.

name: Option<String>

Override frontmatter name (single kinds only)

description: Option<String>

Override frontmatter description (single kinds only)

allowed_tools: Option<String>

Override frontmatter allowed-tools (single kinds only, space-separated)

include: Vec<String>

Only include entries matching NAME (set and collection kinds, repeatable)

exclude: Vec<String>

Exclude entries matching NAME (set and collection kinds, repeatable)

Trait Implementations

impl FromArgMatches for Command

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 Command

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