@shepai/cli 1.8.2 → 1.9.0

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';

package/dist/src/infrastructure/services/agents/streaming/streaming-executor-proxy.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Streaming Executor Proxy
+ *
+ * Wraps an IAgentExecutor, transparently intercepting execute() calls
+ * and routing them through executeStream(). Stream events are forwarded
+ * to a shared EventChannel while the accumulated result is returned
+ * to the caller (the graph node) as if execute() had been called normally.
+ *
+ * This allows graph nodes to remain unaware of streaming — they call
+ * execute() and get an AgentExecutionResult back, while consumers of
+ * the EventChannel receive real-time events.
+ */
+import type { AgentType, AgentFeature } from '../../../../domain/generated/output.js';
+import type { IAgentExecutor, AgentExecutionOptions, AgentExecutionResult, AgentExecutionStreamEvent } from '../../../../application/ports/output/agent-executor.interface.js';
+import type { EventChannel } from './event-channel.js';
+export declare class StreamingExecutorProxy implements IAgentExecutor {
+    private readonly inner;
+    private readonly channel;
+    get agentType(): AgentType;
+    constructor(inner: IAgentExecutor, channel: EventChannel<AgentExecutionStreamEvent>);
+    execute(prompt: string, options?: AgentExecutionOptions): Promise<AgentExecutionResult>;
+    executeStream(prompt: string, options?: AgentExecutionOptions): AsyncIterable<AgentExecutionStreamEvent>;
+    supportsFeature(feature: AgentFeature): boolean;
+}
+//# sourceMappingURL=streaming-executor-proxy.d.ts.map

package/dist/src/infrastructure/services/agents/streaming/streaming-executor-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-executor-proxy.d.ts","sourceRoot":"","sources":["../../../../../../src/infrastructure/services/agents/streaming/streaming-executor-proxy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5E,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EAC1B,MAAM,wDAAwD,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,qBAAa,sBAAuB,YAAW,cAAc;IAMzD,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAN1B,IAAI,SAAS,IAAI,SAAS,CAEzB;gBAGkB,KAAK,EAAE,cAAc,EACrB,OAAO,EAAE,YAAY,CAAC,yBAAyB,CAAC;IAG7D,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAyBtF,aAAa,CAClB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,qBAAqB,GAC9B,aAAa,CAAC,yBAAyB,CAAC;IAI3C,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;CAGhD"}

package/dist/src/infrastructure/services/agents/streaming/streaming-executor-proxy.js

@@ -0,0 +1,51 @@
+/**
+ * Streaming Executor Proxy
+ *
+ * Wraps an IAgentExecutor, transparently intercepting execute() calls
+ * and routing them through executeStream(). Stream events are forwarded
+ * to a shared EventChannel while the accumulated result is returned
+ * to the caller (the graph node) as if execute() had been called normally.
+ *
+ * This allows graph nodes to remain unaware of streaming — they call
+ * execute() and get an AgentExecutionResult back, while consumers of
+ * the EventChannel receive real-time events.
+ */
+export class StreamingExecutorProxy {
+    inner;
+    channel;
+    get agentType() {
+        return this.inner.agentType;
+    }
+    constructor(inner, channel) {
+        this.inner = inner;
+        this.channel = channel;
+    }
+    async execute(prompt, options) {
+        let result = '';
+        try {
+            for await (const event of this.inner.executeStream(prompt, options)) {
+                this.channel.push(event);
+                if (event.type === 'result') {
+                    result = event.content;
+                }
+            }
+        }
+        catch (error) {
+            this.channel.push({
+                type: 'error',
+                content: error instanceof Error ? error.message : String(error),
+                timestamp: new Date(),
+            });
+            this.channel.close();
+            throw error;
+        }
+        this.channel.close();
+        return { result };
+    }
+    async *executeStream(prompt, options) {
+        yield* this.inner.executeStream(prompt, options);
+    }
+    supportsFeature(feature) {
+        return this.inner.supportsFeature(feature);
+    }
+}

package/dist/src/presentation/cli/commands/run.command.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Run Command
+ *
+ * Runs an AI agent workflow against a repository.
+ *
+ * Usage: shep run <agent-name> [options]
+ *
+ * @example
+ * $ shep run analyze-repository
+ * $ shep run analyze-repository --prompt "Focus on security"
+ * $ shep run analyze-repository --repo /path/to/repo
+ * $ shep run analyze-repository --stream
+ */
+import { Command } from 'commander';
+/**
+ * Create the run command
+ */
+export declare function createRunCommand(): Command;
+//# sourceMappingURL=run.command.d.ts.map

package/dist/src/presentation/cli/commands/run.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/run.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmCpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CA+B1C"}

package/dist/src/presentation/cli/commands/run.command.js

@@ -0,0 +1,130 @@
+/**
+ * Run Command
+ *
+ * Runs an AI agent workflow against a repository.
+ *
+ * Usage: shep run <agent-name> [options]
+ *
+ * @example
+ * $ shep run analyze-repository
+ * $ shep run analyze-repository --prompt "Focus on security"
+ * $ shep run analyze-repository --repo /path/to/repo
+ * $ shep run analyze-repository --stream
+ */
+import { Command } from 'commander';
+import { container } from '../../../infrastructure/di/container.js';
+import { RunAgentUseCase } from '../../../application/use-cases/agents/run-agent.use-case.js';
+import { colors, symbols, fmt, messages } from '../ui/index.js';
+/**
+ * Creates a terminal spinner that shows progress while awaiting an async operation.
+ * Returns start/stop controls. The spinner writes to stderr to avoid polluting stdout.
+ */
+function createSpinner(text) {
+    const frames = symbols.spinner;
+    let frameIndex = 0;
+    let intervalId;
+    return {
+        start() {
+            process.stderr.write(`${colors.info(frames[0])} ${text}`);
+            intervalId = setInterval(() => {
+                frameIndex = (frameIndex + 1) % frames.length;
+                process.stderr.write(`\r${colors.info(frames[frameIndex])} ${text}`);
+            }, 80);
+        },
+        stop() {
+            if (intervalId)
+                clearInterval(intervalId);
+            process.stderr.write(`\r${' '.repeat(text.length + 4)}\r`);
+        },
+    };
+}
+/**
+ * Create the run command
+ */
+export function createRunCommand() {
+    return new Command('run')
+        .description('Run an AI agent workflow')
+        .argument('<agent-name>', 'Name of the agent to run (e.g., analyze-repository)')
+        .option('-p, --prompt <prompt>', 'Prompt to send to the agent', 'Analyze this repository')
+        .option('-r, --repo <path>', 'Repository path (defaults to current directory)')
+        .option('-s, --stream', 'Stream output in real-time')
+        .action(async (agentName, options) => {
+        try {
+            const useCase = container.resolve(RunAgentUseCase);
+            const repoPath = options.repo ?? process.cwd();
+            messages.newline();
+            console.log(`${fmt.heading('Running agent:')} ${colors.accent(agentName)}`);
+            console.log(colors.muted(`  Repository: ${repoPath}`));
+            console.log(colors.muted(`  Prompt: ${options.prompt}`));
+            messages.newline();
+            if (options.stream) {
+                await runStreaming(useCase, agentName, options.prompt, repoPath);
+            }
+            else {
+                await runBlocking(useCase, agentName, options.prompt, repoPath);
+            }
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error('Failed to run agent', err);
+            process.exitCode = 1;
+        }
+    });
+}
+/** Stream agent events to stdout in real-time. */
+async function runStreaming(useCase, agentName, prompt, repoPath) {
+    let hasResult = false;
+    for await (const event of useCase.executeStream({
+        agentName,
+        prompt,
+        options: { repositoryPath: repoPath },
+    })) {
+        if (event.type === 'progress') {
+            process.stdout.write(event.content);
+        }
+        else if (event.type === 'result') {
+            hasResult = true;
+            messages.newline();
+            messages.success(`Agent ${agentName} completed`);
+            messages.newline();
+            console.log(fmt.heading('Result:'));
+            messages.newline();
+            console.log(event.content);
+        }
+        else if (event.type === 'error') {
+            messages.error(event.content);
+            process.exitCode = 1;
+        }
+    }
+    if (!hasResult) {
+        messages.success(`Agent ${agentName} completed`);
+    }
+}
+/** Run agent with spinner (blocking mode). */
+async function runBlocking(useCase, agentName, prompt, repoPath) {
+    const spinner = createSpinner(`Agent ${agentName} is working...`);
+    spinner.start();
+    let run;
+    try {
+        run = await useCase.execute({
+            agentName,
+            prompt,
+            options: { repositoryPath: repoPath },
+        });
+    }
+    finally {
+        spinner.stop();
+    }
+    if (run.status === 'completed') {
+        messages.success(`Agent ${agentName} completed`);
+        messages.newline();
+        console.log(fmt.heading('Result:'));
+        messages.newline();
+        console.log(run.result ?? 'No output');
+    }
+    else if (run.status === 'failed') {
+        messages.error('Agent execution failed', new Error(run.error ?? 'Unknown error'));
+        process.exitCode = 1;
+    }
+}

package/dist/src/presentation/cli/index.js

@@ -23,6 +23,7 @@ import { Command } from 'commander';
 import { createVersionCommand } from './commands/version.command.js';
 import { createSettingsCommand } from './commands/settings/index.js';
 import { createUiCommand } from './commands/ui.command.js';
+import { createRunCommand } from './commands/run.command.js';
 import { messages } from './ui/index.js';
 // DI container and settings
 import { initializeContainer, container } from '../../infrastructure/di/container.js';
@@ -68,6 +69,7 @@ async function bootstrap() {
         program.addCommand(createVersionCommand());
         program.addCommand(createSettingsCommand());
         program.addCommand(createUiCommand());
+        program.addCommand(createRunCommand());
         // Parse arguments (parseAsync needed for async command actions like init)
         await program.parseAsync();
     }

package/dist/src/presentation/cli/ui/messages.d.ts

@@ -21,7 +21,7 @@ export declare const messages: {
     /**
      * Print error message
      * @param text - Error message
-     * @param error - Optional error object (shown in debug mode)
+     * @param error - Optional error object with details
      * @example messages.error('Connection failed')
      * // Output: ✗ Connection failed
      */

package/dist/src/presentation/cli/ui/messages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/ui/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH;;GAEG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;OAIG;6BACa,MAAM,KAAG,IAAI;IAI7B;;;;;;OAMG;2BACW,MAAM,UAAU,KAAK,KAAG,IAAI;IAO1C;;;;OAIG;6BACa,MAAM,KAAG,IAAI;IAI7B;;;;OAIG;0BACU,MAAM,KAAG,IAAI;IAI1B;;;;OAIG;2BACW,MAAM,KAAG,IAAI;IAM3B;;OAEG;4BACU,IAAI;IAIjB;;OAEG;yBACS,MAAM,KAAG,IAAI;CAGjB,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/ui/messages.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH;;GAEG;AACH,eAAO,MAAM,QAAQ;IACnB;;;;OAIG;6BACa,MAAM,KAAG,IAAI;IAI7B;;;;;;OAMG;2BACW,MAAM,UAAU,KAAK,KAAG,IAAI;IAY1C;;;;OAIG;6BACa,MAAM,KAAG,IAAI;IAI7B;;;;OAIG;0BACU,MAAM,KAAG,IAAI;IAI1B;;;;OAIG;2BACW,MAAM,KAAG,IAAI;IAM3B;;OAEG;4BACU,IAAI;IAIjB;;OAEG;yBACS,MAAM,KAAG,IAAI;CAGjB,CAAC;AAEX,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC"}