@ebowwa/coder 0.7.63 → 0.7.64

package/dist/core/context-compaction.js

@@ -0,0 +1,428 @@
+/**
+ * Context Compaction - Reduces context size while preserving important information
+ *
+ * When the context window fills up, we need to compact messages to continue.
+ * This module provides token estimation, summarization, and compaction utilities.
+ */
+import { SUMMARIZATION_MODEL } from "./models.js";
+// ============================================
+// CONSTANTS
+// ============================================
+/** Approximate characters per token (rough estimate for Claude models) */
+const CHARS_PER_TOKEN = 4;
+/** Default number of recent messages to keep during compaction */
+const DEFAULT_KEEP_LAST = 5;
+/** Default number of initial messages to keep (usually just the first user query) */
+const DEFAULT_KEEP_FIRST = 1;
+/** Minimum messages required before compaction is possible */
+const MIN_MESSAGES_FOR_COMPACTION = 8;
+/** Default threshold for proactive compaction (90% of max tokens) */
+const DEFAULT_COMPACTION_THRESHOLD = 0.9;
+/** Maximum length for summary text before truncation */
+const MAX_SUMMARY_LENGTH = 8000;
+/** Maximum tokens for summary output */
+const SUMMARY_MAX_TOKENS = 2000;
+/** System prompt for summarization */
+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 */
+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.`;
+// ============================================
+// TOKEN ESTIMATION
+// ============================================
+/**
+ * Estimate the number of tokens in a text string.
+ * Uses a simple heuristic of ~4 characters per token.
+ * This is a rough estimate; actual tokenization varies by model.
+ */
+export function estimateTokens(text) {
+    if (!text || text.length === 0)
+        return 0;
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+/**
+ * Estimate tokens for a single content block
+ */
+function estimateBlockTokens(block) {
+    switch (block.type) {
+        case "text":
+            return estimateTokens(block.text);
+        case "image":
+            // Images are roughly 85-110 tokens for standard sizes
+            // Use 100 as an average estimate
+            return 100;
+        case "tool_use":
+            // Tool use: name + JSON input
+            const toolInput = JSON.stringify(block.input);
+            return estimateTokens(block.name) + estimateTokens(toolInput) + 10; // overhead
+        case "tool_result":
+            // Tool result: content + metadata
+            if (typeof block.content === "string") {
+                return estimateTokens(block.content) + 10;
+            }
+            return block.content.reduce((sum, b) => sum + estimateBlockTokens(b), 0) + 10;
+        case "thinking":
+            return estimateTokens(block.thinking);
+        default:
+            return 0;
+    }
+}
+/**
+ * Estimate the total number of tokens in a message
+ */
+function estimateMessageTokens(message) {
+    // Role overhead (~4 tokens)
+    const roleOverhead = 4;
+    // Sum all content blocks
+    const contentTokens = message.content.reduce((sum, block) => sum + estimateBlockTokens(block), 0);
+    return roleOverhead + contentTokens;
+}
+/**
+ * Get total estimated tokens across all messages
+ */
+export function estimateMessagesTokens(messages) {
+    if (!messages || messages.length === 0)
+        return 0;
+    return messages.reduce((sum, msg) => sum + estimateMessageTokens(msg), 0);
+}
+// ============================================
+// CONTENT EXTRACTION
+// ============================================
+/**
+ * Extract text content from a message for summarization
+ */
+function extractTextFromMessage(message) {
+    const parts = [];
+    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
+ */
+function extractToolPairs(messages) {
+    const toolPairs = new Map();
+    // 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: block });
+            }
+        }
+    }
+    // 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 = block;
+                }
+            }
+        }
+    }
+    return toolPairs;
+}
+// ============================================
+// SUMMARIZATION
+// ============================================
+/**
+ * Summarize a range of messages into a single text.
+ * This is a simple implementation that concatenates and truncates.
+ * Can be enhanced later with LLM-based summarization.
+ */
+export async function summarizeMessages(messages) {
+    if (!messages || messages.length === 0) {
+        return "";
+    }
+    const summaryParts = [];
+    summaryParts.push(`[Context Summary: ${messages.length} messages compacted]\n`);
+    // Track tool operations for a cleaner summary
+    const toolOperations = [];
+    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
+        for (const block of message.content) {
+            if (block.type === "tool_use") {
+                toolOperations.push(`${block.name}`);
+            }
+        }
+        // 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;
+        }, {});
+        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, options = {}) {
+    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
+        const conversationText = messages.map((msg) => {
+            const role = msg.role.toUpperCase();
+            const text = extractTextFromMessage(msg);
+            // Extract tool info
+            const tools = [];
+            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;
+                    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");
+        // Build request
+        const requestBody = {
+            model,
+            max_tokens: SUMMARY_MAX_TOKENS,
+            system: SUMMARIZATION_SYSTEM_PROMPT,
+            messages: [{
+                    role: "user",
+                    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();
+            // 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 messages to fit within a token limit.
+ *
+ * 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
+ */
+export async function compactMessages(messages, maxTokens, options = {}) {
+    const { keepFirst = DEFAULT_KEEP_FIRST, keepLast = DEFAULT_KEEP_LAST, preserveToolPairs = true, useLLMSummarization = true, // Default to LLM summarization
+    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 = {
+        role: "user",
+        content: [{
+                type: "text",
+                text: `[Previous context has been compacted for continuity]\n\n${summary}`,
+            }],
+    };
+    // Optionally preserve important tool pairs
+    let preservedBlocks = [];
+    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);
+            if (pair.result) {
+                preservedBlocks.push(pair.result);
+            }
+        }
+    }
+    // Build compacted message list
+    const compacted = [
+        ...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, maxTokens, threshold = DEFAULT_COMPACTION_THRESHOLD) {
+    // 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) {
+    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/dist/core/git-status.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Git Status - Retrieve repository status information
+ * Uses Bun subprocess to run git commands
+ */
+import type { GitStatus } from "../types/index.js";
+/**
+ * Get comprehensive git status for a working directory
+ *
+ * @param workingDirectory - The directory to check git status for
+ * @returns GitStatus object if in a git repository, null otherwise
+ */
+export declare function getGitStatus(workingDirectory: string): Promise<GitStatus | null>;
+/**
+ * Check if there are any uncommitted changes
+ */
+export declare function hasUncommittedChanges(status: GitStatus): boolean;
+/**
+ * Check if the repository is clean (no changes and synced with upstream)
+ */
+export declare function isRepositoryClean(status: GitStatus): boolean;
+/**
+ * Get a human-readable summary of the git status
+ */
+export declare function getGitStatusSummary(status: GitStatus): string;
+//# sourceMappingURL=git-status.d.ts.map

package/dist/core/git-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-status.d.ts","sourceRoot":"","sources":["../../packages/src/core/git-status.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AA4KnD;;;;;GAKG;AACH,wBAAsB,YAAY,CAChC,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA6B3B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAOhE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAE5D;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CAuB7D"}

package/dist/core/git-status.js

@@ -0,0 +1,204 @@
+/**
+ * Git Status - Retrieve repository status information
+ * Uses Bun subprocess to run git commands
+ */
+/**
+ * Run a git command and return its output
+ */
+async function runGitCommand(args, cwd) {
+    const proc = Bun.spawn(["git", ...args], {
+        cwd,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    const exitCode = await proc.exited;
+    return { stdout: stdout.trim(), stderr: stderr.trim(), exitCode };
+}
+/**
+ * Check if the directory is a git repository
+ */
+async function isGitRepository(workingDirectory) {
+    const { exitCode } = await runGitCommand(["rev-parse", "--git-dir"], workingDirectory);
+    return exitCode === 0;
+}
+/**
+ * Get the current branch name
+ */
+async function getBranch(workingDirectory) {
+    const { stdout, exitCode } = await runGitCommand(["rev-parse", "--abbrev-ref", "HEAD"], workingDirectory);
+    if (exitCode !== 0) {
+        return "HEAD";
+    }
+    return stdout || "HEAD";
+}
+/**
+ * Get ahead/behind counts compared to upstream
+ */
+async function getAheadBehind(workingDirectory) {
+    const { stdout, exitCode } = await runGitCommand(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], workingDirectory);
+    if (exitCode !== 0 || !stdout) {
+        return { ahead: 0, behind: 0 };
+    }
+    const parts = stdout.split(/\s+/);
+    if (parts.length >= 2 && parts[0] !== undefined && parts[1] !== undefined) {
+        return {
+            ahead: parseInt(parts[0], 10) || 0,
+            behind: parseInt(parts[1], 10) || 0,
+        };
+    }
+    return { ahead: 0, behind: 0 };
+}
+/**
+ * Parse git status porcelain output
+ * Format: XY PATH where X is staged status, Y is unstaged status
+ *
+ * Status codes:
+ * - ' ' (space): unmodified
+ * - 'M': modified
+ * - 'A': added (staged)
+ * - 'D': deleted
+ * - 'R': renamed
+ * - 'C': copied
+ * - 'U': unmerged (conflict)
+ * - '?': untracked
+ * - '!': ignored
+ */
+async function getFileStatus(workingDirectory) {
+    const { stdout, exitCode } = await runGitCommand(["status", "--porcelain"], workingDirectory);
+    if (exitCode !== 0 || !stdout) {
+        return {
+            staged: [],
+            unstaged: [],
+            untracked: [],
+            conflicted: [],
+        };
+    }
+    const staged = [];
+    const unstaged = [];
+    const untracked = [];
+    const conflicted = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+        if (!line)
+            continue;
+        // Porcelain format: XY PATH or XY ORIG_PATH -> PATH
+        const x = line[0]; // Staged status
+        const y = line[1]; // Unstaged status
+        let path = line.substring(3);
+        // Handle renamed files (format: "R  old -> new")
+        if (path.includes(" -> ")) {
+            const splitPath = path.split(" -> ");
+            path = splitPath[1] ?? splitPath[0] ?? path;
+        }
+        // Check for conflicts (U or both A/A, D/D, etc.)
+        const isConflicted = x === "U" ||
+            y === "U" ||
+            (x === "A" && y === "A") ||
+            (x === "D" && y === "D") ||
+            x === "A" && y === "U" ||
+            x === "U" && y === "A" ||
+            x === "D" && y === "U" ||
+            x === "U" && y === "D";
+        if (isConflicted) {
+            conflicted.push(path);
+            continue;
+        }
+        // Untracked files
+        if (x === "?" && y === "?") {
+            untracked.push(path);
+            continue;
+        }
+        // Staged changes (X is not space or ?)
+        if (x !== " " && x !== "?" && x !== "!") {
+            staged.push(path);
+        }
+        // Unstaged changes (Y is not space or ?)
+        if (y !== " " && y !== "?" && y !== "!") {
+            // Don't double-add if already in staged
+            if (!staged.includes(path)) {
+                unstaged.push(path);
+            }
+        }
+    }
+    return { staged, unstaged, untracked, conflicted };
+}
+/**
+ * Get comprehensive git status for a working directory
+ *
+ * @param workingDirectory - The directory to check git status for
+ * @returns GitStatus object if in a git repository, null otherwise
+ */
+export async function getGitStatus(workingDirectory) {
+    try {
+        // First check if this is a git repository
+        const isRepo = await isGitRepository(workingDirectory);
+        if (!isRepo) {
+            return null;
+        }
+        // Run all status queries in parallel for better performance
+        const [branch, aheadBehind, fileStatus] = await Promise.all([
+            getBranch(workingDirectory),
+            getAheadBehind(workingDirectory),
+            getFileStatus(workingDirectory),
+        ]);
+        return {
+            branch,
+            ahead: aheadBehind.ahead,
+            behind: aheadBehind.behind,
+            staged: fileStatus.staged,
+            unstaged: fileStatus.unstaged,
+            untracked: fileStatus.untracked,
+            conflicted: fileStatus.conflicted,
+        };
+    }
+    catch (error) {
+        // Log error for debugging but return null gracefully
+        console.error("Error getting git status:", error);
+        return null;
+    }
+}
+/**
+ * Check if there are any uncommitted changes
+ */
+export function hasUncommittedChanges(status) {
+    return (status.staged.length > 0 ||
+        status.unstaged.length > 0 ||
+        status.untracked.length > 0 ||
+        status.conflicted.length > 0);
+}
+/**
+ * Check if the repository is clean (no changes and synced with upstream)
+ */
+export function isRepositoryClean(status) {
+    return !hasUncommittedChanges(status) && status.ahead === 0 && status.behind === 0;
+}
+/**
+ * Get a human-readable summary of the git status
+ */
+export function getGitStatusSummary(status) {
+    const parts = [];
+    parts.push(`branch: ${status.branch}`);
+    if (status.ahead > 0 || status.behind > 0) {
+        const sync = [];
+        if (status.ahead > 0)
+            sync.push(`ahead ${status.ahead}`);
+        if (status.behind > 0)
+            sync.push(`behind ${status.behind}`);
+        parts.push(`(${sync.join(", ")})`);
+    }
+    const changes = [];
+    if (status.staged.length > 0)
+        changes.push(`${status.staged.length} staged`);
+    if (status.unstaged.length > 0)
+        changes.push(`${status.unstaged.length} unstaged`);
+    if (status.untracked.length > 0)
+        changes.push(`${status.untracked.length} untracked`);
+    if (status.conflicted.length > 0)
+        changes.push(`${status.conflicted.length} conflicted`);
+    if (changes.length > 0) {
+        parts.push(`[${changes.join(", ")}]`);
+    }
+    return parts.join(" ");
+}