@aitherium/shell-cli 1.1.0

package/dist/completions.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tab completion for commands, @agent mentions, and !shell shortcuts.
+ */
+import type { GenesisClient } from './client.js';
+/**
+ * Refresh the completion command list from the registry.
+ * Called after loadDynamicCommands() merges new commands.
+ */
+export declare function refreshCommandCompletions(): void;
+export declare const STRATEGY_DIRECTIVES: {
+    trigger: string;
+    hint: string;
+}[];
+export declare function loadAgentNames(client: GenesisClient): Promise<string[]>;
+/**
+ * Resolve an @mention to a canonical agent name using the directory.
+ * Returns { resolved: canonicalName } on success, { unknown: rawName } on failure.
+ */
+export declare function resolveAgentMention(mention: string): {
+    resolved?: string;
+    unknown?: string;
+};
+/** Get all known agent names + aliases for completions. */
+export declare function getAgentCompletionNames(): string[];
+export declare const SUBCOMMAND_DEFS: Record<string, [string, string][]>;
+export declare const SUBCOMMANDS: Record<string, string[]>;
+export declare function completer(agents: string[]): (line: string) => [string[], string];

package/dist/completions.js

@@ -0,0 +1,351 @@
+/**
+ * Tab completion for commands, @agent mentions, and !shell shortcuts.
+ */
+import { getCommandNames } from './commands.js';
+import { getCommandRegistry } from './command-registry.js';
+// Build initial list from static commands; refreshed after dynamic loading
+let COMMAND_NAMES = [...getCommandNames().map(n => `/${n}`), '/jobs'];
+/**
+ * Refresh the completion command list from the registry.
+ * Called after loadDynamicCommands() merges new commands.
+ */
+export function refreshCommandCompletions() {
+    const registry = getCommandRegistry();
+    const allNames = registry.allNames();
+    const mcpTools = registry.getMcpTools().map(t => t.name);
+    COMMAND_NAMES = [
+        ...new Set([
+            ...allNames.map(n => `/${n}`),
+            ...mcpTools.map(n => `/${n}`),
+            '/jobs',
+        ]),
+    ].sort();
+}
+// Common shell commands for ! completion
+const SHELL_HINTS = [
+    '!docker ps', '!docker compose', '!docker logs',
+    '!git status', '!git log --oneline -10', '!git diff',
+    '!pwsh', '!ls', '!cat', '!curl',
+    '!Get-AitherStatus', '!Get-AitherContainer',
+];
+// Fallback agent names when Genesis is unreachable
+const DEFAULT_AGENTS = [
+    'aither', 'personal', 'demiurge', 'athena', 'atlas', 'hydra',
+    'apollo', 'prometheus', 'scribe', 'viviane', 'hera',
+    'isolde', 'prospero', 'ignis', 'terra', 'vera',
+];
+// Strategy directives — passed through to Genesis StrategyResolver, not agent routes
+export const STRATEGY_DIRECTIVES = [
+    { trigger: 'code', hint: 'Force code context — codegraph + architecture + tools' },
+    { trigger: 'research', hint: 'Deep web research + synthesis pipeline' },
+    { trigger: 'internal', hint: 'Full AitherOS internal context (platform only)' },
+    { trigger: 'quick', hint: 'Fast response, no deliberation (effort 1–3)' },
+    { trigger: 'think', hint: 'Deep reasoning with extended deliberation' },
+    { trigger: 'reason', hint: 'Full reasoning model + structured analysis' },
+    { trigger: 'agentic', hint: 'Force agentic ReAct loop with tools' },
+    { trigger: 'debug', hint: 'PRISM-powered debugging — 6 expert personas' },
+    { trigger: 'troubleshoot', hint: 'Systematic service troubleshooting' },
+    { trigger: 'investigate', hint: 'Deep exploratory investigation — long tool chains' },
+    { trigger: 'council', hint: '6-specialist council review before responding' },
+    { trigger: 'deliberate', hint: 'Parallel thought streams + convergence' },
+    { trigger: 'swarm', hint: 'Full 11-agent swarm coding (Forge mode)' },
+    { trigger: 'compete', hint: 'Multiple strategies in parallel — best judged' },
+    { trigger: 'personal', hint: 'Personal assistant mode' },
+    { trigger: 'chat', hint: 'Companion mode — fast, natural conversation (persists)' },
+    { trigger: 'companion', hint: 'Companion mode — fast, natural conversation (persists)' },
+    { trigger: 'talk', hint: 'Companion mode — fast, natural conversation (persists)' },
+];
+let cachedAgents = [];
+/** Maps lowercase alias → canonical agent name (built from directory). */
+let agentAliasMap = {};
+// Common short-name aliases that map to canonical agent IDs.
+// These mirror AGENT_MENTION_MAP in intent_classifier.py.
+const BUILTIN_ALIASES = {
+    demi: 'demiurge',
+    forge: 'demiurge',
+    swarm: 'demiurge',
+    assistant: 'personal',
+};
+export async function loadAgentNames(client) {
+    if (cachedAgents.length)
+        return cachedAgents;
+    try {
+        const result = await client.getAgents();
+        const agents = (result?.agents || []).map((a) => {
+            // Genesis uses a.id, ADK uses a.name/a.identity — accept all
+            const id = (a.id || a.identity || a.name || '').toLowerCase();
+            const name = (a.name || a.id || a.identity || '').toLowerCase();
+            return { id, name };
+        }).filter((a) => a.id);
+        if (agents.length) {
+            cachedAgents = agents.map((a) => a.id);
+            // Build alias map: both id and display name point to canonical id
+            agentAliasMap = {};
+            for (const a of agents) {
+                agentAliasMap[a.id] = a.id;
+                if (a.name && a.name !== a.id) {
+                    agentAliasMap[a.name] = a.id;
+                }
+            }
+            // Add built-in short aliases
+            for (const [alias, canonical] of Object.entries(BUILTIN_ALIASES)) {
+                if (!agentAliasMap[alias]) {
+                    agentAliasMap[alias] = canonical;
+                }
+            }
+        }
+        else {
+            cachedAgents = DEFAULT_AGENTS;
+            agentAliasMap = Object.fromEntries(DEFAULT_AGENTS.map(a => [a, a]));
+            for (const [alias, canonical] of Object.entries(BUILTIN_ALIASES)) {
+                agentAliasMap[alias] = canonical;
+            }
+        }
+    }
+    catch {
+        cachedAgents = DEFAULT_AGENTS;
+        agentAliasMap = Object.fromEntries(DEFAULT_AGENTS.map(a => [a, a]));
+        for (const [alias, canonical] of Object.entries(BUILTIN_ALIASES)) {
+            agentAliasMap[alias] = canonical;
+        }
+    }
+    return cachedAgents;
+}
+/**
+ * Resolve an @mention to a canonical agent name using the directory.
+ * Returns { resolved: canonicalName } on success, { unknown: rawName } on failure.
+ */
+export function resolveAgentMention(mention) {
+    const key = mention.toLowerCase();
+    const canonical = agentAliasMap[key];
+    if (canonical)
+        return { resolved: canonical };
+    // Fuzzy: check if it's a prefix of exactly one agent
+    const prefixMatches = cachedAgents.filter(a => a.toLowerCase().startsWith(key));
+    if (prefixMatches.length === 1)
+        return { resolved: prefixMatches[0].toLowerCase() };
+    return { unknown: mention };
+}
+/** Get all known agent names + aliases for completions. */
+export function getAgentCompletionNames() {
+    return [...new Set([...cachedAgents, ...Object.keys(agentAliasMap)])];
+}
+// Subcommand completions for commands that have them
+// Each entry: [name, argHint] — argHint is '' for no-arg subcommands
+export const SUBCOMMAND_DEFS = {
+    '/onboard': [
+        ['auto', '<path> [name] — Auto-detect code vs knowledge'],
+        ['code', '<path> [name] — Index a local codebase'],
+        ['knowledge', '<path> [name] — Ingest a knowledge directory'],
+        ['repo', '<git-url> [name] — Import a remote repository into workspace'],
+    ],
+    '/obsidian': [
+        ['setup', '[vault-path] — Install plugin into an Obsidian vault'],
+        ['status', '— Check plugin install status across vaults'],
+    ],
+    '/scope': [
+        ['graph', '[path] — Fetch dependency graph'],
+        ['dead', '[path] — Find dead/unreachable code'],
+        ['metrics', '[path] — Codebase metrics summary'],
+        ['health', '— Check CodeGraph service health'],
+        ['reindex', '[path] — Force re-index codebase'],
+    ],
+    '/nb': [
+        ['list', ''],
+        ['plan', '<prompt>'],
+        ['open', '<id>'],
+        ['run', '<id>'],
+        ['create', '<name>'],
+        ['info', '<id>'],
+        ['export', '<id> [path]'],
+        ['templates', ''],
+        ['sessions', ''],
+    ],
+    '/notebook': [
+        ['list', ''],
+        ['plan', '<prompt>'],
+        ['open', '<id>'],
+        ['run', '<id>'],
+        ['create', '<name>'],
+        ['info', '<id>'],
+        ['export', '<id> [path]'],
+        ['templates', ''],
+        ['sessions', ''],
+    ],
+    '/jobs': [
+        ['cancel', '<id>'],
+    ],
+    '/safety': [
+        ['status', ''],
+        ['levels', ''],
+        ['set', '<professional|casual|unrestricted|explicit> [--context <ctx>] [--scope <scope>]'],
+        ['resolve', '[--scope <scope>] [--context <ctx>] [--user <id>] [--tenant <slug>] [--agent <id>]'],
+        ['age-status', ''],
+        ['verify-age', '<YYYY-MM-DD>'],
+        ['platform', ''],
+        ['tenant', '[slug]'],
+        ['agent', '<agent_id>'],
+    ],
+    '/calendar': [
+        ['list', '— Show upcoming events'],
+        ['create', '"<title>" --start <ISO> [--end <ISO>]'],
+        ['delete', '<id>'],
+        ['sync', '— Trigger CalDAV sync'],
+    ],
+    '/cal': [
+        ['list', ''],
+        ['create', '"<title>" --start <ISO>'],
+        ['delete', '<id>'],
+        ['sync', ''],
+    ],
+    '/mail': [
+        ['inbox', '— Show inbox'],
+        ['send', '"<subject>" --body "<text>" [--priority high]'],
+        ['threads', '— List email threads'],
+        ['read', '<thread_id>'],
+    ],
+    '/email': [
+        ['inbox', ''],
+        ['send', '"<subject>" --body "<text>"'],
+        ['threads', ''],
+        ['read', '<thread_id>'],
+    ],
+    '/will': [
+        ['active', '— Show current will policy'],
+        ['list', '— Available wills'],
+        ['activate', '<id>'],
+        ['policy', '— Full policy detail'],
+    ],
+    '/escalate': [
+        ['list', '— Pending proposals'],
+        ['config', '— Show escalation config'],
+        ['approve', '<id>'],
+        ['deny', '<id> [reason]'],
+        ['set', '<key> <value>'],
+    ],
+    '/research': [
+        ['"<topic>"', '[--depth quick|deep] [--report]'],
+    ],
+    '/publish': [
+        ['blog', '"<topic>" — Generate blog post'],
+        ['social', '"<message>" — Craft social post'],
+        ['status', '— Content deck status'],
+    ],
+    '/routines': [
+        ['list', '— Show all routines'],
+        ['run', '<id>'],
+        ['create', '<json>'],
+        ['enable', '<id>'],
+        ['disable', '<id>'],
+        ['edit', '<id> <json>'],
+        ['history', '— Recent execution history'],
+        ['pause', '— Pause all routines'],
+        ['resume', '— Resume routines'],
+        ['status', '— Scheduler status'],
+    ],
+    '/expedition': [
+        ['list', '— Active expeditions'],
+        ['create', '<name>'],
+        ['status', '<id>'],
+        ['gate', '<id> approve|reject'],
+        ['run', '"<goal>" — Full autonomous orchestration'],
+        ['stream', '<id> — SSE event stream'],
+        ['cancel', '<id>'],
+    ],
+    '/products': [
+        ['list', '— Running product instances'],
+        ['catalog', '— Available products'],
+        ['deploy', '<type> — Deploy a product instance'],
+        ['status', '<id> — Instance status'],
+        ['destroy', '<id> — Remove an instance'],
+        ['failover', '<id> — Activate cloud failover'],
+    ],
+    '/prod': [
+        ['list', ''],
+        ['catalog', ''],
+        ['deploy', '<type>'],
+        ['status', '<id>'],
+        ['destroy', '<id>'],
+        ['failover', '<id>'],
+    ],
+    '/tool-scope': [
+        ['show', '— Current tool access config'],
+        ['allow', '<tool> — Allow a tool'],
+        ['deny', '<tool> — Deny a tool'],
+    ],
+    '/compose': [
+        ['interactive', '— Launch agent composer wizard'],
+    ],
+    '/monitor': [
+        ['all', '— All agent metrics'],
+    ],
+    '/docker': [
+        ['up', '[service] — Start containers'],
+        ['down', '[service] — Stop containers'],
+        ['status', '— Container status'],
+        ['build', '[service] — Build images'],
+        ['restart', '[service] — Restart containers'],
+        ['logs', '<service> — View logs'],
+        ['ps', '— List running containers'],
+    ],
+    '/dc': [
+        ['up', '[service]'],
+        ['down', '[service]'],
+        ['status', ''],
+        ['build', '[service]'],
+        ['restart', '[service]'],
+        ['logs', '<service>'],
+        ['ps', ''],
+    ],
+};
+// Flat list for tab completion
+export const SUBCOMMANDS = Object.fromEntries(Object.entries(SUBCOMMAND_DEFS).map(([cmd, defs]) => [cmd, defs.map(([name]) => name)]));
+export function completer(agents) {
+    return (line) => {
+        // Slash commands
+        if (line.startsWith('/')) {
+            // Subcommand completion: "/nb li" → "/nb list"
+            const spaceIdx = line.indexOf(' ');
+            if (spaceIdx > 0) {
+                const cmd = line.slice(0, spaceIdx);
+                const partial = line.slice(spaceIdx + 1);
+                const subs = SUBCOMMANDS[cmd];
+                if (subs) {
+                    const hits = subs
+                        .filter(s => s.startsWith(partial))
+                        .map(s => `${cmd} ${s}`);
+                    return [hits.length ? hits : subs.map(s => `${cmd} ${s}`), line];
+                }
+                return [[], line];
+            }
+            const hits = COMMAND_NAMES.filter(c => c.startsWith(line));
+            return [hits.length ? hits : COMMAND_NAMES, line];
+        }
+        // @agent mentions and @strategy directives
+        if (line.startsWith('@')) {
+            const partial = line.slice(1).toLowerCase();
+            // Strategy directives first, then agents
+            const directiveHits = STRATEGY_DIRECTIVES
+                .filter(d => d.trigger.startsWith(partial))
+                .map(d => `@${d.trigger} `);
+            const agentHits = agents
+                .filter(a => a.toLowerCase().startsWith(partial))
+                .map(a => `@${a} `);
+            const allHits = [...directiveHits, ...agentHits];
+            if (allHits.length)
+                return [allHits, line];
+            // No matches — show everything
+            const allOptions = [
+                ...STRATEGY_DIRECTIVES.map(d => `@${d.trigger} `),
+                ...agents.map(a => `@${a} `),
+            ];
+            return [allOptions, line];
+        }
+        // !shell escape hints
+        if (line.startsWith('!')) {
+            const hits = SHELL_HINTS.filter(h => h.startsWith(line));
+            return [hits.length ? hits : SHELL_HINTS, line];
+        }
+        return [[], line];
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,23 @@
+import { type AuthUser } from './auth.js';
+export type BackendType = 'genesis' | 'adk' | 'unknown';
+export interface ShellConfig {
+    genesisUrl: string;
+    defaultAgent: string;
+    sessionId: string;
+    historyFile: string;
+    model?: string;
+    identityUrl: string;
+    authToken: string | null;
+    authUser: AuthUser | null;
+    /** Detected backend type — set after first health probe. */
+    backendType: BackendType;
+    /** Backend display name (e.g. agent name from ADK, "Genesis" for full stack). */
+    backendName: string;
+    /** CLI-level overrides (--will, --effort, --safety, --private, --image). */
+    effort?: number;
+    safetyLevel?: string;
+    privateMode?: boolean;
+    /** Base64 data URL image attachments from --image flag. */
+    imageAttachments?: string[];
+}
+export declare function loadConfig(): ShellConfig;

package/dist/config.js

@@ -0,0 +1,48 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { getActiveToken, getActiveUser, ensureRootProfile } from './auth.js';
+export function loadConfig() {
+    const home = homedir();
+    const configDir = join(home, '.aither');
+    const configFile = join(configDir, 'shell.yaml');
+    let fileConfig = {};
+    if (existsSync(configFile)) {
+        try {
+            const content = readFileSync(configFile, 'utf-8');
+            for (const line of content.split('\n')) {
+                const match = line.match(/^(\w+):\s*(.+)$/);
+                if (match)
+                    fileConfig[match[1]] = match[2].trim().replace(/^["']|["']$/g, '');
+            }
+        }
+        catch { /* ignore bad config */ }
+    }
+    // Load auth from shared ~/.aither/auth.json
+    // If no session exists, auto-provision root (like Linux console login)
+    let authToken = getActiveToken();
+    if (!authToken) {
+        ensureRootProfile();
+        authToken = getActiveToken();
+    }
+    const authUser = getActiveUser();
+    // AITHER_API_URL is the canonical env var; AITHER_GENESIS_URL is legacy alias
+    const apiUrl = process.env.AITHER_API_URL
+        || process.env.AITHER_GENESIS_URL
+        || fileConfig.api_url
+        || fileConfig.genesis_url
+        || 'http://127.0.0.1:8001';
+    return {
+        genesisUrl: apiUrl,
+        defaultAgent: process.env.AITHER_AGENT || fileConfig.default_agent || 'aither',
+        sessionId: randomUUID(),
+        historyFile: join(configDir, 'shell_history'),
+        model: process.env.AITHER_MODEL || fileConfig.model || undefined,
+        identityUrl: process.env.AITHER_IDENTITY_URL || fileConfig.identity_url || 'http://127.0.0.1:8115',
+        authToken,
+        authUser,
+        backendType: 'unknown',
+        backendName: '',
+    };
+}

package/dist/gargbot.d.ts

@@ -0,0 +1,11 @@
+/**
+ * GargBot CLI commands — chat, ingest, search, status, and Obsidian sync.
+ *
+ * Usage:
+ *   aither gargbot chat "What projects did we do in Texas?"
+ *   aither gargbot ingest ./resumes/john_doe.pdf
+ *   aither gargbot search "bridge engineers with PE"
+ *   aither gargbot status
+ *   aither gargbot sync-obsidian /path/to/vault
+ */
+export declare function handleGargbotCommand(args: string[]): Promise<void>;