@crowley/rag-mcp 1.0.0

package/dist/tools/review.js

@@ -0,0 +1,213 @@
+/**
+ * Review & testing tools module - code review, test generation, and test analysis.
+ */
+/**
+ * Create the review & testing tools module with project-specific descriptions.
+ */
+export function createReviewTools(projectName) {
+    const tools = [
+        {
+            name: "review_code",
+            description: "Review code for issues, pattern violations, and improvements. Uses project patterns and ADRs for context.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "Code to review",
+                    },
+                    filePath: {
+                        type: "string",
+                        description: "File path for context",
+                    },
+                    reviewType: {
+                        type: "string",
+                        enum: ["security", "performance", "patterns", "style", "general"],
+                        description: "Type of review focus (default: general)",
+                    },
+                    diff: {
+                        type: "string",
+                        description: "Git diff to review instead of full code",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        {
+            name: "generate_tests",
+            description: "Generate unit/integration tests based on code and existing test patterns in the project.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "Code to generate tests for",
+                    },
+                    filePath: {
+                        type: "string",
+                        description: "File path for context",
+                    },
+                    framework: {
+                        type: "string",
+                        enum: ["jest", "vitest", "pytest", "mocha"],
+                        description: "Test framework to use (default: jest)",
+                    },
+                    testType: {
+                        type: "string",
+                        enum: ["unit", "integration", "e2e"],
+                        description: "Type of tests to generate (default: unit)",
+                    },
+                    coverage: {
+                        type: "string",
+                        enum: ["minimal", "standard", "comprehensive"],
+                        description: "Coverage level (default: comprehensive)",
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        {
+            name: "analyze_tests",
+            description: "Analyze existing tests for coverage and quality.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    testCode: {
+                        type: "string",
+                        description: "Test code to analyze",
+                    },
+                    sourceCode: {
+                        type: "string",
+                        description: "Optional source code being tested",
+                    },
+                },
+                required: ["testCode"],
+            },
+        },
+    ];
+    const handlers = {
+        review_code: async (args, ctx) => {
+            const { code, filePath, reviewType = "general", diff } = args;
+            const response = await ctx.api.post("/api/review", {
+                code: code || diff,
+                filePath,
+                reviewType,
+                diff,
+            });
+            const { review, context } = response.data;
+            let result = `# Code Review\n\n`;
+            if (review.score) {
+                result += `**Score**: ${review.score}/10\n\n`;
+            }
+            if (review.summary) {
+                result += `## Summary\n${review.summary}\n\n`;
+            }
+            if (review.issues && review.issues.length > 0) {
+                result += `## Issues Found\n`;
+                review.issues.forEach((issue, i) => {
+                    const icon = issue.severity === "critical"
+                        ? "\u{1F6A8}"
+                        : issue.severity === "high"
+                            ? "\u26A0\uFE0F"
+                            : issue.severity === "medium"
+                                ? "\u{1F4CB}"
+                                : "\u2139\uFE0F";
+                    result += `\n### ${icon} ${i + 1}. ${issue.type} (${issue.severity})\n`;
+                    result += `${issue.description}\n`;
+                    if (issue.line)
+                        result += `- Line: ${issue.line}\n`;
+                    if (issue.suggestion)
+                        result += `- Fix: ${issue.suggestion}\n`;
+                });
+                result += "\n";
+            }
+            if (review.positives && review.positives.length > 0) {
+                result += `## Positives\n`;
+                review.positives.forEach((p) => {
+                    result += `- ${p}\n`;
+                });
+                result += "\n";
+            }
+            if (review.suggestions && review.suggestions.length > 0) {
+                result += `## Suggestions\n`;
+                review.suggestions.forEach((s) => {
+                    result += `- ${s}\n`;
+                });
+            }
+            result += `\n---\n_Context: ${context.patternsUsed} patterns, ${context.adrsUsed} ADRs, ${context.similarFilesFound} similar files_`;
+            return result;
+        },
+        generate_tests: async (args, ctx) => {
+            const { code, filePath, framework = "jest", testType = "unit", coverage = "comprehensive", } = args;
+            const response = await ctx.api.post("/api/generate-tests", {
+                code,
+                filePath,
+                framework,
+                testType,
+                coverage,
+            });
+            const { tests, analysis, existingPatternsFound } = response.data;
+            let result = `# Generated Tests\n\n`;
+            result += `**Framework**: ${framework}\n`;
+            result += `**Type**: ${testType}\n`;
+            result += `**Coverage**: ${coverage}\n`;
+            result += `**Existing patterns found**: ${existingPatternsFound}\n\n`;
+            if (analysis) {
+                result += `## Code Analysis\n`;
+                result += `- Functions: ${analysis.functions?.join(", ") || "none"}\n`;
+                result += `- Classes: ${analysis.classes?.join(", ") || "none"}\n`;
+                result += `- Complexity: ${analysis.estimatedComplexity}\n\n`;
+            }
+            result += `## Generated Test Code\n\n`;
+            result +=
+                "```" + (framework === "pytest" ? "python" : "typescript") + "\n";
+            result += tests;
+            result += "\n```\n";
+            return result;
+        },
+        analyze_tests: async (args, ctx) => {
+            const { testCode, sourceCode } = args;
+            const response = await ctx.api.post("/api/analyze-tests", {
+                testCode,
+                sourceCode,
+            });
+            const { analysis } = response.data;
+            let result = `# Test Analysis\n\n`;
+            if (analysis.quality) {
+                result += `**Quality**: ${analysis.quality}`;
+                if (analysis.score)
+                    result += ` (${analysis.score}/10)`;
+                result += "\n\n";
+            }
+            if (analysis.coverage) {
+                result += `## Coverage Estimates\n`;
+                Object.entries(analysis.coverage).forEach(([key, value]) => {
+                    result += `- ${key}: ${value}\n`;
+                });
+                result += "\n";
+            }
+            if (analysis.strengths && analysis.strengths.length > 0) {
+                result += `## Strengths\n`;
+                analysis.strengths.forEach((s) => {
+                    result += `- ${s}\n`;
+                });
+                result += "\n";
+            }
+            if (analysis.weaknesses && analysis.weaknesses.length > 0) {
+                result += `## Weaknesses\n`;
+                analysis.weaknesses.forEach((w) => {
+                    result += `- ${w}\n`;
+                });
+                result += "\n";
+            }
+            if (analysis.missingTests && analysis.missingTests.length > 0) {
+                result += `## Missing Tests\n`;
+                analysis.missingTests.forEach((t) => {
+                    result += `- ${t}\n`;
+                });
+            }
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Search tools module - codebase search, similarity search, grouped/hybrid search,
+ * documentation search, and project statistics.
+ */
+import type { ToolModule } from "../types.js";
+/**
+ * Create the search tools module with project-specific descriptions.
+ */
+export declare function createSearchTools(projectName: string): ToolModule;

package/dist/tools/search.js

@@ -0,0 +1,377 @@
+/**
+ * Search tools module - codebase search, similarity search, grouped/hybrid search,
+ * documentation search, and project statistics.
+ */
+import { formatCodeResults, truncate, pct } from "../formatters.js";
+/**
+ * Create the search tools module with project-specific descriptions.
+ */
+export function createSearchTools(projectName) {
+    const tools = [
+        {
+            name: "search_codebase",
+            description: `Search the ${projectName} codebase for relevant code. Returns matching files with code snippets and relevance scores.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query for finding code",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results to return (default: 5)",
+                        default: 5,
+                    },
+                    language: {
+                        type: "string",
+                        description: "Filter by language (typescript, python, vue, etc.)",
+                    },
+                    path: {
+                        type: "string",
+                        description: "Filter by path pattern (e.g., 'src/modules/*')",
+                    },
+                    layer: {
+                        type: "string",
+                        description: "Filter by architectural layer (api, service, util, model, middleware, test, parser, types, config, other)",
+                    },
+                    service: {
+                        type: "string",
+                        description: "Filter by service/class name (e.g., 'EmbeddingService')",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "search_similar",
+            description: "Find code similar to a given snippet.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    code: {
+                        type: "string",
+                        description: "Code snippet to find similar code for",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 5)",
+                        default: 5,
+                    },
+                },
+                required: ["code"],
+            },
+        },
+        {
+            name: "grouped_search",
+            description: `Search ${projectName} codebase with results grouped by file. Returns one best match per file instead of multiple chunks.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query",
+                    },
+                    groupBy: {
+                        type: "string",
+                        description: "Field to group by (default: 'file')",
+                        default: "file",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max groups to return (default: 10)",
+                        default: 10,
+                    },
+                    language: {
+                        type: "string",
+                        description: "Filter by language",
+                    },
+                    layer: {
+                        type: "string",
+                        description: "Filter by architectural layer (api, service, util, etc.)",
+                    },
+                    service: {
+                        type: "string",
+                        description: "Filter by service/class name",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "hybrid_search",
+            description: `Hybrid search combining keyword matching and semantic similarity for ${projectName}. Better for finding exact terms + related concepts.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 10)",
+                        default: 10,
+                    },
+                    semanticWeight: {
+                        type: "number",
+                        description: "Weight for semantic vs keyword (0-1, default: 0.7)",
+                        default: 0.7,
+                    },
+                    language: {
+                        type: "string",
+                        description: "Filter by language",
+                    },
+                    layer: {
+                        type: "string",
+                        description: "Filter by architectural layer (api, service, util, etc.)",
+                    },
+                    service: {
+                        type: "string",
+                        description: "Filter by service/class name",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "search_docs",
+            description: `Search documentation in the ${projectName} project.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 5)",
+                        default: 5,
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "get_project_stats",
+            description: `Get statistics about the ${projectName} codebase.`,
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
+        {
+            name: "find_symbol",
+            description: `Find a function, class, type, or interface by name in ${projectName}. Fast symbol lookup without full-text search.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    symbol: {
+                        type: "string",
+                        description: "Symbol name to find (function, class, type, etc.)",
+                    },
+                    kind: {
+                        type: "string",
+                        description: "Filter by kind: function, class, interface, type, enum, const",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max results (default: 10)",
+                        default: 10,
+                    },
+                },
+                required: ["symbol"],
+            },
+        },
+        {
+            name: "search_graph",
+            description: `Search ${projectName} codebase with graph expansion. Finds semantically similar code plus connected files via import/call relationships.`,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Max direct results (default: 5)",
+                        default: 5,
+                    },
+                    expandHops: {
+                        type: "number",
+                        description: "Number of graph hops to expand (default: 1)",
+                        default: 1,
+                    },
+                },
+                required: ["query"],
+            },
+        },
+    ];
+    const handlers = {
+        search_codebase: async (args, ctx) => {
+            const { query, limit = 5, language, path, layer, service } = args;
+            const response = await ctx.api.post("/api/search", {
+                collection: `${ctx.collectionPrefix}codebase`,
+                query,
+                limit,
+                filters: { language, path, layer, service },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return "No results found for this query.";
+            }
+            return formatCodeResults(results, 500);
+        },
+        search_similar: async (args, ctx) => {
+            const { code, limit = 5 } = args;
+            const response = await ctx.api.post("/api/search-similar", {
+                collection: `${ctx.collectionPrefix}codebase`,
+                code,
+                limit,
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return "No similar code found.";
+            }
+            return formatCodeResults(results, 400);
+        },
+        grouped_search: async (args, ctx) => {
+            const { query, groupBy = "file", limit = 10, language, layer, service } = args;
+            const filters = { language, layer, service };
+            const hasFilters = Object.values(filters).some(v => v !== undefined);
+            const response = await ctx.api.post("/api/search-grouped", {
+                collection: `${ctx.collectionPrefix}codebase`,
+                query,
+                groupBy,
+                limit,
+                filters: hasFilters ? filters : undefined,
+            });
+            const groups = response.data.groups;
+            if (!groups || groups.length === 0) {
+                return "No results found.";
+            }
+            return groups
+                .map((g) => {
+                const r = g.results[0];
+                return (`**${g[groupBy]}** (score: ${pct(r.score)})\n` +
+                    "```" +
+                    (r.language || "") +
+                    "\n" +
+                    truncate(r.content, 300) +
+                    "\n```");
+            })
+                .join("\n\n---\n\n");
+        },
+        hybrid_search: async (args, ctx) => {
+            const { query, limit = 10, semanticWeight = 0.7, language, layer, service } = args;
+            const filters = { language, layer, service };
+            const hasFilters = Object.values(filters).some(v => v !== undefined);
+            const response = await ctx.api.post("/api/search-hybrid", {
+                collection: `${ctx.collectionPrefix}codebase`,
+                query,
+                limit,
+                semanticWeight,
+                filters: hasFilters ? filters : undefined,
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return "No results found.";
+            }
+            return results
+                .map((r) => `**${r.file}** (combined: ${pct(r.score)}${r.semanticScore != null ? `, semantic: ${pct(r.semanticScore)}` : ''}${r.keywordScore != null ? `, keyword: ${pct(r.keywordScore)}` : ''})\n` +
+                "```" +
+                (r.language || "") +
+                "\n" +
+                truncate(r.content, 300) +
+                "\n```")
+                .join("\n\n---\n\n");
+        },
+        search_docs: async (args, ctx) => {
+            const { query, limit = 5 } = args;
+            const response = await ctx.api.post("/api/search", {
+                collection: `${ctx.collectionPrefix}docs`,
+                query,
+                limit,
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return "No documentation found for this query.";
+            }
+            return results
+                .map((r) => `**${r.file}**\n` +
+                truncate(r.content, 500))
+                .join("\n\n---\n\n");
+        },
+        find_symbol: async (args, ctx) => {
+            const { symbol, kind, limit = 10 } = args;
+            const response = await ctx.api.post("/api/find-symbol", {
+                projectName: ctx.projectName,
+                symbol,
+                kind,
+                limit,
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return `No symbol "${symbol}" found.`;
+            }
+            return results
+                .map((r) => `**${r.kind} ${r.name}** in \`${r.file}\` (lines ${r.startLine}-${r.endLine})\n` +
+                `\`${truncate(r.signature, 150)}\`` +
+                (r.exports ? " _(exported)_" : ""))
+                .join("\n\n");
+        },
+        search_graph: async (args, ctx) => {
+            const { query, limit = 5, expandHops = 1 } = args;
+            const response = await ctx.api.post("/api/search-graph", {
+                collection: `${ctx.collectionPrefix}codebase`,
+                query,
+                limit,
+                expandHops,
+            });
+            const { results, graphExpanded, expandedFiles } = response.data;
+            let output = "";
+            if (results && results.length > 0) {
+                output += "**Direct matches:**\n\n";
+                output += results
+                    .map((r) => `**${r.file}** (score: ${pct(r.score)})\n` +
+                    "```" + (r.language || "") + "\n" +
+                    truncate(r.content, 300) + "\n```")
+                    .join("\n\n");
+            }
+            if (graphExpanded && graphExpanded.length > 0) {
+                output += "\n\n---\n\n**Graph-connected files:**\n\n";
+                output += graphExpanded
+                    .map((r) => `**${r.file}** (score: ${pct(r.score)})\n` +
+                    "```" + (r.language || "") + "\n" +
+                    truncate(r.content, 300) + "\n```")
+                    .join("\n\n");
+            }
+            if (!output) {
+                return "No results found.";
+            }
+            if (expandedFiles && expandedFiles.length > 0) {
+                output += `\n\n_Graph expanded to ${expandedFiles.length} additional files._`;
+            }
+            return output;
+        },
+        get_project_stats: async (_args, ctx) => {
+            const response = await ctx.api.get(`/api/stats/${ctx.collectionPrefix}codebase`);
+            const stats = response.data;
+            let result = `**${ctx.projectName} Project Statistics**\n\n`;
+            result += `- Total Files: ${stats.totalFiles}\n`;
+            result += `- Total Lines: ${stats.totalLines?.toLocaleString() || "N/A"}\n`;
+            result += `- Vector Count: ${stats.vectorCount}\n`;
+            result += `- Last Indexed: ${stats.lastIndexed ? new Date(stats.lastIndexed).toLocaleString() : "Never"}\n`;
+            if (stats.languages) {
+                result += `\n**Languages:**\n`;
+                for (const [lang, count] of Object.entries(stats.languages)) {
+                    result += `- ${lang}: ${count} files\n`;
+                }
+            }
+            return result;
+        },
+    };
+    return { tools, handlers };
+}

package/dist/tools/session.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Session tools module - context summarization, session lifecycle management,
+ * change tracking, and usage pattern analysis.
+ */
+import type { ToolModule, ToolContext } from "../types.js";
+/**
+ * Create the session tools module with project-specific descriptions.
+ * Accepts a mutable ctx reference to update activeSessionId on start/end.
+ */
+export declare function createSessionTools(projectName: string, sharedCtx?: ToolContext): ToolModule;