scalix 0.0.1 → 1.1.0

package/dist/context-manager.js

@@ -0,0 +1,148 @@
+import { messageContentToString } from './agent.js';
+import { estimateTokens, estimateMessageTokens as _estimateMessageTokens } from './token-counter.js';
+import { CONTEXT_DEFAULTS, COMPRESSION_DEFAULTS } from './constants.js';
+export { estimateTokens };
+export function estimateMessageTokens(messages) {
+    return _estimateMessageTokens(messages);
+}
+export class ContextManager {
+    maxContextTokens;
+    compressionThreshold;
+    minRecentMessages;
+    maxToolResultTokens;
+    charsPerToken;
+    slidingWindowTarget;
+    constructor(config) {
+        this.maxContextTokens = config?.maxContextTokens ?? CONTEXT_DEFAULTS.maxContextTokens;
+        this.compressionThreshold = config?.compressionThreshold ?? CONTEXT_DEFAULTS.compressionThreshold;
+        this.minRecentMessages = config?.minRecentMessages ?? CONTEXT_DEFAULTS.minRecentMessages;
+        this.maxToolResultTokens = config?.maxToolResultTokens ?? CONTEXT_DEFAULTS.maxToolResultTokens;
+        this.charsPerToken = config?.charsPerToken ?? CONTEXT_DEFAULTS.charsPerToken;
+        this.slidingWindowTarget = config?.slidingWindowTarget ?? CONTEXT_DEFAULTS.slidingWindowTarget;
+    }
+    setMaxContextTokens(tokens) {
+        if (tokens > 0)
+            this.maxContextTokens = tokens;
+    }
+    shouldCompress(messages) {
+        const tokens = estimateMessageTokens(messages);
+        return tokens > this.maxContextTokens * this.compressionThreshold;
+    }
+    getTokenUsage(messages) {
+        const tokens = estimateMessageTokens(messages);
+        return {
+            tokens,
+            maxTokens: this.maxContextTokens,
+            percentage: Math.round((tokens / this.maxContextTokens) * 100),
+        };
+    }
+    truncateToolResults(messages) {
+        const maxChars = this.maxToolResultTokens * this.charsPerToken;
+        return messages.map((msg) => {
+            if (msg.role !== 'tool' || !msg.content)
+                return msg;
+            const text = messageContentToString(msg.content);
+            const tokens = estimateTokens(text);
+            if (tokens <= this.maxToolResultTokens)
+                return msg;
+            let cutoff = Math.floor(maxChars);
+            while (cutoff > 0 && text.charCodeAt(cutoff) >= 0xDC00 && text.charCodeAt(cutoff) <= 0xDFFF) {
+                cutoff--;
+            }
+            const truncated = text.slice(0, cutoff) +
+                '\n\n...[truncated — ' + (tokens - this.maxToolResultTokens) + ' tokens removed]';
+            return { ...msg, content: truncated };
+        });
+    }
+    splitForCompression(messages) {
+        if (messages.length <= this.minRecentMessages) {
+            return { toCompress: [], toKeep: [...messages] };
+        }
+        const keepCount = Math.max(this.minRecentMessages, Math.floor(messages.length * COMPRESSION_DEFAULTS.keepRatio));
+        let splitIndex = messages.length - keepCount;
+        // Walk backwards to avoid splitting tool-call/result pairs
+        while (splitIndex > 0) {
+            const msg = messages[splitIndex];
+            if (msg.role === 'tool') {
+                splitIndex--;
+                if (splitIndex > 0 && messages[splitIndex]?.role === 'assistant' && messages[splitIndex]?.tool_calls) {
+                    splitIndex--;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        splitIndex = Math.max(0, splitIndex);
+        return {
+            toCompress: messages.slice(0, splitIndex),
+            toKeep: messages.slice(splitIndex),
+        };
+    }
+    buildCompressionPrompt(messages) {
+        const maxPerMessage = 4000;
+        const formatted = messages.map((m) => {
+            let line = `[${m.role}]`;
+            if (m.name)
+                line += ` (${m.name})`;
+            if (m.content) {
+                const text = messageContentToString(m.content);
+                const display = text.length > maxPerMessage
+                    ? text.slice(0, maxPerMessage) + `\n...[${text.length - maxPerMessage} chars omitted]`
+                    : text;
+                line += `: ${display}`;
+            }
+            if (m.tool_calls) {
+                const calls = m.tool_calls.map((tc) => {
+                    const args = tc.function.arguments;
+                    const preview = args.length > 200 ? args.slice(0, 200) + '...' : args;
+                    return `${tc.function.name}(${preview})`;
+                });
+                line += `: called ${calls.join(', ')}`;
+            }
+            return line;
+        }).join('\n');
+        return `You are compressing a conversation to fit within the context window. The compressed output will REPLACE the original messages — anything you omit is permanently lost.
+
+MUST PRESERVE (verbatim where possible):
+1. The user's goal — what they are trying to accomplish and why
+2. Every file path, function name, and line number mentioned
+3. Every error message, stack trace, and fix applied
+4. What was tried, what worked, what failed, and why
+5. The user's explicit preferences, corrections, and instructions
+6. Pending/incomplete work and next steps
+7. Key code snippets, commands run, and their results
+8. Configuration values, environment details, model names
+
+DO NOT preserve greetings, acknowledgments, thinking-out-loud, or redundant explanations.
+
+Conversation to compress:
+${formatted}
+
+Write a detailed, factual summary. Use specific names, paths, and values — not vague references. This summary is the agent's only memory of this work:`;
+    }
+    applySlidingWindow(messages) {
+        const usage = this.getTokenUsage(messages);
+        if (usage.percentage < 95)
+            return messages;
+        const target = this.maxContextTokens * this.slidingWindowTarget;
+        const result = [...messages];
+        while (estimateMessageTokens(result) > target && result.length > this.minRecentMessages) {
+            const removed = result.shift();
+            // Remove orphaned tool results: if we removed an assistant with tool_calls,
+            // also remove its paired tool results
+            if (removed?.role === 'assistant' && removed.tool_calls) {
+                const toolCallIds = new Set(removed.tool_calls.map((tc) => tc.id));
+                while (result.length > 0 && result[0]?.role === 'tool' && result[0]?.tool_call_id && toolCallIds.has(result[0].tool_call_id)) {
+                    result.shift();
+                }
+            }
+            // If we're about to leave orphaned tool results at the front (their assistant was already removed),
+            // clean them up
+            while (result.length > 0 && result[0]?.role === 'tool') {
+                result.shift();
+            }
+        }
+        return result;
+    }
+}

package/dist/context-retriever.js

@@ -0,0 +1,257 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { estimateTokens } from './token-counter.js';
+export const RETRIEVAL_DEFAULTS = {
+    enabled: true,
+    maxSnippets: 5,
+    maxTokensPerSnippet: 500,
+    maxTotalTokens: 3000,
+    previewLines: 30,
+    minRelevanceScore: 0.3,
+};
+const STOP_WORDS = new Set([
+    'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
+    'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by', 'from',
+    'and', 'or', 'but', 'not', 'no', 'so', 'if', 'then', 'else',
+    'do', 'does', 'did', 'will', 'would', 'should', 'could', 'can',
+    'has', 'have', 'had', 'this', 'that', 'these', 'those',
+    'it', 'its', 'i', 'me', 'my', 'we', 'our', 'you', 'your',
+    'he', 'she', 'they', 'them', 'what', 'which', 'who', 'how',
+    'when', 'where', 'why', 'all', 'each', 'every', 'any', 'some',
+    'about', 'up', 'out', 'just', 'also', 'than', 'very',
+    'code', 'file', 'function', 'change', 'make', 'use', 'using',
+    'want', 'need', 'like', 'please', 'help', 'show', 'get',
+]);
+const FILE_HINT_RE = /(?:^|[\s`"'(])([.\w][\w./-]*\/[\w./-]+\.\w{1,10})(?=[\s`"'),.:;]|$)/gm;
+const CAMEL_RE = /\b([A-Z][a-zA-Z]{2,})\b/g;
+const SNAKE_RE = /\b([a-z][a-z0-9]*(?:_[a-z0-9]+){1,})\b/g;
+const INTENT_PATTERNS = {
+    debug: /\b(?:fix|debug|error|bug|broken|crash|fail|issue|wrong|problem)\b/i,
+    create: /\b(?:create|add|new|implement|build|generate|write|introduce)\b/i,
+    modify: /\b(?:change|update|modify|refactor|rename|move|replace|improve|optimize)\b/i,
+    explore: /\b(?:read|show|explain|understand|find|search|look|what|where|how|list|describe)\b/i,
+    general: /./,
+};
+export function analyzeQuery(query) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const keywords = words.filter((w) => !STOP_WORDS.has(w) && w.length > 2);
+    const fileHints = [];
+    for (const m of query.matchAll(FILE_HINT_RE)) {
+        fileHints.push(m[1]);
+    }
+    const symbolHints = [];
+    for (const m of query.matchAll(CAMEL_RE)) {
+        symbolHints.push(m[1]);
+    }
+    for (const m of query.matchAll(SNAKE_RE)) {
+        symbolHints.push(m[1]);
+    }
+    let intentType = 'general';
+    for (const [intent, re] of Object.entries(INTENT_PATTERNS)) {
+        if (intent === 'general')
+            continue;
+        if (re.test(query)) {
+            intentType = intent;
+            break;
+        }
+    }
+    return { keywords, fileHints, symbolHints, intentType };
+}
+function scoreFiles(analysis, index) {
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const importGraph = new Map();
+    for (const imp of index.imports) {
+        const deps = importGraph.get(imp.from) ?? new Set();
+        deps.add(imp.to);
+        importGraph.set(imp.from, deps);
+    }
+    const recentFiles = new Set(index.files
+        .sort((a, b) => b.modifiedAt - a.modifiedAt)
+        .slice(0, 20)
+        .map((f) => f.relativePath));
+    const directMentionFiles = new Set();
+    for (const hint of analysis.fileHints) {
+        for (const f of index.files) {
+            if (f.relativePath === hint || f.relativePath.endsWith(hint)) {
+                directMentionFiles.add(f.relativePath);
+            }
+        }
+    }
+    const scores = [];
+    for (const file of index.files) {
+        let score = 0;
+        const reasons = [];
+        const matchingSymbols = [];
+        // Direct file mention
+        if (directMentionFiles.has(file.relativePath)) {
+            score += 1.0;
+            reasons.push('directly mentioned');
+        }
+        // Symbol match
+        const fileSymbols = symbolsByFile.get(file.relativePath) ?? [];
+        for (const sym of fileSymbols) {
+            const nameLower = sym.name.toLowerCase();
+            if (analysis.symbolHints.some((h) => h.toLowerCase() === nameLower)) {
+                score += 0.6;
+                matchingSymbols.push(sym.name);
+                reasons.push(`symbol "${sym.name}"`);
+            }
+            else if (analysis.keywords.some((k) => nameLower.includes(k))) {
+                score += 0.3;
+                matchingSymbols.push(sym.name);
+                reasons.push(`keyword in symbol "${sym.name}"`);
+            }
+        }
+        // Import proximity — file is imported by a directly-mentioned file
+        for (const mentionedFile of directMentionFiles) {
+            const deps = importGraph.get(mentionedFile);
+            if (deps?.has(file.relativePath)) {
+                score += 0.3;
+                reasons.push(`imported by ${mentionedFile}`);
+            }
+        }
+        // Keyword in path
+        const pathLower = file.relativePath.toLowerCase();
+        for (const kw of analysis.keywords) {
+            if (pathLower.includes(kw)) {
+                score += 0.2;
+                reasons.push(`keyword "${kw}" in path`);
+            }
+        }
+        // Recency bonus
+        if (recentFiles.has(file.relativePath)) {
+            score += 0.1;
+            reasons.push('recently modified');
+        }
+        if (score > 0) {
+            scores.push({
+                file: file.relativePath,
+                score: Math.min(score, 2.0),
+                matchingSymbols,
+                reason: reasons.join(', '),
+            });
+        }
+    }
+    return scores.sort((a, b) => b.score - a.score);
+}
+async function generatePreview(filePath, projectRoot, matchingSymbols, maxLines) {
+    try {
+        const absPath = path.join(projectRoot, filePath);
+        const content = await fs.readFile(absPath, 'utf-8');
+        const lines = content.split('\n');
+        if (matchingSymbols.length > 0) {
+            // Show lines around matching symbols
+            const ranges = [];
+            for (const sym of matchingSymbols.slice(0, 3)) {
+                const start = Math.max(0, sym.line - 2);
+                const end = Math.min(lines.length - 1, sym.line + 8);
+                ranges.push([start, end]);
+            }
+            // Merge overlapping ranges
+            ranges.sort((a, b) => a[0] - b[0]);
+            const merged = [ranges[0]];
+            for (let i = 1; i < ranges.length; i++) {
+                const prev = merged[merged.length - 1];
+                if (ranges[i][0] <= prev[1] + 2) {
+                    prev[1] = Math.max(prev[1], ranges[i][1]);
+                }
+                else {
+                    merged.push(ranges[i]);
+                }
+            }
+            const parts = [];
+            let totalLines = 0;
+            for (const [start, end] of merged) {
+                if (totalLines >= maxLines)
+                    break;
+                const available = maxLines - totalLines;
+                const rangeEnd = Math.min(end, start + available - 1);
+                for (let i = start; i <= rangeEnd; i++) {
+                    parts.push(`${i + 1}\t${lines[i]}`);
+                    totalLines++;
+                }
+                if (rangeEnd < end)
+                    break;
+                parts.push('...');
+            }
+            return parts.join('\n');
+        }
+        // No matching symbols — show first N lines
+        return lines
+            .slice(0, maxLines)
+            .map((l, i) => `${i + 1}\t${l}`)
+            .join('\n');
+    }
+    catch {
+        return '(file could not be read)';
+    }
+}
+export async function retrieveContext(query, index, config = RETRIEVAL_DEFAULTS) {
+    const analysis = analyzeQuery(query);
+    if (analysis.keywords.length === 0 && analysis.fileHints.length === 0 && analysis.symbolHints.length === 0) {
+        return { snippets: [], totalTokens: 0, queryTerms: [] };
+    }
+    const scored = scoreFiles(analysis, index);
+    const candidates = scored.filter((s) => s.score >= config.minRelevanceScore).slice(0, config.maxSnippets);
+    const symbolsByFile = new Map();
+    for (const sym of index.symbols) {
+        const existing = symbolsByFile.get(sym.file) ?? [];
+        existing.push(sym);
+        symbolsByFile.set(sym.file, existing);
+    }
+    const snippets = [];
+    let totalTokens = 0;
+    for (const candidate of candidates) {
+        if (totalTokens >= config.maxTotalTokens)
+            break;
+        const matchingSymbols = (symbolsByFile.get(candidate.file) ?? [])
+            .filter((s) => candidate.matchingSymbols.includes(s.name));
+        const preview = await generatePreview(candidate.file, index.root, matchingSymbols, config.previewLines);
+        let tokens = estimateTokens(preview);
+        let truncatedPreview = preview;
+        if (tokens > config.maxTokensPerSnippet) {
+            const lines = preview.split('\n');
+            const kept = [];
+            let running = 0;
+            for (const line of lines) {
+                const lt = estimateTokens(line);
+                if (running + lt > config.maxTokensPerSnippet)
+                    break;
+                kept.push(line);
+                running += lt;
+            }
+            truncatedPreview = kept.join('\n');
+            tokens = running;
+        }
+        if (totalTokens + tokens > config.maxTotalTokens)
+            break;
+        snippets.push({
+            file: candidate.file,
+            relevanceScore: candidate.score,
+            symbols: candidate.matchingSymbols,
+            preview: truncatedPreview,
+            reason: candidate.reason,
+        });
+        totalTokens += tokens;
+    }
+    return { snippets, totalTokens, queryTerms: analysis.keywords };
+}
+export function snippetsToContext(snippets) {
+    if (snippets.length === 0)
+        return '';
+    const parts = ['## Relevant Code Context',
+        'The following file excerpts may be relevant. Use this as ground truth rather than guessing.\n'];
+    for (const s of snippets) {
+        const symbolStr = s.symbols.length > 0 ? `\nSymbols: ${s.symbols.join(', ')}` : '';
+        parts.push(`### ${s.file} (score: ${s.relevanceScore.toFixed(1)})${symbolStr}`);
+        parts.push('```');
+        parts.push(s.preview);
+        parts.push('```\n');
+    }
+    return parts.join('\n');
+}

package/dist/cost-tracker.js

@@ -0,0 +1,85 @@
+export class CostTracker {
+    entries = [];
+    sessionStart = Date.now();
+    record(model, usage) {
+        this.entries.push({
+            model,
+            promptTokens: usage.prompt_tokens ?? 0,
+            completionTokens: usage.completion_tokens ?? 0,
+            totalTokens: usage.total_tokens ?? 0,
+            cost: usage.cost ?? 0,
+            timestamp: Date.now(),
+        });
+    }
+    get totalTokens() {
+        return this.entries.reduce((s, e) => s + e.totalTokens, 0);
+    }
+    get totalCost() {
+        return this.entries.reduce((s, e) => s + e.cost, 0);
+    }
+    get promptTokens() {
+        return this.entries.reduce((s, e) => s + e.promptTokens, 0);
+    }
+    get completionTokens() {
+        return this.entries.reduce((s, e) => s + e.completionTokens, 0);
+    }
+    get requestCount() {
+        return this.entries.length;
+    }
+    get sessionDuration() {
+        const s = Math.floor((Date.now() - this.sessionStart) / 1000);
+        if (s < 60)
+            return `${s}s`;
+        if (s < 3600)
+            return `${Math.floor(s / 60)}m${s % 60}s`;
+        return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
+    }
+    summary() {
+        const lines = [
+            `Session: ${this.sessionDuration} | ${this.requestCount} requests`,
+            `Tokens: ${this.totalTokens.toLocaleString()} (${this.promptTokens.toLocaleString()} prompt + ${this.completionTokens.toLocaleString()} completion)`,
+        ];
+        const byModel = new Map();
+        for (const e of this.entries) {
+            if (e.model === '(previous session)')
+                continue;
+            const prev = byModel.get(e.model) ?? { tokens: 0, count: 0 };
+            byModel.set(e.model, { tokens: prev.tokens + e.totalTokens, count: prev.count + 1 });
+        }
+        if (byModel.size > 0) {
+            lines.push('By model:');
+            for (const [model, stats] of byModel) {
+                const short = model.split('/').pop()?.replace(/:free$/, '') ?? model;
+                lines.push(`  ${short}: ${stats.tokens.toLocaleString()} tokens (${stats.count} reqs)`);
+            }
+        }
+        return lines.join('\n');
+    }
+    reset() {
+        this.entries = [];
+        this.sessionStart = Date.now();
+    }
+    restore(state) {
+        this.entries = [];
+        if (state.requestCount > 0 && state.totalTokens >= 0) {
+            const count = Math.max(1, state.requestCount);
+            const perReqTokens = Math.floor(state.totalTokens / count);
+            const remainder = state.totalTokens - perReqTokens * count;
+            const perReqCost = state.totalCost / count;
+            for (let i = 0; i < count; i++) {
+                this.entries.push({
+                    model: '(previous session)',
+                    promptTokens: 0,
+                    completionTokens: 0,
+                    totalTokens: perReqTokens + (i === 0 ? remainder : 0),
+                    cost: perReqCost,
+                    timestamp: Date.now(),
+                });
+            }
+        }
+    }
+    getState() {
+        return { totalTokens: this.totalTokens, totalCost: this.totalCost, requestCount: this.requestCount };
+    }
+}
+export const costTracker = new CostTracker();

package/dist/diff.js

@@ -0,0 +1,140 @@
+function lcsLengths(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
+        }
+    }
+    return dp;
+}
+function backtrack(dp, a, b) {
+    const lines = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+        if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+            lines.push({ type: 'context', lineOld: i, lineNew: j, text: a[i - 1] });
+            i--;
+            j--;
+        }
+        else if (j > 0 && (i === 0 || dp[i][j - 1] > dp[i - 1][j])) {
+            lines.push({ type: 'add', lineNew: j, text: b[j - 1] });
+            j--;
+        }
+        else {
+            lines.push({ type: 'remove', lineOld: i, text: a[i - 1] });
+            i--;
+        }
+    }
+    return lines.reverse();
+}
+const LARGE_FILE_THRESHOLD = 50_000;
+function simpleDiff(oldLines, newLines) {
+    const lines = [];
+    const oldSet = new Map();
+    oldLines.forEach((l, i) => {
+        if (!oldSet.has(l))
+            oldSet.set(l, []);
+        oldSet.get(l).push(i + 1);
+    });
+    let commonPrefix = 0;
+    while (commonPrefix < oldLines.length && commonPrefix < newLines.length && oldLines[commonPrefix] === newLines[commonPrefix]) {
+        lines.push({ type: 'context', lineOld: commonPrefix + 1, lineNew: commonPrefix + 1, text: oldLines[commonPrefix] });
+        commonPrefix++;
+    }
+    let commonSuffix = 0;
+    while (commonSuffix < oldLines.length - commonPrefix &&
+        commonSuffix < newLines.length - commonPrefix &&
+        oldLines[oldLines.length - 1 - commonSuffix] === newLines[newLines.length - 1 - commonSuffix]) {
+        commonSuffix++;
+    }
+    for (let i = commonPrefix; i < oldLines.length - commonSuffix; i++) {
+        lines.push({ type: 'remove', lineOld: i + 1, text: oldLines[i] });
+    }
+    for (let i = commonPrefix; i < newLines.length - commonSuffix; i++) {
+        lines.push({ type: 'add', lineNew: i + 1, text: newLines[i] });
+    }
+    for (let s = commonSuffix - 1; s >= 0; s--) {
+        const oldIdx = oldLines.length - 1 - s;
+        const newIdx = newLines.length - 1 - s;
+        lines.push({ type: 'context', lineOld: oldIdx + 1, lineNew: newIdx + 1, text: oldLines[oldIdx] });
+    }
+    return lines;
+}
+export function computeDiff(oldText, newText) {
+    if (oldText === newText)
+        return { hunks: [], additions: 0, deletions: 0 };
+    const oldLines = oldText === '' ? [] : oldText.split('\n');
+    const newLines = newText === '' ? [] : newText.split('\n');
+    const isLarge = oldLines.length > LARGE_FILE_THRESHOLD || newLines.length > LARGE_FILE_THRESHOLD;
+    const allLines = isLarge
+        ? simpleDiff(oldLines, newLines)
+        : backtrack(lcsLengths(oldLines, newLines), oldLines, newLines);
+    const hunks = [];
+    let currentHunk = [];
+    let contextCount = 0;
+    const CONTEXT_SIZE = 3;
+    for (let idx = 0; idx < allLines.length; idx++) {
+        const line = allLines[idx];
+        if (line.type === 'context') {
+            contextCount++;
+            if (currentHunk.length > 0 && contextCount > CONTEXT_SIZE * 2) {
+                hunks.push(currentHunk);
+                currentHunk = [];
+                contextCount = 1;
+            }
+            if (currentHunk.length > 0 || contextCount <= CONTEXT_SIZE) {
+                currentHunk.push(line);
+            }
+        }
+        else {
+            if (contextCount > CONTEXT_SIZE && currentHunk.length === 0) {
+                for (let k = Math.max(0, idx - CONTEXT_SIZE); k < idx; k++) {
+                    if (allLines[k].type === 'context')
+                        currentHunk.push(allLines[k]);
+                }
+            }
+            currentHunk.push(line);
+            contextCount = 0;
+        }
+    }
+    if (currentHunk.some((l) => l.type !== 'context')) {
+        hunks.push(currentHunk);
+    }
+    const additions = allLines.filter((l) => l.type === 'add').length;
+    const deletions = allLines.filter((l) => l.type === 'remove').length;
+    return { hunks, additions, deletions };
+}
+export function formatDiff(diff, filePath) {
+    if (diff.hunks.length === 0)
+        return '(no changes)';
+    const lines = [];
+    if (filePath) {
+        lines.push(`--- ${filePath}`);
+        lines.push(`+++ ${filePath}`);
+    }
+    for (const hunk of diff.hunks) {
+        const firstOld = hunk.find((l) => l.lineOld)?.lineOld ?? 1;
+        const firstNew = hunk.find((l) => l.lineNew)?.lineNew ?? 1;
+        const oldCount = hunk.filter((l) => l.type !== 'add').length;
+        const newCount = hunk.filter((l) => l.type !== 'remove').length;
+        lines.push(`@@ -${firstOld},${oldCount} +${firstNew},${newCount} @@`);
+        for (const line of hunk) {
+            switch (line.type) {
+                case 'add':
+                    lines.push(`\x1b[32m+ ${line.text}\x1b[0m`);
+                    break;
+                case 'remove':
+                    lines.push(`\x1b[31m- ${line.text}\x1b[0m`);
+                    break;
+                case 'context':
+                    lines.push(`  ${line.text}`);
+                    break;
+            }
+        }
+    }
+    lines.push(`\x1b[36m${diff.additions} additions, ${diff.deletions} deletions\x1b[0m`);
+    return lines.join('\n');
+}