@crowley/rag-mcp 1.0.0

package/dist/tools/advanced.js

@@ -0,0 +1,315 @@
+/**
+ * Advanced tools module - memory merging, code completion context,
+ * import suggestions, type context, and behavior patterns.
+ */
+import { truncate, pct } from "../formatters.js";
+/**
+ * Create the advanced tools module with project-specific descriptions.
+ */
+export function createAdvancedTools(projectName) {
+    const tools = [
+        {
+            name: "merge_memories",
+            description: `Consolidate duplicate memories for ${projectName}. Finds similar memories and merges them using LLM to reduce clutter.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        description: "Filter by memory type (decision, insight, context, todo, conversation, note, or all). Default: all",
+                        default: "all",
+                    },
+                    threshold: {
+                        type: "number",
+                        description: "Similarity threshold for merging (0.5-1.0, default: 0.9). Lower = more aggressive merging.",
+                        default: 0.9,
+                    },
+                    dryRun: {
+                        type: "boolean",
+                        description: "If true, preview merge candidates without making changes (default: true).",
+                        default: true,
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max clusters to process (default: 50).",
+                        default: 50,
+                    },
+                },
+            },
+        },
+        {
+            name: "get_completion_context",
+            description: `Get code completion context for ${projectName}. Finds similar patterns, imports, and symbols from the codebase to aid code completion.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    currentFile: {
+                        type: "string",
+                        description: "Path of the file being edited",
+                    },
+                    currentCode: {
+                        type: "string",
+                        description: "Current code snippet or file content",
+                    },
+                    language: {
+                        type: "string",
+                        description: "Programming language filter (optional)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 5)",
+                        default: 5,
+                    },
+                },
+                required: ["currentFile", "currentCode"],
+            },
+        },
+        {
+            name: "get_import_suggestions",
+            description: `Suggest missing imports for ${projectName}. Analyzes similar files to find commonly used imports not present in your current file.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    currentFile: {
+                        type: "string",
+                        description: "Path of the file being edited",
+                    },
+                    currentCode: {
+                        type: "string",
+                        description: "Current code content",
+                    },
+                    language: {
+                        type: "string",
+                        description: "Programming language filter (optional)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max suggestions (default: 10)",
+                        default: 10,
+                    },
+                },
+                required: ["currentFile", "currentCode"],
+            },
+        },
+        {
+            name: "get_type_context",
+            description: `Look up type/interface/class definitions and usage in ${projectName}. Finds where a type is defined and how it's used across the codebase.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    typeName: {
+                        type: "string",
+                        description: "Name of the type/interface/class to look up",
+                    },
+                    code: {
+                        type: "string",
+                        description: "Code containing types to look up (alternative to typeName)",
+                    },
+                    currentFile: {
+                        type: "string",
+                        description: "Current file to exclude from results",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results per category (default: 5)",
+                        default: 5,
+                    },
+                },
+            },
+        },
+        {
+            name: "get_behavior_patterns",
+            description: `Analyze user workflow patterns for ${projectName}. Shows peak hours, tool preferences, common sequences, and session statistics.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    days: {
+                        type: "number",
+                        description: "Number of days to analyze (default: 7)",
+                        default: 7,
+                    },
+                    sessionId: {
+                        type: "string",
+                        description: "Filter to a specific session (optional)",
+                    },
+                },
+            },
+        },
+    ];
+    const handlers = {
+        merge_memories: async (args, ctx) => {
+            const { type = "all", threshold = 0.9, dryRun = true, limit = 50 } = args;
+            const response = await ctx.api.post("/api/memory/merge", {
+                type,
+                threshold,
+                dryRun,
+                limit,
+            });
+            const data = response.data;
+            let result = `## Memory Merge${dryRun ? " (Dry Run)" : ""}\n\n`;
+            result += `- **Memories Scanned:** ${data.totalFound ?? 0}\n`;
+            result += `- **Merge Clusters Found:** ${data.totalMerged ?? 0}\n`;
+            result += `- **Threshold:** ${threshold}\n`;
+            if (dryRun) {
+                result += `\n*This was a dry run. Set dryRun=false to apply merges.*\n`;
+            }
+            if (data.merged && data.merged.length > 0) {
+                result += `\n### Merge Candidates\n\n`;
+                for (const cluster of data.merged.slice(0, 10)) {
+                    const origCount = cluster.original?.length ?? 0;
+                    result += `**Cluster (${origCount} memories → 1):**\n`;
+                    if (cluster.original) {
+                        for (const orig of cluster.original.slice(0, 3)) {
+                            result += `  - ${truncate(orig.content || "", 80)}\n`;
+                        }
+                        if (origCount > 3) {
+                            result += `  - ... and ${origCount - 3} more\n`;
+                        }
+                    }
+                    result += `  **→ Merged:** ${truncate(cluster.merged?.content || "", 120)}\n\n`;
+                }
+                if (data.merged.length > 10) {
+                    result += `... and ${data.merged.length - 10} more clusters\n`;
+                }
+            }
+            return result;
+        },
+        get_completion_context: async (args, ctx) => {
+            const { currentFile, currentCode, language, limit = 5 } = args;
+            const response = await ctx.api.post("/api/code/completion-context", {
+                currentFile,
+                currentCode,
+                language,
+                limit,
+            });
+            const data = response.data;
+            let result = `## Completion Context\n\n`;
+            if (data.patterns && data.patterns.length > 0) {
+                result += `### Similar Patterns (${data.patterns.length})\n\n`;
+                for (const p of data.patterns) {
+                    result += `**${p.file}** (${pct(p.score)} match)\n`;
+                    result += "```\n" + truncate(p.content, 300) + "\n```\n\n";
+                }
+            }
+            else {
+                result += "No similar patterns found.\n\n";
+            }
+            if (data.imports && data.imports.length > 0) {
+                result += `### Imports from Similar Files\n`;
+                result += data.imports.map((i) => `- \`${i}\``).join("\n");
+                result += "\n\n";
+            }
+            if (data.symbols && data.symbols.length > 0) {
+                result += `### Available Symbols\n`;
+                result += data.symbols.map((s) => `- \`${s}\``).join("\n");
+                result += "\n";
+            }
+            return result;
+        },
+        get_import_suggestions: async (args, ctx) => {
+            const { currentFile, currentCode, language, limit = 10 } = args;
+            const response = await ctx.api.post("/api/code/import-suggestions", {
+                currentFile,
+                currentCode,
+                language,
+                limit,
+            });
+            const data = response.data;
+            let result = `## Import Suggestions\n\n`;
+            if (data.currentImports && data.currentImports.length > 0) {
+                result += `**Current Imports (${data.currentImports.length}):** ${data.currentImports.map((i) => `\`${i}\``).join(", ")}\n\n`;
+            }
+            if (data.suggestions && data.suggestions.length > 0) {
+                result += `### Suggested Imports\n\n`;
+                for (const s of data.suggestions) {
+                    result += `- **\`${s.importPath}\`** — used in ${s.frequency} similar files`;
+                    if (s.usedBy && s.usedBy.length > 0) {
+                        result += ` (${s.usedBy.map((f) => truncate(f, 40)).join(", ")})`;
+                    }
+                    result += "\n";
+                }
+            }
+            else {
+                result += "No additional imports suggested.\n";
+            }
+            return result;
+        },
+        get_type_context: async (args, ctx) => {
+            const { typeName, code, currentFile, limit = 5 } = args;
+            if (!typeName && !code) {
+                return "Error: Either typeName or code is required.";
+            }
+            const response = await ctx.api.post("/api/code/type-context", {
+                typeName,
+                code,
+                currentFile,
+                limit,
+            });
+            const data = response.data;
+            let result = `## Type Context${typeName ? `: ${typeName}` : ""}\n\n`;
+            if (data.definitions && data.definitions.length > 0) {
+                result += `### Definitions (${data.definitions.length})\n\n`;
+                for (const d of data.definitions) {
+                    result += `**${d.file}** (${pct(d.score)} match)\n`;
+                    result += "```\n" + truncate(d.content, 400) + "\n```\n\n";
+                }
+            }
+            else {
+                result += "No type definitions found.\n\n";
+            }
+            if (data.usages && data.usages.length > 0) {
+                result += `### Usage Examples (${data.usages.length})\n\n`;
+                for (const u of data.usages) {
+                    result += `**${u.file}** (${pct(u.score)} match)\n`;
+                    result += "```\n" + truncate(u.content, 300) + "\n```\n\n";
+                }
+            }
+            return result;
+        },
+        get_behavior_patterns: async (args, ctx) => {
+            const { days = 7, sessionId } = args;
+            const params = new URLSearchParams();
+            params.set("days", String(days));
+            if (sessionId)
+                params.set("sessionId", sessionId);
+            const response = await ctx.api.get(`/api/behavior-patterns?${params.toString()}`);
+            const data = response.data;
+            let result = `## Behavior Patterns (last ${days} days)\n\n`;
+            // Session stats
+            const ss = data.sessionStats;
+            if (ss) {
+                result += `### Session Statistics\n`;
+                result += `- **Total Sessions:** ${ss.totalSessions}\n`;
+                result += `- **Avg Tools/Session:** ${ss.avgToolsPerSession}\n`;
+                result += `- **Avg Duration:** ${ss.avgDurationMinutes} min\n\n`;
+            }
+            // Peak hours
+            if (data.peakHours && data.peakHours.length > 0) {
+                result += `### Peak Hours\n`;
+                const top5 = data.peakHours.slice(0, 5);
+                for (const h of top5) {
+                    result += `- **${String(h.hour).padStart(2, "0")}:00** — ${h.count} calls\n`;
+                }
+                result += "\n";
+            }
+            // Tool preferences
+            if (data.toolPreferences && data.toolPreferences.length > 0) {
+                result += `### Tool Preferences\n`;
+                for (const t of data.toolPreferences.slice(0, 10)) {
+                    result += `- **${t.tool}**: ${t.count} calls (avg ${t.avgDuration}ms)\n`;
+                }
+                result += "\n";
+            }
+            // Workflows
+            if (data.workflows && data.workflows.length > 0) {
+                result += `### Common Workflows\n`;
+                for (const w of data.workflows.slice(0, 10)) {
+                    result += `- ${w.sequence.join(" → ")} (${w.count}x)\n`;
+                }
+                result += "\n";
+            }
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/agents.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Agent tools module - run specialized agents and list agent types.
+ */
+import type { ToolModule } from "../types.js";
+/**
+ * Create the agent tools module with project-specific descriptions.
+ */
+export declare function createAgentTools(projectName: string): ToolModule;

package/dist/tools/agents.js

@@ -0,0 +1,97 @@
+/**
+ * Agent tools module - run specialized agents and list agent types.
+ */
+/**
+ * Create the agent tools module with project-specific descriptions.
+ */
+export function createAgentTools(projectName) {
+    const tools = [
+        {
+            name: "run_agent",
+            description: `Run a specialized agent for ${projectName}. Agents autonomously research, review, or analyze using multiple tool calls. Returns result + reasoning trace.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    type: {
+                        type: "string",
+                        description: "Agent type: research, review, documentation, refactor, or test",
+                        enum: ["research", "review", "documentation", "refactor", "test"],
+                    },
+                    task: {
+                        type: "string",
+                        description: "The task for the agent to perform",
+                    },
+                    context: {
+                        type: "string",
+                        description: "Optional additional context (code, requirements, etc.)",
+                    },
+                    maxIterations: {
+                        type: "number",
+                        description: "Maximum ReAct iterations (default: varies by agent type)",
+                    },
+                },
+                required: ["type", "task"],
+            },
+        },
+        {
+            name: "get_agent_types",
+            description: `List available agent types for ${projectName} with descriptions.`,
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+    ];
+    const handlers = {
+        run_agent: async (args, ctx) => {
+            const { type, task, context, maxIterations } = args;
+            const response = await ctx.api.post("/api/agent/run", {
+                projectName: ctx.projectName,
+                agentType: type,
+                task,
+                context,
+                maxIterations,
+            });
+            const data = response.data;
+            // Format result with reasoning trace
+            let result = `## Agent Result (${data.type})\n`;
+            result += `**Task:** ${data.task}\n`;
+            result += `**Status:** ${data.status}`;
+            result += ` | **Iterations:** ${data.usage?.iterations || 0}`;
+            result += ` | **Tool Calls:** ${data.usage?.toolCalls || 0}`;
+            result += ` | **Duration:** ${data.usage?.durationMs ? Math.round(data.usage.durationMs / 1000) + "s" : "N/A"}`;
+            result += "\n\n";
+            if (data.error) {
+                result += `**Error:** ${data.error}\n\n`;
+            }
+            if (data.result) {
+                result += `### Result\n${data.result}\n\n`;
+            }
+            // Reasoning trace
+            if (data.steps && data.steps.length > 0) {
+                result += `### Reasoning Trace\n`;
+                for (const step of data.steps) {
+                    result += `**Step ${step.iteration}:** ${step.thought?.slice(0, 200) || "..."}\n`;
+                    if (step.action) {
+                        result += `  Action: ${step.action.tool}(${JSON.stringify(step.action.input).slice(0, 100)})\n`;
+                    }
+                    if (step.observation) {
+                        const obsPreview = step.observation.result?.slice(0, 150) || "...";
+                        result += `  Result: ${obsPreview}${step.observation.truncated ? " [truncated]" : ""}\n`;
+                    }
+                }
+            }
+            return result;
+        },
+        get_agent_types: async (_args, ctx) => {
+            const response = await ctx.api.get("/api/agent/types");
+            const data = response.data;
+            let result = `## Available Agent Types\n\n`;
+            for (const agent of data.agents || []) {
+                result += `- **${agent.name}**: ${agent.description}\n`;
+            }
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/analytics.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Analytics tools module - tool analytics, knowledge gaps, collection analytics,
+ * backups, and quantization.
+ */
+import type { ToolModule } from "../types.js";
+/**
+ * Create the analytics tools module with project-specific descriptions.
+ */
+export declare function createAnalyticsTools(projectName: string): ToolModule;