@shepai/cli 1.8.1 → 1.9.0

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(),
+            };
+        }
+    }
+}

package/dist/src/infrastructure/services/agents/langgraph/analyze-repository-graph.d.ts

@@ -0,0 +1,119 @@
+import { type BaseCheckpointSaver } from '@langchain/langgraph';
+import type { IAgentExecutor } from '../../../../application/ports/output/agent-executor.interface.js';
+/**
+ * State annotation for the analyze-repository graph.
+ *
+ * Uses LangGraph's Annotation API to define state channels with
+ * last-value semantics (default behavior — each update replaces the value).
+ */
+export declare const AnalyzeRepositoryState: import("@langchain/langgraph").AnnotationRoot<{
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    analysisMarkdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    sessionId: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}>;
+export type AnalyzeRepositoryStateType = typeof AnalyzeRepositoryState.State;
+/**
+ * Factory function that creates and compiles the analyze-repository LangGraph.
+ *
+ * The graph has a single node (`analyze`) that calls the provided IAgentExecutor
+ * to generate a repository analysis document. An optional checkpointer enables
+ * persistence of graph state across invocations.
+ *
+ * @param executor - The agent executor to delegate prompt execution to
+ * @param checkpointer - Optional checkpoint saver for state persistence
+ * @returns A compiled LangGraph ready to be invoked
+ */
+export declare function createAnalyzeRepositoryGraph(executor: IAgentExecutor, checkpointer?: BaseCheckpointSaver): import("@langchain/langgraph").CompiledStateGraph<{
+    repositoryPath: string;
+    analysisMarkdown: string;
+    sessionId: string | undefined;
+    error: string | undefined;
+}, {
+    repositoryPath?: string | undefined;
+    analysisMarkdown?: string | undefined;
+    sessionId?: string | undefined;
+    error?: string | undefined;
+}, "__start__" | "analyze", {
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    analysisMarkdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    sessionId: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, {
+    repositoryPath: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    analysisMarkdown: {
+        (): import("@langchain/langgraph").LastValue<string>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    sessionId: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+    error: {
+        (): import("@langchain/langgraph").LastValue<string | undefined>;
+        (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+        Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+    };
+}, import("@langchain/langgraph").StateDefinition, {
+    analyze: Partial<import("@langchain/langgraph").StateType<{
+        repositoryPath: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        analysisMarkdown: {
+            (): import("@langchain/langgraph").LastValue<string>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string, string>): import("@langchain/langgraph").BinaryOperatorAggregate<string, string>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        sessionId: {
+            (): import("@langchain/langgraph").LastValue<string | undefined>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+        error: {
+            (): import("@langchain/langgraph").LastValue<string | undefined>;
+            (annotation: import("@langchain/langgraph").SingleReducer<string | undefined, string | undefined>): import("@langchain/langgraph").BinaryOperatorAggregate<string | undefined, string | undefined>;
+            Root: <S extends import("@langchain/langgraph").StateDefinition>(sd: S) => import("@langchain/langgraph").AnnotationRoot<S>;
+        };
+    }>>;
+}, unknown, unknown>;
+//# sourceMappingURL=analyze-repository-graph.d.ts.map

package/dist/src/infrastructure/services/agents/langgraph/analyze-repository-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-repository-graph.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/langgraph/analyze-repository-graph.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACpG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wDAAwD,CAAC;AAI7F;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;EAKjC,CAAC;AAEH,MAAM,MAAM,0BAA0B,GAAG,OAAO,sBAAsB,CAAC,KAAK,CAAC;AA+B7E;;;;;;;;;;GAUG;AACH,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,cAAc,EACxB,YAAY,CAAC,EAAE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQnC"}

package/dist/src/infrastructure/services/agents/langgraph/analyze-repository-graph.js

@@ -0,0 +1,56 @@
+import { Annotation, StateGraph, START, END } from '@langchain/langgraph';
+import { AgentFeature } from '../../../../domain/generated/output.js';
+import { buildAnalyzePrompt } from './prompts/analyze-repository.prompt.js';
+/**
+ * State annotation for the analyze-repository graph.
+ *
+ * Uses LangGraph's Annotation API to define state channels with
+ * last-value semantics (default behavior — each update replaces the value).
+ */
+export const AnalyzeRepositoryState = Annotation.Root({
+    repositoryPath: (Annotation),
+    analysisMarkdown: (Annotation),
+    sessionId: (Annotation),
+    error: (Annotation),
+});
+/**
+ * Creates the analyze node function that calls the agent-agnostic executor.
+ *
+ * The node receives the current state, builds a prompt from the repository path,
+ * and delegates execution to the injected IAgentExecutor. Session resume is
+ * attempted if the executor supports it and a sessionId exists in state.
+ */
+function createAnalyzeNode(executor) {
+    return async (state) => {
+        const prompt = buildAnalyzePrompt(state.repositoryPath);
+        const options = {
+            cwd: state.repositoryPath,
+        };
+        if (state.sessionId && executor.supportsFeature(AgentFeature.sessionResume)) {
+            options.resumeSession = state.sessionId;
+        }
+        const result = await executor.execute(prompt, options);
+        return {
+            analysisMarkdown: result.result,
+            sessionId: result.sessionId ?? state.sessionId,
+        };
+    };
+}
+/**
+ * Factory function that creates and compiles the analyze-repository LangGraph.
+ *
+ * The graph has a single node (`analyze`) that calls the provided IAgentExecutor
+ * to generate a repository analysis document. An optional checkpointer enables
+ * persistence of graph state across invocations.
+ *
+ * @param executor - The agent executor to delegate prompt execution to
+ * @param checkpointer - Optional checkpoint saver for state persistence
+ * @returns A compiled LangGraph ready to be invoked
+ */
+export function createAnalyzeRepositoryGraph(executor, checkpointer) {
+    const graph = new StateGraph(AnalyzeRepositoryState)
+        .addNode('analyze', createAnalyzeNode(executor))
+        .addEdge(START, 'analyze')
+        .addEdge('analyze', END);
+    return graph.compile({ checkpointer });
+}

package/dist/src/infrastructure/services/agents/langgraph/checkpointer.d.ts

@@ -0,0 +1,9 @@
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
+/**
+ * Creates a SQLite-backed checkpoint saver for LangGraph state persistence.
+ *
+ * @param dbPath - Path to the SQLite database file (e.g., ':memory:' or a file path)
+ * @returns A SqliteSaver instance ready for use as a LangGraph checkpointer
+ */
+export declare function createCheckpointer(dbPath: string): SqliteSaver;
+//# sourceMappingURL=checkpointer.d.ts.map

package/dist/src/infrastructure/services/agents/langgraph/checkpointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpointer.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/langgraph/checkpointer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,wCAAwC,CAAC;AAErE;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAE9D"}

package/dist/src/infrastructure/services/agents/langgraph/checkpointer.js

@@ -0,0 +1,10 @@
+import { SqliteSaver } from '@langchain/langgraph-checkpoint-sqlite';
+/**
+ * Creates a SQLite-backed checkpoint saver for LangGraph state persistence.
+ *
+ * @param dbPath - Path to the SQLite database file (e.g., ':memory:' or a file path)
+ * @returns A SqliteSaver instance ready for use as a LangGraph checkpointer
+ */
+export function createCheckpointer(dbPath) {
+    return SqliteSaver.fromConnString(dbPath);
+}

package/dist/src/infrastructure/services/agents/langgraph/prompts/analyze-repository.prompt.d.ts

@@ -0,0 +1,3 @@
+export declare const ANALYZE_REPOSITORY_PROMPT = "You are analyzing a software repository.\nExamine the codebase structure, dependencies, architecture patterns, and conventions.\nGenerate a comprehensive analysis document in Markdown format.\n\nRepository path: {{repositoryPath}}\n\nYour analysis should include:\n1. Project overview and purpose\n2. Technology stack and dependencies\n3. Architecture patterns and code organization\n4. Key conventions and patterns\n5. Build system and development workflow\n6. Testing strategy\n\nOutput a complete shep-analysis.md document.";
+export declare function buildAnalyzePrompt(repositoryPath: string): string;
+//# sourceMappingURL=analyze-repository.prompt.d.ts.map

package/dist/src/infrastructure/services/agents/langgraph/prompts/analyze-repository.prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-repository.prompt.d.ts","sourceRoot":"","sources":["../../../../../../../src/infrastructure/services/agents/langgraph/prompts/analyze-repository.prompt.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,mhBAcO,CAAC;AAE9C,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEjE"}

package/dist/src/infrastructure/services/agents/langgraph/prompts/analyze-repository.prompt.js

@@ -0,0 +1,18 @@
+export const ANALYZE_REPOSITORY_PROMPT = `You are analyzing a software repository.
+Examine the codebase structure, dependencies, architecture patterns, and conventions.
+Generate a comprehensive analysis document in Markdown format.
+
+Repository path: {{repositoryPath}}
+
+Your analysis should include:
+1. Project overview and purpose
+2. Technology stack and dependencies
+3. Architecture patterns and code organization
+4. Key conventions and patterns
+5. Build system and development workflow
+6. Testing strategy
+
+Output a complete shep-analysis.md document.`;
+export function buildAnalyzePrompt(repositoryPath) {
+    return ANALYZE_REPOSITORY_PROMPT.replace('{{repositoryPath}}', repositoryPath);
+}

package/dist/src/infrastructure/services/agents/streaming/event-channel.d.ts

@@ -0,0 +1,39 @@
+/**
+ * EventChannel - Generic Async Push/Pull Queue
+ *
+ * Bridges event producers (push) and async iteration consumers (for-await-of).
+ * Used by the streaming infrastructure to forward agent execution events
+ * from the StreamingExecutorProxy to the AgentRunnerService caller.
+ *
+ * @example
+ * ```typescript
+ * const channel = new EventChannel<string>();
+ *
+ * // Producer side
+ * channel.push('progress update');
+ * channel.push('done');
+ * channel.close();
+ *
+ * // Consumer side
+ * for await (const event of channel) {
+ *   console.log(event);
+ * }
+ * ```
+ */
+export declare class EventChannel<T> implements AsyncIterable<T> {
+    private queue;
+    private closed;
+    private resolve;
+    /**
+     * Push an event into the channel.
+     * Ignored if the channel is already closed.
+     */
+    push(event: T): void;
+    /**
+     * Close the channel, signaling no more events will be pushed.
+     * Safe to call multiple times.
+     */
+    close(): void;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+//# sourceMappingURL=event-channel.d.ts.map

package/dist/src/infrastructure/services/agents/streaming/event-channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-channel.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/streaming/event-channel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,YAAY,CAAC,CAAC,CAAE,YAAW,aAAa,CAAC,CAAC,CAAC;IACtD,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAA6B;IAE5C;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI;IASpB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAQN,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CAYlD"}

package/dist/src/infrastructure/services/agents/streaming/event-channel.js

@@ -0,0 +1,64 @@
+/**
+ * EventChannel - Generic Async Push/Pull Queue
+ *
+ * Bridges event producers (push) and async iteration consumers (for-await-of).
+ * Used by the streaming infrastructure to forward agent execution events
+ * from the StreamingExecutorProxy to the AgentRunnerService caller.
+ *
+ * @example
+ * ```typescript
+ * const channel = new EventChannel<string>();
+ *
+ * // Producer side
+ * channel.push('progress update');
+ * channel.push('done');
+ * channel.close();
+ *
+ * // Consumer side
+ * for await (const event of channel) {
+ *   console.log(event);
+ * }
+ * ```
+ */
+export class EventChannel {
+    queue = [];
+    closed = false;
+    resolve = null;
+    /**
+     * Push an event into the channel.
+     * Ignored if the channel is already closed.
+     */
+    push(event) {
+        if (this.closed)
+            return;
+        this.queue.push(event);
+        if (this.resolve) {
+            this.resolve();
+            this.resolve = null;
+        }
+    }
+    /**
+     * Close the channel, signaling no more events will be pushed.
+     * Safe to call multiple times.
+     */
+    close() {
+        this.closed = true;
+        if (this.resolve) {
+            this.resolve();
+            this.resolve = null;
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                yield this.queue.shift();
+                continue;
+            }
+            if (this.closed)
+                return;
+            await new Promise((r) => {
+                this.resolve = r;
+            });
+        }
+    }
+}

package/dist/src/infrastructure/services/agents/streaming/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Agent Streaming Module
+ *
+ * Provides the streaming infrastructure for transparent real-time
+ * event delivery from agent executors through the graph pipeline.
+ */
+export { EventChannel } from './event-channel.js';
+export { StreamingExecutorProxy } from './streaming-executor-proxy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/infrastructure/services/agents/streaming/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/streaming/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/src/infrastructure/services/agents/streaming/index.js

@@ -0,0 +1,8 @@
+/**
+ * Agent Streaming Module
+ *
+ * Provides the streaming infrastructure for transparent real-time
+ * event delivery from agent executors through the graph pipeline.
+ */
+export { EventChannel } from './event-channel.js';
+export { StreamingExecutorProxy } from './streaming-executor-proxy.js';