distill-mcp 0.6.0-beta

package/dist/utils/command-normalizer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Command Normalizer
+ *
+ * Normalizes shell commands for retry loop detection.
+ * Similar commands with different flags or file arguments
+ * are normalized to the same base command.
+ */
+/**
+ * Normalize a shell command for comparison.
+ * Removes flags, specific file paths, and normalizes whitespace.
+ *
+ * @example
+ * normalizeCommand("npm run build --verbose") // "npm run build"
+ * normalizeCommand("bun test src/foo.test.ts") // "bun test"
+ * normalizeCommand("tsc --noEmit src/index.ts") // "tsc"
+ */
+export declare function normalizeCommand(cmd: string): string;
+/**
+ * Extract the base command (first word or first two words for npm/bun/yarn/pnpm)
+ *
+ * @example
+ * getBaseCommand("npm run build") // "npm run"
+ * getBaseCommand("bun test") // "bun test"
+ * getBaseCommand("tsc") // "tsc"
+ */
+export declare function getBaseCommand(cmd: string): string;
+/**
+ * Check if two commands are similar (same base operation)
+ */
+export declare function areCommandsSimilar(cmd1: string, cmd2: string): boolean;
+/**
+ * Common build/test commands that are often retried
+ */
+export declare const COMMON_RETRY_COMMANDS: string[];
+/**
+ * Check if a command is a common build/test command
+ */
+export declare function isCommonRetryCommand(cmd: string): boolean;
+//# sourceMappingURL=command-normalizer.d.ts.map

package/dist/utils/command-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-normalizer.d.ts","sourceRoot":"","sources":["../../src/utils/command-normalizer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiBpD;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAUlD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtE;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,UAwBjC,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAGzD"}

package/dist/utils/command-normalizer.js

@@ -0,0 +1,90 @@
+/**
+ * Command Normalizer
+ *
+ * Normalizes shell commands for retry loop detection.
+ * Similar commands with different flags or file arguments
+ * are normalized to the same base command.
+ */
+/**
+ * Normalize a shell command for comparison.
+ * Removes flags, specific file paths, and normalizes whitespace.
+ *
+ * @example
+ * normalizeCommand("npm run build --verbose") // "npm run build"
+ * normalizeCommand("bun test src/foo.test.ts") // "bun test"
+ * normalizeCommand("tsc --noEmit src/index.ts") // "tsc"
+ */
+export function normalizeCommand(cmd) {
+    return (cmd
+        // Remove long flags with values (--flag=value or --flag value)
+        .replace(/--\w+(?:=\S+)?/g, "")
+        // Remove short flags (-v, -f, etc.)
+        .replace(/\s-\w+/g, "")
+        // Remove specific file paths with extensions
+        .replace(/\s+\S+\.(ts|tsx|js|jsx|json|md|css|scss|html|vue|svelte)(?:\s|$)/g, " ")
+        // Remove quoted strings (often file paths or arguments)
+        .replace(/"[^"]*"|'[^']*'/g, "")
+        // Remove path-like arguments (containing /)
+        .replace(/\s+\S*\/\S+/g, "")
+        // Normalize multiple spaces to single space
+        .replace(/\s+/g, " ")
+        .trim());
+}
+/**
+ * Extract the base command (first word or first two words for npm/bun/yarn/pnpm)
+ *
+ * @example
+ * getBaseCommand("npm run build") // "npm run"
+ * getBaseCommand("bun test") // "bun test"
+ * getBaseCommand("tsc") // "tsc"
+ */
+export function getBaseCommand(cmd) {
+    const parts = cmd.trim().split(/\s+/);
+    // Package manager commands keep their subcommand
+    const packageManagers = ["npm", "bun", "yarn", "pnpm", "npx", "bunx"];
+    if (packageManagers.includes(parts[0] ?? "")) {
+        return parts.slice(0, 2).join(" ");
+    }
+    return parts[0] ?? cmd;
+}
+/**
+ * Check if two commands are similar (same base operation)
+ */
+export function areCommandsSimilar(cmd1, cmd2) {
+    return normalizeCommand(cmd1) === normalizeCommand(cmd2);
+}
+/**
+ * Common build/test commands that are often retried
+ */
+export const COMMON_RETRY_COMMANDS = [
+    "npm run build",
+    "npm run test",
+    "npm run lint",
+    "npm run check",
+    "bun run build",
+    "bun run test",
+    "bun test",
+    "bun run lint",
+    "yarn build",
+    "yarn test",
+    "yarn lint",
+    "pnpm build",
+    "pnpm test",
+    "pnpm lint",
+    "tsc",
+    "eslint",
+    "prettier",
+    "vitest",
+    "jest",
+    "cargo build",
+    "cargo test",
+    "go build",
+    "go test",
+];
+/**
+ * Check if a command is a common build/test command
+ */
+export function isCommonRetryCommand(cmd) {
+    const normalized = normalizeCommand(cmd).toLowerCase();
+    return COMMON_RETRY_COMMANDS.some((common) => normalized.startsWith(common.toLowerCase()));
+}

package/dist/utils/content-detector.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Content Type Detector
+ *
+ * Auto-detects the type of content for optimal compression.
+ */
+import type { ContentType } from "../compressors/types.js";
+/**
+ * Check if content is valid JSON
+ */
+export declare function isValidJSON(content: string): boolean;
+/**
+ * Check if content looks like YAML
+ */
+export declare function isLikelyYAML(content: string): boolean;
+/**
+ * Check if content looks like code
+ */
+export declare function isLikelyCode(content: string): boolean;
+/**
+ * Detect the type of content
+ */
+export declare function detectContentType(content: string): ContentType;
+/**
+ * Get a human-readable description of the content type
+ */
+export declare function getContentTypeDescription(type: ContentType): string;
+//# sourceMappingURL=content-detector.d.ts.map

package/dist/utils/content-detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-detector.d.ts","sourceRoot":"","sources":["../../src/utils/content-detector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAkB3D;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAarD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CASrD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,CA6D9D;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAanE"}

package/dist/utils/content-detector.js

@@ -0,0 +1,127 @@
+/**
+ * Content Type Detector
+ *
+ * Auto-detects the type of content for optimal compression.
+ */
+// Log patterns
+const LOG_LEVEL_PATTERN = /\[\s*(INFO|DEBUG|WARN|WARNING|ERROR|TRACE|FATAL)\s*\]/i;
+const LOG_TIMESTAMP_PATTERN = /\d{4}-\d{2}-\d{2}[T\s]\d{2}:\d{2}:\d{2}/;
+const LOG_COMMON_FORMATS = /^(\d{4}-\d{2}-\d{2}|\[\d{2}:\d{2}:\d{2}\]|[A-Z]{3,5}\s+\d{1,2})/m;
+// Stack trace patterns
+const ERROR_START_PATTERN = /^(Error|TypeError|ReferenceError|SyntaxError|RangeError|URIError|EvalError|AggregateError|Exception|Panic|panic):/m;
+const STACK_FRAME_PATTERN = /^\s+at\s+/m;
+const PYTHON_TRACEBACK = /^Traceback \(most recent call last\):/m;
+const RUST_PANIC = /^thread '.*' panicked at/m;
+const GO_PANIC = /^panic:/m;
+// Config patterns
+const JSON_START = /^\s*[\[{]/;
+const YAML_PATTERN = /^[\w-]+:\s*(\n|.+)/m;
+/**
+ * Check if content is valid JSON
+ */
+export function isValidJSON(content) {
+    try {
+        JSON.parse(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if content looks like YAML
+ */
+export function isLikelyYAML(content) {
+    const lines = content.trim().split("\n");
+    if (lines.length < 2)
+        return false;
+    // Check for YAML-like structure: key: value pairs
+    let yamlLikeLines = 0;
+    for (const line of lines.slice(0, 10)) {
+        if (/^\s*[\w-]+:\s*.+$/.test(line) || /^\s*-\s+/.test(line)) {
+            yamlLikeLines++;
+        }
+    }
+    return yamlLikeLines >= 3;
+}
+/**
+ * Check if content looks like code
+ */
+export function isLikelyCode(content) {
+    const codeIndicators = [
+        /^(import|export|const|let|var|function|class|interface|type)\s+/m,
+        /^(def|class|import|from|if|for|while|try|except)\s+/m,
+        /^(fn|struct|impl|use|mod|pub|let|mut)\s+/m,
+        /^(func|package|import|type|struct|interface)\s+/m,
+    ];
+    return codeIndicators.some((pattern) => pattern.test(content));
+}
+/**
+ * Detect the type of content
+ */
+export function detectContentType(content) {
+    // Empty or very short content
+    if (!content || content.trim().length < 10) {
+        return "generic";
+    }
+    // Stack trace detection (check first as it's most specific)
+    if (ERROR_START_PATTERN.test(content) &&
+        (STACK_FRAME_PATTERN.test(content) || content.includes("    at "))) {
+        return "stacktrace";
+    }
+    // Python traceback
+    if (PYTHON_TRACEBACK.test(content)) {
+        return "stacktrace";
+    }
+    // Rust/Go panic
+    if (RUST_PANIC.test(content) || GO_PANIC.test(content)) {
+        return "stacktrace";
+    }
+    // Log detection
+    if (LOG_LEVEL_PATTERN.test(content) || LOG_TIMESTAMP_PATTERN.test(content)) {
+        // Count log-like lines
+        const lines = content.split("\n");
+        const logLines = lines.filter((line) => LOG_LEVEL_PATTERN.test(line) || LOG_TIMESTAMP_PATTERN.test(line));
+        if (logLines.length >= lines.length * 0.3) {
+            return "logs";
+        }
+    }
+    // Common log formats
+    if (LOG_COMMON_FORMATS.test(content)) {
+        const lines = content.split("\n");
+        const matchingLines = lines.filter((line) => LOG_COMMON_FORMATS.test(line));
+        if (matchingLines.length >= lines.length * 0.5) {
+            return "logs";
+        }
+    }
+    // Config detection (JSON)
+    if (JSON_START.test(content.trim()) && isValidJSON(content)) {
+        return "config";
+    }
+    // Config detection (YAML-like)
+    if (YAML_PATTERN.test(content) && isLikelyYAML(content)) {
+        return "config";
+    }
+    // Code detection
+    if (isLikelyCode(content)) {
+        return "code";
+    }
+    return "generic";
+}
+/**
+ * Get a human-readable description of the content type
+ */
+export function getContentTypeDescription(type) {
+    switch (type) {
+        case "logs":
+            return "Application logs";
+        case "stacktrace":
+            return "Stack trace / Error dump";
+        case "config":
+            return "Configuration file (JSON/YAML)";
+        case "code":
+            return "Source code";
+        case "generic":
+            return "Generic text content";
+    }
+}

package/dist/utils/embeddings.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Embeddings Utilities using Transformers.js
+ *
+ * Provides local embedding computation using the all-MiniLM-L6-v2 model.
+ * Model is loaded lazily on first use to avoid startup overhead.
+ */
+type EmbeddingPipeline = (text: string, options?: Record<string, unknown>) => Promise<{
+    data: Float32Array;
+}>;
+/**
+ * Get or initialize the embedding pipeline (lazy loaded)
+ *
+ * The model is downloaded and cached on first use (~23MB quantized).
+ * Subsequent calls return the cached pipeline instantly.
+ */
+export declare function getEmbeddingPipeline(): Promise<EmbeddingPipeline>;
+/**
+ * Compute embedding for a single text
+ *
+ * @param text - Text to embed
+ * @returns 384-dimensional normalized embedding vector
+ */
+export declare function computeEmbedding(text: string): Promise<number[]>;
+/**
+ * Compute embeddings for multiple texts
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of 384-dimensional normalized embedding vectors
+ */
+export declare function computeEmbeddings(texts: string[]): Promise<number[][]>;
+/**
+ * Cosine similarity between two normalized vectors
+ *
+ * Since vectors are normalized, dot product equals cosine similarity.
+ *
+ * @param a - First embedding vector
+ * @param b - Second embedding vector
+ * @returns Similarity score between -1 and 1 (higher = more similar)
+ */
+export declare function cosineSimilarity(a: number[], b: number[]): number;
+/**
+ * Check if embeddings pipeline is ready (model loaded)
+ */
+export declare function isEmbeddingsReady(): boolean;
+/**
+ * Get embedding dimension for the current model
+ */
+export declare function getEmbeddingDimension(): number;
+/**
+ * Reset the embedding pipeline (for testing)
+ */
+export declare function resetEmbeddingPipeline(): void;
+export {};
+//# sourceMappingURL=embeddings.d.ts.map

package/dist/utils/embeddings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.d.ts","sourceRoot":"","sources":["../../src/utils/embeddings.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,KAAK,iBAAiB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC,CAAC;AAM9G;;;;;GAKG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAiBvE;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAItE;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAU5E;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAOjE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAE9C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAG7C"}

package/dist/utils/embeddings.js

@@ -0,0 +1,97 @@
+/**
+ * Embeddings Utilities using Transformers.js
+ *
+ * Provides local embedding computation using the all-MiniLM-L6-v2 model.
+ * Model is loaded lazily on first use to avoid startup overhead.
+ */
+const MODEL_ID = "Xenova/all-MiniLM-L6-v2";
+const EMBEDDING_DIM = 384;
+// Lazy-loaded pipeline singleton
+let extractor = null;
+let loadingPromise = null;
+/**
+ * Get or initialize the embedding pipeline (lazy loaded)
+ *
+ * The model is downloaded and cached on first use (~23MB quantized).
+ * Subsequent calls return the cached pipeline instantly.
+ */
+export async function getEmbeddingPipeline() {
+    if (extractor)
+        return extractor;
+    if (!loadingPromise) {
+        loadingPromise = (async () => {
+            // Dynamic import to avoid type complexity at module level
+            const { pipeline } = await import("@huggingface/transformers");
+            const pipe = await pipeline("feature-extraction", MODEL_ID, {
+                dtype: "q8",
+            });
+            // Cast to our simplified type
+            return pipe;
+        })();
+    }
+    extractor = await loadingPromise;
+    return extractor;
+}
+/**
+ * Compute embedding for a single text
+ *
+ * @param text - Text to embed
+ * @returns 384-dimensional normalized embedding vector
+ */
+export async function computeEmbedding(text) {
+    const pipe = await getEmbeddingPipeline();
+    const output = await pipe(text, { pooling: "mean", normalize: true });
+    return Array.from(output.data);
+}
+/**
+ * Compute embeddings for multiple texts
+ *
+ * @param texts - Array of texts to embed
+ * @returns Array of 384-dimensional normalized embedding vectors
+ */
+export async function computeEmbeddings(texts) {
+    const pipe = await getEmbeddingPipeline();
+    const results = [];
+    for (const text of texts) {
+        const output = await pipe(text, { pooling: "mean", normalize: true });
+        results.push(Array.from(output.data));
+    }
+    return results;
+}
+/**
+ * Cosine similarity between two normalized vectors
+ *
+ * Since vectors are normalized, dot product equals cosine similarity.
+ *
+ * @param a - First embedding vector
+ * @param b - Second embedding vector
+ * @returns Similarity score between -1 and 1 (higher = more similar)
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += (a[i] ?? 0) * (b[i] ?? 0);
+    }
+    return dot;
+}
+/**
+ * Check if embeddings pipeline is ready (model loaded)
+ */
+export function isEmbeddingsReady() {
+    return extractor !== null;
+}
+/**
+ * Get embedding dimension for the current model
+ */
+export function getEmbeddingDimension() {
+    return EMBEDDING_DIM;
+}
+/**
+ * Reset the embedding pipeline (for testing)
+ */
+export function resetEmbeddingPipeline() {
+    extractor = null;
+    loadingPromise = null;
+}

package/dist/utils/embeddings.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Embeddings Utilities Tests
+ *
+ * Note: These tests use the actual model for integration testing.
+ * The model is downloaded once and cached.
+ */
+export {};
+//# sourceMappingURL=embeddings.test.d.ts.map

package/dist/utils/embeddings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embeddings.test.d.ts","sourceRoot":"","sources":["../../src/utils/embeddings.test.ts"],"names":[],"mappings":"AAAA;;;;;GAKG"}

package/dist/utils/embeddings.test.js

@@ -0,0 +1,96 @@
+/**
+ * Embeddings Utilities Tests
+ *
+ * Note: These tests use the actual model for integration testing.
+ * The model is downloaded once and cached.
+ */
+import { describe, it, expect } from "vitest";
+import { computeEmbedding, computeEmbeddings, cosineSimilarity, getEmbeddingDimension, isEmbeddingsReady, } from "./embeddings.js";
+describe("Embeddings utilities", () => {
+    describe("cosineSimilarity", () => {
+        it("should return 1 for identical normalized vectors", () => {
+            const v = [0.5, 0.5, 0.5, 0.5];
+            const norm = Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
+            const normalized = v.map((x) => x / norm);
+            expect(cosineSimilarity(normalized, normalized)).toBeCloseTo(1, 5);
+        });
+        it("should return 0 for orthogonal vectors", () => {
+            const a = [1, 0, 0, 0];
+            const b = [0, 1, 0, 0];
+            expect(cosineSimilarity(a, b)).toBe(0);
+        });
+        it("should return -1 for opposite vectors", () => {
+            const a = [1, 0, 0, 0];
+            const b = [-1, 0, 0, 0];
+            expect(cosineSimilarity(a, b)).toBe(-1);
+        });
+        it("should return 0 for vectors of different lengths", () => {
+            const a = [1, 0, 0];
+            const b = [1, 0, 0, 0];
+            expect(cosineSimilarity(a, b)).toBe(0);
+        });
+        it("should handle empty vectors", () => {
+            expect(cosineSimilarity([], [])).toBe(0);
+        });
+        it("should compute similarity for arbitrary vectors", () => {
+            // Two similar vectors (normalized)
+            const a = [0.6, 0.8, 0, 0];
+            const b = [0.8, 0.6, 0, 0];
+            const similarity = cosineSimilarity(a, b);
+            // 0.6*0.8 + 0.8*0.6 = 0.48 + 0.48 = 0.96
+            expect(similarity).toBeCloseTo(0.96, 5);
+        });
+    });
+    describe("getEmbeddingDimension", () => {
+        it("should return 384 for all-MiniLM-L6-v2", () => {
+            expect(getEmbeddingDimension()).toBe(384);
+        });
+    });
+    describe("isEmbeddingsReady", () => {
+        it("should return false before model is loaded", () => {
+            // Note: This might be true if other tests loaded the model
+            // We just verify it returns a boolean
+            expect(typeof isEmbeddingsReady()).toBe("boolean");
+        });
+    });
+    // Integration tests - these download the model on first run
+    describe("computeEmbedding (integration)", () => {
+        // Skip these tests in CI or if model download is slow
+        const skipIntegration = process.env.SKIP_EMBEDDING_TESTS === "true";
+        it.skipIf(skipIntegration)("should compute embedding with correct dimensions", async () => {
+            const embedding = await computeEmbedding("Hello world");
+            expect(embedding).toHaveLength(384);
+        }, 60000); // 60s timeout for model download
+        it.skipIf(skipIntegration)("should return normalized vectors", async () => {
+            const embedding = await computeEmbedding("Test text");
+            // Check that the vector is normalized (magnitude ≈ 1)
+            const magnitude = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
+            expect(magnitude).toBeCloseTo(1, 3);
+        }, 60000);
+        it.skipIf(skipIntegration)("should produce similar embeddings for similar texts", async () => {
+            const emb1 = await computeEmbedding("compress log output");
+            const emb2 = await computeEmbedding("shrink log files");
+            const emb3 = await computeEmbedding("unrelated banana smoothie recipe");
+            const sim12 = cosineSimilarity(emb1, emb2);
+            const sim13 = cosineSimilarity(emb1, emb3);
+            // Similar texts should have higher similarity
+            expect(sim12).toBeGreaterThan(sim13);
+            expect(sim12).toBeGreaterThan(0.5);
+        }, 60000);
+    });
+    describe("computeEmbeddings (integration)", () => {
+        const skipIntegration = process.env.SKIP_EMBEDDING_TESTS === "true";
+        it.skipIf(skipIntegration)("should compute multiple embeddings", async () => {
+            const texts = ["Hello", "World", "Test"];
+            const embeddings = await computeEmbeddings(texts);
+            expect(embeddings).toHaveLength(3);
+            for (const emb of embeddings) {
+                expect(emb).toHaveLength(384);
+            }
+        }, 60000);
+        it.skipIf(skipIntegration)("should handle empty array", async () => {
+            const embeddings = await computeEmbeddings([]);
+            expect(embeddings).toHaveLength(0);
+        }, 60000);
+    });
+});

package/dist/utils/error-normalizer.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Error Normalizer
+ *
+ * Normalizes error lines to create consistent signatures for deduplication.
+ * Removes variable parts (file paths, line numbers, values) while preserving
+ * the error pattern.
+ */
+export interface ErrorParts {
+    file?: string;
+    line?: number;
+    column?: number;
+    code?: string;
+    message: string;
+    raw: string;
+}
+/**
+ * Normalize an error line by replacing variable parts with placeholders.
+ * This creates a consistent signature for grouping similar errors.
+ */
+export declare function normalizeErrorLine(line: string): string;
+/**
+ * Extract structured parts from an error line.
+ * Returns null if the line doesn't match any known error pattern.
+ */
+export declare function extractErrorParts(line: string): ErrorParts | null;
+/**
+ * Check if a line is likely an error message
+ */
+export declare function isLikelyError(line: string): boolean;
+/**
+ * Create a signature from error parts for grouping.
+ * The signature represents the "type" of error, ignoring location.
+ */
+export declare function createSignature(parts: ErrorParts): string;
+/**
+ * Extract file location from error parts
+ */
+export declare function formatLocation(parts: ErrorParts): string;
+//# sourceMappingURL=error-normalizer.d.ts.map

package/dist/utils/error-normalizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-normalizer.d.ts","sourceRoot":"","sources":["../../src/utils/error-normalizer.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,UAAU;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CA4BvD;AA0HD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAoBjE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAqBnD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAYzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAWxD"}