byterover-cli 0.2.1 → 0.3.0

package/dist/infra/cipher/session/session-event-forwarder.d.ts

@@ -0,0 +1,37 @@
+import type { AgentEventBus, SessionEventBus } from '../events/event-emitter.js';
+/**
+ * Session Event Forwarder
+ *
+ * Automatically forwards session-level events to the agent-level event bus
+ * by adding the sessionId to each event payload.
+ *
+ * This allows external listeners to subscribe to AgentEventBus and receive
+ * all events from all sessions with proper session identification.
+ *
+ * Pattern mirrors Dexto's event forwarding implementation.
+ *
+ * @example
+ * ```typescript
+ * const agentBus = new AgentEventBus();
+ * const sessionBus = new SessionEventBus();
+ *
+ * setupEventForwarding(sessionBus, agentBus, 'session-123');
+ *
+ * // Session event...
+ * sessionBus.emit('llmservice:thinking');
+ *
+ * // ...is automatically forwarded to agent bus with sessionId:
+ * // agentBus receives: { sessionId: 'session-123' }
+ * ```
+ */
+/**
+ * Setup event forwarding from SessionEventBus to AgentEventBus.
+ *
+ * Creates listeners on the session bus that automatically forward events
+ * to the agent bus with sessionId added to the payload.
+ *
+ * @param sessionEventBus - Session-scoped event bus to listen to
+ * @param agentEventBus - Agent-wide event bus to forward events to
+ * @param sessionId - Unique session identifier to add to forwarded events
+ */
+export declare function setupEventForwarding(sessionEventBus: SessionEventBus, agentEventBus: AgentEventBus, sessionId: string): void;

package/dist/infra/cipher/session/session-event-forwarder.js

@@ -0,0 +1,83 @@
+/**
+ * Session Event Forwarder
+ *
+ * Automatically forwards session-level events to the agent-level event bus
+ * by adding the sessionId to each event payload.
+ *
+ * This allows external listeners to subscribe to AgentEventBus and receive
+ * all events from all sessions with proper session identification.
+ *
+ * Pattern mirrors Dexto's event forwarding implementation.
+ *
+ * @example
+ * ```typescript
+ * const agentBus = new AgentEventBus();
+ * const sessionBus = new SessionEventBus();
+ *
+ * setupEventForwarding(sessionBus, agentBus, 'session-123');
+ *
+ * // Session event...
+ * sessionBus.emit('llmservice:thinking');
+ *
+ * // ...is automatically forwarded to agent bus with sessionId:
+ * // agentBus receives: { sessionId: 'session-123' }
+ * ```
+ */
+/**
+ * Setup event forwarding from SessionEventBus to AgentEventBus.
+ *
+ * Creates listeners on the session bus that automatically forward events
+ * to the agent bus with sessionId added to the payload.
+ *
+ * @param sessionEventBus - Session-scoped event bus to listen to
+ * @param agentEventBus - Agent-wide event bus to forward events to
+ * @param sessionId - Unique session identifier to add to forwarded events
+ */
+export function setupEventForwarding(sessionEventBus, agentEventBus, sessionId) {
+    // Forward llmservice:thinking (void payload)
+    sessionEventBus.on('llmservice:thinking', () => {
+        agentEventBus.emit('llmservice:thinking', { sessionId });
+    });
+    // Forward llmservice:chunk
+    sessionEventBus.on('llmservice:chunk', (payload) => {
+        agentEventBus.emit('llmservice:chunk', {
+            ...payload,
+            sessionId,
+        });
+    });
+    // Forward llmservice:response
+    sessionEventBus.on('llmservice:response', (payload) => {
+        agentEventBus.emit('llmservice:response', {
+            ...payload,
+            sessionId,
+        });
+    });
+    // Forward llmservice:toolCall
+    sessionEventBus.on('llmservice:toolCall', (payload) => {
+        agentEventBus.emit('llmservice:toolCall', {
+            ...payload,
+            sessionId,
+        });
+    });
+    // Forward llmservice:toolResult
+    sessionEventBus.on('llmservice:toolResult', (payload) => {
+        agentEventBus.emit('llmservice:toolResult', {
+            ...payload,
+            sessionId,
+        });
+    });
+    // Forward llmservice:error
+    sessionEventBus.on('llmservice:error', (payload) => {
+        agentEventBus.emit('llmservice:error', {
+            ...payload,
+            sessionId,
+        });
+    });
+    // Forward llmservice:unsupportedInput
+    sessionEventBus.on('llmservice:unsupportedInput', (payload) => {
+        agentEventBus.emit('llmservice:unsupportedInput', {
+            ...payload,
+            sessionId,
+        });
+    });
+}

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

@@ -0,0 +1,109 @@
+import type { CipherAgentServices, SessionManagerConfig } from '../../../core/interfaces/cipher/cipher-services.js';
+import type { IChatSession } from '../../../core/interfaces/cipher/i-chat-session.js';
+import type { ByteRoverGrpcConfig } from '../agent-service-factory.js';
+/**
+ * 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.
+ *
+ * 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 readonly config;
+    private readonly grpcConfig;
+    private readonly llmConfig;
+    private pendingCreations;
+    private readonly sessions;
+    private readonly sharedServices;
+    /**
+     * Creates a new session manager
+     *
+     * @param sharedServices - Shared services from CipherAgent (ToolManager, SystemPromptManager, etc.)
+     * @param grpcConfig - gRPC 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, grpcConfig: ByteRoverGrpcConfig, llmConfig: {
+        httpReferer?: string;
+        maxIterations?: number;
+        maxTokens?: number;
+        model: string;
+        openRouterApiKey?: string;
+        siteName?: string;
+        temperature?: number;
+    }, options?: SessionManagerOptions);
+    /**
+     * 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
+     */
+    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>;
+    /**
+     * End a session (remove from memory, preserve history for future restoration).
+     * Currently same as deleteSession since we don't have persistent storage yet.
+     *
+     * @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[];
+    /**
+     * Internal session creation logic.
+     *
+     * @param id - Session ID
+     * @returns New chat session instance
+     */
+    private createSessionInternal;
+}

package/dist/infra/cipher/session/session-manager.js

@@ -0,0 +1,172 @@
+import { randomUUID } from 'node:crypto';
+import { createSessionServices } from '../agent-service-factory.js';
+import { ChatSession } from './chat-session.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 {
+    config;
+    grpcConfig;
+    llmConfig;
+    pendingCreations = new Map();
+    sessions = new Map();
+    sharedServices;
+    /**
+     * Creates a new session manager
+     *
+     * @param sharedServices - Shared services from CipherAgent (ToolManager, SystemPromptManager, etc.)
+     * @param grpcConfig - gRPC 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, grpcConfig, llmConfig, options) {
+        this.sharedServices = sharedServices;
+        this.grpcConfig = grpcConfig;
+        this.llmConfig = llmConfig;
+        this.config = {
+            maxSessions: options?.config?.maxSessions ?? 100,
+            sessionTTL: options?.config?.sessionTTL ?? 3_600_000, // 1 hour
+        };
+    }
+    /**
+     * 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
+     */
+    async createSession(sessionId) {
+        const id = sessionId ?? randomUUID();
+        // 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.createSessionInternal(id);
+        this.pendingCreations.set(id, creationPromise);
+        try {
+            return await creationPromise;
+        }
+        finally {
+            this.pendingCreations.delete(id);
+        }
+    }
+    /**
+     * Delete a session completely (memory + history).
+     *
+     * @param id - Session ID to delete
+     * @returns True if session existed and was deleted
+     */
+    async deleteSession(id) {
+        const session = this.sessions.get(id);
+        if (!session) {
+            return false;
+        }
+        // Clear session history
+        session.reset();
+        // Remove from memory
+        return this.sessions.delete(id);
+    }
+    /**
+     * End a session (remove from memory, preserve history for future restoration).
+     * Currently same as deleteSession since we don't have persistent storage yet.
+     *
+     * @param id - Session ID to end
+     * @returns True if session existed and was ended
+     */
+    async endSession(id) {
+        const session = this.sessions.get(id);
+        if (!session) {
+            return false;
+        }
+        // In the future, this would preserve history in storage
+        // For now, just remove from memory
+        return this.sessions.delete(id);
+    }
+    /**
+     * Get a session by ID.
+     *
+     * @param id - Session ID
+     * @returns Session instance or undefined if not found
+     */
+    getSession(id) {
+        return this.sessions.get(id);
+    }
+    /**
+     * Get the number of active sessions.
+     *
+     * @returns Session count
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * Check if a session exists.
+     *
+     * @param id - Session ID to check
+     * @returns True if session exists
+     */
+    hasSession(id) {
+        return this.sessions.has(id);
+    }
+    /**
+     * List all session IDs.
+     *
+     * @returns Array of session IDs
+     */
+    listSessions() {
+        return [...this.sessions.keys()];
+    }
+    /**
+     * Internal session creation logic.
+     *
+     * @param id - Session ID
+     * @returns New chat session instance
+     */
+    async createSessionInternal(id) {
+        // Create session-specific services using factory
+        const sessionServices = createSessionServices(id, this.sharedServices, this.grpcConfig, this.llmConfig);
+        // Create session with both shared and session services
+        const session = new ChatSession(id, this.sharedServices, sessionServices);
+        // Initialize LLM service to load persisted history from blob storage
+        // Only call initialize() if the service has the method (ByteRoverLLMService has it, GeminiLLMService doesn't)
+        if ('initialize' in sessionServices.llmService && typeof sessionServices.llmService.initialize === 'function') {
+            await sessionServices.llmService.initialize();
+            // Debug logging removed for cleaner user experience
+        }
+        this.sessions.set(id, session);
+        return session;
+    }
+}

package/dist/infra/cipher/storage/blob-history-storage.d.ts

@@ -0,0 +1,76 @@
+import type { SessionMetadata } from '../../../core/domain/cipher/storage/history-types.js';
+import type { IBlobStorage } from '../../../core/interfaces/cipher/i-blob-storage.js';
+import type { IHistoryStorage } from '../../../core/interfaces/cipher/i-history-storage.js';
+import type { InternalMessage } from '../../../core/interfaces/cipher/message-types.js';
+/**
+ * Blob-based implementation of history storage.
+ *
+ * Stores conversation history as JSON blobs in the file system.
+ * Each session gets its own blob file at `.brv/blobs/session-{sessionId}.blob`.
+ *
+ * Follows the same pattern as MemoryManager for consistency.
+ */
+export declare class BlobHistoryStorage implements IHistoryStorage {
+    private readonly blobStorage;
+    private static readonly SESSION_KEY_PREFIX;
+    /**
+     * Creates a new blob history storage instance.
+     *
+     * @param blobStorage - The blob storage backend to use
+     */
+    constructor(blobStorage: IBlobStorage);
+    /**
+     * Delete all history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     */
+    deleteHistory(sessionId: string): Promise<void>;
+    /**
+     * Check if history exists for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns True if history exists
+     */
+    exists(sessionId: string): Promise<boolean>;
+    /**
+     * Get metadata for a specific session without loading full history.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Session metadata or undefined if not found
+     */
+    getSessionMetadata(sessionId: string): Promise<SessionMetadata | undefined>;
+    /**
+     * List all session IDs that have persisted history.
+     *
+     * @returns Array of session IDs
+     */
+    listSessions(): Promise<string[]>;
+    /**
+     * Load conversation history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Array of messages, or undefined if session not found
+     */
+    loadHistory(sessionId: string): Promise<InternalMessage[] | undefined>;
+    /**
+     * Save conversation history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @param messages - Array of messages to persist
+     */
+    saveHistory(sessionId: string, messages: InternalMessage[]): Promise<void>;
+    /**
+     * Extract session ID from storage key.
+     *
+     * @param key - Storage key (e.g., "session-abc123")
+     * @returns Session ID (e.g., "abc123") or undefined if invalid key
+     */
+    private extractSessionId;
+    /**
+     * Get storage key for a session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Storage key (e.g., "session-abc123")
+     */
+    private getSessionKey;
+}

package/dist/infra/cipher/storage/blob-history-storage.js

@@ -0,0 +1,178 @@
+/**
+ * Blob-based implementation of history storage.
+ *
+ * Stores conversation history as JSON blobs in the file system.
+ * Each session gets its own blob file at `.brv/blobs/session-{sessionId}.blob`.
+ *
+ * Follows the same pattern as MemoryManager for consistency.
+ */
+export class BlobHistoryStorage {
+    blobStorage;
+    static SESSION_KEY_PREFIX = 'session-';
+    /**
+     * Creates a new blob history storage instance.
+     *
+     * @param blobStorage - The blob storage backend to use
+     */
+    constructor(blobStorage) {
+        this.blobStorage = blobStorage;
+    }
+    /**
+     * Delete all history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     */
+    async deleteHistory(sessionId) {
+        const key = this.getSessionKey(sessionId);
+        try {
+            await this.blobStorage.delete(key);
+        }
+        catch (error) {
+            // Log error but don't throw - graceful degradation
+            console.error(`[BlobHistoryStorage] Failed to delete history for session ${sessionId}:`, error);
+        }
+    }
+    /**
+     * Check if history exists for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns True if history exists
+     */
+    async exists(sessionId) {
+        const key = this.getSessionKey(sessionId);
+        try {
+            return await this.blobStorage.exists(key);
+        }
+        catch (error) {
+            console.error(`[BlobHistoryStorage] Error checking existence for session ${sessionId}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Get metadata for a specific session without loading full history.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Session metadata or undefined if not found
+     */
+    async getSessionMetadata(sessionId) {
+        const key = this.getSessionKey(sessionId);
+        try {
+            const blob = await this.blobStorage.retrieve(key);
+            if (!blob) {
+                return undefined;
+            }
+            // Parse JSON content to extract metadata
+            const historyData = JSON.parse(blob.content.toString('utf8'));
+            return {
+                createdAt: historyData.createdAt,
+                lastActivity: historyData.updatedAt,
+                messageCount: historyData.messageCount,
+                sessionId: historyData.sessionId,
+                title: historyData.metadata?.title,
+            };
+        }
+        catch (error) {
+            console.error(`[BlobHistoryStorage] Failed to get metadata for session ${sessionId}:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * List all session IDs that have persisted history.
+     *
+     * @returns Array of session IDs
+     */
+    async listSessions() {
+        try {
+            const keys = await this.blobStorage.list(BlobHistoryStorage.SESSION_KEY_PREFIX);
+            // Extract session IDs from keys (remove prefix)
+            return keys.map(key => this.extractSessionId(key)).filter((id) => id !== undefined);
+        }
+        catch (error) {
+            console.error('[BlobHistoryStorage] Failed to list sessions:', error);
+            return [];
+        }
+    }
+    /**
+     * Load conversation history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Array of messages, or undefined if session not found
+     */
+    async loadHistory(sessionId) {
+        const key = this.getSessionKey(sessionId);
+        try {
+            const blob = await this.blobStorage.retrieve(key);
+            if (!blob) {
+                return undefined;
+            }
+            // Parse JSON content
+            const historyData = JSON.parse(blob.content.toString('utf8'));
+            // Removed verbose console.log for cleaner interactive UX
+            // console.log(`[BlobHistoryStorage] Loaded ${historyData.messages.length} messages for session ${sessionId}`)
+            return historyData.messages;
+        }
+        catch (error) {
+            console.error(`[BlobHistoryStorage] Failed to load history for session ${sessionId}:`, error);
+            return undefined;
+        }
+    }
+    /**
+     * Save conversation history for a specific session.
+     *
+     * @param sessionId - Unique session identifier
+     * @param messages - Array of messages to persist
+     */
+    async saveHistory(sessionId, messages) {
+        const key = this.getSessionKey(sessionId);
+        // Check if session already exists to preserve createdAt timestamp
+        const existingMetadata = await this.getSessionMetadata(sessionId);
+        // Build history data structure
+        const now = Date.now();
+        const historyData = {
+            createdAt: existingMetadata?.createdAt ?? now, // Preserve original creation time
+            messageCount: messages.length,
+            messages,
+            sessionId,
+            updatedAt: now,
+        };
+        try {
+            // Serialize to JSON with pretty-printing for inspectability
+            const content = JSON.stringify(historyData, null, 2);
+            // Store in blob storage
+            await this.blobStorage.store(key, content, {
+                contentType: 'application/json',
+                tags: {
+                    sessionId,
+                    type: 'chat-history',
+                },
+            });
+            // Removed verbose console.log for cleaner interactive UX
+            // console.log(`[BlobHistoryStorage] Saved ${messages.length} messages for session ${sessionId}`)
+        }
+        catch (error) {
+            // Log error but don't throw - graceful degradation
+            console.error(`[BlobHistoryStorage] Failed to save history for session ${sessionId}:`, error);
+        }
+    }
+    /**
+     * Extract session ID from storage key.
+     *
+     * @param key - Storage key (e.g., "session-abc123")
+     * @returns Session ID (e.g., "abc123") or undefined if invalid key
+     */
+    extractSessionId(key) {
+        if (!key.startsWith(BlobHistoryStorage.SESSION_KEY_PREFIX)) {
+            return undefined;
+        }
+        return key.slice(BlobHistoryStorage.SESSION_KEY_PREFIX.length);
+    }
+    /**
+     * Get storage key for a session.
+     *
+     * @param sessionId - Unique session identifier
+     * @returns Storage key (e.g., "session-abc123")
+     */
+    getSessionKey(sessionId) {
+        return `${BlobHistoryStorage.SESSION_KEY_PREFIX}${sessionId}`;
+    }
+}