compact-agent 1.27.2 → 1.28.1

package/dist/index.js

@@ -5,6 +5,7 @@ import { readFileSync as fsReadFileSync, writeFileSync as fsWriteFileSync, unlin
 import { tmpdir } from 'node:os';
 import { join as pathJoin } from 'node:path';
 import { spawnSync } from 'node:child_process';
+import { initDebug, emit as dbgEmit, setDebugLevel, getDebugStatus, tailDebug } from './debug.js';
 import chalk from 'chalk';
 import { loadConfig, saveConfig, configExists, getConfigDir } from './config.js';
 import { resetClient } from './api.js';
@@ -404,9 +405,19 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             }
             return { handled: true };
         // ── Clear ─────────────────────────────────────────
-        case '/clear':
+        case '/clear': {
+            // Also reset the global state that's keyed to the conversation
+            // so Shift+F3 / Shift+F1 / F12 don't surface stale data from
+            // before the clear. The main REPL loop replaces `messages` via
+            // `newMessages`; we just nuke the side-channel globals.
+            const g = globalThis;
+            g.__crowcoderQueuedInput = '';
+            g.__voiceLastFullResponse = null;
+            g.__voiceLastChunk = null;
+            g.__lastToolCall = null;
             console.log(chalk.dim('  Conversation cleared.'));
             return { handled: true, newMessages: [] };
+        }
         // ── Backtrack — rewind to a prior user turn (Codex audit item 4) ──
         //   /back          list recent user messages with numbers
         //   /back <n>      truncate conversation to BEFORE the nth most-recent
@@ -465,14 +476,23 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         case '/fork':
         case '/branch': {
             const forkName = args.trim() || `fork of ${session.name}`;
-            // Save the current session under its existing ID first so the
-            // pre-fork state is recoverable via /resume.
-            saveSession({ ...session, messages: [...messages] }).catch(() => { });
+            // Snapshot the pre-fork state in a SEPARATE object before
+            // mutating the live `session` reference — otherwise both save
+            // calls write to whichever ID the mutation has currently set,
+            // overwriting the original branch and silently breaking the
+            // "previous session reachable via /resume" promise. (Bug found
+            // by audit; previously the spread happened AFTER `session.id`
+            // was reassigned, so both saves landed under the new ID.)
             const previousId = session.id;
-            // Mutate the active session in place: new ID + name + timestamps,
-            // same messages. The REPL keeps running against `session` so
-            // mutation is enough — no need to plumb a "swap" through the
-            // return value.
+            const previousSnapshot = {
+                ...session,
+                id: previousId,
+                messages: [...messages],
+            };
+            saveSession(previousSnapshot).catch(() => { });
+            // Now mutate the active session in place. The REPL keeps
+            // running against `session` so mutation is enough — no need
+            // to plumb a swap through the return value.
             session.id = generateSessionId();
             session.name = forkName;
             session.createdAt = new Date().toISOString();
@@ -544,6 +564,72 @@ export function handleSlashCommand(input, config, messages, session, mode) {
             console.log(chalk.dim(`  Sending ${result.length} chars from editor…`));
             return { handled: true, injectPrompt: result };
         }
+        // ── Debug — toggle instrumentation + tail event log ──
+        // Surface for the NDJSON debug stream written to
+        // ~/.compact-agent/debug/<sessionId>.jsonl. Used by reviewers
+        // driving the agent + by users diagnosing their own issues.
+        //
+        //   /debug              show current level + log path + event count
+        //   /debug on [level]   turn instrumentation on (default level: info)
+        //   /debug off          turn instrumentation off (existing log file is kept)
+        //   /debug tail [N]     print the last N events (default 20) inline
+        case '/debug': {
+            const parts = args.trim().split(/\s+/).filter(Boolean);
+            const sub = (parts[0] || '').toLowerCase();
+            if (!sub) {
+                const s = getDebugStatus();
+                console.log(chalk.dim(`  Debug level: ${s.level}`));
+                console.log(chalk.dim(`  Log file:    ${s.logPath || '(no log — level is off)'}`));
+                console.log(chalk.dim(`  Events:      ${s.eventCount} this session`));
+                console.log(chalk.dim(`  Uptime:      ${(s.uptimeMs / 1000).toFixed(1)}s`));
+                console.log('');
+                console.log(chalk.dim(`  /debug on [info|debug|trace]`));
+                console.log(chalk.dim(`  /debug off`));
+                console.log(chalk.dim(`  /debug tail [N]`));
+                return { handled: true };
+            }
+            if (sub === 'off') {
+                setDebugLevel('off');
+                console.log(chalk.green('  Debug: off'));
+                return { handled: true };
+            }
+            if (sub === 'on') {
+                const lvl = (parts[1] || 'info').toLowerCase();
+                if (lvl !== 'info' && lvl !== 'debug' && lvl !== 'trace') {
+                    console.log(chalk.yellow(`  Unknown level "${lvl}". Use info, debug, or trace.`));
+                    return { handled: true };
+                }
+                setDebugLevel(lvl);
+                const s = getDebugStatus();
+                console.log(chalk.green(`  Debug: ${lvl} — writing to ${s.logPath}`));
+                return { handled: true };
+            }
+            if (sub === 'tail') {
+                const n = parseInt(parts[1] || '20', 10);
+                const lines = tailDebug(Number.isFinite(n) && n > 0 ? n : 20);
+                if (lines.length === 0) {
+                    console.log(chalk.dim('  (no events — turn on with /debug on)'));
+                    return { handled: true };
+                }
+                console.log(chalk.dim(`  Last ${lines.length} debug events:`));
+                for (const ln of lines) {
+                    try {
+                        const rec = JSON.parse(ln);
+                        const ts = String(rec.rel || 0).padStart(6) + 'ms';
+                        const lvl = (rec.lvl || '').toUpperCase().padEnd(5);
+                        const ev = rec.ev || '';
+                        const d = rec.data ? '  ' + JSON.stringify(rec.data).slice(0, 120) : '';
+                        console.log(chalk.dim(`    ${ts}  ${lvl}  ${ev}${d}`));
+                    }
+                    catch {
+                        console.log(chalk.dim(`    ${ln.slice(0, 200)}`));
+                    }
+                }
+                return { handled: true };
+            }
+            console.log(chalk.yellow(`  Unknown /debug subcommand "${sub}". Try: /debug, /debug on, /debug off, /debug tail`));
+            return { handled: true };
+        }
         // ── History ───────────────────────────────────────
         case '/history': {
             const stats = getCompactionStats(messages);
@@ -2033,11 +2119,22 @@ export function handleSlashCommand(input, config, messages, session, mode) {
         // user is testing the pipeline or running under a terminal that strips
         // function keys. Records up to 30s, transcribes, injects as next prompt.
         case '/dictate': {
-            const maxSec = parseInt(args, 10) || 30;
-            console.log(chalk.dim(`  /dictate — recording up to ${maxSec}s…`));
+            // Parse + clamp the duration argument.
+            //   /dictate          → 30s default
+            //   /dictate 60       → 60s, clamped to [1, 300]
+            //   /dictate 0        → 30s (user clearly wanted default or
+            //                       cancel; previously parseInt(0) || 30
+            //                       gave 30 silently)
+            //   /dictate -5       → 30s (negative is nonsense)
+            //   /dictate abc      → 30s default
+            const parsed = parseInt(args, 10);
+            const sec = Number.isFinite(parsed) && parsed > 0
+                ? Math.min(300, parsed)
+                : 30;
+            console.log(chalk.dim(`  /dictate — recording up to ${sec}s…`));
             // Return as an async-injected prompt; we resolve the recording
             // synchronously here for simplicity (REPL is blocking anyway).
-            return { handled: true, injectPrompt: '__DICTATE__' + maxSec };
+            return { handled: true, injectPrompt: '__DICTATE__' + sec };
         }
         // /accessibility — show or toggle the accessibility sub-block
         //   /accessibility                  — print status
@@ -2203,6 +2300,19 @@ async function main() {
     // Create session
     const mode = { current: 'dev' };
     const session = createSession(process.cwd(), config.model, config.provider, mode.current);
+    // ── Debug instrumentation ─────────────────────────────────
+    // Initialize early so subsequent emit() calls land in the right file.
+    // Reads $COMPACT_AGENT_DEBUG which bin/crowcoder.js may have set from
+    // the --debug CLI flag. Level 'off' is a no-op; non-off opens an
+    // NDJSON log at ~/.compact-agent/debug/<sessionId>.jsonl.
+    initDebug(session.id);
+    dbgEmit('info', 'session.start', {
+        cwd: process.cwd(),
+        model: config.model,
+        provider: config.provider,
+        mode: mode.current,
+        permissionMode: config.permissionMode,
+    });
     const messages = [];
     // Session start hook + memory persistence
     await runHooks({ event: 'SessionStart', sessionId: session.id, cwd: process.cwd(), permissionMode: config.permissionMode });
@@ -2534,15 +2644,29 @@ async function main() {
                     // Second Esc within window — fire /back.
                     lastEscapeMs = 0;
                     // Enqueue the slash command as queued input. The REPL loop
-                    // picks it up + executes /back the same way as if typed.
+                    // picks it up + dispatches /back on the next iteration.
                     globalThis.__crowcoderQueuedInput = '/back\n';
                     announce('Esc-Esc', 'Rewinding to previous user turn.');
-                    // Nudge readline by writing an empty line so the question
-                    // resolves and the main loop's queued-input drain fires.
+                    // Resolve the pending rl.question() so the main loop
+                    // actually moves on. Previously this used stdin.write('\n')
+                    // which DOESN'T interrupt readline — it merely adds a
+                    // newline to the input stream that readline reads as if
+                    // the user typed it, leaving the REPL stuck until the user
+                    // pressed Enter manually. emit('line', '') triggers the
+                    // 'line' event that rl.question internally listens for,
+                    // resolving the promise immediately. (Bug found by audit.)
                     try {
-                        stdin.write('\n');
+                        rl.emit('line', '');
+                    }
+                    catch {
+                        // Fallback path if rl.emit isn't accepted for some reason
+                        // (e.g. on a future readline version): still nudge via
+                        // stdin so the user can recover by pressing any key.
+                        try {
+                            stdin.write('\n');
+                        }
+                        catch { /* noop */ }
                     }
-                    catch { /* noop */ }
                     return;
                 }
                 lastEscapeMs = now;
@@ -2868,6 +2992,8 @@ async function main() {
         }
         // Slash commands
         if (trimmed.startsWith('/')) {
+            // Truncate arg preview so debug logs don't blow up on /editor seeds etc.
+            dbgEmit('debug', 'slash.dispatch', { input: trimmed.slice(0, 200) });
             const result = handleSlashCommand(trimmed, config, messages, session, mode);
             if (result.shouldExit)
                 break;