autodev-cli 1.4.131 → 1.4.133

package/out/providers/claude/cli.js

@@ -0,0 +1,674 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeProjectFolder = claudeProjectFolder;
+exports.getClaudeProjectDir = getClaudeProjectDir;
+exports.listClaudeSessionFiles = listClaudeSessionFiles;
+exports.listClaudeSessions = listClaudeSessions;
+exports.findLatestClaudeSession = findLatestClaudeSession;
+exports.getClaudeSessionDisplay = getClaudeSessionDisplay;
+exports.setClaudeSessionName = setClaudeSessionName;
+exports.listAllClaudeSessions = listAllClaudeSessions;
+exports.readClaudeTranscript = readClaudeTranscript;
+exports.getClaudeSessionCursor = getClaudeSessionCursor;
+exports.parseClaudeStateSince = parseClaudeStateSince;
+exports.hasClaudeEndTurnSince = hasClaudeEndTurnSince;
+exports.readClaudeOutputSince = readClaudeOutputSince;
+exports.buildClaudeCliCommand = buildClaudeCliCommand;
+exports.probeClaudeSession = probeClaudeSession;
+exports.runClaudeCompact = runClaudeCompact;
+exports.runClaudeClear = runClaudeClear;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+// ---------------------------------------------------------------------------
+// Claude project-folder / JSONL session helpers
+// ---------------------------------------------------------------------------
+/**
+ * Encode a workspace path the way Claude Code names its `~/.claude/projects/`
+ * folders: every `:`, `\`, `/` becomes `-`, and runs of dashes are collapsed.
+ * Note: Claude **keeps the leading dash** that comes from a leading slash on
+ * POSIX paths (e.g. `/home/x/foo` → `-home-x-foo`), so we don't strip `^-`.
+ * Trailing dashes are dropped.
+ */
+function claudeProjectFolder(workspacePath) {
+    return workspacePath.replace(/[:\\/]/g, '-').replace(/-+/g, '-').replace(/-$/g, '');
+}
+/**
+ * Compute the `~/.claude/projects/<encoded>` directory for a workspace,
+ * regardless of whether it already exists. Used when restoring an agent
+ * backup into a new folder: the destination's session traces must land in
+ * the project dir that Claude will look up for that folder.
+ */
+function getClaudeProjectDir(workspacePath) {
+    const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+    return path.join(claudeDir, 'projects', claudeProjectFolder(workspacePath));
+}
+/**
+ * Resolve the Claude `~/.claude/projects/<encoded>` folder for this workspace.
+ * Match is **exact** (case-insensitive only on Windows). We try the primary
+ * encoding and a no-leading-dash fallback so historical folders created by
+ * older Claude versions still resolve. Prefix matching is intentionally NOT
+ * used — the previous fuzzy match (`startsWith(encoded.slice(0,8))`) caused
+ * two VS Code instances opened in sibling directories like
+ * `-home-code-foo` and `-home-code1-bar` (sharing prefix `-home-cod`) to
+ * pick up each other's session JSONLs and end up resuming the same Claude
+ * session.
+ */
+function findClaudeProjectDir(workspacePath) {
+    try {
+        const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+        const projectsDir = path.join(claudeDir, 'projects');
+        const encoded = claudeProjectFolder(workspacePath);
+        const candidates = [encoded, encoded.replace(/^-+/, '')];
+        const folders = fs.readdirSync(projectsDir);
+        const isWindows = process.platform === 'win32';
+        const norm = (s) => (isWindows ? s.toLowerCase() : s);
+        const targets = new Set(candidates.map(norm));
+        const match = folders.find(f => targets.has(norm(f)));
+        return match ? path.join(projectsDir, match) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function listClaudeSessionFiles(workspacePath) {
+    const sessionsDir = findClaudeProjectDir(workspacePath);
+    if (!sessionsDir) {
+        return [];
+    }
+    try {
+        return fs.readdirSync(sessionsDir)
+            .filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'))
+            .map(f => ({ name: f, mtime: fs.statSync(path.join(sessionsDir, f)).mtimeMs, full: path.join(sessionsDir, f) }))
+            .sort((a, b) => b.mtime - a.mtime);
+    }
+    catch {
+        return [];
+    }
+}
+function listClaudeSessions(workspacePath) {
+    return listClaudeSessionFiles(workspacePath).map(f => ({
+        id: f.name.replace('.jsonl', ''),
+        mtime: f.mtime,
+    }));
+}
+function findLatestClaudeSession(workspacePath) {
+    return listClaudeSessionFiles(workspacePath)[0]?.name.replace('.jsonl', '');
+}
+/**
+ * Set the display NAME shown for a Claude session in the `claude --resume`
+ * picker. This Claude version has no dedicated title field — the picker label is
+ * the `display` value in ~/.claude/history.jsonl keyed by sessionId. We APPEND a
+ * fresh entry (never rewrite existing lines, so history can't be corrupted); the
+ * picker surfaces the latest display for the session.
+ */
+/** Read the display NAME shown for a claude session in the --resume picker
+ *  (latest `display` for this sessionId in ~/.claude/history.jsonl). */
+function getClaudeSessionDisplay(sessionId) {
+    try {
+        const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+        const histFile = path.join(claudeDir, 'history.jsonl');
+        if (!fs.existsSync(histFile)) {
+            return undefined;
+        }
+        let display;
+        for (const line of fs.readFileSync(histFile, 'utf8').split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const e = JSON.parse(line);
+                if (e.sessionId === sessionId && e.display) {
+                    display = e.display;
+                }
+            }
+            catch { /* skip */ }
+        }
+        return display;
+    }
+    catch {
+        return undefined;
+    }
+}
+function setClaudeSessionName(sessionId, name, cwd) {
+    if (!sessionId || !name) {
+        return;
+    }
+    try {
+        const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+        const histFile = path.join(claudeDir, 'history.jsonl');
+        const entry = { display: name, pastedContents: {}, timestamp: Date.now(), project: cwd, sessionId };
+        fs.appendFileSync(histFile, JSON.stringify(entry) + '\n', 'utf8');
+    }
+    catch { /* non-critical */ }
+}
+function resolveClaudeJsonl(workspacePath) {
+    return listClaudeSessionFiles(workspacePath)[0]?.full;
+}
+// ---------------------------------------------------------------------------
+// Global (cross-workspace) discovery + transcript reading
+// ---------------------------------------------------------------------------
+/** Decode a `~/.claude/projects` folder name back to a plausible cwd. Lossy
+ *  (dashes in real names collapse), so callers prefer the transcript's own cwd. */
+function decodeClaudeProject(folder) {
+    return '/' + folder.replace(/^-+/, '').replace(/-/g, '/');
+}
+/** sessionId → newest display title, from ~/.claude/history.jsonl. */
+function claudeTitleMap() {
+    const m = new Map();
+    try {
+        const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+        const histFile = path.join(claudeDir, 'history.jsonl');
+        if (!fs.existsSync(histFile)) {
+            return m;
+        }
+        for (const line of fs.readFileSync(histFile, 'utf8').split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            try {
+                const e = JSON.parse(line);
+                if (e.sessionId && e.display) {
+                    m.set(e.sessionId, e.display);
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* none */ }
+    return m;
+}
+/** Peek a transcript head for its real cwd, a first-user title hint, and a
+ *  message-count floor (bounded read so discovery never loads 100s of MB). */
+function peekClaudeTranscript(file, size) {
+    let cwd;
+    let firstUser;
+    let count = 0;
+    const MAX = 256_000;
+    try {
+        let text;
+        if (size > MAX) {
+            const fd = fs.openSync(file, 'r');
+            try {
+                const buf = Buffer.alloc(MAX);
+                fs.readSync(fd, buf, 0, MAX, 0);
+                text = buf.toString('utf8');
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+        }
+        else {
+            text = fs.readFileSync(file, 'utf8');
+        }
+        for (const line of text.split('\n')) {
+            if (!line.trim()) {
+                continue;
+            }
+            count++;
+            try {
+                const o = JSON.parse(line);
+                if (!cwd && typeof o['cwd'] === 'string') {
+                    cwd = o['cwd'];
+                }
+                if (!firstUser && o['type'] === 'user') {
+                    const t = extractClaudeText(o['message']);
+                    if (t) {
+                        firstUser = t.slice(0, 80);
+                    }
+                }
+            }
+            catch { /* skip */ }
+        }
+    }
+    catch { /* unreadable */ }
+    return { cwd, firstUser, count };
+}
+/** ALL claude sessions across every ~/.claude/projects folder (newest first).
+ *  Mirrors the app's sessionManager.discover(): skip `agent-` transcripts,
+ *  derive cwd from the transcript's own `cwd` (folder-name decode fallback). */
+function listAllClaudeSessions() {
+    const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+    const projects = path.join(claudeDir, 'projects');
+    if (!fs.existsSync(projects)) {
+        return [];
+    }
+    const titles = claudeTitleMap();
+    const out = [];
+    let folders = [];
+    try {
+        folders = fs.readdirSync(projects);
+    }
+    catch {
+        return [];
+    }
+    for (const folder of folders) {
+        const dir = path.join(projects, folder);
+        let files = [];
+        try {
+            if (!fs.statSync(dir).isDirectory()) {
+                continue;
+            }
+            files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl') && !f.startsWith('agent-'));
+        }
+        catch {
+            continue;
+        }
+        for (const f of files) {
+            const file = path.join(dir, f);
+            const id = f.replace(/\.jsonl$/, '');
+            let st;
+            try {
+                st = fs.statSync(file);
+            }
+            catch {
+                continue;
+            }
+            const peek = peekClaudeTranscript(file, st.size);
+            out.push({
+                id,
+                name: titles.get(id) || peek.firstUser || '(untitled)',
+                cwd: peek.cwd || decodeClaudeProject(folder),
+                updated: st.mtimeMs,
+                file,
+                msgs: peek.count,
+            });
+        }
+    }
+    return out.sort((a, b) => b.updated - a.updated);
+}
+/** Pull readable text out of a claude transcript entry's `message` (string or
+ *  array content, rendering tool_use / tool_result blocks compactly). */
+function extractClaudeText(message) {
+    if (!message) {
+        return '';
+    }
+    const c = message['content'];
+    if (typeof c === 'string') {
+        return c;
+    }
+    if (Array.isArray(c)) {
+        const short = (v) => {
+            try {
+                const s = typeof v === 'string' ? v : JSON.stringify(v);
+                return s.length > 200 ? s.slice(0, 200) + '…' : s;
+            }
+            catch {
+                return '';
+            }
+        };
+        return c.map(b => {
+            if (b['type'] === 'text') {
+                return String(b['text'] ?? '');
+            }
+            if (b['type'] === 'tool_use') {
+                return `🔧 ${String(b['name'] ?? '')}(${short(b['input'])})`;
+            }
+            if (b['type'] === 'tool_result') {
+                return `↳ ${short(b['content'])}`;
+            }
+            return '';
+        }).filter(Boolean).join('\n');
+    }
+    return '';
+}
+/** Locate a claude transcript by session id across all project folders. */
+function findClaudeTranscriptById(id) {
+    const claudeDir = process.env['CLAUDE_CONFIG_DIR'] ?? path.join(os.homedir(), '.claude');
+    const projects = path.join(claudeDir, 'projects');
+    try {
+        for (const folder of fs.readdirSync(projects)) {
+            const file = path.join(projects, folder, `${id}.jsonl`);
+            if (fs.existsSync(file)) {
+                return file;
+            }
+        }
+    }
+    catch { /* none */ }
+    return undefined;
+}
+/**
+ * Read a claude session transcript (by id, or an explicit `file`) into a
+ * normalized message array. Reuses the same parse shape the app uses: type
+ * user/assistant/system with tool_use/tool_result rendering. Reads only the
+ * tail of huge transcripts. Returns at most `limit` messages. [] on any miss.
+ */
+function readClaudeTranscript(id, file, limit = 400) {
+    const p = file && fs.existsSync(file) ? file : findClaudeTranscriptById(id);
+    if (!p) {
+        return [];
+    }
+    let text = '';
+    try {
+        const size = fs.statSync(p).size;
+        const MAX = 2_000_000; // last ~2 MB is plenty for `limit` messages
+        if (size > MAX) {
+            const fd = fs.openSync(p, 'r');
+            try {
+                const buf = Buffer.alloc(MAX);
+                fs.readSync(fd, buf, 0, MAX, size - MAX);
+                text = buf.toString('utf8');
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            const nl = text.indexOf('\n');
+            if (nl >= 0) {
+                text = text.slice(nl + 1);
+            } // drop the partial first line
+        }
+        else {
+            text = fs.readFileSync(p, 'utf8');
+        }
+    }
+    catch {
+        return [];
+    }
+    const msgs = [];
+    for (const line of text.split('\n')) {
+        if (!line.trim()) {
+            continue;
+        }
+        try {
+            const o = JSON.parse(line);
+            const ts = o['timestamp'] ? Date.parse(String(o['timestamp'])) : undefined;
+            if (o['type'] === 'user') {
+                const t = extractClaudeText(o['message']);
+                if (t) {
+                    msgs.push({ role: 'user', text: t, ts });
+                }
+            }
+            else if (o['type'] === 'assistant') {
+                const t = extractClaudeText(o['message']);
+                if (t) {
+                    msgs.push({ role: 'assistant', text: t, ts });
+                }
+            }
+            else if (o['type'] === 'system' && o['content']) {
+                msgs.push({ role: 'system', text: String(o['content']).slice(0, 200), ts });
+            }
+        }
+        catch { /* skip */ }
+    }
+    return msgs.slice(-limit);
+}
+function getClaudeSessionCursor(workspacePath) {
+    const p = resolveClaudeJsonl(workspacePath);
+    if (!p) {
+        return 0;
+    }
+    try {
+        return fs.statSync(p).size;
+    }
+    catch {
+        return 0;
+    }
+}
+function formatToolStatus(toolName, input) {
+    const base = (p) => (typeof p === 'string' ? path.basename(p) : '');
+    switch (toolName) {
+        case 'Read': return `Reading ${base(input['file_path'])}`;
+        case 'Edit': return `Editing ${base(input['file_path'])}`;
+        case 'Write': return `Writing ${base(input['file_path'])}`;
+        case 'Bash': {
+            const cmd = String(input['command'] ?? '');
+            return `Running: ${cmd.length > 60 ? cmd.slice(0, 60) + '\u2026' : cmd}`;
+        }
+        case 'Glob': return 'Searching files';
+        case 'Grep': return 'Searching code';
+        case 'WebFetch': return 'Fetching web content';
+        case 'WebSearch': return 'Searching the web';
+        case 'Task':
+        case 'Agent': {
+            const desc = typeof input['description'] === 'string' ? input['description'] : '';
+            return desc ? `Subtask: ${desc.length > 50 ? desc.slice(0, 50) + '\u2026' : desc}` : 'Running subtask';
+        }
+        case 'AskUserQuestion': return 'Waiting for answer';
+        case 'EnterPlanMode': return 'Planning';
+        default: return `Using ${toolName}`;
+    }
+}
+function parseClaudeStateSince(workspacePath, fromByte) {
+    const result = { hasEndTurn: false, hasProgress: false };
+    const p = resolveClaudeJsonl(workspacePath);
+    if (!p) {
+        return result;
+    }
+    try {
+        const size = fs.statSync(p).size;
+        if (size <= fromByte) {
+            return result;
+        }
+        const fd = fs.openSync(p, 'r');
+        const buf = Buffer.alloc(size - fromByte);
+        fs.readSync(fd, buf, 0, buf.length, fromByte);
+        fs.closeSync(fd);
+        for (const line of buf.toString('utf8').split('\n')) {
+            const t = line.trim();
+            if (!t) {
+                continue;
+            }
+            try {
+                const record = JSON.parse(t);
+                const rtype = record['type'];
+                if (rtype === 'assistant') {
+                    const msgContent = record['message']?.['content']
+                        ?? record['content'];
+                    if (Array.isArray(msgContent)) {
+                        for (const block of msgContent) {
+                            if (block['type'] === 'tool_use') {
+                                const name = String(block['name'] ?? '');
+                                const input = (block['input'] ?? {});
+                                result.activeToolStatus = formatToolStatus(name, input);
+                                result.hasEndTurn = false;
+                            }
+                        }
+                    }
+                }
+                else if (rtype === 'user') {
+                    const msgContent = record['message']?.['content']
+                        ?? record['content'];
+                    if (Array.isArray(msgContent)) {
+                        const hasToolResult = msgContent
+                            .some(b => b['type'] === 'tool_result');
+                        if (!hasToolResult) {
+                            result.activeToolStatus = undefined;
+                            result.hasEndTurn = false;
+                        }
+                    }
+                }
+                else if (rtype === 'system') {
+                    if (record['subtype'] === 'turn_duration') {
+                        result.hasEndTurn = true;
+                        result.activeToolStatus = undefined;
+                    }
+                }
+                else if (rtype === 'progress') {
+                    const data = record['data'];
+                    const dataType = data?.['type'];
+                    if (dataType === 'bash_progress' || dataType === 'mcp_progress') {
+                        result.hasProgress = true;
+                    }
+                }
+                if (record['stop_reason'] === 'end_turn') {
+                    result.hasEndTurn = true;
+                }
+                // Rate limit detection — error:"rate_limit" on assistant records
+                if (record['error'] === 'rate_limit') {
+                    const msgContent = record['message']?.['content'];
+                    const text = Array.isArray(msgContent)
+                        ? msgContent
+                            .filter(b => b['type'] === 'text')
+                            .map(b => String(b['text'] ?? '')).join(' ')
+                        : '';
+                    if (text) {
+                        result.rateLimitMessage = text;
+                    }
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+    }
+    catch { /* file unreadable */ }
+    return result;
+}
+/** @deprecated Use parseClaudeStateSince instead. */
+function hasClaudeEndTurnSince(workspacePath, fromByte) {
+    return parseClaudeStateSince(workspacePath, fromByte).hasEndTurn;
+}
+function readClaudeOutputSince(workspacePath, fromByte) {
+    const p = resolveClaudeJsonl(workspacePath);
+    if (!p) {
+        return '';
+    }
+    try {
+        const size = fs.statSync(p).size;
+        if (size <= fromByte) {
+            return '';
+        }
+        const fd = fs.openSync(p, 'r');
+        const buf = Buffer.alloc(size - fromByte);
+        fs.readSync(fd, buf, 0, buf.length, fromByte);
+        fs.closeSync(fd);
+        const parts = [];
+        for (const line of buf.toString('utf8').split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const entry = JSON.parse(trimmed);
+                const entryMsg = entry['message'];
+                if (entry['type'] === 'assistant' || entryMsg?.role === 'assistant') {
+                    const content = entryMsg?.content;
+                    if (typeof content === 'string') {
+                        parts.push(content);
+                    }
+                    else if (Array.isArray(content)) {
+                        for (const part of content) {
+                            if (part.type === 'text' && part.text) {
+                                parts.push(part.text);
+                            }
+                        }
+                    }
+                }
+            }
+            catch { /* skip malformed lines */ }
+        }
+        return parts.join('\n\n');
+    }
+    catch {
+        return '';
+    }
+}
+// ---------------------------------------------------------------------------
+// Claude CLI command builder
+// ---------------------------------------------------------------------------
+/** Build the shell command string for the claude-cli provider. */
+function buildClaudeCliCommand(agentProfileFile, messageFile, sessionId, includeProfile = true, model) {
+    const resume = sessionId ? ` --resume ${sessionId}` : '';
+    const resolvedModel = model?.replace(/-1m$/i, '');
+    const modelFlag = resolvedModel ? ` --model ${resolvedModel}` : '';
+    // -p takes ONE prompt argument. Concatenate both @file refs into a single
+    // quoted string so Claude sees both — passing them as two args drops the
+    // second one silently (claude consumes the first as the prompt).
+    const promptArg = includeProfile
+        ? JSON.stringify(`@${agentProfileFile} @${messageFile}`)
+        : JSON.stringify(`@${messageFile}`);
+    return `claude --allow-dangerously-skip-permissions --dangerously-skip-permissions${resume}${modelFlag} -p ${promptArg}`;
+}
+/**
+ * Run a tiny probe prompt via Node exec to obtain a claude-cli session ID
+ * before the main prompt runs. Extracts "session_id" from --output-format json output.
+ */
+function probeClaudeSession(cwd, log) {
+    return new Promise(resolve => {
+        const cmd = `claude --dangerously-skip-permissions --output-format json -p "."`;
+        log(`Claude CLI probe: ${cmd}`);
+        (0, child_process_1.exec)(cmd, { cwd, encoding: 'utf8', timeout: 30000 }, (_err, stdout) => {
+            const id = (stdout ?? '').match(/"session_id"\s*:\s*"([^"]+)"/)?.[1];
+            log(`Claude CLI probe result: ${id ?? 'no session ID found'}`);
+            resolve(id);
+        });
+    });
+}
+/**
+ * Run `/compact` on an existing Claude session to summarise conversation
+ * history and free up context window space. Used after Claude returns
+ * `prompt is too long: N tokens > MAX maximum` (HTTP 400). Resolves on exit
+ * (success or failure — caller decides what to do).
+ */
+function runClaudeCompact(sessionId, cwd, log) {
+    return new Promise((resolve, reject) => {
+        // /compact is a slash-command Claude understands in non-interactive mode.
+        // --resume re-attaches to the same session before running it.
+        const cmd = `claude --dangerously-skip-permissions --resume ${sessionId} -p "/compact"`;
+        log(`Claude compact: ${cmd}`);
+        (0, child_process_1.exec)(cmd, { cwd, encoding: 'utf8', timeout: 180_000, maxBuffer: 32 * 1024 * 1024 }, (err, stdout) => {
+            if (err) {
+                log(`Claude compact stderr: ${(err.message ?? '').slice(0, 300)}`);
+                reject(err);
+            }
+            else {
+                log(`Claude compact done (${stdout.length} bytes of output)`);
+                resolve();
+            }
+        });
+    });
+}
+/**
+ * Run `/clear` on an existing Claude session to wipe the conversation history
+ * and start fresh. Used when autocompact is thrashing (context refills to
+ * limit immediately after compact). Resolves on exit.
+ */
+function runClaudeClear(sessionId, cwd, log) {
+    return new Promise((resolve, reject) => {
+        const cmd = `claude --dangerously-skip-permissions --resume ${sessionId} -p "/clear"`;
+        log(`Claude clear: ${cmd}`);
+        (0, child_process_1.exec)(cmd, { cwd, encoding: 'utf8', timeout: 60_000, maxBuffer: 32 * 1024 * 1024 }, (err, stdout) => {
+            if (err) {
+                log(`Claude clear stderr: ${(err.message ?? '').slice(0, 300)}`);
+                reject(err);
+            }
+            else {
+                log(`Claude clear done (${stdout.length} bytes of output)`);
+                resolve();
+            }
+        });
+    });
+}
+//# sourceMappingURL=cli.js.map