byterover-cli 0.4.0 → 1.0.0

package/dist/infra/cipher/session/message-queue.js

@@ -0,0 +1,90 @@
+import { randomUUID } from 'node:crypto';
+/**
+ * Service for buffering user messages when a session is busy executing.
+ *
+ * When the LLM is processing a request, new messages from the user are
+ * queued and coalesced into a single input when the session becomes available.
+ *
+ * This improves UX by allowing users to add context while waiting for responses.
+ */
+export class MessageQueueService {
+    eventBus;
+    queue = [];
+    /**
+     * Creates a new message queue service.
+     *
+     * @param eventBus - Optional session event bus for queue events
+     */
+    constructor(eventBus) {
+        this.eventBus = eventBus;
+    }
+    /**
+     * Clear all queued messages without processing.
+     */
+    clear() {
+        this.queue.length = 0;
+    }
+    /**
+     * Dequeue all messages and coalesce into single input.
+     * Messages are combined intelligently based on count.
+     *
+     * @returns Coalesced content with images/files, or null if queue is empty
+     */
+    dequeueAll() {
+        if (this.queue.length === 0) {
+            return null;
+        }
+        const messages = [...this.queue];
+        this.queue.length = 0;
+        this.eventBus?.emit('message:dequeued', { count: messages.length });
+        // Collect all attachments
+        const images = [];
+        const files = [];
+        for (const msg of messages) {
+            if (msg.imageData)
+                images.push(msg.imageData);
+            if (msg.fileData)
+                files.push(msg.fileData);
+        }
+        // Coalesce message content based on count
+        let content;
+        if (messages.length === 1) {
+            content = messages[0].content;
+        }
+        else if (messages.length === 2) {
+            content = `First: ${messages[0].content}\n\nAlso: ${messages[1].content}`;
+        }
+        else {
+            content = messages.map((m, i) => `[${i + 1}]: ${m.content}`).join('\n\n');
+        }
+        return { content, files, images };
+    }
+    /**
+     * Queue a message for later processing.
+     *
+     * @param message - Message to queue (without id and queuedAt)
+     * @returns Queue position (1-based)
+     */
+    enqueue(message) {
+        const queued = {
+            ...message,
+            id: randomUUID(),
+            queuedAt: Date.now(),
+        };
+        this.queue.push(queued);
+        this.eventBus?.emit('message:queued', { message: queued, position: this.queue.length });
+        return this.queue.length;
+    }
+    /**
+     * Check if there are pending messages in the queue.
+     */
+    hasPending() {
+        return this.queue.length > 0;
+    }
+    /**
+     * Get the number of pending messages.
+     */
+    pendingCount() {
+        return this.queue.length;
+    }
+}

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

@@ -1,6 +1,33 @@
 import type { CipherAgentServices, SessionManagerConfig } from '../../../core/interfaces/cipher/cipher-services.js';
 import type { IChatSession } from '../../../core/interfaces/cipher/i-chat-session.js';
-import type { ByteRoverHttpConfig } from '../agent-service-factory.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
  */
@@ -12,16 +39,22 @@ export interface SessionManagerOptions {
  *
  * Manages multiple chat sessions with creation, retrieval, and deletion.
  * Each session gets its own LLM service instance with isolated context.
- *
- * Following Dexto's pattern: SessionManager uses shared services from the agent
  * 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
@@ -48,11 +81,32 @@ export declare class SessionManager {
         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.
-     * Following Dexto's pattern with race condition protection via pendingCreations tracker.
      *
      * @param sessionId - Optional session ID (generates UUID if not provided)
      * @returns New or existing chat session instance
@@ -65,9 +119,18 @@ export declare class SessionManager {
      * @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).
-     * Currently same as deleteSession since we don't have persistent storage yet.
+     * 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
@@ -99,6 +162,34 @@ export declare class SessionManager {
      * @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.
      *
@@ -106,4 +197,14 @@ export declare class SessionManager {
      * @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/infra/cipher/session/session-manager.js

@@ -1,21 +1,33 @@
 import { randomUUID } from 'node:crypto';
-import { createSessionServices } from '../agent-service-factory.js';
+import { createSessionServices } from '../agent/service-initializer.js';
+import { CoreToolScheduler } from '../tools/core-tool-scheduler.js';
+import { DEFAULT_POLICY_RULES } from '../tools/default-policy-rules.js';
+import { PolicyEngine } from '../tools/policy-engine.js';
+import { ToolManager } from '../tools/tool-manager.js';
+import { ToolProvider } from '../tools/tool-provider.js';
 import { ChatSession } from './chat-session.js';
+import { generateSessionTitle } from './title-generator.js';
 /**
  * Session manager.
  *
  * Manages multiple chat sessions with creation, retrieval, and deletion.
  * Each session gets its own LLM service instance with isolated context.
- *
- * Following Dexto's pattern: SessionManager uses shared services from the agent
  * and creates session-specific services (LLM, EventBus) per conversation.
  */
 export class SessionManager {
+    cleanupTimer;
     config;
     httpConfig;
     llmConfig;
     pendingCreations = new Map();
+    /** Agent name for each session (e.g., 'plan', 'query', 'curate') */
+    sessionAgentNames = new Map();
+    sessionCreatedAt = new Map();
+    sessionLastActivity = new Map();
+    /** Parent session ID for subagent sessions */
+    sessionParentIds = new Map();
     sessions = new Map();
+    sessionTitles = new Map();
     sharedServices;
     /**
      * Creates a new session manager
@@ -41,12 +53,89 @@ export class SessionManager {
             maxSessions: options?.config?.maxSessions ?? 100,
             sessionTTL: options?.config?.sessionTTL ?? 3_600_000, // 1 hour
         };
+        // Start periodic cleanup (every 15 minutes or 1/4 TTL, whichever is smaller)
+        const cleanupInterval = Math.min(15 * 60 * 1000, this.config.sessionTTL / 4);
+        this.cleanupTimer = setInterval(() => {
+            this.cleanupExpiredSessions().catch(() => {
+                // Silently ignore cleanup errors
+            });
+        }, cleanupInterval);
+    }
+    /**
+     * 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
+     */
+    async createChildSession(parentId, agentName, sessionId) {
+        // Generate session ID if not provided
+        const id = sessionId ?? `${agentName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        // Create the session using normal flow
+        const session = await this.createSession(id);
+        // Track parent-child relationship and agent name
+        this.sessionParentIds.set(id, parentId);
+        this.sessionAgentNames.set(id, agentName);
+        return session;
+    }
+    /**
+     * 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
+     */
+    async createChildSessionWithOverrides(parentId, agentName, sessionId, overrides) {
+        // If no overrides, use the standard createChildSession
+        if (!overrides?.fileSystemService) {
+            return this.createChildSession(parentId, agentName, sessionId);
+        }
+        // Generate session ID if not provided
+        const id = sessionId ?? `${agentName}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        // Check pending operations (race condition protection)
+        if (this.pendingCreations.has(id)) {
+            const pending = this.pendingCreations.get(id);
+            if (!pending) {
+                throw new Error(`Pending session ${id} not found. This is a bug.`);
+            }
+            return pending;
+        }
+        // Check in-memory cache
+        if (this.sessions.has(id)) {
+            const existing = this.sessions.get(id);
+            if (!existing) {
+                throw new Error(`Session ${id} not found in cache. This is a bug.`);
+            }
+            return existing;
+        }
+        // Check max sessions limit
+        if (this.sessions.size >= this.config.maxSessions) {
+            throw new Error(`Maximum sessions (${this.config.maxSessions}) reached. Delete unused sessions or increase maxSessions limit.`);
+        }
+        // Create with pending tracker
+        const creationPromise = this.createSessionWithOverridesInternal(id, overrides);
+        this.pendingCreations.set(id, creationPromise);
+        try {
+            const session = await creationPromise;
+            // Track parent-child relationship and agent name
+            this.sessionParentIds.set(id, parentId);
+            this.sessionAgentNames.set(id, agentName);
+            return session;
+        }
+        finally {
+            this.pendingCreations.delete(id);
+        }
     }
     /**
      * Create a new chat session.
      *
      * Each session gets its own LLM service instance for isolated conversation context.
-     * Following Dexto's pattern with race condition protection via pendingCreations tracker.
      *
      * @param sessionId - Optional session ID (generates UUID if not provided)
      * @returns New or existing chat session instance
@@ -99,9 +188,38 @@ export class SessionManager {
         // Remove from memory
         return this.sessions.delete(id);
     }
+    /**
+     * 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() {
+        // Clear cleanup timer
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = undefined;
+        }
+        // Dispose all sessions (prevents event forwarder leaks)
+        for (const session of this.sessions.values()) {
+            // ChatSession.dispose() removes event forwarders
+            ;
+            session.dispose();
+        }
+        this.sessions.clear();
+        // Clear all metadata maps
+        this.sessionCreatedAt.clear();
+        this.sessionLastActivity.clear();
+        this.sessionTitles.clear();
+        this.sessionAgentNames.clear();
+        this.sessionParentIds.clear();
+        this.pendingCreations.clear();
+    }
     /**
      * End a session (remove from memory, preserve history for future restoration).
-     * Currently same as deleteSession since we don't have persistent storage yet.
+     * 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
@@ -111,8 +229,12 @@ export class SessionManager {
         if (!session) {
             return false;
         }
-        // In the future, this would preserve history in storage
-        // For now, just remove from memory
+        // Ensure history is persisted before removing from memory
+        const contextManager = session.getLLMService().getContextManager();
+        await contextManager.flush();
+        // Cleanup session resources (cancels in-flight ops, preserves history)
+        session.cleanup();
+        // Remove from memory only - history remains in storage
         return this.sessions.delete(id);
     }
     /**
@@ -149,6 +271,73 @@ export class SessionManager {
     listSessions() {
         return [...this.sessions.keys()];
     }
+    /**
+     * List all sessions with metadata.
+     * Returns sessions sorted by last activity (most recent first).
+     *
+     * @returns Array of session metadata
+     */
+    listSessionsWithMetadata() {
+        const sessions = [];
+        for (const [id, session] of this.sessions) {
+            const contextManager = session.getLLMService().getContextManager();
+            sessions.push({
+                agentName: this.sessionAgentNames.get(id),
+                createdAt: this.sessionCreatedAt.get(id) ?? Date.now(),
+                id,
+                lastActivity: this.sessionLastActivity.get(id) ?? Date.now(),
+                messageCount: contextManager.getMessages().length,
+                parentId: this.sessionParentIds.get(id),
+                title: this.sessionTitles.get(id),
+            });
+        }
+        // Sort by last activity (most recent first)
+        return sessions.sort((a, b) => b.lastActivity - a.lastActivity);
+    }
+    /**
+     * 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, firstMessage) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        const title = generateSessionTitle(firstMessage);
+        this.sessionTitles.set(sessionId, title);
+    }
+    /**
+     * Update the last activity timestamp for a session.
+     * Should be called after each message exchange.
+     *
+     * @param sessionId - Session ID
+     */
+    updateSessionActivity(sessionId) {
+        if (this.sessions.has(sessionId)) {
+            this.sessionLastActivity.set(sessionId, Date.now());
+        }
+    }
+    /**
+     * Remove sessions that have exceeded TTL.
+     *
+     * @returns Number of sessions cleaned up
+     */
+    async cleanupExpiredSessions() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [id] of this.sessions) {
+            const lastActivity = this.sessionLastActivity.get(id) ?? 0;
+            if (now - lastActivity > this.config.sessionTTL) {
+                // eslint-disable-next-line no-await-in-loop
+                await this.endSession(id); // Preserve history
+                cleaned++;
+            }
+        }
+        return cleaned;
+    }
     /**
      * Internal session creation logic.
      *
@@ -166,6 +355,64 @@ export class SessionManager {
             await sessionServices.llmService.initialize();
             // Debug logging removed for cleaner user experience
         }
+        // Track session metadata
+        const now = Date.now();
+        this.sessionCreatedAt.set(id, now);
+        this.sessionLastActivity.set(id, now);
+        this.sessions.set(id, session);
+        return session;
+    }
+    /**
+     * 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
+     */
+    async createSessionWithOverridesInternal(id, overrides) {
+        // Create a holder object to allow self-reference in the getToolProvider callback
+        const toolProviderHolder = {};
+        // Create a new ToolProvider with the overridden FileSystemService
+        const overriddenToolProvider = new ToolProvider({
+            fileSystemService: overrides.fileSystemService,
+            getToolProvider: () => toolProviderHolder.provider,
+            memoryManager: this.sharedServices.memoryManager,
+            processService: this.sharedServices.processService,
+        }, this.sharedServices.systemPromptManager);
+        toolProviderHolder.provider = overriddenToolProvider;
+        await overriddenToolProvider.initialize();
+        // Create a new PolicyEngine and ToolScheduler for the overridden session
+        const overriddenPolicyEngine = new PolicyEngine({ defaultDecision: 'ALLOW' });
+        overriddenPolicyEngine.addRules(DEFAULT_POLICY_RULES);
+        const overriddenToolScheduler = new CoreToolScheduler(overriddenToolProvider, overriddenPolicyEngine, undefined, {
+            verbose: false,
+        });
+        // Create a new ToolManager with the overridden ToolProvider
+        const overriddenToolManager = new ToolManager(overriddenToolProvider, overriddenToolScheduler);
+        await overriddenToolManager.initialize();
+        // Create overridden shared services with the new tool stack
+        const overriddenSharedServices = {
+            ...this.sharedServices,
+            fileSystemService: overrides.fileSystemService,
+            policyEngine: overriddenPolicyEngine,
+            toolManager: overriddenToolManager,
+            toolProvider: overriddenToolProvider,
+            toolScheduler: overriddenToolScheduler,
+        };
+        // Create session-specific services using the overridden shared services
+        const sessionServices = createSessionServices(id, overriddenSharedServices, this.httpConfig, this.llmConfig);
+        // Create session with overridden shared services
+        const session = new ChatSession(id, overriddenSharedServices, sessionServices);
+        // Initialize LLM service to load persisted history from blob storage
+        if ('initialize' in sessionServices.llmService && typeof sessionServices.llmService.initialize === 'function') {
+            await sessionServices.llmService.initialize();
+        }
+        // Track session metadata
+        const now = Date.now();
+        this.sessionCreatedAt.set(id, now);
+        this.sessionLastActivity.set(id, now);
         this.sessions.set(id, session);
         return session;
     }