byterover-cli 0.2.1 → 0.3.0

package/dist/infra/cipher/command-parser.js

@@ -0,0 +1,85 @@
+/**
+ * Command parser for interactive CLI
+ * Parses user input to distinguish between slash commands and regular prompts
+ */
+/**
+ * Parse user input into command or prompt
+ *
+ * @param input - Raw user input string
+ * @returns Parsed command result (discriminated union)
+ */
+export function parseInput(input) {
+    const trimmed = input.trim();
+    // Check if it's a slash command
+    if (trimmed.startsWith('/')) {
+        const args = parseQuotedArguments(trimmed.slice(1));
+        const command = args[0] || '';
+        const commandArgs = args.slice(1);
+        return {
+            args: commandArgs,
+            command,
+            rawInput: trimmed,
+            type: 'command',
+        };
+    }
+    // Regular user prompt
+    return {
+        rawInput: input,
+        type: 'prompt',
+    };
+}
+/**
+ * Parse command arguments with support for quoted strings
+ * Respects single and double quotes with escape sequences
+ *
+ * @param input - Command input (without leading slash)
+ * @returns Array of parsed arguments
+ */
+function parseQuotedArguments(input) {
+    const args = [];
+    let current = '';
+    let inQuote = null;
+    let escaped = false;
+    for (const char of input) {
+        if (escaped) {
+            // Handle escape sequences
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            // Start escape sequence
+            escaped = true;
+            continue;
+        }
+        if (inQuote) {
+            // Inside quoted string
+            if (char === inQuote) {
+                // End quote
+                inQuote = null;
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (char === '"' || char === "'") {
+            // Start quote
+            inQuote = char;
+        }
+        else if (char === ' ' || char === '\t') {
+            // Whitespace - end of argument
+            if (current.length > 0) {
+                args.push(current);
+                current = '';
+            }
+        }
+        else {
+            current += char;
+        }
+    }
+    // Add final argument if any
+    if (current.length > 0) {
+        args.push(current);
+    }
+    return args;
+}

package/dist/infra/cipher/display/todo-display.d.ts

@@ -0,0 +1,23 @@
+import type { Todo } from '../../../core/domain/cipher/todos/types.js';
+/**
+ * Formats a single todo item for display.
+ *
+ * @param todo - Todo item to format
+ * @param index - 1-based index of the todo
+ * @returns Formatted todo string
+ */
+export declare function formatTodoItem(todo: Todo, index: number): string;
+/**
+ * Formats the entire todo list for display.
+ *
+ * @param todos - Array of todos to format
+ * @returns Formatted todo list string
+ */
+export declare function formatTodoList(todos: Todo[]): string;
+/**
+ * Formats a compact status line for the current task.
+ *
+ * @param todos - Array of todos
+ * @returns Status line string or null if no task in progress
+ */
+export declare function formatCurrentTaskStatus(todos: Todo[]): null | string;

package/dist/infra/cipher/display/todo-display.js

@@ -0,0 +1,129 @@
+/**
+ * ANSI color codes for terminal output.
+ */
+const Colors = {
+    blue: '\u001B[34m',
+    cyan: '\u001B[36m',
+    dim: '\u001B[2m',
+    green: '\u001B[32m',
+    red: '\u001B[31m',
+    reset: '\u001B[0m',
+    yellow: '\u001B[33m',
+};
+/**
+ * Gets the status icon for a todo.
+ *
+ * @param status - Todo status
+ * @returns Colored status icon
+ */
+function getStatusIcon(status) {
+    switch (status) {
+        case 'cancelled': {
+            return `${Colors.dim}⊘${Colors.reset}`;
+        }
+        case 'completed': {
+            return `${Colors.green}✓${Colors.reset}`;
+        }
+        case 'in_progress': {
+            return `${Colors.blue}→${Colors.reset}`;
+        }
+        case 'pending': {
+            return `${Colors.dim}○${Colors.reset}`;
+        }
+    }
+}
+/**
+ * Gets the status color for a todo.
+ *
+ * @param status - Todo status
+ * @returns ANSI color code
+ */
+function getStatusColor(status) {
+    switch (status) {
+        case 'cancelled': {
+            return Colors.dim;
+        }
+        case 'completed': {
+            return Colors.green;
+        }
+        case 'in_progress': {
+            return Colors.blue;
+        }
+        case 'pending': {
+            return Colors.dim;
+        }
+    }
+}
+/**
+ * Formats a single todo item for display.
+ *
+ * @param todo - Todo item to format
+ * @param index - 1-based index of the todo
+ * @returns Formatted todo string
+ */
+export function formatTodoItem(todo, index) {
+    const icon = getStatusIcon(todo.status);
+    const color = getStatusColor(todo.status);
+    const content = todo.status === 'in_progress' ? todo.activeForm : todo.content;
+    return `${icon} ${color}${index}. ${content}${Colors.reset}`;
+}
+/**
+ * Formats the entire todo list for display.
+ *
+ * @param todos - Array of todos to format
+ * @returns Formatted todo list string
+ */
+export function formatTodoList(todos) {
+    if (todos.length === 0) {
+        return `${Colors.dim}No tasks${Colors.reset}`;
+    }
+    // Add each todo
+    const lines = todos.map((todo, i) => formatTodoItem(todo, i + 1));
+    // Add progress summary
+    const stats = getTodoStats(todos);
+    const summaryLines = ['', formatProgressBar(stats)];
+    return [...lines, ...summaryLines].join('\n');
+}
+/**
+ * Formats a compact progress bar.
+ *
+ * @param stats - Todo statistics
+ * @returns Formatted progress bar string
+ */
+function formatProgressBar(stats) {
+    const percentage = stats.total > 0 ? Math.round((stats.completed / stats.total) * 100) : 0;
+    const barWidth = 20;
+    const filled = Math.round((percentage / 100) * barWidth);
+    const empty = barWidth - filled;
+    const bar = `${Colors.green}${'█'.repeat(filled)}${Colors.dim}${'░'.repeat(empty)}${Colors.reset}`;
+    return `${bar} ${percentage}% (${stats.completed}/${stats.total})`;
+}
+/**
+ * Gets statistics about the todo list.
+ *
+ * @param todos - Array of todos
+ * @returns Statistics object
+ */
+function getTodoStats(todos) {
+    return {
+        cancelled: todos.filter((t) => t.status === 'cancelled').length,
+        completed: todos.filter((t) => t.status === 'completed').length,
+        inProgress: todos.filter((t) => t.status === 'in_progress').length,
+        pending: todos.filter((t) => t.status === 'pending').length,
+        total: todos.length,
+    };
+}
+/**
+ * Formats a compact status line for the current task.
+ *
+ * @param todos - Array of todos
+ * @returns Status line string or null if no task in progress
+ */
+export function formatCurrentTaskStatus(todos) {
+    const inProgress = todos.find((t) => t.status === 'in_progress');
+    if (!inProgress) {
+        return null;
+    }
+    const stats = getTodoStats(todos);
+    return `${Colors.blue}→${Colors.reset} ${inProgress.activeForm} ${Colors.dim}(${stats.completed + 1}/${stats.total})${Colors.reset}`;
+}

package/dist/infra/cipher/events/event-emitter.d.ts

@@ -0,0 +1,137 @@
+import { EventEmitter } from 'node:events';
+import type { AgentEventMap, SessionEventMap } from '../../../core/domain/cipher/agent-events/types.js';
+import type { EventListenerOptions, IEventEmitter } from '../../../core/interfaces/cipher/i-event-emitter.js';
+/**
+ * Base implementation of a type-safe event emitter.
+ *
+ * Extends Node.js EventEmitter with TypeScript type safety and AbortController support.
+ * This follows the pattern from Dexto's event system.
+ *
+ * Features:
+ * - Type-safe emit/on/once/off methods
+ * - AbortController integration for automatic listener cleanup
+ * - Proper handling of void payloads
+ * - WeakMap-based tracking for signal-listener associations
+ *
+ * @template TEventMap - Map of event names to their payload types
+ *
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   'data:received': { value: number };
+ *   'data:cleared': void;
+ * }
+ *
+ * class MyEventBus extends BaseTypedEventEmitter<MyEvents> {}
+ *
+ * const bus = new MyEventBus();
+ * bus.emit('data:received', { value: 42 });
+ * bus.emit('data:cleared');
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * bus.on('data:received', (data) => console.log(data.value), { signal: controller.signal });
+ * controller.abort(); // Automatically removes listener
+ * ```
+ */
+export declare class BaseTypedEventEmitter<TEventMap extends object> extends EventEmitter implements IEventEmitter<TEventMap> {
+    /**
+     * WeakMap tracking AbortSignal → Set<listener function>.
+     * Used to automatically remove listeners when signals are aborted.
+     */
+    private readonly signalListeners;
+    /**
+     * Emit an event with optional payload.
+     *
+     * @param eventName - Name of the event to emit
+     * @param payload - Event payload (omit for void events)
+     * @returns true if the event had listeners, false otherwise
+     */
+    emit<K extends keyof TEventMap>(eventName: K, ...payload: TEventMap[K] extends void ? [] : [TEventMap[K]]): boolean;
+    emit(eventName: string, ...args: never[]): boolean;
+    /**
+     * Remove an event listener.
+     *
+     * @param eventName - Name of the event
+     * @param listener - Callback function to remove
+     * @returns this (for chaining)
+     */
+    off<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void): this;
+    off(eventName: string | symbol, listener: (data?: unknown) => void): this;
+    /**
+     * Register an event listener.
+     *
+     * @param eventName - Name of the event to listen for
+     * @param listener - Callback function
+     * @param options - Optional AbortSignal for automatic cleanup
+     * @returns this (for chaining)
+     */
+    on<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: EventListenerOptions): this;
+    on(eventName: string | symbol, listener: (data?: unknown) => void): this;
+    /**
+     * Register a one-time event listener.
+     *
+     * @param eventName - Name of the event to listen for
+     * @param listener - Callback function
+     * @param options - Optional AbortSignal for automatic cleanup
+     * @returns this (for chaining)
+     */
+    once<K extends keyof TEventMap>(eventName: K, listener: TEventMap[K] extends void ? () => void : (payload: TEventMap[K]) => void, options?: EventListenerOptions): this;
+    once(eventName: string | symbol, listener: (data?: unknown) => void): this;
+    /**
+     * Setup automatic cleanup when AbortSignal fires.
+     *
+     * @param eventName - Event name
+     * @param listener - Listener function to remove
+     * @param signal - AbortSignal to watch
+     */
+    private setupAbortCleanup;
+}
+/**
+ * Event bus for agent-level events.
+ *
+ * Handles global agent events like state changes, conversation resets, etc.
+ * All events include sessionId to track which session triggered the event.
+ *
+ * @example
+ * ```typescript
+ * const agentBus = new AgentEventBus();
+ *
+ * agentBus.on('cipher:stateChanged', (payload) => {
+ *   console.log(`State changed: ${payload.field} in session ${payload.sessionId}`);
+ * });
+ *
+ * agentBus.emit('cipher:stateChanged', {
+ *   field: 'model',
+ *   newValue: 'gemini-2.5-flash',
+ *   sessionId: 'session-123'
+ * });
+ * ```
+ */
+export declare class AgentEventBus extends BaseTypedEventEmitter<AgentEventMap> {
+}
+/**
+ * Event bus for session-level events.
+ *
+ * Handles session-scoped events like LLM thinking, tool calls, responses, etc.
+ * Events do not include sessionId as they are already scoped to a specific session.
+ *
+ * Typically, these events are forwarded to the AgentEventBus with sessionId added.
+ *
+ * @example
+ * ```typescript
+ * const sessionBus = new SessionEventBus();
+ *
+ * sessionBus.on('llmservice:toolCall', (payload) => {
+ *   console.log(`Tool call: ${payload.toolName}`);
+ * });
+ *
+ * sessionBus.emit('llmservice:toolCall', {
+ *   toolName: 'read_file',
+ *   args: { filePath: '/path/to/file' },
+ *   callId: 'call-456'
+ * });
+ * ```
+ */
+export declare class SessionEventBus extends BaseTypedEventEmitter<SessionEventMap> {
+}

package/dist/infra/cipher/events/event-emitter.js

@@ -0,0 +1,158 @@
+import { EventEmitter } from 'node:events';
+/**
+ * Base implementation of a type-safe event emitter.
+ *
+ * Extends Node.js EventEmitter with TypeScript type safety and AbortController support.
+ * This follows the pattern from Dexto's event system.
+ *
+ * Features:
+ * - Type-safe emit/on/once/off methods
+ * - AbortController integration for automatic listener cleanup
+ * - Proper handling of void payloads
+ * - WeakMap-based tracking for signal-listener associations
+ *
+ * @template TEventMap - Map of event names to their payload types
+ *
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   'data:received': { value: number };
+ *   'data:cleared': void;
+ * }
+ *
+ * class MyEventBus extends BaseTypedEventEmitter<MyEvents> {}
+ *
+ * const bus = new MyEventBus();
+ * bus.emit('data:received', { value: 42 });
+ * bus.emit('data:cleared');
+ *
+ * // With AbortController
+ * const controller = new AbortController();
+ * bus.on('data:received', (data) => console.log(data.value), { signal: controller.signal });
+ * controller.abort(); // Automatically removes listener
+ * ```
+ */
+export class BaseTypedEventEmitter
+// eslint-disable-next-line unicorn/prefer-event-target
+ extends EventEmitter {
+    /**
+     * WeakMap tracking AbortSignal → Set<listener function>.
+     * Used to automatically remove listeners when signals are aborted.
+     */
+    signalListeners = new WeakMap();
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    off(eventName, listener) {
+        return super.off(eventName, listener);
+    }
+    on(eventName, listener, options) {
+        // If signal is already aborted, don't add the listener
+        if (options?.signal?.aborted) {
+            return this;
+        }
+        // Add the listener
+        super.on(eventName, listener);
+        // Handle AbortController cleanup
+        if (options?.signal) {
+            this.setupAbortCleanup(eventName, listener, options.signal);
+        }
+        return this;
+    }
+    once(eventName, listener, options) {
+        // If signal is already aborted, don't add the listener
+        if (options?.signal?.aborted) {
+            return this;
+        }
+        // Add the listener
+        super.once(eventName, listener);
+        // Handle AbortController cleanup
+        if (options?.signal) {
+            this.setupAbortCleanup(eventName, listener, options.signal);
+        }
+        return this;
+    }
+    /**
+     * Setup automatic cleanup when AbortSignal fires.
+     *
+     * @param eventName - Event name
+     * @param listener - Listener function to remove
+     * @param signal - AbortSignal to watch
+     */
+    setupAbortCleanup(eventName, listener, signal) {
+        // If already aborted, remove listener immediately
+        if (signal.aborted) {
+            super.off(eventName, listener);
+            return;
+        }
+        // Track this listener for this signal
+        let listeners = this.signalListeners.get(signal);
+        if (!listeners) {
+            listeners = new Set();
+            this.signalListeners.set(signal, listeners);
+        }
+        listeners.add(listener);
+        // Setup abort handler
+        const abortHandler = () => {
+            super.off(eventName, listener);
+            // Cleanup tracking
+            const trackedListeners = this.signalListeners.get(signal);
+            if (trackedListeners) {
+                trackedListeners.delete(listener);
+                if (trackedListeners.size === 0) {
+                    // No more listeners for this signal
+                    signal.removeEventListener('abort', abortHandler);
+                }
+            }
+        };
+        signal.addEventListener('abort', abortHandler, { once: true });
+    }
+}
+/**
+ * Event bus for agent-level events.
+ *
+ * Handles global agent events like state changes, conversation resets, etc.
+ * All events include sessionId to track which session triggered the event.
+ *
+ * @example
+ * ```typescript
+ * const agentBus = new AgentEventBus();
+ *
+ * agentBus.on('cipher:stateChanged', (payload) => {
+ *   console.log(`State changed: ${payload.field} in session ${payload.sessionId}`);
+ * });
+ *
+ * agentBus.emit('cipher:stateChanged', {
+ *   field: 'model',
+ *   newValue: 'gemini-2.5-flash',
+ *   sessionId: 'session-123'
+ * });
+ * ```
+ */
+export class AgentEventBus extends BaseTypedEventEmitter {
+}
+/**
+ * Event bus for session-level events.
+ *
+ * Handles session-scoped events like LLM thinking, tool calls, responses, etc.
+ * Events do not include sessionId as they are already scoped to a specific session.
+ *
+ * Typically, these events are forwarded to the AgentEventBus with sessionId added.
+ *
+ * @example
+ * ```typescript
+ * const sessionBus = new SessionEventBus();
+ *
+ * sessionBus.on('llmservice:toolCall', (payload) => {
+ *   console.log(`Tool call: ${payload.toolName}`);
+ * });
+ *
+ * sessionBus.emit('llmservice:toolCall', {
+ *   toolName: 'read_file',
+ *   args: { filePath: '/path/to/file' },
+ *   callId: 'call-456'
+ * });
+ * ```
+ */
+export class SessionEventBus extends BaseTypedEventEmitter {
+}

package/dist/infra/cipher/exit-codes.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Exit codes for cipher-agent command
+ *
+ * These codes follow Unix conventions and provide clear signals
+ * for scripting and automation scenarios.
+ */
+export declare const ExitCode: {
+    /**
+     * Configuration error - Invalid API key, missing model config, invalid settings
+     */
+    readonly CONFIG_ERROR: 3;
+    /**
+     * Runtime error - LLM execution failure, network issues, unexpected errors
+     */
+    readonly RUNTIME_ERROR: 1;
+    /**
+     * Success - AI response generated successfully
+     */
+    readonly SUCCESS: 0;
+    /**
+     * Validation error - Invalid input, workspace not initialized, file not found
+     */
+    readonly VALIDATION_ERROR: 2;
+};
+export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];
+/**
+ * Custom error class for exit codes with oclif integration.
+ * Extends Error to add code and oclif properties without type assertions.
+ */
+export declare class ExitError extends Error {
+    readonly code: number;
+    readonly oclif: {
+        exit: number;
+    };
+    constructor(code: ExitCode, message?: string);
+}
+/**
+ * Exit the process with the given code and optional error message
+ *
+ * @param code - Exit code to use
+ * @param message - Optional error message to write to stderr
+ * @throws {ExitError} Throws ExitError for oclif to handle (except for silent success exits)
+ */
+export declare function exitWithCode(code: ExitCode, message?: string): never;

package/dist/infra/cipher/exit-codes.js

@@ -0,0 +1,58 @@
+/**
+ * Exit codes for cipher-agent command
+ *
+ * These codes follow Unix conventions and provide clear signals
+ * for scripting and automation scenarios.
+ */
+export const ExitCode = {
+    /**
+     * Configuration error - Invalid API key, missing model config, invalid settings
+     */
+    CONFIG_ERROR: 3,
+    /**
+     * Runtime error - LLM execution failure, network issues, unexpected errors
+     */
+    RUNTIME_ERROR: 1,
+    /**
+     * Success - AI response generated successfully
+     */
+    SUCCESS: 0,
+    /**
+     * Validation error - Invalid input, workspace not initialized, file not found
+     */
+    VALIDATION_ERROR: 2,
+};
+/**
+ * Custom error class for exit codes with oclif integration.
+ * Extends Error to add code and oclif properties without type assertions.
+ */
+export class ExitError extends Error {
+    code;
+    oclif;
+    constructor(code, message) {
+        super(message ?? 'Exit');
+        this.name = 'ExitError';
+        this.code = code;
+        this.oclif = { exit: code };
+    }
+}
+/**
+ * Exit the process with the given code and optional error message
+ *
+ * @param code - Exit code to use
+ * @param message - Optional error message to write to stderr
+ * @throws {ExitError} Throws ExitError for oclif to handle (except for silent success exits)
+ */
+export function exitWithCode(code, message) {
+    if (message) {
+        process.stderr.write(`${message}\n`);
+    }
+    // For successful exits without message, exit silently via process.exit
+    // This prevents oclif from showing "Error: Exit" or similar messages
+    if (code === ExitCode.SUCCESS && !message) {
+        // eslint-disable-next-line n/no-process-exit, unicorn/no-process-exit
+        process.exit(code);
+    }
+    // Throw ExitError - no type assertions needed!
+    throw new ExitError(code, message);
+}