Enum Cmd 

pub enum Cmd {
    Build {
        force: bool,
    },
    Store {
        text: String,
        layer: String,
        importance: u8,
        status: Option<String>,
    },
    Timeline {
        window: String,
        k: usize,
    },
    Loops {
        k: usize,
    },
    ResolveLoop {
        id: u64,
    },
    AutoContext {
        compact: bool,
        output: Option<String>,
    },
    Recall {
        query: String,
        k: usize,
    },
    Look {
        x: f32,
        y: f32,
        z: f32,
        zoom: u8,
        k: usize,
    },
    Radial {
        x: f32,
        y: f32,
        z: f32,
        depth: u8,
        radius: f32,
        k: usize,
    },
    Soft {
        x: f32,
        y: f32,
        z: f32,
        zoom: u8,
        k: usize,
        gpu: bool,
    },
    BenchRecall {
        n: usize,
        query: String,
        k: usize,
    },
    Bench,
    Stats,
    Token {
        user_id: String,
    },
    Find {
        query: String,
        k: usize,
    },
    Fingerprint,
    Links {
        block_index: usize,
    },
    Similar {
        text: String,
        k: usize,
    },
    Rebuild,
    Embed {
        query: String,
        k: usize,
        metric: String,
    },
    GpuBench,
    Verify,
    VerifyMerkle,
    Proof {
        block_index: usize,
    },
    Think {
        query: String,
        max_steps: usize,
    },
    Spine,
    Query {
        mql: String,
    },
    Export {
        output: String,
    },
    Import {
        input: String,
        output_dir: Option<String>,
    },
    Diff {
        a: String,
        b: String,
    },
    FederatedRecall {
        query: String,
        k: usize,
    },
    PulseExchange,
    FederatedFind {
        query: String,
        k: usize,
    },
    Hebbian,
    HebbianDrift,
    Hottest {
        k: usize,
    },
    Archetypes,
    Emerge,
    Resonance,
    Integrate,
    Mirror,
    Resonant {
        k: usize,
    },
    Viz {
        output: String,
    },
    Patterns {
        k: usize,
    },
    Paths {
        sessions: usize,
    },
    Predictions,
    TemporalPatterns,
    Attention,
    PatternExchange,
    Dream,
    DreamLog {
        k: usize,
    },
    EmotionalField,
    EmotionalExchange,
    Modalities,
    CognitiveMap {
        output: String,
    },
    StoreData {
        pairs: Vec<String>,
        importance: u8,
    },
    InitDemo {
        force: bool,
    },
    Serve {
        port: u16,
    },
    Bridge {
        host: String,
        port: u16,
    },
    Mcp,
    McpHttp {
        host: String,
        port: u16,
    },
    Config {
        client: String,
    },
    Doctor {
        fix: bool,
    },
    Mermaid {
        port: u16,
    },
    Autonomous {
        tts: bool,
        daemon: bool,
        interval: u64,
        max_cycles: Option<usize>,
    },
    Introspect,
    SelfModel,
    AwarenessTrace,
    Curiosity,
    Monologue,
    Stories {
        k: usize,
    },
    Daydream {
        seed: String,
        steps: usize,
    },
    Hyperfocus {
        target: String,
        focus_type: String,
    },
    Keys {
        action: KeyAction,
    },
    ZenKeys {
        action: ZenKeyAction,
    },
    Enforce {
        action: EnforceAction,
    },
    Evidence {
        action: EvidenceAction,
    },
    Morphogenesis {
        action: MorphogenesisAction,
    },
    Absentia {
        action: AbsentiaAction,
    },
    Intent {
        action: IntentAction,
    },
    Octopus {
        operation: String,
    },
    ImportChatGpt {
        json: Option<String>,
        persona: String,
        dry_run: bool,
        gdrive: Option<String>,
        gdrive_folder: Option<String>,
    },
    Density {
        output: String,
        grid: u16,
    },
    Reconsolidate,
    Salience,
    Narrative {
        verbose: bool,
    },
    Spaced {
        due: bool,
        k: usize,
    },
    Eureka {
        k: usize,
        verbose: bool,
    },
    Wm {
        action: WmAction,
    },
    Sandbox {
        simulate: Option<String>,
        actions: Option<String>,
        best: bool,
        clear: bool,
    },
    Impulse {
        filter: Option<String>,
        source: String,
        urgency: f32,
        suppress: Option<String>,
        stats: bool,
        clear: bool,
    },
    Meta {
        record: Option<String>,
        evaluate: bool,
        trends: bool,
        report: bool,
        add_strategy: Option<String>,
    },
    Code {
        store: Option<String>,
        error: Option<String>,
        recall: Option<String>,
        list: Option<String>,
        lang: Option<String>,
        project: Option<String>,
        k: usize,
        symbol: Option<String>,
        stats: bool,
    },
    Implicit {
        show: bool,
        practice: Option<String>,
        skills: bool,
        patterns: bool,
        decay: bool,
    },
    Explicit {
        show: bool,
        store_fact: Option<String>,
        concept: Option<String>,
        facts: bool,
        concepts: bool,
    },
    Hippo {
        show: bool,
        consolidate: bool,
        related: Option<u64>,
        replay: Option<u64>,
        decay: bool,
    },
    Neuro {
        show: bool,
        synapse: Option<String>,
        pathway: Option<String>,
        prune: bool,
        reorganize: bool,
        pathways: bool,
    },
    Struct {
        show: bool,
        neurogenesis: Option<String>,
        grow: Option<String>,
        prune: Option<u64>,
        specialized: bool,
    },
    Func {
        show: bool,
        area: Option<String>,
        map: Option<String>,
        connect: Option<String>,
        damage: Option<String>,
        plastic: bool,
    },
    Syn {
        show: bool,
        ltp: Option<String>,
        ltd: Option<String>,
        stdp: Option<String>,
        hetero: Option<String>,
        timedep: Option<String>,
        strong: bool,
        ltp_dominant: bool,
    },
    Stim {
        show: bool,
        activity: Option<String>,
        check: bool,
        recommend: bool,
        diversity: bool,
    },
    Focus {
        enter: Option<String>,
        exit: bool,
        process: Option<String>,
        show: bool,
        insights: bool,
    },
    Simulate {
        register: Option<String>,
        list: bool,
        run: Option<String>,
        stress: Option<String>,
        compare: Option<String>,
        results: Option<String>,
        patterns: bool,
        clear: bool,
        duration: f64,
        load_pattern: String,
        peak_load: f64,
        faults: bool,
    },
    Knowledge {
        search: Option<String>,
        list_type: Option<String>,
        stats: bool,
        add_practice: Option<String>,
        export: bool,
        auto_build: bool,
        clear: bool,
    },
    Generate {
        req: Option<String>,
        strategy: String,
        components: String,
        target_latency: f64,
        gens: u32,
        history: bool,
    },
    Morph {

        grow: Option<String>,
        seed_type: String,
        pattern: String,
        energy: f64,
        x: f64,
        y: f64,
        z: f64,
        evolve: Option<u32>,
        pop_size: usize,
        objective: String,
        list: bool,
        best: bool,
        express: Option<String>,
        analyze: Option<String>,
        mutation_rate: f64,
        daemon: bool,
        interval: u64,
        threshold: f64,
    
},
    Decide {
        evaluate: Option<String>,
        decide: Option<String>,
        quick: Option<String>,
        recommend: Option<String>,
        preference: Option<String>,
        outcome: Option<String>,
        stats: bool,
        log: bool,
        patterns: bool,
        learned: bool,
    },
}

Variants

Build

Build binary index from raw layer files (from scratch)

Fields

force: bool

Force rebuild even if layer files are unchanged

Store

Store a new memory

Fields

text: String

layer: String

importance: u8

status: Option<String>

Status flag: open (open loop) | resolved | archived | normal

Timeline

Show timeline (chronological stores) by window

Fields

window: String

Time window: today, yesterday, last_N_days, since:YYYY-MM-DD, last_session, all

k: usize

Loops

List currently-open loops

Fields

k: usize

ResolveLoop

Mark a loop resolved

Fields

id: u64

AutoContext

Universal auto-context snapshot — for any LLM wrapper script. Writes to stdout (default) or to a file path.

Fields

compact: bool

Compact mode (no box-drawing)

output: Option<String>

Output to this file instead of stdout

Recall

Recall — natural language query, auto-zoom

Fields

query: String

k: usize

Look

Manual look: x y z zoom [k]

Fields

x: f32

y: f32

z: f32

zoom: u8

k: usize

Radial

Radial search: find blocks within radius at a depth

Fields

x: f32

y: f32

z: f32

depth: u8

radius: f32

k: usize

Soft

4D soft zoom: x y z zoom [k]

Fields

x: f32

y: f32

z: f32

zoom: u8

k: usize

gpu: bool

Use GPU acceleration (requires gpu feature)

BenchRecall

Benchmark Time the recall path in one process, separating first-call setup from steady-state calls. This exists because the end-to-end figure quoted for recall (117 ms on the evaluation index) is not comparable to the FAISS baselines, which report query-time search only against a resident index. Calling recall in a loop makes the split visible: the first call pays one-time initialisation, and later calls are the steady-state cost with the state files already warm. Neither is FAISS number, and the gap between them is exactly what the end-to-end figure hides.

Fields

n: usize

Calls after the first.

query: String

k: usize

Results returned per call. Exposed so the cost of printing results can be separated from the cost of finding them.

Bench

Stats

Stats

Token

Generate a per-user bridge auth token (HMAC-signed against [server] api_key)

Fields

user_id: String

User id to sign

Find

Text search

Fields

query: String

k: usize

Fingerprint

Build structural fingerprints and wormhole links

Links

Show structural links (wormholes) for a block

Fields

block_index: usize

Similar

Find structurally similar blocks to a text

Fields

text: String

k: usize

Rebuild

Rebuild — merge pending observations from append log into the main index

Embed

Semantic search using embeddings

Fields

query: String

k: usize

metric: String

GpuBench

GPU vs CPU benchmark (requires gpu feature)

Verify

Verify CRC16 integrity of all blocks

VerifyMerkle

Verify Merkle tree integrity of the entire index

Proof

Show Merkle proof for a specific block

Fields

block_index: usize

Think

Sequential Thinking — Chain-of-Thought memory sequence

Fields

query: String

max_steps: usize

Spine

Start the Binary Spine IPC listener (Zero JSON)

Query

MQL query (Microscope Query Language)

Fields

mql: String

MQL expression, e.g. ‘layer:long_term depth:2..5 “Ora”’

Export

Export index to .mscope archive

Fields

output: String

Output archive path

Import

Import .mscope archive

Fields

input: String

Input archive path

output_dir: Option<String>

Output directory (defaults to config output_dir)

Diff

Diff two .mscope archives

Fields

a: String

First archive

b: String

Second archive

FederatedRecall

Federated recall across multiple indices

Fields

query: String

k: usize

PulseExchange

Exchange resonance pulses across federated indices (mirror neuron protocol)

FederatedFind

Federated text search across multiple indices

Fields

query: String

k: usize

Hebbian

Show Hebbian learning state (activations, co-activations, energy)

HebbianDrift

Apply Hebbian drift — co-activated blocks pull coordinates closer

Hottest

Show hottest blocks (most recently/frequently activated)

Fields

k: usize

Archetypes

Show emerged archetypes (crystallized activation patterns)

Emerge

Detect new archetypes from resonance field and Hebbian state

Resonance

Show resonance protocol state (pulses, field energy)

Integrate

Integrate received pulses into local Hebbian state

Mirror

Show mirror neuron state (resonance echoes, boosted blocks)

Resonant

Show most resonant blocks (strongest mirror neuron signal)

Fields

k: usize

Viz

Export 3D visualization snapshot (Binary)

Fields

output: String

Output file path (default: viz.bin)

Patterns

Show thought patterns (crystallized recall sequences)

Fields

k: usize

Paths

Show recent thought paths (recall sequences by session)

Fields

sessions: usize

Predictions

Show predictive cache stats and active predictions

TemporalPatterns

Show temporal archetype patterns (time-of-day activation profiles)

Attention

Show attention mechanism state (layer weights, quality history)

PatternExchange

Exchange thought patterns across federated indices

Dream

Run dream consolidation (offline memory replay and pruning)

DreamLog

Show dream consolidation history

Fields

k: usize

EmotionalField

Show emotional contagion state (local + remote emotional fields)

EmotionalExchange

Exchange emotional snapshots across federated indices

Modalities

Show multimodal index statistics

CognitiveMap

Export full cognitive map (all 13 layers) as JSON for Three.js viewer

Fields

output: String

Output file path (default: cognitive_map.bin)

StoreData

Store structured data (key=value pairs)

Fields

pairs: Vec<String>

Key-value pairs: key1=val1 key2=val2

importance: u8

InitDemo

Initialize a demo dataset and configuration for quickstart

Fields

force: bool

Force overwrite existing layers/demo.txt

Serve

Start a local HTTP server for the 3D Viewer (viewer.html)

Fields

port: u16

Bridge

Start the REST Bridge API (OpenAPI spec at /openapi.json)

Fields

host: String

Interface to bind. A non-loopback host requires [server] api_key.

port: u16

Mcp

Start the MCP (Model Context Protocol) server for Claude Desktop integration

McpHttp

Start the MCP server over Streamable HTTP transport (remote/multi-client)

Requires --features mcp_http. A non-loopback host requires [server] api_key to be set in config.

Fields

host: String

Interface to bind. A non-loopback host requires [server] api_key.

port: u16

Config

Print drop-in MCP server config + auto-context wrapper instructions for a specific AI client: claude | hermes | cursor | cline | generic

Fields

client: String

Target client: claude, hermes, cursor, cline, generic

Doctor

Run integrity diagnostics and attempt automatic repair (Crash Recovery)

Fields

fix: bool

Attempt to fix common corruption issues (e.g. malformed append log tail)

Mermaid

Start the Mermaid Terminal (WebSocket + HTML UI on port 8080)

Fields

port: u16

Autonomous

Autonomous mode - the system runs itself: daydream, curiosity, monologue, reflect, narrative, dream

Fields

tts: bool

Enable TTS (text-to-speech) via Windows System.Speech

daemon: bool

Run as daemon (continuous loop) instead of single cycle

interval: u64

Cycle interval in seconds (default: 30)

max_cycles: Option<usize>

Maximum number of cycles (default: infinite in daemon mode, 1 in single mode)

Introspect

Introspect - self-reflection: the system thinks about itself

SelfModel

SelfModel - show the system’s self-model snapshot

AwarenessTrace

AwarenessTrace - show the reasoning graph behind ‘I am aware’

Curiosity

Curiosity - show what the system is curious about

Monologue

Monologue - generate an inner monologue (the system thinking)

Stories

Stories - show narrative memory episodes (story arcs from recalls)

Fields

k: usize

Daydream

Daydream - associative drift (mind wandering)

Fields

seed: String

Seed text to start from (default: last narrative)

steps: usize

Number of drift steps

Hyperfocus

Hyperfocus - enter deep concentration mode on a topic

Fields

target: String

Target topic

focus_type: String

Focus type: planning, problem_solving, creative, research

Keys

Key management — binary key store (keys.bin)

Fields

action: KeyAction

ZenKeys

Zen key management — binary zen key store (zen_keys.bin)

Fields

action: ZenKeyAction

Enforce

Commitment enforcement — the A_t^valid gate, documented override, and hash-chained audit.

Fields

action: EnforceAction

Evidence

Evidence layer — epistemic audit, confidence tracking

Fields

action: EvidenceAction

Morphogenesis

Kognitív Morfogenezis — audit-napló, metrikák, gradiens állapot

Fields

action: MorphogenesisAction

Absentia

Absentia — Csend Réteg: ami NEM történt meg, ami hiányzik

Fields

action: AbsentiaAction

Intent

Intent Pipeline — auditálható szándék-generálás

Fields

action: IntentAction

Octopus

Octopus — párhuzamos kognitív műveletek

Fields

operation: String

Művelet: full-pipeline | scan | cycle

ImportChatGpt

Import ChatGPT conversations export (JSON) into Microscope Memory

Fields

json: Option<String>

Path to ChatGPT export JSON file (conversations.json) — or Google Drive shared link

persona: String

AI persona name

dry_run: bool

Show only summary without importing

gdrive: Option<String>

Google Drive file URL (shared link to conversations.json)

gdrive_folder: Option<String>

Google Drive shared folder URL — imports all JSON files from folder

Density

Export binary density map for fast rendering

Fields

output: String

Output file path

grid: u16

Grid resolution (default: 32)

Reconsolidate

Run manual reconsolidation on recent recalls (emotion blend + spatial drift)

Salience

Show the salience network state (inhibitions, mask)

Narrative

Show the inner narrative — the system’s current sense of self

Fields

verbose: bool

Show detailed breakdown (emotion vector, all context)

Spaced

Spaced repetition — Ebbinghaus forgetting curve management (SM-2)

Fields

due: bool

Show only due blocks

k: usize

Number of results to show

Eureka

Show eureka/insight events (unexpected but emotionally relevant connections)

Fields

k: usize

verbose: bool

Show detailed insight scores

Wm

Working memory operations (7±2 buffer, 30s decay)

Fields

action: WmAction

Sandbox

Mental sandbox simulation - run scenarios before taking action

Fields

simulate: Option<String>

Simulate a scenario with given actions

actions: Option<String>

Actions to simulate (comma-separated)

best: bool

Show best scenario based on risk/reward

clear: bool

Clear all scenarios

Impulse

Impulse control - filter incoming stimuli

Fields

filter: Option<String>

Filter a stimulus

source: String

Stimulus source

urgency: f32

Urgency level (0.0-1.0)

suppress: Option<String>

Add suppression pattern

stats: bool

Show stats

clear: bool

Clear suppression patterns

Meta

Meta-cognitive supervision - monitor and optimize system performance

Fields

record: Option<String>

Record performance metrics

evaluate: bool

Evaluate and get correction suggestion

trends: bool

Show performance trends

report: bool

Generate performance report

add_strategy: Option<String>

Add custom correction strategy

Code

Code Memory — dedikált kódmemória réteg kódoló agentek számára

Fields

store: Option<String>

Store code entry (type:title:code:file:lang:project)

error: Option<String>

Store error:solution pair

recall: Option<String>

Recall from code memory

list: Option<String>

List by type (function, error, type, import, etc.)

lang: Option<String>

Filter by language

project: Option<String>

Filter by project

k: usize

Number of results

symbol: Option<String>

Search by symbol name

stats: bool

Show stats

Implicit

Implicit memory - procedural learning and habits

Fields

show: bool

Show implicit memory state

practice: Option<String>

Practice a skill (skill_name:success)

skills: bool

View skill rankings

patterns: bool

Show strongest patterns

decay: bool

Decay weak patterns/skills

Explicit

Explicit memory - declarative facts and concepts

Fields

show: bool

Show explicit memory state

store_fact: Option<String>

Store a fact (statement:source:confidence)

concept: Option<String>

Define a concept

facts: bool

Get high confidence facts

concepts: bool

Show concepts

Hippo

Hippocampus - episodic binding and consolidation

Fields

show: bool

Show hippocampus state

consolidate: bool

Get consolidation candidates

related: Option<u64>

Show related episodes

replay: Option<u64>

Replay episode for consolidation

decay: bool

Decay old episodes

Neuro

Neuroplasticity - adaptive network reorganization

Fields

show: bool

Show network state

synapse: Option<String>

Strengthen synapse (from:to:success)

pathway: Option<String>

Strengthen pathway (domain:block1,block2,block3)

prune: bool

Prune weak connections

reorganize: bool

Reorganize pathways

pathways: bool

Show strongest pathways

Struct

Structural Plasticity - dendritic growth and pruning

Fields

show: bool

Show structural state

neurogenesis: Option<String>

Neurogenesis (blocks:specialization)

grow: Option<String>

Grow dendrite (neuron_id:new_block)

prune: Option<u64>

Prune branches (neuron_id)

specialized: bool

Show specialized neurons

Func

Functional Plasticity - sensorimotor reorganization

Fields

show: bool

Show functional state

area: Option<String>

Create functional area (name:domain:blocks)

map: Option<String>

Map sensorimotor (input:output1,output2,output3)

connect: Option<String>

Connect areas (area1_id:area2_id)

damage: Option<String>

Simulate damage (area_id:severity)

plastic: bool

Show most plastic areas

Syn

Synaptic Plasticity - LTP, LTD, STDP

Fields

show: bool

Show synaptic state

ltp: Option<String>

Long-Term Potentiation (pre:post)

ltd: Option<String>

Long-Term Depression (pre:post)

stdp: Option<String>

STDP (pre:post:pre_time:post_time)

hetero: Option<String>

Heterosynaptic depression (pre:post:radius)

timedep: Option<String>

Time-dependent plasticity (pre:post:practice_count:strategy_age_ms)

strong: bool

Show strongest synapses

ltp_dominant: bool

Show LTP dominant synapses

Stim

Mental Stimulation — continuous activity requirement

Fields

show: bool

Show stimulation state

activity: Option<String>

Record activity (type:intensity)

check: bool

Check if stimulation is needed

recommend: bool

Get recommended activities

diversity: bool

Show activity diversity

Focus

Hyperfocus — concentrate all resources on one objective

Fields

enter: Option<String>

Enter hyperfocus (target:type)

exit: bool

Exit hyperfocus

process: Option<String>

Process data during hyperfocus (blocks:complexity)

show: bool

Show hyperfocus state

insights: bool

Get insights from current focus

Simulate

Architecture Simulator — real-time architecture simulation and stress testing

Fields

register: Option<String>

Register a new architecture (name:description:components:connections)

list: bool

List all registered architectures

run: Option<String>

Run simulation on architecture (arch_id)

stress: Option<String>

Run stress test (arch_id)

compare: Option<String>

Compare two architectures (arch_a,arch_b)

results: Option<String>

Show simulation results

patterns: bool

Show learned patterns

clear: bool

Clear all results

duration: f64

Simulation duration in seconds

load_pattern: String

Load pattern (linear, spike, sine, random)

peak_load: f64

Peak load (0.0-1.0)

faults: bool

Enable fault injection

Knowledge

Knowledge Base — search and manage architectural knowledge

Fields

search: Option<String>

Search the knowledge base

list_type: Option<String>

List entries by type

stats: bool

Show knowledge base statistics

add_practice: Option<String>

Add a best practice

export: bool

Export all knowledge

auto_build: bool

Auto-build knowledge from system state

clear: bool

Clear knowledge base

Generate

Architecture Generator — generate new architectures from patterns

Fields

req: Option<String>

Requirements for the architecture

strategy: String

Generation strategy (hybrid, optimize, novel, evolutionary)

components: String

Component range (min:max)

target_latency: f64

Target latency in ms

gens: u32

Number of generations (evolutionary only)

history: bool

Show generation history

Morph

Morphogenesis — biológiai mintákon alapuló generatív architektúra-tenyésztés

Fields

grow: Option<String>

Növesztés egy seed-ből (seed leírás)

seed_type: String

Seed típus (service, database, cache, gateway)

pattern: String

Növekedési minta (mycelium, capillary, slime, fractal, hybrid)

energy: f64

Seed energia

x: f64

Seed pozíció X

y: f64

Seed pozíció Y

z: f64

Seed pozíció Z

evolve: Option<u32>

Evolúció futtatása N generáción át

pop_size: usize

Populáció méret

objective: String

Fitness cél (latency, throughput, cost, redundancy, balanced)

list: bool

Listázza az organizmusokat

best: bool

Legjobb organizmus mutatása

express: Option<String>

Expresszálás Architecture-ként (organizmus ID)

analyze: Option<String>

Topológiai elemzés (organizmus ID)

mutation_rate: f64

Mutáció ráta evolúciónál

daemon: bool

Background daemon — figyeli a vagus tónust és automatikusan növeszt kompenzatórikus struktúrákat

interval: u64

Daemon ciklus idő másodpercben

threshold: f64

Vagus stressz küszöb (0.0-1.0)

Decide

Heuristic Decision Maker — evaluate options and make decisions

Fields

evaluate: Option<String>

Evaluate options (comma-separated: desc,utility,risk)

decide: Option<String>

Make a decision from options

quick: Option<String>

Quick decision (time budget in ms)

recommend: Option<String>

Recommend architecture for requirements

preference: Option<String>

Set decision preference (risk_averse, aggressive, balanced)

outcome: Option<String>

Evaluate decision outcome (decision_id:score:reflection)

stats: bool

Show decision statistics

log: bool

Show decision log

patterns: bool

Recognize patterns in decisions

learned: bool

Show learned heuristic patterns

Trait Implementations

impl FromArgMatches for Cmd

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 Cmd

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