distill-mcp 0.6.0-beta

package/dist/compressors/semantic.js

@@ -0,0 +1,233 @@
+/**
+ * Semantic Compressor
+ *
+ * Compresses content based on semantic importance using:
+ * - TF-IDF scoring for unique/rare terms
+ * - Position weighting (beginning/end prioritized)
+ * - Keyword detection (errors, instructions, code)
+ *
+ * Phase 2: Rule-based implementation (no ML models)
+ */
+import { countTokens } from "../utils/token-counter.js";
+import { calculateTFIDF, getSegmentTFIDFScore } from "../utils/tfidf.js";
+import { createSegment, scoreSegment, hasErrorIndicators, } from "../utils/segment-scorer.js";
+/**
+ * Segment content into meaningful chunks
+ * Respects:
+ * - Code blocks (keep as single unit)
+ * - Paragraphs (separated by blank lines)
+ * - Error lines (keep intact)
+ */
+function segmentContent(content) {
+    const segments = [];
+    const lines = content.split("\n");
+    const totalLines = lines.length;
+    let currentSegment = [];
+    let startLine = 0;
+    let inCodeBlock = false;
+    let codeBlockMarker = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmedLine = line.trim();
+        // Track code blocks (``` or ~~~)
+        if (trimmedLine.startsWith("```") || trimmedLine.startsWith("~~~")) {
+            const marker = trimmedLine.slice(0, 3);
+            if (!inCodeBlock) {
+                // Start of code block - save previous segment first
+                if (currentSegment.length > 0) {
+                    const text = currentSegment.join("\n").trim();
+                    if (text) {
+                        segments.push(createSegment(text, startLine, i - 1, "paragraph", totalLines));
+                    }
+                }
+                currentSegment = [line];
+                startLine = i;
+                inCodeBlock = true;
+                codeBlockMarker = marker;
+            }
+            else if (marker === codeBlockMarker) {
+                // End of code block
+                currentSegment.push(line);
+                const text = currentSegment.join("\n");
+                segments.push(createSegment(text, startLine, i, "code-block", totalLines));
+                currentSegment = [];
+                startLine = i + 1;
+                inCodeBlock = false;
+                codeBlockMarker = "";
+            }
+            else {
+                // Different marker inside code block, treat as content
+                currentSegment.push(line);
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            currentSegment.push(line);
+            continue;
+        }
+        // Empty line ends a paragraph
+        if (trimmedLine === "") {
+            if (currentSegment.length > 0) {
+                const text = currentSegment.join("\n").trim();
+                if (text) {
+                    // Check if this segment contains errors - treat as separate lines if so
+                    if (hasErrorIndicators(text) && currentSegment.length > 1) {
+                        // Split error-containing segments into individual lines
+                        for (let j = 0; j < currentSegment.length; j++) {
+                            const lineText = currentSegment[j].trim();
+                            if (lineText) {
+                                segments.push(createSegment(lineText, startLine + j, startLine + j, "line", totalLines));
+                            }
+                        }
+                    }
+                    else {
+                        segments.push(createSegment(text, startLine, i - 1, "paragraph", totalLines));
+                    }
+                }
+                currentSegment = [];
+            }
+            startLine = i + 1;
+            continue;
+        }
+        currentSegment.push(line);
+    }
+    // Handle remaining content
+    if (currentSegment.length > 0) {
+        const text = currentSegment.join("\n").trim();
+        if (text) {
+            const type = inCodeBlock ? "code-block" : "paragraph";
+            segments.push(createSegment(text, startLine, lines.length - 1, type, totalLines));
+        }
+    }
+    return segments;
+}
+/**
+ * Select segments to keep based on importance and target ratio
+ */
+function selectSegments(scored, targetTokens, preservePatterns) {
+    // Separate preserved segments (must keep) from regular
+    const preserved = [];
+    const regular = [];
+    for (const segment of scored) {
+        const isPreservedByPattern = preservePatterns?.some((p) => p.test(segment.text));
+        if (segment.isPreserved || isPreservedByPattern) {
+            segment.isPreserved = true;
+            preserved.push(segment);
+        }
+        else {
+            regular.push(segment);
+        }
+    }
+    // Sort regular segments by importance (descending)
+    regular.sort((a, b) => b.importance - a.importance);
+    // Calculate tokens used by preserved segments
+    let tokensUsed = preserved.reduce((sum, s) => sum + s.tokens, 0);
+    const selected = [...preserved];
+    // Add regular segments until we hit target
+    for (const segment of regular) {
+        if (tokensUsed + segment.tokens <= targetTokens) {
+            selected.push(segment);
+            tokensUsed += segment.tokens;
+        }
+        else if (tokensUsed >= targetTokens) {
+            // Already at target
+            break;
+        }
+    }
+    // Sort by original position to maintain reading order
+    selected.sort((a, b) => a.startLine - b.startLine);
+    return selected;
+}
+/**
+ * Semantic compressor implementation
+ */
+export const semanticCompressor = {
+    name: "semantic",
+    supportedTypes: ["generic", "code", "logs"],
+    canCompress(content) {
+        // Can compress any content with at least some substance
+        // Very short content (<100 chars) has no room for meaningful compression
+        return content.length >= 100;
+    },
+    compress(content, options) {
+        const originalTokens = countTokens(content);
+        const targetRatio = options.targetRatio ?? 0.5;
+        // If content is already very small, return as-is
+        // Below 50 tokens, compression would likely make content worse
+        if (originalTokens < 50) {
+            return {
+                compressed: content,
+                stats: {
+                    originalLines: content.split("\n").length,
+                    compressedLines: content.split("\n").length,
+                    originalTokens,
+                    compressedTokens: originalTokens,
+                    reductionPercent: 0,
+                    technique: "semantic-compression (no-op: content already optimized, <50 tokens)",
+                },
+                preservedSegments: [],
+            };
+        }
+        const targetTokens = Math.floor(originalTokens * targetRatio);
+        // Step 1: Segment content
+        const segments = segmentContent(content);
+        // If we only have one segment, can't compress further meaningfully
+        if (segments.length <= 1) {
+            return {
+                compressed: content,
+                stats: {
+                    originalLines: content.split("\n").length,
+                    compressedLines: content.split("\n").length,
+                    originalTokens,
+                    compressedTokens: originalTokens,
+                    reductionPercent: 0,
+                    technique: "semantic-compression (no-op: atomic content, cannot segment)",
+                },
+                preservedSegments: [],
+            };
+        }
+        // Step 2: Calculate TF-IDF scores
+        const segmentTexts = segments.map((s) => s.text);
+        const tfidfMap = calculateTFIDF(segmentTexts);
+        // Step 3: Score each segment
+        const scored = segments.map((segment, i) => {
+            const tfidfScore = getSegmentTFIDFScore(i, tfidfMap);
+            return scoreSegment(segment, tfidfScore);
+        });
+        // Step 4: Mark segments that match preserve patterns
+        if (options.preservePatterns) {
+            for (const segment of scored) {
+                if (options.preservePatterns.some((p) => p.test(segment.text))) {
+                    segment.isPreserved = true;
+                }
+            }
+        }
+        // Step 5: Select segments to keep
+        const selected = selectSegments(scored, targetTokens, options.preservePatterns);
+        // Step 6: Reconstruct compressed text
+        const compressed = selected.map((s) => s.text).join("\n\n");
+        const compressedTokens = countTokens(compressed);
+        // Calculate stats
+        const reductionPercent = originalTokens > 0
+            ? Math.round((1 - compressedTokens / originalTokens) * 100)
+            : 0;
+        // Build preserved segments list (truncated for display)
+        const preservedSegments = selected
+            .filter((s) => s.isPreserved)
+            .map((s) => (s.text.length > 50 ? s.text.slice(0, 47) + "..." : s.text));
+        return {
+            compressed,
+            stats: {
+                originalLines: content.split("\n").length,
+                compressedLines: compressed.split("\n").length,
+                originalTokens,
+                compressedTokens,
+                reductionPercent,
+                technique: "semantic-compression",
+            },
+            omittedInfo: `${segments.length - selected.length} of ${segments.length} segments removed based on importance scoring`,
+            preservedSegments,
+        };
+    },
+};
+export default semanticCompressor;

package/dist/compressors/stacktrace.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Stack Trace Compressor
+ *
+ * Specialized compressor for error stack traces.
+ * Keeps relevant frames (project code) and summarizes internal frames.
+ */
+import type { Compressor } from "./types.js";
+export declare const stacktraceCompressor: Compressor;
+//# sourceMappingURL=stacktrace.d.ts.map

package/dist/compressors/stacktrace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stacktrace.d.ts","sourceRoot":"","sources":["../../src/compressors/stacktrace.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAqC,MAAM,YAAY,CAAC;AAmPhF,eAAO,MAAM,oBAAoB,EAAE,UA4DlC,CAAC"}

package/dist/compressors/stacktrace.js

@@ -0,0 +1,259 @@
+/**
+ * Stack Trace Compressor
+ *
+ * Specialized compressor for error stack traces.
+ * Keeps relevant frames (project code) and summarizes internal frames.
+ */
+import { encodingForModel } from "js-tiktoken";
+const encoding = encodingForModel("gpt-4");
+function countTokens(text) {
+    return encoding.encode(text).length;
+}
+// Patterns for internal frames (node_modules, runtime, etc.)
+const INTERNAL_PATTERNS = [
+    /node_modules/,
+    /internal\//,
+    /<anonymous>/,
+    /native code/,
+    /\[native code\]/,
+    /webpack:/,
+    /turbopack:/,
+    /at Module\./,
+    /at require \(/,
+    /at Object\.<anonymous>/,
+    /at processTicksAndRejections/,
+    /at async /,
+    /__webpack_require__/,
+];
+// Patterns for project code (should be kept)
+const PROJECT_PATTERNS = [
+    /\/(src|app|lib|pages|components|utils|services|hooks|store)\//,
+    /\.(ts|tsx|js|jsx):\d+/,
+];
+/**
+ * Check if a frame is internal (should be summarized)
+ */
+function isInternalFrame(line) {
+    return INTERNAL_PATTERNS.some((pattern) => pattern.test(line));
+}
+/**
+ * Check if a frame is project code (should be kept)
+ */
+function isProjectFrame(line) {
+    if (isInternalFrame(line))
+        return false;
+    return PROJECT_PATTERNS.some((pattern) => pattern.test(line));
+}
+/**
+ * Parse a stack trace line into a frame
+ */
+function parseFrame(line) {
+    const isInternal = isInternalFrame(line);
+    const isProject = isProjectFrame(line);
+    // Extract location if present
+    const locationMatch = line.match(/\(([^)]+)\)$/) || line.match(/at\s+([^\s]+)$/);
+    const location = locationMatch?.[1];
+    return {
+        raw: line,
+        isInternal,
+        isProjectCode: isProject,
+        location,
+    };
+}
+/**
+ * Detect the type of stack trace
+ */
+function detectStackType(content) {
+    if (/^\s+at\s+/m.test(content))
+        return "javascript";
+    if (/^Traceback \(most recent call last\)/m.test(content))
+        return "python";
+    if (/^thread '.*' panicked at/m.test(content))
+        return "rust";
+    if (/^goroutine \d+ \[/m.test(content))
+        return "go";
+    if (/^\s+at [a-zA-Z0-9$.]+\([^)]*\)$/m.test(content))
+        return "java";
+    return "unknown";
+}
+/**
+ * Compress JavaScript/Node.js stack trace
+ */
+function compressJSStack(lines, detail) {
+    const output = [];
+    let internalCount = 0;
+    let consecutiveInternal = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        // Keep error message lines (not starting with "at")
+        if (!line.trim().startsWith("at ") && !line.match(/^\s+at\s+/)) {
+            // If we have pending internal frames, summarize them
+            if (consecutiveInternal > 0) {
+                output.push(`    ... (${consecutiveInternal} internal frames omitted)`);
+                consecutiveInternal = 0;
+            }
+            output.push(line);
+            continue;
+        }
+        const frame = parseFrame(line);
+        if (frame.isInternal) {
+            consecutiveInternal++;
+            internalCount++;
+            // In detailed mode, keep more frames
+            if (detail === "detailed" && consecutiveInternal <= 3) {
+                output.push(line);
+                consecutiveInternal = 0;
+            }
+        }
+        else {
+            // If we have pending internal frames, summarize them
+            if (consecutiveInternal > 0) {
+                output.push(`    ... (${consecutiveInternal} internal frames omitted)`);
+                consecutiveInternal = 0;
+            }
+            output.push(line);
+        }
+    }
+    // Handle trailing internal frames
+    if (consecutiveInternal > 0) {
+        output.push(`    ... (${consecutiveInternal} internal frames omitted)`);
+    }
+    return { compressed: output, internalCount };
+}
+/**
+ * Compress Python traceback
+ */
+function compressPythonStack(lines, detail) {
+    const output = [];
+    let internalCount = 0;
+    let consecutiveInternal = 0;
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? "";
+        // Keep traceback header and error message
+        if (line.startsWith("Traceback") || !line.startsWith("  ")) {
+            if (consecutiveInternal > 0) {
+                output.push(`  ... (${consecutiveInternal} internal frames omitted)`);
+                consecutiveInternal = 0;
+            }
+            output.push(line);
+            i++;
+            continue;
+        }
+        // File line followed by code line
+        if (line.trim().startsWith('File "')) {
+            const isInternal = line.includes("site-packages") ||
+                line.includes("/usr/lib/") ||
+                line.includes("\\lib\\");
+            if (isInternal) {
+                consecutiveInternal++;
+                internalCount++;
+                // Skip the next line (code line) too
+                i += 2;
+                if (detail === "detailed" && consecutiveInternal <= 2) {
+                    output.push(line);
+                    if (lines[i - 1])
+                        output.push(lines[i - 1] ?? "");
+                    consecutiveInternal = 0;
+                }
+            }
+            else {
+                if (consecutiveInternal > 0) {
+                    output.push(`  ... (${consecutiveInternal} internal frames omitted)`);
+                    consecutiveInternal = 0;
+                }
+                output.push(line);
+                i++;
+                // Include the code line
+                if (i < lines.length) {
+                    output.push(lines[i] ?? "");
+                    i++;
+                }
+            }
+        }
+        else {
+            output.push(line);
+            i++;
+        }
+    }
+    if (consecutiveInternal > 0) {
+        output.push(`  ... (${consecutiveInternal} internal frames omitted)`);
+    }
+    return { compressed: output, internalCount };
+}
+/**
+ * Generic stack compression (for Rust, Go, Java, etc.)
+ */
+function compressGenericStack(lines, _detail) {
+    const output = [];
+    let internalCount = 0;
+    let consecutiveInternal = 0;
+    for (const line of lines) {
+        const isInternal = isInternalFrame(line);
+        if (isInternal) {
+            consecutiveInternal++;
+            internalCount++;
+        }
+        else {
+            if (consecutiveInternal > 0) {
+                output.push(`  ... (${consecutiveInternal} internal frames omitted)`);
+                consecutiveInternal = 0;
+            }
+            output.push(line);
+        }
+    }
+    if (consecutiveInternal > 0) {
+        output.push(`  ... (${consecutiveInternal} internal frames omitted)`);
+    }
+    return { compressed: output, internalCount };
+}
+export const stacktraceCompressor = {
+    name: "stacktrace",
+    supportedTypes: ["stacktrace"],
+    canCompress(content) {
+        // Check for stack trace patterns
+        const patterns = [
+            /^(Error|TypeError|ReferenceError|SyntaxError|RangeError):/m,
+            /^\s+at\s+/m,
+            /^Traceback \(most recent call last\):/m,
+            /^thread '.*' panicked at/m,
+            /^goroutine \d+ \[/m,
+        ];
+        return patterns.some((pattern) => pattern.test(content));
+    },
+    compress(content, options) {
+        const lines = content.split("\n");
+        const originalTokens = countTokens(content);
+        // Detect stack type
+        const stackType = detectStackType(content);
+        // Compress based on type
+        let result;
+        switch (stackType) {
+            case "javascript":
+                result = compressJSStack(lines, options.detail);
+                break;
+            case "python":
+                result = compressPythonStack(lines, options.detail);
+                break;
+            default:
+                result = compressGenericStack(lines, options.detail);
+        }
+        const compressed = result.compressed.join("\n");
+        const compressedTokens = countTokens(compressed);
+        const reductionPercent = originalTokens > 0 ? Math.round((1 - compressedTokens / originalTokens) * 100) : 0;
+        return {
+            compressed,
+            stats: {
+                originalLines: lines.length,
+                compressedLines: result.compressed.length,
+                originalTokens,
+                compressedTokens,
+                reductionPercent,
+                technique: `stacktrace-${stackType}`,
+            },
+            omittedInfo: result.internalCount > 0
+                ? `${result.internalCount} internal/library frames summarized`
+                : undefined,
+        };
+    },
+};

package/dist/compressors/types.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Compressor Types
+ *
+ * Shared type definitions for context compressors.
+ */
+export type ContentType = "logs" | "stacktrace" | "config" | "code" | "generic";
+export type DetailLevel = "minimal" | "normal" | "detailed";
+export interface CompressOptions {
+    /** Target compression ratio (0.1 = 10% of original) */
+    targetRatio?: number;
+    /** Patterns to preserve (will not be compressed) */
+    preservePatterns?: RegExp[];
+    /** Level of detail in output */
+    detail: DetailLevel;
+}
+export interface CompressedResult {
+    /** Compressed content */
+    compressed: string;
+    /** Compression statistics */
+    stats: CompressionStats;
+    /** Description of omitted information */
+    omittedInfo?: string;
+}
+export interface CompressionStats {
+    /** Number of lines in original content */
+    originalLines: number;
+    /** Number of lines after compression */
+    compressedLines: number;
+    /** Token count of original content */
+    originalTokens: number;
+    /** Token count after compression */
+    compressedTokens: number;
+    /** Percentage of tokens saved */
+    reductionPercent: number;
+    /** Technique used for compression */
+    technique: string;
+}
+export interface Compressor {
+    /** Compressor name */
+    name: string;
+    /** Content types this compressor can handle */
+    supportedTypes: ContentType[];
+    /** Check if this compressor can handle the content */
+    canCompress(content: string): boolean;
+    /** Compress the content */
+    compress(content: string, options: CompressOptions): CompressedResult;
+}
+/**
+ * Line group for deduplication
+ */
+export interface LineGroup {
+    /** Normalized pattern for matching */
+    pattern: string;
+    /** First occurrence of this pattern */
+    sample: string;
+    /** All lines matching this pattern */
+    lines: string[];
+    /** Number of occurrences */
+    count: number;
+    /** Whether this group contains errors */
+    hasError: boolean;
+    /** Whether this group contains warnings */
+    hasWarning: boolean;
+}
+/**
+ * Parsed diff hunk
+ */
+export interface DiffHunk {
+    /** Original file line start */
+    oldStart: number;
+    /** Original file line count */
+    oldCount: number;
+    /** New file line start */
+    newStart: number;
+    /** New file line count */
+    newCount: number;
+    /** The hunk content (including +/- prefixes) */
+    content: string;
+    /** Lines added in this hunk */
+    additions: number;
+    /** Lines removed in this hunk */
+    deletions: number;
+}
+/**
+ * Parsed file diff
+ */
+export interface FileDiff {
+    /** Old file path (null if new file) */
+    oldPath: string | null;
+    /** New file path (null if deleted file) */
+    newPath: string | null;
+    /** File status */
+    status: "modified" | "added" | "deleted" | "renamed";
+    /** Binary file indicator */
+    isBinary: boolean;
+    /** Hunks in this file */
+    hunks: DiffHunk[];
+    /** Total additions */
+    additions: number;
+    /** Total deletions */
+    deletions: number;
+}
+/**
+ * Complete parsed diff
+ */
+export interface ParsedDiff {
+    /** All file diffs */
+    files: FileDiff[];
+    /** Total additions across all files */
+    totalAdditions: number;
+    /** Total deletions across all files */
+    totalDeletions: number;
+}
+/**
+ * Diff compression strategy
+ */
+export type DiffStrategy = "hunks-only" | "summary" | "semantic";
+/**
+ * Diff compression options
+ */
+export interface DiffCompressOptions {
+    /** Compression strategy */
+    strategy: DiffStrategy;
+    /** Maximum tokens for output (semantic strategy) */
+    maxTokens?: number;
+    /** Number of context lines to keep (hunks-only strategy) */
+    contextLines?: number;
+}
+/**
+ * Diff compression result
+ */
+export interface DiffCompressedResult {
+    /** Compressed diff content */
+    compressed: string;
+    /** List of changed file paths */
+    filesChanged: string[];
+    /** Summary of changes */
+    summary: string;
+    /** Total additions */
+    additions: number;
+    /** Total deletions */
+    deletions: number;
+    /** Compression statistics */
+    stats: CompressionStats;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/compressors/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/compressors/types.ts"],"names":[],"mappings":"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"}

package/dist/compressors/types.js

@@ -0,0 +1,6 @@
+/**
+ * Compressor Types
+ *
+ * Shared type definitions for context compressors.
+ */
+export {};