distill-mcp 0.6.0-beta

package/dist/tools/diff-compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff-compress.d.ts","sourceRoot":"","sources":["../../src/tools/diff-compress.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD;;GAEG;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;CAQ9B,CAAC;AAoCF;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC;IACT,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC,CA+CD;AAED;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAM9B,CAAC"}

package/dist/tools/diff-compress.js

@@ -0,0 +1,94 @@
+/**
+ * Diff Compress Tool
+ *
+ * Compress git diff output to reduce tokens while preserving essential changes.
+ * Supports three strategies: hunks-only, summary, and semantic.
+ */
+import { z } from "zod";
+import { compressDiff } from "../compressors/diff.js";
+/**
+ * JSON Schema for MCP tool registration
+ */
+// Minimal schema
+export const diffCompressSchema = {
+    type: "object",
+    properties: {
+        diff: { type: "string" },
+        strategy: { enum: ["hunks-only", "summary", "semantic"] },
+        maxTokens: { type: "number" },
+    },
+    required: ["diff", "strategy"],
+};
+/**
+ * Zod schema for runtime input validation
+ */
+const inputSchema = z.object({
+    diff: z.string().min(1, "Diff content is required"),
+    strategy: z.enum(["hunks-only", "summary", "semantic"]),
+    maxTokens: z.number().positive().optional(),
+});
+/**
+ * Format the compression result - minimal header to save tokens
+ */
+function formatOutput(output, _strategy) {
+    const savingsPercent = output.originalTokens > 0
+        ? Math.round(((output.originalTokens - output.compressedTokens) / output.originalTokens) * 100)
+        : 0;
+    const header = `[diff] ${output.filesChanged.length} files, +${output.additions}/-${output.deletions}, ${output.originalTokens}→${output.compressedTokens} tokens (-${savingsPercent}%)`;
+    return `${header}\n${output.compressed}`;
+}
+/**
+ * Execute diff compression
+ */
+export async function executeDiffCompress(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;
+    // Compress diff
+    const result = compressDiff(input.diff, {
+        strategy: input.strategy,
+        maxTokens: input.maxTokens,
+    });
+    // Build output
+    const output = {
+        compressed: result.compressed,
+        filesChanged: result.filesChanged,
+        summary: result.summary,
+        additions: result.additions,
+        deletions: result.deletions,
+        originalTokens: result.stats.originalTokens,
+        compressedTokens: result.stats.compressedTokens,
+    };
+    // Update session state with tokens saved
+    const tokensSaved = output.originalTokens - output.compressedTokens;
+    if (tokensSaved > 0) {
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: formatOutput(output, input.strategy),
+            },
+        ],
+    };
+}
+/**
+ * Tool definition for MCP registration
+ */
+export const diffCompressTool = {
+    name: "diff_compress",
+    description: "Compress git diff. Strategies: hunks-only, summary, semantic.",
+    inputSchema: diffCompressSchema,
+    execute: executeDiffCompress,
+};

package/dist/tools/discover-tools.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Discover Tools - Meta-tool for dynamic tool discovery
+ *
+ * Allows LLMs to discover and load available tools on-demand,
+ * reducing initial token consumption by ~80%.
+ *
+ * Supports TOON output format for additional ~40% token savings.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const discoverToolsTool: ToolDefinition;
+//# sourceMappingURL=discover-tools.d.ts.map

package/dist/tools/discover-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-tools.d.ts","sourceRoot":"","sources":["../../src/tools/discover-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAoMpD,eAAO,MAAM,iBAAiB,EAAE,cAK/B,CAAC"}

package/dist/tools/discover-tools.js

@@ -0,0 +1,163 @@
+/**
+ * Discover Tools - Meta-tool for dynamic tool discovery
+ *
+ * Allows LLMs to discover and load available tools on-demand,
+ * reducing initial token consumption by ~80%.
+ *
+ * Supports TOON output format for additional ~40% token savings.
+ */
+import { getDynamicLoader } from "./dynamic-loader.js";
+import { serializeToolsToToon, serializeToolsToToonTabular, serializeMetadataToToon, serializeMetadataToToonTabular, compareTokens, } from "../utils/toon-serializer.js";
+// Minimal schema - descriptions in tool description, not properties
+const discoverToolsSchema = {
+    type: "object",
+    properties: {
+        query: { type: "string" },
+        category: { enum: ["compress", "analyze", "logs", "code", "pipeline"] },
+        load: { type: "boolean" },
+        format: { enum: ["list", "toon", "toon-tabular"] },
+    },
+};
+async function executeDiscoverTools(args) {
+    const { query, category, load = false, format = "list" } = args;
+    const loader = getDynamicLoader();
+    // Get matching tools metadata
+    let matches;
+    if (query) {
+        matches = loader.searchTools(query).map((t) => ({
+            name: t.name,
+            category: t.category,
+            description: t.description,
+        }));
+    }
+    else if (category) {
+        matches = loader.getToolsByCategory(category).map((t) => ({
+            name: t.name,
+            category: t.category,
+            description: t.description,
+        }));
+    }
+    else {
+        // List all available tools
+        matches = loader.getAvailableTools();
+    }
+    // Load tools if requested
+    let loadedCount = 0;
+    if (load && matches.length > 0) {
+        const names = matches.map((m) => m.name);
+        const loaded = await loader.loadByNames(names);
+        loadedCount = loaded.length;
+    }
+    // Handle TOON format output
+    if (format === "toon" || format === "toon-tabular") {
+        return formatToonOutput(matches, format, load, loadedCount);
+    }
+    // Default list format
+    return formatListOutput(matches, loader, load, loadedCount);
+}
+/**
+ * Format output as TOON (Token-Oriented Object Notation)
+ *
+ * When load=false, uses lightweight metadata-only TOON (no schema loading).
+ * When load=true, loads full definitions and includes parameter info.
+ */
+async function formatToonOutput(matches, format, load, loadedCount) {
+    if (matches.length === 0) {
+        return {
+            content: [{ type: "text", text: "No tools found.\nCategories: compress|analyze|logs|code|pipeline" }],
+        };
+    }
+    const loader = getDynamicLoader();
+    let toonOutput;
+    let savingsNote;
+    if (load) {
+        // Load full tool definitions to get schemas for detailed TOON output
+        const toolDefs = await loader.loadByNames(matches.map((m) => m.name));
+        // Build category map
+        const categories = new Map();
+        for (const m of matches) {
+            categories.set(m.name, m.category);
+        }
+        // Serialize to full TOON with parameters
+        if (format === "toon-tabular") {
+            toonOutput = serializeToolsToToonTabular(toolDefs);
+        }
+        else {
+            toonOutput = serializeToolsToToon(toolDefs, {
+                groupByCategory: true,
+                categories,
+            });
+        }
+        const stats = compareTokens(toolDefs);
+        savingsNote = `[tokens] json:${stats.json} → toon:${format === "toon-tabular" ? stats.toonTabular : stats.toon} (-${stats.savings}%)`;
+    }
+    else {
+        // Use lightweight metadata-only TOON (no loading required)
+        const metadata = matches.map((m) => ({
+            name: m.name,
+            category: m.category,
+            description: m.description,
+        }));
+        if (format === "toon-tabular") {
+            toonOutput = serializeMetadataToToonTabular(metadata);
+        }
+        else {
+            toonOutput = serializeMetadataToToon(metadata, { groupByCategory: true });
+        }
+        savingsNote = "[lazy] metadata only (use load:true for full schemas)";
+    }
+    const lines = [toonOutput, "", savingsNote];
+    if (load) {
+        lines.push(`[loaded] ${loadedCount} tools activated`);
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+    };
+}
+/**
+ * Format output as standard list
+ */
+function formatListOutput(matches, loader, load, loadedCount) {
+    const lines = [];
+    if (matches.length === 0) {
+        lines.push("No tools found matching your criteria.");
+        lines.push("");
+        lines.push("Available categories: compress, analyze, logs, code, pipeline");
+    }
+    else {
+        // Group by category for better readability
+        const byCategory = new Map();
+        for (const tool of matches) {
+            const cat = tool.category;
+            if (!byCategory.has(cat)) {
+                byCategory.set(cat, []);
+            }
+            byCategory.get(cat).push(tool);
+        }
+        lines.push(`Found ${matches.length} tools:`);
+        lines.push("");
+        for (const [cat, tools] of byCategory) {
+            lines.push(`[${cat}]`);
+            for (const t of tools) {
+                const status = loader.isLoaded(t.name) ? "*" : " ";
+                lines.push(`${status} ${t.name}: ${t.description}`);
+            }
+            lines.push("");
+        }
+        if (load) {
+            lines.push(`Loaded ${loadedCount} new tools. They are now available for use.`);
+        }
+        else {
+            lines.push("Use load:true to activate these tools.");
+        }
+    }
+    return {
+        content: [{ type: "text", text: lines.join("\n") }],
+    };
+}
+export const discoverToolsTool = {
+    name: "discover_tools",
+    description: "Find and load optimization tools. Categories: compress, analyze, logs, code, pipeline.",
+    inputSchema: discoverToolsSchema,
+    execute: executeDiscoverTools,
+};

package/dist/tools/dynamic-loader.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Dynamic Tool Loader
+ *
+ * Manages lazy loading of MCP tools to reduce token consumption.
+ * Only core tools are loaded at startup; others are loaded on-demand.
+ */
+import type { ToolDefinition } from "./registry.js";
+import { type BM25Result } from "../utils/bm25.js";
+import { type HybridSearchResult } from "../utils/hybrid-search.js";
+export type ToolCategory = "compress" | "analyze" | "logs" | "code" | "pipeline" | "core";
+export interface ToolMetadata {
+    name: string;
+    category: ToolCategory;
+    keywords: string[];
+    description: string;
+    loader: () => Promise<ToolDefinition>;
+}
+/**
+ * Tool catalog with metadata for discovery
+ * Full tool definitions are loaded lazily via the loader function
+ */
+export declare const TOOL_CATALOG: ToolMetadata[];
+/**
+ * Dynamic Tool Loader
+ *
+ * Manages tool loading and provides discovery capabilities.
+ */
+export declare class DynamicToolLoader {
+    private loadedTools;
+    private onChangeCallbacks;
+    private bm25Index;
+    private hybridIndex;
+    /**
+     * Get searchable text from tool metadata
+     */
+    private static getSearchableText;
+    /**
+     * Get or create BM25 search index (lazy initialization)
+     */
+    private getBM25Index;
+    /**
+     * Get or create hybrid search index (lazy initialization)
+     */
+    private getHybridIndex;
+    /**
+     * Get metadata for all available tools (without loading them)
+     */
+    getAvailableTools(): Array<{
+        name: string;
+        category: ToolCategory;
+        description: string;
+    }>;
+    /**
+     * Search tools by query string using BM25 ranking
+     * Returns results sorted by relevance score (most relevant first)
+     */
+    searchTools(query: string): ToolMetadata[];
+    /**
+     * Search tools with BM25 scores and matched terms
+     * Useful for debugging or displaying search relevance
+     */
+    searchToolsWithScores(query: string): BM25Result<ToolMetadata>[];
+    /**
+     * Hybrid search combining BM25 (lexical) and semantic similarity
+     *
+     * This method finds tools even when the query uses different words
+     * than the tool description (e.g., "shrink output" → compress).
+     *
+     * @param query - Search query
+     * @returns Ranked results with both BM25 and semantic scores
+     */
+    searchToolsHybrid(query: string): Promise<HybridSearchResult<ToolMetadata>[]>;
+    /**
+     * Preload semantic embeddings for faster hybrid search
+     *
+     * Call this during idle time to avoid latency on first hybrid search.
+     * The embedding model (~23MB) is downloaded and cached on first use.
+     */
+    preloadSemanticSearch(): Promise<void>;
+    /**
+     * Check if semantic search is ready (embeddings loaded)
+     */
+    isSemanticSearchReady(): boolean;
+    /**
+     * Get tools by category
+     */
+    getToolsByCategory(category: ToolCategory): ToolMetadata[];
+    /**
+     * Load core tools (called at startup)
+     */
+    loadCoreTools(): Promise<ToolDefinition[]>;
+    /**
+     * Load tools by category
+     */
+    loadByCategory(category: ToolCategory): Promise<ToolDefinition[]>;
+    /**
+     * Load tools matching a query
+     */
+    loadByQuery(query: string): Promise<ToolDefinition[]>;
+    /**
+     * Load specific tools by name
+     */
+    loadByNames(names: string[]): Promise<ToolDefinition[]>;
+    /**
+     * Load all tools (fallback for clients that don't support dynamic loading)
+     */
+    loadAllTools(): Promise<ToolDefinition[]>;
+    /**
+     * Get already loaded tools
+     */
+    getLoadedTools(): ToolDefinition[];
+    /**
+     * Check if a tool is loaded
+     */
+    isLoaded(name: string): boolean;
+    /**
+     * Register callback for tool list changes
+     */
+    onToolsChanged(callback: () => void): void;
+    /**
+     * Internal: Load tools from metadata array
+     */
+    private loadToolsFromMetadata;
+    /**
+     * Emit change notification
+     */
+    private emitChange;
+}
+export declare function getDynamicLoader(): DynamicToolLoader;
+export declare function resetDynamicLoader(): void;
+//# sourceMappingURL=dynamic-loader.d.ts.map

package/dist/tools/dynamic-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dynamic-loader.d.ts","sourceRoot":"","sources":["../../src/tools/dynamic-loader.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAmC,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,YAAY,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,MAAM,CAAC;AAE1F,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,YAAY,CAAC;IACvB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;CACvC;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,EAAE,YAAY,EAoLtC,CAAC;AAEF;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,WAAW,CAA0C;IAC7D,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,SAAS,CAAwC;IACzD,OAAO,CAAC,WAAW,CAAgD;IAEnE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IAIhC;;OAEG;IACH,OAAO,CAAC,YAAY;IAWpB;;OAEG;IACH,OAAO,CAAC,cAAc;IAWtB;;OAEG;IACH,iBAAiB,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,YAAY,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;IAQzF;;;OAGG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,EAAE;IAM1C;;;OAGG;IACH,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,YAAY,CAAC,EAAE;IAKhE;;;;;;;;OAQG;IACG,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,YAAY,CAAC,EAAE,CAAC;IAKnF;;;;;OAKG;IACG,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5C;;OAEG;IACH,qBAAqB,IAAI,OAAO;IAIhC;;OAEG;IACH,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,YAAY,EAAE;IAI1D;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAKhD;;OAEG;IACG,cAAc,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAKvE;;OAEG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK3D;;OAEG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC;IAK7D;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAI/C;;OAEG;IACH,cAAc,IAAI,cAAc,EAAE;IAIlC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI/B;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IAI1C;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACH,OAAO,CAAC,UAAU;CASnB;AAOD,wBAAgB,gBAAgB,IAAI,iBAAiB,CAKpD;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}