distill-mcp 0.6.0-beta

package/dist/tools/smart-pipeline.js

@@ -0,0 +1,295 @@
+/**
+ * Smart Pipeline Tool
+ *
+ * Automatically chains compression tools based on detected content type.
+ * Executes multiple optimization steps sequentially with result passthrough.
+ */
+import { z } from "zod";
+import { countTokens } from "../utils/token-counter.js";
+import { detectContentType } from "../utils/content-detector.js";
+// Import compression functions directly (not tools)
+import { analyzeBuildOutput } from "../parsers/index.js";
+import { groupBySignature, formatGroups } from "../utils/signature-grouper.js";
+import { getSummarizer } from "../summarizers/index.js";
+import { compressContent } from "../compressors/index.js";
+import { compressDiff } from "../compressors/diff.js";
+import { detectPipelineContentType, } from "../pipelines/definitions.js";
+/**
+ * JSON Schema for MCP tool registration
+ */
+// Minimal schema - customPipeline/maxSteps rarely used
+export const smartPipelineSchema = {
+    type: "object",
+    properties: {
+        content: { type: "string" },
+        mode: { enum: ["auto", "custom"] },
+        contentType: { enum: ["build", "logs", "stacktrace", "diff", "config", "code", "generic"] },
+    },
+    required: ["content"],
+};
+/**
+ * Zod schema for runtime input validation
+ */
+const inputSchema = z.object({
+    content: z.string().min(1, "Content is required"),
+    mode: z.enum(["auto", "custom"]).optional().default("auto"),
+    contentType: z
+        .enum(["build", "logs", "stacktrace", "diff", "config", "code", "generic"])
+        .optional(),
+    customPipeline: z.array(z.string()).optional(),
+    maxSteps: z.number().int().positive().optional().default(5),
+});
+// =============================================================================
+// Pipeline Step Functions
+// =============================================================================
+/**
+ * Format log summary to string
+ */
+function formatLogSummary(summary) {
+    const parts = [];
+    parts.push(`## ${summary.overview}`);
+    parts.push("");
+    if (summary.errors.length > 0) {
+        parts.push("### Errors");
+        for (const error of summary.errors.slice(0, 10)) {
+            const count = error.count > 1 ? ` (x${error.count})` : "";
+            parts.push(`- ${error.timestamp || ""} ${error.message}${count}`);
+        }
+        parts.push("");
+    }
+    if (summary.warnings.length > 0) {
+        parts.push("### Warnings");
+        for (const warning of summary.warnings.slice(0, 5)) {
+            const count = warning.count > 1 ? ` (x${warning.count})` : "";
+            parts.push(`- ${warning.timestamp || ""} ${warning.message}${count}`);
+        }
+        parts.push("");
+    }
+    if (summary.keyEvents.length > 0) {
+        parts.push("### Key Events");
+        for (const event of summary.keyEvents.slice(0, 5)) {
+            parts.push(`- ${event.timestamp || ""} ${event.message}`);
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * Step: Analyze build output
+ */
+function stepAnalyzeBuild(content) {
+    const result = analyzeBuildOutput(content, { verbosity: "normal" });
+    return result.summary;
+}
+/**
+ * Step: Deduplicate errors
+ */
+function stepDeduplicate(content) {
+    const lines = content.split("\n");
+    const result = groupBySignature(lines);
+    return formatGroups(result);
+}
+/**
+ * Step: Summarize logs
+ */
+function stepSummarizeLogs(content) {
+    const summarizer = getSummarizer(content);
+    if (!summarizer) {
+        // Fallback to generic compression
+        return stepSemanticCompress(content);
+    }
+    const summary = summarizer.summarize(content, { detail: "normal" });
+    return formatLogSummary(summary);
+}
+/**
+ * Step: Compress diff
+ */
+function stepCompressDiff(content) {
+    const result = compressDiff(content, { strategy: "hunks-only" });
+    return result.compressed;
+}
+/**
+ * Step: Semantic compression
+ */
+function stepSemanticCompress(content) {
+    const result = compressContent(content, {
+        detail: "normal",
+        targetRatio: 0.5,
+    });
+    return result.compressed;
+}
+/**
+ * Step: Generic compression
+ */
+function stepGenericCompress(content) {
+    const result = compressContent(content, {
+        detail: "normal",
+    });
+    return result.compressed;
+}
+/**
+ * Map of step names to functions
+ */
+const STEP_FUNCTIONS = {
+    analyze_build_output: stepAnalyzeBuild,
+    analyze_build: stepAnalyzeBuild,
+    deduplicate_errors: stepDeduplicate,
+    deduplicate: stepDeduplicate,
+    summarize_logs: stepSummarizeLogs,
+    diff_compress: stepCompressDiff,
+    compress_diff: stepCompressDiff,
+    semantic_compress: stepSemanticCompress,
+    compress_context: stepGenericCompress,
+    generic: stepGenericCompress,
+};
+/**
+ * Map content types to step sequences
+ */
+const TYPE_TO_STEPS = {
+    build: ["analyze_build_output", "deduplicate_errors"],
+    logs: ["summarize_logs"],
+    stacktrace: ["deduplicate_errors", "semantic_compress"],
+    diff: ["diff_compress"],
+    config: ["compress_context"],
+    code: ["semantic_compress"],
+    generic: ["semantic_compress"],
+};
+// =============================================================================
+// Pipeline Execution
+// =============================================================================
+/**
+ * Execute a pipeline on content
+ */
+function executePipeline(content, steps, maxSteps) {
+    let currentContent = content;
+    const stepResults = [];
+    const stepsToExecute = steps.slice(0, maxSteps);
+    for (const stepName of stepsToExecute) {
+        const stepFn = STEP_FUNCTIONS[stepName];
+        if (!stepFn) {
+            console.error(`[smart-pipeline] Unknown step: ${stepName}`);
+            continue;
+        }
+        const inputTokens = countTokens(currentContent);
+        try {
+            currentContent = stepFn(currentContent);
+        }
+        catch (error) {
+            console.error(`[smart-pipeline] Step ${stepName} failed:`, error);
+            // Continue with current content
+            continue;
+        }
+        const outputTokens = countTokens(currentContent);
+        const savingsPercent = inputTokens > 0 ? Math.round((1 - outputTokens / inputTokens) * 100) : 0;
+        stepResults.push({
+            step: stepName,
+            inputTokens,
+            outputTokens,
+            savingsPercent,
+        });
+        // Stop if no improvement
+        if (outputTokens >= inputTokens) {
+            break;
+        }
+    }
+    return { finalContent: currentContent, stepResults };
+}
+/**
+ * Format pipeline result - minimal header to save tokens
+ */
+function formatOutput(result) {
+    const header = `[pipeline:${result.detectedType}] ${result.totalOriginalTokens}→${result.totalCompressedTokens} tokens (-${result.totalSavingsPercent}%)`;
+    return `${header}\n${result.finalContent}`;
+}
+/**
+ * Execute the smart pipeline tool
+ */
+export async function executeSmartPipeline(args) {
+    // Validate input
+    const parseResult = inputSchema.safeParse(args);
+    if (!parseResult.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Invalid input: ${parseResult.error.errors.map((e) => e.message).join(", ")}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    const input = parseResult.data;
+    // Detect content type
+    let detectedType;
+    if (input.contentType) {
+        detectedType = input.contentType;
+    }
+    else {
+        detectedType = detectPipelineContentType(input.content);
+        // Fall back to standard detection if no specific type found
+        if (detectedType === "generic") {
+            const standardType = detectContentType(input.content);
+            if (standardType !== "generic") {
+                detectedType = standardType;
+            }
+        }
+    }
+    // Determine pipeline steps
+    let steps;
+    if (input.mode === "custom" && input.customPipeline) {
+        steps = input.customPipeline;
+    }
+    else {
+        steps = TYPE_TO_STEPS[detectedType] ?? TYPE_TO_STEPS.generic;
+    }
+    // Validate custom pipeline steps
+    if (input.mode === "custom" && input.customPipeline) {
+        const invalidSteps = input.customPipeline.filter((s) => !STEP_FUNCTIONS[s]);
+        if (invalidSteps.length > 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Invalid pipeline steps: ${invalidSteps.join(", ")}. Available: ${Object.keys(STEP_FUNCTIONS).join(", ")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    // Execute pipeline
+    const originalTokens = countTokens(input.content);
+    const { finalContent, stepResults } = executePipeline(input.content, steps, input.maxSteps);
+    const finalTokens = countTokens(finalContent);
+    // Build result
+    const result = {
+        finalContent,
+        detectedType,
+        steps: stepResults,
+        totalOriginalTokens: originalTokens,
+        totalCompressedTokens: finalTokens,
+        totalSavingsPercent: originalTokens > 0
+            ? Math.round((1 - finalTokens / originalTokens) * 100)
+            : 0,
+    };
+    // Update session state
+    const tokensSaved = originalTokens - finalTokens;
+    if (tokensSaved > 0) {
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatOutput(result),
+            },
+        ],
+    };
+}
+/**
+ * Tool definition for MCP registration
+ */
+export const smartPipelineTool = {
+    name: "smart_pipeline",
+    description: "Chain compression tools. Auto-detects content type.",
+    inputSchema: smartPipelineSchema,
+    execute: executeSmartPipeline,
+};

package/dist/tools/summarize-logs.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Summarize Logs Tool
+ *
+ * Intelligently summarizes verbose logs, extracting errors, warnings,
+ * key events, and statistics.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const summarizeLogsSchema: {
+    type: "object";
+    properties: {
+        logs: {
+            type: string;
+        };
+        logType: {
+            enum: string[];
+        };
+        focus: {
+            type: string;
+            items: {
+                enum: string[];
+            };
+        };
+        detail: {
+            enum: string[];
+        };
+    };
+    required: string[];
+};
+export declare function executeSummarizeLogs(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const summarizeLogsTool: ToolDefinition;
+//# sourceMappingURL=summarize-logs.d.ts.map

package/dist/tools/summarize-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"summarize-logs.d.ts","sourceRoot":"","sources":["../../src/tools/summarize-logs.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAapD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;CAS/B,CAAC;AAmBF,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CAkC7D;AAwID,eAAO,MAAM,iBAAiB,EAAE,cAM/B,CAAC"}

package/dist/tools/summarize-logs.js

@@ -0,0 +1,184 @@
+/**
+ * Summarize Logs Tool
+ *
+ * Intelligently summarizes verbose logs, extracting errors, warnings,
+ * key events, and statistics.
+ */
+import { z } from "zod";
+import { getSummarizer, MAX_ENTRIES, } from "../summarizers/index.js";
+import { detectLogType } from "../utils/log-parser.js";
+// Minimal schema - timeframe rarely used
+export const summarizeLogsSchema = {
+    type: "object",
+    properties: {
+        logs: { type: "string" },
+        logType: { enum: ["server", "test", "build", "application", "generic"] },
+        focus: { type: "array", items: { enum: ["errors", "warnings", "performance", "timeline"] } },
+        detail: { enum: ["minimal", "normal", "detailed"] },
+    },
+    required: ["logs"],
+};
+const inputSchema = z.object({
+    logs: z.string(),
+    logType: z
+        .enum(["server", "test", "build", "application", "generic"])
+        .optional(),
+    focus: z
+        .array(z.enum(["errors", "warnings", "performance", "timeline"]))
+        .optional(),
+    detail: z.enum(["minimal", "normal", "detailed"]).optional().default("normal"),
+    timeframe: z
+        .object({
+        start: z.string().optional(),
+        end: z.string().optional(),
+    })
+        .optional(),
+});
+export async function executeSummarizeLogs(args) {
+    const input = inputSchema.parse(args);
+    // Detect log type if not provided
+    const detectedType = input.logType || detectLogType(input.logs);
+    // Get appropriate summarizer
+    const summarizer = getSummarizer(input.logs, detectedType);
+    // Build options
+    const options = {
+        logType: detectedType,
+        focus: input.focus,
+        detail: input.detail,
+        timeframe: input.timeframe,
+    };
+    // Generate summary
+    const summary = summarizer.summarize(input.logs, options);
+    // Format output
+    const output = formatSummary(summary, options);
+    // Calculate token savings
+    const originalTokens = Math.ceil(input.logs.length / 4);
+    const outputTokens = Math.ceil(output.length / 4);
+    const reductionPercent = originalTokens > 0 ? Math.round((1 - outputTokens / originalTokens) * 100) : 0;
+    // Minimal header
+    const header = `[logs] ${originalTokens}→${outputTokens} tokens (-${reductionPercent}%)`;
+    return {
+        content: [{ type: "text", text: `${header}\n${output}` }],
+    };
+}
+/**
+ * Format the summary as markdown
+ */
+function formatSummary(summary, options) {
+    const parts = [];
+    const focus = options.focus || ["errors", "warnings", "timeline"];
+    // Header
+    parts.push(`## Log Summary (${summary.logType})\n`);
+    parts.push(`**${summary.overview}**\n`);
+    // Errors section
+    if (focus.includes("errors") && summary.errors.length > 0) {
+        parts.push("---");
+        parts.push(`### Errors (${summary.statistics.errorCount})\n`);
+        if (summary.errors.length <= 5) {
+            for (const error of summary.errors) {
+                const prefix = error.timestamp ? `${error.timestamp} - ` : "";
+                const suffix = error.count > 1 ? ` (×${error.count})` : "";
+                parts.push(`- ${prefix}${error.message}${suffix}`);
+            }
+        }
+        else {
+            parts.push("| Time | Message | Count |");
+            parts.push("|------|---------|-------|");
+            for (const error of summary.errors.slice(0, MAX_ENTRIES[options.detail].errors)) {
+                const time = error.timestamp || "-";
+                const msg = truncate(error.message, 60);
+                parts.push(`| ${time} | ${msg} | ${error.count} |`);
+            }
+            if (summary.errors.length > MAX_ENTRIES[options.detail].errors) {
+                parts.push(`\n*...and ${summary.errors.length - MAX_ENTRIES[options.detail].errors} more errors*`);
+            }
+        }
+        parts.push("");
+    }
+    // Warnings section
+    if (focus.includes("warnings") && summary.warnings.length > 0) {
+        parts.push("---");
+        parts.push(`### Warnings (${summary.statistics.warningCount})\n`);
+        for (const warning of summary.warnings.slice(0, MAX_ENTRIES[options.detail].warnings)) {
+            const prefix = warning.timestamp ? `${warning.timestamp} - ` : "";
+            const suffix = warning.count > 1 ? ` (×${warning.count})` : "";
+            parts.push(`- ${prefix}${warning.message}${suffix}`);
+        }
+        if (summary.warnings.length > MAX_ENTRIES[options.detail].warnings) {
+            parts.push(`\n*...and ${summary.warnings.length - MAX_ENTRIES[options.detail].warnings} more warnings*`);
+        }
+        parts.push("");
+    }
+    // Timeline / Key Events
+    if (focus.includes("timeline") && summary.keyEvents.length > 0) {
+        parts.push("---");
+        parts.push("### Key Events\n");
+        let eventNum = 1;
+        for (const event of summary.keyEvents.slice(0, MAX_ENTRIES[options.detail].events)) {
+            const time = event.timestamp || "";
+            parts.push(`${eventNum}. ${time ? `${time} - ` : ""}${event.message}`);
+            eventNum++;
+        }
+        parts.push("");
+    }
+    // Performance / Statistics
+    if (focus.includes("performance") || summary.logType === "server") {
+        parts.push("---");
+        parts.push("### Statistics\n");
+        const stats = summary.statistics;
+        if (stats.timespan) {
+            parts.push(`- **Duration:** ${stats.timespan.durationFormatted}`);
+        }
+        // Server-specific stats
+        if (stats.requestCount !== undefined) {
+            parts.push(`- **Total requests:** ${stats.requestCount.toLocaleString()}`);
+        }
+        if (stats.avgResponseTime !== undefined && stats.avgResponseTime > 0) {
+            parts.push(`- **Avg response time:** ${stats.avgResponseTime}ms`);
+        }
+        if (stats.endpoints && stats.endpoints.length > 0) {
+            parts.push("\n**Top Endpoints:**");
+            parts.push("| Endpoint | Requests | Avg Time |");
+            parts.push("|----------|----------|----------|");
+            for (const ep of stats.endpoints.slice(0, 5)) {
+                parts.push(`| ${ep.method} ${ep.path} | ${ep.count} | ${ep.avgTime}ms |`);
+            }
+        }
+        // Test-specific stats
+        if (stats.passCount !== undefined) {
+            const total = (stats.passCount || 0) + (stats.failCount || 0) + (stats.skipCount || 0);
+            const passRate = total > 0 ? Math.round(((stats.passCount || 0) / total) * 100) : 0;
+            parts.push(`- **Tests:** ${stats.passCount} passed, ${stats.failCount} failed`);
+            if (stats.skipCount) {
+                parts.push(`- **Skipped:** ${stats.skipCount}`);
+            }
+            parts.push(`- **Pass rate:** ${passRate}%`);
+        }
+        if (stats.testDuration) {
+            parts.push(`- **Test duration:** ${(stats.testDuration / 1000).toFixed(2)}s`);
+        }
+        // Build-specific stats
+        if (stats.buildDuration) {
+            parts.push(`- **Build time:** ${(stats.buildDuration / 1000).toFixed(2)}s`);
+        }
+        if (stats.bundleSize) {
+            parts.push(`- **Bundle size:** ${(stats.bundleSize / 1024).toFixed(1)} KB`);
+        }
+        parts.push("");
+    }
+    return parts.join("\n");
+}
+/**
+ * Truncate a string to a maximum length
+ */
+function truncate(str, maxLen) {
+    if (str.length <= maxLen)
+        return str;
+    return str.slice(0, maxLen - 3) + "...";
+}
+export const summarizeLogsTool = {
+    name: "summarize_logs",
+    description: "Summarize logs. Extracts errors, warnings, key events. Auto-detects log type.",
+    inputSchema: summarizeLogsSchema,
+    execute: executeSummarizeLogs,
+};

package/dist/tools/token-budget.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Token Budget Tests
+ *
+ * Ensures tool definitions stay within token budgets to prevent
+ * context window bloat from MCP tool descriptions.
+ *
+ * These tests guard against regression - any change that increases
+ * token consumption will fail the test.
+ */
+export {};
+//# sourceMappingURL=token-budget.test.d.ts.map

package/dist/tools/token-budget.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-budget.test.d.ts","sourceRoot":"","sources":["../../src/tools/token-budget.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}