@ai-sdlc/orchestrator 0.1.0

package/dist/runners/claude-code.js

@@ -0,0 +1,200 @@
+/**
+ * Claude Code runner — invokes Claude Code CLI in --print mode
+ * and collects the result via git diff.
+ */
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_MODEL, DEFAULT_ALLOWED_TOOLS, DEFAULT_RUNNER_TIMEOUT_MS, DEFAULT_LINT_COMMAND, DEFAULT_FORMAT_COMMAND, DEFAULT_COMMIT_MESSAGE_TEMPLATE, DEFAULT_COMMIT_CO_AUTHOR, } from '../defaults.js';
+import { formatContextForPrompt } from '../analysis/context-builder.js';
+const execFileAsync = promisify(execFile);
+export function buildPrompt(ctx) {
+    const lintCmd = ctx.lintCommand ?? DEFAULT_LINT_COMMAND;
+    const fmtCmd = ctx.formatCommand ?? DEFAULT_FORMAT_COMMAND;
+    const lines = [
+        `You are fixing issue #${ctx.issueNumber}: ${ctx.issueTitle}`,
+        '',
+        '## Issue Description',
+        ctx.issueBody,
+        '',
+    ];
+    if (ctx.ciErrors) {
+        let step = 0;
+        lines.push('## CI Failure Logs', '', '```', ctx.ciErrors, '```', '', '## Instructions', `${++step}. Analyze the CI failure logs above to identify the root cause.`, `${++step}. Read the relevant source files to understand the context.`, `${++step}. Fix the errors that caused CI to fail.`);
+        if (fmtCmd) {
+            lines.push(`${++step}. If the failure is a formatting/prettier error, run \`${fmtCmd}\` to auto-fix it.`);
+        }
+        if (lintCmd && fmtCmd) {
+            lines.push(`${++step}. After making ANY code changes, always run \`${lintCmd}\` and \`${fmtCmd}\` to catch issues before committing.`);
+        }
+        else if (lintCmd) {
+            lines.push(`${++step}. After making ANY code changes, always run \`${lintCmd}\` to catch issues before committing.`);
+        }
+        else if (fmtCmd) {
+            lines.push(`${++step}. After making ANY code changes, always run \`${fmtCmd}\` to catch issues before committing.`);
+        }
+        lines.push(`${++step}. Write or update tests if needed to cover your fix.`, `${++step}. Do NOT modify files matching the blocked paths below.`, `${++step}. Keep your changes to at most ${ctx.constraints.maxFilesPerChange} files.`);
+    }
+    else {
+        let step = 0;
+        lines.push('## Instructions', `${++step}. Read the relevant source files to understand the codebase.`, `${++step}. Implement the fix or feature described in the issue.`, `${++step}. Write or update tests to cover your changes.`);
+        if (lintCmd && fmtCmd) {
+            lines.push(`${++step}. After making code changes, run \`${lintCmd}\` and \`${fmtCmd}\` to ensure CI will pass.`);
+        }
+        else if (lintCmd) {
+            lines.push(`${++step}. After making code changes, run \`${lintCmd}\` to ensure CI will pass.`);
+        }
+        else if (fmtCmd) {
+            lines.push(`${++step}. After making code changes, run \`${fmtCmd}\` to ensure CI will pass.`);
+        }
+        lines.push(`${++step}. Do NOT modify files matching the blocked paths below.`, `${++step}. Keep your changes to at most ${ctx.constraints.maxFilesPerChange} files.`);
+    }
+    lines.push('', '## Constraints', `- Maximum files to change: ${ctx.constraints.maxFilesPerChange}`, `- Tests required: ${ctx.constraints.requireTests}`, `- Blocked paths (do NOT modify): ${ctx.constraints.blockedPaths.join(', ') || 'none'}`);
+    // Append relevant episodic memory if available
+    if (ctx.memory) {
+        const episodes = ctx.memory.episodic.search(`issue-${ctx.issueNumber}`);
+        if (episodes.length > 0) {
+            lines.push('', '## Previous Context');
+            for (const ep of episodes.slice(0, 5)) {
+                const summary = ep.metadata && typeof ep.metadata === 'object' && 'summary' in ep.metadata
+                    ? ep.metadata.summary
+                    : ep.key;
+                lines.push(`- ${summary}`);
+            }
+        }
+    }
+    // Append episodic context if available
+    if (ctx.episodicContext) {
+        lines.push('', ctx.episodicContext);
+    }
+    // Append codebase context if available
+    if (ctx.codebaseContext) {
+        lines.push('', formatContextForPrompt(ctx.codebaseContext));
+    }
+    return lines.join('\n');
+}
+async function gitExec(workDir, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd: workDir });
+    return stdout.trim();
+}
+function runClaude(prompt, workDir, opts) {
+    const tools = opts?.allowedTools?.join(',') ?? DEFAULT_ALLOWED_TOOLS;
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_RUNNER_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        const model = opts?.model ?? process.env.AI_SDLC_MODEL ?? DEFAULT_MODEL;
+        const child = spawn('claude', ['-p', '--model', model, '--allowedTools', tools], {
+            cwd: workDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+            timeout: timeoutMs,
+        });
+        const chunks = [];
+        const errChunks = [];
+        child.stdout.on('data', (data) => chunks.push(data));
+        child.stderr.on('data', (data) => errChunks.push(data));
+        child.on('close', (code) => {
+            const stdout = Buffer.concat(chunks).toString('utf-8');
+            const stderr = Buffer.concat(errChunks).toString('utf-8');
+            if (code === 0) {
+                resolve({ stdout, stderr, model });
+            }
+            else {
+                reject(new Error(`claude exited with code ${code}: ${stderr || stdout}`));
+            }
+        });
+        child.on('error', reject);
+        // Send prompt via stdin and close it
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+/**
+ * Parse token usage from Claude CLI stderr output.
+ * Claude Code CLI outputs token info to stderr in various formats.
+ */
+export function parseTokenUsage(stderr, model) {
+    // Try to match patterns like "Input tokens: 1234" / "Output tokens: 5678"
+    const inputMatch = stderr.match(/input[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    const outputMatch = stderr.match(/output[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (inputMatch || outputMatch) {
+        const cacheMatch = stderr.match(/cache[\s_-]*(?:read|hit)[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+        return {
+            inputTokens: inputMatch ? parseInt(inputMatch[1].replace(/,/g, ''), 10) : 0,
+            outputTokens: outputMatch ? parseInt(outputMatch[1].replace(/,/g, ''), 10) : 0,
+            cacheReadTokens: cacheMatch ? parseInt(cacheMatch[1].replace(/,/g, ''), 10) : undefined,
+            model,
+        };
+    }
+    // Try to match total tokens pattern
+    const totalMatch = stderr.match(/total[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (totalMatch) {
+        const total = parseInt(totalMatch[1].replace(/,/g, ''), 10);
+        // Estimate 70% input / 30% output split
+        return {
+            inputTokens: Math.round(total * 0.7),
+            outputTokens: Math.round(total * 0.3),
+            model,
+        };
+    }
+    return undefined;
+}
+export class ClaudeCodeRunner {
+    async run(ctx) {
+        const prompt = buildPrompt(ctx);
+        try {
+            // Invoke Claude Code CLI in print mode, sending prompt via stdin
+            const result = await runClaude(prompt, ctx.workDir, {
+                allowedTools: ctx.allowedTools,
+                timeoutMs: ctx.timeoutMs,
+                model: ctx.model,
+            });
+            // Parse token usage from stderr
+            const tokenUsage = parseTokenUsage(result.stderr, result.model);
+            // Collect changed files
+            const diffOutput = await gitExec(ctx.workDir, ['diff', '--name-only']);
+            const untrackedOutput = await gitExec(ctx.workDir, [
+                'ls-files',
+                '--others',
+                '--exclude-standard',
+            ]);
+            const filesChanged = [
+                ...diffOutput.split('\n').filter(Boolean),
+                ...untrackedOutput.split('\n').filter(Boolean),
+            ];
+            if (filesChanged.length === 0) {
+                return {
+                    success: false,
+                    filesChanged: [],
+                    summary: 'Agent made no changes',
+                    error: 'No files were modified',
+                    tokenUsage,
+                };
+            }
+            // Stage and commit
+            await gitExec(ctx.workDir, ['add', '-A']);
+            const tmpl = ctx.commitMessageTemplate ?? DEFAULT_COMMIT_MESSAGE_TEMPLATE;
+            const coAuthor = ctx.commitCoAuthor ?? DEFAULT_COMMIT_CO_AUTHOR;
+            const commitMsg = tmpl
+                .replace(/\{issueNumber\}/g, String(ctx.issueNumber))
+                .replace(/\{issueTitle\}/g, ctx.issueTitle);
+            await gitExec(ctx.workDir, ['commit', '-m', `${commitMsg}\n\nCo-Authored-By: ${coAuthor}`]);
+            return {
+                success: true,
+                filesChanged,
+                summary: result.stdout.slice(0, 2000),
+                tokenUsage,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                filesChanged: [],
+                summary: 'Agent execution failed',
+                error: message,
+            };
+        }
+    }
+}
+/** @deprecated Use ClaudeCodeRunner instead */
+export const GitHubActionsRunner = ClaudeCodeRunner;
+//# sourceMappingURL=claude-code.js.map

package/dist/runners/codex.d.ts

@@ -0,0 +1,19 @@
+/**
+ * OpenAI Codex CLI runner — invokes `codex exec -` with stdin prompt
+ * in --full-auto --json mode and collects the result via git diff.
+ */
+import type { AgentRunner, AgentContext, AgentResult, TokenUsage } from './types.js';
+import { buildPrompt } from './claude-code.js';
+export { buildPrompt };
+/**
+ * Parse token usage from Codex CLI output.
+ *
+ * Enhanced parser: first tries to parse NDJSON events from stderr
+ * (looking for `usage` or `token_usage` fields), accumulating totals
+ * across multiple events. Falls back to regex matching.
+ */
+export declare function parseTokenUsage(stderr: string, model: string): TokenUsage | undefined;
+export declare class CodexRunner implements AgentRunner {
+    run(ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=codex.d.ts.map

package/dist/runners/codex.js

@@ -0,0 +1,153 @@
+/**
+ * OpenAI Codex CLI runner — invokes `codex exec -` with stdin prompt
+ * in --full-auto --json mode and collects the result via git diff.
+ */
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_RUNNER_TIMEOUT_MS, DEFAULT_CODEX_MODEL, DEFAULT_COMMIT_MESSAGE_TEMPLATE, DEFAULT_COMMIT_CO_AUTHOR, } from '../defaults.js';
+import { buildPrompt } from './claude-code.js';
+export { buildPrompt };
+const execFileAsync = promisify(execFile);
+async function gitExec(workDir, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd: workDir });
+    return stdout.trim();
+}
+/**
+ * Parse token usage from Codex CLI output.
+ *
+ * Enhanced parser: first tries to parse NDJSON events from stderr
+ * (looking for `usage` or `token_usage` fields), accumulating totals
+ * across multiple events. Falls back to regex matching.
+ */
+export function parseTokenUsage(stderr, model) {
+    // First pass: try parsing NDJSON events with usage data
+    let inputTotal = 0;
+    let outputTotal = 0;
+    let foundJson = false;
+    const lines = stderr.split('\n').filter(Boolean);
+    for (const line of lines) {
+        try {
+            const obj = JSON.parse(line);
+            const usage = obj.usage ?? obj.token_usage;
+            if (usage && typeof usage === 'object') {
+                const input = usage.input_tokens ?? usage.prompt_tokens ?? 0;
+                const output = usage.output_tokens ?? usage.completion_tokens ?? 0;
+                if (typeof input === 'number')
+                    inputTotal += input;
+                if (typeof output === 'number')
+                    outputTotal += output;
+                foundJson = true;
+            }
+        }
+        catch {
+            // Not JSON — skip
+        }
+    }
+    if (foundJson && (inputTotal > 0 || outputTotal > 0)) {
+        return { inputTokens: inputTotal, outputTokens: outputTotal, model };
+    }
+    // Fallback: regex matching
+    const inputMatch = stderr.match(/input[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    const outputMatch = stderr.match(/output[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (inputMatch || outputMatch) {
+        return {
+            inputTokens: inputMatch ? parseInt(inputMatch[1].replace(/,/g, ''), 10) : 0,
+            outputTokens: outputMatch ? parseInt(outputMatch[1].replace(/,/g, ''), 10) : 0,
+            model,
+        };
+    }
+    const totalMatch = stderr.match(/total[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (totalMatch) {
+        const total = parseInt(totalMatch[1].replace(/,/g, ''), 10);
+        return {
+            inputTokens: Math.round(total * 0.7),
+            outputTokens: Math.round(total * 0.3),
+            model,
+        };
+    }
+    return undefined;
+}
+export class CodexRunner {
+    async run(ctx) {
+        const prompt = buildPrompt(ctx);
+        const timeoutMs = ctx.timeoutMs ?? DEFAULT_RUNNER_TIMEOUT_MS;
+        const model = DEFAULT_CODEX_MODEL ?? 'codex-default';
+        try {
+            const args = ['exec', '-', '--full-auto', '--json'];
+            if (DEFAULT_CODEX_MODEL) {
+                args.push('-m', DEFAULT_CODEX_MODEL);
+            }
+            const { stdout, stderr } = await new Promise((resolve, reject) => {
+                const child = spawn('codex', args, {
+                    cwd: ctx.workDir,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                    env: { ...process.env },
+                    timeout: timeoutMs,
+                });
+                const chunks = [];
+                const errChunks = [];
+                child.stdout.on('data', (data) => chunks.push(data));
+                child.stderr.on('data', (data) => errChunks.push(data));
+                child.on('close', (code) => {
+                    const out = Buffer.concat(chunks).toString('utf-8');
+                    const err = Buffer.concat(errChunks).toString('utf-8');
+                    if (code === 0) {
+                        resolve({ stdout: out, stderr: err });
+                    }
+                    else {
+                        reject(new Error(`codex exited with code ${code}: ${err || out}`));
+                    }
+                });
+                child.on('error', reject);
+                // Send prompt via stdin and close it
+                child.stdin.write(prompt);
+                child.stdin.end();
+            });
+            const tokenUsage = parseTokenUsage(stderr, model);
+            // Collect changed files
+            const diffOutput = await gitExec(ctx.workDir, ['diff', '--name-only']);
+            const untrackedOutput = await gitExec(ctx.workDir, [
+                'ls-files',
+                '--others',
+                '--exclude-standard',
+            ]);
+            const filesChanged = [
+                ...diffOutput.split('\n').filter(Boolean),
+                ...untrackedOutput.split('\n').filter(Boolean),
+            ];
+            if (filesChanged.length === 0) {
+                return {
+                    success: false,
+                    filesChanged: [],
+                    summary: 'Agent made no changes',
+                    error: 'No files were modified',
+                    tokenUsage,
+                };
+            }
+            // Stage and commit
+            await gitExec(ctx.workDir, ['add', '-A']);
+            const tmpl = ctx.commitMessageTemplate ?? DEFAULT_COMMIT_MESSAGE_TEMPLATE;
+            const coAuthor = ctx.commitCoAuthor ?? DEFAULT_COMMIT_CO_AUTHOR;
+            const commitMsg = tmpl
+                .replace(/\{issueNumber\}/g, String(ctx.issueNumber))
+                .replace(/\{issueTitle\}/g, ctx.issueTitle);
+            await gitExec(ctx.workDir, ['commit', '-m', `${commitMsg}\n\nCo-Authored-By: ${coAuthor}`]);
+            return {
+                success: true,
+                filesChanged,
+                summary: stdout.slice(0, 2000),
+                tokenUsage,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                filesChanged: [],
+                summary: 'Agent execution failed',
+                error: message,
+            };
+        }
+    }
+}
+//# sourceMappingURL=codex.js.map

package/dist/runners/copilot-stub.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stub runner for GitHub Copilot — placeholder for future implementation.
+ */
+import type { AgentRunner, AgentContext, AgentResult } from './types.js';
+export declare class CopilotStubRunner implements AgentRunner {
+    readonly name = "copilot";
+    run(_ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=copilot-stub.d.ts.map

package/dist/runners/copilot-stub.js

@@ -0,0 +1,15 @@
+/**
+ * Stub runner for GitHub Copilot — placeholder for future implementation.
+ */
+export class CopilotStubRunner {
+    name = 'copilot';
+    async run(_ctx) {
+        return {
+            success: false,
+            filesChanged: [],
+            summary: 'GitHub Copilot runner not yet implemented',
+            error: 'STUB: GitHub Copilot integration requires Copilot Workspace API access',
+        };
+    }
+}
+//# sourceMappingURL=copilot-stub.js.map

package/dist/runners/copilot.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GitHub Copilot CLI runner — invokes `copilot` in --yolo mode
+ * and collects the result via git diff.
+ */
+import type { AgentRunner, AgentContext, AgentResult, TokenUsage } from './types.js';
+import { buildPrompt } from './claude-code.js';
+export { buildPrompt };
+/**
+ * Parse token usage from Copilot CLI stderr output.
+ */
+export declare function parseTokenUsage(stderr: string, model: string): TokenUsage | undefined;
+export declare class CopilotRunner implements AgentRunner {
+    run(ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=copilot.d.ts.map

package/dist/runners/copilot.js

@@ -0,0 +1,119 @@
+/**
+ * GitHub Copilot CLI runner — invokes `copilot` in --yolo mode
+ * and collects the result via git diff.
+ */
+import { spawn, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { DEFAULT_RUNNER_TIMEOUT_MS, DEFAULT_COPILOT_MODEL, DEFAULT_COMMIT_MESSAGE_TEMPLATE, DEFAULT_COMMIT_CO_AUTHOR, } from '../defaults.js';
+import { buildPrompt } from './claude-code.js';
+export { buildPrompt };
+const execFileAsync = promisify(execFile);
+async function gitExec(workDir, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd: workDir });
+    return stdout.trim();
+}
+/**
+ * Parse token usage from Copilot CLI stderr output.
+ */
+export function parseTokenUsage(stderr, model) {
+    const inputMatch = stderr.match(/input[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    const outputMatch = stderr.match(/output[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (inputMatch || outputMatch) {
+        return {
+            inputTokens: inputMatch ? parseInt(inputMatch[1].replace(/,/g, ''), 10) : 0,
+            outputTokens: outputMatch ? parseInt(outputMatch[1].replace(/,/g, ''), 10) : 0,
+            model,
+        };
+    }
+    const totalMatch = stderr.match(/total[\s_-]*tokens?[:\s]+(\d[\d,]*)/i);
+    if (totalMatch) {
+        const total = parseInt(totalMatch[1].replace(/,/g, ''), 10);
+        return {
+            inputTokens: Math.round(total * 0.7),
+            outputTokens: Math.round(total * 0.3),
+            model,
+        };
+    }
+    return undefined;
+}
+export class CopilotRunner {
+    async run(ctx) {
+        const prompt = buildPrompt(ctx);
+        const timeoutMs = ctx.timeoutMs ?? DEFAULT_RUNNER_TIMEOUT_MS;
+        const model = DEFAULT_COPILOT_MODEL ?? 'copilot-default';
+        try {
+            const args = ['-p', prompt, '--yolo'];
+            if (DEFAULT_COPILOT_MODEL) {
+                args.push('--model', DEFAULT_COPILOT_MODEL);
+            }
+            const { stdout, stderr } = await new Promise((resolve, reject) => {
+                const child = spawn('copilot', args, {
+                    cwd: ctx.workDir,
+                    stdio: ['ignore', 'pipe', 'pipe'],
+                    env: { ...process.env },
+                    timeout: timeoutMs,
+                });
+                const chunks = [];
+                const errChunks = [];
+                child.stdout.on('data', (data) => chunks.push(data));
+                child.stderr.on('data', (data) => errChunks.push(data));
+                child.on('close', (code) => {
+                    const out = Buffer.concat(chunks).toString('utf-8');
+                    const err = Buffer.concat(errChunks).toString('utf-8');
+                    if (code === 0) {
+                        resolve({ stdout: out, stderr: err });
+                    }
+                    else {
+                        reject(new Error(`copilot exited with code ${code}: ${err || out}`));
+                    }
+                });
+                child.on('error', reject);
+            });
+            const tokenUsage = parseTokenUsage(stderr, model);
+            // Collect changed files
+            const diffOutput = await gitExec(ctx.workDir, ['diff', '--name-only']);
+            const untrackedOutput = await gitExec(ctx.workDir, [
+                'ls-files',
+                '--others',
+                '--exclude-standard',
+            ]);
+            const filesChanged = [
+                ...diffOutput.split('\n').filter(Boolean),
+                ...untrackedOutput.split('\n').filter(Boolean),
+            ];
+            if (filesChanged.length === 0) {
+                return {
+                    success: false,
+                    filesChanged: [],
+                    summary: 'Agent made no changes',
+                    error: 'No files were modified',
+                    tokenUsage,
+                };
+            }
+            // Stage and commit
+            await gitExec(ctx.workDir, ['add', '-A']);
+            const tmpl = ctx.commitMessageTemplate ?? DEFAULT_COMMIT_MESSAGE_TEMPLATE;
+            const coAuthor = ctx.commitCoAuthor ?? DEFAULT_COMMIT_CO_AUTHOR;
+            const commitMsg = tmpl
+                .replace(/\{issueNumber\}/g, String(ctx.issueNumber))
+                .replace(/\{issueTitle\}/g, ctx.issueTitle);
+            await gitExec(ctx.workDir, ['commit', '-m', `${commitMsg}\n\nCo-Authored-By: ${coAuthor}`]);
+            return {
+                success: true,
+                filesChanged,
+                summary: stdout.slice(0, 2000),
+                tokenUsage,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+                success: false,
+                filesChanged: [],
+                summary: 'Agent execution failed',
+                error: message,
+            };
+        }
+    }
+}
+//# sourceMappingURL=copilot.js.map

package/dist/runners/cursor-stub.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stub runner for Cursor — placeholder for future implementation.
+ */
+import type { AgentRunner, AgentContext, AgentResult } from './types.js';
+export declare class CursorStubRunner implements AgentRunner {
+    readonly name = "cursor";
+    run(_ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=cursor-stub.d.ts.map

package/dist/runners/cursor-stub.js

@@ -0,0 +1,15 @@
+/**
+ * Stub runner for Cursor — placeholder for future implementation.
+ */
+export class CursorStubRunner {
+    name = 'cursor';
+    async run(_ctx) {
+        return {
+            success: false,
+            filesChanged: [],
+            summary: 'Cursor runner not yet implemented',
+            error: 'STUB: Cursor integration requires Cursor Agent API access',
+        };
+    }
+}
+//# sourceMappingURL=cursor-stub.js.map

package/dist/runners/cursor.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cursor CLI runner — invokes `cursor-agent` in --print mode with
+ * stream-json output and collects the result via git diff.
+ */
+import type { AgentRunner, AgentContext, AgentResult, TokenUsage } from './types.js';
+import { buildPrompt } from './claude-code.js';
+export { buildPrompt };
+/**
+ * Parse NDJSON stream output from cursor-agent --output-format=stream-json.
+ * Extracts the final assistant message content for use as a summary.
+ */
+export declare function parseStreamJson(stdout: string): string;
+/**
+ * Parse token usage from Cursor CLI stderr output.
+ */
+export declare function parseTokenUsage(stderr: string, model: string): TokenUsage | undefined;
+export declare class CursorRunner implements AgentRunner {
+    run(ctx: AgentContext): Promise<AgentResult>;
+}
+//# sourceMappingURL=cursor.d.ts.map