byterover-cli 0.4.1 → 1.0.0

package/dist/infra/cipher/llm/context/compression/reactive-overflow.js

@@ -0,0 +1,272 @@
+/**
+ * Reactive Overflow compression strategy.
+ *
+ * This strategy uses an LLM to generate intelligent summaries of older messages
+ * when the context window overflows. Unlike simple truncation strategies, it
+ * preserves the semantic meaning of the conversation.
+ *
+ * Algorithm:
+ * 1. Check if overflow (currentTokens > maxHistoryTokens)
+ * 2. Select oldest non-system messages to summarize
+ * 3. Generate LLM summary of selected messages
+ * 4. Return: systemMessages + summaryMessage + remainingMessages
+ * 5. Summary message has metadata.isSummary = true
+ *
+ * Key design principles:
+ * - Uses same model as conversation (per user configuration)
+ * - Summary message marks compaction boundary
+ * - filterCompacted() excludes old messages at read-time
+ * - Full history preserved in storage for audit
+ *
+ */
+import { isTextPart } from '../../../../../core/interfaces/cipher/message-type-guards.js';
+/**
+ * Default configuration values.
+ */
+const DEFAULTS = {
+    minMessagesToSummarize: 10,
+    preserveLastNTurns: 2,
+    summaryTargetTokens: 2000,
+};
+/**
+ * Reactive Overflow compression strategy.
+ *
+ * Uses an LLM to generate intelligent summaries when context overflows.
+ */
+export class ReactiveOverflowStrategy {
+    llmProvider;
+    minMessagesToSummarize;
+    model;
+    preserveLastNTurns;
+    summaryTargetTokens;
+    constructor(options) {
+        this.llmProvider = options.llmProvider;
+        this.model = options.model;
+        this.summaryTargetTokens = options.summaryTargetTokens ?? DEFAULTS.summaryTargetTokens;
+        this.minMessagesToSummarize = options.minMessagesToSummarize ?? DEFAULTS.minMessagesToSummarize;
+        this.preserveLastNTurns = options.preserveLastNTurns ?? DEFAULTS.preserveLastNTurns;
+    }
+    async compress(history, maxHistoryTokens, tokenizer) {
+        // Calculate current token count
+        const currentTokens = this.countHistoryTokens(history, tokenizer);
+        // Check if compression is needed
+        if (currentTokens <= maxHistoryTokens) {
+            return history;
+        }
+        // Separate system messages from non-system messages
+        const systemMessages = history.filter((m) => m.role === 'system');
+        const nonSystemMessages = history.filter((m) => m.role !== 'system');
+        // Check if we have enough messages to summarize
+        if (nonSystemMessages.length < this.minMessagesToSummarize) {
+            // Not enough messages, can't use this strategy
+            return history;
+        }
+        // Calculate how many messages to keep (preserve last N turns)
+        const turnBoundaries = this.findTurnBoundaries(nonSystemMessages);
+        const turnsToPreserve = Math.min(this.preserveLastNTurns, turnBoundaries.length);
+        const preserveFromIndex = turnsToPreserve > 0
+            ? turnBoundaries[turnBoundaries.length - turnsToPreserve]
+            : nonSystemMessages.length;
+        // Split messages into "to summarize" and "to keep"
+        const messagesToSummarize = nonSystemMessages.slice(0, preserveFromIndex);
+        const messagesToKeep = nonSystemMessages.slice(preserveFromIndex);
+        // Need enough messages to summarize
+        if (messagesToSummarize.length < this.minMessagesToSummarize) {
+            return history;
+        }
+        // Generate summary using LLM
+        const summaryContent = await this.generateSummary(messagesToSummarize);
+        // Create summary message with metadata
+        const summaryMessage = {
+            content: `[Conversation Summary]\n${summaryContent}`,
+            metadata: {
+                compactedAt: Date.now(),
+                isSummary: true,
+                summarizedMessageCount: messagesToSummarize.length,
+            },
+            role: 'system',
+        };
+        // Return: system messages + summary + kept messages
+        return [...systemMessages, summaryMessage, ...messagesToKeep];
+    }
+    getName() {
+        return 'ReactiveOverflow';
+    }
+    /**
+     * Count tokens in message history.
+     */
+    countHistoryTokens(history, tokenizer) {
+        let total = 0;
+        for (const message of history) {
+            total += this.countMessageTokens(message, tokenizer);
+        }
+        return total;
+    }
+    /**
+     * Count tokens in a single message.
+     */
+    countMessageTokens(message, tokenizer) {
+        // Role overhead (approximately 4 tokens)
+        let tokens = 4;
+        if (typeof message.content === 'string') {
+            tokens += tokenizer.countTokens(message.content);
+        }
+        else if (Array.isArray(message.content)) {
+            for (const part of message.content) {
+                tokens += isTextPart(part) ? tokenizer.countTokens(part.text) : 100;
+            }
+        }
+        // Tool calls overhead
+        if (message.toolCalls) {
+            for (const call of message.toolCalls) {
+                tokens += tokenizer.countTokens(call.function.name);
+                tokens += tokenizer.countTokens(call.function.arguments);
+            }
+        }
+        return tokens;
+    }
+    /**
+     * Extract text content from a message.
+     */
+    extractTextContent(message) {
+        if (typeof message.content === 'string') {
+            return message.content;
+        }
+        if (Array.isArray(message.content)) {
+            return message.content
+                .filter((p) => isTextPart(p))
+                .map((p) => p.text)
+                .join('\n');
+        }
+        return '';
+    }
+    /**
+     * Find turn boundaries in message history.
+     *
+     * A turn boundary is the index where a user message starts.
+     * Returns indices of all user messages.
+     */
+    findTurnBoundaries(messages) {
+        const boundaries = [];
+        for (const [index, message] of messages.entries()) {
+            if (message.role === 'user') {
+                boundaries.push(index);
+            }
+        }
+        return boundaries;
+    }
+    /**
+     * Format messages for the summary prompt.
+     */
+    formatMessagesForSummary(messages) {
+        const lines = [];
+        for (const message of messages) {
+            const role = this.formatRole(message.role);
+            const content = this.extractTextContent(message);
+            // Truncate very long messages
+            const truncatedContent = content.length > 2000
+                ? `${content.slice(0, 2000)}... [truncated]`
+                : content;
+            if (truncatedContent) {
+                lines.push(`${role}: ${truncatedContent}`);
+            }
+            // Include tool call information
+            if (message.toolCalls && message.toolCalls.length > 0) {
+                const toolNames = message.toolCalls.map((tc) => tc.function.name).join(', ');
+                lines.push(`[Used tools: ${toolNames}]`);
+            }
+        }
+        return lines.join('\n\n');
+    }
+    /**
+     * Format role for display.
+     */
+    formatRole(role) {
+        switch (role) {
+            case 'assistant': {
+                return 'Assistant';
+            }
+            case 'system': {
+                return 'System';
+            }
+            case 'tool': {
+                return 'Tool Result';
+            }
+            case 'user': {
+                return 'User';
+            }
+            default: {
+                return role.charAt(0).toUpperCase() + role.slice(1);
+            }
+        }
+    }
+    /**
+     * Generate a fallback summary without LLM.
+     */
+    generateFallbackSummary(messages) {
+        const userMessages = messages.filter((m) => m.role === 'user');
+        const assistantMessages = messages.filter((m) => m.role === 'assistant');
+        const toolMessages = messages.filter((m) => m.role === 'tool');
+        const lines = [
+            `Summarized ${messages.length} messages:`,
+            `- ${userMessages.length} user messages`,
+            `- ${assistantMessages.length} assistant responses`,
+            `- ${toolMessages.length} tool results`,
+        ];
+        // Extract key topics from user messages
+        const topics = new Set();
+        for (const msg of userMessages.slice(0, 5)) {
+            const content = this.extractTextContent(msg);
+            const words = content.split(/\s+/).slice(0, 10).join(' ');
+            if (words) {
+                topics.add(words);
+            }
+        }
+        if (topics.size > 0) {
+            const topicLines = ['', 'Key topics discussed:'];
+            for (const topic of topics) {
+                topicLines.push(`- ${topic}...`);
+            }
+            lines.push(...topicLines);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate a summary of messages using the LLM.
+     */
+    async generateSummary(messages) {
+        const conversationText = this.formatMessagesForSummary(messages);
+        const prompt = `You are a conversation summarizer. Summarize the following conversation concisely, preserving:
+- Key decisions made
+- Important actions taken
+- Critical context for continuing the conversation
+- Any unresolved questions or tasks
+
+Keep the summary focused and actionable. Do not include unnecessary details.
+
+Conversation:
+${conversationText}
+
+Summary:`;
+        try {
+            const summary = await this.llmProvider.generate({
+                maxTokens: this.summaryTargetTokens,
+                prompt,
+                ...(this.model && { model: this.model }),
+                temperature: 0.3, // Lower temperature for more consistent summaries
+            });
+            return summary.trim() || 'Unable to generate summary.';
+        }
+        catch {
+            // Fallback if LLM fails
+            const fallbackSummary = this.generateFallbackSummary(messages);
+            return fallbackSummary;
+        }
+    }
+}
+/**
+ * Create a ReactiveOverflowStrategy instance.
+ */
+export function createReactiveOverflowStrategy(options) {
+    return new ReactiveOverflowStrategy(options);
+}

package/dist/infra/cipher/llm/context/context-manager.d.ts

@@ -2,7 +2,7 @@ import type { IHistoryStorage } from '../../../../core/interfaces/cipher/i-histo
 import type { ILogger } from '../../../../core/interfaces/cipher/i-logger.js';
 import type { IMessageFormatter } from '../../../../core/interfaces/cipher/i-message-formatter.js';
 import type { ITokenizer } from '../../../../core/interfaces/cipher/i-tokenizer.js';
-import type { InternalMessage } from '../../../../core/interfaces/cipher/message-types.js';
+import type { InternalMessage, ToolPart, ToolState } from '../../../../core/interfaces/cipher/message-types.js';
 import type { ICompressionStrategy } from './compression/types.js';
 /**
  * Configuration for persistence retry behavior.
@@ -138,6 +138,15 @@ export declare class ContextManager<T> {
      * @param content - System message content
      */
     addSystemMessage(content: string): Promise<void>;
+    /**
+     * Add a pending tool call to the current assistant message.
+     * Creates a ToolPart in pending state and adds it to the last assistant message's content.
+     *
+     * @param callId - Unique identifier for this tool call
+     * @param toolName - Name of the tool being called
+     * @param input - Parsed input arguments
+     */
+    addToolCallPending(callId: string, toolName: string, input: Record<string, unknown>): void;
     /**
      * Add a tool result message to the conversation.
      * Thread-safe: Uses mutex to protect shared state during parallel tool execution.
@@ -169,6 +178,18 @@ export declare class ContextManager<T> {
      * Also clears persisted history if storage is enabled.
      */
     clearHistory(): Promise<void>;
+    /**
+     * Flush any pending history writes to storage.
+     * Provides explicit durability guarantee - ensures all messages
+     * are persisted before the promise resolves.
+     *
+     * Call at turn boundaries, before session cleanup, or when
+     * explicit persistence confirmation is needed.
+     *
+     * @returns Promise that resolves when history is persisted
+     * @throws Error if persistence fails after all retries
+     */
+    flush(): Promise<void>;
     /**
      * Get comprehensive messages (all messages, for persistence/debugging).
      * This includes all messages including invalid ones.
@@ -203,6 +224,13 @@ export declare class ContextManager<T> {
      * Get the session ID.
      */
     getSessionId(): string;
+    /**
+     * Get a tool part by its call ID.
+     *
+     * @param callId - ID of the tool call to find
+     * @returns The tool part if found, undefined otherwise
+     */
+    getToolPart(callId: string): ToolPart | undefined;
     /**
      * Initialize the context manager by loading persisted history.
      * Should be called after construction to restore previous conversation.
@@ -210,6 +238,18 @@ export declare class ContextManager<T> {
      * @returns True if history was loaded, false otherwise
      */
     initialize(): Promise<boolean>;
+    /**
+     * Update a tool call's state.
+     * Used for transitioning through pending → running → completed/error.
+     *
+     * @param callId - ID of the tool call to update
+     * @param stateUpdate - New state
+     */
+    updateToolCallState(callId: string, stateUpdate: ToolState): void;
+    /**
+     * Add a ToolPart to a message at the given index.
+     */
+    private addToolPartToMessage;
     /**
      * Compress conversation history if needed to fit within token limits.
      *
@@ -228,6 +268,12 @@ export declare class ContextManager<T> {
      * @returns Token count
      */
     private countTokens;
+    /**
+     * Find the index of the last assistant message.
+     *
+     * @returns Index of last assistant message, or -1 if not found
+     */
+    private findLastAssistantMessageIndex;
     /**
      * Check if a system message is noise (empty or whitespace only).
      *

package/dist/infra/cipher/llm/context/context-manager.js

@@ -101,6 +101,29 @@ export class ContextManager {
             this.logger.error('Failed to persist history after system message', { error, sessionId: this.sessionId });
         });
     }
+    /**
+     * Add a pending tool call to the current assistant message.
+     * Creates a ToolPart in pending state and adds it to the last assistant message's content.
+     *
+     * @param callId - Unique identifier for this tool call
+     * @param toolName - Name of the tool being called
+     * @param input - Parsed input arguments
+     */
+    addToolCallPending(callId, toolName, input) {
+        const toolPart = {
+            callId,
+            state: { input, status: 'pending' },
+            toolName,
+            type: 'tool',
+        };
+        // Find the last assistant message and add the tool part
+        const lastAssistantIdx = this.findLastAssistantMessageIndex();
+        if (lastAssistantIdx === -1) {
+            this.logger.warn('No assistant message found to add tool call', { callId, sessionId: this.sessionId });
+            return;
+        }
+        this.addToolPartToMessage(lastAssistantIdx, toolPart);
+    }
     /**
      * Add a tool result message to the conversation.
      * Thread-safe: Uses mutex to protect shared state during parallel tool execution.
@@ -173,6 +196,22 @@ export class ContextManager {
             }
         }
     }
+    /**
+     * Flush any pending history writes to storage.
+     * Provides explicit durability guarantee - ensures all messages
+     * are persisted before the promise resolves.
+     *
+     * Call at turn boundaries, before session cleanup, or when
+     * explicit persistence confirmation is needed.
+     *
+     * @returns Promise that resolves when history is persisted
+     * @throws Error if persistence fails after all retries
+     */
+    async flush() {
+        if (this.historyStorage) {
+            await this.persistHistory();
+        }
+    }
     /**
      * Get comprehensive messages (all messages, for persistence/debugging).
      * This includes all messages including invalid ones.
@@ -236,6 +275,25 @@ export class ContextManager {
     getSessionId() {
         return this.sessionId;
     }
+    /**
+     * Get a tool part by its call ID.
+     *
+     * @param callId - ID of the tool call to find
+     * @returns The tool part if found, undefined otherwise
+     */
+    getToolPart(callId) {
+        for (let msgIdx = this.messages.length - 1; msgIdx >= 0; msgIdx--) {
+            const message = this.messages[msgIdx];
+            if (!Array.isArray(message.content))
+                continue;
+            for (const part of message.content) {
+                if (part.type === 'tool' && part.callId === callId) {
+                    return part;
+                }
+            }
+        }
+        return undefined;
+    }
     /**
      * Initialize the context manager by loading persisted history.
      * Should be called after construction to restore previous conversation.
@@ -269,6 +327,64 @@ export class ContextManager {
             return false;
         }
     }
+    /**
+     * Update a tool call's state.
+     * Used for transitioning through pending → running → completed/error.
+     *
+     * @param callId - ID of the tool call to update
+     * @param stateUpdate - New state
+     */
+    updateToolCallState(callId, stateUpdate) {
+        // Find the tool part with this callId
+        for (let msgIdx = this.messages.length - 1; msgIdx >= 0; msgIdx--) {
+            const message = this.messages[msgIdx];
+            if (!Array.isArray(message.content))
+                continue;
+            for (let partIdx = 0; partIdx < message.content.length; partIdx++) {
+                const part = message.content[partIdx];
+                if (part.type === 'tool' && part.callId === callId) {
+                    // Update the tool part state
+                    const updatedPart = {
+                        ...part,
+                        state: stateUpdate,
+                    };
+                    // Create new content array with updated part
+                    const newContent = [...message.content];
+                    newContent[partIdx] = updatedPart;
+                    // Update the message
+                    this.messages[msgIdx] = {
+                        ...message,
+                        content: newContent,
+                    };
+                    return;
+                }
+            }
+        }
+        this.logger.warn('Tool call not found for state update', { callId, sessionId: this.sessionId });
+    }
+    // ==================== PRIVATE METHODS ====================
+    /**
+     * Add a ToolPart to a message at the given index.
+     */
+    addToolPartToMessage(messageIdx, toolPart) {
+        const message = this.messages[messageIdx];
+        let newContent;
+        if (Array.isArray(message.content)) {
+            newContent = [...message.content, toolPart];
+        }
+        else if (typeof message.content === 'string') {
+            // Convert string content to array with text part + tool part
+            newContent = [{ text: message.content, type: 'text' }, toolPart];
+        }
+        else {
+            // null content - just add tool part
+            newContent = [toolPart];
+        }
+        this.messages[messageIdx] = {
+            ...message,
+            content: newContent,
+        };
+    }
     /**
      * Compress conversation history if needed to fit within token limits.
      *
@@ -352,6 +468,19 @@ export class ContextManager {
             .join('\n');
         return this.tokenizer.countTokens(text);
     }
+    /**
+     * Find the index of the last assistant message.
+     *
+     * @returns Index of last assistant message, or -1 if not found
+     */
+    findLastAssistantMessageIndex() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i].role === 'assistant') {
+                return i;
+            }
+        }
+        return -1;
+    }
     /**
      * Check if a system message is noise (empty or whitespace only).
      *

package/dist/infra/cipher/llm/context/utils.js

@@ -1,9 +1,7 @@
 /**
  * Count tokens for a single content part
  *
- * @param part - Content part
- * @param part.text - Text content (for text type)
- * @param part.type - Type of content part
+ * @param part - Content part (text, image, file, reasoning, or tool)
  * @param tokenizer - Tokenizer for counting
  * @returns Token count for the part
  */
@@ -20,9 +18,24 @@ function countPartTokens(part, tokenizer) {
             // Conservative estimate: ~100 tokens per image
             return 100;
         }
+        case 'reasoning': {
+            // Reasoning/thinking content - use tokenizer
+            return tokenizer.countTokens(part.text);
+        }
         case 'text': {
             // Text content - use tokenizer
-            return tokenizer.countTokens(part.text ?? '');
+            return tokenizer.countTokens(part.text);
+        }
+        case 'tool': {
+            // Tool call part - count input + output tokens
+            let tokens = tokenizer.countTokens(JSON.stringify(part.state.input));
+            if (part.state.status === 'completed') {
+                tokens += tokenizer.countTokens(part.state.output);
+            }
+            else if (part.state.status === 'error') {
+                tokens += tokenizer.countTokens(part.state.error);
+            }
+            return tokens;
         }
         default: {
             return 0;

package/dist/infra/cipher/llm/generators/byterover-content-generator.js

@@ -77,10 +77,12 @@ export class ByteRoverContentGenerator {
         const config = this.providerType === 'claude' ? {} : genConfig;
         // Build execution metadata from request
         const executionMetadata = {
-            sessionId: request.sessionId,
-            ...(request.mode && { mode: request.mode }),
+            sessionId: request.taskId,
+            taskId: request.taskId,
             ...(request.executionContext && { executionContext: request.executionContext }),
         };
+        // // Debug: Log taskId for tracking
+        // appendFileSync('debug-taskid.log', `[${new Date().toISOString()}] taskId from request: "${request.taskId}"\n`)
         const rawResponse = await this.httpService.generateContent(contents, config, this.config.model, executionMetadata);
         // Parse response to internal format
         const messages = this.formatter.parseResponse(rawResponse);