@shepai/cli 1.8.2 → 1.9.0

package/dist/src/infrastructure/services/agents/agent-executor-factory.service.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Agent Executor Factory Service
+ *
+ * Infrastructure implementation of the IAgentExecutorFactory port.
+ * Creates and caches agent executor instances based on agent type.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import type { AgentType, AgentConfig } from '../../../domain/generated/output.js';
+import type { IAgentExecutor } from '../../../application/ports/output/agent-executor.interface.js';
+import type { IAgentExecutorFactory } from '../../../application/ports/output/agent-executor-factory.interface.js';
+import { type SpawnFunction } from './executors/claude-code-executor.service.js';
+/**
+ * Factory that creates and caches agent executor instances.
+ *
+ * Executor instances are cached per agent type (singleton per type)
+ * to avoid unnecessary re-creation of stateless executors.
+ */
+export declare class AgentExecutorFactory implements IAgentExecutorFactory {
+    private readonly spawn;
+    private readonly cache;
+    /**
+     * @param spawn - Spawn function for creating subprocesses (injectable for testing).
+     */
+    constructor(spawn: SpawnFunction);
+    /**
+     * Create (or return cached) executor for the specified agent type.
+     *
+     * @param agentType - The type of agent to create an executor for
+     * @param _authConfig - Agent authentication and configuration
+     * @returns A configured agent executor
+     * @throws Error if the agent type is not supported
+     */
+    createExecutor(agentType: AgentType, _authConfig: AgentConfig): IAgentExecutor;
+    /**
+     * Get the list of agent types this factory can create executors for.
+     *
+     * @returns Array of supported agent types
+     */
+    getSupportedAgents(): AgentType[];
+}
+//# sourceMappingURL=agent-executor-factory.service.d.ts.map

package/dist/src/infrastructure/services/agents/agent-executor-factory.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-executor-factory.service.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/agents/agent-executor-factory.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAClF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+DAA+D,CAAC;AACpG,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uEAAuE,CAAC;AACnH,OAAO,EAEL,KAAK,aAAa,EACnB,MAAM,6CAA6C,CAAC;AAErD;;;;;GAKG;AACH,qBAAa,oBAAqB,YAAW,qBAAqB;IAMpD,OAAO,CAAC,QAAQ,CAAC,KAAK;IALlC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAE3D;;OAEG;gBAC0B,KAAK,EAAE,aAAa;IAEjD;;;;;;;OAOG;IACH,cAAc,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,GAAG,cAAc;IAoB9E;;;;OAIG;IACH,kBAAkB,IAAI,SAAS,EAAE;CAGlC"}

package/dist/src/infrastructure/services/agents/agent-executor-factory.service.js

@@ -0,0 +1,58 @@
+/**
+ * Agent Executor Factory Service
+ *
+ * Infrastructure implementation of the IAgentExecutorFactory port.
+ * Creates and caches agent executor instances based on agent type.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import { ClaudeCodeExecutorService, } from './executors/claude-code-executor.service.js';
+/**
+ * Factory that creates and caches agent executor instances.
+ *
+ * Executor instances are cached per agent type (singleton per type)
+ * to avoid unnecessary re-creation of stateless executors.
+ */
+export class AgentExecutorFactory {
+    spawn;
+    cache = new Map();
+    /**
+     * @param spawn - Spawn function for creating subprocesses (injectable for testing).
+     */
+    constructor(spawn) {
+        this.spawn = spawn;
+    }
+    /**
+     * Create (or return cached) executor for the specified agent type.
+     *
+     * @param agentType - The type of agent to create an executor for
+     * @param _authConfig - Agent authentication and configuration
+     * @returns A configured agent executor
+     * @throws Error if the agent type is not supported
+     */
+    createExecutor(agentType, _authConfig) {
+        const key = agentType;
+        const cached = this.cache.get(key);
+        if (cached)
+            return cached;
+        let executor;
+        switch (key) {
+            case 'claude-code':
+                executor = new ClaudeCodeExecutorService(this.spawn);
+                break;
+            default:
+                throw new Error(`Unsupported agent type: ${agentType}. Supported: ${this.getSupportedAgents().join(', ')}`);
+        }
+        this.cache.set(key, executor);
+        return executor;
+    }
+    /**
+     * Get the list of agent types this factory can create executors for.
+     *
+     * @returns Array of supported agent types
+     */
+    getSupportedAgents() {
+        return ['claude-code'];
+    }
+}

package/dist/src/infrastructure/services/agents/agent-registry.service.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Agent Registry Service
+ *
+ * Infrastructure implementation of the IAgentRegistry port.
+ * Manages agent workflow definitions in an in-memory map,
+ * enabling runtime discovery and instantiation of agent workflows.
+ *
+ * Pre-registers built-in agents (analyze-repository) at construction time.
+ */
+import type { IAgentRegistry, AgentDefinitionWithFactory } from '../../../application/ports/output/agent-registry.interface.js';
+export declare class AgentRegistryService implements IAgentRegistry {
+    private readonly agents;
+    constructor();
+    register(definition: AgentDefinitionWithFactory): void;
+    get(name: string): AgentDefinitionWithFactory | undefined;
+    list(): AgentDefinitionWithFactory[];
+}
+//# sourceMappingURL=agent-registry.service.d.ts.map

package/dist/src/infrastructure/services/agents/agent-registry.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-registry.service.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/agents/agent-registry.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,0BAA0B,EAC3B,MAAM,wDAAwD,CAAC;AAGhE,qBAAa,oBAAqB,YAAW,cAAc;IACzD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiD;;IAWxE,QAAQ,CAAC,UAAU,EAAE,0BAA0B,GAAG,IAAI;IAItD,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS;IAIzD,IAAI,IAAI,0BAA0B,EAAE;CAGrC"}

package/dist/src/infrastructure/services/agents/agent-registry.service.js

@@ -0,0 +1,30 @@
+/**
+ * Agent Registry Service
+ *
+ * Infrastructure implementation of the IAgentRegistry port.
+ * Manages agent workflow definitions in an in-memory map,
+ * enabling runtime discovery and instantiation of agent workflows.
+ *
+ * Pre-registers built-in agents (analyze-repository) at construction time.
+ */
+import { createAnalyzeRepositoryGraph } from './langgraph/analyze-repository-graph.js';
+export class AgentRegistryService {
+    agents = new Map();
+    constructor() {
+        // Register built-in agents
+        this.register({
+            name: 'analyze-repository',
+            description: 'Analyze repository structure, dependencies, and architecture',
+            graphFactory: createAnalyzeRepositoryGraph,
+        });
+    }
+    register(definition) {
+        this.agents.set(definition.name, definition);
+    }
+    get(name) {
+        return this.agents.get(name);
+    }
+    list() {
+        return Array.from(this.agents.values());
+    }
+}

package/dist/src/infrastructure/services/agents/agent-runner.service.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agent Runner Service
+ *
+ * Infrastructure implementation of the IAgentRunner port.
+ * Orchestrates agent execution by resolving definitions from the registry,
+ * creating executors, compiling LangGraph workflows, and tracking runs
+ * in the repository.
+ */
+import type { BaseCheckpointSaver } from '@langchain/langgraph';
+import type { IAgentRunner, AgentRunOptions } from '../../../application/ports/output/agent-runner.interface.js';
+import type { IAgentRegistry } from '../../../application/ports/output/agent-registry.interface.js';
+import type { IAgentExecutorFactory } from '../../../application/ports/output/agent-executor-factory.interface.js';
+import type { IAgentRunRepository } from '../../../application/ports/output/agent-run-repository.interface.js';
+import type { AgentRun, AgentRunEvent } from '../../../domain/generated/output.js';
+export declare class AgentRunnerService implements IAgentRunner {
+    private readonly registry;
+    private readonly executorFactory;
+    private readonly checkpointer;
+    private readonly runRepository;
+    constructor(registry: IAgentRegistry, executorFactory: IAgentExecutorFactory, checkpointer: BaseCheckpointSaver, runRepository: IAgentRunRepository);
+    runAgent(agentName: string, prompt: string, options?: AgentRunOptions): Promise<AgentRun>;
+    runAgentStream(agentName: string, prompt: string, options?: AgentRunOptions): AsyncIterable<AgentRunEvent>;
+    private setupRun;
+    private markCompleted;
+    private markFailed;
+}
+//# sourceMappingURL=agent-runner.service.d.ts.map

package/dist/src/infrastructure/services/agents/agent-runner.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.service.d.ts","sourceRoot":"","sources":["../../../../../src/infrastructure/services/agents/agent-runner.service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EAChB,MAAM,sDAAsD,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wDAAwD,CAAC;AAC7F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gEAAgE,CAAC;AAC5G,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8DAA8D,CAAC;AAExG,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAM5E,qBAAa,kBAAmB,YAAW,YAAY;IAEnD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAHb,QAAQ,EAAE,cAAc,EACxB,eAAe,EAAE,qBAAqB,EACtC,YAAY,EAAE,mBAAmB,EACjC,aAAa,EAAE,mBAAmB;IAG/C,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;IAmBxF,cAAc,CACnB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,eAAe,GACxB,aAAa,CAAC,aAAa,CAAC;YAwCjB,QAAQ;YAwCR,aAAa;YAUb,UAAU;CAQzB"}

package/dist/src/infrastructure/services/agents/agent-runner.service.js

@@ -0,0 +1,117 @@
+/**
+ * Agent Runner Service
+ *
+ * Infrastructure implementation of the IAgentRunner port.
+ * Orchestrates agent execution by resolving definitions from the registry,
+ * creating executors, compiling LangGraph workflows, and tracking runs
+ * in the repository.
+ */
+import * as crypto from 'node:crypto';
+import { AgentRunStatus } from '../../../domain/generated/output.js';
+import { getSettings } from '../../../infrastructure/services/settings.service.js';
+import { EventChannel } from './streaming/event-channel.js';
+import { StreamingExecutorProxy } from './streaming/streaming-executor-proxy.js';
+export class AgentRunnerService {
+    registry;
+    executorFactory;
+    checkpointer;
+    runRepository;
+    constructor(registry, executorFactory, checkpointer, runRepository) {
+        this.registry = registry;
+        this.executorFactory = executorFactory;
+        this.checkpointer = checkpointer;
+        this.runRepository = runRepository;
+    }
+    async runAgent(agentName, prompt, options) {
+        const { definition, executor, runId, threadId } = await this.setupRun(agentName, prompt);
+        try {
+            const compiledGraph = definition.graphFactory(executor, this.checkpointer);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = await compiledGraph.invoke({ repositoryPath: options?.repositoryPath ?? process.cwd() }, { configurable: { thread_id: threadId } });
+            await this.markCompleted(runId, result);
+            return (await this.runRepository.findById(runId));
+        }
+        catch (error) {
+            await this.markFailed(runId, error);
+            return (await this.runRepository.findById(runId));
+        }
+    }
+    async *runAgentStream(agentName, prompt, options) {
+        const { definition, executor, runId, threadId } = await this.setupRun(agentName, prompt);
+        // Create streaming channel and proxy
+        const channel = new EventChannel();
+        const proxy = new StreamingExecutorProxy(executor, channel);
+        // Compile graph with proxy (graph doesn't know about streaming)
+        const compiledGraph = definition.graphFactory(proxy, this.checkpointer);
+        // Start graph invocation in background
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const graphPromise = compiledGraph
+            .invoke({ repositoryPath: options?.repositoryPath ?? process.cwd() }, { configurable: { thread_id: threadId } })
+            .then(async (result) => {
+            channel.close();
+            await this.markCompleted(runId, result);
+        })
+            .catch(async (error) => {
+            channel.close();
+            await this.markFailed(runId, error);
+        });
+        // Yield events as they arrive, mapping infra → domain type
+        for await (const event of channel) {
+            yield {
+                type: event.type,
+                content: event.content,
+                timestamp: event.timestamp instanceof Date ? event.timestamp.toISOString() : event.timestamp,
+            };
+        }
+        // Ensure graph promise cleanup completes
+        await graphPromise;
+    }
+    async setupRun(agentName, prompt) {
+        const definition = this.registry.get(agentName);
+        if (!definition) {
+            throw new Error(`Agent '${agentName}' not found. Available: ${this.registry
+                .list()
+                .map((a) => a.name)
+                .join(', ')}`);
+        }
+        const settings = getSettings();
+        const agentType = settings.agent.type;
+        const executor = this.executorFactory.createExecutor(agentType, settings.agent);
+        const runId = crypto.randomUUID();
+        const threadId = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const agentRun = {
+            id: runId,
+            agentType,
+            agentName,
+            status: AgentRunStatus.pending,
+            prompt,
+            threadId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        await this.runRepository.create(agentRun);
+        await this.runRepository.updateStatus(runId, AgentRunStatus.running, {
+            pid: process.pid,
+            startedAt: now,
+            updatedAt: now,
+        });
+        return { definition, executor, runId, threadId };
+    }
+    async markCompleted(runId, result) {
+        const completedAt = new Date().toISOString();
+        await this.runRepository.updateStatus(runId, AgentRunStatus.completed, {
+            result: result.analysisMarkdown ?? result.result ?? JSON.stringify(result),
+            completedAt,
+            updatedAt: completedAt,
+        });
+    }
+    async markFailed(runId, error) {
+        const failedAt = new Date().toISOString();
+        await this.runRepository.updateStatus(runId, AgentRunStatus.failed, {
+            error: error instanceof Error ? error.message : String(error),
+            completedAt: failedAt,
+            updatedAt: failedAt,
+        });
+    }
+}

package/dist/src/infrastructure/services/agents/executors/claude-code-executor.service.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Claude Code Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for Claude Code agent.
+ * Executes prompts via the `claude` CLI subprocess with JSON and stream-json
+ * output formats.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+import type { ChildProcess } from 'node:child_process';
+import type { AgentType, AgentFeature } from '../../../../domain/generated/output.js';
+import type { IAgentExecutor, AgentExecutionOptions, AgentExecutionResult, AgentExecutionStreamEvent } from '../../../../application/ports/output/agent-executor.interface.js';
+/**
+ * Type for the spawn dependency.
+ * Matches the signature of child_process.spawn.
+ * Injected via constructor to enable testability.
+ */
+export type SpawnFunction = (command: string, args: string[], options?: object) => ChildProcess;
+/**
+ * Executor service for Claude Code agent.
+ * Uses subprocess spawning to interact with the `claude` CLI.
+ */
+export declare class ClaudeCodeExecutorService implements IAgentExecutor {
+    private readonly spawn;
+    readonly agentType: AgentType;
+    constructor(spawn: SpawnFunction);
+    execute(prompt: string, options?: AgentExecutionOptions): Promise<AgentExecutionResult>;
+    executeStream(prompt: string, options?: AgentExecutionOptions): AsyncIterable<AgentExecutionStreamEvent>;
+    supportsFeature(feature: AgentFeature): boolean;
+    private buildArgs;
+    private buildStreamArgs;
+    private buildSpawnOptions;
+    private parseJsonResult;
+    private parseStreamLine;
+}
+//# sourceMappingURL=claude-code-executor.service.d.ts.map

package/dist/src/infrastructure/services/agents/executors/claude-code-executor.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code-executor.service.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/executors/claude-code-executor.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AACtF,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,kEAAkE,CAAC;AAE1E;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,YAAY,CAAC;AAUhG;;;GAGG;AACH,qBAAa,yBAA0B,YAAW,cAAc;IAGlD,OAAO,CAAC,QAAQ,CAAC,KAAK;IAFlC,QAAQ,CAAC,SAAS,EAAE,SAAS,CAA8B;gBAE9B,KAAK,EAAE,aAAa;IAE3C,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAiDtF,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,yBAAyB,CAAC;IA+F3C,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAI/C,OAAO,CAAC,SAAS;IAWjB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,eAAe;IAiCvB,OAAO,CAAC,eAAe;CAkExB"}

package/dist/src/infrastructure/services/agents/executors/claude-code-executor.service.js

@@ -0,0 +1,275 @@
+/**
+ * Claude Code Executor Service
+ *
+ * Infrastructure implementation of IAgentExecutor for Claude Code agent.
+ * Executes prompts via the `claude` CLI subprocess with JSON and stream-json
+ * output formats.
+ *
+ * Uses constructor dependency injection for the spawn function
+ * to enable testability without mocking node:child_process directly.
+ */
+/** Features supported by Claude Code CLI */
+const SUPPORTED_FEATURES = new Set([
+    'session-resume',
+    'streaming',
+    'system-prompt',
+    'structured-output',
+]);
+/**
+ * Executor service for Claude Code agent.
+ * Uses subprocess spawning to interact with the `claude` CLI.
+ */
+export class ClaudeCodeExecutorService {
+    spawn;
+    agentType = 'claude-code';
+    constructor(spawn) {
+        this.spawn = spawn;
+    }
+    async execute(prompt, options) {
+        const args = this.buildArgs(prompt, options);
+        const spawnOpts = this.buildSpawnOptions(options);
+        const proc = this.spawn('claude', args, spawnOpts);
+        return new Promise((resolve, reject) => {
+            let stdout = '';
+            let stderr = '';
+            let timedOut = false;
+            let timeoutId;
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    timedOut = true;
+                    proc.kill();
+                }, options.timeout);
+            }
+            proc.stdout?.on('data', (chunk) => {
+                stdout += chunk.toString();
+            });
+            proc.stderr?.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+            proc.on('error', (error) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                reject(error);
+            });
+            proc.on('close', (code) => {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                if (timedOut) {
+                    reject(new Error('Agent execution timed out'));
+                    return;
+                }
+                if (code !== 0 && code !== null) {
+                    reject(new Error(stderr.trim() || `Process exited with code ${code}`));
+                    return;
+                }
+                resolve(this.parseJsonResult(stdout));
+            });
+        });
+    }
+    async *executeStream(prompt, options) {
+        const args = this.buildStreamArgs(prompt, options);
+        const spawnOpts = this.buildSpawnOptions(options);
+        const proc = this.spawn('claude', args, spawnOpts);
+        // Close stdin immediately - we're not sending input in print mode
+        if (proc.stdin) {
+            proc.stdin.end();
+        }
+        // Buffer for incomplete lines
+        let lineBuffer = '';
+        let stderr = '';
+        // Create an async queue to bridge event-based IO to async iteration
+        const queue = [];
+        let resolve = null;
+        let error = null;
+        function enqueue(event) {
+            queue.push(event);
+            if (resolve) {
+                resolve();
+                resolve = null;
+            }
+        }
+        function waitForItem() {
+            if (queue.length > 0)
+                return Promise.resolve();
+            return new Promise((r) => {
+                resolve = r;
+            });
+        }
+        proc.stdout?.on('data', (chunk) => {
+            lineBuffer += chunk.toString();
+            const lines = lineBuffer.split('\n');
+            // Keep the last partial line in the buffer
+            lineBuffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                const event = this.parseStreamLine(trimmed);
+                if (event) {
+                    enqueue(event);
+                }
+            }
+        });
+        proc.stderr?.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        proc.on('error', (err) => {
+            error = err;
+            enqueue(null); // signal end
+        });
+        proc.on('close', (code) => {
+            // Process any remaining data in the buffer
+            if (lineBuffer.trim()) {
+                const event = this.parseStreamLine(lineBuffer.trim());
+                if (event)
+                    enqueue(event);
+            }
+            if (code !== 0 && code !== null && stderr.trim()) {
+                enqueue({
+                    type: 'error',
+                    content: stderr.trim(),
+                    timestamp: new Date(),
+                });
+            }
+            enqueue(null); // signal end
+        });
+        // Yield events as they arrive
+        while (true) {
+            await waitForItem();
+            const item = queue.shift();
+            if (item === null || item === undefined) {
+                if (error !== null) {
+                    yield {
+                        type: 'error',
+                        content: error.message,
+                        timestamp: new Date(),
+                    };
+                }
+                return;
+            }
+            yield item;
+        }
+    }
+    supportsFeature(feature) {
+        return SUPPORTED_FEATURES.has(feature);
+    }
+    buildArgs(prompt, options) {
+        const args = ['-p', prompt, '--output-format', 'json'];
+        if (options?.resumeSession)
+            args.push('--resume', options.resumeSession);
+        if (options?.model)
+            args.push('--model', options.model);
+        if (options?.systemPrompt)
+            args.push('--append-system-prompt', options.systemPrompt);
+        if (options?.allowedTools?.length)
+            args.push('--allowedTools', options.allowedTools.join(','));
+        if (options?.outputSchema)
+            args.push('--json-schema', JSON.stringify(options.outputSchema));
+        if (options?.maxTurns)
+            args.push('--max-turns', String(options.maxTurns));
+        return args;
+    }
+    buildStreamArgs(prompt, options) {
+        const args = this.buildArgs(prompt, options);
+        const fmtIdx = args.indexOf('--output-format');
+        if (fmtIdx !== -1)
+            args[fmtIdx + 1] = 'stream-json';
+        // stream-json requires --verbose and --include-partial-messages when using -p (--print)
+        // --no-chrome ensures it runs in non-interactive mode without browser integration
+        args.push('--verbose', '--include-partial-messages', '--no-chrome');
+        return args;
+    }
+    buildSpawnOptions(options) {
+        const spawnOpts = {};
+        if (options?.cwd)
+            spawnOpts.cwd = options.cwd;
+        return spawnOpts;
+    }
+    parseJsonResult(stdout) {
+        const trimmed = stdout.trim();
+        try {
+            const parsed = JSON.parse(trimmed);
+            const result = {
+                result: parsed.result ?? trimmed,
+            };
+            if (parsed.session_id) {
+                result.sessionId = parsed.session_id;
+            }
+            if (parsed.input_tokens !== undefined && parsed.output_tokens !== undefined) {
+                result.usage = {
+                    inputTokens: parsed.input_tokens,
+                    outputTokens: parsed.output_tokens,
+                };
+            }
+            // Store additional metadata
+            const { result: _r, session_id: _s, input_tokens: _it, output_tokens: _ot, ...rest } = parsed;
+            if (Object.keys(rest).length > 0) {
+                result.metadata = rest;
+            }
+            return result;
+        }
+        catch {
+            // If stdout is not valid JSON, treat it as raw text result
+            return { result: trimmed };
+        }
+    }
+    parseStreamLine(line) {
+        try {
+            const parsed = JSON.parse(line);
+            // Handle Claude Code stream_json format with nested events
+            if (parsed.type === 'stream_event' && parsed.event) {
+                const { event } = parsed;
+                // Extract text deltas for progress
+                if (event.type === 'content_block_delta' && event.delta?.text) {
+                    return {
+                        type: 'progress',
+                        content: event.delta.text,
+                        timestamp: new Date(),
+                    };
+                }
+                // Message complete - ignore for now (accumulated text is in progress events)
+                if (event.type === 'message_stop') {
+                    return null;
+                }
+            }
+            // Ignore assistant messages - we already get all text via content_block_delta events
+            if (parsed.type === 'assistant') {
+                return null;
+            }
+            // Handle legacy format (backward compatibility)
+            if (parsed.type === 'result') {
+                return {
+                    type: 'result',
+                    content: parsed.result ?? '',
+                    timestamp: new Date(),
+                };
+            }
+            if (parsed.type === 'error') {
+                return {
+                    type: 'error',
+                    content: parsed.error ?? parsed.message ?? '',
+                    timestamp: new Date(),
+                };
+            }
+            // Generic progress for other event types (ensure content is a string)
+            if (parsed.content || parsed.message) {
+                const rawContent = parsed.content ?? parsed.message;
+                const content = typeof rawContent === 'string' ? rawContent : JSON.stringify(rawContent);
+                return {
+                    type: 'progress',
+                    content,
+                    timestamp: new Date(),
+                };
+            }
+            return null;
+        }
+        catch {
+            // Non-JSON line, treat as progress text
+            return {
+                type: 'progress',
+                content: line,
+                timestamp: new Date(),
+            };
+        }
+    }
+}