klyro 1.0.4 → 1.0.6

package/dist/cli/repl.js

@@ -25,7 +25,7 @@ import { parseUnifiedDiff } from '../tui/diff-parser.js';
 import { parse } from './slash/parser.js';
 import { resolveProvider, providerHelp, lastProviderError } from '../providers.js';
 import { readVersion } from '../version.js';
-import { MouseFilter, MOUSE_ENABLE, MOUSE_DISABLE, createReadWrapper } from '../tui/mouse.js';
+import { MouseFilter, MOUSE_ENABLE, MOUSE_DISABLE, PASTE_ENABLE, PASTE_DISABLE, PasteFilter, createReadWrapper } from '../tui/mouse.js';
 import { inferProviderFromBaseURL } from '../agent/registry.js';
 import { getDefaultSessionStore } from '../persistence/session.js';
 import { buildSystemPrompt, parseImageInput } from '../context/system-prompt.js';
@@ -291,6 +291,10 @@ export async function startRepl(opts = {}) {
     let lastStatus = null;
     const pendingQueue = [];
     let isMounted = false;
+    // Live vim input mode for the TUI (toggled by /vim, persisted to config).
+    let vimLive = 'insert';
+    // Custom-command recursion guard (a command body may invoke /commands).
+    const customDepthRef = { current: 0 };
     let directHooks;
     // Plain-text mirror for exit replay (scroll.md §1.2: session survives in
     // native scrollback after the alt screen is torn down). Cap 300 lines.
@@ -393,6 +397,7 @@ export async function startRepl(opts = {}) {
     // IMPORTANT: Ink 7 reads stdin via 'readable' + stdin.read() (paused mode),
     // never 'data' events — so the tap wraps read(), not emit().
     const mouseFilter = new MouseFilter();
+    const pasteFilter = new PasteFilter();
     const origStdinRead = process.stdin.read.bind(process.stdin);
     const origStdinEmit = process.stdin.emit.bind(process.stdin);
     let mouseTapInstalled = false;
@@ -405,18 +410,36 @@ export async function startRepl(opts = {}) {
             catch { /* ignore */ }
         }
     }
+    // Bracketed paste: bulk-insert into the input buffer instead of
+    // char-at-a-time typing (no autocomplete/history churn per char).
+    function dispatchPastes(pastes) {
+        for (const p of pastes) {
+            try {
+                if (isMounted && directHooks)
+                    directHooks.pasteText(p);
+            }
+            catch { /* ignore */ }
+        }
+    }
     function installMouseTap() {
         if (!isAltScreen || mouseTapInstalled)
             return;
         mouseTapInstalled = true;
+        // Bracketed paste on: the terminal wraps pastes in ESC[200~ … ESC[201~.
+        try {
+            process.stdout.write(PASTE_ENABLE);
+        }
+        catch { /* ignore */ }
         const stdinAny = process.stdin;
         // Primary path: Ink's paused-mode read loop.
-        stdinAny.read = createReadWrapper(origStdinRead, mouseFilter, (d) => dispatchWheels([d]));
+        stdinAny.read = createReadWrapper(origStdinRead, mouseFilter, (d) => dispatchWheels([d]), { onPaste: (p) => dispatchPastes([p]), pasteFilter });
         // Fallback path: flowing mode ('data' events), e.g. if any library
         // resumes the stream. Same split, same dispatch.
         stdinAny.emit = (...a) => {
             if (a[0] === 'data' && Buffer.isBuffer(a[1])) {
-                const split = mouseFilter.push(a[1]);
+                const psplit = pasteFilter.push(a[1]);
+                dispatchPastes(psplit.pastes);
+                const split = mouseFilter.push(psplit.kept);
                 dispatchWheels(split.wheels);
                 if (split.kept.length === 0)
                     return false;
@@ -430,6 +453,11 @@ export async function startRepl(opts = {}) {
             return;
         mouseTapInstalled = false;
         mouseFilter.reset();
+        pasteFilter.reset();
+        try {
+            process.stdout.write(PASTE_DISABLE);
+        }
+        catch { /* ignore */ }
         const stdinAny = process.stdin;
         stdinAny.read = origStdinRead;
         stdinAny.emit = origStdinEmit;
@@ -457,7 +485,9 @@ export async function startRepl(opts = {}) {
         if (!isAltScreen)
             return;
         const sink = (...args) => {
-            const line = `[${new Date().toISOString()}] ${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}`;
+            // Scrub secrets before the line reaches the ring buffer or disk —
+            // stray provider/tool logs must never persist credentials.
+            const line = redact(`[${new Date().toISOString()}] ${args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}`);
             consoleRing.push(line);
             if (consoleRing.length > 200)
                 consoleRing.splice(0, consoleRing.length - 200);
@@ -700,6 +730,13 @@ export async function startRepl(opts = {}) {
         onMounted: (hooks) => {
             directHooks = hooks;
             isMounted = true;
+            // Apply a live vim mode toggled before mount.
+            if (vimLive !== 'insert') {
+                try {
+                    hooks.setVimMode(vimLive);
+                }
+                catch { /* ignore */ }
+            }
             for (const ev of pendingQueue) {
                 if (ev.kind === 'status')
                     hooks.updateStatus(ev.patch);
@@ -809,6 +846,7 @@ export async function startRepl(opts = {}) {
         let activeCallId = null;
         let activeCallName = null;
         let activeCallArgs = '';
+        let runEndStatus = 'error';
         try {
             const result = await run({
                 task: taskText,
@@ -941,6 +979,7 @@ export async function startRepl(opts = {}) {
             });
             if (result.finalText)
                 lastAssistantText = result.finalText;
+            runEndStatus = result.status;
             if (result.verification) {
                 const v = result.verification;
                 queuedAppend({
@@ -980,6 +1019,12 @@ export async function startRepl(opts = {}) {
             queuedAppend({ id: `err-${Date.now()}`, kind: 'error', message });
             queuedStatus({ status: 'error', errorMessage: message });
         }
+        // sessionEnd hooks: best-effort end-of-run side effects. Never throws.
+        try {
+            const { runSessionEndHooks } = await import('./hooks.js');
+            await runSessionEndHooks(cwd, sessionId, runEndStatus);
+        }
+        catch { /* ignore */ }
     }
     async function handleSlash(cmd) {
         switch (cmd.kind) {
@@ -1050,7 +1095,30 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'memory': {
-                queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: 'Memory: .klyro/memory/session-notes.md (stub) — use /memory to view', role: 'assistant' });
+                const { loadMemory } = await import('../context/memory.js');
+                const notes = (await loadMemory(cwd)).trim();
+                queuedAppend({
+                    id: `mem-${Date.now()}`,
+                    kind: 'text',
+                    text: notes ? `Memory (.klyro/memory/session-notes.md):\n${notes.slice(0, 4000)}` : 'Memory is empty — the agent records durable notes here via memory_write.',
+                    role: 'assistant',
+                });
+                return;
+            }
+            case 'memory-append': {
+                // Human write path: same redaction + atomicity as memory_write.
+                if (!cmd.text) {
+                    queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: 'usage: /memory append <text>', role: 'assistant' });
+                    return;
+                }
+                try {
+                    const { memoryWrite } = await import('../context/memory.js');
+                    const p = await memoryWrite(cwd, cmd.text);
+                    queuedAppend({ id: `mem-${Date.now()}`, kind: 'text', text: `Noted → ${p}`, role: 'assistant' });
+                }
+                catch (err) {
+                    queuedAppend({ id: `mem-err-${Date.now()}`, kind: 'error', message: `memory append failed: ${err instanceof Error ? err.message : String(err)}` });
+                }
                 return;
             }
             case 'jobs': {
@@ -1109,8 +1177,8 @@ export async function startRepl(opts = {}) {
             case 'undo': {
                 try {
                     const { undo } = await import('../checkpoints/store.js');
-                    await undo(cwd);
-                    queuedAppend({ id: `undo-${Date.now()}`, kind: 'text', text: 'Undone last checkpoint', role: 'assistant' });
+                    await undo(cwd, cmd.n ?? 1);
+                    queuedAppend({ id: `undo-${Date.now()}`, kind: 'text', text: `Undone ${cmd.n ?? 1} checkpoint(s)`, role: 'assistant' });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -1119,10 +1187,47 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'rewind': {
+                // Numbered rewind menu: bare /rewind lists snapshots (1 = latest),
+                // /rewind <n> restores, /rewind <n> summary also reports reverted files.
+                const { listCheckpointInfo, undo } = await import('../checkpoints/store.js');
+                const infos = await listCheckpointInfo(cwd);
+                if (infos.length === 0) {
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'No checkpoints yet — snapshots are taken after each file mutation.', role: 'assistant' });
+                    return;
+                }
+                const n = cmd.n ?? 1;
+                if (cmd.n === undefined && !cmd.summary) {
+                    const rows = infos.slice(0, 10).map((c) => {
+                        const age = c.ts > 0 ? ` (${Math.max(1, Math.round((Date.now() - c.ts) / 60000))}m ago)` : '';
+                        return `  ${c.index}. ${c.id.slice(0, 12)} · ${c.files} file(s)${age}`;
+                    });
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}\nrun /rewind <n> to restore, /rewind <n> summary for a revert report`, role: 'assistant' });
+                    return;
+                }
+                if (n < 1 || n > infos.length) {
+                    queuedAppend({ id: `rewind-err-${Date.now()}`, kind: 'error', message: `rewind failed: only ${infos.length} checkpoint(s), got n=${n}` });
+                    return;
+                }
                 try {
-                    const { rewind } = await import('../checkpoints/store.js');
-                    await rewind(cwd);
-                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text: 'Rewound to last checkpoint', role: 'assistant' });
+                    // Capture the pre-restore dirty state so `summary` can report it.
+                    let before = '';
+                    if (cmd.summary) {
+                        try {
+                            const { execFileSync } = await import('node:child_process');
+                            before = execFileSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf-8', timeout: 5000 });
+                        }
+                        catch {
+                            before = '';
+                        }
+                    }
+                    await undo(cwd, n);
+                    const target = infos[n - 1];
+                    let text = `Rewound to checkpoint ${n} (${target.id.slice(0, 12)}, ${target.files} file(s))`;
+                    if (cmd.summary) {
+                        const files = before.split('\n').map((l) => l.trim()).filter(Boolean).slice(0, 20);
+                        text += files.length > 0 ? `\nReverted working-tree changes:\n${files.map((f) => `  ${f}`).join('\n')}` : '\nWorking tree was clean before restore.';
+                    }
+                    queuedAppend({ id: `rewind-${Date.now()}`, kind: 'text', text, role: 'assistant' });
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -1130,6 +1235,27 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
+            case 'checkpoints': {
+                try {
+                    const { listCheckpointInfo } = await import('../checkpoints/store.js');
+                    const infos = await listCheckpointInfo(cwd);
+                    if (infos.length === 0) {
+                        queuedAppend({ id: `ckpt-${Date.now()}`, kind: 'text', text: 'No checkpoints yet.', role: 'assistant' });
+                    }
+                    else {
+                        const rows = infos.slice(0, 15).map((c) => {
+                            const age = c.ts > 0 ? ` (${Math.max(1, Math.round((Date.now() - c.ts) / 60000))}m ago)` : '';
+                            return `  ${c.index}. ${c.id.slice(0, 12)} · ${c.files} file(s)${age}`;
+                        });
+                        queuedAppend({ id: `ckpt-${Date.now()}`, kind: 'text', text: `Checkpoints (1 = latest):\n${rows.join('\n')}`, role: 'assistant' });
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    queuedAppend({ id: `ckpt-err-${Date.now()}`, kind: 'error', message: `checkpoints failed: ${msg}` });
+                }
+                return;
+            }
             case 'verify': {
                 const { detectVerifiers, primaryVerifyCommand } = await import('../verification/registry.js');
                 const { verify } = await import('../verification/engine.js');
@@ -1297,26 +1423,18 @@ export async function startRepl(opts = {}) {
                 return;
             }
             case 'init': {
-                const { writeFileSync, existsSync } = await import('node:fs');
-                const { join } = await import('node:path');
-                const target = join(cwd, 'KLYRO.md');
-                if (existsSync(target)) {
-                    queuedAppend({ id: `init-${Date.now()}`, kind: 'text', text: `KLYRO.md already exists at ${target}`, role: 'assistant' });
+                try {
+                    const { initProject, nextStepsText } = await import('./init.js');
+                    const { created, skipped } = await initProject(cwd);
+                    const lines = [
+                        ...created.map((f) => `created ${f}`),
+                        ...skipped.map((f) => `kept ${f}`),
+                        nextStepsText(),
+                    ];
+                    queuedAppend({ id: `init-${Date.now()}`, kind: 'text', text: lines.join('\n'), role: 'assistant' });
                 }
-                else {
-                    try {
-                        const { runScan } = await import('./scan.js');
-                        let out = '';
-                        const orig = process.stdout.write.bind(process.stdout);
-                        process.stdout.write = ((c) => { out += String(c); return true; });
-                        await runScan({ cwd, json: false });
-                        process.stdout.write = orig;
-                        writeFileSync(target, `# KLYRO.md\n\nProject: ${cwd}\n\n## Stack\n\n${out.slice(0, 2000)}\n\n## Conventions\n\n- Prefer smallest change that solves the task.\n- Run verification after edits.\n`);
-                        queuedAppend({ id: `init2-${Date.now()}`, kind: 'text', text: `created ${target}`, role: 'assistant' });
-                    }
-                    catch (err) {
-                        queuedAppend({ id: `init-err-${Date.now()}`, kind: 'error', message: `init failed: ${err instanceof Error ? err.message : String(err)}` });
-                    }
+                catch (err) {
+                    queuedAppend({ id: `init-err-${Date.now()}`, kind: 'error', message: `init failed: ${err instanceof Error ? err.message : String(err)}` });
                 }
                 return;
             }
@@ -1613,8 +1731,13 @@ export async function startRepl(opts = {}) {
             case 'cancel': {
                 ac.abort();
                 ac = new AbortController();
+                // Immediate abort cascade: background shells must not outlive the
+                // cancelled run (the runtime abort path also kills them, but the
+                // controller swap above means we do it here for immediacy).
+                const { killAllJobs } = await import('../tools/shell/background.js');
+                const killed = killAllJobs();
                 queuedStatus({ status: 'aborted' });
-                queuedAppend({ id: `cancel-${Date.now()}`, kind: 'text', text: 'cancelled current operation', role: 'assistant' });
+                queuedAppend({ id: `cancel-${Date.now()}`, kind: 'text', text: killed.length > 0 ? `cancelled current operation (${killed.length} background job(s) killed)` : 'cancelled current operation', role: 'assistant' });
                 return;
             }
             case 'shell': {
@@ -2468,13 +2591,72 @@ export async function startRepl(opts = {}) {
                 }
                 return;
             }
-            case 'keymap':
-            case 'vim':
+            case 'keymap': {
+                // Real binding table (mirrors src/tui/app.tsx useInput + mouse.ts).
+                // A stored `klyro.keymap` override is shown, not applied — the TUI
+                // has one compiled keymap; the value is kept for future remapping.
+                const { runConfig } = await import('./config.js');
+                const capture = async (args) => {
+                    const orig = process.stdout.write.bind(process.stdout);
+                    let out = '';
+                    process.stdout.write = ((c) => { out += String(c); return true; });
+                    try {
+                        await runConfig(args);
+                    }
+                    finally {
+                        process.stdout.write = orig;
+                    }
+                    return out;
+                };
+                const stored = cmd.name?.trim();
+                if (stored) {
+                    await capture(['set', 'klyro.keymap', stored]);
+                    queuedAppend({ id: `keymap2-${Date.now()}`, kind: 'text', text: `keymap note saved: ${stored} (display-only — the TUI uses its compiled keymap below)`, role: 'assistant' });
+                    return;
+                }
+                queuedAppend({
+                    id: `keymap-${Date.now()}`,
+                    kind: 'text',
+                    role: 'assistant',
+                    text: [
+                        'Keymap (TUI compiled bindings):',
+                        '  Enter send · Shift+Enter newline · Tab complete slash · Esc drop queued / Esc×2 cancel run',
+                        '  Ctrl+C cancel (1st) / quit (2nd) · Ctrl+O expand last tool group · Ctrl+G jump bottom',
+                        '  PgUp/PgDn or Ctrl+U/Ctrl+D half-page · Ctrl+Home/End top/bottom · Home/End jump · Space jump to unread',
+                        '  Ctrl+B/F page · Shift/Ctrl+↑/↓ line · ↑/↓ history (with text) else scroll · wheel ±3 lines',
+                        '  Shift+drag selects · /vim toggles vim input mode · /keymap <note> saves a display note',
+                    ].join('\n'),
+                });
+                return;
+            }
+            case 'vim': {
+                // Live vim input mode (not a config stub): toggles the TUI between
+                // insert and normal mode via directHooks; persists the choice too.
+                const want = cmd.state?.trim().toLowerCase();
+                const next = want === 'on' || want === 'normal' ? 'normal' : want === 'off' || want === 'insert' ? 'insert' : vimLive === 'insert' ? 'normal' : 'insert';
+                vimLive = next;
+                try {
+                    const { runConfig } = await import('./config.js');
+                    const orig = process.stdout.write.bind(process.stdout);
+                    process.stdout.write = (() => true);
+                    try {
+                        await runConfig(['set', 'klyro.vim', next]);
+                    }
+                    finally {
+                        process.stdout.write = orig;
+                    }
+                }
+                catch { /* persist best-effort */ }
+                if (isMounted && directHooks)
+                    directHooks.setVimMode(next);
+                queuedAppend({ id: `vim-${Date.now()}`, kind: 'text', text: `vim mode: ${next}${next === 'normal' ? ' (h/l/0/$ move · 3h counts · w/b words · x/D/dd delete · i/a insert · j/k scroll)' : ''}`, role: 'assistant' });
+                return;
+            }
             case 'theme':
             case 'statusline':
             case 'output-style': {
-                const key = cmd.kind === 'keymap' ? 'klyro.keymap' : cmd.kind === 'vim' ? 'klyro.vim' : cmd.kind === 'theme' ? 'klyro.theme' : cmd.kind === 'statusline' ? 'klyro.statusline' : 'klyro.outputStyle';
-                const val = (cmd.kind === 'keymap' ? cmd.name : cmd.kind === 'vim' ? cmd.state : cmd.kind === 'theme' ? cmd.name : cmd.kind === 'statusline' ? cmd.format : cmd.style)?.trim();
+                const key = cmd.kind === 'theme' ? 'klyro.theme' : cmd.kind === 'statusline' ? 'klyro.statusline' : 'klyro.outputStyle';
+                const val = (cmd.kind === 'theme' ? cmd.name : cmd.kind === 'statusline' ? cmd.format : cmd.style)?.trim();
                 const { runConfig } = await import('./config.js');
                 const capture = async (args) => {
                     const orig = process.stdout.write.bind(process.stdout);
@@ -2711,6 +2893,51 @@ export async function startRepl(opts = {}) {
                     await handleSlash(parse(target + extra));
                     return;
                 }
+                // Custom command files: .klyro/commands/*.md (project wins).
+                // Body expands $1..$9/$@ and runs as a prompt (recursion-guarded).
+                if (m) {
+                    const { loadCustomCommands, expandArgs } = await import('./slash/custom.js');
+                    const custom = loadCustomCommands(cwd).find((c) => c.name === m[1].toLowerCase());
+                    if (custom) {
+                        const depth = (customDepthRef.current ?? 0) + 1;
+                        if (depth > 3) {
+                            queuedAppend({ id: `cust-${Date.now()}`, kind: 'error', message: `custom command recursion limit: /${custom.name}` });
+                            return;
+                        }
+                        const argList = m[2] ? m[2].split(/\s+/) : [];
+                        const expanded = expandArgs(custom.body, argList);
+                        customDepthRef.current = depth;
+                        try {
+                            if (expanded.trimStart().startsWith('/'))
+                                await handleSlash(parse(expanded));
+                            else
+                                await runWithBridge(expanded);
+                        }
+                        finally {
+                            customDepthRef.current = depth - 1;
+                        }
+                        return;
+                    }
+                }
+                // MCP prompt-commands: /mcp__<server>__<prompt> [args...]
+                if (m) {
+                    const pm = /^mcp__([A-Za-z0-9_-]{1,20})__([A-Za-z0-9_-]+)$/.exec(m[1].toLowerCase());
+                    if (pm) {
+                        const { runMcpPrompt } = await import('../mcp/registry.js');
+                        const argList = m[2] ? m[2].split(/\s+/) : [];
+                        const args = {};
+                        argList.forEach((a, i) => { args[`arg${i + 1}`] = a; });
+                        args['input'] = m[2] ?? '';
+                        try {
+                            const text = await runMcpPrompt(cwd, pm[1], pm[2], args);
+                            await runWithBridge(text);
+                        }
+                        catch (err) {
+                            queuedAppend({ id: `mcp-p-${Date.now()}`, kind: 'error', message: `mcp prompt failed: ${err instanceof Error ? err.message : String(err)}` });
+                        }
+                        return;
+                    }
+                }
                 queuedAppend({
                     id: `unk-${Date.now()}`,
                     kind: 'error',

package/dist/cli/run.d.ts

@@ -66,6 +66,12 @@ export interface RunCliOptions {
     persist?: boolean;
     sessionId?: string;
     sessionsDir?: string;
+    /**
+     * Bare mode (`--bare`): skip MCP servers, all hooks, memory/KLYRO.md/L6
+     * context, and session persistence for fast deterministic runs. The model
+     * gets the base system prompt + tools only.
+     */
+    bare?: boolean;
     /** P1.4 — run the task under a named child-capable orchestrator context. */
     agent?: string;
     maxDepth?: number;
@@ -78,5 +84,5 @@ export interface RunCliOptions {
 export declare function shouldForceExit(lastSigintAt: number | undefined, now: number): boolean;
 export declare function runOnce(opts: RunCliOptions): Promise<number>;
 /** Wrap a system-prompt fn to inject Level-6 context (project map etc.) + KLYRO.md (4.4). */
-export declare function makeRunSystemPrompt(cwd: string, base: SystemPromptFn): Promise<SystemPromptFn>;
+export declare function makeRunSystemPrompt(cwd: string, base: SystemPromptFn, bare?: boolean): Promise<SystemPromptFn>;
 export declare function loadTranscript(path: string): Message[];