byterover-cli 0.2.1 → 0.3.0

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

@@ -0,0 +1,173 @@
+import { ProcessErrorCode } from './process-error-code.js';
+/**
+ * Base error class for process execution operations.
+ *
+ * All process-specific errors extend this base class.
+ */
+export class ProcessError extends Error {
+    code;
+    details;
+    suggestion;
+    /**
+     * 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, code, details, suggestion) {
+        super(message);
+        this.name = 'ProcessError';
+        this.code = code;
+        this.details = details;
+        this.suggestion = suggestion;
+    }
+    /**
+     * 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, reason) {
+        return new ProcessError(`Command blocked by security policy: ${command}. Reason: ${reason}`, ProcessErrorCode.COMMAND_BLOCKED, { command, reason }, 'Modify the command to avoid dangerous patterns or adjust security level.');
+    }
+    /**
+     * Factory method: Command injection detected.
+     *
+     * @param command - Command with injection pattern
+     * @param pattern - Detected injection pattern
+     * @returns ProcessError instance
+     */
+    static commandInjection(command, pattern) {
+        return new ProcessError(`Command injection detected: ${command}. Pattern: ${pattern}`, ProcessErrorCode.INJECTION_DETECTED, { command, pattern }, 'Remove unsafe command chaining or substitution patterns.');
+    }
+    /**
+     * Factory method: Command not found in PATH.
+     *
+     * @param command - Command that was not found
+     * @returns ProcessError instance
+     */
+    static commandNotFound(command) {
+        const commandName = command.split(/\s+/)[0];
+        return new ProcessError(`Command not found: ${commandName}`, ProcessErrorCode.COMMAND_NOT_FOUND, { command, commandName }, `Ensure '${commandName}' is installed and available in PATH.`);
+    }
+    /**
+     * Factory method: Command exceeds maximum length.
+     *
+     * @param length - Actual command length
+     * @param maxLength - Maximum allowed length
+     * @returns ProcessError instance
+     */
+    static commandTooLong(length, maxLength) {
+        return new ProcessError(`Command exceeds maximum length: ${length} > ${maxLength}`, ProcessErrorCode.COMMAND_TOO_LONG, { length, maxLength }, `Reduce command length to ${maxLength} characters or less.`);
+    }
+    /**
+     * Factory method: Command execution failed.
+     *
+     * @param command - Command that failed
+     * @param cause - Cause of failure
+     * @returns ProcessError instance
+     */
+    static executionFailed(command, cause) {
+        return new ProcessError(`Command execution failed: ${command}. Cause: ${cause}`, ProcessErrorCode.EXECUTION_FAILED, { cause, command }, 'Check command syntax and try again.');
+    }
+    /**
+     * Factory method: Invalid command validation.
+     *
+     * @param command - Command that failed validation
+     * @param reason - Reason for validation failure
+     * @returns ProcessError instance
+     */
+    static invalidCommand(command, reason) {
+        return new ProcessError(`Invalid command: ${command}. Reason: ${reason}`, ProcessErrorCode.INVALID_COMMAND, { command, reason }, 'Ensure command is properly formatted and contains valid characters.');
+    }
+    /**
+     * Factory method: Invalid process configuration.
+     *
+     * @param reason - Reason why configuration is invalid
+     * @returns ProcessError instance
+     */
+    static invalidConfig(reason) {
+        return new ProcessError(`Invalid process configuration: ${reason}`, ProcessErrorCode.INVALID_CONFIG, { reason }, 'Review and correct ProcessConfig settings.');
+    }
+    /**
+     * 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, reason) {
+        return new ProcessError(`Invalid working directory: ${path}. Reason: ${reason}`, ProcessErrorCode.WORKING_DIRECTORY_INVALID, { path, reason }, 'Use a path within the configured base directory without ".." traversal.');
+    }
+    /**
+     * 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, cause) {
+        return new ProcessError(`Failed to kill process: ${processId}. Cause: ${cause}`, ProcessErrorCode.KILL_FAILED, { cause, processId }, 'Process may have already terminated or lacks permissions to kill.');
+    }
+    /**
+     * Factory method: ProcessService not initialized.
+     *
+     * @returns ProcessError instance
+     */
+    static notInitialized() {
+        return new ProcessError('ProcessService not initialized', ProcessErrorCode.SERVICE_NOT_INITIALIZED, undefined, 'Call initialize() before executing commands.');
+    }
+    /**
+     * 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, size, maxSize) {
+        return new ProcessError(`Output buffer full for process ${processId}: ${size} >= ${maxSize} bytes`, ProcessErrorCode.OUTPUT_BUFFER_FULL, { maxSize, processId, size }, 'Increase maxOutputBuffer in ProcessConfig or read output more frequently.');
+    }
+    /**
+     * Factory method: Permission denied executing command.
+     *
+     * @param command - Command that was denied
+     * @returns ProcessError instance
+     */
+    static permissionDenied(command) {
+        const commandName = command.split(/\s+/)[0];
+        return new ProcessError(`Permission denied: ${commandName}`, ProcessErrorCode.PERMISSION_DENIED, { command, commandName }, `Ensure you have permission to execute '${commandName}' or run with appropriate privileges.`);
+    }
+    /**
+     * Factory method: Background process not found.
+     *
+     * @param processId - ID of process that was not found
+     * @returns ProcessError instance
+     */
+    static processNotFound(processId) {
+        return new ProcessError(`Process not found: ${processId}`, ProcessErrorCode.PROCESS_NOT_FOUND, { processId }, 'Process may have completed and been cleaned up, or the ID is invalid.');
+    }
+    /**
+     * Factory method: Command execution timed out.
+     *
+     * @param command - Command that timed out
+     * @param timeout - Timeout value in milliseconds
+     * @returns ProcessError instance
+     */
+    static timeout(command, timeout) {
+        return new ProcessError(`Command timed out after ${timeout}ms: ${command}`, ProcessErrorCode.TIMEOUT, { command, timeout }, 'Increase timeout value or optimize the command to run faster.');
+    }
+    /**
+     * 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, max) {
+        return new ProcessError(`Too many concurrent processes: ${current} >= ${max}`, ProcessErrorCode.TOO_MANY_PROCESSES, { current, max }, 'Wait for existing processes to complete or increase maxConcurrentProcesses.');
+    }
+}

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

@@ -0,0 +1,56 @@
+/**
+ * Base error class for session operations.
+ * All session-specific errors extend this base class.
+ */
+export declare class SessionError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    /**
+     * Creates a new session error
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization
+     * @param details - Additional error context
+     */
+    constructor(message: string, code: string, details?: Record<string, unknown>);
+}
+/**
+ * Error thrown when tool execution loop exceeds maximum iterations.
+ */
+export declare class MaxIterationsExceededError extends SessionError {
+    /**
+     * Creates a new max iterations exceeded error
+     * @param maxIterations - Maximum iterations allowed
+     * @param sessionId - Session ID where error occurred
+     */
+    constructor(maxIterations: number, sessionId: string);
+}
+/**
+ * Error thrown when a session operation is cancelled.
+ */
+export declare class SessionCancelledError extends SessionError {
+    /**
+     * Creates a new session cancelled error
+     * @param sessionId - Session ID where cancellation occurred
+     */
+    constructor(sessionId: string);
+}
+/**
+ * Error thrown when LLM service call fails.
+ */
+export declare class LLMError extends SessionError {
+    /**
+     * Creates a new LLM error
+     * @param reason - Reason for the failure (already formatted, user-friendly message)
+     * @param sessionId - Session ID where error occurred
+     */
+    constructor(reason: string, sessionId: string);
+}
+/**
+ * Error thrown when session is not initialized.
+ */
+export declare class SessionNotInitializedError extends SessionError {
+    /**
+     * Creates a new session not initialized error
+     */
+    constructor();
+}

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

@@ -0,0 +1,74 @@
+/**
+ * Base error class for session operations.
+ * All session-specific errors extend this base class.
+ */
+export class SessionError extends Error {
+    code;
+    details;
+    /**
+     * Creates a new session error
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization
+     * @param details - Additional error context
+     */
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'SessionError';
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Error thrown when tool execution loop exceeds maximum iterations.
+ */
+export class MaxIterationsExceededError extends SessionError {
+    /**
+     * Creates a new max iterations exceeded error
+     * @param maxIterations - Maximum iterations allowed
+     * @param sessionId - Session ID where error occurred
+     */
+    constructor(maxIterations, sessionId) {
+        super(`Tool execution loop exceeded maximum iterations (${maxIterations}). This may indicate an infinite loop.`, 'MAX_ITERATIONS_EXCEEDED', { maxIterations, sessionId });
+        this.name = 'MaxIterationsExceededError';
+    }
+}
+/**
+ * Error thrown when a session operation is cancelled.
+ */
+export class SessionCancelledError extends SessionError {
+    /**
+     * Creates a new session cancelled error
+     * @param sessionId - Session ID where cancellation occurred
+     */
+    constructor(sessionId) {
+        super('Session operation was cancelled by user', 'SESSION_CANCELLED', { sessionId });
+        this.name = 'SessionCancelledError';
+    }
+}
+/**
+ * Error thrown when LLM service call fails.
+ */
+export class LLMError extends SessionError {
+    /**
+     * Creates a new LLM error
+     * @param reason - Reason for the failure (already formatted, user-friendly message)
+     * @param sessionId - Session ID where error occurred
+     */
+    constructor(reason, sessionId) {
+        // Pass reason as-is since it's already formatted with user-friendly message
+        super(reason, 'LLM_ERROR', { reason, sessionId });
+        this.name = 'LLMError';
+    }
+}
+/**
+ * Error thrown when session is not initialized.
+ */
+export class SessionNotInitializedError extends SessionError {
+    /**
+     * Creates a new session not initialized error
+     */
+    constructor() {
+        super('Session not initialized. Cannot perform operations.', 'SESSION_NOT_INITIALIZED');
+        this.name = 'SessionNotInitializedError';
+    }
+}

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

@@ -0,0 +1,57 @@
+/**
+ * Base error class for tool operations.
+ * All tool-specific errors extend this base class.
+ */
+export declare class ToolError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    /**
+     * Creates a new tool error
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization
+     * @param details - Additional error context
+     */
+    constructor(message: string, code: string, details?: Record<string, unknown>);
+}
+/**
+ * Error thrown when a tool is not found.
+ */
+export declare class ToolNotFoundError extends ToolError {
+    /**
+     * Creates a new tool not found error
+     * @param toolName - Name of the tool that was not found
+     */
+    constructor(toolName: string);
+}
+/**
+ * Error thrown when tool execution fails.
+ */
+export declare class ToolExecutionError extends ToolError {
+    /**
+     * Creates a new tool execution error
+     * @param toolName - Name of the tool that failed
+     * @param reason - Reason for the failure
+     * @param sessionId - Optional session ID
+     */
+    constructor(toolName: string, reason: string, sessionId?: string);
+}
+/**
+ * Error thrown when tool input validation fails.
+ */
+export declare class ToolValidationError extends ToolError {
+    /**
+     * Creates a new tool validation error
+     * @param toolName - Name of the tool
+     * @param validationErrors - Validation error details
+     */
+    constructor(toolName: string, validationErrors: string);
+}
+/**
+ * Error thrown when the tool provider is not initialized.
+ */
+export declare class ToolProviderNotInitializedError extends ToolError {
+    /**
+     * Creates a new tool provider not initialized error
+     */
+    constructor();
+}

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

@@ -0,0 +1,81 @@
+/**
+ * Base error class for tool operations.
+ * All tool-specific errors extend this base class.
+ */
+export class ToolError extends Error {
+    code;
+    details;
+    /**
+     * Creates a new tool error
+     * @param message - Error message describing what went wrong
+     * @param code - Error code for categorization
+     * @param details - Additional error context
+     */
+    constructor(message, code, details) {
+        super(message);
+        this.name = 'ToolError';
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Error thrown when a tool is not found.
+ */
+export class ToolNotFoundError extends ToolError {
+    /**
+     * Creates a new tool not found error
+     * @param toolName - Name of the tool that was not found
+     */
+    constructor(toolName) {
+        super(`Tool not found: ${toolName}`, 'TOOL_NOT_FOUND', { toolName });
+        this.name = 'ToolNotFoundError';
+    }
+}
+/**
+ * Error thrown when tool execution fails.
+ */
+export class ToolExecutionError extends ToolError {
+    /**
+     * Creates a new tool execution error
+     * @param toolName - Name of the tool that failed
+     * @param reason - Reason for the failure
+     * @param sessionId - Optional session ID
+     */
+    constructor(toolName, reason, sessionId) {
+        super(`Tool execution failed: ${toolName}. Reason: ${reason}`, 'TOOL_EXECUTION_FAILED', {
+            reason,
+            sessionId,
+            toolName,
+        });
+        this.name = 'ToolExecutionError';
+    }
+}
+/**
+ * Error thrown when tool input validation fails.
+ */
+export class ToolValidationError extends ToolError {
+    /**
+     * Creates a new tool validation error
+     * @param toolName - Name of the tool
+     * @param validationErrors - Validation error details
+     */
+    constructor(toolName, validationErrors) {
+        super(`Tool input validation failed: ${toolName}. ${validationErrors}`, 'TOOL_VALIDATION_FAILED', {
+            toolName,
+            validationErrors,
+        });
+        this.name = 'ToolValidationError';
+    }
+}
+/**
+ * Error thrown when the tool provider is not initialized.
+ */
+export class ToolProviderNotInitializedError extends ToolError {
+    /**
+     * Creates a new tool provider not initialized error
+     */
+    constructor() {
+        super('ToolProvider not initialized. Call initialize() before using tools', 'TOOL_PROVIDER_NOT_INITIALIZED');
+        this.name = 'ToolProviderNotInitializedError';
+    }
+}

package/dist/core/domain/cipher/file-system/types.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Buffer encoding type from Node.js
+ */
+export type BufferEncoding = 'ascii' | 'base64' | 'base64url' | 'binary' | 'hex' | 'latin1' | 'ucs2' | 'ucs-2' | 'utf8' | 'utf16le';
+/**
+ * Configuration for the file system service.
+ * Defines security policies and operational limits.
+ */
+export interface FileSystemConfig {
+    /** Whitelist of allowed base paths (relative to working directory) */
+    allowedPaths: string[];
+    /** Blacklist of forbidden file extensions (e.g., .exe, .dll) */
+    blockedExtensions: string[];
+    /** Blacklist of forbidden paths (e.g., .git, node_modules/.bin) */
+    blockedPaths: string[];
+    /** Maximum file size in bytes for read operations */
+    maxFileSize: number;
+    /** Working directory for relative path resolution */
+    workingDirectory: string;
+}
+/**
+ * Options for reading files.
+ */
+export interface ReadFileOptions {
+    /** Character encoding */
+    encoding?: BufferEncoding;
+    /** Maximum number of lines to read */
+    limit?: number;
+    /** Starting line number (1-based, like text editors) */
+    offset?: number;
+}
+/**
+ * Options for writing files.
+ */
+export interface WriteFileOptions {
+    /** Create parent directories if they don't exist */
+    createDirs?: boolean;
+    /** Character encoding */
+    encoding?: BufferEncoding;
+}
+/**
+ * Options for editing files.
+ */
+export interface EditFileOptions {
+    /** Character encoding */
+    encoding?: BufferEncoding;
+}
+/**
+ * Options for glob file discovery.
+ */
+export interface GlobOptions {
+    /** Case-sensitive pattern matching (default: true) */
+    caseSensitive?: boolean;
+    /** Working directory for glob pattern */
+    cwd?: string;
+    /** Include file metadata (size, modified date) */
+    includeMetadata?: boolean;
+    /** Maximum number of results to return */
+    maxResults?: number;
+    /** Respect .gitignore rules when matching files (default: true) */
+    respectGitignore?: boolean;
+}
+/**
+ * Options for content search.
+ */
+export interface SearchOptions {
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+    /** Case-insensitive search */
+    caseInsensitive?: boolean;
+    /** Number of context lines before/after match */
+    contextLines?: number;
+    /** Working directory for search */
+    cwd?: string;
+    /** Glob pattern to filter files (default: all files) */
+    globPattern?: string;
+    /** Maximum number of matches to return */
+    maxResults?: number;
+}
+/**
+ * Result of a file read operation.
+ */
+export interface FileContent {
+    /** File content as string */
+    content: string;
+    /** Character encoding used */
+    encoding: string;
+    /** Total number of lines in the returned content */
+    lines: number;
+    /** File size in bytes */
+    size: number;
+    /** Whether content was truncated due to size/line limits */
+    truncated: boolean;
+}
+/**
+ * Result of a file write operation.
+ */
+export interface WriteResult {
+    /** Number of bytes written */
+    bytesWritten: number;
+    /** Absolute path to the written file */
+    path: string;
+    /** Whether the write was successful */
+    success: boolean;
+}
+/**
+ * Result of a file edit operation.
+ */
+export interface EditResult {
+    /** Number of bytes written */
+    bytesWritten: number;
+    /** Absolute path to the edited file */
+    path: string;
+    /** Number of replacements made */
+    replacements: number;
+    /** Whether the edit was successful */
+    success: boolean;
+}
+/**
+ * Metadata about a file.
+ */
+export interface FileMetadata {
+    /** Whether this is a directory */
+    isDirectory: boolean;
+    /** Last modified date */
+    modified: Date;
+    /** Absolute path to the file */
+    path: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Result of a glob file discovery operation.
+ */
+export interface GlobResult {
+    /** Array of matching files with metadata */
+    files: FileMetadata[];
+    /** Number of files ignored due to .gitignore rules */
+    ignoredCount: number;
+    /** Human-readable message describing the results */
+    message?: string;
+    /** Total number of files found (before truncation) */
+    totalFound: number;
+    /** Whether results were truncated due to maxResults limit */
+    truncated: boolean;
+}
+/**
+ * A single search match with context.
+ */
+export interface SearchMatch {
+    /** Context lines before and after the match */
+    context?: {
+        /** Lines after the match */
+        after: string[];
+        /** Lines before the match */
+        before: string[];
+    };
+    /** File path where match was found */
+    file: string;
+    /** Matching line content */
+    line: string;
+    /** Line number (1-based) */
+    lineNumber: number;
+}
+/**
+ * Result of a content search operation.
+ */
+export interface SearchResult {
+    /** Number of files searched */
+    filesSearched: number;
+    /** Array of matches */
+    matches: SearchMatch[];
+    /** Total number of matches found */
+    totalMatches: number;
+    /** Whether results were truncated due to maxResults limit */
+    truncated: boolean;
+}
+/**
+ * Edit operation definition.
+ */
+export interface EditOperation {
+    /** String to replace with */
+    newString: string;
+    /** String to search for */
+    oldString: string;
+    /** Replace all occurrences (default: false, requires unique match) */
+    replaceAll?: boolean;
+}
+/**
+ * Result of path validation.
+ * Uses discriminated union for type safety.
+ */
+export type ValidationResult = {
+    /** Error message explaining why path is invalid */
+    error: string;
+    /** Path is invalid */
+    valid: false;
+} | {
+    /** Normalized absolute path */
+    normalizedPath: string;
+    /** Path is valid */
+    valid: true;
+};