distill-mcp 0.6.0-beta

package/dist/tools/conversation-memory.js

@@ -0,0 +1,289 @@
+/**
+ * Conversation Memory Tool
+ *
+ * Manages long conversation context with decision extraction
+ * and context restoration capabilities.
+ */
+import { z } from "zod";
+import { compressConversationWithMemory, extractDecisions, extractCodeReferences, restoreContext, } from "../compressors/conversation.js";
+import { getSessionTracker } from "../analytics/session-tracker.js";
+import { getOutputConfig } from "../config/output-config.js";
+import { serializeResultToToon, } from "../utils/toon-serializer.js";
+// Global memory storage for session persistence
+let sessionMemory = null;
+export const conversationMemorySchema = {
+    type: "object",
+    properties: {
+        action: {
+            type: "string",
+            enum: ["compress", "restore", "get_memory", "clear", "extract_decisions"],
+            description: "Action to perform",
+        },
+        messages: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    role: { type: "string", enum: ["user", "assistant", "system"] },
+                    content: { type: "string" },
+                },
+                required: ["role", "content"],
+            },
+            description: "Conversation messages (for compress action)",
+        },
+        strategy: {
+            type: "string",
+            enum: ["rolling-summary", "key-extraction", "hybrid"],
+            description: "Compression strategy (default: hybrid)",
+        },
+        maxTokens: {
+            type: "number",
+            description: "Maximum tokens for output (default: 10000)",
+        },
+        preserveLastN: {
+            type: "number",
+            description: "Number of recent messages to preserve (default: 2)",
+        },
+        includeSummary: {
+            type: "boolean",
+            description: "Include summary in restored context (default: true)",
+        },
+        includeDecisions: {
+            type: "boolean",
+            description: "Include decisions in restored context (default: true)",
+        },
+        includeCodeRefs: {
+            type: "boolean",
+            description: "Include code references in restored context (default: true)",
+        },
+        recentMessages: {
+            type: "number",
+            description: "Number of recent messages to include in restoration (default: 3)",
+        },
+    },
+    required: ["action"],
+};
+const messageSchema = z.object({
+    role: z.enum(["user", "assistant", "system"]),
+    content: z.string(),
+});
+const inputSchema = z.object({
+    action: z.enum(["compress", "restore", "get_memory", "clear", "extract_decisions"]),
+    messages: z.array(messageSchema).optional(),
+    strategy: z
+        .enum(["rolling-summary", "key-extraction", "hybrid"])
+        .optional()
+        .default("hybrid"),
+    maxTokens: z.number().optional().default(10000),
+    preserveLastN: z.number().optional().default(2),
+    includeSummary: z.boolean().optional().default(true),
+    includeDecisions: z.boolean().optional().default(true),
+    includeCodeRefs: z.boolean().optional().default(true),
+    recentMessages: z.number().optional().default(3),
+});
+/**
+ * Format memory summary for display
+ */
+function formatMemorySummary(memory) {
+    const parts = [];
+    parts.push("[Memory Summary]");
+    parts.push(`Summary: ${memory.summary}`);
+    parts.push(`Decisions: ${memory.decisions.length}`);
+    parts.push(`Code References: ${memory.codeReferences.length}`);
+    parts.push(`Messages: ${memory.compressedHistory.length}`);
+    parts.push(`Last Updated: ${new Date(memory.lastUpdated).toISOString()}`);
+    if (memory.decisions.length > 0) {
+        parts.push("");
+        parts.push("[Recent Decisions]");
+        for (const d of memory.decisions.slice(-5)) {
+            parts.push(`- ${d.decision}`);
+        }
+    }
+    if (memory.codeReferences.length > 0) {
+        parts.push("");
+        parts.push("[Code References]");
+        const created = memory.codeReferences.filter((r) => r.action === "created");
+        const modified = memory.codeReferences.filter((r) => r.action === "modified");
+        if (created.length > 0) {
+            parts.push(`Created: ${created.map((r) => r.file).slice(0, 5).join(", ")}`);
+        }
+        if (modified.length > 0) {
+            parts.push(`Modified: ${modified.map((r) => r.file).slice(0, 5).join(", ")}`);
+        }
+    }
+    return parts.join("\n");
+}
+/**
+ * Format output based on config
+ */
+function formatOutput(result, name) {
+    const config = getOutputConfig();
+    if (config.mode === "toon" || config.useToon) {
+        const schema = { name };
+        return serializeResultToToon(result, schema, {
+            verbosity: config.verbosity,
+            includeStats: config.includeStats,
+        });
+    }
+    if (typeof result === "string") {
+        return result;
+    }
+    return JSON.stringify(result, null, 2);
+}
+/**
+ * Execute conversation memory tool
+ */
+async function executeConversationMemory(args) {
+    const input = inputSchema.parse(args);
+    switch (input.action) {
+        case "compress": {
+            if (!input.messages || input.messages.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: messages array required for compress action",
+                        },
+                    ],
+                };
+            }
+            const messages = input.messages;
+            const result = compressConversationWithMemory(messages, {
+                strategy: input.strategy,
+                maxTokens: input.maxTokens,
+                preserveSystem: true,
+                preserveLastN: input.preserveLastN,
+            });
+            // Store in session memory
+            sessionMemory = result.memory;
+            // Track usage
+            const tokensSaved = result.stats.originalTokens - result.stats.compressedTokens;
+            getSessionTracker().recordInvocation("conversation_memory", result.stats.originalTokens, result.stats.compressedTokens, tokensSaved, 0);
+            const output = [
+                `[Compressed] ${result.stats.originalTokens}→${result.stats.compressedTokens} tokens (-${Math.round((1 - result.stats.compressedTokens / result.stats.originalTokens) * 100)}%)`,
+                `Decisions: ${result.stats.decisionsExtracted}, Code Refs: ${result.stats.codeRefsFound}`,
+                "",
+                result.context,
+            ].join("\n");
+            return {
+                content: [{ type: "text", text: output }],
+            };
+        }
+        case "restore": {
+            if (!sessionMemory) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No memory stored. Use compress action first.",
+                        },
+                    ],
+                };
+            }
+            const context = restoreContext(sessionMemory, {
+                includeSummary: input.includeSummary,
+                includeDecisions: input.includeDecisions,
+                includeCodeRefs: input.includeCodeRefs,
+                recentMessages: input.recentMessages,
+            });
+            return {
+                content: [{ type: "text", text: context }],
+            };
+        }
+        case "get_memory": {
+            if (!sessionMemory) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No memory stored. Use compress action first.",
+                        },
+                    ],
+                };
+            }
+            const output = formatMemorySummary(sessionMemory);
+            return {
+                content: [{ type: "text", text: output }],
+            };
+        }
+        case "clear": {
+            sessionMemory = null;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Memory cleared.",
+                    },
+                ],
+            };
+        }
+        case "extract_decisions": {
+            if (!input.messages || input.messages.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "Error: messages array required for extract_decisions action",
+                        },
+                    ],
+                };
+            }
+            const messages = input.messages;
+            const decisions = extractDecisions(messages);
+            const codeRefs = extractCodeReferences(messages);
+            const parts = [];
+            parts.push(`[Extracted] ${decisions.length} decisions, ${codeRefs.length} code references`);
+            parts.push("");
+            if (decisions.length > 0) {
+                parts.push("[Decisions]");
+                for (const d of decisions) {
+                    parts.push(`- ${d.decision}`);
+                }
+                parts.push("");
+            }
+            if (codeRefs.length > 0) {
+                parts.push("[Code References]");
+                const byAction = new Map();
+                for (const ref of codeRefs) {
+                    if (!byAction.has(ref.action)) {
+                        byAction.set(ref.action, []);
+                    }
+                    byAction.get(ref.action).push(ref.file);
+                }
+                for (const [action, files] of byAction) {
+                    parts.push(`${action}: ${files.join(", ")}`);
+                }
+            }
+            return {
+                content: [{ type: "text", text: parts.join("\n") }],
+            };
+        }
+        default:
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Unknown action: ${input.action}`,
+                    },
+                ],
+            };
+    }
+}
+export const conversationMemoryTool = {
+    name: "conversation_memory",
+    description: "Manage long conversation context. Actions: compress (with decision extraction), restore, get_memory, clear, extract_decisions.",
+    inputSchema: conversationMemorySchema,
+    execute: executeConversationMemory,
+};
+/**
+ * Get current session memory (for SDK use)
+ */
+export function getSessionMemory() {
+    return sessionMemory;
+}
+/**
+ * Set session memory (for SDK use)
+ */
+export function setSessionMemory(memory) {
+    sessionMemory = memory;
+}

package/dist/tools/deduplicate-errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deduplicate Errors Tool
+ *
+ * Detects and deduplicates repetitive errors in build/test outputs,
+ * keeping only unique occurrences with counters.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const deduplicateErrorsSchema: {
+    type: "object";
+    properties: {
+        content: {
+            type: string;
+        };
+        threshold: {
+            type: string;
+        };
+        keepFirst: {
+            type: string;
+        };
+    };
+    required: string[];
+};
+export declare function executeDeduplicateErrors(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const deduplicateErrorsTool: ToolDefinition;
+//# sourceMappingURL=deduplicate-errors.d.ts.map

package/dist/tools/deduplicate-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduplicate-errors.d.ts","sourceRoot":"","sources":["../../src/tools/deduplicate-errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AASpD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;CAQnC,CAAC;AASF,wBAAsB,wBAAwB,CAC5C,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,CAgD7D;AAED,eAAO,MAAM,qBAAqB,EAAE,cAMnC,CAAC"}

package/dist/tools/deduplicate-errors.js

@@ -0,0 +1,72 @@
+/**
+ * Deduplicate Errors Tool
+ *
+ * Detects and deduplicates repetitive errors in build/test outputs,
+ * keeping only unique occurrences with counters.
+ */
+import { z } from "zod";
+import { groupBySignature, formatGroups, calculateStats, } from "../utils/signature-grouper.js";
+// Minimal schema - errorPattern rarely used
+export const deduplicateErrorsSchema = {
+    type: "object",
+    properties: {
+        content: { type: "string" },
+        threshold: { type: "number" },
+        keepFirst: { type: "number" },
+    },
+    required: ["content"],
+};
+const inputSchema = z.object({
+    content: z.string(),
+    threshold: z.number().min(1).optional().default(2),
+    keepFirst: z.number().min(0).optional().default(1),
+    errorPattern: z.string().optional(),
+});
+export async function executeDeduplicateErrors(args) {
+    const { content, threshold, keepFirst, errorPattern } = inputSchema.parse(args);
+    // Parse custom pattern if provided
+    let customPattern;
+    if (errorPattern) {
+        try {
+            customPattern = new RegExp(errorPattern, "gm");
+        }
+        catch {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Invalid regex pattern: ${errorPattern}`,
+                    },
+                ],
+            };
+        }
+    }
+    // Split content into lines
+    const lines = content.split("\n");
+    // Group by signature
+    const options = {
+        threshold,
+        keepFirst,
+        customPattern,
+    };
+    const result = groupBySignature(lines, options);
+    const stats = calculateStats(result);
+    if (result.groups.size === 0) {
+        return {
+            content: [{ type: "text", text: "No errors detected." }],
+        };
+    }
+    // Formatted groups
+    const formattedGroups = formatGroups(result, "markdown", options);
+    // Minimal header
+    const header = `[dedup] ${stats.uniqueErrors} patterns, ${stats.totalDuplicates} duplicates removed (-${stats.reductionPercent}%)`;
+    return {
+        content: [{ type: "text", text: `${header}\n${formattedGroups}` }],
+    };
+}
+export const deduplicateErrorsTool = {
+    name: "deduplicate_errors",
+    description: "Group repeated errors. Shows unique patterns with count and affected files.",
+    inputSchema: deduplicateErrorsSchema,
+    execute: executeDeduplicateErrors,
+};

package/dist/tools/detect-retry-loop.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Detect Retry Loop Tool
+ *
+ * Analyzes command history to detect retry loops - patterns where
+ * the same command is being executed repeatedly, often indicating
+ * an unresolved build/test failure.
+ */
+import type { ToolDefinition } from "./registry.js";
+export declare const detectRetryLoopSchema: {
+    type: "object";
+    properties: {
+        commands: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        errors: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        threshold: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+};
+export declare function executeDetectRetryLoop(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+export declare const detectRetryLoopTool: ToolDefinition;
+//# sourceMappingURL=detect-retry-loop.d.ts.map

package/dist/tools/detect-retry-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-retry-loop.d.ts","sourceRoot":"","sources":["../../src/tools/detect-retry-loop.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAQpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;CAmBjC,CAAC;AA0KF,wBAAsB,sBAAsB,CAC1C,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,CA2C7D;AAED,eAAO,MAAM,mBAAmB,EAAE,cAMjC,CAAC"}

package/dist/tools/detect-retry-loop.js

@@ -0,0 +1,212 @@
+/**
+ * Detect Retry Loop Tool
+ *
+ * Analyzes command history to detect retry loops - patterns where
+ * the same command is being executed repeatedly, often indicating
+ * an unresolved build/test failure.
+ */
+import { z } from "zod";
+import { normalizeCommand, getBaseCommand, areCommandsSimilar, } from "../utils/command-normalizer.js";
+export const detectRetryLoopSchema = {
+    type: "object",
+    properties: {
+        commands: {
+            type: "array",
+            items: { type: "string" },
+            description: "Recent command history (most recent last)",
+        },
+        errors: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional: error outputs associated with commands",
+        },
+        threshold: {
+            type: "number",
+            description: "Minimum repetitions to consider a loop (default: 3)",
+        },
+    },
+    required: ["commands"],
+};
+const inputSchema = z.object({
+    commands: z.array(z.string()).min(1),
+    errors: z.array(z.string()).optional(),
+    threshold: z.number().min(2).optional().default(3),
+});
+/**
+ * Analyze commands to find retry patterns
+ */
+function analyzeRetryPatterns(commands, threshold) {
+    const groups = new Map();
+    for (const cmd of commands) {
+        const normalized = normalizeCommand(cmd);
+        const existing = groups.get(normalized) || [];
+        existing.push(cmd);
+        groups.set(normalized, existing);
+    }
+    let maxRepetitions = 0;
+    let mostRepeated = null;
+    for (const [normalized, cmds] of groups.entries()) {
+        if (cmds.length > maxRepetitions) {
+            maxRepetitions = cmds.length;
+            mostRepeated = normalized;
+        }
+    }
+    return { groups, maxRepetitions, mostRepeated };
+}
+/**
+ * Count consecutive runs of similar commands at the end of history
+ */
+function countConsecutiveRuns(commands) {
+    if (commands.length === 0)
+        return 0;
+    const lastCmd = commands[commands.length - 1];
+    let count = 1;
+    for (let i = commands.length - 2; i >= 0; i--) {
+        if (areCommandsSimilar(commands[i], lastCmd)) {
+            count++;
+        }
+        else {
+            break;
+        }
+    }
+    return count;
+}
+/**
+ * Detect the type of command (build, test, lint, etc.)
+ */
+function detectCommandType(cmd) {
+    const lower = cmd.toLowerCase();
+    if (/\btest\b|vitest|jest|mocha|ava/.test(lower))
+        return "test";
+    if (/\bbuild\b|compile|tsc\b/.test(lower))
+        return "build";
+    if (/\blint\b|eslint|prettier/.test(lower))
+        return "lint";
+    if (/\bcheck\b|type-check/.test(lower))
+        return "typecheck";
+    if (/\bformat\b/.test(lower))
+        return "format";
+    if (/cargo\s+(build|test|check)/.test(lower))
+        return lower.includes("test") ? "test" : "build";
+    if (/go\s+(build|test)/.test(lower))
+        return lower.includes("test") ? "test" : "build";
+    return "command";
+}
+/**
+ * Generate suggestions based on the loop type and errors
+ */
+function generateSuggestions(loopType, baseCommand, errors) {
+    const suggestions = [];
+    // Common suggestions based on loop type
+    switch (loopType) {
+        case "build":
+            suggestions.push("Check the specific error message for the root cause");
+            suggestions.push("Try `git stash` to test with a clean working state");
+            suggestions.push("Look for circular dependencies or missing imports");
+            break;
+        case "test":
+            suggestions.push("Run a single failing test to isolate the issue");
+            suggestions.push("Check if tests depend on external state or services");
+            suggestions.push("Review test fixtures and mock data");
+            break;
+        case "lint":
+            suggestions.push("Run with --fix flag to auto-correct issues");
+            suggestions.push("Check if rules are conflicting with each other");
+            suggestions.push("Consider disabling the problematic rule temporarily");
+            break;
+        case "typecheck":
+            suggestions.push("Check for missing type definitions (@types/*)");
+            suggestions.push("Look for incorrect generic type usage");
+            suggestions.push("Review recent changes to shared type files");
+            break;
+    }
+    // Error-based suggestions
+    if (errors && errors.length > 0) {
+        const errorText = errors.join("\n").toLowerCase();
+        if (errorText.includes("cannot find module") || errorText.includes("module not found")) {
+            suggestions.unshift("Run `npm install` or `bun install` to install missing dependencies");
+        }
+        if (errorText.includes("enoent") || errorText.includes("no such file")) {
+            suggestions.unshift("Check if referenced files exist and paths are correct");
+        }
+        if (errorText.includes("permission denied") || errorText.includes("eacces")) {
+            suggestions.unshift("Check file permissions or run with appropriate privileges");
+        }
+        if (errorText.includes("out of memory") || errorText.includes("heap")) {
+            suggestions.unshift("Increase Node.js memory limit with --max-old-space-size");
+        }
+        if (errorText.includes("timeout") || errorText.includes("timed out")) {
+            suggestions.unshift("Check for infinite loops or long-running operations");
+        }
+    }
+    // General suggestion
+    suggestions.push("Consider using `deduplicate_errors` to group similar errors");
+    return [...new Set(suggestions)].slice(0, 5);
+}
+/**
+ * Format the analysis result
+ */
+function formatResult(result) {
+    const parts = [];
+    if (result.isLoop) {
+        parts.push("## Retry Loop Detected\n");
+        parts.push(`**Command**: \`${result.baseCommand}\``);
+        parts.push(`**Type**: ${result.loopType}`);
+        parts.push(`**Total runs**: ${result.repetitions}`);
+        parts.push(`**Consecutive runs**: ${result.consecutiveRuns}`);
+        parts.push("");
+        parts.push("### Suggestions\n");
+        result.suggestions.forEach((s, i) => {
+            parts.push(`${i + 1}. ${s}`);
+        });
+    }
+    else {
+        parts.push("## No Retry Loop Detected\n");
+        parts.push(result.analysis);
+    }
+    return parts.join("\n");
+}
+export async function executeDetectRetryLoop(args) {
+    const { commands, errors, threshold } = inputSchema.parse(args);
+    // Analyze patterns
+    const { maxRepetitions, mostRepeated } = analyzeRetryPatterns(commands, threshold);
+    const consecutiveRuns = countConsecutiveRuns(commands);
+    // Determine if this is a retry loop
+    const isLoop = maxRepetitions >= threshold || consecutiveRuns >= threshold;
+    let result;
+    if (isLoop && mostRepeated) {
+        const loopType = detectCommandType(mostRepeated);
+        const baseCommand = getBaseCommand(mostRepeated);
+        const suggestions = generateSuggestions(loopType, baseCommand, errors);
+        result = {
+            isLoop: true,
+            loopType,
+            baseCommand: mostRepeated,
+            repetitions: maxRepetitions,
+            consecutiveRuns,
+            suggestions,
+            analysis: `Detected ${maxRepetitions} runs of similar ${loopType} command`,
+        };
+    }
+    else {
+        result = {
+            isLoop: false,
+            loopType: null,
+            baseCommand: null,
+            repetitions: maxRepetitions,
+            consecutiveRuns,
+            suggestions: [],
+            analysis: `No retry loop detected. Max command repetitions: ${maxRepetitions}, Consecutive: ${consecutiveRuns}`,
+        };
+    }
+    const output = formatResult(result);
+    return {
+        content: [{ type: "text", text: output }],
+    };
+}
+export const detectRetryLoopTool = {
+    name: "detect_retry_loop",
+    description: "Detect retry loops in command history. Identifies when build/test commands are being repeatedly executed without success, and suggests alternative approaches.",
+    inputSchema: detectRetryLoopSchema,
+    execute: executeDetectRetryLoop,
+};

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

@@ -0,0 +1,40 @@
+/**
+ * Diff Compress Tool
+ *
+ * Compress git diff output to reduce tokens while preserving essential changes.
+ * Supports three strategies: hunks-only, summary, and semantic.
+ */
+import type { ToolDefinition } from "./registry.js";
+/**
+ * JSON Schema for MCP tool registration
+ */
+export declare const diffCompressSchema: {
+    type: "object";
+    properties: {
+        diff: {
+            type: string;
+        };
+        strategy: {
+            enum: string[];
+        };
+        maxTokens: {
+            type: string;
+        };
+    };
+    required: string[];
+};
+/**
+ * Execute diff compression
+ */
+export declare function executeDiffCompress(args: unknown): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+/**
+ * Tool definition for MCP registration
+ */
+export declare const diffCompressTool: ToolDefinition;
+//# sourceMappingURL=diff-compress.d.ts.map