distill-mcp 0.6.0-beta

package/dist/tools/semantic-compress.test.js

@@ -0,0 +1,182 @@
+/**
+ * Semantic Compress Tool Tests
+ */
+import { describe, it, expect } from "vitest";
+import { executeSemanticCompress } from "./semantic-compress.js";
+describe("semantic_compress tool", () => {
+    describe("basic compression", () => {
+        it("should compress content to approximately target ratio", async () => {
+            const content = `
+This is the introduction paragraph which contains important context.
+
+This is some middle content that provides additional details.
+More middle content here with less critical information.
+Even more content in the middle section that can be removed.
+
+Additional filler content that doesn't add much value.
+This paragraph exists mainly to pad the document length.
+
+This is the conclusion which summarizes the key points.
+      `.trim();
+            const result = await executeSemanticCompress({ content, targetRatio: 0.5 });
+            expect(result.isError).toBeFalsy();
+            // Should contain minimal header with stats
+            const text = result.content[0].text;
+            expect(text).toContain("[semantic]");
+        });
+        it("should preserve patterns when specified", async () => {
+            const content = `
+Regular content here that can be removed.
+
+CRITICAL: This must be preserved at all costs.
+
+More regular content that is less important.
+Even more filler content here.
+      `.trim();
+            const result = await executeSemanticCompress({
+                content,
+                targetRatio: 0.3,
+                preservePatterns: ["CRITICAL:.*"],
+            });
+            expect(result.isError).toBeFalsy();
+            expect(result.content[0].text).toContain("CRITICAL:");
+        });
+        it("should prioritize error messages", async () => {
+            const content = `
+Info: Starting the process now.
+
+Debug: Loading configuration files.
+
+Error: Failed to connect to database server.
+
+Info: Retrying connection attempt.
+
+Debug: More debug information here.
+      `.trim();
+            const result = await executeSemanticCompress({ content, targetRatio: 0.4 });
+            expect(result.isError).toBeFalsy();
+            expect(result.content[0].text).toContain("Error:");
+        });
+    });
+    describe("code block handling", () => {
+        it("should keep code blocks as single units", async () => {
+            const content = `
+Here is some introductory text.
+
+\`\`\`typescript
+function hello() {
+  return "world";
+}
+\`\`\`
+
+And some concluding text here.
+      `.trim();
+            const result = await executeSemanticCompress({ content, targetRatio: 0.8 });
+            expect(result.isError).toBeFalsy();
+            const text = result.content[0].text;
+            // If code block is included, it should be complete
+            if (text.includes("function hello")) {
+                expect(text).toContain('return "world"');
+                expect(text).toContain("```");
+            }
+        });
+    });
+    describe("input validation", () => {
+        it("should reject empty content", async () => {
+            const result = await executeSemanticCompress({ content: "" });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("Invalid input");
+        });
+        it("should reject invalid regex patterns", async () => {
+            const result = await executeSemanticCompress({
+                content: "test content here",
+                preservePatterns: ["[invalid"],
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain("Invalid regex");
+        });
+        it("should reject targetRatio below minimum", async () => {
+            const result = await executeSemanticCompress({
+                content: "test content",
+                targetRatio: 0.05,
+            });
+            expect(result.isError).toBe(true);
+        });
+        it("should reject targetRatio above maximum", async () => {
+            const result = await executeSemanticCompress({
+                content: "test content",
+                targetRatio: 0.95,
+            });
+            expect(result.isError).toBe(true);
+        });
+    });
+    describe("edge cases", () => {
+        it("should handle content shorter than target gracefully", async () => {
+            const result = await executeSemanticCompress({
+                content: "Short content",
+                targetRatio: 0.5,
+            });
+            // Should not error, just return content as-is
+            expect(result.isError).toBeFalsy();
+        });
+        it("should handle single paragraph content", async () => {
+            const result = await executeSemanticCompress({
+                content: "This is a single paragraph without any breaks or structure.",
+                targetRatio: 0.5,
+            });
+            expect(result.isError).toBeFalsy();
+        });
+        it("should handle content with only code blocks", async () => {
+            const content = `
+\`\`\`javascript
+const x = 1;
+const y = 2;
+console.log(x + y);
+\`\`\`
+      `.trim();
+            const result = await executeSemanticCompress({ content, targetRatio: 0.5 });
+            expect(result.isError).toBeFalsy();
+        });
+        it("should use default targetRatio of 0.5", async () => {
+            const content = Array(20).fill("Content paragraph here.").join("\n\n");
+            const result = await executeSemanticCompress({ content });
+            expect(result.isError).toBeFalsy();
+            // Output should show compression occurred (minimal header format)
+            expect(result.content[0].text).toContain("[semantic]");
+            expect(result.content[0].text).toContain("tokens");
+        });
+    });
+    describe("output format", () => {
+        it("should include compression statistics in minimal header", async () => {
+            const content = Array(10).fill("Paragraph of content here.").join("\n\n");
+            const result = await executeSemanticCompress({ content, targetRatio: 0.5 });
+            const text = result.content[0].text;
+            // Minimal header format: [semantic] X→Y tokens (-Z%)
+            expect(text).toMatch(/\[semantic\] \d+→\d+ tokens \(-\d+%\)/);
+        });
+        it("should show preserved segments when patterns match", async () => {
+            // Need enough content for compression to actually occur
+            const content = `
+Normal content here that will be evaluated for compression.
+
+IMPORTANT: This is preserved and must remain in the output.
+
+More normal content that provides additional context.
+
+Additional filler content that adds to the document length.
+
+Even more content here to ensure we have enough for compression.
+
+Final paragraph with some concluding thoughts about the topic.
+      `.trim();
+            const result = await executeSemanticCompress({
+                content,
+                targetRatio: 0.5,
+                preservePatterns: ["IMPORTANT:.*"],
+            });
+            const text = result.content[0].text;
+            // The preserved content should definitely be in the output
+            expect(text).toContain("IMPORTANT:");
+        });
+    });
+});

package/dist/tools/session-stats.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Session Stats Tool
+ *
+ * Provides session-wide statistics including:
+ * - Total tokens saved
+ * - Per-tool usage breakdown
+ * - Estimated cost reduction
+ * - Session duration and activity
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const sessionStatsSchema: {
+    type: "object";
+    properties: {
+        action: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        format: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+    };
+    required: never[];
+};
+export declare function executeSessionStats(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const sessionStatsTool: ToolDefinition;
+//# sourceMappingURL=session-stats.d.ts.map

package/dist/tools/session-stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-stats.d.ts","sourceRoot":"","sources":["../../src/tools/session-stats.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAapD,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;CAe9B,CAAC;AA4KF,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,CA0B7D;AAED,eAAO,MAAM,gBAAgB,EAAE,cAM9B,CAAC"}

package/dist/tools/session-stats.js

@@ -0,0 +1,194 @@
+/**
+ * Session Stats Tool
+ *
+ * Provides session-wide statistics including:
+ * - Total tokens saved
+ * - Per-tool usage breakdown
+ * - Estimated cost reduction
+ * - Session duration and activity
+ */
+import { z } from "zod";
+import { getSessionTracker, resetSessionTracker, } from "../analytics/session-tracker.js";
+// Anthropic pricing (per 1M tokens) - Claude 3.5 Sonnet
+const ANTHROPIC_PRICING = {
+    input: 3.0, // $3 per 1M input tokens
+    output: 15.0, // $15 per 1M output tokens
+};
+export const sessionStatsSchema = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: ["get", "reset", "export"],
+            description: "Action to perform: get stats, reset session, or export JSON",
+        },
+        format: {
+            type: "string",
+            enum: ["summary", "detailed", "json"],
+            description: "Output format (default: summary)",
+        },
+    },
+    required: [],
+};
+const inputSchema = z.object({
+    action: z.enum(["get", "reset", "export"]).optional().default("get"),
+    format: z.enum(["summary", "detailed", "json"]).optional().default("summary"),
+});
+/**
+ * Format duration in human-readable format
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        return `${hours}h ${minutes % 60}m`;
+    }
+    if (minutes > 0) {
+        return `${minutes}m ${seconds % 60}s`;
+    }
+    return `${seconds}s`;
+}
+/**
+ * Calculate cost reduction based on tokens saved
+ */
+function calculateCostReduction(tokensSaved) {
+    // Assume saved tokens would have been input tokens
+    return (tokensSaved / 1_000_000) * ANTHROPIC_PRICING.input;
+}
+/**
+ * Format summary output
+ */
+function formatSummary(stats) {
+    const durationMs = Date.now() - stats.startTime.getTime();
+    const optimizationRate = stats.totalTokensIn > 0
+        ? ((stats.totalTokensSaved / stats.totalTokensIn) * 100).toFixed(1)
+        : "0";
+    const costSaved = calculateCostReduction(stats.totalTokensSaved);
+    const parts = [];
+    parts.push("## Session Statistics\n");
+    // Overview table
+    parts.push("### Overview\n");
+    parts.push("| Metric | Value |");
+    parts.push("|--------|-------|");
+    parts.push(`| Session Duration | ${formatDuration(durationMs)} |`);
+    parts.push(`| Total Tool Calls | ${stats.totalInvocations} |`);
+    parts.push(`| Tokens Processed | ${stats.totalTokensIn.toLocaleString()} |`);
+    parts.push(`| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |`);
+    parts.push(`| Optimization Rate | ${optimizationRate}% |`);
+    parts.push(`| Est. Cost Saved | $${costSaved.toFixed(4)} |`);
+    if (stats.totalErrors > 0) {
+        parts.push(`| Errors | ${stats.totalErrors} |`);
+    }
+    // Top tools
+    const toolEntries = Object.entries(stats.toolStats)
+        .sort((a, b) => b[1].tokensSaved - a[1].tokensSaved)
+        .slice(0, 5);
+    if (toolEntries.length > 0) {
+        parts.push("\n### Top Tools by Savings\n");
+        parts.push("| Tool | Calls | Saved |");
+        parts.push("|------|-------|-------|");
+        for (const [name, toolStats] of toolEntries) {
+            parts.push(`| ${name} | ${toolStats.invocations} | ${toolStats.tokensSaved.toLocaleString()} |`);
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * Format detailed output
+ */
+function formatDetailed(stats) {
+    const durationMs = Date.now() - stats.startTime.getTime();
+    const optimizationRate = stats.totalTokensIn > 0
+        ? ((stats.totalTokensSaved / stats.totalTokensIn) * 100).toFixed(1)
+        : "0";
+    const costSaved = calculateCostReduction(stats.totalTokensSaved);
+    const parts = [];
+    parts.push("## Session Statistics (Detailed)\n");
+    // Session info
+    parts.push("### Session Info\n");
+    parts.push(`- **Started**: ${stats.startTime.toISOString()}`);
+    parts.push(`- **Duration**: ${formatDuration(durationMs)}`);
+    parts.push(`- **Last Activity**: ${stats.lastActivityTime.toISOString()}`);
+    // Token metrics
+    parts.push("\n### Token Metrics\n");
+    parts.push("| Metric | Value |");
+    parts.push("|--------|-------|");
+    parts.push(`| Tokens In | ${stats.totalTokensIn.toLocaleString()} |`);
+    parts.push(`| Tokens Out | ${stats.totalTokensOut.toLocaleString()} |`);
+    parts.push(`| Tokens Saved | ${stats.totalTokensSaved.toLocaleString()} |`);
+    parts.push(`| Optimization Rate | ${optimizationRate}% |`);
+    parts.push(`| Est. Cost Saved | $${costSaved.toFixed(4)} |`);
+    // All tools breakdown
+    const toolEntries = Object.entries(stats.toolStats).sort((a, b) => b[1].invocations - a[1].invocations);
+    if (toolEntries.length > 0) {
+        parts.push("\n### Tool Breakdown\n");
+        parts.push("| Tool | Calls | In | Out | Saved | Avg Time |");
+        parts.push("|------|-------|-----|-----|-------|----------|");
+        for (const [name, toolStats] of toolEntries) {
+            const avgTime = toolStats.invocations > 0
+                ? Math.round(toolStats.totalDurationMs / toolStats.invocations)
+                : 0;
+            parts.push(`| ${name} | ${toolStats.invocations} | ${toolStats.tokensIn.toLocaleString()} | ${toolStats.tokensOut.toLocaleString()} | ${toolStats.tokensSaved.toLocaleString()} | ${avgTime}ms |`);
+        }
+    }
+    // Error summary
+    if (stats.totalErrors > 0) {
+        parts.push(`\n### Errors: ${stats.totalErrors} total`);
+    }
+    return parts.join("\n");
+}
+/**
+ * Format JSON export
+ */
+function formatJson(stats) {
+    const durationMs = Date.now() - stats.startTime.getTime();
+    const optimizationRate = stats.totalTokensIn > 0 ? stats.totalTokensSaved / stats.totalTokensIn : 0;
+    return JSON.stringify({
+        session: {
+            startTime: stats.startTime.toISOString(),
+            lastActivityTime: stats.lastActivityTime.toISOString(),
+            durationMs,
+        },
+        totals: {
+            invocations: stats.totalInvocations,
+            tokensIn: stats.totalTokensIn,
+            tokensOut: stats.totalTokensOut,
+            tokensSaved: stats.totalTokensSaved,
+            optimizationRate: Math.round(optimizationRate * 1000) / 10, // percentage with 1 decimal
+            estimatedCostSavedUsd: calculateCostReduction(stats.totalTokensSaved),
+            errors: stats.totalErrors,
+        },
+        tools: stats.toolStats,
+    }, null, 2);
+}
+export async function executeSessionStats(args) {
+    const { action, format } = inputSchema.parse(args);
+    if (action === "reset") {
+        resetSessionTracker();
+        return {
+            content: [{ type: "text", text: "Session statistics have been reset." }],
+        };
+    }
+    const tracker = getSessionTracker();
+    const stats = tracker.getStats();
+    let output;
+    if (action === "export" || format === "json") {
+        output = formatJson(stats);
+    }
+    else if (format === "detailed") {
+        output = formatDetailed(stats);
+    }
+    else {
+        output = formatSummary(stats);
+    }
+    return {
+        content: [{ type: "text", text: output }],
+    };
+}
+export const sessionStatsTool = {
+    name: "session_stats",
+    description: "Get session-wide statistics including tokens saved, cost reduction, and per-tool usage breakdown. Use action='reset' to start fresh or action='export' for JSON output.",
+    inputSchema: sessionStatsSchema,
+    execute: executeSessionStats,
+};

package/dist/tools/set-output-config.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Set Output Config Tool
+ *
+ * Configure global output format and verbosity settings.
+ * Affects all tool outputs in the session.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const setOutputConfigSchema: {
+    type: "object";
+    properties: {
+        action: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        verbosity: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        mode: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        useToon: {
+            type: string;
+            description: string;
+        };
+        includeStats: {
+            type: string;
+            description: string;
+        };
+    };
+    required: never[];
+};
+export declare const setOutputConfigTool: ToolDefinition;
+//# sourceMappingURL=set-output-config.d.ts.map

package/dist/tools/set-output-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-output-config.d.ts","sourceRoot":"","sources":["../../src/tools/set-output-config.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAUpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BjC,CAAC;AAgGF,eAAO,MAAM,mBAAmB,EAAE,cAMjC,CAAC"}

package/dist/tools/set-output-config.js

@@ -0,0 +1,122 @@
+/**
+ * Set Output Config Tool
+ *
+ * Configure global output format and verbosity settings.
+ * Affects all tool outputs in the session.
+ */
+import { z } from "zod";
+import { getOutputConfig, setOutputConfig, resetOutputConfig, } from "../config/output-config.js";
+export const setOutputConfigSchema = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: ["get", "set", "reset"],
+            description: "Action: get current config, set new values, or reset to defaults",
+        },
+        verbosity: {
+            type: "string",
+            enum: ["minimal", "normal", "detailed"],
+            description: "Verbosity level for output",
+        },
+        mode: {
+            type: "string",
+            enum: ["structured", "prose", "toon"],
+            description: "Output format mode",
+        },
+        useToon: {
+            type: "boolean",
+            description: "Use TOON format when applicable",
+        },
+        includeStats: {
+            type: "boolean",
+            description: "Include statistics in output",
+        },
+    },
+    required: [],
+};
+const inputSchema = z.object({
+    action: z.enum(["get", "set", "reset"]).optional().default("set"),
+    verbosity: z.enum(["minimal", "normal", "detailed"]).optional(),
+    mode: z.enum(["structured", "prose", "toon"]).optional(),
+    useToon: z.boolean().optional(),
+    includeStats: z.boolean().optional(),
+});
+/**
+ * Format config for display
+ */
+function formatConfig(config) {
+    const lines = [];
+    lines.push("[Output Config]");
+    lines.push(`verbosity: ${config.verbosity}`);
+    lines.push(`mode: ${config.mode}`);
+    lines.push(`useToon: ${config.useToon}`);
+    lines.push(`includeStats: ${config.includeStats}`);
+    return lines.join("\n");
+}
+/**
+ * Execute output config tool
+ */
+async function executeSetOutputConfig(args) {
+    const input = inputSchema.parse(args);
+    switch (input.action) {
+        case "get": {
+            const config = getOutputConfig();
+            return {
+                content: [{ type: "text", text: formatConfig(config) }],
+            };
+        }
+        case "reset": {
+            resetOutputConfig();
+            const config = getOutputConfig();
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Output config reset to defaults.\n\n${formatConfig(config)}`,
+                    },
+                ],
+            };
+        }
+        case "set":
+        default: {
+            // Build update object from provided values
+            const update = {};
+            if (input.verbosity !== undefined) {
+                update.verbosity = input.verbosity;
+            }
+            if (input.mode !== undefined) {
+                update.mode = input.mode;
+            }
+            if (input.useToon !== undefined) {
+                update.useToon = input.useToon;
+            }
+            if (input.includeStats !== undefined) {
+                update.includeStats = input.includeStats;
+            }
+            // Apply updates if any
+            if (Object.keys(update).length > 0) {
+                setOutputConfig(update);
+            }
+            const config = getOutputConfig();
+            const changedFields = Object.keys(update);
+            const changeMsg = changedFields.length > 0
+                ? `Updated: ${changedFields.join(", ")}`
+                : "No changes (provide verbosity, mode, useToon, or includeStats)";
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `${changeMsg}\n\n${formatConfig(config)}`,
+                    },
+                ],
+            };
+        }
+    }
+}
+export const setOutputConfigTool = {
+    name: "set_output_config",
+    description: "Configure global output format. Set verbosity (minimal/normal/detailed), mode (structured/prose/toon), and stats inclusion.",
+    inputSchema: setOutputConfigSchema,
+    execute: executeSetOutputConfig,
+};

package/dist/tools/smart-cache-tool.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Smart Cache MCP Tool
+ *
+ * Exposes cache operations for user interaction:
+ * - get: Retrieve cached content
+ * - set: Store content in cache
+ * - invalidate: Remove specific entries
+ * - stats: View cache statistics
+ * - clear: Clear all cache entries
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const smartCacheSchema: {
+    type: "object";
+    properties: {
+        action: {
+            enum: string[];
+        };
+        key: {
+            type: string;
+        };
+        value: {
+            type: string;
+        };
+        filePath: {
+            type: string;
+        };
+    };
+    required: string[];
+};
+export declare function executeSmartCache(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare const smartCacheTool: ToolDefinition;
+//# sourceMappingURL=smart-cache-tool.d.ts.map

package/dist/tools/smart-cache-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smart-cache-tool.d.ts","sourceRoot":"","sources":["../../src/tools/smart-cache-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAIpD,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;CAS5B,CAAC;AAyCF,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAmKhF;AAED,eAAO,MAAM,cAAc,EAAE,cAK5B,CAAC"}