@hoangsonw/forge 0.1.0

package/dist/cli/repl.js

@@ -0,0 +1,1046 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRepl = void 0;
+/**
+ * Forge REPL — production-grade interactive shell.
+ *
+ * Composed of three collaborators:
+ *   • repl-input.ts      raw-mode line editor with ghost text + dropdown +
+ *                        status line
+ *   • repl-commands.ts   slash-command catalog + fuzzy ranker + semantic
+ *                        prompt shortcuts (/ask, /explain, /fix, …)
+ *   • this file          session state, routing, task execution, persistence
+ *
+ * Each turn flows:
+ *   input  →  slash dispatch OR semantic expansion OR bare text
+ *          →  orchestrateRun({ input, description = prior-turns + new })
+ *          →  result recorded in state.turns + persisted to JSONL
+ *          →  next prompt
+ *
+ * Multi-turn context lives in state.turns and is woven into the planner's
+ * `description` field so the agent sees the conversation so far.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+// eslint-disable-next-line @typescript-eslint/no-require-imports -- JSON import via require avoids assert syntax churn
+const pkg = require('../../package.json');
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const banners_1 = require("./banners");
+const ui_1 = require("./ui");
+const bootstrap_1 = require("./bootstrap");
+const logger_1 = require("../logging/logger");
+const orchestrator_1 = require("../core/orchestrator");
+const loader_1 = require("../config/loader");
+const paths_1 = require("../config/paths");
+const repl_input_1 = require("./repl-input");
+const repl_commands_1 = require("./repl-commands");
+const provider_1 = require("../models/provider");
+const conversation_1 = require("../core/conversation");
+/** Backwards-compat helpers: map between ConversationTurn (new source of
+ *  truth) and the older ReplTurn shape used throughout the REPL. We keep the
+ *  abstraction thin — the conversation stores everything, the REPL reads
+ *  from it. */
+const turnsOf = (state) => state.conversation.turns;
+// ---------- History persistence ----------
+const HISTORY_FILE = path.join(paths_1.FORGE_HOME, 'history');
+const HISTORY_MAX = 1000;
+const loadHistory = () => {
+    try {
+        if (!fs.existsSync(HISTORY_FILE))
+            return [];
+        const raw = fs.readFileSync(HISTORY_FILE, 'utf8');
+        return raw
+            .split('\n')
+            .map((s) => s.trim())
+            .filter(Boolean)
+            .slice(-HISTORY_MAX);
+    }
+    catch {
+        return [];
+    }
+};
+const appendHistory = (line) => {
+    try {
+        fs.mkdirSync(path.dirname(HISTORY_FILE), { recursive: true });
+        fs.appendFileSync(HISTORY_FILE, line + '\n', 'utf8');
+    }
+    catch {
+        /* best-effort */
+    }
+};
+// ---------- Rendering helpers ----------
+const chip = (label, tone = 'dim') => {
+    const map = {
+        ok: chalk_1.default.bgRgb(...banners_1.PALETTE.teal).black,
+        warn: chalk_1.default.bgRgb(...banners_1.PALETTE.amber).black,
+        info: chalk_1.default.bgRgb(...banners_1.PALETTE.violet).white,
+        dim: chalk_1.default.bgRgb(...banners_1.PALETTE.dim).white,
+    };
+    return map[tone](` ${label} `);
+};
+const modeColor = (m) => {
+    const toneOf = {
+        fast: 'ok',
+        balanced: 'ok',
+        heavy: 'warn',
+        plan: 'info',
+        execute: 'warn',
+        audit: 'info',
+        debug: 'warn',
+        architect: 'info',
+        'offline-safe': 'ok',
+    };
+    return chip(m, toneOf[m] ?? 'dim');
+};
+const shortCwd = (root) => {
+    const home = os.homedir();
+    if (root === home)
+        return '~';
+    if (root.startsWith(home + path.sep))
+        return '~/' + path.relative(home, root);
+    const parts = root.split(path.sep).filter(Boolean);
+    return parts.length <= 3 ? root : '…/' + parts.slice(-3).join('/');
+};
+// Rough token estimate: ~4 chars per token for English + code.
+const approxTokens = (s) => Math.ceil(s.length / 4);
+const contextEstimate = (state) => {
+    const used = turnsOf(state).reduce((acc, t) => {
+        const body = `${t.input}\n${t.result?.summary ?? ''}\n${(t.result?.filesChanged ?? []).join(' ')}`;
+        return acc + approxTokens(body);
+    }, 0);
+    // rough ceiling by provider default; real value comes from model descriptor
+    const modelCtx = {
+        ollama: 32_000,
+        anthropic: 200_000,
+        openai: 128_000,
+        llamacpp: 8_192,
+    };
+    return { used, max: modelCtx[state.provider] ?? 32_000 };
+};
+const fmtTokens = (n) => {
+    if (n < 1000)
+        return String(n);
+    if (n < 1000000)
+        return (n / 1000).toFixed(n < 10000 ? 1 : 0) + 'k';
+    return (n / 1000000).toFixed(1) + 'M';
+};
+const sessionCost = (state) => turnsOf(state).reduce((acc, t) => acc + (t.result?.costUsd ?? 0), 0);
+const prompt = (state) => {
+    const n = chalk_1.default.dim(`[${turnsOf(state).length + 1}]`);
+    const arrow = chalk_1.default.bold.rgb(...banners_1.PALETTE.teal)('❯');
+    return `${n} ${chalk_1.default.bold('forge')} ${arrow} `;
+};
+const statusLine = (state) => {
+    const ctx = contextEstimate(state);
+    const pctUsed = ctx.used / ctx.max;
+    const ctxStr = `${fmtTokens(ctx.used)}/${fmtTokens(ctx.max)}`;
+    const ctxColor = pctUsed > 0.85
+        ? chalk_1.default.rgb(...banners_1.PALETTE.red)
+        : pctUsed > 0.6
+            ? chalk_1.default.rgb(...banners_1.PALETTE.amber)
+            : chalk_1.default.rgb(...banners_1.PALETTE.teal);
+    const bits = [];
+    bits.push(chalk_1.default.rgb(...banners_1.PALETTE.teal)('◆') + ' ' + modeColor(state.mode));
+    bits.push(chalk_1.default.dim(state.provider) + chalk_1.default.rgb(...banners_1.PALETTE.muted)(':' + state.modelId));
+    bits.push(chalk_1.default.rgb(...banners_1.PALETTE.violet)(shortCwd(state.projectRoot)));
+    bits.push(chalk_1.default.dim('ctx ') + ctxColor(ctxStr));
+    bits.push(chalk_1.default.dim(`turn ${turnsOf(state).length + 1}`));
+    const cost = sessionCost(state);
+    if (cost > 0)
+        bits.push(chalk_1.default.rgb(...banners_1.PALETTE.pink)('$' + cost.toFixed(4)));
+    if (state.autoApprove)
+        bits.push(chip('auto', 'warn'));
+    if (state.flags.strict)
+        bits.push(chip('strict', 'warn'));
+    if (state.flags.allowFiles)
+        bits.push(chip('+files', 'warn'));
+    if (state.flags.allowShell)
+        bits.push(chip('+shell', 'warn'));
+    if (state.flags.allowNetwork)
+        bits.push(chip('+net', 'warn'));
+    if (state.flags.allowWeb)
+        bits.push(chip('+web', 'warn'));
+    if (state.flags.allowMcp)
+        bits.push(chip('+mcp', 'warn'));
+    // Remote writers (UI, another terminal) indicator — click-for-details via /turns.
+    if (state.remoteUpdates > 0) {
+        bits.push(chalk_1.default.bgRgb(...banners_1.PALETTE.violet).white(` ⇣${state.remoteUpdates} new `));
+    }
+    // Conversation source badge so the user knows where this lives.
+    bits.push(state.conversation.meta.source === 'chat'
+        ? chalk_1.default.dim('chat:') + chalk_1.default.rgb(...banners_1.PALETTE.violet)(state.conversation.meta.id.slice(0, 18))
+        : chalk_1.default.dim('repl:') + chalk_1.default.rgb(...banners_1.PALETTE.teal)(state.conversation.meta.id.slice(0, 18)));
+    return '  ' + bits.join(chalk_1.default.dim(' · '));
+};
+const hero = (_state, version) => {
+    const lines = [
+        '',
+        '  ' +
+            chalk_1.default.bold.rgb(...banners_1.PALETTE.teal)('forge') +
+            chalk_1.default.dim(` v${version}  · interactive session`),
+        '  ' +
+            chalk_1.default.rgb(...banners_1.PALETTE.muted)('Type a prompt to run. Start with / for a command. Tab to accept. ↑/↓ to browse.'),
+        '  ' +
+            chalk_1.default.rgb(...banners_1.PALETTE.muted)('Try: ') +
+            chalk_1.default.white('"add a /health endpoint"') +
+            chalk_1.default.dim(' · ') +
+            chalk_1.default.white('/ask how does the scheduler work?') +
+            chalk_1.default.dim(' · ') +
+            chalk_1.default.white('/help'),
+        '',
+    ];
+    return lines.join('\n');
+};
+const helpCard = () => {
+    const col = (k, v) => '  ' + chalk_1.default.bold.rgb(...banners_1.PALETTE.teal)(k.padEnd(28)) + chalk_1.default.dim(v);
+    const header = (s) => '\n  ' + chalk_1.default.bold.rgb(...banners_1.PALETTE.violet)(s);
+    const byCat = new Map();
+    for (const c of repl_commands_1.SLASH_COMMANDS) {
+        const arr = byCat.get(c.category) ?? [];
+        arr.push(c);
+        byCat.set(c.category, arr);
+    }
+    const ordered = [
+        'Agentic',
+        'Shortcut',
+        'Session',
+        'Modes',
+        'Knowledge',
+        'Models',
+        'Infrastructure',
+    ];
+    const out = [''];
+    out.push(header('Input'));
+    out.push(col('<text>', 'run as a task; prior turns thread into the planner'));
+    out.push(col('/<command> [args]', 'commander passthrough or REPL action'));
+    out.push(col('Tab / Shift+Tab', 'accept suggestion · cycle backward'));
+    out.push(col('↑ / ↓', 'navigate suggestions (when dropdown open) or history'));
+    out.push(col('→ at end', 'accept ghost-text suggestion'));
+    out.push(col('Ctrl+R', 'reverse-i-search through history (Ctrl+S newer · Esc cancel)'));
+    out.push(col('Alt+Enter · Ctrl+J', 'insert newline (multi-line compose)'));
+    out.push(col('Ctrl+A/E · Home/End', 'line start / line end'));
+    out.push(col('Alt+B · Alt+F', 'word back / word forward'));
+    out.push(col('Ctrl+U · Ctrl+K', 'kill to start / kill to end'));
+    out.push(col('Ctrl+W · Alt+Bksp', 'kill word backward'));
+    out.push(col('Ctrl+Y', 'yank last killed text'));
+    out.push(col('Ctrl+T', 'transpose characters around cursor'));
+    out.push(col('Ctrl+L', 'clear screen'));
+    out.push(col('F1 / F2 / F3', 'help / sessions / new conversation'));
+    out.push(col('Esc · Esc Esc', 'dismiss dropdown · clear buffer'));
+    out.push(col('Ctrl+C', 'non-empty: clear line · empty: press twice to exit · during task: cancel'));
+    out.push(col('Ctrl+D', 'exit'));
+    for (const cat of ordered) {
+        const group = byCat.get(cat);
+        if (!group)
+            continue;
+        out.push(header(cat));
+        for (const c of group) {
+            const aliases = c.aliases?.length
+                ? chalk_1.default.dim(` (${c.aliases.map((a) => '/' + a).join(' ')})`)
+                : '';
+            // eslint-disable-next-line no-control-regex -- stripping ANSI CSI SGR sequences
+            out.push(col('/' + c.name + aliases.replace(/\x1b\[[0-9;]*m/g, ''), c.description));
+        }
+    }
+    out.push('');
+    return out.join('\n');
+};
+// ---------- Turn persistence + threading ----------
+// ---------- Session summary rendering ----------
+const printResumedSummary = (state) => {
+    const turns = turnsOf(state);
+    if (!turns.length) {
+        (0, ui_1.info)(`Resumed ${state.conversation.meta.id} · no prior turns on disk.`);
+        return;
+    }
+    const n = turns.length;
+    process.stdout.write('\n  ' +
+        chalk_1.default.bold.rgb(...banners_1.PALETTE.teal)('Resumed ') +
+        chalk_1.default.white(state.conversation.meta.id) +
+        chalk_1.default.dim(`  ·  ${n} prior turn${n === 1 ? '' : 's'}\n\n`));
+    const show = turns.slice(-5);
+    const offset = turns.length - show.length;
+    show.forEach((t, idx) => {
+        const num = chalk_1.default.dim(`  ${String(offset + idx + 1).padStart(2, '0')}.`);
+        const head = chalk_1.default.white(t.input.replace(/\s+/g, ' ').slice(0, 100));
+        process.stdout.write(`${num} ${head}\n`);
+        if (t.result) {
+            const ok = t.result.success
+                ? chalk_1.default.rgb(...banners_1.PALETTE.green)('✓')
+                : chalk_1.default.rgb(...banners_1.PALETTE.red)('✗');
+            const meta = `${(t.result.durationMs / 1000).toFixed(1)}s · ${t.result.filesChanged.length} files` +
+                (t.result.costUsd ? ` · $${t.result.costUsd.toFixed(4)}` : '');
+            process.stdout.write('      ' +
+                ok +
+                ' ' +
+                chalk_1.default.dim((t.result.summary ?? '').replace(/\s+/g, ' ').slice(0, 100)) +
+                chalk_1.default.dim(`  (${meta})`) +
+                '\n');
+        }
+    });
+    if (turns.length > show.length) {
+        process.stdout.write(chalk_1.default.dim(`  …+${turns.length - show.length} earlier\n`));
+    }
+    process.stdout.write(chalk_1.default.dim('  Continue the conversation below. Forge will thread the prior turns into the next plan.\n\n'));
+};
+const relativeTime = (iso) => {
+    const age = Date.now() - new Date(iso).getTime();
+    if (age < 60_000)
+        return 'just now';
+    if (age < 3_600_000)
+        return `${Math.floor(age / 60_000)}m ago`;
+    if (age < 86_400_000)
+        return `${Math.floor(age / 3_600_000)}h ago`;
+    return `${Math.floor(age / 86_400_000)}d ago`;
+};
+const printSessionsList = (state) => {
+    const list = (0, conversation_1.listConversations)(state.projectRoot);
+    if (!list.length) {
+        (0, ui_1.info)('No prior conversations in this project.');
+        return;
+    }
+    process.stdout.write('\n');
+    for (const s of list.slice(0, 20)) {
+        const sourceTag = s.source === 'repl'
+            ? chalk_1.default.bgRgb(...banners_1.PALETTE.cyan).black(' REPL ')
+            : chalk_1.default.bgRgb(...banners_1.PALETTE.violet).white(' CHAT ');
+        const id = chalk_1.default.rgb(...banners_1.PALETTE.teal)(s.id);
+        const turnsLabel = chalk_1.default.dim(`${s.turns} turn${s.turns === 1 ? '' : 's'}`);
+        const active = s.id === state.conversation.meta.id ? chalk_1.default.rgb(...banners_1.PALETTE.amber)('  ← current') : '';
+        process.stdout.write(`  ${sourceTag} ${id}  ${turnsLabel}  ${chalk_1.default.dim(relativeTime(s.lastAt))}${active}\n`);
+        if (s.title && s.title !== 'New conversation' && s.title !== 'Untitled') {
+            process.stdout.write('    ' + chalk_1.default.dim(s.title.slice(0, 100)) + '\n');
+        }
+    }
+    if (list.length > 20)
+        process.stdout.write(chalk_1.default.dim(`  …+${list.length - 20} older\n`));
+    process.stdout.write(chalk_1.default.dim('\n  load one with: /load <sessionId>\n\n'));
+};
+const renderTurnSummaryLine = (idx, t) => {
+    const head = chalk_1.default.bold.rgb(...banners_1.PALETTE.teal)(`  ${idx + 1}.`);
+    process.stdout.write(`${head} ${chalk_1.default.white(t.input.slice(0, 200))}\n`);
+    if (t.result) {
+        const tag = t.result.success
+            ? chalk_1.default.rgb(...banners_1.PALETTE.green)('     ✓')
+            : chalk_1.default.rgb(...banners_1.PALETTE.red)('     ✗');
+        const meta = chalk_1.default.dim(`(${(t.result.durationMs / 1000).toFixed(1)}s · ${t.result.filesChanged.length} files${t.result.costUsd ? ` · $${t.result.costUsd.toFixed(4)}` : ''})`);
+        process.stdout.write(`${tag} ${chalk_1.default.dim((t.result.summary ?? '').slice(0, 200))} ${meta}\n`);
+    }
+};
+// ---------- Internal slash handlers ----------
+const parseArgv = (input) => {
+    const out = [];
+    let buf = '';
+    let quote = null;
+    for (let i = 0; i < input.length; i++) {
+        const c = input[i];
+        if (quote) {
+            if (c === quote)
+                quote = null;
+            else if (c === '\\' && input[i + 1])
+                buf += input[++i];
+            else
+                buf += c;
+        }
+        else if (c === '"' || c === "'")
+            quote = c;
+        else if (/\s/.test(c)) {
+            if (buf) {
+                out.push(buf);
+                buf = '';
+            }
+        }
+        else
+            buf += c;
+    }
+    if (buf)
+        out.push(buf);
+    return out;
+};
+const togglePermission = (state, flag, enable) => {
+    const key = flag.toLowerCase();
+    if (key === 'all') {
+        state.flags.allowFiles = enable;
+        state.flags.allowShell = enable;
+        state.flags.allowNetwork = enable;
+        state.flags.allowWeb = enable;
+        state.flags.allowMcp = enable;
+        return `all → ${enable ? 'on' : 'off'}`;
+    }
+    const map = {
+        files: 'allowFiles',
+        shell: 'allowShell',
+        net: 'allowNetwork',
+        network: 'allowNetwork',
+        web: 'allowWeb',
+        mcp: 'allowMcp',
+        strict: 'strict',
+    };
+    const field = map[key];
+    if (!field)
+        return null;
+    state.flags[field] = enable;
+    return `${String(field)} → ${enable ? 'on' : 'off'}`;
+};
+const printTurns = (state) => {
+    const turns = turnsOf(state);
+    if (!turns.length) {
+        (0, ui_1.info)('No turns yet in this session.');
+        return;
+    }
+    process.stdout.write('\n');
+    turns.forEach((t, i) => renderTurnSummaryLine(i, t));
+    process.stdout.write('\n');
+};
+const handleInternalSlash = async (state, cmd, rest, closeRepl) => {
+    switch (cmd.name) {
+        case 'help':
+            process.stdout.write(helpCard());
+            return true;
+        case 'exit':
+            closeRepl();
+            return true;
+        case 'clear':
+            process.stdout.write('\x1b[2J\x1b[H');
+            return true;
+        case 'new': {
+            // Create a fresh conversation atomically (await the disk write) so the
+            // next frame renders against the new state, not the stale old one.
+            state.watcher?.close();
+            state.conversation = await (0, conversation_1.createConversation)({
+                projectPath: state.projectRoot,
+                source: 'repl',
+                mode: state.mode,
+            });
+            state.remoteUpdates = 0;
+            attachWatcher(state);
+            (0, ui_1.ok)(`Started a fresh conversation: ${state.conversation.meta.id}`);
+            return true;
+        }
+        case 'turns':
+            // Reviewing the turn list counts as acknowledging remote updates.
+            state.remoteUpdates = 0;
+            printTurns(state);
+            return true;
+        case 'pwd':
+            (0, ui_1.info)(state.projectRoot);
+            return true;
+        case 'cd': {
+            const target = rest.join(' ') || os.homedir();
+            try {
+                const resolved = path.resolve(state.projectRoot, target);
+                if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+                    (0, ui_1.err)(`not a directory: ${resolved}`);
+                    return true;
+                }
+                process.chdir(resolved);
+                state.projectRoot = (0, loader_1.findProjectRoot)(resolved) ?? resolved;
+                (0, paths_1.ensureProjectDir)(state.projectRoot);
+                (0, ui_1.ok)(`cwd → ${state.projectRoot}`);
+            }
+            catch (e) {
+                (0, ui_1.err)(`cd failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return true;
+        }
+        case 'mode': {
+            const name = rest[0];
+            const valid = [
+                'fast',
+                'balanced',
+                'heavy',
+                'plan',
+                'execute',
+                'audit',
+                'debug',
+                'architect',
+                'offline-safe',
+            ];
+            if (!name) {
+                (0, ui_1.info)(`current mode: ${(0, ui_1.accent)(state.mode)}   (one of: ${valid.join(', ')})`);
+                return true;
+            }
+            if (!valid.includes(name)) {
+                (0, ui_1.err)(`unknown mode: ${name}. one of: ${valid.join(', ')}`);
+                return true;
+            }
+            state.mode = name;
+            (0, ui_1.ok)(`mode → ${(0, ui_1.accent)(state.mode)}`);
+            return true;
+        }
+        case 'yes':
+            state.autoApprove = !state.autoApprove;
+            (0, ui_1.ok)(`auto-approve → ${state.autoApprove ? 'on' : 'off'}`);
+            return true;
+        case 'strict':
+            state.flags.strict = !state.flags.strict;
+            (0, ui_1.ok)(`strict → ${state.flags.strict ? 'on' : 'off'}`);
+            return true;
+        case 'allow': {
+            const msg = togglePermission(state, rest[0] ?? '', true);
+            if (!msg)
+                (0, ui_1.err)('usage: /allow files|shell|network|web|mcp|all');
+            else
+                (0, ui_1.ok)(msg);
+            return true;
+        }
+        case 'deny': {
+            const msg = togglePermission(state, rest[0] ?? '', false);
+            if (!msg)
+                (0, ui_1.err)('usage: /deny files|shell|network|web|mcp|all');
+            else
+                (0, ui_1.ok)(msg);
+            return true;
+        }
+        case 'retry': {
+            const turns = turnsOf(state);
+            const last = turns[turns.length - 1];
+            if (!last) {
+                (0, ui_1.err)('No previous turn to retry.');
+                return true;
+            }
+            (0, ui_1.info)(`Retrying: ${last.input.slice(0, 120)}`);
+            return false;
+        }
+        case 'undo': {
+            try {
+                (0, child_process_1.execSync)('git stash push -u -m forge-repl-undo', {
+                    cwd: state.projectRoot,
+                    stdio: 'ignore',
+                });
+                (0, ui_1.ok)('Stashed local changes (git stash pop to restore).');
+            }
+            catch (e) {
+                (0, ui_1.err)(`/undo requires git; ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return true;
+        }
+        case 'sessions':
+            printSessionsList(state);
+            return true;
+        case 'load': {
+            const id = rest[0];
+            if (!id) {
+                (0, ui_1.err)('usage: /load <sessionId>');
+                return true;
+            }
+            // Normalise: accept bare id, repl-<id>, chat-<id>, or conv-<id>.
+            const sessionId = id.startsWith('repl-') || id.startsWith('chat-') || id.startsWith('conv-')
+                ? id
+                : `repl-${id}`;
+            const loaded = (0, conversation_1.loadConversation)(state.projectRoot, sessionId);
+            if (!loaded) {
+                (0, ui_1.err)(`No conversation found for ${sessionId}`);
+                return true;
+            }
+            state.watcher?.close();
+            state.conversation = loaded;
+            state.remoteUpdates = 0;
+            attachWatcher(state);
+            (0, ui_1.ok)(`Loaded ${loaded.turns.length} turn${loaded.turns.length === 1 ? '' : 's'} from ${sessionId}  (${loaded.meta.source.toUpperCase()})`);
+            printResumedSummary(state);
+            return true;
+        }
+        case 'continue': {
+            const list = (0, conversation_1.listConversations)(state.projectRoot).filter((s) => s.id !== state.conversation.meta.id);
+            if (!list.length) {
+                (0, ui_1.info)('No other conversations to continue.');
+                return true;
+            }
+            const target = list[0]; // newest first
+            const loaded = (0, conversation_1.loadConversation)(state.projectRoot, target.id);
+            if (!loaded) {
+                (0, ui_1.err)(`Could not load ${target.id}`);
+                return true;
+            }
+            state.watcher?.close();
+            state.conversation = loaded;
+            state.remoteUpdates = 0;
+            attachWatcher(state);
+            (0, ui_1.ok)(`Continuing ${loaded.meta.id} (${loaded.meta.source.toUpperCase()}) with ${loaded.turns.length} prior turn${loaded.turns.length === 1 ? '' : 's'}.`);
+            printResumedSummary(state);
+            return true;
+        }
+        case 'rename': {
+            const title = rest.join(' ').trim();
+            if (!title) {
+                (0, ui_1.info)(`current title: ${(0, ui_1.accent)(state.conversation.meta.title)}`);
+                return true;
+            }
+            await (0, conversation_1.renameConversation)(state.projectRoot, state.conversation.meta.id, title);
+            // Refresh meta from disk.
+            const reloaded = (0, conversation_1.loadConversation)(state.projectRoot, state.conversation.meta.id);
+            if (reloaded)
+                state.conversation = reloaded;
+            (0, ui_1.ok)(`Renamed to: ${(0, ui_1.accent)(title)}`);
+            return true;
+        }
+        case 'delete': {
+            const raw = rest[0];
+            const targetId = raw
+                ? raw.startsWith('repl-') || raw.startsWith('chat-') || raw.startsWith('conv-')
+                    ? raw
+                    : `repl-${raw}`
+                : state.conversation.meta.id;
+            const isCurrent = targetId === state.conversation.meta.id;
+            const target = (0, conversation_1.loadConversation)(state.projectRoot, targetId);
+            if (!target) {
+                (0, ui_1.err)(`No conversation ${targetId}`);
+                return true;
+            }
+            const gone = (0, conversation_1.deleteConversation)(state.projectRoot, targetId);
+            if (!gone) {
+                (0, ui_1.err)(`Delete failed for ${targetId}`);
+                return true;
+            }
+            if (isCurrent) {
+                // Roll over to a fresh conversation so the user has somewhere to type.
+                state.watcher?.close();
+                state.conversation = await (0, conversation_1.createConversation)({
+                    projectPath: state.projectRoot,
+                    source: 'repl',
+                    mode: state.mode,
+                });
+                state.remoteUpdates = 0;
+                attachWatcher(state);
+            }
+            (0, ui_1.ok)(`Deleted ${targetId}.`);
+            return true;
+        }
+        case 'export': {
+            const destRaw = rest.join(' ').trim();
+            const dest = destRaw
+                ? path.resolve(state.projectRoot, destRaw)
+                : path.join(state.projectRoot, `${state.conversation.meta.id}.json`);
+            try {
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                const payload = JSON.stringify(state.conversation, null, 2);
+                fs.writeFileSync(dest, payload, 'utf8');
+                (0, ui_1.ok)(`Exported ${state.conversation.turns.length} turn${state.conversation.turns.length === 1 ? '' : 's'} → ${dest}`);
+            }
+            catch (e) {
+                (0, ui_1.err)(`export failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+            return true;
+        }
+        default:
+            return false;
+    }
+};
+// ---------- Commander passthrough ----------
+/** Recursively install exitOverride on every command so neither the root nor
+ *  any subcommand ever calls process.exit — even on help/version/parse errors. */
+const installExitOverride = (cmd) => {
+    cmd.exitOverride();
+    for (const sub of cmd.commands)
+        installExitOverride(sub);
+};
+const runCommanderPassthrough = async (program, argv, _state) => {
+    installExitOverride(program);
+    process.exitCode = 0;
+    // Safety net: if anything in the passthrough tries to call process.exit
+    // directly (e.g. a subcommand action with a legacy exit), intercept it so
+    // the REPL stays alive.
+    const originalExit = process.exit;
+    let interceptedCode;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    process.exit = ((code) => {
+        interceptedCode = code;
+        throw Object.assign(new Error('[REPL intercepted process.exit]'), {
+            __replInterceptedExit: true,
+            __code: code,
+        });
+        // never reached
+    });
+    try {
+        await program.parseAsync(['node', 'forge', ...argv]);
+    }
+    catch (e) {
+        const isIntercept = e && typeof e === 'object' && '__replInterceptedExit' in e;
+        if (isIntercept) {
+            // Give the user visible context: a command tried to exit the process.
+            const code = e.__code ?? 0;
+            if (code !== 0) {
+                (0, ui_1.err)(`/${argv[0]} exited with code ${code} (REPL stayed open).`);
+            }
+            else {
+                // exit code 0 is usually an "OK, I'm done" signal — stay silent.
+            }
+        }
+        else if (e instanceof commander_1.CommanderError) {
+            const quiet = new Set([
+                'commander.help',
+                'commander.version',
+                'commander.helpDisplayed',
+                'commander.missingMandatoryOptionValue',
+            ]);
+            if (!quiet.has(e.code)) {
+                (0, ui_1.err)(`/${argv[0]}: ${e.message}`);
+            }
+            // help-like exits are expected — the help card was already printed.
+        }
+        else {
+            (0, ui_1.err)(`/${argv[0]} failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    finally {
+        // Restore the real exit so the next Ctrl+D / clean shutdown still works.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        process.exit = originalExit;
+        if (interceptedCode !== undefined && interceptedCode !== 0) {
+            process.exitCode = interceptedCode;
+        }
+    }
+};
+// ---------- Orchestrator turn ----------
+const runTaskTurn = async (state, rawInput, semantic) => {
+    const now = new Date().toISOString();
+    const effectiveInput = semantic?.prompt ?? rawInput;
+    const turn = {
+        id: (0, conversation_1.newTurnId)(),
+        at: now,
+        input: rawInput,
+        mode: semantic?.mode ?? state.mode,
+        status: 'running',
+    };
+    // Local-first in-memory update so status bar reflects the turn immediately,
+    // then persist. The watcher will re-deliver this event to our own process;
+    // we dedupe by id in applyRemoteUpdate.
+    state.conversation.turns.push(turn);
+    // Submitting a turn implicitly acknowledges any remote updates seen since
+    // the last prompt — the user has now participated again.
+    state.remoteUpdates = 0;
+    try {
+        await (0, conversation_1.appendUserTurn)(state.projectRoot, state.conversation.meta.id, turn);
+    }
+    catch (e) {
+        (0, ui_1.warn)(`turn persist failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    state.running = true;
+    state.abort = new AbortController();
+    const composed = (0, conversation_1.composeDescription)(effectiveInput, state.conversation.turns.slice(0, -1));
+    process.stdout.write('\n');
+    try {
+        const out = await (0, orchestrator_1.orchestrateRun)({
+            input: effectiveInput,
+            description: composed,
+            mode: turn.mode,
+            autoApprove: state.autoApprove || semantic?.autoApprove,
+            planOnly: turn.mode === 'plan' || Boolean(semantic?.planOnly),
+            flags: { ...state.flags },
+        });
+        const r = out.result;
+        const result = {
+            taskId: out.task.id,
+            success: r.success,
+            summary: r.summary ?? '',
+            filesChanged: r.filesChanged ?? [],
+            durationMs: r.durationMs ?? 0,
+            costUsd: r.costUsd,
+        };
+        const status = r.success ? 'done' : 'failed';
+        turn.taskId = out.task.id;
+        turn.status = status;
+        turn.result = result;
+        state.localTaskIds.add(out.task.id);
+        try {
+            await (0, conversation_1.attachTurnResult)(state.projectRoot, state.conversation.meta.id, {
+                turnId: turn.id,
+                taskId: out.task.id,
+                result,
+                status,
+            });
+        }
+        catch (e) {
+            (0, ui_1.warn)(`turn result persist failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+        process.stdout.write('\n');
+        if (r.success) {
+            const costBit = r.costUsd && r.costUsd > 0 ? chalk_1.default.dim(` · $${r.costUsd.toFixed(4)}`) : '';
+            (0, ui_1.ok)(`turn ${turnsOf(state).length} done  ${chalk_1.default.dim(`(${((r.durationMs ?? 0) / 1000).toFixed(1)}s · ${r.filesChanged?.length ?? 0} files)`)}${costBit}`);
+            if (r.filesChanged?.length) {
+                for (const f of r.filesChanged.slice(0, 8)) {
+                    process.stdout.write(`   ${chalk_1.default.rgb(...banners_1.PALETTE.teal)('▸')} ${chalk_1.default.white(f)}\n`);
+                }
+                if (r.filesChanged.length > 8) {
+                    process.stdout.write(chalk_1.default.dim(`   …+${r.filesChanged.length - 8} more\n`));
+                }
+            }
+        }
+        else {
+            (0, ui_1.err)(`turn ${turnsOf(state).length} failed — ${(r.summary ?? '').slice(0, 160)}`);
+        }
+    }
+    catch (e) {
+        const result = {
+            taskId: 'unknown',
+            success: false,
+            summary: e instanceof Error ? e.message : String(e),
+            filesChanged: [],
+            durationMs: 0,
+        };
+        turn.status = 'failed';
+        turn.result = result;
+        try {
+            await (0, conversation_1.attachTurnResult)(state.projectRoot, state.conversation.meta.id, {
+                turnId: turn.id,
+                taskId: turn.taskId ?? 'unknown',
+                result,
+                status: 'failed',
+            });
+        }
+        catch {
+            /* double-fault — already reported via err() below */
+        }
+        (0, ui_1.err)(`Turn crashed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    finally {
+        state.running = false;
+        state.abort = undefined;
+    }
+};
+// ---------- Watcher wiring ----------
+/**
+ * Attach a watcher to the active conversation file. When another writer
+ * appends an event (another terminal, the UI, or a subagent recording a
+ * task result that we didn't originate), sync it into local state and
+ * increment the unread counter. The cursor redraws on the next keystroke
+ * via statusLine().
+ */
+const attachWatcher = (state) => {
+    state.watcher?.close();
+    state.watcher = (0, conversation_1.watchConversationFile)(state.projectRoot, state.conversation.meta.id, (update) => {
+        let remoteAdded = 0;
+        for (const nt of update.newTurns) {
+            // Did we author this turn? If yes, the local push already accounted
+            // for it; skip to avoid duplication.
+            const already = state.conversation.turns.some((t) => t.id === nt.id);
+            if (already)
+                continue;
+            state.conversation.turns.push(nt);
+            remoteAdded++;
+        }
+        for (const { turn } of update.completedTurns) {
+            const mine = turn.taskId ? state.localTaskIds.has(turn.taskId) : false;
+            if (mine)
+                continue;
+            const idx = state.conversation.turns.findIndex((t) => t.id === turn.id);
+            if (idx >= 0)
+                state.conversation.turns[idx] = turn;
+            // If the completed turn arrived as a pure result without the user
+            // event, the newTurns branch above already added it.
+        }
+        if (remoteAdded ||
+            update.completedTurns.some((c) => !state.localTaskIds.has(c.turn.taskId ?? ''))) {
+            state.remoteUpdates += remoteAdded;
+        }
+    });
+};
+// ---------- Entry point ----------
+const startRepl = async (program, opts = {}) => {
+    (0, bootstrap_1.bootstrap)();
+    // During interactive REPL, silence logger stderr/stdout output — provider
+    // failures etc. would otherwise corrupt the rendered frame. File logging
+    // continues so the user can inspect ~/.forge/logs/forge.log after.
+    (0, logger_1.setConsoleOutput)(false);
+    const cfg = (0, loader_1.loadGlobalConfig)();
+    const projectRoot = (0, loader_1.findProjectRoot)() ?? process.cwd();
+    (0, paths_1.ensureProjectDir)(projectRoot);
+    // Pull a readable "provider:model" label for the status line.
+    const providers = (() => {
+        try {
+            return (0, provider_1.listProviders)().map((p) => p.name);
+        }
+        catch {
+            return [];
+        }
+    })();
+    const provider = cfg.provider ?? providers[0] ?? 'local';
+    const modelId = cfg.models?.[cfg.defaultMode] ?? cfg.models?.balanced ?? 'default';
+    // Resolve conversation: resume an existing one (accepting any prefix), or
+    // create a fresh REPL-sourced conversation.
+    let conversation = null;
+    if (opts.resumeSessionId) {
+        const normalised = opts.resumeSessionId.startsWith('repl-') ||
+            opts.resumeSessionId.startsWith('chat-') ||
+            opts.resumeSessionId.startsWith('conv-')
+            ? opts.resumeSessionId
+            : `repl-${opts.resumeSessionId}`;
+        conversation = (0, conversation_1.loadConversation)(projectRoot, normalised);
+    }
+    if (!conversation) {
+        conversation = await (0, conversation_1.createConversation)({
+            projectPath: projectRoot,
+            source: 'repl',
+            mode: cfg.defaultMode ?? 'balanced',
+        });
+    }
+    const state = {
+        conversation,
+        projectRoot,
+        mode: cfg.defaultMode ?? 'balanced',
+        flags: {
+            skipRoutine: false,
+            allowFiles: false,
+            allowShell: false,
+            allowNetwork: false,
+            allowWeb: false,
+            allowMcp: false,
+            strict: false,
+            nonInteractive: false,
+        },
+        autoApprove: false,
+        running: false,
+        provider,
+        modelId: String(modelId),
+        localTaskIds: new Set(),
+        remoteUpdates: 0,
+    };
+    attachWatcher(state);
+    process.stdout.write(hero(state, pkg.version ?? '0.1.0'));
+    if (conversation.turns.length)
+        printResumedSummary(state);
+    const history = loadHistory();
+    let editor = null;
+    let lastSigint = 0;
+    let closed = false;
+    const hooks = {
+        prompt: () => prompt(state),
+        statusLine: () => statusLine(state),
+        suggestions: (input) => {
+            const ranked = (0, repl_commands_1.rankSlash)(input, 8);
+            return ranked.map((r) => ({
+                label: r.label,
+                value: r.value,
+                description: r.description,
+                score: r.score,
+            }));
+        },
+        history,
+        isRunning: () => state.running,
+        onCancel: () => {
+            const now = Date.now();
+            // During a running task: cancel it.
+            if (state.running) {
+                (0, ui_1.warn)('Cancelling current task …');
+                try {
+                    process.kill(process.pid, 'SIGINT');
+                }
+                catch {
+                    /* noop */
+                }
+                state.running = false;
+                return;
+            }
+            // Idle + buffer was empty (editor handles the non-empty case itself).
+            // Two presses within 2s exits. Otherwise just print a hint.
+            if (now - lastSigint < 2000) {
+                editor?.close();
+                return;
+            }
+            lastSigint = now;
+            process.stdout.write('\n' + chalk_1.default.dim('  (Ctrl+C again to exit · Ctrl+D also exits)\n'));
+        },
+        onExit: () => {
+            editor?.close();
+        },
+        onSubmit: async (line, picked) => {
+            if (!line)
+                return;
+            appendHistory(line);
+            history.push(line);
+            // Slash command?
+            if (line.startsWith('/')) {
+                const body = line.slice(1);
+                const parts = parseArgv(body);
+                const head = (parts[0] ?? '').toLowerCase();
+                const rest = parts.slice(1);
+                const cmd = (0, repl_commands_1.findSlash)(head);
+                if (!cmd) {
+                    (0, ui_1.err)(`Unknown command: /${head}  ${chalk_1.default.dim('(type /help)')}`);
+                    return;
+                }
+                if (cmd.kind === 'internal') {
+                    const handled = await handleInternalSlash(state, cmd, rest, () => {
+                        closed = true;
+                        editor?.close();
+                    });
+                    // retry falls through to run
+                    if (cmd.name === 'retry' && !handled) {
+                        const turns = turnsOf(state);
+                        const last = turns[turns.length - 1];
+                        if (last)
+                            await runTaskTurn(state, last.input);
+                    }
+                    return;
+                }
+                if (cmd.kind === 'passthrough') {
+                    await runCommanderPassthrough(program, [cmd.passthroughTo ?? cmd.name, ...rest]);
+                    return;
+                }
+                if (cmd.kind === 'semantic' && cmd.template) {
+                    const args = rest.join(' ');
+                    const expansion = cmd.template(args);
+                    await runTaskTurn(state, `/${cmd.name} ${args}`.trim(), expansion);
+                    return;
+                }
+                return;
+            }
+            // Bare text → task turn
+            await runTaskTurn(state, line);
+            void picked; // unused for bare text
+        },
+    };
+    editor = new repl_input_1.LineEditor(hooks);
+    await editor.run();
+    // Tear down watcher; otherwise fs watchers keep the process alive.
+    state.watcher?.close();
+    // Restore logger console output for subsequent CLI invocations in the
+    // same process (unusual, but safe to do).
+    (0, logger_1.setConsoleOutput)(true);
+    if (!closed)
+        process.stdout.write('\n');
+    process.stdout.write((0, ui_1.dim)(`  session ${state.conversation.meta.id} saved.`) + '\n');
+    process.stdout.write((0, ui_1.dim)(`  resume with: forge repl --resume ${state.conversation.meta.id}`) + '\n\n');
+};
+exports.startRepl = startRepl;
+//# sourceMappingURL=repl.js.map