compact-agent 1.33.6 → 1.35.0

package/bin/crowcoder.js

@@ -61,4 +61,98 @@
   }
 })();
 
+// ── --prompt / --prompt-file (non-interactive single-chain mode) ──
+//
+// When this CLI is being driven by an external harness (Terminal-Bench,
+// CI scripts, etc.) we need a way to:
+//   1. accept a prompt without opening the REPL
+//   2. run one runQuery chain to completion
+//   3. exit with a meaningful code (0 = success, 1 = error)
+//
+// Two surface forms:
+//   --prompt "do the thing"        — inline text
+//   --prompt-file path/to/task.txt — read from disk; useful for long
+//                                    or multi-line task descriptions
+//                                    that would otherwise need careful
+//                                    shell quoting.
+//
+// We export the resolved prompt via COMPACT_AGENT_PROMPT (or
+// COMPACT_AGENT_PROMPT_FILE, which the loader reads with fs.readFile).
+// src/index.ts branches on these env vars near the top of main() and
+// skips the REPL entirely.
+//
+// A bare `--non-interactive` flag is also accepted as a no-prompt
+// signal — useful when paired with a config that already has
+// `__crowcoderQueuedInput` set, but mostly an alias for the same path.
+// ESM-safe sync FS load. import() is async (returns a promise) and the
+// flag parser MUST run synchronously before the dynamic import of
+// dist/index.js below. createRequire gives us a real CommonJS require
+// inside ESM — same path Node recommends for sync fs in ESM scripts.
+const { createRequire } = await import('node:module');
+const __require = createRequire(import.meta.url);
+
+(() => {
+  const fs = __require('node:fs');
+  const argv = process.argv;
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--prompt') {
+      const next = argv[i + 1];
+      if (typeof next !== 'string') {
+        process.stderr.write('[compact-agent] --prompt requires an argument.\n');
+        process.exit(2);
+      }
+      process.env.COMPACT_AGENT_PROMPT = next;
+      process.env.COMPACT_AGENT_NON_INTERACTIVE = '1';
+      argv.splice(i, 2);
+      i--;
+      continue;
+    }
+    if (a && a.startsWith('--prompt=')) {
+      process.env.COMPACT_AGENT_PROMPT = a.slice('--prompt='.length);
+      process.env.COMPACT_AGENT_NON_INTERACTIVE = '1';
+      argv.splice(i, 1);
+      i--;
+      continue;
+    }
+    if (a === '--prompt-file') {
+      const next = argv[i + 1];
+      if (typeof next !== 'string') {
+        process.stderr.write('[compact-agent] --prompt-file requires a path.\n');
+        process.exit(2);
+      }
+      try {
+        process.env.COMPACT_AGENT_PROMPT = fs.readFileSync(next, 'utf8');
+      } catch (err) {
+        process.stderr.write(`[compact-agent] could not read --prompt-file: ${err && err.message ? err.message : err}\n`);
+        process.exit(2);
+      }
+      process.env.COMPACT_AGENT_NON_INTERACTIVE = '1';
+      argv.splice(i, 2);
+      i--;
+      continue;
+    }
+    if (a === '--non-interactive') {
+      process.env.COMPACT_AGENT_NON_INTERACTIVE = '1';
+      argv.splice(i, 1);
+      i--;
+      continue;
+    }
+    // --perm <mode>: override permission mode without touching saved
+    // config. Critical for harness runs that want yolo without
+    // mutating the user's interactive config file.
+    if (a === '--perm') {
+      const next = argv[i + 1];
+      if (next && /^(ask|auto|yolo)$/.test(next)) {
+        process.env.COMPACT_AGENT_PERM_OVERRIDE = next;
+        argv.splice(i, 2);
+        i--;
+        continue;
+      }
+      process.stderr.write('[compact-agent] --perm requires ask|auto|yolo.\n');
+      process.exit(2);
+    }
+  }
+})();
+
 import('../dist/index.js');

package/dist/index.js

@@ -2679,14 +2679,33 @@ async function main() {
         }
         catch { /* never block startup on this */ }
     }
-    // Load or create config
+    // Load or create config.
+    //
+    // Non-interactive mode (COMPACT_AGENT_NON_INTERACTIVE=1) requires a
+    // pre-existing config — the setup wizard would block on stdin
+    // forever in a piped/headless environment. We bail with a clear
+    // error if no config is on disk, so the caller knows to run the
+    // wizard interactively first (`compact-agent` with no args).
+    const nonInteractive = process.env.COMPACT_AGENT_NON_INTERACTIVE === '1';
     let config;
     if (!configExists()) {
+        if (nonInteractive) {
+            process.stderr.write('[compact-agent] non-interactive mode requires a pre-existing config at ~/.compact-agent/config.json.\n' +
+                'Run `compact-agent` once interactively to walk through the setup wizard, OR write the config manually.\n');
+            process.exit(2);
+        }
         config = await setupWizard(rl);
     }
     else {
         config = loadConfig();
     }
+    // Per-invocation permission override (--perm flag). Doesn't touch
+    // saved config — purely a runtime knob so harness runs can force
+    // yolo without mutating the user's interactive permission setting.
+    const permOverride = process.env.COMPACT_AGENT_PERM_OVERRIDE;
+    if (permOverride === 'ask' || permOverride === 'auto' || permOverride === 'yolo') {
+        config.permissionMode = permOverride;
+    }
     // Apply the user's chosen color palette before anything paints. setPalette
     // mutates the exported `theme` object in place so the banner, prompt, and
     // every subsequent log line render in the right colors.
@@ -2740,9 +2759,14 @@ async function main() {
     if (memoryContext) {
         messages.push({ role: 'system', content: memoryContext });
     }
-    // Show startup display based on theme setting
+    // Show startup display based on theme setting. Skipped entirely in
+    // non-interactive mode — banners are noise when a harness is parsing
+    // our stdout.
     const themeMode = config.theme || 'full';
-    if (themeMode === 'full') {
+    if (nonInteractive) {
+        // intentionally no output
+    }
+    else if (themeMode === 'full') {
         // Full mode: banner. ASCII splash removed per user request — both `full`
         // and `compact` themes now render the same banner block.
         printThemedBanner(config.provider, config.model, mode.current, config.permissionMode, session.id, ALL_TOOLS.map((t) => t.name));
@@ -2819,7 +2843,13 @@ async function main() {
     // (the promises variant doesn't expose it). Some platforms / terminals
     // don't deliver every F-key — failure here is a silent no-op; users can
     // fall back to /dictate and /voice slash commands.
+    //
+    // Skipped in non-interactive mode — there's no user at the keyboard,
+    // and listening to keypress would consume bytes from the harness's
+    // piped stdin that may or may not look like F-keys.
     try {
+        if (nonInteractive)
+            throw new Error('skip:nonInteractive');
         const readlineCb = await import('node:readline');
         const { describeStatus, describeLocation } = await import('./status.js');
         readlineCb.emitKeypressEvents(stdin);
@@ -3530,6 +3560,85 @@ async function main() {
         permissionMode: config.permissionMode,
         cwd: process.cwd(),
     });
+    // ── Non-interactive single-chain mode ─────────────────
+    //
+    // Triggered by `--prompt <text>` / `--prompt-file <path>` (parsed in
+    // bin/crowcoder.js and stashed on COMPACT_AGENT_PROMPT). We push the
+    // prompt as one user message, run a single runQuery to completion,
+    // and exit. No REPL, no banner, no hotkey listener, no live queue.
+    //
+    // This is the entrypoint that lets external harnesses (Terminal-Bench,
+    // CI scripts, etc.) drive compact-agent with a single task and read
+    // its output cleanly. Stdin is left untouched — readline never
+    // attaches — so piped stdin won't confuse anything.
+    if (process.env.COMPACT_AGENT_NON_INTERACTIVE === '1') {
+        const promptText = process.env.COMPACT_AGENT_PROMPT;
+        if (!promptText || !promptText.trim()) {
+            process.stderr.write('[compact-agent] non-interactive mode requires --prompt <text> or --prompt-file <path>.\n');
+            process.exit(2);
+        }
+        // ── F9: Empty-engagement guard (non-interactive nudge) ──
+        //
+        // Some failures in the 2026-05-25 baseline run came from the
+        // model emitting a single no-tool-call response and exiting —
+        // never actually attempting the work. polyglot-c-py, solana-data,
+        // and vim-terminal-task all showed this pattern. The model
+        // interpreted some aspect of the spec as "I can't do this" (e.g.
+        // "use vim" suggesting interactive editing) and bailed.
+        //
+        // In non-interactive mode there's no human to push back, so we
+        // prepend a system message that explicitly frames the contract:
+        // the agent must DO the work, with tools. Responses without tool
+        // calls are interpreted as "I'm done" — and F5+ DeCRIM will
+        // then walk the agent through verification.
+        //
+        // This is system-prompt-level and doesn't repeat per-turn (that
+        // would bloat context). It's a one-shot priming injection.
+        messages.push({
+            role: 'system',
+            content: 'You are running in NON-INTERACTIVE mode: no human will answer follow-up questions. ' +
+                'You must DO the work using the available tools (bash, write, edit, read, glob, grep, etc.) — ' +
+                'not describe what would need to be done. ' +
+                'If the task mentions a specific tool you do not have direct access to (e.g. "use vim"), ' +
+                'achieve the equivalent effect with the tools you do have. ' +
+                'If you lack information, USE A TOOL to investigate; do not ask the user. ' +
+                'A response with no tool calls is interpreted as "I am done" and triggers final verification.',
+        });
+        messages.push({ role: 'user', content: promptText.trim() });
+        try {
+            await runQuery({
+                config,
+                messages,
+                cwd: process.cwd(),
+                rl,
+                sessionId: session.id,
+                mode: mode.current,
+            });
+            // Run any session-stop hooks the user registered.
+            try {
+                await runHooks({ event: 'SessionStop', sessionId: session.id, cwd: process.cwd(), permissionMode: config.permissionMode });
+            }
+            catch { /* never fail an otherwise-successful run on hook errors */ }
+            // Close readline so the Node process can exit cleanly. Without
+            // this, the readline interface keeps the event loop alive until
+            // the user types something (which they can't, since stdin is
+            // piped from a harness).
+            try {
+                rl.close();
+            }
+            catch { /* noop */ }
+            process.exit(0);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[compact-agent] chain failed: ${msg}\n`);
+            try {
+                rl.close();
+            }
+            catch { /* noop */ }
+            process.exit(1);
+        }
+    }
     // Main REPL loop
     while (true) {
         let input;