@crowley/rag-mcp 1.0.5 → 1.1.0

package/dist/tools/quality.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Quality tools module - LLM quality monitoring and reporting.
+ */
+import type { ToolSpec } from "../types.js";
+/**
+ * Create the quality tools module.
+ */
+export declare function createQualityTools(projectName: string): ToolSpec[];

package/dist/tools/quality.js

@@ -0,0 +1,60 @@
+/**
+ * Quality tools module - LLM quality monitoring and reporting.
+ */
+import { z } from "zod";
+import { TOOL_ANNOTATIONS } from "../annotations.js";
+/**
+ * Create the quality tools module.
+ */
+export function createQualityTools(projectName) {
+    return [
+        {
+            name: "get_quality_report",
+            description: `Get LLM quality metrics for ${projectName}. Shows JSON parse rates, latency percentiles, thinking trace rates, and alerts.`,
+            schema: z.object({
+                endpoint: z.string().optional().describe("Filter by specific endpoint (e.g., '/api/ask')"),
+            }),
+            annotations: TOOL_ANNOTATIONS["get_quality_report"] || {
+                title: "Get Quality Report",
+                readOnlyHint: true,
+                openWorldHint: false,
+            },
+            handler: async (args, ctx) => {
+                const params = args.endpoint ? `?endpoint=${encodeURIComponent(args.endpoint)}` : '';
+                const response = await ctx.api.get(`/api/quality/report${params}`);
+                const data = response.data;
+                let result = `## Quality Report\n\n`;
+                result += `**Total Metrics:** ${data.total}\n\n`;
+                if (data.total === 0) {
+                    result += `No quality metrics recorded yet.\n`;
+                    return result;
+                }
+                const m = data.metrics;
+                result += `### Aggregate Metrics\n`;
+                result += `- **Avg Latency:** ${m.avgLatencyMs}ms\n`;
+                result += `- **P95 Latency:** ${m.p95LatencyMs}ms\n`;
+                result += `- **JSON Parse Rate:** ${(m.jsonParseRate * 100).toFixed(1)}%\n`;
+                result += `- **Thinking Rate:** ${(m.thinkingRate * 100).toFixed(1)}%\n`;
+                result += `- **Avg Output Length:** ${m.avgOutputLength} chars\n`;
+                result += `- **Avg Thinking Length:** ${m.avgThinkingLength} chars\n`;
+                result += `- **Avg Tokens:** ${m.avgTokens}\n\n`;
+                if (data.alerts.length > 0) {
+                    result += `### ⚠ Alerts\n`;
+                    for (const alert of data.alerts) {
+                        result += `- ${alert}\n`;
+                    }
+                    result += `\n`;
+                }
+                if (Object.keys(data.byEndpoint).length > 0) {
+                    result += `### By Endpoint\n`;
+                    for (const [ep, stats] of Object.entries(data.byEndpoint)) {
+                        result += `- **${ep}**: ${stats.count} calls, ${stats.avgLatencyMs}ms avg, `;
+                        result += `JSON: ${(stats.jsonParseRate * 100).toFixed(0)}%, `;
+                        result += `Thinking: ${(stats.thinkingRate * 100).toFixed(0)}%\n`;
+                    }
+                }
+                return result;
+            },
+        },
+    ];
+}

package/dist/tools/review.d.ts

@@ -1,8 +1,8 @@
 /**
  * Review & testing tools module - code review, test generation, and test analysis.
  */
-import type { ToolModule } from "../types.js";
+import type { ToolSpec } from "../types.js";
 /**
  * Create the review & testing tools module with project-specific descriptions.
  */
-export declare function createReviewTools(projectName: string): ToolModule;
+export declare function createReviewTools(projectName: string): ToolSpec[];

package/dist/tools/review.js

@@ -1,213 +1,166 @@
 /**
  * Review & testing tools module - code review, test generation, and test analysis.
  */
+import { z } from "zod";
+import { TOOL_ANNOTATIONS } from "../annotations.js";
 /**
  * Create the review & testing tools module with project-specific descriptions.
  */
 export function createReviewTools(projectName) {
-    const tools = [
+    return [
         {
             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"],
+            schema: z.object({
+                code: z.string().describe("Code to review"),
+                filePath: z.string().optional().describe("File path for context"),
+                reviewType: z.enum(["security", "performance", "patterns", "style", "general"]).optional().describe("Type of review focus (default: general)"),
+                diff: z.string().optional().describe("Git diff to review instead of full code"),
+            }),
+            annotations: TOOL_ANNOTATIONS["review_code"],
+            handler: 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;
             },
         },
         {
             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"],
+            schema: z.object({
+                code: z.string().describe("Code to generate tests for"),
+                filePath: z.string().optional().describe("File path for context"),
+                framework: z.enum(["jest", "vitest", "pytest", "mocha"]).optional().describe("Test framework to use (default: jest)"),
+                testType: z.enum(["unit", "integration", "e2e"]).optional().describe("Type of tests to generate (default: unit)"),
+                coverage: z.enum(["minimal", "standard", "comprehensive"]).optional().describe("Coverage level (default: comprehensive)"),
+            }),
+            annotations: TOOL_ANNOTATIONS["generate_tests"],
+            handler: 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;
             },
         },
         {
             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"],
+            schema: z.object({
+                testCode: z.string().describe("Test code to analyze"),
+                sourceCode: z.string().optional().describe("Optional source code being tested"),
+            }),
+            annotations: TOOL_ANNOTATIONS["analyze_tests"],
+            handler: 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;
             },
         },
     ];
-    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

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