byterover-cli 0.2.1 → 0.3.0

package/dist/core/domain/cipher/errors/llm-error.js

@@ -0,0 +1,161 @@
+/**
+ * Base error class for LLM-related operations.
+ * All LLM-specific errors extend this base class.
+ */
+export class LlmError extends Error {
+    code;
+    details;
+    model;
+    provider;
+    /**
+     * Creates a new LLM error
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization (e.g., 'LLM_GENERATION_FAILED')
+     * @param provider - LLM provider name (e.g., 'gemini', 'openai')
+     * @param model - Model name that was being used (e.g., 'gemini-2.5-flash')
+     */
+    constructor(message, code, provider, model) {
+        super(message);
+        this.name = 'LlmError';
+        this.code = code;
+        this.provider = provider;
+        this.model = model;
+    }
+}
+/**
+ * Error thrown when LLM generation fails.
+ * This can happen due to API errors, network issues, or model failures.
+ */
+export class LlmGenerationError extends LlmError {
+    originalError;
+    /**
+     * Creates a new generation error
+     * @param error - The original error message from the LLM provider
+     * @param provider - LLM provider name
+     * @param model - Model name that was being used
+     */
+    constructor(error, provider, model) {
+        // Don't add "Generation failed:" prefix if error already has emoji prefix (user-friendly message)
+        const message = error.startsWith('❌') ? error : `Generation failed: ${error}`;
+        super(message, 'LLM_GENERATION_FAILED', provider, model);
+        this.name = 'LlmGenerationError';
+        this.originalError = error;
+    }
+}
+/**
+ * Error thrown when rate limits are exceeded.
+ * Includes optional retry delay information.
+ */
+export class LlmRateLimitError extends LlmError {
+    retryAfter;
+    /**
+     * Creates a new rate limit error
+     * @param provider - LLM provider name
+     * @param retryAfter - Optional number of seconds to wait before retrying
+     */
+    constructor(provider, retryAfter) {
+        const message = retryAfter
+            ? `Rate limit exceeded for ${provider}. Retry after ${retryAfter} seconds`
+            : `Rate limit exceeded for ${provider}. Please wait before retrying`;
+        super(message, 'LLM_RATE_LIMIT_EXCEEDED', provider);
+        this.name = 'LlmRateLimitError';
+        this.retryAfter = retryAfter;
+    }
+    /**
+     * Gets the retry delay in milliseconds
+     * @returns Delay in milliseconds, or undefined if not specified
+     */
+    getRetryAfterMs() {
+        return this.retryAfter ? this.retryAfter * 1000 : undefined;
+    }
+}
+/**
+ * Error thrown when maximum iterations are exceeded in agentic loops.
+ * This prevents infinite loops when tool calling doesn't converge.
+ */
+export class LlmMaxIterationsError extends LlmError {
+    maxIterations;
+    /**
+     * Creates a new max iterations error
+     * @param maxIterations - The maximum number of iterations that was configured
+     * @param provider - LLM provider name
+     * @param model - Model name that was being used
+     */
+    constructor(maxIterations, provider, model) {
+        super(`Maximum iterations (${maxIterations}) reached without completion`, 'LLM_MAX_ITERATIONS_EXCEEDED', provider, model);
+        this.name = 'LlmMaxIterationsError';
+        this.maxIterations = maxIterations;
+    }
+}
+/**
+ * Error thrown when tool execution fails during LLM operations.
+ * This occurs when the LLM requests a tool call but the execution fails.
+ */
+export class LlmToolExecutionError extends LlmError {
+    originalError;
+    toolName;
+    /**
+     * Creates a new tool execution error
+     * @param toolName - Name of the tool that failed
+     * @param error - The original error message
+     * @param provider - LLM provider name
+     * @param model - Model name that was being used
+     */
+    constructor(toolName, error, provider, model) {
+        super(`Tool execution failed for '${toolName}': ${error}`, 'LLM_TOOL_EXECUTION_FAILED', provider, model);
+        this.name = 'LlmToolExecutionError';
+        this.toolName = toolName;
+        this.originalError = error;
+    }
+}
+/**
+ * Error thrown when LLM configuration is invalid or missing.
+ * This includes missing API keys, invalid settings, etc.
+ */
+export class LlmConfigurationError extends LlmError {
+    configKey;
+    /**
+     * Creates a new configuration error
+     * @param configKey - The configuration key that is problematic
+     * @param message - Description of the configuration issue
+     * @param provider - LLM provider name
+     */
+    constructor(configKey, message, provider) {
+        super(`Configuration error for '${configKey}': ${message}`, 'LLM_CONFIGURATION_ERROR', provider);
+        this.name = 'LlmConfigurationError';
+        this.configKey = configKey;
+    }
+}
+/**
+ * Error thrown when parsing LLM responses fails.
+ * This occurs when the response format is unexpected or malformed.
+ */
+export class LlmResponseParsingError extends LlmError {
+    originalError;
+    /**
+     * Creates a new response parsing error
+     * @param error - Description of the parsing error
+     * @param provider - LLM provider name
+     * @param model - Model name that was being used
+     */
+    constructor(error, provider, model) {
+        super(`Response parsing failed: ${error}`, 'LLM_RESPONSE_PARSING_FAILED', provider, model);
+        this.name = 'LlmResponseParsingError';
+        this.originalError = error;
+    }
+}
+/**
+ * Error thrown when no tool executor is provided but tools are requested.
+ * This is a configuration issue where the LLM wants to call tools but can't.
+ */
+export class LlmMissingToolExecutorError extends LlmError {
+    /**
+     * Creates a new missing tool executor error
+     * @param provider - LLM provider name
+     * @param model - Model name that was being used
+     */
+    constructor(provider, model) {
+        super('Function calls requested but no tool executor provided', 'LLM_TOOL_EXECUTOR_MISSING', provider, model);
+        this.name = 'LlmMissingToolExecutorError';
+    }
+}

package/dist/core/domain/cipher/errors/memory-error.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Memory error class with factory methods for creating specific error instances
+ */
+/**
+ * Error codes for memory operations
+ */
+export declare enum MemoryErrorCode {
+    MEMORY_ALREADY_EXISTS = "MEMORY_ALREADY_EXISTS",
+    MEMORY_CONTENT_REQUIRED = "MEMORY_CONTENT_REQUIRED",
+    MEMORY_CONTENT_TOO_LONG = "MEMORY_CONTENT_TOO_LONG",
+    MEMORY_DELETE_ERROR = "MEMORY_DELETE_ERROR",
+    MEMORY_INVALID_ID = "MEMORY_INVALID_ID",
+    MEMORY_INVALID_TAGS = "MEMORY_INVALID_TAGS",
+    MEMORY_NOT_FOUND = "MEMORY_NOT_FOUND",
+    MEMORY_RETRIEVAL_ERROR = "MEMORY_RETRIEVAL_ERROR",
+    MEMORY_STORAGE_ERROR = "MEMORY_STORAGE_ERROR"
+}
+/**
+ * Memory error class with factory methods for creating specific error instances
+ */
+export declare class MemoryError extends Error {
+    readonly code: MemoryErrorCode;
+    readonly details?: Record<string, unknown> | undefined;
+    readonly suggestion?: string | undefined;
+    constructor(message: string, code: MemoryErrorCode, details?: Record<string, unknown> | undefined, suggestion?: string | undefined);
+    static alreadyExists(id: string): MemoryError;
+    static contentRequired(): MemoryError;
+    static contentTooLong(length: number, maxLength: number): MemoryError;
+    static deleteError(message: string, cause?: Error): MemoryError;
+    static invalidId(id: unknown): MemoryError;
+    static invalidTags(tags: unknown): MemoryError;
+    static notFound(id: string): MemoryError;
+    static retrievalError(message: string, cause?: Error): MemoryError;
+    static storageError(message: string, cause?: Error): MemoryError;
+}

package/dist/core/domain/cipher/errors/memory-error.js

@@ -0,0 +1,62 @@
+/**
+ * Memory error class with factory methods for creating specific error instances
+ */
+/**
+ * Error codes for memory operations
+ */
+export var MemoryErrorCode;
+(function (MemoryErrorCode) {
+    // General errors
+    MemoryErrorCode["MEMORY_ALREADY_EXISTS"] = "MEMORY_ALREADY_EXISTS";
+    MemoryErrorCode["MEMORY_CONTENT_REQUIRED"] = "MEMORY_CONTENT_REQUIRED";
+    MemoryErrorCode["MEMORY_CONTENT_TOO_LONG"] = "MEMORY_CONTENT_TOO_LONG";
+    MemoryErrorCode["MEMORY_DELETE_ERROR"] = "MEMORY_DELETE_ERROR";
+    MemoryErrorCode["MEMORY_INVALID_ID"] = "MEMORY_INVALID_ID";
+    MemoryErrorCode["MEMORY_INVALID_TAGS"] = "MEMORY_INVALID_TAGS";
+    MemoryErrorCode["MEMORY_NOT_FOUND"] = "MEMORY_NOT_FOUND";
+    // Storage errors
+    MemoryErrorCode["MEMORY_RETRIEVAL_ERROR"] = "MEMORY_RETRIEVAL_ERROR";
+    MemoryErrorCode["MEMORY_STORAGE_ERROR"] = "MEMORY_STORAGE_ERROR";
+})(MemoryErrorCode || (MemoryErrorCode = {}));
+/**
+ * Memory error class with factory methods for creating specific error instances
+ */
+export class MemoryError extends Error {
+    code;
+    details;
+    suggestion;
+    constructor(message, code, details, suggestion) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.suggestion = suggestion;
+        this.name = 'MemoryError';
+    }
+    static alreadyExists(id) {
+        return new MemoryError(`Memory already exists: ${id}`, MemoryErrorCode.MEMORY_ALREADY_EXISTS, { id }, 'Use update() to modify existing memory or delete() first before creating a new one.');
+    }
+    static contentRequired() {
+        return new MemoryError('Memory content is required', MemoryErrorCode.MEMORY_CONTENT_REQUIRED, undefined, 'Provide a non-empty content string when creating or updating a memory.');
+    }
+    static contentTooLong(length, maxLength) {
+        return new MemoryError(`Memory content too long: ${length} characters (max: ${maxLength})`, MemoryErrorCode.MEMORY_CONTENT_TOO_LONG, { length, maxLength }, `Reduce the content to ${maxLength} characters or less.`);
+    }
+    static deleteError(message, cause) {
+        return new MemoryError(`Memory deletion error: ${message}`, MemoryErrorCode.MEMORY_DELETE_ERROR, { cause }, 'Check if the memory file exists and you have write permissions.');
+    }
+    static invalidId(id) {
+        return new MemoryError(`Invalid memory ID: ${String(id)}`, MemoryErrorCode.MEMORY_INVALID_ID, { id }, 'Provide a valid non-empty string as the memory ID.');
+    }
+    static invalidTags(tags) {
+        return new MemoryError(`Invalid tags format: ${JSON.stringify(tags)}`, MemoryErrorCode.MEMORY_INVALID_TAGS, { tags }, 'Tags must be an array of strings, each 1-50 characters long, with a maximum of 10 tags.');
+    }
+    static notFound(id) {
+        return new MemoryError(`Memory not found: ${id}`, MemoryErrorCode.MEMORY_NOT_FOUND, { id }, 'Check if the memory ID is correct or use list() to find available memories.');
+    }
+    static retrievalError(message, cause) {
+        return new MemoryError(`Memory retrieval error: ${message}`, MemoryErrorCode.MEMORY_RETRIEVAL_ERROR, { cause }, 'Check if the memory storage is accessible and readable.');
+    }
+    static storageError(message, cause) {
+        return new MemoryError(`Memory storage error: ${message}`, MemoryErrorCode.MEMORY_STORAGE_ERROR, { cause }, 'Check if the storage directory exists and you have write permissions.');
+    }
+}

package/dist/core/domain/cipher/errors/process-error-code.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Error codes for process execution failures.
+ *
+ * Used by ProcessError factory to create structured error objects.
+ */
+export declare enum ProcessErrorCode {
+    /**
+     * Command matches a blocked pattern.
+     *
+     * Command is explicitly forbidden by security policy.
+     */
+    COMMAND_BLOCKED = "COMMAND_BLOCKED",
+    /**
+     * Command not found in PATH.
+     *
+     * System returned ENOENT error.
+     */
+    COMMAND_NOT_FOUND = "COMMAND_NOT_FOUND",
+    /**
+     * Command exceeds maximum length.
+     *
+     * Commands longer than 10,000 characters are rejected.
+     */
+    COMMAND_TOO_LONG = "COMMAND_TOO_LONG",
+    /**
+     * Command execution failed.
+     *
+     * Generic execution error (non-zero exit code, spawn failure, etc.).
+     */
+    EXECUTION_FAILED = "EXECUTION_FAILED",
+    /**
+     * Command injection detected.
+     *
+     * Command contains unsafe patterns like command chaining or substitution.
+     */
+    INJECTION_DETECTED = "INJECTION_DETECTED",
+    /**
+     * Command validation failed.
+     *
+     * Command is malformed or violates security policy.
+     */
+    INVALID_COMMAND = "INVALID_COMMAND",
+    /**
+     * Process configuration is invalid.
+     *
+     * Invalid ProcessConfig provided to constructor.
+     */
+    INVALID_CONFIG = "INVALID_CONFIG",
+    /**
+     * Failed to terminate background process.
+     *
+     * Process.kill() threw an error or process didn't stop.
+     */
+    KILL_FAILED = "KILL_FAILED",
+    /**
+     * Output buffer exceeded size limit.
+     *
+     * Background process output exceeded maxOutputBuffer bytes.
+     */
+    OUTPUT_BUFFER_FULL = "OUTPUT_BUFFER_FULL",
+    /**
+     * Permission denied executing command.
+     *
+     * System returned EACCES error.
+     */
+    PERMISSION_DENIED = "PERMISSION_DENIED",
+    /**
+     * Background process not found.
+     *
+     * Invalid or expired processId.
+     */
+    PROCESS_NOT_FOUND = "PROCESS_NOT_FOUND",
+    /**
+     * ProcessService not initialized.
+     *
+     * Must call initialize() before executing commands.
+     */
+    SERVICE_NOT_INITIALIZED = "SERVICE_NOT_INITIALIZED",
+    /**
+     * Command execution timed out.
+     *
+     * Process exceeded timeout limit and was killed.
+     */
+    TIMEOUT = "TIMEOUT",
+    /**
+     * Too many concurrent background processes.
+     *
+     * Exceeded maxConcurrentProcesses limit.
+     */
+    TOO_MANY_PROCESSES = "TOO_MANY_PROCESSES",
+    /**
+     * Working directory is invalid or unsafe.
+     *
+     * Directory doesn't exist, is outside base directory, or contains path traversal.
+     */
+    WORKING_DIRECTORY_INVALID = "WORKING_DIRECTORY_INVALID"
+}

package/dist/core/domain/cipher/errors/process-error-code.js

@@ -0,0 +1,98 @@
+/**
+ * Error codes for process execution failures.
+ *
+ * Used by ProcessError factory to create structured error objects.
+ */
+export var ProcessErrorCode;
+(function (ProcessErrorCode) {
+    /**
+     * Command matches a blocked pattern.
+     *
+     * Command is explicitly forbidden by security policy.
+     */
+    ProcessErrorCode["COMMAND_BLOCKED"] = "COMMAND_BLOCKED";
+    /**
+     * Command not found in PATH.
+     *
+     * System returned ENOENT error.
+     */
+    ProcessErrorCode["COMMAND_NOT_FOUND"] = "COMMAND_NOT_FOUND";
+    /**
+     * Command exceeds maximum length.
+     *
+     * Commands longer than 10,000 characters are rejected.
+     */
+    ProcessErrorCode["COMMAND_TOO_LONG"] = "COMMAND_TOO_LONG";
+    /**
+     * Command execution failed.
+     *
+     * Generic execution error (non-zero exit code, spawn failure, etc.).
+     */
+    ProcessErrorCode["EXECUTION_FAILED"] = "EXECUTION_FAILED";
+    /**
+     * Command injection detected.
+     *
+     * Command contains unsafe patterns like command chaining or substitution.
+     */
+    ProcessErrorCode["INJECTION_DETECTED"] = "INJECTION_DETECTED";
+    /**
+     * Command validation failed.
+     *
+     * Command is malformed or violates security policy.
+     */
+    ProcessErrorCode["INVALID_COMMAND"] = "INVALID_COMMAND";
+    /**
+     * Process configuration is invalid.
+     *
+     * Invalid ProcessConfig provided to constructor.
+     */
+    ProcessErrorCode["INVALID_CONFIG"] = "INVALID_CONFIG";
+    /**
+     * Failed to terminate background process.
+     *
+     * Process.kill() threw an error or process didn't stop.
+     */
+    ProcessErrorCode["KILL_FAILED"] = "KILL_FAILED";
+    /**
+     * Output buffer exceeded size limit.
+     *
+     * Background process output exceeded maxOutputBuffer bytes.
+     */
+    ProcessErrorCode["OUTPUT_BUFFER_FULL"] = "OUTPUT_BUFFER_FULL";
+    /**
+     * Permission denied executing command.
+     *
+     * System returned EACCES error.
+     */
+    ProcessErrorCode["PERMISSION_DENIED"] = "PERMISSION_DENIED";
+    /**
+     * Background process not found.
+     *
+     * Invalid or expired processId.
+     */
+    ProcessErrorCode["PROCESS_NOT_FOUND"] = "PROCESS_NOT_FOUND";
+    /**
+     * ProcessService not initialized.
+     *
+     * Must call initialize() before executing commands.
+     */
+    ProcessErrorCode["SERVICE_NOT_INITIALIZED"] = "SERVICE_NOT_INITIALIZED";
+    /**
+     * Command execution timed out.
+     *
+     * Process exceeded timeout limit and was killed.
+     */
+    ProcessErrorCode["TIMEOUT"] = "TIMEOUT";
+    /**
+     * Too many concurrent background processes.
+     *
+     * Exceeded maxConcurrentProcesses limit.
+     */
+    ProcessErrorCode["TOO_MANY_PROCESSES"] = "TOO_MANY_PROCESSES";
+    /**
+     * Working directory is invalid or unsafe.
+     *
+     * Directory doesn't exist, is outside base directory, or contains path traversal.
+     */
+    ProcessErrorCode["WORKING_DIRECTORY_INVALID"] = "WORKING_DIRECTORY_INVALID";
+})(ProcessErrorCode || (ProcessErrorCode = {}));

package/dist/core/domain/cipher/errors/process-error.d.ts

@@ -0,0 +1,135 @@
+import { ProcessErrorCode } from './process-error-code.js';
+/**
+ * Base error class for process execution operations.
+ *
+ * All process-specific errors extend this base class.
+ */
+export declare class ProcessError extends Error {
+    readonly code: ProcessErrorCode;
+    readonly details?: Record<string, unknown>;
+    readonly suggestion?: string;
+    /**
+     * Creates a new process error.
+     *
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization
+     * @param details - Additional error context
+     * @param suggestion - Optional recovery suggestion
+     */
+    constructor(message: string, code: ProcessErrorCode, details?: Record<string, unknown>, suggestion?: string);
+    /**
+     * Factory method: Command matches blocked pattern.
+     *
+     * @param command - Command that was blocked
+     * @param reason - Reason why command is blocked
+     * @returns ProcessError instance
+     */
+    static commandBlocked(command: string, reason: string): ProcessError;
+    /**
+     * Factory method: Command injection detected.
+     *
+     * @param command - Command with injection pattern
+     * @param pattern - Detected injection pattern
+     * @returns ProcessError instance
+     */
+    static commandInjection(command: string, pattern: string): ProcessError;
+    /**
+     * Factory method: Command not found in PATH.
+     *
+     * @param command - Command that was not found
+     * @returns ProcessError instance
+     */
+    static commandNotFound(command: string): ProcessError;
+    /**
+     * Factory method: Command exceeds maximum length.
+     *
+     * @param length - Actual command length
+     * @param maxLength - Maximum allowed length
+     * @returns ProcessError instance
+     */
+    static commandTooLong(length: number, maxLength: number): ProcessError;
+    /**
+     * Factory method: Command execution failed.
+     *
+     * @param command - Command that failed
+     * @param cause - Cause of failure
+     * @returns ProcessError instance
+     */
+    static executionFailed(command: string, cause: string): ProcessError;
+    /**
+     * Factory method: Invalid command validation.
+     *
+     * @param command - Command that failed validation
+     * @param reason - Reason for validation failure
+     * @returns ProcessError instance
+     */
+    static invalidCommand(command: string, reason: string): ProcessError;
+    /**
+     * Factory method: Invalid process configuration.
+     *
+     * @param reason - Reason why configuration is invalid
+     * @returns ProcessError instance
+     */
+    static invalidConfig(reason: string): ProcessError;
+    /**
+     * Factory method: Invalid or unsafe working directory.
+     *
+     * @param path - Working directory path that failed validation
+     * @param reason - Reason why path is invalid
+     * @returns ProcessError instance
+     */
+    static invalidWorkingDirectory(path: string, reason: string): ProcessError;
+    /**
+     * Factory method: Failed to terminate background process.
+     *
+     * @param processId - ID of process that failed to terminate
+     * @param cause - Cause of failure
+     * @returns ProcessError instance
+     */
+    static killFailed(processId: string, cause: string): ProcessError;
+    /**
+     * Factory method: ProcessService not initialized.
+     *
+     * @returns ProcessError instance
+     */
+    static notInitialized(): ProcessError;
+    /**
+     * Factory method: Output buffer exceeded size limit.
+     *
+     * @param processId - ID of process with full buffer
+     * @param size - Current buffer size
+     * @param maxSize - Maximum allowed size
+     * @returns ProcessError instance
+     */
+    static outputBufferFull(processId: string, size: number, maxSize: number): ProcessError;
+    /**
+     * Factory method: Permission denied executing command.
+     *
+     * @param command - Command that was denied
+     * @returns ProcessError instance
+     */
+    static permissionDenied(command: string): ProcessError;
+    /**
+     * Factory method: Background process not found.
+     *
+     * @param processId - ID of process that was not found
+     * @returns ProcessError instance
+     */
+    static processNotFound(processId: string): ProcessError;
+    /**
+     * Factory method: Command execution timed out.
+     *
+     * @param command - Command that timed out
+     * @param timeout - Timeout value in milliseconds
+     * @returns ProcessError instance
+     */
+    static timeout(command: string, timeout: number): ProcessError;
+    /**
+     * Factory method: Too many concurrent background processes.
+     *
+     * @param current - Current number of running processes
+     * @param max - Maximum allowed concurrent processes
+     * @returns ProcessError instance
+     */
+    static tooManyProcesses(current: number, max: number): ProcessError;
+}