codehere 0.3.4 → 0.5.0-alpha.2

package/dist/infrastructure/orchestration/gemini-adapter.js

@@ -0,0 +1,425 @@
+/**
+ * Gemini adapter — F2 fifth concrete AgentAdapter (v0.4 sprint Track 1a).
+ *
+ * Wraps the official Google `gemini` CLI (`@google/gemini-cli`) as a subprocess.
+ * Headless mode: `gemini -p "<prompt>" -o stream-json --approval-mode=yolo`.
+ *
+ * Event schema verified against the installed gemini-cli source
+ * (StreamJsonFormatter / JsonStreamEventType in @google/gemini-cli bundle):
+ *   init         — { session_id, model, timestamp }
+ *   message      — { role: "user"|"assistant", content, delta?: bool }
+ *   tool_use     — { tool_name, tool_id, parameters }
+ *   tool_result  — tool execution output (best-effort parse — schema sparse)
+ *   error        — { error: {...} }
+ *   result       — { status: "success"|"error", stats?, error?: { type, message } }
+ *
+ * Token usage from result.stats: { total_tokens, input_tokens, output_tokens, cached }.
+ *
+ * Sandbox: Gemini's --approval-mode=yolo enables sandboxing by default. codehere is
+ * the external safety layer — its PreToolUse hook (F0) is where destructive-command
+ * scanning happens. We DISABLE Gemini's sandbox via GEMINI_SANDBOX=false so file
+ * writes / shell commands aren't blocked at the wrong layer. (Note: today's hook
+ * still only wraps Claude Code; for Gemini, codehere observes via session events
+ * and audits at task-completion. Per-tool blocking parity for non-Claude adapters
+ * is v0.4+ work — see project_v04_sprint.md Track 3.)
+ *
+ * Same structural pattern as ClaudeCodeAdapter / CodexAdapter / AiderAdapter:
+ * event buffer, late-joiner replay, SIGTERM→SIGKILL escalation, known-error
+ * fingerprints. Finalizes on `close` (not `exit`) so trailing stdout flushes.
+ * Kills the process group (negative pid) so subagents under gemini exit too.
+ */
+import { spawn, execFileSync } from 'child_process';
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { ProgressAggregator } from './progress-aggregator.js';
+import { applyMemoryPrefix } from './memory-injector.js';
+import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
+// `--approval-mode=yolo` auto-accepts every tool action without prompting (the
+// older `--yolo` flag is deprecated). codehere's safety hook is the external
+// gate, so gemini-side prompts would block headless tasks.
+//
+// `-o stream-json` — JSONL events, one per line, schema verified above.
+//
+// `--skip-trust` — skip the per-workspace trust prompt that gemini shows on
+// first run in a new directory.
+const HEADLESS_FLAGS = [
+    '--approval-mode',
+    'yolo',
+    '--skip-trust',
+    '-o',
+    'stream-json',
+];
+// Error patterns scoped to STDERR / result.error / error events only — NOT
+// every JSON-serialized event (which would false-positive on tool output).
+const ERROR_PATTERNS = [
+    {
+        code: 'auth_missing',
+        regex: /please set an auth method|GEMINI_API_KEY|GOOGLE_API_KEY|GOOGLE_GENAI_USE_VERTEXAI|GOOGLE_GENAI_USE_GCA|GOOGLE_APPLICATION_CREDENTIALS/i,
+        message: 'Gemini auth missing.',
+        recovery: 'Set GEMINI_API_KEY env var (free tier at https://aistudio.google.com/apikey) — or configure Vertex AI / Application Default Credentials per https://google-gemini.github.io/gemini-cli/docs/get-started/authentication.html',
+    },
+    {
+        code: 'auth_invalid',
+        regex: /authentication\s+failed|401\s*unauth|invalid\s+api\s+key|api\s+key\s+not\s+valid/i,
+        message: 'Gemini API key is rejected.',
+        recovery: 'Verify GEMINI_API_KEY at https://aistudio.google.com/apikey and re-export.',
+    },
+    {
+        code: 'rate_limit',
+        regex: /rate.?limit(ed)?|HTTP\s*429|too many requests/i,
+        message: 'Gemini rate-limited the request.',
+        recovery: 'Wait a minute and retry, or check your Google AI Studio quota.',
+    },
+    {
+        code: 'quota_exceeded',
+        regex: /\bRESOURCE_EXHAUSTED\b|quota[\s_]exceeded|insufficient[_\s]quota/i,
+        message: 'Google AI Studio / Vertex quota exhausted.',
+        recovery: 'Check quota at https://aistudio.google.com/ or top up your Google Cloud billing account.',
+    },
+];
+function scanForKnownError(text) {
+    for (const p of ERROR_PATTERNS) {
+        if (p.regex.test(text))
+            return { code: p.code, message: p.message, recovery: p.recovery };
+    }
+    return null;
+}
+export function spawnGemini(prompt, options = {}) {
+    const sessionId = randomUUID();
+    const startedAt = Date.now();
+    const emitter = new EventEmitter();
+    const buffer = [];
+    let statusValue = 'running';
+    let killRequested = false;
+    const cwd = options.cwd ?? process.cwd();
+    // F3 Task 8 — memory injection (same shape as every other adapter).
+    const injected = applyMemoryPrefix(prompt, cwd, options);
+    const finalPrompt = injected.prompt;
+    const snapshot = snapshotCwd(cwd);
+    const aggregator = new ProgressAggregator('gemini');
+    let stepsSnapshot = [];
+    let artifactsSnapshot;
+    let textAccum = '';
+    let usageSnapshot;
+    let errorEmitted = false;
+    const emit = (event) => {
+        buffer.push(event);
+        emitter.emit('event', event);
+        if (aggregator.ingest(event)) {
+            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
+            const snapEvt = {
+                type: 'codehere:steps',
+                timestamp: Date.now(),
+                data: { steps: stepsSnapshot },
+            };
+            buffer.push(snapEvt);
+            emitter.emit('event', snapEvt);
+        }
+        // Accumulate assistant text for the test-summary parser. Real schema:
+        // { type: 'message', role: 'assistant', content: '...', delta?: bool }.
+        // Both deltas (streaming chunks) and full messages contribute.
+        if (event.type === 'message') {
+            const data = event.data;
+            if (data?.role === 'assistant' && typeof data.content === 'string') {
+                textAccum += data.content;
+                // Only add a newline at non-delta boundaries to avoid breaking up streamed words
+                if (!event.data?.delta)
+                    textAccum += '\n';
+            }
+        }
+        // tool_result event — schema sparse in source; accept common output fields.
+        if (event.type === 'tool_result') {
+            const data = event.data;
+            const t = data?.output ?? data?.result ?? data?.content;
+            if (typeof t === 'string')
+                textAccum += t + '\n';
+        }
+        // Token usage comes ONLY in the final `result` event with status:'success',
+        // shape { stats: { input_tokens, output_tokens, total_tokens, cached } }.
+        if (event.type === 'result') {
+            const data = event.data;
+            if (data?.status === 'success' && data.stats) {
+                const s = data.stats;
+                usageSnapshot = {
+                    inputTokens: Number(s.input_tokens ?? 0),
+                    outputTokens: Number(s.output_tokens ?? 0),
+                    ...(s.cached ? { cacheReadTokens: Number(s.cached) } : {}),
+                };
+            }
+        }
+        // Scoped error matching: ONLY look at stderr lines and the FAILURE form of
+        // the `result` event (status:"error"). DO NOT scan `error` stream events
+        // because gemini's headless docs explicitly classify them as "Non-fatal
+        // warnings and system errors" — e.g. loop-detection warnings emit `error`
+        // events with severity:"warning". The terminal failure signal is the final
+        // `result` event with status:"error". Treating non-fatal `error` events as
+        // a terminal codehere:error would falsely mark successful sessions as failed.
+        if (!errorEmitted) {
+            let text = '';
+            const data = event.data;
+            if (event.type === 'stderr' && data && typeof data.line === 'string') {
+                text = data.line;
+            }
+            else if (event.type === 'result') {
+                const r = data;
+                if (r?.status === 'error' && r.error) {
+                    text = `${r.error.type ?? ''} ${r.error.message ?? ''}`;
+                }
+            }
+            if (text) {
+                const hit = scanForKnownError(text);
+                if (hit) {
+                    errorEmitted = true;
+                    const errEvent = {
+                        type: 'codehere:error',
+                        timestamp: Date.now(),
+                        data: { code: hit.code, message: hit.message, recovery: hit.recovery },
+                    };
+                    buffer.push(errEvent);
+                    emitter.emit('event', errEvent);
+                }
+            }
+        }
+    };
+    // Disable Gemini's built-in sandbox — codehere is the external safety layer.
+    // GEMINI_SANDBOX=false trumps any sandbox-on default that --approval-mode=yolo
+    // would otherwise enable. (Settings precedence: env > settings.json > default.)
+    const spawnEnv = {
+        ...process.env,
+        GEMINI_SANDBOX: 'false',
+        ...(options.env ?? {}),
+    };
+    let child;
+    try {
+        child = spawn('gemini', ['-p', finalPrompt, ...HEADLESS_FLAGS, ...(options.extraArgs ?? [])], {
+            cwd,
+            env: spawnEnv,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            // Detach into its own process group so kill() can reap subagents.
+            detached: true,
+        });
+        // Don't keep the parent alive on this child alone.
+        child.unref();
+    }
+    catch (err) {
+        statusValue = 'error';
+        const msg = err instanceof Error ? err.message : String(err);
+        queueMicrotask(() => emit({ type: 'error', timestamp: Date.now(), data: { message: msg } }));
+        return {
+            sessionId,
+            startedAt,
+            prompt,
+            agent: 'gemini',
+            get status() {
+                return statusValue;
+            },
+            get steps() {
+                return stepsSnapshot;
+            },
+            get artifacts() {
+                return artifactsSnapshot;
+            },
+            subscribe(handler) {
+                for (const e of buffer)
+                    handler(e);
+                emitter.on('event', handler);
+                return () => emitter.off('event', handler);
+            },
+            kill() {
+                /* already not running */
+            },
+        };
+    }
+    let stdoutBuf = '';
+    child.stdout?.on('data', (chunk) => {
+        stdoutBuf += chunk.toString('utf-8');
+        let idx;
+        while ((idx = stdoutBuf.indexOf('\n')) >= 0) {
+            const line = stdoutBuf.slice(0, idx).trim();
+            stdoutBuf = stdoutBuf.slice(idx + 1);
+            if (!line)
+                continue;
+            try {
+                const data = JSON.parse(line);
+                emit({ type: data.type ?? 'gemini_event', timestamp: Date.now(), data });
+            }
+            catch {
+                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
+            }
+        }
+    });
+    child.stderr?.on('data', (chunk) => {
+        const text = chunk.toString('utf-8');
+        for (const line of text.split('\n')) {
+            if (line.trim())
+                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
+        }
+    });
+    // Use `close` (after all stdio has drained), not `exit` (which can fire while
+    // unread stdout is still in-flight). Flush any final un-newlined buffered line.
+    child.on('close', (code, signal) => {
+        if (stdoutBuf.trim()) {
+            const line = stdoutBuf.trim();
+            stdoutBuf = '';
+            try {
+                const data = JSON.parse(line);
+                emit({ type: data.type ?? 'gemini_event', timestamp: Date.now(), data });
+            }
+            catch {
+                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
+            }
+        }
+        statusValue =
+            killRequested || signal !== null
+                ? 'killed'
+                : errorEmitted
+                    ? 'error'
+                    : code === 0
+                        ? 'completed'
+                        : 'error';
+        if (aggregator.finalize(statusValue === 'completed' ? 'completed' : statusValue === 'killed' ? 'killed' : 'error')) {
+            stepsSnapshot = aggregator.steps.map((s) => ({ ...s }));
+            emit({ type: 'codehere:steps', timestamp: Date.now(), data: { steps: stepsSnapshot } });
+        }
+        if (statusValue === 'completed') {
+            try {
+                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
+                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
+            }
+            catch {
+                /* best-effort */
+            }
+        }
+        emit({
+            type: 'exit',
+            timestamp: Date.now(),
+            data: { code, signal, status: statusValue, durationMs: Date.now() - startedAt },
+        });
+    });
+    child.on('error', (err) => {
+        statusValue = 'error';
+        emit({ type: 'error', timestamp: Date.now(), data: { message: err.message } });
+    });
+    return {
+        sessionId,
+        startedAt,
+        prompt,
+        agent: 'gemini',
+        memoryInjection: injected.record,
+        get status() {
+            return statusValue;
+        },
+        get steps() {
+            return stepsSnapshot;
+        },
+        get artifacts() {
+            return artifactsSnapshot;
+        },
+        subscribe(handler) {
+            for (const e of buffer)
+                handler(e);
+            emitter.on('event', handler);
+            return () => emitter.off('event', handler);
+        },
+        kill() {
+            if (statusValue !== 'running')
+                return;
+            killRequested = true;
+            // Process-group kill via negative pid is POSIX-only — Node on Windows
+            // throws ESRCH for that. Fall back to direct child.kill on Windows.
+            const isPosix = process.platform !== 'win32';
+            const sendSignal = (sig) => {
+                if (isPosix && child.pid) {
+                    try {
+                        process.kill(-child.pid, sig);
+                        return;
+                    }
+                    catch {
+                        /* fall through to child.kill */
+                    }
+                }
+                try {
+                    child.kill(sig);
+                }
+                catch {
+                    /* already dead */
+                }
+            };
+            sendSignal('SIGTERM');
+            setTimeout(() => {
+                if (statusValue === 'running')
+                    sendSignal('SIGKILL');
+            }, 3000);
+        },
+    };
+}
+export const GeminiAdapter = {
+    id: 'gemini',
+    label: 'Gemini',
+    // Match `gemini`, `node /path/.../gemini`, and `./gemini` invocations.
+    processPattern: /(?:^|\/)gemini(?:\s|$)|node\s+\S*gemini/,
+    isInstalled() {
+        try {
+            const out = execFileSync('which', ['gemini'], { encoding: 'utf-8', timeout: 2000 });
+            return out.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    },
+    spawn(prompt, options) {
+        return spawnGemini(prompt, options);
+    },
+    checkReadiness() {
+        const installed = this.isInstalled();
+        if (!installed) {
+            return {
+                id: this.id,
+                label: this.label,
+                state: 'needs_install',
+                installed: false,
+                installHint: {
+                    command: 'npm install -g @google/gemini-cli',
+                    url: 'https://github.com/google-gemini/gemini-cli',
+                },
+            };
+        }
+        // Gemini supports several auth paths:
+        //   env: GEMINI_API_KEY (free tier), GOOGLE_API_KEY, GOOGLE_GENAI_USE_VERTEXAI,
+        //        GOOGLE_GENAI_USE_GCA, GOOGLE_APPLICATION_CREDENTIALS
+        //   file: ~/.gemini/settings.json (the file gemini's own error msg points at)
+        //   file: ~/.gemini/oauth_creds.json (cached Google login)
+        //
+        // Pre-May-1 we returned 'ready' on install alone, deferring to runtime to
+        // catch missing-auth via ERROR_PATTERNS.auth_missing. That was dishonest:
+        // /api/readiness/agents would say 'ready' → user would spawn → 41s later
+        // the task errored with no clear next step. Surfaced May 1 2026 by the
+        // multi-agent dogfood test (see SECURITY_AUDIT_2026-05-01.md spirit —
+        // honest readiness signals are a UX security property).
+        const hasEnvAuth = !!process.env.GEMINI_API_KEY ||
+            !!process.env.GOOGLE_API_KEY ||
+            !!process.env.GOOGLE_GENAI_USE_VERTEXAI ||
+            !!process.env.GOOGLE_GENAI_USE_GCA ||
+            !!process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        const hasFileAuth = existsSync(join(homedir(), '.gemini', 'settings.json')) ||
+            existsSync(join(homedir(), '.gemini', 'oauth_creds.json'));
+        if (!hasEnvAuth && !hasFileAuth) {
+            return {
+                id: this.id,
+                label: this.label,
+                state: 'needs_auth',
+                installed: true,
+                authHint: {
+                    command: 'export GEMINI_API_KEY=...  # free tier: https://aistudio.google.com/apikey',
+                    url: 'https://google-gemini.github.io/gemini-cli/docs/get-started/authentication.html',
+                    detail: 'Gemini found on PATH but no auth detected (no GEMINI_API_KEY env var, no ~/.gemini/settings.json, no ~/.gemini/oauth_creds.json). Free tier available at aistudio.google.com/apikey.',
+                },
+            };
+        }
+        return { id: this.id, label: this.label, state: 'ready', installed: true };
+    },
+};
+//# sourceMappingURL=gemini-adapter.js.map

package/dist/infrastructure/orchestration/generic-cli-adapter.js

@@ -37,6 +37,7 @@ import { join } from 'path';
 import { randomUUID } from 'crypto';
 import { ProgressAggregator } from './progress-aggregator.js';
 import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
+import { applyMemoryPrefix } from './memory-injector.js';
 const CONFIG_PATH = join(homedir(), '.codehere', 'agents.yaml');
 const CONFIG_PATH_JSON = join(homedir(), '.codehere', 'agents.json');
 /** Minimal YAML parser for the narrow shape above. Intentionally NOT a full YAML
@@ -134,6 +135,12 @@ function spawnGeneric(cfg, prompt, options = {}) {
     let statusValue = 'running';
     let killRequested = false;
     const cwd = options.cwd ?? process.cwd();
+    // F3 Task 8 — memory injection (same shape as every other adapter).
+    // Apr 29: caught via the adapter-injection-wiring trip-wire — generic
+    // adapters were silently exempt from F3 even though Task 8 said
+    // "every spawned agent." Now consistent.
+    const injected = applyMemoryPrefix(prompt, cwd, options);
+    const finalPrompt = injected.prompt;
     const snapshot = snapshotCwd(cwd);
     const aggregator = new ProgressAggregator(cfg.id);
     let stepsSnapshot = [];
@@ -155,7 +162,7 @@ function spawnGeneric(cfg, prompt, options = {}) {
     const spawnEnv = { ...process.env, ...(cfg.env ?? {}), ...(options.env ?? {}) };
     const usesStdin = cfg.prompt_via === 'stdin';
     const fixedArgs = cfg.args ?? [];
-    const argv = usesStdin ? [...fixedArgs] : [...fixedArgs, prompt];
+    const argv = usesStdin ? [...fixedArgs] : [...fixedArgs, finalPrompt];
     let child;
     try {
         // SAFE · array form (not shell:true) means no shell interpretation.
@@ -172,7 +179,7 @@ function spawnGeneric(cfg, prompt, options = {}) {
             stdio: [usesStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
         });
         if (usesStdin) {
-            child.stdin?.write(prompt);
+            child.stdin?.write(finalPrompt);
             child.stdin?.end();
         }
     }
@@ -264,6 +271,7 @@ function spawnGeneric(cfg, prompt, options = {}) {
         startedAt,
         prompt,
         agent: cfg.id,
+        memoryInjection: injected.record,
         get status() {
             return statusValue;
         },