@aitherium/shell-cli 1.1.0 → 1.11.1

package/dist/repl.js

@@ -17,12 +17,16 @@ import { existsSync, readFileSync, appendFileSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import chalk from 'chalk';
 import { search, Separator } from '@inquirer/prompts';
+import { setActiveConfig } from './config.js';
+import { RelayClient, resolveRelayUrl } from './relay.js';
 import { createStreamRenderer, SteeringBar } from './renderer.js';
-import { getCommand, getCommandNames } from './commands.js';
+import { getCommand, getCommandNames, invokeMcpTool } from './commands.js';
 import { getCommandRegistry } from './command-registry.js';
 import { loadAgentNames, resolveAgentMention, completer, refreshCommandCompletions, SUBCOMMAND_DEFS } from './completions.js';
+import { collectArgs } from './interactive.js';
 import { setJobNotifier, listJobs, getJob, cancelJob, runningCount, launchChatJob, launchForgeJob, launchSwarmJob, formatJobLine, formatJobOutput, } from './jobs.js';
-import { configureRemoteSync, syncSessionToRemote } from './session-store.js';
+import { configureRemoteSync, recordTurn, loadSession, buildContextSummary } from './session-store.js';
+import { setCurrentCommand, withCrashReporting } from './crash-reporter.js';
 /** Commands that are long-running and auto-background. */
 const AUTO_BG_COMMANDS = new Set(['forge', 'swarm']);
 /** Post session profile to Strata for observability (best-effort). */
@@ -47,12 +51,33 @@ async function postToStrata(client, profile) {
     });
 }
 export async function startRepl(client, config) {
+    // Publish config process-wide so deep helpers (MCP tool routing) can resolve
+    // mcpUrl/authToken without threading config through every call site.
+    setActiveConfig(config);
+    // ── Blessed multi-pane TUI is the DEFAULT (opt OUT with AITHER_TUI=0) ──
+    // Seamless answer pane (left) + collapsible per-turn trace threads (right), so
+    // pipeline telemetry no longer interleaves with the streamed answer. Falls back
+    // to the native-readline shell below on non-TTY, when AITHER_TUI=0, or if the
+    // blessed surface fails to initialise on this terminal.
+    const _tuiEnv = (process.env.AITHER_TUI || '').toLowerCase();
+    const _tuiOff = ['0', 'false', 'off', 'no'].includes(_tuiEnv);
+    if (process.stdout.isTTY && process.stdin.isTTY && !_tuiOff) {
+        try {
+            const { startTuiRepl } = await import('./tui/repl-tui.js');
+            await startTuiRepl(client, config);
+            return;
+        }
+        catch (err) {
+            console.error(chalk.yellow(`  TUI unavailable (${err?.message || err}) — using classic shell.`));
+            // fall through to the readline REPL
+        }
+    }
     // Enable cross-client session sync (local CLI ↔ tunnel.aitherium.com)
     configureRemoteSync(config.genesisUrl, config.authToken);
     const agents = await loadAgentNames(client);
     // Auto-discover commands from Genesis (MCP tools, ADK groups, tagged endpoints)
     const registry = getCommandRegistry();
-    const dynamicCount = await registry.loadDynamicCommands(client);
+    const dynamicCount = await registry.loadDynamicCommands(client, config);
     if (dynamicCount > 0) {
         refreshCommandCompletions();
     }
@@ -97,10 +122,92 @@ export async function startRepl(client, config) {
     let closed = false;
     let lastShellCmd = '';
     let menuActive = false;
+    // ── Relay (native group chat) — linear readline variant of the TUI mode ──
+    let relayRl = null;
+    function relayPrint(line) {
+        // Print above the prompt without mangling the user's in-progress input.
+        process.stdout.write('\r\x1b[K' + line + '\n');
+        try {
+            rl.prompt(true);
+        }
+        catch { /* */ }
+    }
+    function relayFmt(m) {
+        const who = m.agent ? chalk.magenta('@' + m.nick) : chalk.cyan(m.nick);
+        return `  ${who}: ${m.content}`;
+    }
+    async function startRelayReadline(arg) {
+        const a = arg.trim();
+        const sub = a.split(/\s+/)[0]?.toLowerCase() || '';
+        if (relayRl) {
+            if (sub === 'leave' || sub === 'exit' || sub === 'quit') {
+                leaveRelayReadline();
+                return;
+            }
+            if (sub === 'join' && a.split(/\s+/)[1]) {
+                relayRl.join(a.split(/\s+/)[1]);
+                return;
+            }
+            if (sub === 'channels') {
+                const cs = await relayRl.listChannels(a.split(/\s+/)[1] || 'platform');
+                console.log(chalk.bold('  Channels: ') + chalk.dim(cs.map(c => c.name).join('  ')));
+                return;
+            }
+            if (sub === 'who') {
+                console.log(chalk.dim('  (roster updates print on join/part)'));
+                return;
+            }
+            if (a.startsWith('#')) {
+                relayRl.join(a);
+                return;
+            }
+            console.log(chalk.dim('  In relay: type to chat · /relay join #x · /relay channels · /leave'));
+            return;
+        }
+        const nick = config.authUser?.username || config.authUser?.display_name || `dev_${Math.floor(Math.random() * 9000 + 1000)}`;
+        const client = new RelayClient({
+            url: resolveRelayUrl(), token: config.authToken || undefined, nick,
+            handlers: {
+                onStatus: (s) => { if (s !== 'open')
+                    relayPrint(chalk.dim(`  📡 relay: ${s}`)); },
+                onHistory: (ch, msgs) => { relayPrint(chalk.dim(`── ${ch} — last ${msgs.length} ──`)); for (const m of msgs)
+                    relayPrint(relayFmt(m)); },
+                onMessage: (m) => relayPrint(relayFmt(m)),
+                onJoin: (n, _ch, isAgent) => relayPrint(chalk.dim(`  → ${isAgent ? '@' : ''}${n} joined`)),
+                onPart: (n) => relayPrint(chalk.dim(`  ← ${n} left`)),
+                onUserlist: (ch, users) => relayPrint(chalk.dim(`  ${ch}: ${users.length} here (${users.filter(u => u.is_agent).length} agents)`)),
+                onError: (msg) => relayPrint(chalk.red(`  relay: ${msg}`)),
+            },
+        });
+        const channel = a.startsWith('#') ? a : '#general';
+        relayRl = client;
+        console.log(chalk.green(`  📡 Joining ${channel} as ${nick}…  (type to chat · /relay join #x · /leave)`));
+        client.connect(channel);
+    }
+    function leaveRelayReadline() {
+        if (!relayRl)
+            return;
+        try {
+            relayRl.part();
+        }
+        catch { /* */ }
+        relayRl.disconnect();
+        relayRl = null;
+        console.log(chalk.dim('  📡 Left relay — back to agent chat.'));
+    }
     /** Pending clarification gate from the last plan response. */
     let pendingGate = null;
     /** Last session profile for RLM context injection across turns. */
     let lastSessionProfile = null;
+    /** Seeded conversation summary when launched with --continue/--resume. */
+    let seededContext = null;
+    if (config.resumed) {
+        const _entry = loadSession(config.sessionId);
+        if (_entry?.messages.length) {
+            seededContext = buildContextSummary(_entry.messages);
+            console.log(chalk.green(`  ↩ Resumed session ${config.sessionId.slice(0, 8)} (${_entry.messages.length} messages)`));
+        }
+    }
     /** Build prompt with running job count and GPU status. */
     function buildPrompt() {
         const running = runningCount();
@@ -223,6 +330,18 @@ export async function startRepl(client, config) {
         console.log(chalk.dim('  Not logged in. Use /login to authenticate.'));
     }
     console.log(chalk.dim('  /  commands   !  shell   @  directives/agents   &  background   ?  help'));
+    // ── Featured pack tip (rotates daily) ──
+    const TIPS = [
+        { text: '47 packs available', cmd: '/explore', icon: '📦' },
+        { text: 'Grid: distributed inference across your machines', cmd: '/grid', icon: '🔗' },
+        { text: 'Try @demiurge for code review', cmd: '/agents', icon: '🤖' },
+        { text: 'Browse the marketplace', cmd: '/explore', icon: '🏪' },
+        { text: 'Sync config across machines', cmd: '/grid sync', icon: '☁️' },
+        { text: 'portal.aitherium.com — manage workspace', cmd: '/login', icon: '🌐' },
+    ];
+    const tipIdx = Math.floor(Date.now() / 86400000) % TIPS.length;
+    const tip = TIPS[tipIdx];
+    console.log(chalk.dim(`  ${tip.icon} ${tip.text} — ${chalk.cyan(tip.cmd)}`));
     console.log();
     // ── Register shell session with Genesis (best effort) ──
     const _sessionRegistered = client.post('/shell/session/start', {
@@ -306,9 +425,13 @@ export async function startRepl(client, config) {
                 drainQueue();
                 return;
             }
-            // If the command has subcommands, show a second picker
+            // If the command has subcommands, show a second picker. Skip single-entry
+            // tables whose name is a positional placeholder (<x>/[x]/"x") — there's no
+            // real subcommand to pick; fall through to execute `/selected`, which
+            // processLine then collects arguments for interactively.
             const subDefs = SUBCOMMAND_DEFS['/' + selected];
-            if (subDefs && subDefs.length > 0) {
+            const isPlaceholderOnly = subDefs?.length === 1 && /^["<[]/.test(subDefs[0][0]);
+            if (subDefs && subDefs.length > 0 && !isPlaceholderOnly) {
                 let subSelected;
                 let subSearchInput = '';
                 try {
@@ -482,6 +605,15 @@ export async function startRepl(client, config) {
                 handleJobsCommand(cmdArgs);
                 return;
             }
+            // ── /relay — native group chat (humans + agents) ──
+            if (cmdName === 'relay') {
+                await startRelayReadline(cmdArgs);
+                return;
+            }
+            if ((cmdName === 'leave' || cmdName === 'unrelay') && relayRl) {
+                leaveRelayReadline();
+                return;
+            }
             // Bare "/" via Enter — launch picker as fallback
             if (!cmdName) {
                 if (process.stdin.isTTY && !menuActive) {
@@ -528,7 +660,25 @@ export async function startRepl(client, config) {
                     if (process.stdin.isTTY)
                         process.stdin.setRawMode(false);
                     process.stdin.resume();
-                    await cmd.handler(client, cmdArgs, config);
+                    // Bare invocation of a command with a subcommand table → collect its
+                    // arguments interactively (stdin is already detached above, so
+                    // @inquirer owns the keystrokes). Cancelling aborts the command.
+                    let finalArgs = cmdArgs;
+                    let cancelled = false;
+                    const subDefs = SUBCOMMAND_DEFS['/' + cmdName];
+                    if (!cmdArgs && subDefs?.length) {
+                        const collected = await collectArgs(cmdName, subDefs);
+                        if (collected === null) {
+                            cancelled = true;
+                            console.log(chalk.dim('  (cancelled)'));
+                        }
+                        else
+                            finalArgs = collected;
+                    }
+                    if (!cancelled) {
+                        setCurrentCommand(`/${cmdName} ${finalArgs}`.trim());
+                        await cmd.handler(client, finalArgs, config);
+                    }
                     // Reattach readline's listeners
                     process.stdin.removeAllListeners('data');
                     process.stdin.removeAllListeners('keypress');
@@ -539,6 +689,11 @@ export async function startRepl(client, config) {
                 }
                 catch (err) {
                     console.log(chalk.red(`  Error: ${err.message}`));
+                    // Prompt user to send error report
+                    try {
+                        await withCrashReporting(async () => { throw err; }, `/${cmdName} ${cmdArgs}`.trim());
+                    }
+                    catch { /* already handled */ }
                 }
                 finally {
                     restoreReadline();
@@ -570,14 +725,17 @@ export async function startRepl(client, config) {
                             }
                         }
                         const spinner = (await import('ora')).default(`Calling ${cmdName}...`).start();
-                        const result = await client.post('/tools/call', {
-                            tool: cmdName,
-                            params,
-                        });
+                        // Routes to the remote MCP gateway (config.mcpUrl) when set, else
+                        // the chat backend's REST /tools/call.
+                        const output = await invokeMcpTool(client, cmdName, params);
                         spinner.stop();
-                        const output = result?.result || result?.output || result;
                         console.log(chalk.cyan(`  [MCP: ${cmdName}]`));
-                        console.log(typeof output === 'string' ? output : JSON.stringify(output, null, 2));
+                        if (output && typeof output === 'object' && 'error' in output) {
+                            console.log(chalk.red(`  MCP tool error: ${output.error}`));
+                        }
+                        else {
+                            console.log(typeof output === 'string' ? output : JSON.stringify(output, null, 2));
+                        }
                     }
                     catch (err) {
                         console.log(chalk.red(`  MCP tool error: ${err.message}`));
@@ -609,6 +767,11 @@ export async function startRepl(client, config) {
             console.log(chalk.yellow('  Usage: !command  (run in PowerShell 7)'));
             return;
         }
+        // ── Relay mode: plain input is a message to the channel (humans + agents) ──
+        if (relayRl) {
+            relayRl.send(cleanInput);
+            return;
+        }
         // @agent routing vs @strategy triggers
         // Strategy triggers (@think, @research, @debug, etc.) should be passed
         // through to Genesis as-is — the StrategyResolver detects them there.
@@ -701,17 +864,32 @@ export async function startRepl(client, config) {
         catch { /* don't block on health check failure */ }
         // Do NOT pause readline — user can type to steer the active session.
         // Lines entered during generation are routed to /chat/steer.
-        // The SteeringBar reserves the bottom terminal row for user input.
         activeAbort = new AbortController();
-        steeringBar.activate();
-        const renderer = createStreamRenderer(config.sessionId, message);
+        // The SteeringBar gives a fixed bottom input bar, but it does so with a
+        // DECSTBM scroll region that destroys native scrollback and EATS long output
+        // (the original bug). A fixed bar and terminal scrollback are fundamentally
+        // incompatible, so the bar is opt-in (AITHER_STEER=1). DEFAULT: the native
+        // readline prompt at the bottom + the renderer's transient ora spinner (which
+        // clears itself before each write) — scrollback works, output is never eaten,
+        // and steering still works (typing during generation is routed to /chat/steer).
+        const _useSteerBar = ['1', 'true', 'on', 'yes'].includes((process.env.AITHER_STEER || '').toLowerCase());
+        if (_useSteerBar) {
+            steeringBar.activate();
+            // Blank readline's prompt so it can't leave a duplicate behind the bar.
+            if (process.stdin.isTTY)
+                rl.setPrompt('');
+        }
+        const renderer = createStreamRenderer(config.sessionId, message, _useSteerBar ? steeringBar : undefined);
         // Build session context from previous turn for RLM continuity
         const prevCtx = lastSessionProfile ? {
             summary: `Previous prompt: "${lastSessionProfile.prompt.slice(0, 200)}" → ${lastSessionProfile.model}, ${lastSessionProfile.tool_calls.length} tools, ${lastSessionProfile.errors.length} errors`,
             tools_used: lastSessionProfile.tool_calls.map(t => t.name),
             model: lastSessionProfile.model,
             errors: lastSessionProfile.errors,
+        } : seededContext ? {
+            summary: seededContext, tools_used: [], model: config.model || '', errors: [],
         } : undefined;
+        seededContext = null; // consume once
         // If there's a pending clarification gate, auto-attach it so the
         // backend resolves the gate and refines the plan instead of starting
         // a brand new pipeline. The gate is consumed on use.
@@ -847,19 +1025,21 @@ export async function startRepl(client, config) {
         }
         finally {
             steeringBar.deactivate();
+            if (process.stdin.isTTY)
+                refreshPrompt(); // restore the green prompt
             renderer.finish();
             // Capture session profile for RLM and Strata
             lastSessionProfile = renderer.getSessionProfile();
             // Post to Strata (best-effort, non-blocking)
             postToStrata(client, lastSessionProfile).catch(() => { });
-            // Sync session to remote for cross-client resume
-            syncSessionToRemote({
-                sessionId: config.sessionId,
-                agent: lastSessionProfile.agent || 'aither',
-                messages: [{ role: 'user', content: lastSessionProfile.prompt, timestamp: new Date().toISOString() }],
-                createdAt: new Date().toISOString(),
-                updatedAt: new Date().toISOString(),
-            }).catch(() => { });
+            // Persist the full turn (user + assistant) locally + remote → /export, --continue.
+            try {
+                const _toks = lastSessionProfile.events.reduce((n, e) => n + ((e.type === 'llm_done' || e.type === 'llm_end') ? Number(e.data?.tokens_used || e.data?.tokens || 0) : 0), 0);
+                recordTurn(config.sessionId, lastSessionProfile.agent || 'aither', lastSessionProfile.prompt, renderer.getContent(), {
+                    model: lastSessionProfile.model, tools: lastSessionProfile.tool_calls.map(t => t.name), tokens: _toks,
+                });
+            }
+            catch { /* */ }
             activeAbort = null;
             if (!closed)
                 restoreReadline();
@@ -958,6 +1138,8 @@ export async function startRepl(client, config) {
     rl.on('SIGINT', () => {
         if (activeAbort) {
             steeringBar.deactivate();
+            if (process.stdin.isTTY)
+                refreshPrompt(); // restore the green prompt
             activeAbort.abort();
             activeAbort = null;
         }

package/dist/session-store.d.ts

@@ -3,14 +3,19 @@
  *
  * Sessions stored in ~/.aither/sessions/ as JSON.
  */
+export interface SessionMessage {
+    role: string;
+    content: string;
+    timestamp?: string;
+    /** Assistant-turn metadata (best-effort). */
+    model?: string;
+    tools?: string[];
+    tokens?: number;
+}
 export interface SessionEntry {
     sessionId: string;
     agent: string;
-    messages: Array<{
-        role: string;
-        content: string;
-        timestamp?: string;
-    }>;
+    messages: SessionMessage[];
     createdAt: string;
     updatedAt: string;
 }
@@ -23,6 +28,26 @@ export declare function listSessions(limit?: number): Array<{
     updatedAt: string;
 }>;
 export declare function deleteSession(id: string): boolean;
+export interface TurnMeta {
+    model?: string;
+    tools?: string[];
+    tokens?: number;
+}
+/**
+ * Append a completed chat turn (user + assistant) to the session transcript,
+ * persisting it locally AND pushing the FULL transcript to remote. This is what
+ * makes `--continue` / `--resume` / `/export` / `/chats` actually work — before
+ * this, only user prompts were synced and nothing was written locally.
+ */
+export declare function recordTurn(sessionId: string, agent: string, user: string, assistant: string, meta?: TurnMeta): SessionEntry;
+/** Most-recently-updated local session id (for `--continue`). */
+export declare function mostRecentSessionId(): string | null;
+/** A compact "conversation so far" string for the session_context channel. */
+export declare function buildContextSummary(messages: SessionMessage[], maxTurns?: number, maxChars?: number): string;
+/** Total recorded assistant tokens for a session. */
+export declare function sessionTokens(entry: SessionEntry): number;
+/** Render a transcript as Markdown (for /export). */
+export declare function transcriptMarkdown(entry: SessionEntry): string;
 export declare function configureRemoteSync(genesisUrl: string, authToken: string | null): void;
 export declare function syncSessionToRemote(session: SessionEntry): Promise<void>;
 export declare function loadRemoteSession(sessionId: string): Promise<SessionEntry | null>;

package/dist/session-store.js

@@ -66,6 +66,62 @@ export function deleteSession(id) {
     }
     return false;
 }
+/**
+ * Append a completed chat turn (user + assistant) to the session transcript,
+ * persisting it locally AND pushing the FULL transcript to remote. This is what
+ * makes `--continue` / `--resume` / `/export` / `/chats` actually work — before
+ * this, only user prompts were synced and nothing was written locally.
+ */
+export function recordTurn(sessionId, agent, user, assistant, meta = {}) {
+    const now = new Date().toISOString();
+    const entry = loadSession(sessionId)
+        || { sessionId, agent: agent || 'aither', messages: [], createdAt: now, updatedAt: now };
+    if (agent)
+        entry.agent = agent;
+    // Skip aborted/empty turns entirely — recording the user prompt without an
+    // assistant reply leaves a dangling question that poisons resume context.
+    if (!assistant || !assistant.trim())
+        return entry;
+    if (user)
+        entry.messages.push({ role: 'user', content: user, timestamp: now });
+    entry.messages.push({
+        role: 'assistant', content: assistant, timestamp: now,
+        model: meta.model, tools: meta.tools, tokens: meta.tokens,
+    });
+    saveSession(entry);
+    void syncSessionToRemote(entry).catch(() => { });
+    return entry;
+}
+/** Most-recently-updated local session id (for `--continue`). */
+export function mostRecentSessionId() {
+    const list = listSessions(1);
+    return list.length ? list[0].sessionId : null;
+}
+/** A compact "conversation so far" string for the session_context channel. */
+export function buildContextSummary(messages, maxTurns = 8, maxChars = 1800) {
+    const recent = messages.slice(-maxTurns * 2);
+    let s = recent.map(m => `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}`).join('\n');
+    if (s.length > maxChars)
+        s = '…' + s.slice(-maxChars);
+    return s;
+}
+/** Total recorded assistant tokens for a session. */
+export function sessionTokens(entry) {
+    return entry.messages.reduce((n, m) => n + (m.tokens || 0), 0);
+}
+/** Render a transcript as Markdown (for /export). */
+export function transcriptMarkdown(entry) {
+    const lines = [
+        `# AitherShell session ${entry.sessionId}`,
+        `Agent: ${entry.agent}  ·  ${entry.messages.length} messages  ·  ${entry.updatedAt}`,
+        '',
+    ];
+    for (const m of entry.messages) {
+        lines.push(m.role === 'user' ? `## You` : `## ${entry.agent}${m.model ? ` (${m.model})` : ''}`);
+        lines.push('', m.content, '');
+    }
+    return lines.join('\n');
+}
 // ── Remote Sync — push/pull sessions via Genesis /session/sync/* ─────
 let _genesisUrl = null;
 let _authToken = null;

package/dist/status-banner.d.ts

@@ -0,0 +1,59 @@
+/**
+ * status-banner.ts — Live fleet/backend status for the connect banner AND the
+ * in-TUI welcome header.
+ *
+ * The boxed connect banner (main.ts `showBanner`) prints to the normal terminal
+ * BEFORE the blessed alt-screen takes over, so inside the TUI it scrolls away and
+ * the user is left with a bare "AitherShell · url" header. `gatherStatus()` +
+ * `formatStatusLines()` let the TUI render the same live picture — services up,
+ * which backend (local vs Genesis/cloud), and the orchestrator + reasoning models
+ * actually loaded — right inside the output pane.
+ *
+ * The low-level probe/model helpers live here (rather than main.ts) so both the
+ * connect banner and the TUI share one implementation.
+ */
+import type { GenesisClient } from './client.js';
+import type { ShellConfig } from './config.js';
+/** Probe a health endpoint, tolerating http↔https and a single cold-start miss. */
+export declare function probeHealth(url: string, timeoutMs?: number): Promise<boolean>;
+/** Build the health-probe set from the configured endpoints. Remote endpoints
+ *  probe the public authenticated edges they actually use (gateway/identity/mcp)
+ *  instead of 127.0.0.1, which is unreachable from a real remote node. */
+export declare function buildProbes(config: ShellConfig): {
+    name: string;
+    url: string;
+}[];
+/** Pick the model the orchestrator path is actually serving + where, from the
+ *  MicroScheduler /llm/backends/snapshot. Prefers the local orchestrator vLLM
+ *  and the tuned LoRA (the live default), so the banner names the real model. */
+export declare function pickServingModel(backends: Record<string, any>): {
+    model: string;
+    where: string;
+} | null;
+export interface StatusInfo {
+    genesisHost: string;
+    online: boolean;
+    backendType: string;
+    backendName: string;
+    health?: string;
+    version?: string;
+    services?: number;
+    agents?: number;
+    serviceLines: {
+        name: string;
+        up: boolean;
+    }[];
+    orchestratorModel?: string;
+    reasoningModel?: string;
+    profile?: string;
+    isLocal?: boolean;
+    serving?: string;
+    poolFree?: number;
+    poolTotal?: number;
+}
+/** Gather a full live status snapshot. Every sub-fetch degrades to null/empty —
+ *  never throws — so a partial fleet still produces a useful banner. */
+export declare function gatherStatus(client: GenesisClient, config: ShellConfig): Promise<StatusInfo>;
+/** Compact, aligned status lines for the in-TUI welcome (plain strings with
+ *  chalk colour — caller pushes them through surface.outputLine). */
+export declare function formatStatusLines(info: StatusInfo): string[];