@sudocode-ai/local-server 0.1.7 → 0.1.8

package/dist/workers/worker-ipc.d.ts

@@ -0,0 +1,84 @@
+/**
+ * IPC Message Type Definitions for Worker Pool
+ *
+ * Defines the message protocol for bidirectional communication between
+ * main server process and worker processes.
+ *
+ * @module workers/worker-ipc
+ */
+import type { ExecutionStatus } from "@sudocode-ai/types";
+/**
+ * Output event from worker (logs, status updates)
+ */
+export interface OutputEvent {
+    type: "stdout" | "stderr" | "log";
+    data: string;
+    timestamp: string;
+}
+/**
+ * Execution result upon completion
+ */
+export interface ExecutionResult {
+    status: ExecutionStatus;
+    exitCode?: number;
+    error?: string;
+    completedAt: string;
+}
+/**
+ * Messages sent from Worker → Main Process
+ */
+export type WorkerToMainMessage = {
+    type: "ready";
+    executionId: string;
+    workerId: string;
+} | {
+    type: "log";
+    executionId: string;
+    data: OutputEvent;
+} | {
+    type: "agui-event";
+    executionId: string;
+    event: any;
+} | {
+    type: "status";
+    executionId: string;
+    status: ExecutionStatus;
+} | {
+    type: "complete";
+    executionId: string;
+    result: ExecutionResult;
+} | {
+    type: "error";
+    executionId: string;
+    error: string;
+    fatal?: boolean;
+};
+/**
+ * Messages sent from Main Process → Worker
+ */
+export type MainToWorkerMessage = {
+    type: "cancel";
+    executionId: string;
+} | {
+    type: "ping";
+};
+/**
+ * Worker environment configuration
+ */
+export interface WorkerEnv {
+    EXECUTION_ID: string;
+    PROJECT_ID: string;
+    REPO_PATH: string;
+    DB_PATH: string;
+    MAX_MEMORY_MB?: string;
+    WORKER_ID: string;
+}
+/**
+ * Type guard for WorkerToMainMessage
+ */
+export declare function isWorkerMessage(msg: any): msg is WorkerToMainMessage;
+/**
+ * Type guard for MainToWorkerMessage
+ */
+export declare function isMainMessage(msg: any): msg is MainToWorkerMessage;
+//# sourceMappingURL=worker-ipc.d.ts.map

package/dist/workers/worker-ipc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-ipc.d.ts","sourceRoot":"","sources":["../../src/workers/worker-ipc.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI1D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,KAAK,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,eAAe,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB,GACD;IACE,IAAI,EAAE,KAAK,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,WAAW,CAAC;CACnB,GAED;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,GAAG,CAAC;CACZ,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,eAAe,CAAC;CACzB,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,eAAe,CAAC;CACzB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAC3B;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,mBAAmB,CAUpE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,mBAAmB,CAQlE"}

package/dist/workers/worker-ipc.js

@@ -0,0 +1,29 @@
+/**
+ * IPC Message Type Definitions for Worker Pool
+ *
+ * Defines the message protocol for bidirectional communication between
+ * main server process and worker processes.
+ *
+ * @module workers/worker-ipc
+ */
+/**
+ * Type guard for WorkerToMainMessage
+ */
+export function isWorkerMessage(msg) {
+    return (msg &&
+        typeof msg === "object" &&
+        "type" in msg &&
+        typeof msg.type === "string" &&
+        ["ready", "log", "agui-event", "status", "complete", "error"].includes(msg.type));
+}
+/**
+ * Type guard for MainToWorkerMessage
+ */
+export function isMainMessage(msg) {
+    return (msg &&
+        typeof msg === "object" &&
+        "type" in msg &&
+        typeof msg.type === "string" &&
+        ["cancel", "ping"].includes(msg.type));
+}
+//# sourceMappingURL=worker-ipc.js.map

package/dist/workers/worker-ipc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-ipc.js","sourceRoot":"","sources":["../../src/workers/worker-ipc.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAsFH;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,GAAQ;IACtC,OAAO,CACL,GAAG;QACH,OAAO,GAAG,KAAK,QAAQ;QACvB,MAAM,IAAI,GAAG;QACb,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;QAC5B,CAAC,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,QAAQ,CACpE,GAAG,CAAC,IAAI,CACT,CACF,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,GAAQ;IACpC,OAAO,CACL,GAAG;QACH,OAAO,GAAG,KAAK,QAAQ;QACvB,MAAM,IAAI,GAAG;QACb,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;QAC5B,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CACtC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sudocode-ai/local-server",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Local backend server for sudocode - provides REST API and WebSocket endpoints",
   "main": "dist/index.js",
   "type": "module",
@@ -41,17 +41,17 @@
   },
   "dependencies": {
     "@ag-ui/core": "^0.0.39",
-    "@sudocode-ai/cli": "^0.1.7",
-    "@sudocode-ai/types": "^0.1.7",
+    "@sudocode-ai/cli": "^0.1.8",
+    "@sudocode-ai/types": "^0.1.8",
     "@types/ws": "^8.18.1",
-    "agent-execution-engine": "^0.0.4",
+    "agent-execution-engine": "^0.0.12",
     "async-mutex": "^0.5.0",
     "better-sqlite3": "^11.10.0",
     "cors": "^2.8.5",
-    "dotenv": "^16.4.5",
     "express": "^4.18.2",
     "glob": "^10.4.5",
     "node-fetch": "^2.7.0",
+    "which": "^6.0.0",
     "ws": "^8.18.3",
     "zod": "^3.22.4"
   },
@@ -61,6 +61,7 @@
     "@types/express": "^4.17.21",
     "@types/node": "^20.11.19",
     "@types/supertest": "^6.0.3",
+    "@types/which": "^3.0.4",
     "esbuild": "^0.27.0",
     "supertest": "^7.1.4",
     "tsx": "^4.7.1",

package/dist/execution/output/ag-ui-integration.d.ts

@@ -1,96 +0,0 @@
-/**
- * AG-UI Integration Helpers
- *
- * Factory functions and helpers to wire SPEC-007 output processing with SPEC-009 AG-UI streaming.
- * Simplifies the integration between ClaudeCodeOutputProcessor and AgUiEventAdapter.
- *
- * @module execution/output/ag-ui-integration
- */
-import { AgUiEventAdapter } from './ag-ui-adapter.js';
-import type { IOutputProcessor } from './types.js';
-/**
- * AG-UI System containing processor and adapter
- *
- * The processor handles parsing Claude Code output and emitting events.
- * The adapter transforms those events into AG-UI protocol events.
- */
-export interface AgUiSystem {
-    /** Output processor for parsing Claude Code stream-json */
-    processor: IOutputProcessor;
-    /** AG-UI event adapter for broadcasting events */
-    adapter: AgUiEventAdapter;
-}
-/**
- * Create a complete AG-UI system with processor and adapter pre-wired
- *
- * This is the recommended way to create an AG-UI streaming system.
- * It automatically:
- * - Creates a ClaudeCodeOutputProcessor
- * - Creates an AgUiEventAdapter with the provided runId
- * - Wires the processor to emit events through the adapter
- *
- * @param runId - Unique identifier for this execution run
- * @param threadId - Optional thread ID (defaults to runId)
- * @returns Complete AG-UI system ready to process output
- *
- * @example
- * ```typescript
- * const { processor, adapter } = createAgUiSystem('run-123');
- *
- * // Wire adapter to transport for SSE streaming
- * transportManager.connectAdapter(adapter, 'run-123');
- *
- * // Process Claude Code output
- * await processor.processLine('{"type":"assistant",...}');
- *
- * // Events automatically flow: processor -> adapter -> transport -> SSE clients
- * ```
- */
-export declare function createAgUiSystem(runId: string, threadId?: string): AgUiSystem;
-/**
- * Manually wire an output processor to an AG-UI adapter
- *
- * Use this when you need more control over processor/adapter creation.
- * This function handles all the event handler registration.
- *
- * @param processor - Output processor to wire
- * @param adapter - AG-UI adapter to receive events
- *
- * @example
- * ```typescript
- * const processor = new ClaudeCodeOutputProcessor();
- * const adapter = new AgUiEventAdapter('run-123');
- *
- * // Manually wire them together
- * wireManually(processor, adapter);
- *
- * // Now processor events will flow to adapter
- * ```
- */
-export declare function wireManually(processor: IOutputProcessor, adapter: AgUiEventAdapter): void;
-/**
- * Create an AG-UI system with custom processor implementation
- *
- * Use this when you have a custom output processor that implements IOutputProcessor.
- * The processor will be wired to a new AgUiEventAdapter.
- *
- * @param processor - Custom output processor implementation
- * @param runId - Unique identifier for this execution run
- * @param threadId - Optional thread ID (defaults to runId)
- * @returns AG-UI system with your custom processor
- *
- * @example
- * ```typescript
- * class CustomProcessor implements IOutputProcessor {
- *   // ... your implementation
- * }
- *
- * const processor = new CustomProcessor();
- * const { processor, adapter } = createAgUiSystemWithProcessor(
- *   processor,
- *   'run-123'
- * );
- * ```
- */
-export declare function createAgUiSystemWithProcessor(processor: IOutputProcessor, runId: string, threadId?: string): AgUiSystem;
-//# sourceMappingURL=ag-ui-integration.d.ts.map

package/dist/execution/output/ag-ui-integration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ag-ui-integration.d.ts","sourceRoot":"","sources":["../../../src/execution/output/ag-ui-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,2DAA2D;IAC3D,SAAS,EAAE,gBAAgB,CAAC;IAC5B,kDAAkD;IAClD,OAAO,EAAE,gBAAgB,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,GAChB,UAAU,CAQZ;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,GACxB,IAAI,CAEN;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,6BAA6B,CAC3C,SAAS,EAAE,gBAAgB,EAC3B,KAAK,EAAE,MAAM,EACb,QAAQ,CAAC,EAAE,MAAM,GAChB,UAAU,CAKZ"}

package/dist/execution/output/ag-ui-integration.js

@@ -1,96 +0,0 @@
-/**
- * AG-UI Integration Helpers
- *
- * Factory functions and helpers to wire SPEC-007 output processing with SPEC-009 AG-UI streaming.
- * Simplifies the integration between ClaudeCodeOutputProcessor and AgUiEventAdapter.
- *
- * @module execution/output/ag-ui-integration
- */
-import { ClaudeCodeOutputProcessor } from './claude-code-output-processor.js';
-import { AgUiEventAdapter } from './ag-ui-adapter.js';
-/**
- * Create a complete AG-UI system with processor and adapter pre-wired
- *
- * This is the recommended way to create an AG-UI streaming system.
- * It automatically:
- * - Creates a ClaudeCodeOutputProcessor
- * - Creates an AgUiEventAdapter with the provided runId
- * - Wires the processor to emit events through the adapter
- *
- * @param runId - Unique identifier for this execution run
- * @param threadId - Optional thread ID (defaults to runId)
- * @returns Complete AG-UI system ready to process output
- *
- * @example
- * ```typescript
- * const { processor, adapter } = createAgUiSystem('run-123');
- *
- * // Wire adapter to transport for SSE streaming
- * transportManager.connectAdapter(adapter, 'run-123');
- *
- * // Process Claude Code output
- * await processor.processLine('{"type":"assistant",...}');
- *
- * // Events automatically flow: processor -> adapter -> transport -> SSE clients
- * ```
- */
-export function createAgUiSystem(runId, threadId) {
-    const processor = new ClaudeCodeOutputProcessor();
-    const adapter = new AgUiEventAdapter(runId, threadId);
-    // Wire processor events to adapter
-    adapter.connectToProcessor(processor);
-    return { processor, adapter };
-}
-/**
- * Manually wire an output processor to an AG-UI adapter
- *
- * Use this when you need more control over processor/adapter creation.
- * This function handles all the event handler registration.
- *
- * @param processor - Output processor to wire
- * @param adapter - AG-UI adapter to receive events
- *
- * @example
- * ```typescript
- * const processor = new ClaudeCodeOutputProcessor();
- * const adapter = new AgUiEventAdapter('run-123');
- *
- * // Manually wire them together
- * wireManually(processor, adapter);
- *
- * // Now processor events will flow to adapter
- * ```
- */
-export function wireManually(processor, adapter) {
-    adapter.connectToProcessor(processor);
-}
-/**
- * Create an AG-UI system with custom processor implementation
- *
- * Use this when you have a custom output processor that implements IOutputProcessor.
- * The processor will be wired to a new AgUiEventAdapter.
- *
- * @param processor - Custom output processor implementation
- * @param runId - Unique identifier for this execution run
- * @param threadId - Optional thread ID (defaults to runId)
- * @returns AG-UI system with your custom processor
- *
- * @example
- * ```typescript
- * class CustomProcessor implements IOutputProcessor {
- *   // ... your implementation
- * }
- *
- * const processor = new CustomProcessor();
- * const { processor, adapter } = createAgUiSystemWithProcessor(
- *   processor,
- *   'run-123'
- * );
- * ```
- */
-export function createAgUiSystemWithProcessor(processor, runId, threadId) {
-    const adapter = new AgUiEventAdapter(runId, threadId);
-    adapter.connectToProcessor(processor);
-    return { processor, adapter };
-}
-//# sourceMappingURL=ag-ui-integration.js.map

package/dist/execution/output/ag-ui-integration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ag-ui-integration.js","sourceRoot":"","sources":["../../../src/execution/output/ag-ui-integration.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAgBtD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAa,EACb,QAAiB;IAEjB,MAAM,SAAS,GAAG,IAAI,yBAAyB,EAAE,CAAC;IAClD,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAEtD,mCAAmC;IACnC,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAEtC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAC1B,SAA2B,EAC3B,OAAyB;IAEzB,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;AACxC,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,6BAA6B,CAC3C,SAA2B,EAC3B,KAAa,EACb,QAAiB;IAEjB,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACtD,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;IAEtC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC;AAChC,CAAC"}

package/dist/execution/output/claude-code-output-processor.d.ts

@@ -1,321 +0,0 @@
-/**
- * Claude Code Output Processor
- *
- * Implements the IOutputProcessor interface specifically for parsing
- * Claude Code's stream-json output format in real-time.
- *
- * This processor is tailored to Claude Code's CLI output and handles its
- * specific message structure, tool calling patterns, and metadata format.
- *
- * @module execution/output/claude-code-output-processor
- */
-import type { IOutputProcessor, ProcessingMetrics, ToolCall, FileChange, ToolCallHandler, FileChangeHandler, ProgressHandler, ErrorHandler } from "./types.js";
-/**
- * ClaudeCodeOutputProcessor - Parses Claude Code's stream-json output
- *
- * This processor is specifically designed for Claude Code's output format.
- * It handles line-by-line parsing of Claude's stream-json messages,
- * extracting tool calls, file changes, and usage metrics in real-time.
- *
- * **Claude Code Specific Features:**
- * - Parses Claude's message.content array structure
- * - Handles tool_use and tool_result content types
- * - Extracts usage metrics from result messages
- * - Processes Claude-specific error formats
- *
- * @example
- * ```typescript
- * const processor = new ClaudeCodeOutputProcessor();
- *
- * processor.onToolCall((toolCall) => {
- *   console.log(`Claude called tool: ${toolCall.name}`, toolCall.input);
- * });
- *
- * // Process Claude Code's stream-json output
- * await processor.processLine('{"type":"assistant","message":{"content":[...]}}');
- * const metrics = processor.getMetrics();
- * ```
- */
-export declare class ClaudeCodeOutputProcessor implements IOutputProcessor {
-    private _metrics;
-    private _toolCalls;
-    private _fileChanges;
-    private _toolCallHandlers;
-    private _fileChangeHandlers;
-    private _progressHandlers;
-    private _errorHandlers;
-    private _messageHandlers;
-    private _usageHandlers;
-    private _lineNumber;
-    constructor();
-    /**
-     * Process a single line of Claude Code's stream-json output
-     *
-     * Parses the JSON line and routes to appropriate handler based on message type.
-     * Handles malformed JSON gracefully and skips empty lines.
-     *
-     * @param line - Raw JSON line from Claude Code CLI output
-     */
-    processLine(line: string): Promise<void>;
-    /**
-     * Get current processing metrics
-     *
-     * @returns Current aggregate metrics
-     */
-    getMetrics(): ProcessingMetrics;
-    /**
-     * Get all tool calls recorded during processing
-     *
-     * @returns Array of all tool calls
-     */
-    getToolCalls(): ToolCall[];
-    /**
-     * Get all file changes detected during processing
-     *
-     * @returns Array of all file changes
-     */
-    getFileChanges(): FileChange[];
-    /**
-     * Register a callback for tool call events
-     *
-     * @param handler - Function to call when a tool is invoked
-     */
-    onToolCall(handler: ToolCallHandler): void;
-    /**
-     * Register a callback for file change events
-     *
-     * @param handler - Function to call when a file is modified
-     */
-    onFileChange(handler: FileChangeHandler): void;
-    /**
-     * Register a callback for progress update events
-     *
-     * @param handler - Function to call when metrics are updated
-     */
-    onProgress(handler: ProgressHandler): void;
-    /**
-     * Register a callback for error events
-     *
-     * @param handler - Function to call when an error occurs
-     */
-    onError(handler: ErrorHandler): void;
-    /**
-     * Register a callback for message events
-     *
-     * @param handler - Function to call when a text message is received
-     */
-    onMessage(handler: import("./types.js").MessageHandler): void;
-    /**
-     * Register a callback for usage metric updates
-     *
-     * @param handler - Function to call when usage metrics are updated
-     */
-    onUsage(handler: import("./types.js").UsageHandler): void;
-    /**
-     * Get tool calls filtered by tool name
-     *
-     * @param toolName - Name of the tool to filter by (e.g., 'Bash', 'Read', 'Write')
-     * @returns Array of tool calls matching the tool name
-     *
-     * @example
-     * ```typescript
-     * const bashCalls = processor.getToolCallsByName('Bash');
-     * console.log(`Executed ${bashCalls.length} bash commands`);
-     * ```
-     */
-    getToolCallsByName(toolName: string): ToolCall[];
-    /**
-     * Get file changes filtered by file path
-     *
-     * @param path - File path to filter by (exact match)
-     * @returns Array of file changes to the specified path
-     *
-     * @example
-     * ```typescript
-     * const changes = processor.getFileChangesByPath('src/index.ts');
-     * console.log(`File modified ${changes.length} times`);
-     * ```
-     */
-    getFileChangesByPath(path: string): FileChange[];
-    /**
-     * Get file changes filtered by operation type
-     *
-     * @param operation - Operation type to filter by ('read', 'write', 'edit')
-     * @returns Array of file changes with the specified operation
-     *
-     * @example
-     * ```typescript
-     * const writes = processor.getFileChangesByOperation('write');
-     * console.log(`Wrote to ${writes.length} files`);
-     * ```
-     */
-    getFileChangesByOperation(operation: "read" | "write" | "edit"): FileChange[];
-    /**
-     * Get only failed tool calls
-     *
-     * @returns Array of tool calls with status='error'
-     *
-     * @example
-     * ```typescript
-     * const failures = processor.getFailedToolCalls();
-     * failures.forEach(call => {
-     *   console.error(`${call.name} failed:`, call.error);
-     * });
-     * ```
-     */
-    getFailedToolCalls(): ToolCall[];
-    /**
-     * Get only successful tool calls
-     *
-     * @returns Array of tool calls with status='success'
-     *
-     * @example
-     * ```typescript
-     * const successes = processor.getSuccessfulToolCalls();
-     * console.log(`${successes.length} tool calls succeeded`);
-     * ```
-     */
-    getSuccessfulToolCalls(): ToolCall[];
-    /**
-     * Get total cost of execution in USD
-     *
-     * @returns Total cost based on token usage
-     *
-     * @example
-     * ```typescript
-     * const cost = processor.getTotalCost();
-     * console.log(`Execution cost: $${cost.toFixed(2)}`);
-     * ```
-     */
-    getTotalCost(): number;
-    /**
-     * Get execution summary with aggregate statistics
-     *
-     * Provides a high-level overview of the execution including:
-     * - Tool call counts by type
-     * - File operation counts by type
-     * - Success rates
-     * - Token usage and costs
-     * - Duration
-     *
-     * @returns Complete execution summary
-     *
-     * @example
-     * ```typescript
-     * const summary = processor.getExecutionSummary();
-     * console.log('Execution Summary:', {
-     *   duration: `${summary.duration}ms`,
-     *   cost: `$${summary.totalCost.toFixed(2)}`,
-     *   successRate: `${summary.successRate.toFixed(1)}%`,
-     *   toolCalls: summary.toolCallsByType,
-     * });
-     * ```
-     */
-    getExecutionSummary(): import("./types.js").ExecutionSummary;
-    /**
-     * Handle tool_use message from Claude Code
-     *
-     * Creates a new ToolCall entry with pending status and emits onToolCall event.
-     * Also detects potential file operations based on tool name.
-     *
-     * @param message - Parsed tool_use message
-     */
-    private _handleToolUse;
-    /**
-     * Handle tool_result message from Claude Code
-     *
-     * Updates the corresponding ToolCall with result/error status.
-     * Detects file changes from Read/Write/Edit tools and emits onFileChange event.
-     *
-     * @param message - Parsed tool_result message
-     */
-    private _handleToolResult;
-    /**
-     * Handle text message from Claude Code
-     *
-     * Emits message events to registered handlers.
-     *
-     * @param message - Parsed text message
-     */
-    private _handleText;
-    /**
-     * Handle usage message from Claude Code
-     *
-     * Updates usage metrics with token counts and calculates cost.
-     * Emits usage events to registered handlers.
-     *
-     * @param message - Parsed usage message
-     */
-    private _handleUsage;
-    /**
-     * Handle error message from Claude Code
-     *
-     * Tracks error in metrics and emits onError event.
-     *
-     * @param message - Parsed error message
-     */
-    private _handleError;
-    /**
-     * Detect file change from a tool call
-     *
-     * Analyzes tool calls to file operation tools (Read/Write/Edit) and
-     * extracts file change information.
-     *
-     * @param toolCall - The completed tool call
-     * @param message - The tool result message
-     * @returns FileChange object if file operation detected, null otherwise
-     */
-    private _detectFileChange;
-    /**
-     * Detect the type of message from parsed Claude Code JSON data
-     *
-     * Claude Code uses a specific structure with type and message.content fields.
-     * This method understands Claude's output format.
-     *
-     * @param data - Parsed JSON object from Claude Code
-     * @returns Message type
-     */
-    private _detectMessageType;
-    /**
-     * Parse raw Claude Code JSON data into an OutputMessage
-     *
-     * @param data - Parsed JSON object from Claude Code
-     * @param type - Detected message type
-     * @returns Structured OutputMessage
-     */
-    private _parseMessage;
-    /**
-     * Extract text content from Claude Code message data
-     *
-     * Claude can return content as a string or an array of content blocks.
-     * This method handles both formats.
-     */
-    private _extractTextContent;
-    /**
-     * Extract tool use information from Claude Code message data
-     *
-     * Claude includes tool_use blocks in the message.content array.
-     */
-    private _extractToolUse;
-    /**
-     * Extract tool result information from Claude Code message data
-     *
-     * Claude includes tool_result blocks with execution results.
-     */
-    private _extractToolResult;
-    /**
-     * Extract usage information from Claude Code result message
-     *
-     * Claude provides token usage in result messages with detailed breakdowns.
-     */
-    private _extractUsage;
-    /**
-     * Emit progress event to all registered handlers
-     */
-    private _emitProgress;
-    /**
-     * Emit error event to all registered handlers
-     */
-    private _emitError;
-}
-//# sourceMappingURL=claude-code-output-processor.d.ts.map

package/dist/execution/output/claude-code-output-processor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"claude-code-output-processor.d.ts","sourceRoot":"","sources":["../../../src/execution/output/claude-code-output-processor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAEhB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,YAAY,EAIb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,yBAA0B,YAAW,gBAAgB;IAEhE,OAAO,CAAC,QAAQ,CAAoB;IACpC,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,YAAY,CAAe;IAGnC,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,mBAAmB,CAA2B;IACtD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,cAAc,CAAsB;IAC5C,OAAO,CAAC,gBAAgB,CAAwB;IAChD,OAAO,CAAC,cAAc,CAAsB;IAG5C,OAAO,CAAC,WAAW,CAAK;;IA0BxB;;;;;;;OAOG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkE9C;;;;OAIG;IACH,UAAU,IAAI,iBAAiB;IAU/B;;;;OAIG;IACH,YAAY,IAAI,QAAQ,EAAE;IAI1B;;;;OAIG;IACH,cAAc,IAAI,UAAU,EAAE;IAI9B;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAI1C;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI;IAI9C;;;;OAIG;IACH,UAAU,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IAI1C;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC;;;;OAIG;IACH,SAAS,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,cAAc,GAAG,IAAI;IAI7D;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,YAAY,EAAE,YAAY,GAAG,IAAI;IAQzD;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE;IAIhD;;;;;;;;;;;OAWG;IACH,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,EAAE;IAIhD;;;;;;;;;;;OAWG;IACH,yBAAyB,CACvB,SAAS,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GACnC,UAAU,EAAE;IAMf;;;;;;;;;;;;OAYG;IACH,kBAAkB,IAAI,QAAQ,EAAE;IAIhC;;;;;;;;;;OAUG;IACH,sBAAsB,IAAI,QAAQ,EAAE;IAIpC;;;;;;;;;;OAUG;IACH,YAAY,IAAI,MAAM;IAItB;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,mBAAmB,IAAI,OAAO,YAAY,EAAE,gBAAgB;IAsD5D;;;;;;;OAOG;IACH,OAAO,CAAC,cAAc;IA2BtB;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAanB;;;;;;;OAOG;IACH,OAAO,CAAC,YAAY;IA2BpB;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAmBpB;;;;;;;;;OASG;IACH,OAAO,CAAC,iBAAiB;IA2CzB;;;;;;;;OAQG;IACH,OAAO,CAAC,kBAAkB;IAoC1B;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAsErB;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB;IAgB3B;;;;OAIG;IACH,OAAO,CAAC,eAAe;IAgBvB;;;;OAIG;IACH,OAAO,CAAC,kBAAkB;IAgB1B;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAcrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,UAAU;CAcnB"}