@kinqs/brainrouter-cli 0.3.4

package/dist/cli/commands/orchestration.js

@@ -0,0 +1,218 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import chalk from 'chalk';
+import { childSessionKey } from '../../runtime/mcpUtils.js';
+import { listRoles } from '../../orchestration/roles.js';
+import { formatSessionSummary, getSession, listSessions, reconcileStale } from '../../orchestration/orchestrator.js';
+import { readPreferences, writePreferences } from '../../state/preferencesStore.js';
+import { readTranscriptEntries } from '../../state/sessionStore.js';
+import { getLoopState, stopLoop } from '../../runtime/loopRunner.js';
+import { formatTranscriptContent } from './_helpers.js';
+export async function tryHandleOrchestrationCommand(ctx) {
+    const { command, args, agent, mcpClient, config, rl, repl } = ctx;
+    // 'ctx' alias to keep references to the old ReplContext name working
+    const replCtx = repl;
+    switch (command) {
+        case '/roles':
+            {
+                console.log(chalk.bold('\nAvailable Agent Roles:'));
+                for (const r of listRoles()) {
+                    console.log(`  ${chalk.cyan(r.name)} (${chalk.gray(r.defaultAccess)}) - ${r.description}`);
+                }
+                console.log();
+                return true;
+            }
+        case '/agents':
+            {
+                reconcileStale(agent.workspaceRoot);
+                const sessions = listSessions(agent.workspaceRoot);
+                // `--json` for scripting. Emits a single JSON line on stdout so
+                // tmux-resurrect, status bars, agent pickers, and pipelines can
+                // parse the live session list reliably.
+                if (args.includes('--json')) {
+                    const payload = sessions.map((s) => ({
+                        id: s.id,
+                        role: s.role,
+                        status: s.status,
+                        label: s.label,
+                        startedAt: s.startedAt,
+                        updatedAt: s.updatedAt,
+                        completedAt: s.completedAt,
+                        prompt: s.prompt,
+                        usage: s.usage,
+                        parentSessionKey: s.parentSessionKey,
+                        finalOutputPreview: s.finalOutput ? String(s.finalOutput).slice(0, 280) : undefined,
+                    }));
+                    // process.stdout.write with no chalk so jq / scripts get clean JSON.
+                    process.stdout.write(JSON.stringify({ sessions: payload }) + '\n');
+                    return true;
+                }
+                console.log(chalk.bold('\nChild Agent Sessions:'));
+                if (sessions.length === 0) {
+                    console.log(chalk.yellow('  No child agents yet. Use /spawn <role> <prompt> to start one.'));
+                }
+                else {
+                    for (const s of sessions) {
+                        const colorFn = s.status === 'completed' ? chalk.green :
+                            s.status === 'failed' ? chalk.red :
+                                s.status === 'stale' ? chalk.yellow :
+                                    s.status === 'closed' ? chalk.gray : chalk.cyan;
+                        console.log(`  ${colorFn(formatSessionSummary(s))}`);
+                        if (s.usage) {
+                            console.log(chalk.gray(`      tokens: ${s.usage.promptTokens.toLocaleString()}↑ ${s.usage.completionTokens.toLocaleString()}↓ across ${s.usage.calls} call${s.usage.calls === 1 ? '' : 's'} (${s.usage.turns} turn${s.usage.turns === 1 ? '' : 's'})`));
+                        }
+                        if (s.prompt) {
+                            console.log(chalk.gray(`      prompt: ${s.prompt.replace(/\s+/g, ' ').slice(0, 100)}${s.prompt.length > 100 ? '…' : ''}`));
+                        }
+                    }
+                    console.log(chalk.gray('\n  (pipe-friendly output: /agents --json)'));
+                }
+                console.log();
+                return true;
+            }
+        case '/agent':
+            {
+                const id = args[0];
+                if (!id) {
+                    console.log(chalk.red('\nUsage: /agent <id> [--full]\n'));
+                    break;
+                }
+                const full = args.includes('--full');
+                const s = getSession(agent.workspaceRoot, id);
+                if (!s) {
+                    console.log(chalk.red(`\nNo session ${id}\n`));
+                    break;
+                }
+                console.log(chalk.bold(`\nAgent ${s.id}`));
+                console.log(`  Role:    ${chalk.cyan(s.role)} (${s.access})`);
+                console.log(`  Status:  ${chalk.yellow(s.status)}`);
+                console.log(`  Started: ${chalk.gray(s.startedAt)}`);
+                if (s.completedAt)
+                    console.log(`  Ended:   ${chalk.gray(s.completedAt)}`);
+                if (s.label)
+                    console.log(`  Label:   ${s.label}`);
+                console.log(`  Prompt:  ${chalk.gray(s.prompt.slice(0, 240))}`);
+                if (s.usage) {
+                    console.log(`  Tokens:  ${chalk.cyan(s.usage.promptTokens.toLocaleString())}↑  ${chalk.cyan(s.usage.completionTokens.toLocaleString())}↓  ${chalk.gray(`(${s.usage.calls} LLM call${s.usage.calls === 1 ? '' : 's'}, ${s.usage.turns} turn${s.usage.turns === 1 ? '' : 's'})`)}`);
+                }
+                if (s.finalOutput)
+                    console.log(`\n${chalk.bold('Final output:')}\n${s.finalOutput}`);
+                if (s.error)
+                    console.log(`\n${chalk.red('Error:')} ${s.error}`);
+                const entries = readTranscriptEntries(agent.workspaceRoot, childSessionKey(s.parentSessionKey, s.id), full ? 1000 : 10);
+                if (entries.length > 0) {
+                    console.log(chalk.bold(`\n${full ? 'Full' : 'Recent'} transcript (${entries.length} entries):`));
+                    for (const e of entries) {
+                        const text = formatTranscriptContent(e.content ?? e.tool_calls ?? '');
+                        const roleColor = e.role === 'user' ? chalk.yellow : e.role === 'assistant' ? chalk.green : e.role === 'tool' ? chalk.magenta : chalk.cyan;
+                        console.log(`  ${chalk.gray(e.timestamp)} ${roleColor(e.role)} ${chalk.gray(text)}`);
+                    }
+                    if (!full && entries.length === 10) {
+                        console.log(chalk.gray(`\n  (use /agent ${id} --full to see all entries)`));
+                    }
+                }
+                console.log();
+                return true;
+            }
+        case '/spawn':
+            {
+                const role = args[0];
+                const prompt = args.slice(1).join(' ').trim();
+                if (!role || !prompt) {
+                    console.log(chalk.red('\nUsage: /spawn <role> <prompt>\n'));
+                    return true;
+                }
+                // Validate the role upfront — saves an LLM round-trip that would just
+                // error out server-side anyway.
+                const validRoles = listRoles().map((r) => r.name);
+                if (!validRoles.includes(role)) {
+                    console.log(chalk.red(`\nUnknown role "${role}". Available: ${validRoles.join(', ')}.\n`));
+                    return true;
+                }
+                ctx.repl.runAgentTurn(`Use the spawn_agent tool to start a ${role} child agent with this prompt:\n\n${prompt}\n\nReturn the child agent id when done.`);
+                return true;
+            }
+        case '/wait':
+            {
+                const id = args[0];
+                const ms = args[1] ? Number(args[1]) : 120000;
+                if (!id) {
+                    console.log(chalk.red('\nUsage: /wait <id> [timeoutMs]\n'));
+                    break;
+                }
+                ctx.repl.runAgentTurn(`Use the wait_agent tool with id="${id}" and timeoutMs=${ms}. Then summarize the child output for me.`);
+                return true;
+            }
+        case '/auto-review':
+            {
+                const prefs = readPreferences(agent.workspaceRoot);
+                const arg = args[0];
+                if (!arg) {
+                    console.log(chalk.bold(`\nAuto-review: ${prefs.autoReview ? chalk.green('on') : chalk.gray('off')}`));
+                    console.log(chalk.gray('  When on, every worker child agent is auto-followed by a reviewer agent on its diff.'));
+                    console.log(chalk.gray('  Toggle with: /auto-review on | off\n'));
+                    return true;
+                }
+                const next = arg === 'on' || arg === 'true';
+                writePreferences(agent.workspaceRoot, { autoReview: next });
+                console.log(chalk.green(`\n✓ Auto-review ${next ? 'enabled' : 'disabled'}.\n`));
+                return true;
+            }
+        case '/kill':
+            {
+                const id = args[0];
+                if (!id) {
+                    console.log(chalk.red('\nUsage: /kill <agent-id>\n'));
+                    break;
+                }
+                const session = getSession(agent.workspaceRoot, id);
+                if (!session) {
+                    console.log(chalk.red(`\nNo agent session with id "${id}".\n`));
+                    break;
+                }
+                if (session.status !== 'pending' && session.status !== 'running') {
+                    console.log(chalk.gray(`\nAgent ${id} is already ${session.status}.\n`));
+                    return true;
+                }
+                ctx.repl.runAgentTurn(`Use the close_agent tool with id="${id}" and reason="user-requested kill". Then confirm the close result.`);
+                return true;
+            }
+        case '/ps':
+            {
+                const loopState = getLoopState();
+                console.log(chalk.bold('\nBackground tasks'));
+                if (!loopState) {
+                    console.log(chalk.gray('  No /loop running.'));
+                }
+                else {
+                    console.log(`  Loop: ${chalk.cyan(loopState.prompt)} (${loopState.iterations} ticks, every ${loopState.intervalMs}ms)`);
+                }
+                reconcileStale(agent.workspaceRoot);
+                const sessions = listSessions(agent.workspaceRoot).filter((s) => s.status === 'pending' || s.status === 'running');
+                if (sessions.length === 0) {
+                    console.log(chalk.gray('  No running child agents.'));
+                }
+                else {
+                    for (const s of sessions) {
+                        console.log(`  Agent: ${chalk.cyan(s.id)} ${chalk.gray(s.role)} (${s.status})`);
+                    }
+                }
+                console.log();
+                return true;
+            }
+        case '/stop':
+            {
+                // Stop the loop AND mark any running children stale.
+                const stopped = stopLoop();
+                console.log(stopped ? chalk.green('\n✓ Stopped /loop.') : chalk.gray('\nNo loop was running.'));
+                const reconciled = reconcileStale(agent.workspaceRoot);
+                if (reconciled > 0)
+                    console.log(chalk.yellow(`Marked ${reconciled} child session(s) stale.`));
+                console.log();
+                return true;
+            }
+    }
+    return false;
+}

package/dist/cli/commands/session.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleSessionCommand(ctx: CommandContext): Promise<boolean>;

package/dist/cli/commands/session.js

@@ -0,0 +1,191 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import { randomUUID } from 'node:crypto';
+import chalk from 'chalk';
+import ora from 'ora';
+import { marked } from 'marked';
+import { listTranscripts, loadTranscript } from '../../state/sessionStore.js';
+import { readGoal, resumeGoal } from '../../state/goalStore.js';
+import { askYesNo } from '../cliPrompt.js';
+import { buildGoalKickoffPrompt } from './_helpers.js';
+export async function tryHandleSessionCommand(ctx) {
+    const { command, args, agent, mcpClient, config, rl, repl } = ctx;
+    // 'ctx' alias to keep references to the old ReplContext name working
+    const replCtx = repl;
+    switch (command) {
+        case '/sessions':
+            {
+                const transcripts = listTranscripts(agent.workspaceRoot);
+                console.log(chalk.bold('\nPersisted sessions:'));
+                if (transcripts.length === 0) {
+                    console.log(chalk.yellow('  (none — start chatting and your transcript will appear here)'));
+                }
+                else {
+                    for (const t of transcripts.slice(0, 30)) {
+                        const when = t.modifiedAt.replace('T', ' ').slice(0, 19);
+                        const isCurrent = t.sessionKey === agent.sessionKey;
+                        const tag = isCurrent ? chalk.green(' (current)') : '';
+                        console.log(`  ${chalk.cyan(t.sessionKey)}${tag}`);
+                        console.log(`    ${chalk.gray(`${t.turnCount} entries · ${when}`)}`);
+                        if (t.firstUserMessage)
+                            console.log(`    ${chalk.gray(`"${t.firstUserMessage}"`)}`);
+                    }
+                    console.log(chalk.gray('\nResume one with: /resume <sessionKey>'));
+                }
+                console.log();
+                return true;
+            }
+        case '/resume':
+            {
+                const sessionKey = args.join(' ').trim();
+                if (!sessionKey) {
+                    console.log(chalk.red('\nUsage: /resume <sessionKey>\n'));
+                    console.log(chalk.gray('Tip: copy a sessionKey from /sessions.\n'));
+                    return true;
+                }
+                const entries = loadTranscript(agent.workspaceRoot, sessionKey);
+                if (entries.length === 0) {
+                    console.log(chalk.red(`\nNo transcript found for "${sessionKey}".\n`));
+                    return true;
+                }
+                agent.sessionKey = sessionKey;
+                const loaded = agent.loadHistory(entries);
+                console.log(chalk.green(`\n✓ Resumed session ${chalk.cyan(sessionKey)} with ${loaded} prior messages.`));
+                // If the resumed session has a goal that was suspended (paused,
+                // blocked, or hit usage limit), prompt the user whether to resume it
+                // now. Without this prompt the loop silently stays paused and the
+                // user has to remember to `/goal resume` — easy to miss.
+                const resumedGoal = readGoal(agent.workspaceRoot, sessionKey);
+                if (resumedGoal &&
+                    (resumedGoal.status === 'paused' ||
+                        resumedGoal.status === 'blocked' ||
+                        resumedGoal.status === 'usage_limited')) {
+                    const label = resumedGoal.status.replace('_', ' ');
+                    console.log(chalk.yellow(`\n⏸  This session has a ${label} goal:`));
+                    console.log(`     ${chalk.cyan(resumedGoal.text)}`);
+                    console.log(`     ${chalk.gray(`${resumedGoal.budget.iterationsUsed}/${resumedGoal.budget.maxIterations} iterations used`)}${resumedGoal.blockedReason ? chalk.gray(` · ${resumedGoal.blockedReason}`) : ''}`);
+                    const resume = await askYesNo('Resume the goal and continue auto-iteration? (y/N) ', false);
+                    if (resume) {
+                        // If the goal hit a budget cap, the user probably also wants to
+                        // raise it — but don't force the question; they can /goal budget
+                        // before/after. Just unpause and kick off the next iteration.
+                        const reactivated = resumeGoal(agent.workspaceRoot, sessionKey);
+                        if (reactivated) {
+                            // Same rationale as /goal resume — drop any stale wrap-up
+                            // steering left over from the budget-trigger that paused us.
+                            agent.removeTaggedSystemMessage('goal-budget-steering');
+                            agent.refreshSystemPrompt();
+                            console.log(chalk.green(`\n▶  Goal resumed (${reactivated.budget.iterationsUsed}/${reactivated.budget.maxIterations} used). Starting next iteration…\n`));
+                            ctx.repl.runAgentTurn(buildGoalKickoffPrompt(reactivated, 'resume'));
+                            return true; // runAgentTurn owns its prompt cycle
+                        }
+                    }
+                    else {
+                        console.log(chalk.gray(`\nGoal stays ${label}. Run /goal resume later to continue.\n`));
+                    }
+                }
+                else {
+                    console.log(chalk.gray('Your next message will continue the conversation.\n'));
+                }
+                return true;
+            }
+        case '/fork':
+            {
+                const label = args.join(' ').trim() || `fork-${new Date().toISOString().slice(11, 19)}`;
+                const newKey = `${agent.sessionKey}:fork:${randomUUID().slice(0, 8)}:${label.replace(/[^A-Za-z0-9._-]+/g, '-')}`;
+                const previous = agent.sessionKey;
+                agent.fork(newKey);
+                console.log(chalk.green(`\n✓ Forked session.`));
+                console.log(chalk.gray(`  Parent : ${previous}`));
+                console.log(chalk.gray(`  New    : ${newKey}`));
+                console.log(chalk.gray('  Your next message starts a new transcript while keeping prior context.\n'));
+                return true;
+            }
+        case '/rename':
+            {
+                const newName = args.join(' ').trim();
+                if (!newName) {
+                    console.log(chalk.red('\nUsage: /rename <new session label>\n'));
+                    return true;
+                }
+                const safe = newName.replace(/[^A-Za-z0-9._-]+/g, '-');
+                const previous = agent.sessionKey;
+                const newKey = `${previous.split(':')[0]}:${safe}`;
+                agent.sessionKey = newKey;
+                agent.refreshSystemPrompt();
+                console.log(chalk.green(`\n✓ Session renamed`));
+                console.log(chalk.gray(`  Old: ${previous}`));
+                console.log(chalk.gray(`  New: ${newKey}`));
+                console.log(chalk.gray('  (Future transcript entries land under the new key; existing entries stay under the old.)\n'));
+                return true;
+            }
+        case '/compact':
+            {
+                const spinner = ora(chalk.gray('Summarizing conversation for compaction...')).start();
+                try {
+                    const result = await agent.compactHistory();
+                    if (!result) {
+                        spinner.warn(chalk.yellow('Nothing to compact — chat history is already short.'));
+                        return true;
+                    }
+                    spinner.succeed(chalk.green(`Compacted ${result.replacedMessages} messages → ~${result.estimatedTokens} tokens (${result.durationMs}ms).`));
+                    console.log(chalk.bold('\nCompaction summary:'));
+                    console.log(marked.parse(result.summary));
+                    console.log(chalk.gray('The summary is now part of system context. Continue normally.\n'));
+                }
+                catch (err) {
+                    spinner.fail(chalk.red(`Compaction failed: ${err.message}`));
+                    console.log(chalk.gray('Fallback: nothing was changed. Use /clear if you want to drop history without summarizing.\n'));
+                }
+                return true;
+            }
+        case '/new':
+            {
+                const label = args.join(' ').trim() || `new-${new Date().toISOString().slice(11, 19)}`;
+                const newKey = `${agent.sessionKey.split(':')[0]}:${label.replace(/[^A-Za-z0-9._-]+/g, '-')}`;
+                const previous = agent.sessionKey;
+                agent.sessionKey = newKey;
+                agent.clearHistory();
+                console.log(chalk.green(`\n✓ Started a new chat.`));
+                console.log(chalk.gray(`  Old: ${previous}`));
+                console.log(chalk.gray(`  New: ${newKey}\n`));
+                return true;
+            }
+        case '/side':
+        case '/btw':
+            {
+                const prompt = args.join(' ').trim();
+                if (!prompt) {
+                    console.log(chalk.red(`\nUsage: ${command} <ephemeral side question>\n`));
+                    console.log(chalk.gray('  Side conversations run in a forked chat history and discard the result on exit.\n'));
+                    return true;
+                }
+                const original = agent.sessionKey;
+                const sideKey = `${original}:side:${randomUUID().slice(0, 6)}`;
+                agent.sessionKey = sideKey;
+                console.log(chalk.gray(`(side conversation in ${sideKey} — answer is ephemeral)\n`));
+                // Fire-and-forget BUT restore the sessionKey when the turn finishes,
+                // not after a fixed 100ms. The old setTimeout race restored the key
+                // long before the turn finished its async work — capture, transcript
+                // writes, contradiction checks — so side-conversation tool messages
+                // and the assistant reply ended up appended to the MAIN session.
+                void ctx.repl.runAgentTurnAsync(prompt).finally(() => {
+                    agent.sessionKey = original;
+                });
+                return true;
+            }
+        case '/clear': {
+            agent.clearHistory();
+            console.log(chalk.yellow('\nConversation history cleared.\n'));
+            return true;
+        }
+        case '/quit':
+        case '/exit': {
+            rl.close();
+            return true;
+        }
+    }
+    return false;
+}

package/dist/cli/commands/ui.d.ts

@@ -0,0 +1,6 @@
+/**
+ * AUTO-EXTRACTED from cli/repl.ts as part of the slash-command split.
+ * Hand-tune imports if the compiler complains.
+ */
+import type { CommandContext } from './_context.js';
+export declare function tryHandleUiCommand(ctx: CommandContext): Promise<boolean>;