@ebowwa/coder 0.7.63 → 0.7.65

package/packages/src/core/context/compaction.ts

@@ -0,0 +1,170 @@
+/**
+ * Compaction - Reduce message context size while preserving important information
+ *
+ * Strategy:
+ * 1. Always keep the first N messages (original query)
+ * 2. Always keep the last M messages (recent context)
+ * 3. Summarize middle messages into a single "context summary" user message
+ * 4. Preserve tool_use/tool_result pairs when possible
+ */
+
+import type { Message, ContentBlock } from "../../types/index.js";
+import type { CompactionOptions, CompactionResult, CompactionStats } from "./types.js";
+import {
+  DEFAULT_KEEP_FIRST,
+  DEFAULT_KEEP_LAST,
+  DEFAULT_COMPACTION_THRESHOLD,
+  MIN_MESSAGES_FOR_COMPACTION,
+} from "./constants.js";
+import { estimateMessagesTokens } from "./token-estimation.js";
+import { extractToolPairs } from "./extraction.js";
+import { summarizeMessages, summarizeWithLLM } from "./summarization.js";
+
+/**
+ * Compact messages to fit within a token limit.
+ */
+export async function compactMessages(
+  messages: Message[],
+  maxTokens: number,
+  options: CompactionOptions = {}
+): Promise<CompactionResult> {
+  const {
+    keepFirst = DEFAULT_KEEP_FIRST,
+    keepLast = DEFAULT_KEEP_LAST,
+    preserveToolPairs = true,
+    useLLMSummarization = true,
+    apiKey,
+    baseUrl,
+  } = options;
+
+  const tokensBefore = estimateMessagesTokens(messages);
+
+  // If already under limit, no compaction needed
+  if (tokensBefore <= maxTokens) {
+    return {
+      messages,
+      messagesRemoved: 0,
+      tokensBefore,
+      tokensAfter: tokensBefore,
+      didCompact: false,
+    };
+  }
+
+  // Not enough messages to compact - silent return
+  if (messages.length <= keepFirst + keepLast) {
+    return {
+      messages,
+      messagesRemoved: 0,
+      tokensBefore,
+      tokensAfter: tokensBefore,
+      didCompact: false,
+    };
+  }
+
+  // Extract segments
+  const firstMessages = messages.slice(0, keepFirst);
+  const middleMessages = messages.slice(keepFirst, -keepLast);
+  const lastMessages = messages.slice(-keepLast);
+
+  // Create summary of middle messages (use LLM if available, fallback to simple)
+  const summary = useLLMSummarization
+    ? await summarizeWithLLM(middleMessages, { apiKey, baseUrl })
+    : await summarizeMessages(middleMessages);
+
+  // Build summary message
+  const summaryMessage: Message = {
+    role: "user",
+    content: [{
+      type: "text",
+      text: `[Previous context has been compacted for continuity]\n\n${summary}`,
+    }],
+  };
+
+  // Optionally preserve important tool pairs
+  let preservedBlocks: ContentBlock[] = [];
+  if (preserveToolPairs && middleMessages.length > 0) {
+    const toolPairs = extractToolPairs(middleMessages);
+
+    // Keep the most recent tool use/result pairs (up to 3)
+    const recentPairs = Array.from(toolPairs.values())
+      .slice(-3)
+      .filter(pair => pair.result && !pair.result.is_error);
+
+    for (const pair of recentPairs) {
+      preservedBlocks.push(pair.use as ContentBlock);
+      if (pair.result) {
+        preservedBlocks.push(pair.result as ContentBlock);
+      }
+    }
+  }
+
+  // Build compacted message list
+  const compacted: Message[] = [
+    ...firstMessages,
+    summaryMessage,
+  ];
+
+  // Add preserved tool results if any
+  if (preservedBlocks.length > 0) {
+    compacted.push({
+      role: "assistant",
+      content: preservedBlocks.filter(b => b.type === "tool_use"),
+    });
+    compacted.push({
+      role: "user",
+      content: preservedBlocks.filter(b => b.type === "tool_result"),
+    });
+  }
+
+  // Add recent messages
+  compacted.push(...lastMessages);
+
+  const tokensAfter = estimateMessagesTokens(compacted);
+  const messagesRemoved = messages.length - compacted.length;
+
+  console.log(`Context compaction: ${messages.length} -> ${compacted.length} messages, ${tokensBefore} -> ${tokensAfter} tokens`);
+
+  return {
+    messages: compacted,
+    messagesRemoved,
+    tokensBefore,
+    tokensAfter,
+    didCompact: true,
+  };
+}
+
+/**
+ * Check if compaction is needed proactively.
+ * Returns true if current token usage exceeds the threshold AND there are enough messages to compact.
+ */
+export function needsCompaction(
+  messages: Message[],
+  maxTokens: number,
+  threshold: number = DEFAULT_COMPACTION_THRESHOLD
+): boolean {
+  // Not enough messages to meaningfully compact
+  if (messages.length < MIN_MESSAGES_FOR_COMPACTION) {
+    return false;
+  }
+
+  const currentTokens = estimateMessagesTokens(messages);
+  const thresholdTokens = Math.floor(maxTokens * threshold);
+  return currentTokens >= thresholdTokens;
+}
+
+/**
+ * Get compaction statistics for logging/metrics
+ */
+export function getCompactionStats(result: CompactionResult): CompactionStats {
+  if (!result.didCompact) {
+    return { reductionPercent: 0, tokensSaved: 0 };
+  }
+
+  const tokensSaved = result.tokensBefore - result.tokensAfter;
+  const reductionPercent = (tokensSaved / result.tokensBefore) * 100;
+
+  return {
+    reductionPercent: Math.round(reductionPercent * 100) / 100,
+    tokensSaved,
+  };
+}

package/packages/src/core/context/constants.ts

@@ -0,0 +1,58 @@
+/**
+ * Context Constants - Configuration values for context compaction
+ */
+
+/** Approximate characters per token (rough estimate for Claude models) */
+export const CHARS_PER_TOKEN = 4;
+
+/** Default number of recent messages to keep during compaction */
+export const DEFAULT_KEEP_LAST = 5;
+
+/** Default number of initial messages to keep (usually just the first user query) */
+export const DEFAULT_KEEP_FIRST = 1;
+
+/** Minimum messages required before compaction is possible */
+export const MIN_MESSAGES_FOR_COMPACTION = 8;
+
+/** Default threshold for proactive compaction (90% of max tokens) */
+export const DEFAULT_COMPACTION_THRESHOLD = 0.9;
+
+/** Maximum length for summary text before truncation */
+export const MAX_SUMMARY_LENGTH = 8000;
+
+/** Maximum tokens for summary output */
+export const SUMMARY_MAX_TOKENS = 2000;
+
+/** System prompt for summarization */
+export const SUMMARIZATION_SYSTEM_PROMPT = `You are a context summarizer. Your job is to create concise, information-dense summaries of conversation history.
+
+Guidelines:
+- Preserve all important decisions, file changes, and key information
+- Keep track of what tools were used and their outcomes
+- Note any errors encountered and how they were resolved
+- Maintain chronological flow
+- Be extremely concise - use bullet points and short sentences
+- Focus on information that would be needed to continue the conversation
+- Do not include pleasantries or filler text
+
+Format your summary as:
+## Summary
+[Brief overview of what was discussed]
+
+## Key Actions
+- [Action 1]
+- [Action 2]
+
+## Files Modified
+- [file]: [what changed]
+
+## Important Context
+[Any critical information needed going forward]`;
+
+/** User prompt template for summarization */
+export const SUMMARIZATION_PROMPT = `Summarize the following conversation messages for context compaction. Preserve all important information in a concise format.
+
+Messages to summarize:
+{{MESSAGES}}
+
+Provide a dense, information-rich summary that captures everything needed to continue this conversation.`;

package/packages/src/core/context/extraction.ts

@@ -0,0 +1,85 @@
+/**
+ * Content Extraction - Extract and organize message content
+ */
+
+import type { Message, ContentBlock } from "../../types/index.js";
+import type { ToolPair } from "./types.js";
+
+/**
+ * Extract text content from a message for summarization
+ */
+export function extractTextFromMessage(message: Message): string {
+  const parts: string[] = [];
+
+  for (const block of message.content) {
+    switch (block.type) {
+      case "text":
+        parts.push(block.text);
+        break;
+      case "tool_use":
+        parts.push(`[Tool: ${block.name}(${JSON.stringify(block.input)})]`);
+        break;
+      case "tool_result":
+        const content = typeof block.content === "string"
+          ? block.content
+          : block.content.map(b => b.type === "text" ? b.text : "[content]").join("");
+        parts.push(`[Result: ${content.slice(0, 500)}${content.length > 500 ? "..." : ""}]`);
+        break;
+      case "thinking":
+        parts.push(`[Thinking: ${block.thinking.slice(0, 200)}...]`);
+        break;
+    }
+  }
+
+  return parts.join("\n");
+}
+
+/**
+ * Extract tool use/result pairs from messages for preservation
+ */
+export function extractToolPairs(messages: Message[]): Map<string, ToolPair> {
+  const toolPairs = new Map<string, ToolPair>();
+
+  // First pass: collect all tool uses
+  for (const message of messages) {
+    for (const block of message.content) {
+      if (block.type === "tool_use") {
+        toolPairs.set(block.id, {
+          use: { type: "tool_use", id: block.id, name: block.name, input: block.input }
+        });
+      }
+    }
+  }
+
+  // Second pass: match results to uses
+  for (const message of messages) {
+    for (const block of message.content) {
+      if (block.type === "tool_result") {
+        const pair = toolPairs.get(block.tool_use_id);
+        if (pair) {
+          pair.result = {
+            type: "tool_result",
+            tool_use_id: block.tool_use_id,
+            content: block.content,
+            is_error: block.is_error
+          };
+        }
+      }
+    }
+  }
+
+  return toolPairs;
+}
+
+/**
+ * Extract tool names from a message
+ */
+export function extractToolNames(message: Message): string[] {
+  const names: string[] = [];
+  for (const block of message.content) {
+    if (block.type === "tool_use") {
+      names.push(block.name);
+    }
+  }
+  return names;
+}

package/packages/src/core/context/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Context Module - Context compaction for conversation management
+ *
+ * When the context window fills up, we need to compact messages to continue.
+ * This module provides token estimation, summarization, and compaction utilities.
+ *
+ * @example
+ * ```ts
+ * import { compactMessages, needsCompaction, estimateMessagesTokens } from "./context/index.js";
+ *
+ * // Check if compaction is needed
+ * if (needsCompaction(messages, maxTokens)) {
+ *   const result = await compactMessages(messages, maxTokens);
+ *   console.log(`Saved ${result.tokensBefore - result.tokensAfter} tokens`);
+ * }
+ * ```
+ */
+
+// Types
+export type {
+  LLMSummarizationOptions,
+  CompactionOptions,
+  CompactionResult,
+  CompactionStats,
+  ToolPair,
+} from "./types.js";
+
+// Constants
+export {
+  CHARS_PER_TOKEN,
+  DEFAULT_KEEP_LAST,
+  DEFAULT_KEEP_FIRST,
+  MIN_MESSAGES_FOR_COMPACTION,
+  DEFAULT_COMPACTION_THRESHOLD,
+  MAX_SUMMARY_LENGTH,
+  SUMMARY_MAX_TOKENS,
+} from "./constants.js";
+
+// Token Estimation
+export {
+  estimateTokens,
+  estimateBlockTokens,
+  estimateMessageTokens,
+  estimateMessagesTokens,
+} from "./token-estimation.js";
+
+// Extraction
+export {
+  extractTextFromMessage,
+  extractToolPairs,
+  extractToolNames,
+} from "./extraction.js";
+
+// Summarization
+export {
+  summarizeMessages,
+  summarizeWithLLM,
+  compactContentNative,
+} from "./summarization.js";
+
+// Compaction
+export {
+  compactMessages,
+  needsCompaction,
+  getCompactionStats,
+} from "./compaction.js";

package/packages/src/core/context/summarization.ts

@@ -0,0 +1,251 @@
+/**
+ * Summarization - Create summaries of conversation messages
+ *
+ * Strategies:
+ * 1. Native compact_content (Rust) - Fast preprocessing
+ * 2. Simple concatenation + truncation - Fallback
+ * 3. LLM-based summarization - Best quality when API available
+ */
+
+import type { Message, ToolResultBlock } from "../../types/index.js";
+import { SUMMARIZATION_MODEL } from "../models.js";
+import type { LLMSummarizationOptions } from "./types.js";
+import {
+  MAX_SUMMARY_LENGTH,
+  SUMMARY_MAX_TOKENS,
+  SUMMARIZATION_SYSTEM_PROMPT,
+  SUMMARIZATION_PROMPT,
+} from "./constants.js";
+import { extractTextFromMessage, extractToolNames } from "./extraction.js";
+
+// Lazy-load native module
+let _native: {
+  compact_content?: (
+    content: string,
+    maxTokens: number,
+    strategy?: "truncate" | "summarize" | "extract"
+  ) => string;
+} | null = null;
+let _nativeLoadAttempted = false;
+
+function getNative(): typeof _native {
+  if (_nativeLoadAttempted) return _native;
+  _nativeLoadAttempted = true;
+
+  try {
+    const nativePath = require.resolve("../../../native/index.js");
+    const nativeModule = require(nativePath);
+    _native = nativeModule.getNative?.() ?? null;
+  } catch {
+    _native = null;
+  }
+
+  return _native;
+}
+
+/**
+ * Preprocess content using native compact_content if available.
+ * Used to reduce large content before LLM summarization.
+ */
+function preprocessContent(content: string, maxTokens: number): string {
+  const native = getNative();
+
+  if (native?.compact_content) {
+    // Use native "extract" strategy for better preservation of structure
+    return native.compact_content(content, maxTokens, "extract");
+  }
+
+  // Fallback: simple truncation
+  const maxChars = maxTokens * 4;
+  if (content.length <= maxChars) return content;
+  return content.slice(0, maxChars) + "\n\n...[content truncated]";
+}
+
+/**
+ * Simple summarization that concatenates and truncates.
+ * Can be enhanced later with LLM-based summarization.
+ */
+export async function summarizeMessages(messages: Message[]): Promise<string> {
+  if (!messages || messages.length === 0) {
+    return "";
+  }
+
+  const summaryParts: string[] = [];
+  summaryParts.push(`[Context Summary: ${messages.length} messages compacted]\n`);
+
+  // Track tool operations for a cleaner summary
+  const toolOperations: string[] = [];
+
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (!message) continue;
+
+    const role = message.role.toUpperCase();
+    const text = extractTextFromMessage(message);
+
+    // Track tool operations
+    toolOperations.push(...extractToolNames(message));
+
+    // Add truncated message content
+    const truncated = text.length > 300 ? `${text.slice(0, 300)}...` : text;
+    summaryParts.push(`${role}: ${truncated}\n`);
+  }
+
+  // Add tool summary
+  if (toolOperations.length > 0) {
+    const toolCounts = toolOperations.reduce((acc, tool) => {
+      acc[tool] = (acc[tool] || 0) + 1;
+      return acc;
+    }, {} as Record<string, number>);
+
+    const toolSummary = Object.entries(toolCounts)
+      .map(([name, count]) => `${name}(${count})`)
+      .join(", ");
+    summaryParts.push(`\nTools used: ${toolSummary}\n`);
+  }
+
+  let summary = summaryParts.join("");
+
+  // Truncate if too long
+  if (summary.length > MAX_SUMMARY_LENGTH) {
+    summary = summary.slice(0, MAX_SUMMARY_LENGTH) + "\n...[truncated]";
+  }
+
+  return summary;
+}
+
+/**
+ * Summarize messages using an LLM for better context preservation.
+ * Falls back to simple truncation if LLM fails or no API key provided.
+ */
+export async function summarizeWithLLM(
+  messages: Message[],
+  options: LLMSummarizationOptions = {}
+): Promise<string> {
+  const {
+    apiKey = process.env.ANTHROPIC_AUTH_TOKEN || process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY,
+    model = SUMMARIZATION_MODEL,
+    baseUrl = process.env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
+    timeout = 30000,
+  } = options;
+
+  // No API key - fall back to simple summarization
+  if (!apiKey) {
+    return summarizeMessages(messages);
+  }
+
+  try {
+    // Build the conversation text for summarization
+    let conversationText = messages.map((msg) => {
+      const role = msg.role.toUpperCase();
+      const text = extractTextFromMessage(msg);
+
+      // Extract tool info
+      const tools: string[] = [];
+      for (const block of msg.content) {
+        if (block.type === "tool_use") {
+          tools.push(`[TOOL_USE: ${block.name}]`);
+        } else if (block.type === "tool_result") {
+          const resultBlock = block as ToolResultBlock;
+          const preview = typeof resultBlock.content === "string"
+            ? resultBlock.content.slice(0, 200)
+            : "[complex result]";
+          tools.push(`[TOOL_RESULT: ${resultBlock.is_error ? "ERROR" : "OK"}] ${preview}`);
+        }
+      }
+
+      const toolsStr = tools.length > 0 ? `\n${tools.join("\n")}` : "";
+      return `${role}:\n${text.slice(0, 2000)}${toolsStr}`;
+    }).join("\n\n---\n\n");
+
+    // Preprocess with native if content is very large (reduce API costs)
+    const estimatedInputTokens = Math.ceil(conversationText.length / 4);
+    if (estimatedInputTokens > 8000) {
+      // Use native preprocessing to reduce size before LLM
+      conversationText = preprocessContent(conversationText, 6000);
+    }
+
+    // Build request
+    const requestBody = {
+      model,
+      max_tokens: SUMMARY_MAX_TOKENS,
+      system: SUMMARIZATION_SYSTEM_PROMPT,
+      messages: [{
+        role: "user" as const,
+        content: SUMMARIZATION_PROMPT.replace("{{MESSAGES}}", conversationText),
+      }],
+    };
+
+    // Make API call with timeout
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+
+    try {
+      const response = await fetch(`${baseUrl}/v1/messages`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": apiKey,
+          "anthropic-version": "2023-06-01",
+        },
+        body: JSON.stringify(requestBody),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(`\x1b[33m[Compaction] LLM summarization failed: ${response.status} - ${errorText}\x1b[0m`);
+        return summarizeMessages(messages);
+      }
+
+      const data = await response.json() as {
+        content?: Array<{ type: string; text?: string }>;
+        usage?: { input_tokens: number; output_tokens: number };
+      };
+
+      // Extract text from response
+      const summaryText = data.content
+        ?.filter((block) => block.type === "text")
+        .map((block) => block.text || "")
+        .join("\n") || "";
+
+      if (!summaryText) {
+        console.error("\x1b[33m[Compaction] LLM returned empty summary\x1b[0m");
+        return summarizeMessages(messages);
+      }
+
+      // Log usage for debugging
+      if (data.usage) {
+        console.log(`\x1b[90m[Compaction] LLM summary: ${data.usage.input_tokens} in, ${data.usage.output_tokens} out\x1b[0m`);
+      }
+
+      return `[LLM Summary of ${messages.length} messages]\n\n${summaryText}`;
+
+    } finally {
+      clearTimeout(timeoutId);
+    }
+
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`\x1b[33m[Compaction] LLM summarization error: ${errorMsg}\x1b[0m`);
+    // Fall back to simple summarization
+    return summarizeMessages(messages);
+  }
+}
+
+/**
+ * Compact content using native module (exposed for direct use)
+ */
+export function compactContentNative(
+  content: string,
+  maxTokens: number,
+  strategy: "truncate" | "summarize" | "extract" = "extract"
+): string | null {
+  const native = getNative();
+  if (native?.compact_content) {
+    return native.compact_content(content, maxTokens, strategy);
+  }
+  return null;
+}