codehere 0.3.0-rc.2 → 0.3.0-rc.27

package/dist/presentation/cli/repl.js

@@ -0,0 +1,718 @@
+/**
+ * Interactive REPL · raw-mode live command palette.
+ *
+ * Faithful port of v0.2.2's session.ts (commit f4828c2 · "REPL fixes,
+ * Palette Enter completes selected command, stdin multi-char chunk
+ * processing"). Same banner with state badges, same `> ` prompt with
+ * brand color, same filter-as-you-type palette under the prompt, same
+ * escape-buffering keystroke handler, same Tab/Enter complete, same
+ * arrow-key palette navigation when palette is visible / history when not.
+ *
+ * Backends adapted to v0.3 (chat/edit/review/planner removed in D7):
+ *   - Task slash commands (ask, explain, fix, review, plan, test, refactor,
+ *     orchestrate, run) → spawn via Conductor
+ *   - Subcommand slash (trust, report, hook, status, health, serve, setup,
+ *     config) → invoke `node dist/index.js <cmd>` inline
+ *   - /undo → "queued for v0.5 (F3 memory layer)"
+ *
+ * Citing f4828c2 for lineage. Don't redesign.
+ */
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+import { spawn as childSpawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { colors, success, error, warning, newline, createCodehereLogo } from '../../ui.js';
+import { getVersion } from '../../utils/version.js';
+import { SessionManager, availableAgents } from '../../infrastructure/orchestration/session-manager.js';
+import { collectCodeFiles } from '../../infrastructure/security/file-collection.js';
+import chalk from 'chalk';
+const brandBlue = chalk.rgb(74, 144, 226);
+const stdin = process.stdin;
+const stdout = process.stdout;
+const SLASH_COMMANDS = [
+    // Tasks · delegate via Conductor
+    {
+        name: 'ask',
+        args: '<question>',
+        description: 'Ask anything about your codebase',
+        kind: 'task',
+        promptTemplate: (a) => a,
+    },
+    {
+        name: 'explain',
+        args: '<file>',
+        description: 'Explain a file',
+        kind: 'task',
+        promptTemplate: (a) => `Explain this file in plain English: ${a}`,
+    },
+    {
+        name: 'fix',
+        args: '<file> <hint>',
+        description: 'Apply a targeted fix',
+        kind: 'task',
+        promptTemplate: (a) => {
+            const parts = a.split(/\s+/);
+            const file = parts[0];
+            const hint = parts.slice(1).join(' ');
+            return `fix ${file}: ${hint}`;
+        },
+    },
+    {
+        name: 'review',
+        args: '<file>',
+        description: 'Code review with findings',
+        kind: 'task',
+        promptTemplate: (a) => `Review ${a} for bugs, security issues, and risks. Concrete findings only.`,
+    },
+    {
+        name: 'plan',
+        args: '<goal>',
+        description: 'Break a goal into steps',
+        kind: 'task',
+        promptTemplate: (a) => `Plan: ${a}. Break into concrete steps before any execution.`,
+    },
+    {
+        name: 'test',
+        args: '<file>',
+        description: 'Generate tests for a file',
+        kind: 'task',
+        promptTemplate: (a) => `add tests for ${a}. Cover edge cases and likely failure modes.`,
+    },
+    {
+        name: 'refactor',
+        args: '<pattern> <instr>',
+        description: 'Refactor across files',
+        kind: 'task',
+        promptTemplate: (a) => `refactor: ${a}`,
+    },
+    // Subcommands · run an existing CLI subcommand inline
+    {
+        name: 'trust',
+        args: '[path]',
+        description: 'Scan for vulnerabilities',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'trust',
+    },
+    {
+        name: 'report',
+        args: '[path]',
+        description: 'Security audit report',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'report',
+    },
+    {
+        name: 'hook',
+        args: '[install|status]',
+        description: 'Safety hook management',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'hook',
+    },
+    {
+        name: 'status',
+        args: '',
+        description: 'Dashboard — hook activity',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'status',
+    },
+    { name: 'health', args: '', description: 'System health check', kind: 'sub', noKey: true, subcommand: 'health' },
+    {
+        name: 'setup',
+        args: '',
+        description: 'Configure first-run preferences',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'setup',
+    },
+    {
+        name: 'config',
+        args: '[key] [value]',
+        description: 'Manage preferences',
+        kind: 'sub',
+        noKey: true,
+        subcommand: 'config',
+    },
+    { name: 'agents', args: '', description: 'List installed specialists', kind: 'session', noKey: true },
+    { name: 'undo', args: '<file>', description: 'Undo file changes (queued for v0.5)', kind: 'session', noKey: true },
+    { name: 'history', args: '', description: 'Show command history', kind: 'session', noKey: true },
+    // Helpers
+    { name: 'help', args: '', description: 'Command reference', kind: 'session', noKey: true },
+    { name: 'clear', args: '', description: 'Clear the screen', kind: 'session', noKey: true },
+    { name: 'exit', args: '', description: 'Leave the session', kind: 'session', noKey: true },
+];
+const PALETTE_CMDS = SLASH_COMMANDS.map((c) => ({
+    sig: `/${c.name}${c.args ? ' ' + c.args : ''}`,
+    name: c.name,
+    desc: c.description,
+    noKey: c.noKey,
+}));
+function maxPalette() {
+    const rows = process.stdout.rows || 24;
+    return Math.min(rows - 8, 20);
+}
+// ── State detection (badges in welcome) ──────────────────────────────────
+function detectState() {
+    const cwd = process.cwd();
+    const name = basename(cwd);
+    const settingsPath = join(process.env.HOME || '', '.claude', 'settings.json');
+    let hasHooks = false;
+    try {
+        hasHooks = existsSync(settingsPath) && readFileSync(settingsPath, 'utf-8').includes('codehere');
+    }
+    catch {
+        /* ignore */
+    }
+    const hasAnyAgent = availableAgents().some((a) => a.installed && a.id !== 'conductor');
+    const isGitRepo = existsSync(join(cwd, '.git'));
+    let fileCount = 0;
+    let scannableCount = 0;
+    try {
+        const count = (dir, d) => {
+            if (d > 3)
+                return 0;
+            let n = 0;
+            for (const e of readdirSync(dir, { withFileTypes: true })) {
+                if (e.name.startsWith('.') || e.name === 'node_modules' || e.name === 'dist')
+                    continue;
+                if (e.isDirectory())
+                    n += count(join(dir, e.name), d + 1);
+                else
+                    n++;
+            }
+            return n;
+        };
+        fileCount = count(cwd, 0);
+        // rc.21: surface the scannable count — code files that trust/scan
+        // would actually look at. Honest count beats a single inflated number.
+        // UX_OBSERVATIONS P3. Static ESM import (rc.20 used `require()` which is
+        // undefined in this package's ESM runtime — Codex caught the silent fail).
+        try {
+            scannableCount = collectCodeFiles(cwd).length;
+        }
+        catch {
+            /* ignore — banner stays silent rather than crashes */
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return { name, hasHooks, hasAgents: hasAnyAgent, isGitRepo, fileCount, scannableCount };
+}
+/**
+ * Format the banner's "X files (Y scannable)" line.
+ *
+ * Pure function (no I/O) so the rc.20 silent-fail regression that Codex
+ * caught — banner falling back to total-only when scannable load fails —
+ * has a tight unit test.
+ *
+ * Contract:
+ *   - scannable > 0 AND scannable < total → "<total> files (<scannable> scannable)"
+ *   - otherwise                            → "<total> files"
+ *
+ * Exported for test/cli/rc15-fixes.test.ts banner integration test.
+ */
+export function formatFileLine(total, scannable) {
+    if (scannable > 0 && scannable < total) {
+        return `${total} files (${scannable} scannable)`;
+    }
+    return `${total} files`;
+}
+export function buildWelcomeLines(state, version) {
+    const logo = createCodehereLogo();
+    const ver = colors.dim(`v${version}`);
+    const badges = [
+        state.hasHooks ? colors.green('● hooks') : colors.dim('○ hooks'),
+        state.hasAgents ? colors.green('● agents') : colors.dim('○ agents'),
+    ];
+    const lines = [
+        '',
+        `  ${logo} ${ver}`,
+        '',
+        '  ' + badges.join('  '),
+        '',
+        colors.dim(`  ${state.name}`) +
+            colors.dim(` · ${state.isGitRepo ? 'git' : 'dir'} · ${formatFileLine(state.fileCount, state.scannableCount)}`),
+        '',
+    ];
+    if (!state.hasHooks) {
+        lines.push('  ' + colors.yellow('→') + ' ' + colors.cyan('/hook install') + colors.dim(' to activate safety scanning'));
+    }
+    else if (!state.hasAgents) {
+        lines.push('  ' +
+            colors.yellow('→') +
+            ' Install ' +
+            colors.cyan('claude-code') +
+            colors.dim(' / ') +
+            colors.cyan('codex') +
+            colors.dim(' / aider / opencode to delegate tasks'));
+    }
+    lines.push(colors.dim('  Type / for commands, or ask anything'));
+    lines.push('');
+    return lines;
+}
+function printWelcome() {
+    const state = detectState();
+    for (const line of buildWelcomeLines(state, getVersion())) {
+        console.log(line);
+    }
+}
+// ── Main session ─────────────────────────────────────────────────────────
+export async function runInteractiveRepl() {
+    printWelcome();
+    if (stdin.isTTY)
+        stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    const state = { history: [] };
+    const historyBuf = [];
+    let historyIdx = -1;
+    let line = '';
+    let selected = 0;
+    let pLines = 0;
+    let processing = false;
+    let escBuf = '';
+    let escTimer = null;
+    const cols = () => stdout.columns || 80;
+    function truncate(s, maxWidth) {
+        // eslint-disable-next-line no-control-regex -- ANSI escape stripping requires the literal ESC byte
+        const visible = s.replace(/\x1b\[[0-9;]*m/g, '');
+        if (visible.length <= maxWidth)
+            return s;
+        let vis = 0;
+        let cut = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s[i] === '\x1b') {
+                const end = s.indexOf('m', i);
+                if (end !== -1) {
+                    i = end;
+                    continue;
+                }
+            }
+            vis++;
+            if (vis >= maxWidth - 1) {
+                cut = i + 1;
+                break;
+            }
+        }
+        return cut > 0 ? s.slice(0, cut) + '\x1b[0m' : s;
+    }
+    function render() {
+        stdout.write('\r\x1b[J');
+        stdout.write(brandBlue('> ') + line);
+        if (line.startsWith('/') && !line.includes(' ')) {
+            const filter = line.slice(1).toLowerCase();
+            const allMatching = PALETTE_CMDS.filter((c) => c.name.startsWith(filter));
+            const limit = maxPalette();
+            const filtered = allMatching.slice(0, limit);
+            const overflow = allMatching.length - filtered.length;
+            if (filtered.length > 0) {
+                const maxLen = Math.max(...filtered.map((c) => c.sig.length));
+                const w = cols();
+                let drawnLines = 0;
+                for (let i = 0; i < filtered.length; i++) {
+                    const c = filtered[i];
+                    const pad = ' '.repeat(Math.max(1, maxLen - c.sig.length + 2));
+                    const badge = c.noKey ? colors.dim(' (free)') : '';
+                    const prefix = i === selected ? brandBlue('▸') : ' ';
+                    const text = i === selected ? brandBlue(c.sig) : c.sig;
+                    const row = `  ${prefix} ${text}${pad}${colors.dim(c.desc)}${badge}`;
+                    stdout.write('\n' + truncate(row, w));
+                    drawnLines++;
+                }
+                if (overflow > 0) {
+                    stdout.write('\n' + colors.dim(`  ... +${overflow} more (type to filter)`));
+                    drawnLines++;
+                }
+                stdout.write(`\x1b[${drawnLines}A`);
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = drawnLines;
+            }
+            else {
+                stdout.write('\n' + colors.dim('  No matching commands'));
+                stdout.write('\x1b[1A');
+                stdout.write(`\x1b[${line.length + 3}G`);
+                pLines = 1;
+            }
+        }
+        else {
+            pLines = 0;
+        }
+    }
+    function handle(key) {
+        if (processing)
+            return;
+        // Ctrl+C
+        if (key === '\x03') {
+            if (line.length > 0) {
+                line = '';
+                selected = 0;
+                stdout.write('\r\x1b[J\n');
+                render();
+            }
+            else {
+                stdout.write('\r\x1b[J\n');
+                process.exit(0);
+            }
+            return;
+        }
+        // Ctrl+D
+        if (key === '\x04') {
+            stdout.write('\r\x1b[J\n' + colors.dim('  See you.') + '\n');
+            process.exit(0);
+        }
+        // Ctrl+L
+        if (key === '\x0c') {
+            line = '';
+            selected = 0;
+            stdout.write('\x1b[2J\x1b[H');
+            printWelcome();
+            render();
+            return;
+        }
+        // Arrow up
+        if (key === '\x1b[A') {
+            if (pLines > 0) {
+                selected = Math.max(0, selected - 1);
+            }
+            else if (historyBuf.length > 0 && historyIdx < historyBuf.length - 1) {
+                historyIdx++;
+                line = historyBuf[historyIdx];
+            }
+            render();
+            return;
+        }
+        // Arrow down
+        if (key === '\x1b[B') {
+            if (pLines > 0) {
+                selected = Math.min(pLines - 1, selected + 1);
+            }
+            else {
+                if (historyIdx > 0) {
+                    historyIdx--;
+                    line = historyBuf[historyIdx];
+                }
+                else {
+                    historyIdx = -1;
+                    line = '';
+                }
+            }
+            render();
+            return;
+        }
+        // Tab
+        if (key === '\t' && pLines > 0) {
+            const filter = line.slice(1).toLowerCase();
+            const filtered = PALETTE_CMDS.filter((c) => c.name.startsWith(filter)).slice(0, maxPalette());
+            if (filtered[selected]) {
+                line = `/${filtered[selected].name} `;
+                selected = 0;
+            }
+            render();
+            return;
+        }
+        // Enter
+        if (key === '\r' || key === '\n') {
+            if (pLines > 0 && line.startsWith('/') && !line.includes(' ')) {
+                const filter = line.slice(1).toLowerCase();
+                const filtered = PALETTE_CMDS.filter((c) => c.name.startsWith(filter)).slice(0, maxPalette());
+                if (filtered[selected]) {
+                    line = `/${filtered[selected].name}`;
+                }
+            }
+            stdout.write('\r\x1b[J\n');
+            const trimmed = line.trim();
+            if (trimmed) {
+                historyBuf.unshift(trimmed);
+                historyIdx = -1;
+            }
+            line = '';
+            selected = 0;
+            pLines = 0;
+            if (!trimmed) {
+                render();
+                return;
+            }
+            processing = true;
+            executeInput(trimmed, state)
+                .catch((err) => {
+                console.log(error('  ' + (err instanceof Error ? err.message : String(err))));
+            })
+                .finally(() => {
+                processing = false;
+                stdin.resume();
+                stdin.ref();
+                if (stdin.isTTY && !stdin.isRaw)
+                    stdin.setRawMode(true);
+                console.log();
+                render();
+            });
+            return;
+        }
+        // Backspace
+        if (key === '\x7f' || key === '\b') {
+            if (line.length > 0) {
+                line = line.slice(0, -1);
+                selected = 0;
+                render();
+            }
+            return;
+        }
+        // Ignore stray escape sequences
+        if (key.startsWith('\x1b'))
+            return;
+        // Regular character
+        line += key;
+        selected = 0;
+        render();
+    }
+    render();
+    stdin.on('data', (raw) => {
+        if (processing)
+            return;
+        if (raw.startsWith('\x1b') && raw.length >= 2) {
+            handle(raw);
+            return;
+        }
+        for (let i = 0; i < raw.length; i++) {
+            if (processing)
+                return;
+            const ch = raw[i];
+            if (escBuf.length > 0) {
+                escBuf += ch;
+                if (escTimer)
+                    clearTimeout(escTimer);
+                if (escBuf.length >= 3) {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }
+                else {
+                    escTimer = setTimeout(() => {
+                        const seq = escBuf;
+                        escBuf = '';
+                        handle(seq);
+                    }, 50);
+                }
+                continue;
+            }
+            if (ch === '\x1b') {
+                escBuf = ch;
+                escTimer = setTimeout(() => {
+                    const seq = escBuf;
+                    escBuf = '';
+                    handle(seq);
+                }, 50);
+                continue;
+            }
+            handle(ch);
+        }
+    });
+}
+/** One-shot · `codehere "review src/auth.ts"` runs that task and exits. */
+export async function runOneShot(prompt) {
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(warning('No specialist installed. Run `codehere setup` and try again.'));
+        process.exit(1);
+    }
+    try {
+        await spawnViaConductor(prompt);
+    }
+    catch (err) {
+        console.error(error('Error:'), err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+// ── Dispatch ─────────────────────────────────────────────────────────────
+async function executeInput(input, state) {
+    const lower = input.toLowerCase();
+    if (lower.startsWith('/')) {
+        const parts = input.substring(1).trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1).join(' ');
+        await handleSlash(cmd, args, state);
+        return;
+    }
+    // Legacy non-slash syntax (v0.2 backwards compat)
+    if (lower.startsWith('explain '))
+        return runTask(`Explain this file in plain English: ${input.substring(8).trim()}`, state);
+    if (lower.startsWith('e '))
+        return runTask(`Explain this file in plain English: ${input.substring(2).trim()}`, state);
+    if (lower.startsWith('fix ')) {
+        const rest = input.substring(4).trim();
+        const parts = rest.split(/\s+/);
+        return runTask(`fix ${parts[0]}: ${parts.slice(1).join(' ')}`, state);
+    }
+    if (lower.startsWith('review '))
+        return runTask(`Review ${input.substring(7).trim()} for bugs, security, and risks.`, state);
+    if (lower.startsWith('plan '))
+        return runTask(`Plan: ${input.substring(5).trim()}. Break into steps.`, state);
+    // Default: ask via Conductor
+    await runTask(input, state);
+}
+async function handleSlash(cmd, args, state) {
+    if (cmd === 'help' || cmd === '?') {
+        showSlashCommandMenu();
+        return;
+    }
+    if (cmd === 'clear') {
+        stdout.write('\x1b[2J\x1b[H');
+        printWelcome();
+        return;
+    }
+    if (cmd === 'exit' || cmd === 'quit' || cmd === 'q') {
+        console.log(colors.dim('Goodbye! 👋'));
+        process.exit(0);
+    }
+    if (cmd === 'agents') {
+        const all = availableAgents();
+        newline();
+        console.log(colors.bold('  Installed specialists:'));
+        for (const a of all) {
+            const tag = a.installed ? colors.green('  ✓ ') : colors.dim('  · ');
+            const status = a.installed ? '' : colors.dim('  (not installed)');
+            console.log(tag + colors.cyan(a.id.padEnd(14)) + colors.dim(a.label) + status);
+        }
+        newline();
+        return;
+    }
+    if (cmd === 'history' || cmd === 'h') {
+        if (state.history.length === 0) {
+            console.log(colors.dim('No command history yet.'));
+        }
+        else {
+            console.log(colors.bold('Recent Commands:'));
+            state.history.slice(-10).forEach((h, i) => {
+                const preview = h.command.length > 60 ? h.command.slice(0, 57) + '…' : h.command;
+                console.log(colors.dim(`  ${i + 1}. ${preview}`));
+            });
+        }
+        return;
+    }
+    if (cmd === 'undo') {
+        console.log(colors.dim('  /undo is queued for v0.5 (F3 memory layer).'));
+        console.log(colors.dim('  For now: ') + colors.cyan('git diff') + colors.dim(' / ') + colors.cyan('git checkout -- <file>'));
+        return;
+    }
+    const def = SLASH_COMMANDS.find((c) => c.name === cmd);
+    if (!def) {
+        console.log(warning(`Unknown command: /${cmd}`));
+        console.log(colors.dim('Type /help to see available commands'));
+        return;
+    }
+    if (def.kind === 'task' && def.promptTemplate) {
+        if (!args && def.args) {
+            console.log(warning(`Usage: /${def.name} ${def.args}`));
+            return;
+        }
+        await runTask(def.promptTemplate(args), state);
+        return;
+    }
+    if (def.kind === 'sub' && def.subcommand) {
+        await runSubcommand(def.subcommand, args ? args.split(/\s+/) : []);
+        return;
+    }
+}
+function showSlashCommandMenu() {
+    newline();
+    console.log(colors.bold('  Slash commands'));
+    newline();
+    const maxNameLen = Math.max(...SLASH_COMMANDS.map((c) => c.name.length + c.args.length)) + 1;
+    for (const cmd of SLASH_COMMANDS) {
+        const signature = `/${cmd.name}${cmd.args ? ' ' + cmd.args : ''}`;
+        const pad = ' '.repeat(Math.max(0, maxNameLen + 2 - signature.length + 8));
+        const badge = cmd.noKey ? colors.dim(' (free)') : '';
+        console.log(`  ${colors.cyan(signature)}${pad}${colors.dim(cmd.description)}${badge}`);
+    }
+    newline();
+    console.log(colors.dim('  Type any command with / prefix, or just ask a question directly.'));
+    newline();
+}
+// ── Run-task / Run-subcommand helpers ────────────────────────────────────
+async function runTask(prompt, state) {
+    await spawnViaConductor(prompt, state);
+}
+async function runSubcommand(name, extraArgs) {
+    const here = fileURLToPath(import.meta.url);
+    const cliPath = join(dirname(here), '..', '..', 'index.js');
+    await new Promise((resolve) => {
+        const child = childSpawn('node', [cliPath, name, ...extraArgs], { stdio: 'inherit' });
+        child.on('close', () => resolve());
+        child.on('error', (err) => {
+            console.log(error('  ' + err.message));
+            resolve();
+        });
+    });
+}
+async function spawnViaConductor(prompt, state) {
+    const installed = availableAgents().filter((a) => a.installed);
+    if (installed.length === 0) {
+        console.log(warning('No specialist installed — install one and try again.'));
+        return;
+    }
+    const manager = SessionManager.getInstance();
+    const session = manager.spawn(prompt, 'conductor', { cwd: process.cwd() });
+    console.log(colors.dim('  ┌─ ') +
+        colors.bold(session.sessionId.slice(0, 8)) +
+        colors.dim(' · ' + new Date(session.startedAt).toLocaleTimeString()));
+    let captured = '';
+    await new Promise((resolve) => {
+        const unsubscribe = session.subscribe((event) => {
+            const text = renderEvent(event);
+            if (text)
+                captured += text + '\n';
+            if (event.type === 'codehere:complete' || event.type === 'codehere:error' || event.type === 'exit') {
+                unsubscribe();
+                resolve();
+            }
+        });
+    });
+    const status = session.status;
+    const verdict = status === 'completed'
+        ? success('  └─ done')
+        : status === 'killed'
+            ? warning('  └─ killed')
+            : error('  └─ ' + status);
+    console.log(verdict);
+    if (state) {
+        state.history.push({ command: prompt, response: captured, timestamp: new Date().toISOString() });
+    }
+}
+function renderEvent(event) {
+    switch (event.type) {
+        case 'codehere:conductor-routing': {
+            const data = event.data;
+            console.log(colors.dim('  │ ') +
+                colors.bold('routing → ') +
+                colors.cyan(data.delegatedTo ?? '?') +
+                colors.dim(' · ' + (data.reason ?? '')));
+            return null;
+        }
+        case 'stdout':
+        case 'stderr': {
+            const data = event.data;
+            const line = data?.line;
+            if (line) {
+                const text = String(line).trimEnd();
+                if (text) {
+                    console.log(colors.dim('  │ ') + text);
+                    return text;
+                }
+            }
+            return null;
+        }
+        case 'error': {
+            const data = event.data;
+            if (data?.message)
+                console.log(colors.red('  │ ✗ ') + data.message);
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=repl.js.map