byterover-cli 0.4.0 → 1.0.0

package/dist/infra/cipher/interactive-loop.js

@@ -92,54 +92,47 @@ export function displayInfo(message, clear = false) {
 }
 /**
  * Setup event listeners for spinner and error handling
+ * @returns Cleanup function to remove all listeners (prevents memory leaks)
  */
 function setupEventListeners(eventBus, spinnerState) {
     const { frames: spinnerFrames, indexRef: spinnerIndexRef, isExecutingRef, ref: spinnerRef } = spinnerState;
-    // Thinking event - start spinner
-    eventBus.on('llmservice:thinking', () => {
-        // Only start spinner if currently executing and not already running
+    // Store listener references for cleanup
+    const thinkingListener = () => {
         if (isExecutingRef.value && !spinnerRef.current) {
-            // Start animated spinner
             spinnerRef.current = setInterval(() => {
                 clearTerminalLine();
                 process.stdout.write(chalk.gray(`💭 Agent thinking ${spinnerFrames[spinnerIndexRef.value]}`));
                 spinnerIndexRef.value = (spinnerIndexRef.value + 1) % spinnerFrames.length;
             }, 80);
         }
-    });
-    // Response event - clear spinner
-    eventBus.on('llmservice:response', () => {
+    };
+    const responseListener = () => {
         if (spinnerRef.current) {
             clearInterval(spinnerRef.current);
             spinnerRef.current = null;
             clearTerminalLine();
         }
-    });
-    // Tool call event - clear spinner before tool execution
-    eventBus.on('llmservice:toolCall', () => {
+    };
+    const toolCallListener = () => {
         if (spinnerRef.current) {
             clearInterval(spinnerRef.current);
             spinnerRef.current = null;
             clearTerminalLine();
         }
-    });
-    // Error event - SINGLE POINT where ALL errors are displayed
-    // Clear spinner and display formatted error message
-    eventBus.on('llmservice:error', (payload) => {
-        // Stop spinner first
+    };
+    const errorListener = (payload) => {
         if (spinnerRef.current) {
             clearInterval(spinnerRef.current);
             spinnerRef.current = null;
             clearTerminalLine();
         }
-        // Display error message (already formatted with ❌ from gRPC layer)
         process.stdout.write('\n' + chalk.red(payload.error) + '\n\n');
-    });
-    // cipher:ui event - handle UI events (welcome banner, responses, etc.)
-    eventBus.on('cipher:ui', (payload) => {
+    };
+    // TODO(v0.5.0): Move to outer scope for better performance
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    const uiListener = (payload) => {
         switch (payload.type) {
             case 'banner': {
-                // Welcome banner
                 const { model, sessionId } = payload.context;
                 console.log('\n' + chalk.cyan('═'.repeat(60)));
                 console.log(chalk.bold.cyan('🤖 CipherAgent Interactive Mode'));
@@ -151,14 +144,12 @@ function setupEventListeners(eventBus, spinnerState) {
                 break;
             }
             case 'help': {
-                // Help message
                 if (payload.message) {
                     console.log(chalk.yellow(`ℹ ${payload.message}`));
                 }
                 break;
             }
             case 'response': {
-                // AI response
                 if (payload.message) {
                     console.log('\n' + chalk.rgb(255, 165, 0)('─'.repeat(60)));
                     console.log(chalk.bold.rgb(255, 165, 0)('🤖 AI Response:'));
@@ -169,18 +160,16 @@ function setupEventListeners(eventBus, spinnerState) {
                 break;
             }
             case 'shutdown': {
-                // Shutdown message
                 if (payload.message) {
                     console.log(chalk.gray(`✓ ${payload.message}`));
                 }
                 break;
             }
-            // No default case needed - other UI types can be ignored
         }
-    });
-    // cipher:log event - handle structured logging
-    // NOTE: Skip 'error' level - those are handled by llmservice:error to avoid duplicates
-    eventBus.on('cipher:log', (payload) => {
+    };
+    // TODO(v0.5.0): Move to outer scope for better performance
+    // eslint-disable-next-line unicorn/consistent-function-scoping
+    const logListener = (payload) => {
         const prefix = payload.source ? `[${payload.source}] ` : '';
         const message = `${prefix}${payload.message}`;
         switch (payload.level) {
@@ -201,7 +190,23 @@ function setupEventListeners(eventBus, spinnerState) {
                 break;
             }
         }
-    });
+    };
+    // Register all listeners
+    eventBus.on('llmservice:thinking', thinkingListener);
+    eventBus.on('llmservice:response', responseListener);
+    eventBus.on('llmservice:toolCall', toolCallListener);
+    eventBus.on('llmservice:error', errorListener);
+    eventBus.on('cipher:ui', uiListener);
+    eventBus.on('cipher:log', logListener);
+    // Return cleanup function to remove all listeners
+    return () => {
+        eventBus.off('llmservice:thinking', thinkingListener);
+        eventBus.off('llmservice:response', responseListener);
+        eventBus.off('llmservice:toolCall', toolCallListener);
+        eventBus.off('llmservice:error', errorListener);
+        eventBus.off('cipher:ui', uiListener);
+        eventBus.off('cipher:log', logListener);
+    };
 }
 /**
  * Stop and clear spinner if running
@@ -238,7 +243,7 @@ async function executePrompt(prompt, agent, state, eventBus) {
     try {
         // Mark execution started - prevents late thinking events from starting spinner
         isExecutingRef.value = true;
-        // Execute AI prompt
+        // Execute AI prompt (agent uses its default session)
         const response = await agent.execute(prompt);
         // Mark execution finished - no more spinners allowed
         isExecutingRef.value = false;
@@ -278,9 +283,10 @@ export async function startInteractiveLoop(agent, options) {
     const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
     const spinnerIndexRef = { value: 0 };
     const isExecutingRef = { value: false };
-    // Setup event listeners
+    // Setup event listeners and get cleanup function
+    let cleanupEventListeners;
     if (options?.eventBus) {
-        setupEventListeners(options.eventBus, {
+        cleanupEventListeners = setupEventListeners(options.eventBus, {
             frames: spinnerFrames,
             indexRef: spinnerIndexRef,
             isExecutingRef,
@@ -290,6 +296,7 @@ export async function startInteractiveLoop(agent, options) {
     const isExitingRef = { value: false };
     const exitEventHandler = async () => {
         stopSpinner(spinnerRef);
+        cleanupEventListeners?.();
         await cleanup(agent, rl, isExitingRef, options?.eventBus);
         process.exit(0);
     };
@@ -318,13 +325,14 @@ export async function startInteractiveLoop(agent, options) {
                 // Empty input, skip
                 continue;
             }
-            // Execute AI prompt
+            // Execute AI prompt (agent uses its default session)
             // eslint-disable-next-line no-await-in-loop -- Sequential agent execution required for interactive loop
             await executePrompt(parsed.rawInput, agent, { isExecutingRef, spinnerRef }, options?.eventBus);
         }
     }
     finally {
         stopSpinner(spinnerRef);
+        cleanupEventListeners?.();
         await cleanup(agent, rl, isExitingRef, options?.eventBus);
         rl.off('SIGINT', exitEventHandler);
         process.off('SIGTERM', exitEventHandler);

package/dist/infra/cipher/llm/capability-cache.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Model Capability Cache
+ *
+ * Caches model capability lookups for performance.
+ * Avoids repeated registry lookups for the same model.
+ */
+import { type LLMProvider, type ModelCapabilities } from '../../../core/domain/cipher/llm/index.js';
+/**
+ * Cache for model capability lookups.
+ *
+ * This cache stores model information to avoid repeated registry lookups.
+ * The cache is keyed by "provider:model" for quick access.
+ */
+export declare class ModelCapabilityCache {
+    private readonly cache;
+    /**
+     * Get cache size (number of cached models).
+     */
+    get size(): number;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Get model capabilities.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns ModelCapabilities object
+     */
+    getCapabilities(provider: LLMProvider, model: string): ModelCapabilities;
+    /**
+     * Get characters per token ratio for model.
+     */
+    getCharsPerToken(provider: LLMProvider, model: string): number;
+    /**
+     * Get max input tokens for model.
+     */
+    getMaxInputTokens(provider: LLMProvider, model: string): number;
+    /**
+     * Check if a model is cached.
+     */
+    has(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports audio.
+     */
+    supportsAudio(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports a specific feature.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @param feature - Feature to check
+     * @returns true if feature is supported
+     */
+    supportsFeature(provider: LLMProvider, model: string, feature: keyof ModelCapabilities): boolean;
+    /**
+     * Check if model supports images.
+     */
+    supportsImages(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports PDFs.
+     */
+    supportsPdf(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports streaming.
+     */
+    supportsStreaming(provider: LLMProvider, model: string): boolean;
+    /**
+     * Check if model supports extended thinking (Gemini).
+     */
+    supportsThinking(provider: LLMProvider, model: string): boolean;
+    /**
+     * Generate cache key from provider and model.
+     */
+    private getCacheKey;
+    /**
+     * Get cached model info, fetching from registry if not cached.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns Cached model info
+     */
+    private getOrFetch;
+}
+/**
+ * Singleton instance for shared capability cache.
+ * Use this for application-wide caching.
+ */
+export declare const globalCapabilityCache: ModelCapabilityCache;

package/dist/infra/cipher/llm/capability-cache.js

@@ -0,0 +1,125 @@
+/**
+ * Model Capability Cache
+ *
+ * Caches model capability lookups for performance.
+ * Avoids repeated registry lookups for the same model.
+ */
+import { getModelInfoWithFallback, } from '../../../core/domain/cipher/llm/index.js';
+/**
+ * Cache for model capability lookups.
+ *
+ * This cache stores model information to avoid repeated registry lookups.
+ * The cache is keyed by "provider:model" for quick access.
+ */
+export class ModelCapabilityCache {
+    cache = new Map();
+    /**
+     * Get cache size (number of cached models).
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Clear the cache.
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Get model capabilities.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns ModelCapabilities object
+     */
+    getCapabilities(provider, model) {
+        return this.getOrFetch(provider, model).capabilities;
+    }
+    /**
+     * Get characters per token ratio for model.
+     */
+    getCharsPerToken(provider, model) {
+        return this.getOrFetch(provider, model).charsPerToken;
+    }
+    /**
+     * Get max input tokens for model.
+     */
+    getMaxInputTokens(provider, model) {
+        return this.getOrFetch(provider, model).maxInputTokens;
+    }
+    /**
+     * Check if a model is cached.
+     */
+    has(provider, model) {
+        return this.cache.has(this.getCacheKey(provider, model));
+    }
+    /**
+     * Check if model supports audio.
+     */
+    supportsAudio(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsAudio');
+    }
+    /**
+     * Check if model supports a specific feature.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @param feature - Feature to check
+     * @returns true if feature is supported
+     */
+    supportsFeature(provider, model, feature) {
+        const capabilities = this.getCapabilities(provider, model);
+        return capabilities[feature] ?? false;
+    }
+    /**
+     * Check if model supports images.
+     */
+    supportsImages(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsImages');
+    }
+    /**
+     * Check if model supports PDFs.
+     */
+    supportsPdf(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsPdf');
+    }
+    /**
+     * Check if model supports streaming.
+     */
+    supportsStreaming(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsStreaming');
+    }
+    /**
+     * Check if model supports extended thinking (Gemini).
+     */
+    supportsThinking(provider, model) {
+        return this.supportsFeature(provider, model, 'supportsThinking');
+    }
+    /**
+     * Generate cache key from provider and model.
+     */
+    getCacheKey(provider, model) {
+        return `${provider}:${model}`;
+    }
+    /**
+     * Get cached model info, fetching from registry if not cached.
+     * @param provider - LLM provider
+     * @param model - Model name
+     * @returns Cached model info
+     */
+    getOrFetch(provider, model) {
+        const key = this.getCacheKey(provider, model);
+        if (!this.cache.has(key)) {
+            const modelInfo = getModelInfoWithFallback(provider, model);
+            this.cache.set(key, {
+                capabilities: modelInfo.capabilities,
+                charsPerToken: modelInfo.charsPerToken,
+                maxInputTokens: modelInfo.maxInputTokens,
+            });
+        }
+        return this.cache.get(key);
+    }
+}
+/**
+ * Singleton instance for shared capability cache.
+ * Use this for application-wide caching.
+ */
+export const globalCapabilityCache = new ModelCapabilityCache();

package/dist/infra/cipher/llm/context/compaction/compaction-service.d.ts

@@ -1,5 +1,7 @@
 import type { CompactionResult } from '../../../../../core/domain/cipher/storage/message-storage-types.js';
+import type { IContentGenerator } from '../../../../../core/interfaces/cipher/i-content-generator.js';
 import type { ITokenizer } from '../../../../../core/interfaces/cipher/i-tokenizer.js';
+import type { InternalMessage } from '../../../../../core/interfaces/cipher/message-types.js';
 import type { MessageStorageService } from '../../../storage/message-storage-service.js';
 /**
  * Configuration for compaction behavior.
@@ -10,11 +12,26 @@ export interface CompactionConfig {
      * Default: 0.85 (85%)
      */
     overflowThreshold?: number;
+    /**
+     * Number of recent user turns to protect from pruning.
+     * Based on OpenCode's turn-based protection pattern.
+     * Tool outputs in these turns will not be compacted.
+     * Default: 2
+     */
+    protectedTurns?: number;
     /**
      * Number of tokens to keep in tool outputs after pruning.
+     * Based on OpenCode's PRUNE_PROTECT constant.
      * Default: 40000
      */
     pruneKeepTokens?: number;
+    /**
+     * Minimum tokens that must be recoverable to perform pruning.
+     * Based on OpenCode's PRUNE_MINIMUM constant.
+     * If pruning would save less than this, skip it.
+     * Default: 20000
+     */
+    pruneMinimumTokens?: number;
     /**
      * System prompt for generating compaction summaries.
      */
@@ -82,6 +99,17 @@ export declare class CompactionService {
      * Uses the configured tokenizer.
      */
     estimateTokens(text: string): Promise<number>;
+    /**
+     * Generate a compaction summary using the LLM.
+     * Called when context overflow requires full compaction (not just pruning).
+     *
+     * @param generator - The content generator to use for LLM calls
+     * @param messages - The conversation history to summarize
+     * @param taskId - Task ID from usecase for billing tracking
+     * @param model - The model ID to use for generation
+     * @returns The generated summary text
+     */
+    generateSummary(generator: IContentGenerator, messages: InternalMessage[], taskId: string, model: string): Promise<string>;
     /**
      * Get the current compaction configuration.
      */
@@ -97,6 +125,10 @@ export declare class CompactionService {
     /**
      * Prune old tool outputs to reduce context size.
      * Keeps the most recent tool outputs up to the configured token limit.
+     * Only executes if minimum token threshold can be recovered.
+     *
+     * @param sessionId - The session to prune
+     * @returns CompactionResult with count and tokens saved (or zeros if below threshold)
      */
     pruneToolOutputs(sessionId: string): Promise<CompactionResult>;
 }

package/dist/infra/cipher/llm/context/compaction/compaction-service.js

@@ -32,7 +32,9 @@ export class CompactionService {
         this.tokenizer = tokenizer;
         this.config = {
             overflowThreshold: config?.overflowThreshold ?? 0.85,
+            protectedTurns: config?.protectedTurns ?? 2,
             pruneKeepTokens: config?.pruneKeepTokens ?? 40_000,
+            pruneMinimumTokens: config?.pruneMinimumTokens ?? 20_000,
             summaryPrompt: config?.summaryPrompt ?? DEFAULT_SUMMARY_PROMPT,
         };
     }
@@ -96,6 +98,36 @@ export class CompactionService {
     async estimateTokens(text) {
         return this.tokenizer.countTokens(text);
     }
+    /**
+     * Generate a compaction summary using the LLM.
+     * Called when context overflow requires full compaction (not just pruning).
+     *
+     * @param generator - The content generator to use for LLM calls
+     * @param messages - The conversation history to summarize
+     * @param taskId - Task ID from usecase for billing tracking
+     * @param model - The model ID to use for generation
+     * @returns The generated summary text
+     */
+    async generateSummary(generator, messages, taskId, model) {
+        const { systemPrompt, userMessage } = this.getSummaryPromptParts();
+        try {
+            const response = await generator.generateContent({
+                config: {
+                    maxTokens: 4096, // Reasonable limit for summaries
+                    temperature: 0.3, // Lower temperature for more focused summaries
+                },
+                contents: [...messages, { content: userMessage, role: 'user' }],
+                model,
+                systemPrompt,
+                taskId,
+                tools: {}, // No tools for summary generation
+            });
+            return typeof response.content === 'string' ? response.content : '[Summary generation failed]';
+        }
+        catch {
+            return '[Summary generation failed due to error]';
+        }
+    }
     /**
      * Get the current compaction configuration.
      */
@@ -109,19 +141,28 @@ export class CompactionService {
     getSummaryPromptParts() {
         return {
             systemPrompt: this.config.summaryPrompt,
-            userMessage: 'Based on our conversation so far, provide a detailed summary that captures all important context. ' +
-                'This summary will be used to continue the conversation without the full history.',
+            userMessage: 'Provide a detailed prompt for continuing our conversation above. ' +
+                'Focus on information that would be helpful for continuing the conversation, including ' +
+                'what we did, what we are doing, which files we are working on, and what we are going to do next ' +
+                'considering a new session will not have access to our conversation.',
         };
     }
     /**
      * Prune old tool outputs to reduce context size.
      * Keeps the most recent tool outputs up to the configured token limit.
+     * Only executes if minimum token threshold can be recovered.
+     *
+     * @param sessionId - The session to prune
+     * @returns CompactionResult with count and tokens saved (or zeros if below threshold)
      */
     async pruneToolOutputs(sessionId) {
-        return this.messageStorage.pruneToolOutputs({
+        const result = await this.messageStorage.pruneToolOutputs({
             keepTokens: this.config.pruneKeepTokens,
+            minimumTokens: this.config.pruneMinimumTokens,
+            protectedTurns: this.config.protectedTurns,
             sessionId,
         });
+        return result;
     }
 }
 /**

package/dist/infra/cipher/llm/context/compression/enhanced-compaction.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Enhanced Compaction Strategy
+ *
+ * Extends the ReactiveOverflowStrategy with additional features from OpenCode:
+ * - Creates CompactionPart to track compaction metadata
+ * - Preserves last 2 conversation turns (configurable)
+ * - Only compacts if saving > 20K tokens (configurable)
+ * - Emits compaction events for observability
+ *
+ * This is a wrapper that adds these features on top of the existing
+ * ReactiveOverflowStrategy for backward compatibility.
+ */
+import type { ITokenizer } from '../../../../../core/interfaces/cipher/i-tokenizer.js';
+import type { CompactionPart, InternalMessage } from '../../../../../core/interfaces/cipher/message-types.js';
+import type { SessionEventBus } from '../../../events/event-emitter.js';
+import type { ICompressionStrategy } from './types.js';
+import { type ReactiveOverflowOptions } from './reactive-overflow.js';
+/**
+ * Configuration for enhanced compaction.
+ */
+export interface EnhancedCompactionOptions extends ReactiveOverflowOptions {
+    /**
+     * Event bus for emitting compaction events.
+     * Optional - if not provided, events won't be emitted.
+     */
+    eventBus?: SessionEventBus;
+    /**
+     * Minimum token savings required to trigger compaction.
+     * Default: 20000 (20K tokens)
+     */
+    minTokenSavings?: number;
+    /**
+     * Number of recent conversation turns to always preserve.
+     * Default: 2
+     */
+    preserveTurns?: number;
+}
+/**
+ * Enhanced Compaction Strategy.
+ *
+ * Wraps ReactiveOverflowStrategy with additional OpenCode-style features:
+ * - Token savings threshold
+ * - CompactionPart creation
+ * - Event emission
+ *
+ * @example
+ * ```typescript
+ * const strategy = new EnhancedCompactionStrategy({
+ *   llmProvider: myLlmProvider,
+ *   eventBus: sessionEventBus,
+ *   minTokenSavings: 20000,
+ *   preserveTurns: 2,
+ * })
+ *
+ * const compactedHistory = await strategy.compress(history, maxTokens, tokenizer)
+ * ```
+ */
+export declare class EnhancedCompactionStrategy implements ICompressionStrategy {
+    private readonly baseStrategy;
+    private readonly eventBus?;
+    /** Track the last compaction result for observability */
+    private lastCompactionResult?;
+    private readonly minTokenSavings;
+    private readonly preserveTurns;
+    constructor(options: EnhancedCompactionOptions);
+    /**
+     * Compress history with enhanced features.
+     */
+    compress(history: InternalMessage[], maxHistoryTokens: number, tokenizer: ITokenizer): Promise<InternalMessage[]>;
+    /**
+     * Create a CompactionPart for the given compaction result.
+     * Can be used to insert into message parts for tracking.
+     */
+    createCompactionPart(summary: string): CompactionPart | undefined;
+    /**
+     * Get the last compaction result for observability.
+     */
+    getLastCompactionResult(): CompactionResult | undefined;
+    getName(): string;
+    /**
+     * Count total tokens in history.
+     */
+    private countTokens;
+    /**
+     * Find message IDs that were compacted (removed or summarized).
+     * Since messages don't have IDs, we use indices as pseudo-IDs.
+     */
+    private findCompactedMessageIds;
+}
+/**
+ * Result of a compaction operation.
+ */
+export interface CompactionResult {
+    /** Timestamp when compaction occurred */
+    compactedAt: number;
+    /** IDs of messages that were compacted */
+    compactedMessageIds: string[];
+    /** Number of messages after compaction */
+    messageCountAfter: number;
+    /** Number of messages before compaction */
+    messageCountBefore: number;
+    /** Token count after compaction */
+    tokensAfter: number;
+    /** Token count before compaction */
+    tokensBefore: number;
+    /** Tokens saved by compaction */
+    tokensSaved: number;
+}
+/**
+ * Create an EnhancedCompactionStrategy instance.
+ */
+export declare function createEnhancedCompactionStrategy(options: EnhancedCompactionOptions): EnhancedCompactionStrategy;