@ebowwa/coder 0.7.64 → 0.7.66

package/packages/src/core/cognitive-security/hooks.ts

@@ -493,7 +493,8 @@ export class CognitiveSecurityHooks {
     if (this.config.logEvents) {
       const prefix = action === "deny" ? "\x1b[31m[Security]\x1b[0m" : "\x1b[90m[Security]\x1b[0m";
       const toolStr = tool ? ` ${tool}:` : "";
-      console.log(`${prefix}${toolStr} ${reason}`);
+      // Use console.error to avoid interfering with TUI (stdout is used by renderer)
+      console.error(`${prefix}${toolStr} ${reason}`);
     }
   }
 

package/packages/src/core/config/todo

@@ -0,0 +1,7 @@
+mv
+- /Users/ebowwa/Desktop/codespaces/packages/src/coder/packages/src/core/claude-md.ts
+- /Users/ebowwa/Desktop/codespaces/packages/src/coder/packages/src/core/config-loader.ts
+- /Users/ebowwa/Desktop/codespaces/packages/src/coder/packages/src/core/models.ts
+- /Users/ebowwa/Desktop/codespaces/packages/src/coder/packages/src/core/permissions.ts
+
+here aqi

package/packages/src/core/context/__tests__/integration.test.ts

@@ -0,0 +1,334 @@
+import { describe, it, expect } from "bun:test";
+import { compactMessages, needsCompaction, getCompactionStats } from "../compaction.js";
+import { LoopState } from "../../agent-loop/loop-state.js";
+import type { Message, ContentBlock } from "../../../types/index.js";
+
+/**
+ * Integration tests for context compaction module
+ * Tests compaction, token estimation, and LoopState integration
+ */
+describe("Context Compaction Integration", () => {
+  // Helper to create text content blocks
+  const textBlock = (text: string): ContentBlock => ({ type: "text", text });
+
+  // Helper to create messages
+  const userMessage = (content: string | ContentBlock[]): Message => ({
+    role: "user",
+    content: Array.isArray(content) ? content : [textBlock(content)]
+  });
+
+  const assistantMessage = (content: string | ContentBlock[]): Message => ({
+    role: "assistant",
+    content: Array.isArray(content) ? content : [textBlock(content)]
+  });
+
+  describe("needsCompaction", () => {
+    it("returns false for empty messages", () => {
+      const messages: Message[] = [];
+      const result = needsCompaction(messages, 1000);
+      expect(result).toBe(false);
+    });
+
+    it("returns false for small messages", () => {
+      const messages = [
+        userMessage("Hello"),
+        assistantMessage("Hi there!")
+      ];
+      
+      const result = needsCompaction(messages, 100000);
+      expect(result).toBe(false);
+    });
+
+    it("returns true when exceeding threshold", () => {
+      // Add many large messages to exceed threshold
+      const messages: Message[] = [];
+      for (let i = 0; i < 100; i++) {
+        messages.push(userMessage("This is a test message ".repeat(100)));
+        messages.push(assistantMessage("This is a response message ".repeat(100)));
+      }
+      
+      const result = needsCompaction(messages, 1000);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("compactMessages", () => {
+    it("compacts messages while preserving first and last", async () => {
+      const messages: Message[] = [];
+      
+      // First messages (to preserve)
+      messages.push(userMessage("Initial question"));
+      messages.push(assistantMessage("Initial response"));
+      
+      // Middle messages (to summarize)
+      for (let i = 0; i < 20; i++) {
+        messages.push(userMessage(`User question ${i}: ` + "test ".repeat(50)));
+        messages.push(assistantMessage(`Assistant answer ${i}: ` + "response ".repeat(50)));
+      }
+      
+      // Last messages (to preserve)
+      messages.push(userMessage("Final question"));
+      messages.push(assistantMessage("Final response"));
+
+      // Use lower maxTokens to ensure compaction triggers
+      const result = await compactMessages(messages, 500, {
+        keepFirst: 2,
+        keepLast: 2,
+        useLLMSummarization: false
+      });
+
+      // Verify compaction occurred
+      expect(result.didCompact).toBe(true);
+      expect(result.messages.length).toBeLessThan(messages.length);
+      expect(result.messages.length).toBeGreaterThan(0);
+      expect(result.tokensAfter).toBeLessThan(result.tokensBefore);
+      
+      // Verify first messages preserved
+      expect(result.messages[0]).toEqual(messages[0]);
+      expect(result.messages[1]).toEqual(messages[1]);
+      
+      // Verify last messages preserved
+      const lastIdx = result.messages.length - 1;
+      expect(result.messages[lastIdx - 1]).toEqual(messages[messages.length - 2]);
+      expect(result.messages[lastIdx]).toEqual(messages[messages.length - 1]);
+      
+      // Verify summary inserted
+      const hasSummary = result.messages.some(m => 
+        m.content.some(block => 
+          block.type === "text" && 
+          (block as any).text?.includes("compacted")
+        )
+      );
+      expect(hasSummary).toBe(true);
+    });
+
+    it("handles empty messages gracefully", async () => {
+      const messages: Message[] = [];
+      
+      const result = await compactMessages(messages, 1000);
+      
+      expect(result.messages).toEqual([]);
+      expect(result.didCompact).toBe(false);
+    });
+
+    it("returns unchanged if under token limit", async () => {
+      const messages = [
+        userMessage("Hello"),
+        assistantMessage("Hi!")
+      ];
+      
+      const result = await compactMessages(messages, 100000);
+      
+      expect(result.didCompact).toBe(false);
+      expect(result.messages).toEqual(messages);
+    });
+
+    it("preserves tool use and tool result pairs", async () => {
+      const messages: Message[] = [
+        userMessage("Read the file"),
+        {
+          role: "assistant",
+          content: [
+            textBlock("I'll read the file."),
+            { type: "tool_use", id: "tool-1", name: "Read", input: { file_path: "/test.txt" } }
+          ]
+        },
+        {
+          role: "user",
+          content: [
+            { type: "tool_result", tool_use_id: "tool-1", content: "File contents here" }
+          ]
+        },
+        assistantMessage("The file contains test data.")
+      ];
+
+      const result = await compactMessages(messages, 500, {
+        keepFirst: 1,
+        keepLast: 1,
+        preserveToolPairs: true,
+        useLLMSummarization: false
+      });
+
+      // Should have compacted with tool pairs preserved
+      expect(result.messages.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("getCompactionStats", () => {
+    it("returns zero stats for no compaction", () => {
+      const result = {
+        messages: [],
+        messagesRemoved: 0,
+        tokensBefore: 100,
+        tokensAfter: 100,
+        didCompact: false
+      };
+      
+      const stats = getCompactionStats(result);
+      
+      expect(stats.reductionPercent).toBe(0);
+      expect(stats.tokensSaved).toBe(0);
+    });
+
+    it("calculates correct stats after compaction", () => {
+      const result = {
+        messages: [],
+        messagesRemoved: 50,
+        tokensBefore: 1000,
+        tokensAfter: 300,
+        didCompact: true
+      };
+      
+      const stats = getCompactionStats(result);
+      
+      expect(stats.tokensSaved).toBe(700);
+      expect(stats.reductionPercent).toBeCloseTo(70, 0);
+    });
+  });
+
+  describe("LoopState integration", () => {
+    it("LoopState.applyCompaction works with compactMessages result", async () => {
+      const initialMessages: Message[] = [];
+      for (let i = 0; i < 30; i++) {
+        initialMessages.push(userMessage(`Message ${i}: ` + "x".repeat(100)));
+        initialMessages.push(assistantMessage(`Response ${i}: ` + "y".repeat(100)));
+      }
+      
+      const loopState = new LoopState(initialMessages);
+      
+      // Compact
+      const compactionResult = await compactMessages(loopState.messages, 5000, {
+        keepFirst: 2,
+        keepLast: 4,
+        useLLMSummarization: false
+      });
+      
+      // Apply to state
+      const applied = loopState.applyCompaction(compactionResult, getCompactionStats);
+      
+      if (compactionResult.didCompact) {
+        expect(applied).toBe(true);
+        expect(loopState.messages.length).toBeLessThan(initialMessages.length);
+        expect(loopState.compactionCount).toBe(1);
+        expect(loopState.totalTokensCompacted).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe("extraction and summarization integration", () => {
+    it("extracts text correctly from mixed content blocks", async () => {
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: [
+            textBlock("Here's my question:"),
+            { type: "image", source: { type: "base64", media_type: "image/png", data: "abc123" } } as ContentBlock,
+            textBlock("Please help with this.")
+          ]
+        },
+        assistantMessage("I'll help you with that.")
+      ];
+
+      const result = await compactMessages(messages, 500, {
+        useLLMSummarization: false
+      });
+
+      // Text should be handled, image preserved or summarized
+      expect(result.messages.length).toBeGreaterThan(0);
+    });
+
+    it("summarizes long conversations effectively", async () => {
+      const messages: Message[] = [
+        userMessage("I need to build a REST API"),
+        assistantMessage("I'll help you build a REST API. What framework?"),
+        userMessage("Express.js"),
+        assistantMessage("Great choice. Let's set up routes.")
+      ];
+
+      // Add more conversation to ensure we exceeds token limit
+      for (let i = 0; i < 30; i++) {
+        messages.push(userMessage(`Question about route ${i}: ` + "test ".repeat(100)));
+        messages.push(assistantMessage(`Answer about route ${i}: ` + "response ".repeat(100)));
+      }
+
+      // Use a very low token limit to force compaction
+      const result = await compactMessages(messages, 100, {
+        keepFirst: 2,
+        keepLast: 4,
+        useLLMSummarization: false
+      });
+
+      // Should have summary of earlier conversation
+      expect(result.didCompact).toBe(true);
+      expect(result.messages.length).toBeLessThan(messages.length);
+      expect(result.messagesRemoved).toBeGreaterThan(0);
+    });
+  });
+
+  describe("performance with large contexts", () => {
+    it("handles 100+ messages efficiently", async () => {
+      const messages: Message[] = [];
+      
+      // Add 100 messages
+      for (let i = 0; i < 100; i++) {
+        messages.push(userMessage(`User ${i}: ` + "test ".repeat(20)));
+        messages.push(assistantMessage(`Assistant ${i}: ` + "response ".repeat(20)));
+      }
+
+      const startTime = Date.now();
+      
+      const result = await compactMessages(messages, 5000, {
+        keepFirst: 2,
+        keepLast: 4,
+        useLLMSummarization: false
+      });
+      
+      const duration = Date.now() - startTime;
+
+      // Should complete in reasonable time (< 5s for integration test)
+      expect(duration).toBeLessThan(5000);
+      expect(result.didCompact).toBe(true);
+      expect(result.messages.length).toBeLessThan(200);
+    });
+  });
+
+  describe("error handling and edge cases", () => {
+    it("handles messages with empty content", async () => {
+      const messages: Message[] = [
+        { role: "user", content: [] },
+        { role: "assistant", content: [] }
+      ];
+      
+      const result = await compactMessages(messages, 1000);
+      
+      expect(result.messages).toBeDefined();
+      expect(result.didCompact).toBe(false);
+    });
+
+    it("handles malformed content blocks gracefully", async () => {
+      const messages: Message[] = [
+        {
+          role: "user",
+          content: [
+            { type: "unknown" } as unknown as ContentBlock,
+            textBlock("Valid text")
+          ]
+        }
+      ];
+
+      const result = await compactMessages(messages, 1000);
+      
+      expect(result.messages.length).toBeGreaterThan(0);
+    });
+
+    it("handles very large single messages", async () => {
+      const hugeText = "x".repeat(100000);
+      const messages = [userMessage(hugeText)];
+
+      const result = await compactMessages(messages, 1000);
+
+      // Should return as-is (not enough messages to compact)
+      expect(result.messages.length).toBe(1);
+    });
+  });
+});

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;
+}