distill-mcp 0.6.0-beta

package/dist/tools/analyze-build-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-build-output.d.ts","sourceRoot":"","sources":["../../src/tools/analyze-build-output.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;CAQpC,CAAC;AAUF,wBAAsB,yBAAyB,CAC7C,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,CAgB7D;AAED,eAAO,MAAM,sBAAsB,EAAE,cAKpC,CAAC"}

package/dist/tools/analyze-build-output.js

@@ -0,0 +1,45 @@
+/**
+ * Analyze Build Output Tool
+ *
+ * Analyzes and compresses build tool outputs (tsc, webpack, eslint, etc.)
+ * to dramatically reduce tokens while preserving critical information.
+ */
+import { z } from "zod";
+import { analyzeBuildOutput } from "../parsers/index.js";
+// Minimal schema
+export const analyzeBuildOutputSchema = {
+    type: "object",
+    properties: {
+        output: { type: "string" },
+        buildTool: { enum: ["tsc", "eslint", "webpack", "vite", "esbuild", "rust", "go", "generic"] },
+        verbosity: { enum: ["minimal", "normal", "detailed"] },
+    },
+    required: ["output"],
+};
+const inputSchema = z.object({
+    output: z.string(),
+    buildTool: z
+        .enum(["tsc", "eslint", "webpack", "vite", "esbuild", "rust", "go", "generic"])
+        .optional(),
+    verbosity: z.enum(["minimal", "normal", "detailed"]).optional().default("normal"),
+});
+export async function executeAnalyzeBuildOutput(args) {
+    const { output, buildTool, verbosity } = inputSchema.parse(args);
+    // Analyze the build output
+    const result = analyzeBuildOutput(output, {
+        buildTool: buildTool,
+        verbosity,
+    });
+    // Format with minimal header
+    const header = `[build] ${result.stats.tokensOriginal}→${result.stats.tokensCompressed} tokens (-${result.stats.reductionPercent}%)`;
+    const formatted = `${header}\n${result.summary}`;
+    return {
+        content: [{ type: "text", text: formatted }],
+    };
+}
+export const analyzeBuildOutputTool = {
+    name: "analyze_build_output",
+    description: "Parse and group build errors (tsc, eslint, webpack). 90%+ token reduction.",
+    inputSchema: analyzeBuildOutputSchema,
+    execute: executeAnalyzeBuildOutput,
+};

package/dist/tools/analyze-context.d.ts

@@ -0,0 +1,23 @@
+import type { ServerConfig } from "../server";
+export declare const analyzeContextSchema: {
+    type: "object";
+    properties: {
+        content: {
+            type: string;
+            description: string;
+        };
+        model: {
+            type: string;
+            description: string;
+            enum: string[];
+        };
+    };
+    required: string[];
+};
+export declare function analyzeContext(args: unknown, _config: ServerConfig): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+//# sourceMappingURL=analyze-context.d.ts.map

package/dist/tools/analyze-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze-context.d.ts","sourceRoot":"","sources":["../../src/tools/analyze-context.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAE9C,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;CAchC,CAAC;AAOF,wBAAsB,cAAc,CAClC,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CA8E7D"}

package/dist/tools/analyze-context.js

@@ -0,0 +1,78 @@
+import { encodingForModel } from "js-tiktoken";
+import { z } from "zod";
+import { ANTHROPIC_MODELS, calculateCost, formatCost, calculateContextUsage, } from "@ctxopt/shared";
+export const analyzeContextSchema = {
+    type: "object",
+    properties: {
+        content: {
+            type: "string",
+            description: "The prompt or context content to analyze",
+        },
+        model: {
+            type: "string",
+            description: "The target model (default: claude-sonnet-4-20250514)",
+            enum: Object.keys(ANTHROPIC_MODELS),
+        },
+    },
+    required: ["content"],
+};
+const inputSchema = z.object({
+    content: z.string(),
+    model: z.string().optional().default("claude-sonnet-4-20250514"),
+});
+export async function analyzeContext(args, _config) {
+    const { content, model } = inputSchema.parse(args);
+    // Count tokens using tiktoken (cl100k_base is compatible with Claude)
+    const encoding = encodingForModel("gpt-4");
+    const tokens = encoding.encode(content);
+    const tokenCount = tokens.length;
+    // Calculate costs (assuming this is input)
+    const costs = calculateCost(model, tokenCount, 0);
+    const contextUsage = calculateContextUsage(tokenCount, model);
+    // Analyze content for optimization opportunities
+    const suggestions = [];
+    // Check context size
+    if (contextUsage > 80) {
+        suggestions.push(`- **Critical**: Context uses ${contextUsage}% of the window. Consider summarizing older messages.`);
+    }
+    else if (contextUsage > 50) {
+        suggestions.push(`- **Warning**: Context uses ${contextUsage}% of the window. Monitor growth.`);
+    }
+    // Check for potential redundancy (simple heuristic)
+    const lines = content.split("\n").filter((l) => l.trim().length > 0);
+    const uniqueLines = new Set(lines);
+    if (uniqueLines.size < lines.length * 0.9) {
+        const duplicatePercent = Math.round(((lines.length - uniqueLines.size) / lines.length) * 100);
+        suggestions.push(`- **Redundancy detected**: ~${duplicatePercent}% duplicate lines found. Consider deduplication.`);
+    }
+    // Check for long system prompts
+    const systemPromptMatch = content.match(/system[:\s]/i);
+    if (systemPromptMatch && tokenCount > 2000) {
+        suggestions.push(`- **Tip**: Long system prompt detected. Consider extracting reusable parts to reduce per-request tokens.`);
+    }
+    // Check for verbose formatting
+    if (content.includes("```") && tokenCount > 5000) {
+        const codeBlockCount = (content.match(/```/g) || []).length / 2;
+        if (codeBlockCount > 3) {
+            suggestions.push(`- **Tip**: ${Math.floor(codeBlockCount)} code blocks detected. Consider including only relevant snippets.`);
+        }
+    }
+    const modelInfo = ANTHROPIC_MODELS[model];
+    const modelName = modelInfo?.name || model;
+    const result = `## Context Analysis
+
+**Token Count:** ${tokenCount.toLocaleString()} tokens
+**Model:** ${modelName}
+**Estimated Input Cost:** ${formatCost(costs.inputCostMicros)}
+**Context Window Usage:** ${contextUsage}%
+
+${suggestions.length > 0
+        ? `### Optimization Suggestions\n\n${suggestions.join("\n")}`
+        : "### Status\n\n Context looks well-optimized!"}
+
+---
+*Analyzed by CtxOpt*`;
+    return {
+        content: [{ type: "text", text: result }],
+    };
+}

package/dist/tools/auto-optimize.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Auto-Optimize Tool
+ *
+ * Unified tool that auto-detects content type and applies
+ * the appropriate optimization automatically.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const autoOptimizeTool: ToolDefinition;
+//# sourceMappingURL=auto-optimize.d.ts.map

package/dist/tools/auto-optimize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-optimize.d.ts","sourceRoot":"","sources":["../../src/tools/auto-optimize.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AA8NpD,eAAO,MAAM,gBAAgB,EAAE,cAK9B,CAAC"}

package/dist/tools/auto-optimize.js

@@ -0,0 +1,191 @@
+/**
+ * Auto-Optimize Tool
+ *
+ * Unified tool that auto-detects content type and applies
+ * the appropriate optimization automatically.
+ */
+import { detectContentType } from "../utils/content-detector.js";
+import { compressContent } from "../compressors/index.js";
+import { getSummarizer } from "../summarizers/index.js";
+import { analyzeBuildOutput } from "../parsers/index.js";
+import { groupBySignature, formatGroups, calculateStats } from "../utils/signature-grouper.js";
+import { countTokens } from "../utils/token-counter.js";
+// Minimal schema - format rarely used, keep only essential properties
+const autoOptimizeSchema = {
+    type: "object",
+    properties: {
+        content: { type: "string" },
+        hint: { enum: ["build", "logs", "errors", "code", "auto"] },
+        aggressive: { type: "boolean" },
+        format: { enum: ["plain", "markdown"] },
+    },
+    required: ["content"],
+};
+function isBuildOutput(content) {
+    // Detect if content is build output
+    return (content.includes("error TS") ||
+        content.includes("warning TS") ||
+        content.includes("error[E") ||
+        content.includes("error:") ||
+        /\d+:\d+.*error/i.test(content) ||
+        content.includes("npm ERR") ||
+        content.includes("ERROR in"));
+}
+function optimizeBuildOutput(content) {
+    const originalTokens = countTokens(content);
+    const result = analyzeBuildOutput(content);
+    return {
+        optimizedContent: result.summary,
+        detectedType: `build-${result.buildTool}`,
+        originalTokens,
+        optimizedTokens: result.stats.tokensCompressed,
+        savingsPercent: result.stats.reductionPercent,
+        method: "error-grouping",
+    };
+}
+function optimizeLogs(content, format = "plain") {
+    const originalTokens = countTokens(content);
+    const summarizer = getSummarizer(content);
+    const summaryResult = summarizer.summarize(content, { detail: "normal" });
+    // Format summary as text
+    const summaryText = formatLogSummary(summaryResult, format);
+    const optimizedTokens = countTokens(summaryText);
+    return {
+        optimizedContent: summaryText,
+        detectedType: `logs-${summarizer.logType}`,
+        originalTokens,
+        optimizedTokens,
+        savingsPercent: Math.round((1 - optimizedTokens / originalTokens) * 100),
+        method: "log-summarization",
+    };
+}
+function formatLogSummary(summary, format = "plain") {
+    const parts = [];
+    const md = format === "markdown";
+    parts.push(md ? `## ${summary.overview}` : summary.overview);
+    if (md)
+        parts.push("");
+    if (summary.errors.length > 0) {
+        if (md)
+            parts.push("### Errors");
+        else
+            parts.push("ERRORS:");
+        for (const error of summary.errors.slice(0, 10)) {
+            const count = error.count > 1 ? ` (×${error.count})` : "";
+            const ts = error.timestamp ? `${error.timestamp} ` : "";
+            parts.push(md ? `- ${ts}${error.message}${count}` : `  ${ts}${error.message}${count}`);
+        }
+        if (md)
+            parts.push("");
+    }
+    if (summary.warnings.length > 0) {
+        if (md)
+            parts.push("### Warnings");
+        else
+            parts.push("WARNINGS:");
+        for (const warning of summary.warnings.slice(0, 5)) {
+            const count = warning.count > 1 ? ` (×${warning.count})` : "";
+            const ts = warning.timestamp ? `${warning.timestamp} ` : "";
+            parts.push(md ? `- ${ts}${warning.message}${count}` : `  ${ts}${warning.message}${count}`);
+        }
+        if (md)
+            parts.push("");
+    }
+    if (summary.keyEvents.length > 0) {
+        if (md)
+            parts.push("### Key Events");
+        else
+            parts.push("KEY EVENTS:");
+        for (const event of summary.keyEvents.slice(0, 5)) {
+            const ts = event.timestamp ? `${event.timestamp} ` : "";
+            parts.push(md ? `- ${ts}${event.message}` : `  ${ts}${event.message}`);
+        }
+    }
+    return parts.join("\n");
+}
+function optimizeErrors(content, format = "plain") {
+    const originalTokens = countTokens(content);
+    const lines = content.split("\n").filter((l) => l.trim());
+    const md = format === "markdown";
+    // Group errors by signature
+    const result = groupBySignature(lines);
+    const stats = calculateStats(result);
+    const formatted = formatGroups(result, format);
+    const header = md
+        ? `**${stats.originalLines} lines → ${stats.uniqueErrors} unique patterns** (${stats.totalDuplicates} duplicates removed)\n\n`
+        : `${stats.originalLines} lines -> ${stats.uniqueErrors} unique patterns (${stats.totalDuplicates} duplicates removed)\n\n`;
+    const optimizedContent = header + formatted;
+    const optimizedTokens = countTokens(optimizedContent);
+    return {
+        optimizedContent,
+        detectedType: "errors",
+        originalTokens,
+        optimizedTokens,
+        savingsPercent: stats.reductionPercent,
+        method: "error-deduplication",
+    };
+}
+function optimizeGeneric(content, aggressive) {
+    const originalTokens = countTokens(content);
+    const result = compressContent(content, {
+        detail: aggressive ? "minimal" : "normal",
+    });
+    return {
+        optimizedContent: result.compressed,
+        detectedType: "generic",
+        originalTokens,
+        optimizedTokens: result.stats.compressedTokens,
+        savingsPercent: result.stats.reductionPercent,
+        method: result.stats.technique,
+    };
+}
+async function autoOptimize(args) {
+    const { content, hint = "auto", aggressive = false, format = "plain" } = args;
+    const md = format === "markdown";
+    // Minimum threshold for optimization (500 chars ~ 125 tokens)
+    if (content.length < 500) {
+        const msg = md
+            ? `## Already Optimal\n\nContent is too short (${content.length} chars) to benefit from optimization.\n\n${content}`
+            : `Already Optimal: Content too short (${content.length} chars)\n\n${content}`;
+        return {
+            content: [{ type: "text", text: msg }],
+        };
+    }
+    let result;
+    // Determine content type
+    if (hint === "build" || (hint === "auto" && isBuildOutput(content))) {
+        result = optimizeBuildOutput(content);
+    }
+    else if (hint === "logs" || (hint === "auto" && detectContentType(content) === "logs")) {
+        result = optimizeLogs(content, format);
+    }
+    else if (hint === "errors") {
+        result = optimizeErrors(content, format);
+    }
+    else {
+        // Use automatic type detection
+        const detectedType = detectContentType(content);
+        switch (detectedType) {
+            case "logs":
+                result = optimizeLogs(content, format);
+                break;
+            case "stacktrace":
+                result = optimizeErrors(content, format);
+                break;
+            default:
+                result = optimizeGeneric(content, aggressive);
+        }
+    }
+    // Format output - minimal header to save tokens
+    const stats = `[${result.detectedType}] ${result.originalTokens}→${result.optimizedTokens} tokens (-${result.savingsPercent}%)`;
+    const output = `${stats}\n${result.optimizedContent}`;
+    return {
+        content: [{ type: "text", text: output }],
+    };
+}
+export const autoOptimizeTool = {
+    name: "auto_optimize",
+    description: "Auto-compress verbose output (build errors, logs). 80-95% token reduction.",
+    inputSchema: autoOptimizeSchema,
+    execute: async (args) => autoOptimize(args),
+};

package/dist/tools/code-execute.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Code Execute Tool
+ *
+ * Executes TypeScript code with ctxopt SDK in a sandboxed environment.
+ * Reduces MCP token overhead by ~98% compared to individual tool calls.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const codeExecuteTool: ToolDefinition;
+//# sourceMappingURL=code-execute.d.ts.map

package/dist/tools/code-execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-execute.d.ts","sourceRoot":"","sources":["../../src/tools/code-execute.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAyFpD,eAAO,MAAM,eAAe,EAAE,cAK7B,CAAC"}

package/dist/tools/code-execute.js

@@ -0,0 +1,84 @@
+/**
+ * Code Execute Tool
+ *
+ * Executes TypeScript code with ctxopt SDK in a sandboxed environment.
+ * Reduces MCP token overhead by ~98% compared to individual tool calls.
+ */
+import { executeSandbox, DEFAULT_LIMITS } from "../sandbox/index.js";
+/**
+ * Minimal schema for token efficiency
+ */
+const codeExecuteSchema = {
+    type: "object",
+    properties: {
+        code: { type: "string" },
+        timeout: { type: "number" },
+    },
+    required: ["code"],
+};
+/**
+ * Execute code in sandbox
+ */
+async function executeCodeExecute(args) {
+    const { code, timeout = DEFAULT_LIMITS.timeout } = args;
+    // Validate timeout
+    const safeTimeout = Math.min(Math.max(timeout, 1000), // Min 1 second
+    DEFAULT_LIMITS.maxTimeout // Max 30 seconds
+    );
+    // Execute in sandbox
+    const result = await executeSandbox(code, {
+        workingDir: process.cwd(),
+        timeout: safeTimeout,
+        memoryLimit: DEFAULT_LIMITS.memoryLimit,
+        maxOutputTokens: DEFAULT_LIMITS.maxOutputTokens,
+    });
+    if (!result.success) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `[ERR] ${result.error}\n\nExecution time: ${result.stats.executionTimeMs}ms`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    // Format output
+    let output;
+    if (typeof result.output === "string") {
+        output = result.output;
+    }
+    else if (result.output === null || result.output === undefined) {
+        output = "(no output)";
+    }
+    else {
+        output = JSON.stringify(result.output, null, 2);
+    }
+    const header = `[OK] ${result.stats.executionTimeMs}ms, ${result.stats.tokensUsed} tokens`;
+    return {
+        content: [
+            {
+                type: "text",
+                text: `${header}\n\n${output}`,
+            },
+        ],
+    };
+}
+/**
+ * Tool description with SDK reference
+ */
+const DESCRIPTION = `Execute TypeScript with ctxopt SDK. 98% fewer tokens than tool calls.
+
+SDK (ctx):
+  compress: auto(content,hint?) logs(logs) diff(diff) semantic(content,ratio?)
+  code: parse(content,lang) extract(content,lang,{type,name}) skeleton(content,lang)
+  files: read(path) exists(path) glob(pattern)
+  utils: countTokens(text) detectType(content) detectLanguage(path)
+
+Example: return ctx.compress.auto(ctx.files.read("logs.txt"))`;
+export const codeExecuteTool = {
+    name: "code_execute",
+    description: DESCRIPTION,
+    inputSchema: codeExecuteSchema,
+    execute: executeCodeExecute,
+};

package/dist/tools/code-skeleton.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Code Skeleton Tool
+ *
+ * Extracts code skeleton (signatures only) from source files.
+ * Provides configurable depth levels and token statistics.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const codeSkeletonSchema: {
+    type: "object";
+    properties: {
+        filePath: {
+            type: string;
+        };
+        depth: {
+            enum: number[];
+        };
+    };
+    required: string[];
+};
+/**
+ * Execute code-skeleton tool
+ */
+export declare function executeCodeSkeleton(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+/**
+ * Code Skeleton Tool Definition
+ */
+export declare const codeSkeletonTool: ToolDefinition;
+//# sourceMappingURL=code-skeleton.d.ts.map

package/dist/tools/code-skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-skeleton.d.ts","sourceRoot":"","sources":["../../src/tools/code-skeleton.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAOpD,eAAO,MAAM,kBAAkB;;;;;;;;;;;CAO9B,CAAC;AAsIF;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,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,CAoE7D;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAK9B,CAAC"}