distill-mcp 0.6.0-beta

package/dist/server.js

@@ -0,0 +1,133 @@
+/**
+ * CtxOpt MCP Server
+ *
+ * Main server implementation with dynamic tool loading.
+ * Only core tools are loaded at startup to minimize token consumption.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+// Middleware
+import { createMiddlewareChain } from "./middleware/chain.js";
+import { createLoggingMiddleware } from "./middleware/logging.js";
+// Tools
+import { createToolRegistry } from "./tools/registry.js";
+import { getDynamicLoader, resetDynamicLoader } from "./tools/dynamic-loader.js";
+import { discoverToolsTool } from "./tools/discover-tools.js";
+import { lazyMcpTools, setLazyMcpRegistry, calculateLazySavings } from "./tools/lazy-mcp.js";
+/**
+ * Create and configure the MCP server
+ */
+export async function createServer(config = {}) {
+    // Determine loading mode (support legacy loadAllTools option)
+    const mode = config.mode ?? (config.loadAllTools ? "all" : "core");
+    // Reset dynamic loader for fresh start
+    resetDynamicLoader();
+    const loader = getDynamicLoader();
+    // Create middleware chain
+    const middleware = createMiddlewareChain();
+    middleware.use(createLoggingMiddleware({ verbose: config.verbose ?? false }));
+    // Create tool registry
+    const tools = createToolRegistry();
+    tools.setMiddlewareChain(middleware);
+    // Load tools based on mode
+    if (mode === "lazy") {
+        // Lazy mode: Only 2 meta-tools (95% token savings)
+        for (const tool of lazyMcpTools) {
+            tools.register(tool);
+        }
+        // Connect registry to lazy-mcp for run_tool execution
+        setLazyMcpRegistry({
+            execute: async (name, args) => {
+                const result = await tools.execute(name, args);
+                return { content: result.content, isError: result.isError };
+            },
+        });
+        if (config.verbose) {
+            const savings = calculateLazySavings();
+            console.error(`[ctxopt] Lazy mode: ${savings.savingsPercent}% token savings`);
+        }
+    }
+    else if (mode === "all") {
+        // All mode: Load all tools at startup
+        tools.register(discoverToolsTool);
+        const allTools = await loader.loadAllTools();
+        for (const tool of allTools) {
+            tools.register(tool);
+        }
+    }
+    else {
+        // Core mode (default): Core tools + discover_tools
+        tools.register(discoverToolsTool);
+        const coreTools = await loader.loadCoreTools();
+        for (const tool of coreTools) {
+            tools.register(tool);
+        }
+    }
+    // Connect dynamic loader to registry
+    loader.onToolsChanged(() => {
+        // Register newly loaded tools
+        for (const tool of loader.getLoadedTools()) {
+            if (!tools.get(tool.name)) {
+                tools.register(tool);
+            }
+        }
+    });
+    // Create MCP server
+    const server = new Server({
+        name: "@ctxopt/mcp-server",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    // Handle ListTools request
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: tools.getToolDefinitions(),
+    }));
+    // Handle CallTool request
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        // Try to load tool dynamically if not found
+        if (!tools.get(name)) {
+            const loaded = await loader.loadByNames([name]);
+            for (const tool of loaded) {
+                tools.register(tool);
+            }
+        }
+        const result = await tools.execute(name, args);
+        return {
+            content: result.content,
+            isError: result.isError,
+        };
+    });
+    // Set up notification for tool list changes
+    tools.onToolsChanged(() => {
+        // Send notification to client that tool list has changed
+        server.notification({
+            method: "notifications/tools/list_changed",
+        });
+    });
+    return {
+        server,
+        middleware,
+        tools,
+    };
+}
+/**
+ * Run the MCP server on stdio transport
+ */
+export async function runServer(config = {}) {
+    const { server } = await createServer(config);
+    const transport = new StdioServerTransport();
+    // Handle server close event
+    server.onclose = async () => {
+        if (config.verbose) {
+            console.error("[ctxopt] Server connection closed");
+        }
+        process.exit(0);
+    };
+    await server.connect(transport);
+    console.error("CtxOpt MCP Server running on stdio");
+}

package/dist/summarizers/build-logs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Build Logs Summarizer
+ *
+ * Summarizes build tool output (webpack, vite, tsc, esbuild, etc.).
+ */
+import type { Summarizer } from "./types.js";
+/**
+ * Build logs summarizer
+ */
+export declare const buildLogsSummarizer: Summarizer;
+//# sourceMappingURL=build-logs.d.ts.map

package/dist/summarizers/build-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-logs.d.ts","sourceRoot":"","sources":["../../src/summarizers/build-logs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EAKX,MAAM,YAAY,CAAC;AA+GpB;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAwHjC,CAAC"}

package/dist/summarizers/build-logs.js

@@ -0,0 +1,234 @@
+/**
+ * Build Logs Summarizer
+ *
+ * Summarizes build tool output (webpack, vite, tsc, esbuild, etc.).
+ */
+import { parseLogLine, calculateTimespan, deduplicateEntries, filterByTimeframe, isKeyEvent, } from "../utils/log-parser.js";
+import { MAX_ENTRIES } from "./types.js";
+/**
+ * Build tool detection patterns
+ */
+const BUILD_TOOL_PATTERNS = {
+    webpack: /\b(webpack|Module|chunk|bundle)\b/i,
+    vite: /\b(vite|hmr|pre-bundling)\b/i,
+    tsc: /\b(tsc|typescript|\.ts\(\d+,\d+\)|error TS\d+)\b/i,
+    esbuild: /\b(esbuild|bundled?)\b/i,
+    rollup: /\b(rollup|bundle)\b/i,
+    npm: /\b(npm|added \d+ package|npm WARN|npm ERR)\b/i,
+};
+/**
+ * Build error patterns
+ */
+const ERROR_PATTERNS = [
+    // TypeScript: error TS2304: Cannot find name 'foo'
+    /error\s+TS(\d+):\s*(.+)/i,
+    // ESLint: error  rule-name  message
+    /error\s+([a-z\-@\/]+)\s+(.+)/i,
+    // Webpack: Module not found
+    /Module not found:\s*(.+)/i,
+    // Generic: ERROR: message
+    /\bERROR[:\s]+(.+)/i,
+    // npm ERR!
+    /npm ERR!\s*(.+)/,
+];
+/**
+ * Build duration patterns
+ */
+const DURATION_PATTERNS = [
+    // Built in 1.23s
+    /Built?\s+in\s+(\d+(?:\.\d+)?)\s*(s|ms)/i,
+    // Done in 1.23s
+    /Done\s+in\s+(\d+(?:\.\d+)?)\s*(s|ms)/i,
+    // Time: 1234ms
+    /Time:\s*(\d+(?:\.\d+)?)\s*(s|ms)/i,
+    // Compiled in 1.23s
+    /Compiled?\s+in\s+(\d+(?:\.\d+)?)\s*(s|ms)/i,
+];
+/**
+ * Bundle size patterns
+ */
+const SIZE_PATTERNS = [
+    // dist/main.js  45.2 kB
+    /(\S+\.(?:js|css|mjs))\s+(\d+(?:\.\d+)?)\s*(B|KB|MB|kB)/i,
+    // gzipped: 12.3 kB
+    /gzip(?:ped)?:\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|kB)/i,
+];
+/**
+ * Parse build duration from logs
+ */
+function parseBuildDuration(logs) {
+    for (const pattern of DURATION_PATTERNS) {
+        const match = logs.match(pattern);
+        if (match) {
+            const value = parseFloat(match[1] ?? "0");
+            const unit = (match[2] ?? "ms").toLowerCase();
+            return unit === "s" ? value * 1000 : value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Parse bundle sizes from logs
+ */
+function parseBundleSizes(logs) {
+    const sizes = [];
+    const lines = logs.split("\n");
+    for (const line of lines) {
+        const match = line.match(SIZE_PATTERNS[0]);
+        if (match) {
+            sizes.push({
+                file: match[1] ?? "",
+                size: parseFloat(match[2] ?? "0"),
+                unit: match[3] ?? "B",
+            });
+        }
+    }
+    return sizes;
+}
+/**
+ * Detect build tool from logs
+ */
+function detectBuildTool(logs) {
+    for (const [tool, pattern] of Object.entries(BUILD_TOOL_PATTERNS)) {
+        if (pattern.test(logs)) {
+            return tool;
+        }
+    }
+    return "generic";
+}
+/**
+ * Build logs summarizer
+ */
+export const buildLogsSummarizer = {
+    name: "build-logs",
+    logType: "build",
+    canSummarize(logs) {
+        const indicators = [
+            /\b(webpack|vite|esbuild|rollup|parcel|tsc)\b/i,
+            /\b(Compiling|Bundling|Building)\b/i,
+            /\berror\s+TS\d+\b/,
+            /\bModule not found\b/i,
+            /\bBuilt?\s+in\b/i,
+            /\.(js|ts|tsx|jsx)\s+\d+(\.\d+)?\s*(KB|MB|B)/i,
+        ];
+        return indicators.some((p) => p.test(logs));
+    },
+    summarize(logs, options) {
+        const lines = logs.split("\n").filter((l) => l.trim());
+        const errors = [];
+        const warnings = [];
+        const keyEvents = [];
+        const allEntries = [];
+        const buildTool = detectBuildTool(logs);
+        const buildDuration = parseBuildDuration(logs);
+        const bundleSizes = parseBundleSizes(logs);
+        // Track TypeScript errors by code
+        const tsErrorCodes = new Map();
+        // Parse all lines
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const entry = parseLogLine(trimmed);
+            allEntries.push(entry);
+            // Check for errors
+            let isError = false;
+            for (const pattern of ERROR_PATTERNS) {
+                const match = trimmed.match(pattern);
+                if (match) {
+                    isError = true;
+                    errors.push({
+                        level: "error",
+                        message: match[2] ?? match[1] ?? trimmed,
+                        count: 1,
+                        raw: trimmed,
+                    });
+                    // Track TS error codes
+                    const tsMatch = trimmed.match(/TS(\d+)/);
+                    if (tsMatch) {
+                        const code = `TS${tsMatch[1]}`;
+                        tsErrorCodes.set(code, (tsErrorCodes.get(code) || 0) + 1);
+                    }
+                    break;
+                }
+            }
+            // Check for warnings
+            if (!isError && /\bwarn(?:ing)?\b/i.test(trimmed)) {
+                warnings.push({
+                    level: "warning",
+                    message: entry.message,
+                    count: 1,
+                    raw: trimmed,
+                });
+            }
+            // Detect key events
+            if (isKeyEvent(trimmed) || /\b(start|done|finish|complet|success|fail)\b/i.test(trimmed)) {
+                keyEvents.push(entry);
+            }
+        }
+        // Filter by timeframe if specified
+        const filteredEntries = filterByTimeframe(allEntries, options.timeframe);
+        // Calculate timespan
+        const timespan = calculateTimespan(filteredEntries);
+        // Deduplicate errors and warnings
+        const deduplicatedErrors = deduplicateEntries(errors);
+        const deduplicatedWarnings = deduplicateEntries(warnings);
+        // Calculate total bundle size
+        let totalBundleSize = 0;
+        for (const { size, unit } of bundleSizes) {
+            const multiplier = unit.toLowerCase() === "kb" ? 1024 : unit.toLowerCase() === "mb" ? 1024 * 1024 : 1;
+            totalBundleSize += size * multiplier;
+        }
+        // Build statistics
+        const statistics = {
+            timespan,
+            totalLines: lines.length,
+            errorCount: errors.length,
+            warningCount: warnings.length,
+            infoCount: allEntries.filter((e) => e.level === "info").length,
+            debugCount: allEntries.filter((e) => e.level === "debug").length,
+            buildDuration,
+            compiledFiles: bundleSizes.length,
+            bundleSize: totalBundleSize > 0 ? totalBundleSize : undefined,
+        };
+        // Build overview
+        const overview = buildOverview(buildTool, statistics, tsErrorCodes);
+        return {
+            logType: "build",
+            overview,
+            errors: deduplicatedErrors.slice(0, MAX_ENTRIES[options.detail].errors),
+            warnings: deduplicatedWarnings.slice(0, MAX_ENTRIES[options.detail].warnings),
+            keyEvents: keyEvents.slice(0, MAX_ENTRIES[options.detail].events),
+            statistics,
+        };
+    },
+};
+/**
+ * Build overview text
+ */
+function buildOverview(buildTool, stats, tsErrorCodes) {
+    const parts = [`${buildTool} build`];
+    if (stats.buildDuration) {
+        parts.push(`completed in ${(stats.buildDuration / 1000).toFixed(2)}s`);
+    }
+    if (stats.errorCount > 0) {
+        parts.push(`${stats.errorCount} errors`);
+        // Add top TS error codes
+        if (tsErrorCodes.size > 0) {
+            const topCodes = Array.from(tsErrorCodes.entries())
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 3)
+                .map(([code, count]) => `${code}(${count})`)
+                .join(", ");
+            parts.push(`[${topCodes}]`);
+        }
+    }
+    else {
+        parts.push("successful");
+    }
+    if (stats.bundleSize && stats.bundleSize > 0) {
+        const sizeKB = (stats.bundleSize / 1024).toFixed(1);
+        parts.push(`${sizeKB} KB total`);
+    }
+    return parts.join(" - ");
+}

package/dist/summarizers/generic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generic Logs Summarizer
+ *
+ * Fallback summarizer for application logs that don't match specific patterns.
+ */
+import type { Summarizer } from "./types.js";
+/**
+ * Generic logs summarizer
+ */
+export declare const genericSummarizer: Summarizer;
+//# sourceMappingURL=generic.d.ts.map

package/dist/summarizers/generic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generic.d.ts","sourceRoot":"","sources":["../../src/summarizers/generic.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EAKX,MAAM,YAAY,CAAC;AAUpB;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAwE/B,CAAC"}

package/dist/summarizers/generic.js

@@ -0,0 +1,93 @@
+/**
+ * Generic Logs Summarizer
+ *
+ * Fallback summarizer for application logs that don't match specific patterns.
+ */
+import { parseLogLine, calculateTimespan, deduplicateEntries, filterByTimeframe, isKeyEvent, } from "../utils/log-parser.js";
+import { MAX_ENTRIES } from "./types.js";
+/**
+ * Generic logs summarizer
+ */
+export const genericSummarizer = {
+    name: "generic",
+    logType: "generic",
+    canSummarize(_logs) {
+        // Generic summarizer can handle anything
+        return true;
+    },
+    summarize(logs, options) {
+        const lines = logs.split("\n").filter((l) => l.trim());
+        const errors = [];
+        const warnings = [];
+        const keyEvents = [];
+        const allEntries = [];
+        // Parse all lines
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            const entry = parseLogLine(trimmed);
+            allEntries.push(entry);
+            // Categorize by level
+            switch (entry.level) {
+                case "error":
+                    errors.push(entry);
+                    break;
+                case "warning":
+                    warnings.push(entry);
+                    break;
+            }
+            // Detect key events
+            if (isKeyEvent(trimmed)) {
+                keyEvents.push(entry);
+            }
+        }
+        // Filter by timeframe if specified
+        const filteredEntries = filterByTimeframe(allEntries, options.timeframe);
+        // Calculate timespan
+        const timespan = calculateTimespan(filteredEntries);
+        // Deduplicate errors and warnings
+        const deduplicatedErrors = deduplicateEntries(errors);
+        const deduplicatedWarnings = deduplicateEntries(warnings);
+        // Build statistics
+        const statistics = {
+            timespan,
+            totalLines: lines.length,
+            errorCount: errors.length,
+            warningCount: warnings.length,
+            infoCount: allEntries.filter((e) => e.level === "info").length,
+            debugCount: allEntries.filter((e) => e.level === "debug").length,
+        };
+        // Build overview
+        const overview = buildOverview(statistics);
+        return {
+            logType: options.logType || "generic",
+            overview,
+            errors: deduplicatedErrors.slice(0, MAX_ENTRIES[options.detail].errors),
+            warnings: deduplicatedWarnings.slice(0, MAX_ENTRIES[options.detail].warnings),
+            keyEvents: keyEvents.slice(0, MAX_ENTRIES[options.detail].events),
+            statistics,
+        };
+    },
+};
+/**
+ * Build overview text
+ */
+function buildOverview(stats) {
+    const parts = [];
+    parts.push(`${stats.totalLines.toLocaleString()} lines`);
+    if (stats.timespan) {
+        parts.push(`spanning ${stats.timespan.durationFormatted}`);
+    }
+    const levelCounts = [];
+    if (stats.errorCount > 0)
+        levelCounts.push(`${stats.errorCount} errors`);
+    if (stats.warningCount > 0)
+        levelCounts.push(`${stats.warningCount} warnings`);
+    if (stats.infoCount > 0)
+        levelCounts.push(`${stats.infoCount} info`);
+    if (levelCounts.length > 0) {
+        parts.push(`(${levelCounts.join(", ")})`);
+    }
+    return parts.join(" ") || "Log summary";
+}

package/dist/summarizers/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Log Summarizers
+ *
+ * Exports all summarizers and utility functions.
+ */
+export * from "./types.js";
+export { serverLogsSummarizer } from "./server-logs.js";
+export { testLogsSummarizer } from "./test-logs.js";
+export { buildLogsSummarizer } from "./build-logs.js";
+export { genericSummarizer } from "./generic.js";
+import type { Summarizer, LogType } from "./types.js";
+/**
+ * All available summarizers in priority order
+ */
+export declare const summarizers: Summarizer[];
+/**
+ * Get the appropriate summarizer for the given logs
+ */
+export declare function getSummarizer(logs: string, preferredType?: LogType): Summarizer;
+//# sourceMappingURL=index.d.ts.map

package/dist/summarizers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/summarizers/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,cAAc,YAAY,CAAC;AAC3B,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAEjD,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,WAAW,EAAE,UAAU,EAKnC,CAAC;AAEF;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,UAAU,CAkB/E"}

package/dist/summarizers/index.js

@@ -0,0 +1,43 @@
+/**
+ * Log Summarizers
+ *
+ * Exports all summarizers and utility functions.
+ */
+export * from "./types.js";
+export { serverLogsSummarizer } from "./server-logs.js";
+export { testLogsSummarizer } from "./test-logs.js";
+export { buildLogsSummarizer } from "./build-logs.js";
+export { genericSummarizer } from "./generic.js";
+import { serverLogsSummarizer } from "./server-logs.js";
+import { testLogsSummarizer } from "./test-logs.js";
+import { buildLogsSummarizer } from "./build-logs.js";
+import { genericSummarizer } from "./generic.js";
+/**
+ * All available summarizers in priority order
+ */
+export const summarizers = [
+    serverLogsSummarizer,
+    testLogsSummarizer,
+    buildLogsSummarizer,
+    genericSummarizer, // Fallback
+];
+/**
+ * Get the appropriate summarizer for the given logs
+ */
+export function getSummarizer(logs, preferredType) {
+    // If a type is specified, find that summarizer
+    if (preferredType) {
+        const preferred = summarizers.find((s) => s.logType === preferredType);
+        if (preferred) {
+            return preferred;
+        }
+    }
+    // Auto-detect based on content
+    for (const summarizer of summarizers) {
+        if (summarizer.logType !== "generic" && summarizer.canSummarize(logs)) {
+            return summarizer;
+        }
+    }
+    // Fallback to generic
+    return genericSummarizer;
+}

package/dist/summarizers/server-logs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Server Logs Summarizer
+ *
+ * Summarizes HTTP server logs with request statistics, response times, and error tracking.
+ */
+import type { Summarizer } from "./types.js";
+/**
+ * Server logs summarizer
+ */
+export declare const serverLogsSummarizer: Summarizer;
+//# sourceMappingURL=server-logs.d.ts.map

package/dist/summarizers/server-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-logs.d.ts","sourceRoot":"","sources":["../../src/summarizers/server-logs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,UAAU,EAMX,MAAM,YAAY,CAAC;AA0EpB;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,UAyJlC,CAAC"}