byterover-cli 1.6.0 → 1.7.0

package/dist/agent/infra/session/chat-session.js

@@ -0,0 +1,372 @@
+import { LLMError, SessionCancelledError } from '../../core/domain/errors/session-error.js';
+import { MessageQueueService } from './message-queue.js';
+import { sessionStatusManager } from './session-status.js';
+// List of all session events that should be forwarded to agent bus
+const SESSION_EVENT_NAMES = [
+    'llmservice:thinking',
+    'llmservice:chunk',
+    'llmservice:response',
+    'llmservice:toolCall',
+    'llmservice:toolResult',
+    'llmservice:doomLoopDetected',
+    'llmservice:error',
+    'llmservice:unsupportedInput',
+    'message:queued',
+    'message:dequeued',
+    'run:complete',
+    'session:statusChanged',
+    'step:started',
+    'step:finished',
+];
+/**
+ * Chat session implementation.
+ * (LLM, EventBus) and receives shared services (ToolManager, SystemPromptManager).
+ *
+ * The LLM service handles:
+ * - Message history (via ContextManager)
+ * - Agentic loop
+ * - Tool execution
+ *
+ * This session provides:
+ * - Session isolation
+ * - Cancellation support
+ * - Event forwarding to agent bus
+ * - Proper cleanup/disposal
+ */
+export class ChatSession {
+    eventBus;
+    id;
+    /** Map of taskId -> AbortController for concurrent task cancellation */
+    activeControllers = new Map();
+    /** Fallback controller for non-task executions (interactive mode) */
+    currentController;
+    /** Fallback taskId for non-task executions - DEPRECATED: use activeControllers */
+    currentTaskId;
+    forwarders = new Map();
+    isExecuting = false;
+    llmService;
+    messageQueue;
+    sharedServices;
+    /** When true, strip taskId from forwarded events (subagent mode via emitTaskId: false) */
+    suppressTaskIdForwarding = false;
+    /**
+     * Creates a new chat session
+     *
+     * @param id - Unique session identifier
+     * @param sharedServices - Shared services from CipherAgent
+     * @param sessionServices - Session-specific services (LLM, EventBus)
+     */
+    constructor(id, sharedServices, sessionServices) {
+        this.id = id;
+        this.sharedServices = sharedServices;
+        this.eventBus = sessionServices.sessionEventBus;
+        this.llmService = sessionServices.llmService;
+        this.messageQueue = new MessageQueueService(sessionServices.sessionEventBus);
+        // Setup event forwarding from session bus to agent bus
+        this.setupEventForwarding();
+    }
+    /**
+     * Cancel the current operation or a specific task.
+     * @param taskId - Optional taskId to cancel specific task, otherwise cancels fallback controller
+     */
+    cancel(taskId) {
+        if (taskId) {
+            const controller = this.activeControllers.get(taskId);
+            if (controller) {
+                controller.abort();
+                this.activeControllers.delete(taskId);
+            }
+        }
+        else if (this.currentController) {
+            this.currentController.abort();
+        }
+    }
+    /**
+     * Cleanup session resources but preserve history for later restoration.
+     * Call this when ending a session temporarily (e.g., user navigates away).
+     * History remains in ContextManager for persistence; event listeners stay for potential reactivation.
+     */
+    cleanup() {
+        // Cancel all active task controllers
+        for (const controller of this.activeControllers.values()) {
+            controller.abort();
+        }
+        this.activeControllers.clear();
+        // Cancel fallback controller
+        if (this.currentController) {
+            this.currentController.abort();
+            this.currentController = undefined;
+        }
+        // Note: History remains in LLMService's ContextManager for persistence
+        // Event listeners remain for potential reactivation
+    }
+    /**
+     * Dispose of the session completely - remove all event listeners.
+     * Call this when permanently destroying a session.
+     * Removes event listeners to prevent memory leaks.
+     */
+    dispose() {
+        // First cleanup any in-flight operations
+        this.cleanup();
+        // Remove all event forwarders
+        for (const [eventName, forwarder] of this.forwarders.entries()) {
+            this.eventBus.off(eventName, forwarder);
+        }
+        this.forwarders.clear();
+        // Clean up session status
+        sessionStatusManager.remove(this.id);
+    }
+    /**
+     * Get the conversation history.
+     */
+    getHistory() {
+        // Get history from service's context manager
+        const contextManager = this.llmService.getContextManager();
+        const internalMessages = contextManager.getMessages();
+        // Convert to session Message format
+        return internalMessages.map((msg) => ({
+            content: typeof msg.content === 'string' ? msg.content : '',
+            role: msg.role,
+            timestamp: Date.now(), // Internal messages don't have timestamps
+            toolCallId: msg.toolCallId,
+            toolCalls: msg.toolCalls?.map((tc) => ({
+                arguments: JSON.parse(tc.function.arguments),
+                id: tc.id,
+                name: tc.function.name,
+            })),
+            toolName: msg.name,
+        }));
+    }
+    /**
+     * Get the LLM service for direct access to context manager.
+     * Useful for pre-loading conversation history in JSON input mode.
+     */
+    getLLMService() {
+        return this.llmService;
+    }
+    /**
+     * Get the number of messages in the conversation.
+     */
+    getMessageCount() {
+        const contextManager = this.llmService.getContextManager();
+        return contextManager.getMessages().length;
+    }
+    /**
+     * Reset the conversation history.
+     */
+    reset() {
+        const contextManager = this.llmService.getContextManager();
+        contextManager.clearHistory();
+        // Emit conversation reset event
+        this.sharedServices.agentEventBus.emit('cipher:conversationReset', {
+            sessionId: this.id,
+        });
+    }
+    /**
+     * Send a message and get a response.
+     * Delegates to the LLM service which handles the agentic loop.
+     * Processes any queued messages first if present.
+     *
+     * @param input - User message
+     * @param options - Execution options
+     * @param options.executionContext - Optional execution context
+     * @param options.taskId - Optional task ID for billing tracking
+     * @param options.emitTaskId - Whether to include taskId in emitted events (default: true)
+     */
+    async run(input, options) {
+        const taskId = options?.taskId;
+        const emitTaskId = options?.emitTaskId !== false;
+        const controller = new AbortController();
+        // Track controller per-task for concurrent execution support
+        if (taskId) {
+            this.activeControllers.set(taskId, controller);
+        }
+        else {
+            this.currentController = controller;
+        }
+        // Store taskId for event forwarding only if emitTaskId is true
+        this.currentTaskId = emitTaskId ? taskId : undefined;
+        // Suppress taskId in forwarded events for subagent sessions (prevents subagent
+        // events from appearing under the parent task in the TUI)
+        this.suppressTaskIdForwarding = !emitTaskId;
+        this.isExecuting = true;
+        sessionStatusManager.setBusy(this.id, this.eventBus);
+        try {
+            let finalInput = input;
+            if (!taskId) {
+                const queued = this.messageQueue.dequeueAll();
+                finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
+            }
+            const response = await this.llmService.completeTask(finalInput, {
+                executionContext: options?.executionContext,
+                signal: controller.signal,
+                taskId,
+            });
+            return response;
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                throw new SessionCancelledError(this.id);
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new LLMError(errorMessage, this.id);
+        }
+        finally {
+            if (taskId) {
+                this.activeControllers.delete(taskId);
+            }
+            else {
+                this.currentController = undefined;
+            }
+            // Clear taskId if this was the active one
+            if (this.currentTaskId === taskId) {
+                this.currentTaskId = undefined;
+            }
+            // Reset suppression flag
+            this.suppressTaskIdForwarding = false;
+            // Only mark idle if no active tasks
+            if (this.activeControllers.size === 0) {
+                this.isExecuting = false;
+                sessionStatusManager.setIdle(this.id, this.eventBus);
+            }
+        }
+    }
+    /**
+     * Send a message, queuing if the session is busy executing.
+     * If the session is idle, executes immediately via run().
+     * If the session is busy, queues the message and returns the queue position.
+     *
+     * @param input - User message content
+     * @param options - Optional execution options and attachments
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.fileData - Optional file attachment
+     * @param options.imageData - Optional image attachment
+     * @returns Response string if executed, or queue info if queued
+     */
+    async sendMessage(input, options) {
+        if (this.isExecuting) {
+            // Queue the message for later processing
+            const position = this.messageQueue.enqueue({
+                content: input,
+                fileData: options?.fileData,
+                imageData: options?.imageData,
+            });
+            return { position, queued: true };
+        }
+        // Execute immediately
+        return this.run(input, { executionContext: options?.executionContext });
+    }
+    /**
+     * Stream execution with real-time event emission.
+     * Unlike run(), this does not return a response directly - events are yielded via the agent's stream().
+     * Emits run:complete event when finished.
+     *
+     * @param input - User message
+     * @param options - Execution options with optional signal for cancellation
+     * @param options.executionContext - Optional execution context for the LLM
+     * @param options.signal - Optional AbortSignal for cancellation
+     * @param options.taskId - Optional task ID for concurrent task isolation
+     */
+    async streamRun(input, options) {
+        const startTime = Date.now();
+        const taskId = options?.taskId;
+        const controller = new AbortController();
+        let finishReason = 'stop';
+        let error;
+        // Track controller per-task for concurrent execution support
+        if (taskId) {
+            this.activeControllers.set(taskId, controller);
+        }
+        else {
+            this.currentController = controller;
+        }
+        // Store taskId for event forwarding (last-write-wins for concurrent tasks)
+        this.currentTaskId = taskId;
+        this.isExecuting = true;
+        sessionStatusManager.setBusy(this.id, this.eventBus);
+        // Link external signal if provided
+        if (options?.signal) {
+            options.signal.addEventListener('abort', () => controller.abort(), { once: true });
+        }
+        try {
+            let finalInput = input;
+            if (!taskId) {
+                const queued = this.messageQueue.dequeueAll();
+                finalInput = queued ? `${queued.content}\n\nAlso: ${input}` : input;
+            }
+            await this.llmService.completeTask(finalInput, {
+                executionContext: options?.executionContext,
+                signal: controller.signal,
+                stream: true,
+                taskId,
+            });
+        }
+        catch (error_) {
+            if (controller.signal.aborted) {
+                finishReason = 'cancelled';
+            }
+            else {
+                finishReason = 'error';
+                error = error_ instanceof Error ? error_ : new Error(String(error_));
+            }
+        }
+        finally {
+            if (taskId) {
+                this.activeControllers.delete(taskId);
+            }
+            else {
+                this.currentController = undefined;
+            }
+            // Clear taskId if this was the active one
+            if (this.currentTaskId === taskId) {
+                this.currentTaskId = undefined;
+            }
+            // Only mark idle if no active tasks
+            if (this.activeControllers.size === 0) {
+                this.isExecuting = false;
+                sessionStatusManager.setIdle(this.id, this.eventBus);
+            }
+            // Emit run:complete event with taskId
+            const durationMs = Date.now() - startTime;
+            this.eventBus.emit('run:complete', {
+                durationMs,
+                error,
+                finishReason,
+                stepCount: 0,
+                ...(taskId && { taskId }),
+            });
+        }
+    }
+    /**
+     * Setup automatic event forwarding from SessionEventBus to AgentEventBus.
+     * All session events are forwarded with sessionId and taskId added to the payload.
+     *
+     * Note: taskId is preserved from the event payload if present (for concurrent task isolation).
+     * Falls back to this.currentTaskId for backward compatibility with events that don't include taskId.
+     */
+    setupEventForwarding() {
+        for (const eventName of SESSION_EVENT_NAMES) {
+            const forwarder = (payload) => {
+                // Add sessionId and taskId to payload
+                const basePayload = payload && typeof payload === 'object' ? payload : {};
+                // When suppressTaskIdForwarding is true (subagent mode), strip taskId from
+                // forwarded events so they don't appear under the parent task in the TUI
+                const payloadTaskId = basePayload.taskId;
+                const effectiveTaskId = this.suppressTaskIdForwarding
+                    ? undefined
+                    : (payloadTaskId ?? this.currentTaskId);
+                const payloadWithSession = {
+                    ...basePayload,
+                    sessionId: this.id,
+                    ...(effectiveTaskId && { taskId: effectiveTaskId }),
+                };
+                // Forward to agent bus - eventName is properly typed from SESSION_EVENT_NAMES
+                this.sharedServices.agentEventBus.emit(eventName, payloadWithSession);
+            };
+            // Track forwarder for cleanup
+            this.forwarders.set(eventName, forwarder);
+            // Register listener on session bus - eventName is properly typed from SESSION_EVENT_NAMES
+            this.eventBus.on(eventName, forwarder);
+        }
+    }
+}

package/dist/agent/infra/session/index.d.ts

@@ -0,0 +1,7 @@
+export { LLMError, MaxIterationsExceededError, SessionCancelledError, SessionError, SessionNotInitializedError, } from '../../core/domain/errors/session-error.js';
+export type { LLMResponse, Message, MessageRole, SessionConfig, ToolCall } from '../../core/domain/session/types.js';
+export type { IChatSession } from '../../core/interfaces/i-chat-session.js';
+export type { ILLMService } from '../../core/interfaces/i-llm-service.js';
+export { ChatSession } from './chat-session.js';
+export { SessionManager } from './session-manager.js';
+export { SessionStatusManager, sessionStatusManager } from './session-status.js';

package/dist/agent/infra/session/index.js

@@ -0,0 +1,7 @@
+// Session errors
+export { LLMError, MaxIterationsExceededError, SessionCancelledError, SessionError, SessionNotInitializedError, } from '../../core/domain/errors/session-error.js';
+export { ChatSession } from './chat-session.js';
+// Session manager
+export { SessionManager } from './session-manager.js';
+// Session status
+export { SessionStatusManager, sessionStatusManager } from './session-status.js';

package/dist/agent/infra/session/session-manager.d.ts

@@ -0,0 +1,210 @@
+import type { CipherAgentServices, SessionManagerConfig } from '../../core/interfaces/cipher-services.js';
+import type { IChatSession } from '../../core/interfaces/i-chat-session.js';
+import type { FileSystemService } from '../file-system/file-system-service.js';
+import { type ByteRoverHttpConfig } from '../agent/service-initializer.js';
+/**
+ * Service overrides for creating sessions with custom services.
+ * Used to create restricted sessions (e.g., context-tree only search).
+ */
+export interface SessionServiceOverrides {
+    /**
+     * Custom file system service to use for this session.
+     * If provided, a new ToolProvider and ToolManager will be created
+     * using this file system service instead of the shared one.
+     */
+    fileSystemService?: FileSystemService;
+}
+/**
+ * Metadata about a session for listing purposes.
+ */
+export interface SessionMetadata {
+    /** Name of the agent running this session (e.g., 'plan', 'query', 'curate') */
+    agentName?: string;
+    createdAt: number;
+    id: string;
+    lastActivity: number;
+    messageCount: number;
+    /** Parent session ID for subagent sessions */
+    parentId?: string;
+    title?: string;
+}
+/**
+ * Options for SessionManager constructor
+ */
+export interface SessionManagerOptions {
+    config?: SessionManagerConfig;
+}
+/**
+ * Session manager.
+ *
+ * Manages multiple chat sessions with creation, retrieval, and deletion.
+ * Each session gets its own LLM service instance with isolated context.
+ * and creates session-specific services (LLM, EventBus) per conversation.
+ */
+export declare class SessionManager {
+    private cleanupTimer?;
+    private readonly config;
+    private readonly httpConfig;
+    private readonly llmConfig;
+    private pendingCreations;
+    /** Agent name for each session (e.g., 'plan', 'query', 'curate') */
+    private readonly sessionAgentNames;
+    private readonly sessionCreatedAt;
+    private readonly sessionLastActivity;
+    /** Parent session ID for subagent sessions */
+    private readonly sessionParentIds;
+    private readonly sessions;
+    private readonly sessionTitles;
+    private readonly sharedServices;
+    /**
+     * Creates a new session manager
+     *
+     * @param sharedServices - Shared services from CipherAgent (ToolManager, SystemPromptManager, etc.)
+     * @param httpConfig - HTTP client configuration
+     * @param llmConfig - LLM service configuration
+     * @param llmConfig.openRouterApiKey - Optional OpenRouter API key for direct service
+     * @param llmConfig.httpReferer - Optional HTTP Referer for OpenRouter rankings
+     * @param llmConfig.siteName - Optional site name for OpenRouter rankings
+     * @param llmConfig.maxIterations - Maximum iterations for agentic loop
+     * @param llmConfig.maxTokens - Maximum output tokens
+     * @param llmConfig.model - LLM model identifier
+     * @param llmConfig.temperature - Temperature for generation
+     * @param options - Optional session manager options
+     * @param options.config - Session manager configuration
+     */
+    constructor(sharedServices: CipherAgentServices, httpConfig: ByteRoverHttpConfig, llmConfig: {
+        httpReferer?: string;
+        maxIterations?: number;
+        maxTokens?: number;
+        model: string;
+        openRouterApiKey?: string;
+        siteName?: string;
+        temperature?: number;
+    }, options?: SessionManagerOptions);
+    /**
+     * Create a child session for a subagent.
+     * Child sessions are linked to their parent and have an agent name.
+     *
+     * @param parentId - Parent session ID
+     * @param agentName - Name of the agent (e.g., 'query', 'curate')
+     * @param sessionId - Optional session ID (generates one if not provided)
+     * @returns New child chat session instance
+     */
+    createChildSession(parentId: string, agentName: string, sessionId?: string): Promise<IChatSession>;
+    /**
+     * Create a child session for a subagent with custom service overrides.
+     * This is used to create sessions with restricted file system access
+     * (e.g., context-tree only search for query commands).
+     *
+     * @param parentId - Parent session ID
+     * @param agentName - Name of the agent (e.g., 'explore', 'curate')
+     * @param sessionId - Optional session ID (generates one if not provided)
+     * @param overrides - Service overrides (e.g., restricted FileSystemService)
+     * @returns New child chat session instance with overridden services
+     */
+    createChildSessionWithOverrides(parentId: string, agentName: string, sessionId?: string, overrides?: SessionServiceOverrides): Promise<IChatSession>;
+    /**
+     * Create a new chat session.
+     *
+     * Each session gets its own LLM service instance for isolated conversation context.
+     *
+     * @param sessionId - Optional session ID (generates UUID if not provided)
+     * @returns New or existing chat session instance
+     */
+    createSession(sessionId?: string): Promise<IChatSession>;
+    /**
+     * Delete a session completely (memory + history).
+     *
+     * @param id - Session ID to delete
+     * @returns True if session existed and was deleted
+     */
+    deleteSession(id: string): Promise<boolean>;
+    /**
+     * Stop cleanup timer and dispose of all resources.
+     * Call this when shutting down the session manager.
+     *
+     * IMPORTANT: This method now properly disposes all sessions to prevent
+     * memory leaks from event forwarders and other session resources.
+     */
+    dispose(): void;
+    /**
+     * End a session (remove from memory, preserve history for future restoration).
+     * Unlike deleteSession, this preserves the conversation history in storage
+     * so the session can be restored later.
+     *
+     * @param id - Session ID to end
+     * @returns True if session existed and was ended
+     */
+    endSession(id: string): Promise<boolean>;
+    /**
+     * Get a session by ID.
+     *
+     * @param id - Session ID
+     * @returns Session instance or undefined if not found
+     */
+    getSession(id: string): IChatSession | undefined;
+    /**
+     * Get the number of active sessions.
+     *
+     * @returns Session count
+     */
+    getSessionCount(): number;
+    /**
+     * Check if a session exists.
+     *
+     * @param id - Session ID to check
+     * @returns True if session exists
+     */
+    hasSession(id: string): boolean;
+    /**
+     * List all session IDs.
+     *
+     * @returns Array of session IDs
+     */
+    listSessions(): string[];
+    /**
+     * List all sessions with metadata.
+     * Returns sessions sorted by last activity (most recent first).
+     *
+     * @returns Array of session metadata
+     */
+    listSessionsWithMetadata(): SessionMetadata[];
+    /**
+     * Set session title from the first user message.
+     * Uses heuristic extraction (no LLM call).
+     *
+     * @param sessionId - Session ID
+     * @param firstMessage - First user message
+     */
+    setSessionTitleFromMessage(sessionId: string, firstMessage: string): void;
+    /**
+     * Update the last activity timestamp for a session.
+     * Should be called after each message exchange.
+     *
+     * @param sessionId - Session ID
+     */
+    updateSessionActivity(sessionId: string): void;
+    /**
+     * Remove sessions that have exceeded TTL.
+     *
+     * @returns Number of sessions cleaned up
+     */
+    private cleanupExpiredSessions;
+    /**
+     * Internal session creation logic.
+     *
+     * @param id - Session ID
+     * @returns New chat session instance
+     */
+    private createSessionInternal;
+    /**
+     * Internal session creation with service overrides.
+     * Creates a new ToolProvider and ToolManager with the overridden FileSystemService
+     * to provide file access restrictions for the session.
+     *
+     * @param id - Session ID
+     * @param overrides - Service overrides (e.g., restricted FileSystemService)
+     * @returns New chat session instance with overridden services
+     */
+    private createSessionWithOverridesInternal;
+}

package/dist/agent/infra/session/session-metadata-store.d.ts

@@ -0,0 +1,52 @@
+/**
+ * SessionMetadataStore - Manages session metadata persistence.
+ *
+ * Stores session metadata in .brv/sessions/ directory:
+ * - active.json: Current active session pointer
+ * - session-*.json: Individual session metadata files
+ *
+ * Design adapted from gemini-cli's ChatRecordingService pattern.
+ */
+import type { ISessionPersistence, SessionCleanupResult, SessionRetentionConfig } from '../../core/interfaces/i-session-persistence.js';
+import { type ActiveSessionPointer, type SessionInfo, type SessionMetadata } from '../../core/domain/session/session-metadata.js';
+/**
+ * SessionMetadataStore implementation.
+ *
+ * Manages session metadata stored in .brv/sessions/ directory.
+ */
+export declare class SessionMetadataStore implements ISessionPersistence {
+    private readonly activeSessionPath;
+    private readonly sessionsDir;
+    private readonly workingDirectory;
+    /**
+     * Create a new SessionMetadataStore.
+     *
+     * @param workingDirectory - Project working directory (defaults to process.cwd())
+     */
+    constructor(workingDirectory?: string);
+    cleanupSessions(config: SessionRetentionConfig): Promise<SessionCleanupResult>;
+    clearActiveSession(): Promise<void>;
+    /**
+     * Create a new session metadata object.
+     *
+     * @param sessionId - Session ID
+     * @returns New session metadata with defaults
+     */
+    createSessionMetadata(sessionId: string): SessionMetadata;
+    deleteSession(sessionId: string): Promise<boolean>;
+    getActiveSession(): Promise<ActiveSessionPointer | null>;
+    getSession(sessionId: string): Promise<null | SessionMetadata>;
+    isActiveSessionStale(): Promise<boolean>;
+    isSessionForCurrentProject(sessionId: string): Promise<boolean>;
+    listSessions(): Promise<SessionInfo[]>;
+    markSessionEnded(sessionId: string): Promise<void>;
+    markSessionInterrupted(sessionId: string): Promise<void>;
+    saveSession(metadata: SessionMetadata): Promise<void>;
+    setActiveSession(sessionId: string): Promise<void>;
+    setSessionTitle(sessionId: string, title: string): Promise<void>;
+    updateSessionActivity(sessionId: string, messageCount: number): Promise<void>;
+    /**
+     * Ensure the sessions directory exists.
+     */
+    private ensureSessionsDir;
+}