codehere 1.0.1 → 1.0.2

package/dist/infrastructure/orchestration/claude-code-adapter.js

@@ -1,592 +0,0 @@
-/**
- * Claude Code adapter — F1 foundation of the PM layer (v0.3).
- *
- * Wraps `claude -p "<task>" --output-format=stream-json …` as a subprocess
- * and exposes a tight interface: spawn, subscribe to events, kill.
- *
- * Deep module: everything about process management, stream parsing, line
- * buffering, SIGTERM→SIGKILL escalation, and late-joiner replay is hidden
- * behind four exported names (TaskSession type, spawnClaudeCode, TaskEvent,
- * TaskStatus). Callers never see a child_process handle.
- *
- * Safety note: spawned sessions inherit the user's global PreToolUse hook
- * via ~/.claude/settings.json automatically — we do NOT re-wire it here.
- * That's F0 doing its job for free.
- */
-import { spawn } from 'child_process';
-import { execFileSync } from 'child_process';
-import { startRecording } from './cassette-recorder.js';
-import { resolveAgentSpawn } from './mocks/resolve-agent-spawn.js';
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { ProgressAggregator } from './progress-aggregator.js';
-import { snapshotCwd, extractArtifacts } from './artifacts-extractor.js';
-import { applyMemoryPrefix } from './memory-injector.js';
-import { mirrorToolCallToAudit } from '../hooks/mirror-tool-call-to-audit.js';
-// Runtime-error fingerprints → structured codehere:error events with recovery hints.
-// Matched against any stderr line or assistant-text content we see on the stream.
-const ERROR_PATTERNS = [
-    {
-        code: 'credit_low',
-        regex: /credit balance is too low/i,
-        message: 'Your Claude API account has no credits.',
-        recovery: 'codehere tries to use your Claude Code subscription by default. If you are seeing this, ' +
-            'ANTHROPIC_API_KEY is still being used somehow. Unset it in your shell (e.g. remove from ~/.zshrc), ' +
-            'or top up at console.anthropic.com.',
-    },
-    {
-        code: 'auth_invalid',
-        regex: /invalid api key|authentication.*failed|not authenticated|401 unauth/i,
-        message: 'Claude Code auth was rejected.',
-        recovery: 'Run `claude` in a terminal, sign in, then retry the task.',
-    },
-    {
-        code: 'rate_limit',
-        regex: /rate.?limit(ed)?|429|too many requests/i,
-        message: 'Claude rate-limited the request.',
-        recovery: 'Wait a minute and retry. If this persists, check your Claude usage dashboard.',
-    },
-];
-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;
-}
-// v0.7 MED-2 fix — dropped `--include-partial-messages` and
-// `--include-hook-events` from the headless flags. Per docs/contracts/claude-code.md
-// §7 the adapter doesn't consume partial-message deltas (only full assistant
-// blocks) and doesn't surface hook events in any UI. Both flags inflated
-// stream volume + token cost without benefit. If we later need either
-// (e.g., to wire a hook visualization in v0.8), re-add with explicit
-// parsing intent.
-const HEADLESS_FLAGS = [
-    '--output-format',
-    'stream-json',
-    '--verbose',
-    // Pre-grant common tools so -p mode doesn't dead-end at interactive permission
-    // prompts we cannot surface to the user. Safety is still enforced by codehere's
-    // PreToolUse hook (F0) on every tool call — that's the real gate.
-    '--allowedTools',
-    'Bash',
-    'Edit',
-    'Write',
-    'Read',
-    'Grep',
-    'Glob',
-    'MultiEdit',
-    'NotebookEdit',
-    // AskUserQuestion is now SURFACED by codehere (Layer 3): the agent's question
-    // renders as a card, the user answers, and --resume continues the same session
-    // (SPIKE 0 confirmed real claude emits the question cleanly + resumes without
-    // the thinking-signature wall). So it's pre-granted alongside the rest.
-    'AskUserQuestion',
-    // ExitPlanMode stays disallowed — no plan-approval surface yet, so it would
-    // still dead-end the headless run.
-    '--disallowedTools',
-    'ExitPlanMode',
-];
-/**
- * Resume a completed claude session for a follow-up turn — STANDALONE (no live
- * session object). claude keeps its own session store, so `claude --resume
- * <session_id>` continues with full context regardless of whether codehere kept
- * the session in memory. This is what lets a goal be continued AFTER a daemon
- * restart, by reconstructing from the persisted (nativeSessionId, cwd).
- * (resume-after-restart fix, dogfood 2026-06-09.)
- */
-export function resumeClaudeMessage(nativeSessionId, cwd, text) {
-    const startedAt = Date.now();
-    return new Promise((resolve, reject) => {
-        const env = { ...process.env };
-        // Subscription-first, same auth the ORIGINAL spawn used: every reachable
-        // daemon spawn path runs with preferSubscription=true (session-manager
-        // hardcodes it; readiness only emits false in the not_installed state,
-        // which can't spawn) — so the session being resumed was created with these
-        // keys stripped, and resuming must match or the auth context would differ
-        // mid-goal. If a preferSubscription=false spawn path ever becomes
-        // reachable, persist the preference and honor it here.
-        delete env.ANTHROPIC_API_KEY;
-        delete env.ANTHROPIC_AUTH_TOKEN;
-        delete env.CLAUDE_API_KEY;
-        const sp = resolveAgentSpawn('claude-code', 'claude', ['-p', text, '--resume', nativeSessionId, ...HEADLESS_FLAGS], text);
-        const child = spawn(sp.command, sp.args, { cwd, env: env, stdio: ['ignore', 'pipe', 'pipe'] });
-        let stdout = '';
-        let stderr = '';
-        child.on('error', reject);
-        child.stdout?.on('data', (c) => (stdout += c.toString('utf-8')));
-        child.stderr?.on('data', (c) => (stderr += c.toString('utf-8')));
-        child.on('exit', (code) => {
-            if (code !== 0) {
-                reject(new Error(`claude --resume exited ${code}: ${stderr.slice(0, 200)}`));
-                return;
-            }
-            // The final 'result' event repeats the assistant's last text — prefer it
-            // alone when present (joining both doubled the reply on the first real run).
-            const fragments = [];
-            let resultText;
-            for (const line of stdout.split('\n')) {
-                const t = line.trim();
-                if (!t)
-                    continue;
-                try {
-                    const o = JSON.parse(t);
-                    if (o.type === 'assistant' && o.message?.content) {
-                        for (const b of o.message.content)
-                            if (b.type === 'text' && b.text)
-                                fragments.push(b.text);
-                    }
-                    else if (o.type === 'result' && typeof o.result === 'string') {
-                        resultText = o.result;
-                    }
-                }
-                catch {
-                    /* non-JSON line — skip */
-                }
-            }
-            const replyText = (resultText ?? fragments.join('')).trim();
-            resolve({ result: replyText || '(the agent left no text response)', durationMs: Date.now() - startedAt });
-        });
-    });
-}
-export function spawnClaudeCode(prompt, options = {}) {
-    const sessionId = randomUUID();
-    const startedAt = Date.now();
-    const emitter = new EventEmitter();
-    const buffer = [];
-    let statusValue = 'running';
-    let killRequested = false;
-    // PM UX Layer 2+3 state. Shared helper modules; per-session instances.
-    const cwd = options.cwd ?? process.cwd();
-    // F3 Task 8 — inject project memory (AGENTS.md + lessons + repo_map slice)
-    // into the prompt prefix unless the caller opted out. Pure, side-effect-
-    // free; returns unchanged prompt + record=undefined when there's no
-    // .codehere/ at cwd.
-    const injected = applyMemoryPrefix(prompt, cwd, options);
-    const finalPrompt = injected.prompt;
-    const snapshot = snapshotCwd(cwd);
-    const aggregator = new ProgressAggregator('claude-code');
-    let stepsSnapshot = [];
-    let artifactsSnapshot;
-    let textAccum = ''; // accumulates assistant text + result summary for test-count parsing
-    let usageSnapshot; // token accumulator (principle #7)
-    let modelSeen; // real model id from assistant events → per-model cost
-    let errorEmitted = false;
-    const emit = (event) => {
-        buffer.push(event);
-        emitter.emit('event', event);
-        // Layer 2: feed aggregator; on step change, emit synthetic snapshot 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 text for test-summary parsing (Layer 3) + mirror tool calls to
-        // the hash-chained audit.
-        if (event.type === 'assistant') {
-            const msg = event.data?.message;
-            if (!modelSeen && msg?.model)
-                modelSeen = msg.model; // capture the real model for per-model pricing
-            if (msg?.content) {
-                for (const b of msg.content) {
-                    if (b.type === 'text' && b.text)
-                        textAccum += b.text + '\n';
-                    else if (b.type === 'tool_use' && b.name) {
-                        // Audit-trail backstop for claude (#proof-pillar). Claude's PreToolUse
-                        // hook is the BLOCKING gate, but headless `claude -p` (how codehere
-                        // spawns it) does NOT execute that hook into the audit — MEASURED twice
-                        // 2026-06-08: a spawned claude REVIEW (read-only) left 0 entries, and a
-                        // spawned claude WRITE produced ONLY this mirror's entry (no hook entry
-                        // under the session). So the hook is silent for spawned claude and the
-                        // mirror is the SOLE audit source — no double-count. Mirror each
-                        // tool_use post-hoc like the other 4 adapters so "what every agent did"
-                        // is provable for claude too. mirrored:true marks it.
-                        // CAVEAT: if a future claude DOES fire PreToolUse hooks in headless mode,
-                        // hooked tools (Bash/Edit/Write/MultiEdit/NotebookEdit) would double —
-                        // then dedup on (sessionId,toolName,action) in the audit readers, or
-                        // mirror only the hook's complement. Not needed today (hook is silent).
-                        const params = (b.input ?? {});
-                        const toolInput = (typeof params.command === 'string' && params.command) ||
-                            (typeof params.file_path === 'string' && params.file_path) ||
-                            (typeof params.path === 'string' && params.path) ||
-                            (typeof params.pattern === 'string' && params.pattern) ||
-                            JSON.stringify(params).slice(0, 500);
-                        mirrorToolCallToAudit({
-                            sessionId,
-                            agent: 'claude-code',
-                            toolName: b.name,
-                            toolInput: String(toolInput),
-                            cwd,
-                        });
-                    }
-                }
-            }
-        }
-        else if (event.type === 'result') {
-            const d = event.data;
-            if (d?.result)
-                textAccum += d.result + '\n';
-            // Claude Code's stream-json `result` event is the final summary — carries
-            // the full session's usage totals. One event per session; overwrite, don't sum.
-            if (d?.usage) {
-                usageSnapshot = {
-                    inputTokens: Number(d.usage.input_tokens ?? 0),
-                    outputTokens: Number(d.usage.output_tokens ?? 0),
-                    cacheReadTokens: d.usage.cache_read_input_tokens ? Number(d.usage.cache_read_input_tokens) : undefined,
-                    cacheCreationTokens: d.usage.cache_creation_input_tokens
-                        ? Number(d.usage.cache_creation_input_tokens)
-                        : undefined,
-                    ...(modelSeen ? { model: modelSeen } : {}),
-                };
-            }
-        }
-        else if (event.type === 'user') {
-            const msg = event.data?.message;
-            if (msg?.content) {
-                for (const b of msg.content) {
-                    if (b.type === 'tool_result') {
-                        const raw = Array.isArray(b.content)
-                            ? b.content.map((c) => c.text ?? '').join('')
-                            : String(b.content ?? '');
-                        textAccum += raw + '\n';
-                    }
-                }
-            }
-        }
-        // F1b: scan for known failure patterns once per session
-        if (!errorEmitted) {
-            const data = event.data;
-            let text = '';
-            if (event.type === 'stderr' && data && typeof data.line === 'string') {
-                text = data.line;
-            }
-            else if (event.type === 'assistant' && data && typeof data === 'object') {
-                const msg = data.message;
-                if (msg?.content) {
-                    text = msg.content.map((b) => (b.type === 'text' ? (b.text ?? '') : '')).join(' ');
-                }
-            }
-            else if (event.type === 'result' && data && typeof data.result === 'string') {
-                text = String(data.result ?? '');
-            }
-            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);
-                }
-            }
-        }
-    };
-    const preferSubscription = options.preferSubscription !== false;
-    const spawnEnv = { ...process.env, ...(options.env ?? {}) };
-    if (preferSubscription) {
-        // Force keychain/OAuth path — matches what the user's interactive `claude` uses.
-        delete spawnEnv.ANTHROPIC_API_KEY;
-        delete spawnEnv.ANTHROPIC_AUTH_TOKEN;
-        delete spawnEnv.CLAUDE_API_KEY;
-    }
-    let child;
-    try {
-        const sp = resolveAgentSpawn('claude-code', 'claude', [
-            '-p',
-            finalPrompt,
-            ...HEADLESS_FLAGS,
-            ...(options.extraArgs ?? []),
-        ]);
-        child = spawn(sp.command, sp.args, {
-            cwd,
-            env: spawnEnv,
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-    }
-    catch (err) {
-        // Recorder is short-circuit no-op when CODEHERE_RECORD_CASSETTES != '1'
-        // so the spawn-failure path doesn't even pay the closure cost.
-        statusValue = 'error';
-        const msg = err instanceof Error ? err.message : String(err);
-        // Emit synchronously so subscribers added immediately after see it
-        queueMicrotask(() => emit({ type: 'error', timestamp: Date.now(), data: { message: msg } }));
-        return {
-            sessionId,
-            startedAt,
-            prompt,
-            agent: 'claude-code',
-            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 */
-            },
-        };
-    }
-    // ── Organic cassette recording (S2b · capture-first plan) ─────────────────
-    // No-op unless CODEHERE_RECORD_CASSETTES=1 · zero overhead by default.
-    // Captures the raw byte stream + exit so a future replay can reproduce
-    // this exact session through the mock adapter without a live agent call.
-    const recorder = startRecording({
-        adapter: 'claude-code',
-        sessionId,
-        prompt: finalPrompt,
-        cwd,
-    });
-    // ── stdout: newline-delimited JSON from `--output-format stream-json` ────────
-    let stdoutBuf = '';
-    // Iter 13 — capture the claude-internal session_id from the init event so
-    // appendMessage can use `--resume <session-id>` (reliable) instead of `-c`
-    // (which picks "most recent in cwd" and can collide with other concurrent
-    // claude sessions OR with conversations containing thinking blocks the
-    // headless API can't replay).
-    let claudeSessionId;
-    child.stdout?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStdout(text);
-        stdoutBuf += text;
-        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);
-                if (claudeSessionId === undefined &&
-                    data.type === 'system' &&
-                    data.subtype === 'init' &&
-                    typeof data.session_id === 'string') {
-                    claudeSessionId = data.session_id;
-                }
-                emit({ type: data.type ?? 'message', timestamp: Date.now(), data });
-            }
-            catch {
-                // Non-JSON stdout line — preserve so callers can see raw output
-                emit({ type: 'stdout', timestamp: Date.now(), data: { line } });
-            }
-        }
-    });
-    // ── stderr: Claude prints debug/errors here; forward raw ─────────────────────
-    child.stderr?.on('data', (chunk) => {
-        const text = chunk.toString('utf-8');
-        recorder.onStderr(text);
-        for (const line of text.split('\n')) {
-            if (line.trim())
-                emit({ type: 'stderr', timestamp: Date.now(), data: { line } });
-        }
-    });
-    child.on('exit', (code, signal) => {
-        recorder.onExit(code ?? -1, signal);
-        statusValue =
-            killRequested || signal !== null ? 'killed' : errorEmitted ? 'error' : code === 0 ? 'completed' : 'error';
-        // Emit synthetic PM events BEFORE 'exit' so the client has time to render
-        // them before its onmessage handler closes the SSE stream in response to exit.
-        // (Client must close on exit to avoid leaking connections — but close() cancels
-        //  pending messages, so order matters.)
-        // Layer 2: flip any still-active steps to done/failed so the UI stops spinning.
-        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 } });
-        }
-        // Layer 3: on clean completion, extract artifacts (git diff + trust + tests + tokens) and announce.
-        if (statusValue === 'completed') {
-            try {
-                artifactsSnapshot = { ...extractArtifacts(snapshot, textAccum), usage: usageSnapshot };
-                emit({ type: 'codehere:artifacts', timestamp: Date.now(), data: artifactsSnapshot });
-            }
-            catch {
-                /* best-effort; don't break exit path */
-            }
-        }
-        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: 'claude-code',
-        canAppendMessage: true,
-        memoryInjection: injected.record,
-        // claude's own session_id, captured from the init event — persisted so a
-        // follow-up turn can resume even after a daemon restart (resume-after-restart).
-        get nativeSessionId() {
-            return claudeSessionId;
-        },
-        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;
-            child.kill('SIGTERM');
-            // Escalate if it doesn't die in 3s
-            setTimeout(() => {
-                if (statusValue === 'running') {
-                    try {
-                        child.kill('SIGKILL');
-                    }
-                    catch {
-                        /* already dead */
-                    }
-                }
-            }, 3000);
-        },
-        /**
-         * Iter 12 (with iter-13 fix) — follow-up message to a completed session.
-         *
-         * Iter 12 used `claude -p "<text>" -c` which picks "most recent
-         * conversation in current directory". Iter 13 dogfood proved this
-         * fragile: in a cwd with multiple concurrent claude sessions OR with
-         * conversations containing thinking blocks, -c either picks the wrong
-         * session or hits an API-replay error ("Invalid signature in thinking
-         * block"). Fix: capture the claude session_id from this session's init
-         * event (above) and use `--resume <session-id>` for follow-ups —
-         * unambiguous and replay-safe.
-         *
-         * Scope: still one-shot Q&A. No streaming. Returns assistant's response
-         * text. If we never captured a session_id (init event never fired —
-         * shouldn't happen in healthy claude runs), reject explicitly.
-         */
-        appendMessage(text) {
-            const startedAt = Date.now();
-            return new Promise((resolve, reject) => {
-                if (!claudeSessionId) {
-                    reject(new Error('Cannot reply: original claude session_id was never captured (init event missed)'));
-                    return;
-                }
-                let stdout = '';
-                let stderr = '';
-                // Route follow-ups through the mock seam too — under CODEHERE_MOCK=1 this
-                // hits the mock REPL, not the real binary. (Was a real-spend leak:
-                // appendMessage spawned `claude` directly regardless of mock mode.)
-                const sp2 = resolveAgentSpawn('claude-code', 'claude', ['-p', text, '--resume', claudeSessionId, ...HEADLESS_FLAGS], text);
-                const followup = spawn(sp2.command, sp2.args, {
-                    cwd,
-                    env: spawnEnv,
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                });
-                followup.on('error', (err) => reject(err));
-                followup.stdout?.on('data', (chunk) => {
-                    stdout += chunk.toString('utf-8');
-                });
-                followup.stderr?.on('data', (chunk) => {
-                    stderr += chunk.toString('utf-8');
-                });
-                followup.on('exit', (code) => {
-                    if (code !== 0) {
-                        reject(new Error(`claude -c exited ${code}: ${stderr.slice(0, 200)}`));
-                        return;
-                    }
-                    // Parse stream-json. Route every line through the SAME emit() pipeline
-                    // as the original run (Layer 3 merge): emit() ingests into the shared
-                    // aggregator, refreshes stepsSnapshot, and notifies session-manager —
-                    // so the continuation's steps (say/think/tool/output) merge into
-                    // session.steps, ride SSE, and show in the timeline. Was text-only.
-                    const lines = stdout.split('\n').filter((l) => l.trim());
-                    const fragments = [];
-                    for (const line of lines) {
-                        try {
-                            const obj = JSON.parse(line);
-                            emit({ type: obj.type ?? 'message', timestamp: Date.now(), data: obj });
-                            if (obj.type === 'assistant' && obj.message?.content) {
-                                for (const block of obj.message.content) {
-                                    if (block.type === 'text' && block.text)
-                                        fragments.push(block.text);
-                                }
-                            }
-                            else if (obj.type === 'result' && typeof obj.result === 'string') {
-                                fragments.push(obj.result);
-                            }
-                        }
-                        catch {
-                            // Non-JSON line — skip
-                        }
-                    }
-                    // Dedupe trivially: if 'result' contained the same text as the
-                    // last assistant block, take just one. Conservative: prefer 'result'
-                    // if present (it's the final summary), else join assistants.
-                    const result = fragments.length ? fragments[fragments.length - 1] : '(no response captured)';
-                    resolve({ result, durationMs: Date.now() - startedAt });
-                });
-            });
-        },
-    };
-}
-// ── AgentAdapter implementation ─────────────────────────────────────────────
-export const ClaudeCodeAdapter = {
-    id: 'claude-code',
-    label: 'Claude Code',
-    description: 'Good default for editing code, running tests, and shell commands. Strongest safety net: codehere can stop risky actions before they run, not just record them after.',
-    processPattern: /(?:^|\/)claude(?:\s|$)/,
-    isInstalled() {
-        try {
-            const out = execFileSync('which', ['claude'], { encoding: 'utf-8', timeout: 2000 });
-            return out.trim().length > 0;
-        }
-        catch {
-            return false;
-        }
-    },
-    spawn(prompt, options) {
-        return spawnClaudeCode(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 @anthropic-ai/claude-code',
-                    url: 'https://docs.claude.com/en/docs/claude-code/setup',
-                },
-            };
-        }
-        // Claude Code supports BOTH subscription (OAuth via keychain) and API key.
-        // "Ready" if either path works. We can't verify subscription without
-        // calling the API, so we treat any Claude Code install as ready by default —
-        // runtime F1b error-fingerprints catch real auth failures after spawn.
-        return { id: this.id, label: this.label, state: 'ready', installed: true };
-    },
-};
-//# sourceMappingURL=claude-code-adapter.js.map