@sudocode-ai/local-server 0.1.0

package/dist/execution/process/simple-manager.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Simple Process Manager Implementation
+ *
+ * A straightforward implementation of IProcessManager that spawns a fresh
+ * process for each task. This is the "simple first" approach that will later
+ * be upgraded to support process pooling.
+ *
+ * Supports any CLI tool/agent (Claude Code, Codex, Gemini CLI, etc.)
+ *
+ * Key features:
+ * - One process per task (no pooling)
+ * - Event-based I/O streaming
+ * - Graceful termination (SIGTERM → SIGKILL)
+ * - Automatic cleanup
+ * - Metrics tracking
+ * - Agent-agnostic design
+ *
+ * @module execution/process/simple-manager
+ */
+import type { ManagedProcess, ProcessConfig, ProcessMetrics, OutputHandler, ErrorHandler } from "./types.js";
+import type { IProcessManager } from "./manager.js";
+/**
+ * Simple process manager that spawns one process per task
+ *
+ * This implementation follows the "simple first" principle - it provides
+ * a production-ready process manager without the complexity of pooling.
+ *
+ * Works with any CLI tool/agent by accepting executable path and args.
+ *
+ * @example
+ * ```typescript
+ * // Claude Code example
+ * const manager = new SimpleProcessManager({
+ *   executablePath: 'claude',
+ *   args: ['--print', '--output-format', 'stream-json'],
+ * });
+ *
+ * const process = await manager.acquireProcess({
+ *   executablePath: 'claude',
+ *   args: ['--print', '--output-format', 'stream-json'],
+ *   workDir: '/path/to/project',
+ *   timeout: 300000,
+ * });
+ *
+ * // Codex example
+ * const codexProcess = await manager.acquireProcess({
+ *   executablePath: 'codex',
+ *   args: ['--mode', 'agent', '--json'],
+ *   workDir: '/path/to/project',
+ * });
+ * ```
+ */
+export declare class SimpleProcessManager implements IProcessManager {
+    private readonly _defaultConfig;
+    private _activeProcesses;
+    private _cleanupTimers;
+    private _metrics;
+    /**
+     * Create a new SimpleProcessManager
+     *
+     * @param defaultConfig - Default configuration to merge with per-process config
+     */
+    constructor(_defaultConfig?: Partial<ProcessConfig>);
+    acquireProcess(config: ProcessConfig): Promise<ManagedProcess>;
+    /**
+     * Spawn a process with the given configuration
+     *
+     * @param config - Process configuration
+     * @returns ChildProcess instance
+     */
+    private spawnProcess;
+    /**
+     * Set up event handlers for a managed process
+     *
+     * Handles lifecycle events:
+     * - exit: Process terminated normally or abnormally
+     * - error: Process encountered an error
+     * - stdout/stderr data: Track activity for idle detection
+     *
+     * @param managedProcess - The managed process to set up handlers for
+     * @param config - Process configuration (for timeout)
+     */
+    private setupProcessHandlers;
+    releaseProcess(processId: string): Promise<void>;
+    terminateProcess(processId: string, signal?: NodeJS.Signals): Promise<void>;
+    sendInput(processId: string, input: string): Promise<void>;
+    /**
+     * Close stdin stream for a process
+     *
+     * Signals EOF to the process, useful for programs that wait for stdin to close.
+     *
+     * @param processId - ID of the process
+     */
+    closeInput(processId: string): void;
+    onOutput(processId: string, handler: OutputHandler): void;
+    onError(processId: string, handler: ErrorHandler): void;
+    getProcess(processId: string): ManagedProcess | null;
+    getActiveProcesses(): ManagedProcess[];
+    getMetrics(): ProcessMetrics;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=simple-manager.d.ts.map

package/dist/execution/process/simple-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple-manager.d.ts","sourceRoot":"","sources":["../../../src/execution/process/simple-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,cAAc,EACd,aAAa,EACb,YAAY,EACb,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,oBAAqB,YAAW,eAAe;IAgB9C,OAAO,CAAC,QAAQ,CAAC,cAAc;IAf3C,OAAO,CAAC,gBAAgB,CAAqC;IAC7D,OAAO,CAAC,cAAc,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAMd;IAEF;;;;OAIG;gBAC0B,cAAc,GAAE,OAAO,CAAC,aAAa,CAAM;IAElE,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO,CAAC,cAAc,CAAC;IAsDpE;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,oBAAoB;IA8FtB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIhD,gBAAgB,CACpB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,MAAM,CAAC,OAAmB,GACjC,OAAO,CAAC,IAAI,CAAC;IAkDV,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAchE;;;;;;OAMG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IASnC,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,IAAI;IAezD,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,IAAI;IAWvD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIpD,kBAAkB,IAAI,cAAc,EAAE;IAItC,UAAU,IAAI,cAAc;IAKtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAahC"}

package/dist/execution/process/types.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Process Layer Types
+ *
+ * Core types and interfaces for the Process Layer (Layer 1) of the execution system.
+ * Defines generic types for managing any CLI tool/agent process lifecycle.
+ *
+ * @module execution/process/types
+ */
+import type { ChildProcess } from 'child_process';
+import type { Readable, Writable } from 'stream';
+/**
+ * Status of a managed process throughout its lifecycle
+ */
+export type ProcessStatus = 'spawning' | 'idle' | 'busy' | 'terminating' | 'crashed' | 'completed';
+/**
+ * Configuration for spawning a new process
+ * Generic interface that works with any CLI tool/agent
+ */
+export interface ProcessConfig {
+    /** Path to the executable (e.g., 'claude', 'codex', 'node') */
+    executablePath: string;
+    /** Command-line arguments to pass to the executable */
+    args: string[];
+    /** Working directory for the process */
+    workDir: string;
+    /** Environment variables to pass to the process */
+    env?: Record<string, string>;
+    /** Maximum execution time in milliseconds */
+    timeout?: number;
+    /** Maximum idle time before cleanup (pool only) */
+    idleTimeout?: number;
+    /** Retry configuration for failed spawns */
+    retry?: {
+        /** Maximum number of retry attempts */
+        maxAttempts: number;
+        /** Initial backoff delay in milliseconds */
+        backoffMs: number;
+    };
+}
+/**
+ * Represents a single managed process instance with its lifecycle state
+ * Can be any CLI tool/agent (Claude Code, Codex, Gemini CLI, etc.)
+ */
+export interface ManagedProcess {
+    /** Unique process identifier */
+    id: string;
+    /** Operating system process ID */
+    pid: number;
+    /** Current status of the process */
+    status: ProcessStatus;
+    /** When the process was spawned */
+    spawnedAt: Date;
+    /** Last I/O activity timestamp */
+    lastActivity: Date;
+    /** Exit code if process has exited */
+    exitCode: number | null;
+    /** Signal that terminated the process if applicable */
+    signal: string | null;
+    /** Node.js ChildProcess handle */
+    process: ChildProcess;
+    /** Process I/O streams */
+    streams: {
+        stdout: Readable;
+        stderr: Readable;
+        stdin: Writable;
+    };
+    /** Process execution metrics */
+    metrics: {
+        /** Total duration in milliseconds */
+        totalDuration: number;
+        /** Number of tasks completed */
+        tasksCompleted: number;
+        /** Success rate (0-1) */
+        successRate: number;
+    };
+}
+/**
+ * Handler for process output (stdout/stderr)
+ *
+ * @param data - Output data buffer
+ * @param type - Stream type
+ */
+export type OutputHandler = (data: Buffer, type: 'stdout' | 'stderr') => void;
+/**
+ * Handler for process errors
+ *
+ * @param error - Error that occurred
+ */
+export type ErrorHandler = (error: Error) => void;
+/**
+ * Aggregate metrics for all processes managed by a ProcessManager
+ */
+export interface ProcessMetrics {
+    /** Total number of processes spawned */
+    totalSpawned: number;
+    /** Number of currently active processes */
+    currentlyActive: number;
+    /** Total number of successfully completed processes */
+    totalCompleted: number;
+    /** Total number of failed processes */
+    totalFailed: number;
+    /** Average process duration in milliseconds */
+    averageDuration: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/execution/process/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/execution/process/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAEjD;;GAEG;AACH,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,MAAM,GACN,MAAM,GACN,aAAa,GACb,SAAS,GACT,WAAW,CAAC;AAEhB;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,cAAc,EAAE,MAAM,CAAC;IAEvB,uDAAuD;IACvD,IAAI,EAAE,MAAM,EAAE,CAAC;IAEf,wCAAwC;IACxC,OAAO,EAAE,MAAM,CAAC;IAEhB,mDAAmD;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B,6CAA6C;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,mDAAmD;IACnD,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,4CAA4C;IAC5C,KAAK,CAAC,EAAE;QACN,uCAAuC;QACvC,WAAW,EAAE,MAAM,CAAC;QACpB,4CAA4C;QAC5C,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAE7B,gCAAgC;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,kCAAkC;IAClC,GAAG,EAAE,MAAM,CAAC;IAGZ,oCAAoC;IACpC,MAAM,EAAE,aAAa,CAAC;IACtB,mCAAmC;IACnC,SAAS,EAAE,IAAI,CAAC;IAChB,kCAAkC;IAClC,YAAY,EAAE,IAAI,CAAC;IACnB,sCAAsC;IACtC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,uDAAuD;IACvD,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAGtB,kCAAkC;IAClC,OAAO,EAAE,YAAY,CAAC;IACtB,0BAA0B;IAC1B,OAAO,EAAE;QACP,MAAM,EAAE,QAAQ,CAAC;QACjB,MAAM,EAAE,QAAQ,CAAC;QACjB,KAAK,EAAE,QAAQ,CAAC;KACjB,CAAC;IAGF,gCAAgC;IAChC,OAAO,EAAE;QACP,qCAAqC;QACrC,aAAa,EAAE,MAAM,CAAC;QACtB,gCAAgC;QAChC,cAAc,EAAE,MAAM,CAAC;QACvB,yBAAyB;QACzB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,KAAK,IAAI,CAAC;AAE9E;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;AAElD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,2CAA2C;IAC3C,eAAe,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,eAAe,EAAE,MAAM,CAAC;CACzB"}

package/dist/execution/process/utils.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Process Layer Utilities
+ *
+ * Helper functions for the Process Layer including ID generation,
+ * formatting, and validation utilities.
+ *
+ * @module execution/process/utils
+ */
+/**
+ * Generate a unique process ID with a prefix
+ *
+ * Creates URL-safe, unique identifiers for processes. Uses nanoid for
+ * cryptographically strong random IDs.
+ *
+ * @param prefix - Prefix for the ID (e.g., 'process', 'task')
+ * @returns Unique ID string in format: `{prefix}-{randomId}`
+ *
+ * @example
+ * ```typescript
+ * const id = generateId('process');
+ * // Returns: 'process-a1b2c3d4'
+ * ```
+ */
+export declare function generateId(prefix: string): string;
+/**
+ * Format duration in milliseconds to human-readable string
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Formatted duration string
+ *
+ * @example
+ * ```typescript
+ * formatDuration(1500); // "1.5s"
+ * formatDuration(65000); // "1m 5s"
+ * ```
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Validate that a signal name is valid for Node.js
+ *
+ * @param signal - Signal name to validate
+ * @returns True if signal is valid
+ */
+export declare function isValidSignal(signal: string): boolean;
+/**
+ * Format error message from process exit
+ *
+ * @param exitCode - Process exit code
+ * @param signal - Signal that terminated the process
+ * @returns Formatted error message
+ */
+export declare function formatProcessError(exitCode: number | null, signal: string | null): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/execution/process/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/execution/process/utils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAuBjD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAUrD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,EAAE,MAAM,GAAG,IAAI,GACpB,MAAM,CAQR"}

package/dist/execution/resilience/circuit-breaker.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Circuit Breaker Implementation
+ *
+ * Implements the circuit breaker pattern for preventing cascading failures.
+ * Tracks failures and successes, automatically opening when thresholds are
+ * exceeded and recovering through half-open state.
+ *
+ * @module execution/resilience/circuit-breaker
+ */
+import type { CircuitBreaker, CircuitState } from './types.js';
+/**
+ * CircuitBreakerManager - Manages multiple circuit breakers
+ *
+ * Maintains a collection of circuit breakers, typically one per task type
+ * or service. Provides methods for checking state, recording outcomes,
+ * and managing circuit lifecycle.
+ *
+ * @example
+ * ```typescript
+ * const manager = new CircuitBreakerManager();
+ * const breaker = manager.getOrCreate('issue-executor', {
+ *   failureThreshold: 5,
+ *   successThreshold: 2,
+ *   timeout: 60000,
+ * });
+ *
+ * if (manager.canExecute('issue-executor')) {
+ *   // Execute task
+ *   const success = await executeTask();
+ *   if (success) {
+ *     manager.recordSuccess('issue-executor');
+ *   } else {
+ *     manager.recordFailure('issue-executor', new Error('Task failed'));
+ *   }
+ * }
+ * ```
+ */
+export declare class CircuitBreakerManager {
+    private breakers;
+    /**
+     * Get an existing circuit breaker by name
+     *
+     * @param name - Circuit breaker name
+     * @returns Circuit breaker or null if not found
+     */
+    get(name: string): CircuitBreaker | null;
+    /**
+     * Get or create a circuit breaker
+     *
+     * If a circuit breaker with the given name exists, returns it.
+     * Otherwise creates a new one with the provided configuration.
+     *
+     * @param name - Circuit breaker name (typically task type)
+     * @param config - Configuration for new circuit breaker
+     * @returns Circuit breaker instance
+     */
+    getOrCreate(name: string, config?: CircuitBreaker['config']): CircuitBreaker;
+    /**
+     * Check if a circuit breaker allows execution
+     *
+     * Returns false if circuit is open and timeout hasn't elapsed yet.
+     * Returns true for closed and half-open states.
+     *
+     * @param name - Circuit breaker name
+     * @returns True if execution is allowed
+     */
+    canExecute(name: string): boolean;
+    /**
+     * Record a successful execution
+     *
+     * Updates metrics and may transition circuit from half-open to closed
+     * if success threshold is met.
+     *
+     * @param name - Circuit breaker name
+     */
+    recordSuccess(name: string): void;
+    /**
+     * Record a failed execution
+     *
+     * Updates metrics and may transition circuit from closed/half-open to open
+     * if failure threshold is met.
+     *
+     * @param name - Circuit breaker name
+     * @param error - Error that occurred
+     */
+    recordFailure(name: string, error: Error): void;
+    /**
+     * Reset a circuit breaker to closed state
+     *
+     * Clears all failure counts and returns circuit to closed state.
+     * Useful for manual recovery or after fixing underlying issues.
+     *
+     * @param name - Circuit breaker name
+     */
+    reset(name: string): void;
+    /**
+     * Get all circuit breakers
+     *
+     * @returns Map of circuit breaker name to breaker instance
+     */
+    getAll(): Map<string, CircuitBreaker>;
+    /**
+     * Check if enough time has passed to transition from open to half-open
+     *
+     * @param breaker - Circuit breaker to check
+     * @returns True if timeout has elapsed
+     * @private
+     */
+    private shouldTransitionToHalfOpen;
+    /**
+     * Get count of consecutive successes
+     *
+     * In a production implementation, this would track a sliding window
+     * of recent attempts. For simplicity, we use total successful requests.
+     *
+     * @param breaker - Circuit breaker to check
+     * @returns Number of consecutive successes
+     * @private
+     */
+    private getConsecutiveSuccesses;
+}
+/**
+ * Create a new circuit breaker instance
+ *
+ * Helper function to create a properly configured circuit breaker.
+ *
+ * @param name - Circuit breaker name
+ * @param config - Circuit breaker configuration
+ * @returns New circuit breaker instance
+ *
+ * @example
+ * ```typescript
+ * const breaker = createCircuitBreaker('api-calls', {
+ *   failureThreshold: 10,
+ *   successThreshold: 3,
+ *   timeout: 30000,
+ * });
+ * ```
+ */
+export declare function createCircuitBreaker(name: string, config?: CircuitBreaker['config']): CircuitBreaker;
+/**
+ * Check if a circuit breaker is in a specific state
+ *
+ * @param breaker - Circuit breaker to check
+ * @param state - State to check for
+ * @returns True if breaker is in the specified state
+ */
+export declare function isInState(breaker: CircuitBreaker, state: CircuitState): boolean;
+/**
+ * Get the current state of a circuit breaker
+ *
+ * @param breaker - Circuit breaker to check
+ * @returns Current state
+ */
+export declare function getState(breaker: CircuitBreaker): CircuitState;
+/**
+ * Calculate failure rate for a circuit breaker
+ *
+ * @param breaker - Circuit breaker to analyze
+ * @returns Failure rate (0-1) or 0 if no requests
+ */
+export declare function getFailureRate(breaker: CircuitBreaker): number;
+/**
+ * Calculate success rate for a circuit breaker
+ *
+ * @param breaker - Circuit breaker to analyze
+ * @returns Success rate (0-1) or 0 if no requests
+ */
+export declare function getSuccessRate(breaker: CircuitBreaker): number;
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/execution/resilience/circuit-breaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circuit-breaker.d.ts","sourceRoot":"","sources":["../../../src/execution/resilience/circuit-breaker.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAqC;IAErD;;;;;OAKG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAIxC;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,cAAc,CAAC,QAAQ,CAI9B,GACA,cAAc;IAqBjB;;;;;;;;OAQG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAkBjC;;;;;;;OAOG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAuBjC;;;;;;;;OAQG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI;IAuB/C;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAWzB;;;;OAIG;IACH,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAIrC;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAWlC;;;;;;;;;OASG;IACH,OAAO,CAAC,uBAAuB;CAKhC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,GAAE,cAAc,CAAC,QAAQ,CAI9B,GACA,cAAc,CAWhB;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,YAAY,GAClB,OAAO,CAET;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,cAAc,GAAG,YAAY,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAM9D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAM9D"}

package/dist/execution/resilience/executor.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Resilient Executor Interface
+ *
+ * Core abstraction for resilient task execution. Provides methods for
+ * executing tasks with retry logic, circuit breakers, and fault tolerance.
+ *
+ * @module execution/resilience/executor
+ */
+import type { ExecutionTask } from '../engine/types.js';
+import type { RetryPolicy, CircuitBreaker, RetryMetrics, ResilientExecutionResult, RetryAttemptHandler, CircuitOpenHandler } from './types.js';
+/**
+ * IResilientExecutor - Interface for resilient task execution
+ *
+ * Defines the contract for executors that add resilience patterns
+ * (retry, circuit breaker) to task execution. Implementations wrap
+ * the Engine Layer with fault tolerance mechanisms.
+ *
+ * @example
+ * ```typescript
+ * const executor = new ResilientExecutor(engine, {
+ *   maxAttempts: 3,
+ *   backoff: {
+ *     type: 'exponential',
+ *     baseDelayMs: 1000,
+ *     maxDelayMs: 30000,
+ *     jitter: true,
+ *   },
+ *   retryableErrors: ['timeout', 'ECONNREFUSED'],
+ *   retryableExitCodes: [1],
+ * });
+ *
+ * const result = await executor.executeTask(task);
+ * console.log(`Success after ${result.totalAttempts} attempts`);
+ * ```
+ */
+export interface IResilientExecutor {
+    /**
+     * Execute a single task with retry and circuit breaker
+     *
+     * Attempts to execute the task, retrying on transient failures according
+     * to the retry policy. Checks circuit breaker before execution to prevent
+     * cascading failures.
+     *
+     * @param task - The task to execute
+     * @param policy - Optional retry policy (uses default if not provided)
+     * @returns Promise resolving to enhanced result with retry information
+     * @throws Error if circuit breaker is open or max retries exceeded
+     */
+    executeTask(task: ExecutionTask, policy?: RetryPolicy): Promise<ResilientExecutionResult>;
+    /**
+     * Execute multiple tasks with retry and circuit breaker
+     *
+     * Executes all tasks in parallel, each with its own retry logic.
+     * Tasks of the same type share a circuit breaker.
+     *
+     * @param tasks - Array of tasks to execute
+     * @param policy - Optional retry policy for all tasks
+     * @returns Promise resolving to array of enhanced results
+     */
+    executeTasks(tasks: ExecutionTask[], policy?: RetryPolicy): Promise<ResilientExecutionResult[]>;
+    /**
+     * Get circuit breaker by name
+     *
+     * Circuit breakers are typically named by task type (e.g., 'issue', 'spec').
+     * Returns null if no circuit breaker exists for the given name.
+     *
+     * @param name - Name of the circuit breaker
+     * @returns Circuit breaker or null if not found
+     */
+    getCircuitBreaker(name: string): CircuitBreaker | null;
+    /**
+     * Reset a circuit breaker to closed state
+     *
+     * Manually resets a circuit breaker, clearing failure counts and
+     * returning it to the closed state. Useful for recovery after
+     * fixing underlying issues.
+     *
+     * @param name - Name of the circuit breaker to reset
+     */
+    resetCircuitBreaker(name: string): void;
+    /**
+     * Get aggregate retry metrics
+     *
+     * Returns statistics about retry behavior across all tasks,
+     * including circuit breaker states.
+     *
+     * @returns Retry metrics (defensive copy)
+     */
+    getRetryMetrics(): RetryMetrics;
+    /**
+     * Register handler for retry attempt events
+     *
+     * Called whenever a task is retried after a failure. Useful for
+     * logging, alerting, or monitoring retry patterns.
+     *
+     * @param handler - Callback function to invoke on each retry
+     */
+    onRetryAttempt(handler: RetryAttemptHandler): void;
+    /**
+     * Register handler for circuit breaker open events
+     *
+     * Called when a circuit breaker transitions from closed/half-open
+     * to open state. Useful for alerting on service degradation.
+     *
+     * @param handler - Callback function to invoke when circuit opens
+     */
+    onCircuitOpen(handler: CircuitOpenHandler): void;
+}
+//# sourceMappingURL=executor.d.ts.map

package/dist/execution/resilience/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/execution/resilience/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,wBAAwB,EACxB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,WAAW,kBAAkB;IAKjC;;;;;;;;;;;OAWG;IACH,WAAW,CACT,IAAI,EAAE,aAAa,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAErC;;;;;;;;;OASG;IACH,YAAY,CACV,KAAK,EAAE,aAAa,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAAC;IAMvC;;;;;;;;OAQG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;IAEvD;;;;;;;;OAQG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAMxC;;;;;;;OAOG;IACH,eAAe,IAAI,YAAY,CAAC;IAEhC;;;;;;;OAOG;IACH,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAEnD;;;;;;;OAOG;IACH,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAAC;CAClD"}

package/dist/execution/resilience/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resilience Layer Exports
+ *
+ * Layer 3: Task Execution Layer - Resilience & Retry
+ *
+ * @module execution/resilience
+ */
+export type { RetryPolicy, CircuitState, CircuitBreaker, ExecutionAttempt, ResilientExecutionResult, RetryMetrics, RetryAttemptHandler, CircuitOpenHandler, } from './types.js';
+export { DEFAULT_RETRY_POLICY } from './types.js';
+export type { IResilientExecutor } from './executor.js';
+export { ResilientExecutor } from './resilient-executor.js';
+export { calculateBackoff, isRetryableError, isRetryableExitCode, isRetryableResult, sleep, createAttempt, calculateTotalRetryDelay, } from './retry.js';
+export { CircuitBreakerManager, createCircuitBreaker, isInState, getState, getFailureRate, getSuccessRate, } from './circuit-breaker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/execution/resilience/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/execution/resilience/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,YAAY,EACV,WAAW,EACX,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,wBAAwB,EACxB,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAGlD,YAAY,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGxD,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,EACL,aAAa,EACb,wBAAwB,GACzB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,SAAS,EACT,QAAQ,EACR,cAAc,EACd,cAAc,GACf,MAAM,sBAAsB,CAAC"}

package/dist/execution/resilience/resilient-executor.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Resilient Executor Implementation
+ *
+ * Implements resilient task execution with retry logic and circuit breakers.
+ * Wraps the Engine Layer with fault tolerance mechanisms.
+ *
+ * @module execution/resilience/resilient-executor
+ */
+import type { IExecutionEngine } from "../engine/engine.js";
+import type { ExecutionTask } from "../engine/types.js";
+import type { IResilientExecutor } from "./executor.js";
+import type { RetryPolicy, CircuitBreaker, RetryMetrics, ResilientExecutionResult, RetryAttemptHandler, CircuitOpenHandler } from "./types.js";
+/**
+ * ResilientExecutor - Main implementation of resilient task execution
+ *
+ * Provides retry logic and circuit breaker protection for task execution.
+ * Wraps an IExecutionEngine with fault tolerance mechanisms.
+ *
+ * @example
+ * ```typescript
+ * const engine = new SimpleExecutionEngine(processManager);
+ * const executor = new ResilientExecutor(engine);
+ *
+ * const task: ExecutionTask = {
+ *   id: 'task-1',
+ *   type: 'issue',
+ *   prompt: 'Fix the bug in authentication',
+ *   workDir: '/path/to/project',
+ *   priority: 0,
+ *   dependencies: [],
+ *   createdAt: new Date(),
+ *   config: {},
+ * };
+ *
+ * const result = await executor.executeTask(task);
+ * console.log(`Completed after ${result.totalAttempts} attempts`);
+ * ```
+ */
+export declare class ResilientExecutor implements IResilientExecutor {
+    private _engine;
+    private _circuitManager;
+    private _defaultPolicy;
+    private _metrics;
+    private _retryHandlers;
+    private _circuitOpenHandlers;
+    constructor(engine: IExecutionEngine, defaultPolicy?: RetryPolicy);
+    /**
+     * Execute a single task with retry and circuit breaker protection
+     */
+    executeTask(task: ExecutionTask, policy?: RetryPolicy): Promise<ResilientExecutionResult>;
+    /**
+     * Execute multiple tasks with retry and circuit breaker protection
+     */
+    executeTasks(tasks: ExecutionTask[], policy?: RetryPolicy): Promise<ResilientExecutionResult[]>;
+    /**
+     * Get circuit breaker by name
+     */
+    getCircuitBreaker(name: string): CircuitBreaker | null;
+    /**
+     * Reset a circuit breaker to closed state
+     */
+    resetCircuitBreaker(name: string): void;
+    /**
+     * Get aggregate retry metrics
+     */
+    getRetryMetrics(): RetryMetrics;
+    /**
+     * Register handler for retry attempt events
+     */
+    onRetryAttempt(handler: RetryAttemptHandler): void;
+    /**
+     * Register handler for circuit breaker open events
+     */
+    onCircuitOpen(handler: CircuitOpenHandler): void;
+    /**
+     * Helper to create ResilientExecutionResult from engine result
+     * @private
+     */
+    private _createResilientResult;
+    /**
+     * Helper to update average attempts to success metric
+     * @private
+     */
+    private _updateAverageAttempts;
+}
+//# sourceMappingURL=resilient-executor.d.ts.map

package/dist/execution/resilience/resilient-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resilient-executor.d.ts","sourceRoot":"","sources":["../../../src/execution/resilience/resilient-executor.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAmB,MAAM,oBAAoB,CAAC;AACzE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EACV,WAAW,EACX,cAAc,EACd,YAAY,EACZ,wBAAwB,EAExB,mBAAmB,EACnB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAWpB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAC1D,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,QAAQ,CAAe;IAG/B,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,oBAAoB,CAA4B;gBAGtD,MAAM,EAAE,gBAAgB,EACxB,aAAa,GAAE,WAAkC;IAcnD;;OAEG;IACG,WAAW,CACf,IAAI,EAAE,aAAa,EACnB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,wBAAwB,CAAC;IAkLpC;;OAEG;IACG,YAAY,CAChB,KAAK,EAAE,aAAa,EAAE,EACtB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAMtC;;OAEG;IACH,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAItD;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIvC;;OAEG;IACH,eAAe,IAAI,YAAY;IAW/B;;OAEG;IACH,cAAc,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAIlD;;OAEG;IACH,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAIhD;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;OAGG;IACH,OAAO,CAAC,sBAAsB;CAQ/B"}