@homenshum/convex-mcp-nodebench 0.4.1 → 0.7.0

package/dist/tools/deploymentTools.js

@@ -20,7 +20,12 @@ function runPreDeployChecks(projectDir) {
     if (!convexDir) {
         checks.push({ name: "convex_dir_exists", passed: false, message: "No convex/ directory found" });
         blockers.push("No convex/ directory found");
-        return { passed: false, checks, blockers };
+        return {
+            passed: false,
+            checks,
+            blockers: blockers.map((b, i) => ({ priority: i + 1, blocker: b, fixFirst: i === 0 })),
+            fixOrder: "Fix #1: Create a convex/ directory. Then re-run convex_pre_deploy_gate.",
+        };
     }
     checks.push({ name: "convex_dir_exists", passed: true, message: `Found at ${convexDir}` });
     // Check 2: schema.ts exists
@@ -101,10 +106,19 @@ function runPreDeployChecks(projectDir) {
         checks.push({ name: "generated_dir_exists", passed: false, message: "_generated/ not found - run 'npx convex dev' first" });
         blockers.push("Run 'npx convex dev' to initialize the project before deploying");
     }
+    // Add priority ordering to blockers
+    const prioritizedBlockers = blockers.map((b, i) => ({
+        priority: i + 1,
+        blocker: b,
+        fixFirst: i === 0,
+    }));
     return {
         passed: blockers.length === 0,
         checks,
-        blockers,
+        blockers: prioritizedBlockers,
+        fixOrder: blockers.length > 0
+            ? `Fix ${blockers.length} blocker(s) in order: ${blockers.map((_, i) => `#${i + 1}`).join(" → ")}. Then re-run convex_pre_deploy_gate.`
+            : "All checks passed. Safe to deploy.",
     };
 }
 function checkEnvVars(projectDir) {
@@ -222,8 +236,34 @@ export const deploymentTools = [
         handler: async (args) => {
             const projectDir = resolve(args.projectDir);
             const result = checkEnvVars(projectDir);
+            // Group missing vars by service for actionable output
+            const serviceGroups = {};
+            for (const v of result.missingInEnvFile) {
+                const vUp = v.toUpperCase();
+                const svc = vUp.includes("OPENAI") ? "OpenAI" :
+                    vUp.includes("GEMINI") || vUp.includes("GOOGLE") ? "Google" :
+                        vUp.includes("OPENBB") ? "OpenBB" :
+                            vUp.includes("TWILIO") ? "Twilio" :
+                                vUp.includes("LINKEDIN") ? "LinkedIn" :
+                                    vUp.includes("GITHUB") ? "GitHub" :
+                                        vUp.includes("STRIPE") ? "Stripe" :
+                                            vUp.includes("OPENROUTER") ? "OpenRouter" :
+                                                vUp.includes("RESEARCH") ? "Research MCP" :
+                                                    vUp.includes("MCP") ? "MCP" :
+                                                        vUp.includes("NTFY") ? "Ntfy" :
+                                                            vUp.includes("XAI") ? "xAI" :
+                                                                vUp.includes("CLERK") ? "Clerk" :
+                                                                    vUp.includes("CONVEX") ? "Convex" :
+                                                                        "Other";
+                if (!serviceGroups[svc])
+                    serviceGroups[svc] = [];
+                serviceGroups[svc].push(v);
+            }
             return {
                 ...result,
+                missingByService: Object.entries(serviceGroups)
+                    .sort(([, a], [, b]) => b.length - a.length)
+                    .map(([service, vars]) => ({ service, count: vars.length, vars })),
                 quickRef: getQuickRef("convex_check_env_vars"),
             };
         },

package/dist/tools/devSetupTools.d.ts

@@ -0,0 +1,2 @@
+import type { McpTool } from "../types.js";
+export declare const devSetupTools: McpTool[];

package/dist/tools/devSetupTools.js

@@ -0,0 +1,170 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getDb, genId } from "../db.js";
+import { getQuickRef } from "./toolRegistry.js";
+function auditDevSetup(projectDir) {
+    const issues = [];
+    const checks = [];
+    // Check 1: .gitignore includes _generated/
+    const gitignorePath = join(projectDir, ".gitignore");
+    if (existsSync(gitignorePath)) {
+        const gitignore = readFileSync(gitignorePath, "utf-8");
+        if (gitignore.includes("_generated") || gitignore.includes("convex/_generated")) {
+            checks.push({ area: "gitignore", status: "pass", detail: "_generated/ is in .gitignore" });
+        }
+        else {
+            checks.push({ area: "gitignore", status: "warn", detail: "_generated/ not in .gitignore — generated files may be committed" });
+            issues.push({
+                severity: "warning",
+                area: "gitignore",
+                message: "_generated/ directory is not in .gitignore. These files are auto-generated and should not be committed.",
+                fix: "Add `convex/_generated/` to .gitignore",
+            });
+        }
+    }
+    else {
+        checks.push({ area: "gitignore", status: "fail", detail: "No .gitignore file found" });
+        issues.push({
+            severity: "warning",
+            area: "gitignore",
+            message: "No .gitignore file found. Generated and environment files may be committed.",
+            fix: "Create a .gitignore with at least: node_modules/, convex/_generated/, .env.local",
+        });
+    }
+    // Check 2: .env.example exists
+    const envExamplePath = join(projectDir, ".env.example");
+    if (existsSync(envExamplePath)) {
+        checks.push({ area: "env_example", status: "pass", detail: ".env.example exists for onboarding" });
+    }
+    else {
+        // Check if there are env vars in use
+        const envLocalPath = join(projectDir, ".env.local");
+        const envPath = join(projectDir, ".env");
+        if (existsSync(envLocalPath) || existsSync(envPath)) {
+            checks.push({ area: "env_example", status: "warn", detail: ".env files exist but no .env.example for new developers" });
+            issues.push({
+                severity: "info",
+                area: "env_example",
+                message: "No .env.example file. New developers won't know which env vars to set.",
+                fix: "Create .env.example with placeholder values for all required environment variables",
+            });
+        }
+    }
+    // Check 3: convex.json exists and points to valid deployment
+    const convexJsonPath = join(projectDir, "convex.json");
+    if (existsSync(convexJsonPath)) {
+        try {
+            const convexJson = JSON.parse(readFileSync(convexJsonPath, "utf-8"));
+            if (convexJson.project) {
+                checks.push({ area: "convex_json", status: "pass", detail: `convex.json configured for project: ${convexJson.project}` });
+            }
+            else {
+                checks.push({ area: "convex_json", status: "warn", detail: "convex.json exists but no project configured" });
+            }
+        }
+        catch {
+            checks.push({ area: "convex_json", status: "fail", detail: "convex.json exists but is invalid JSON" });
+            issues.push({
+                severity: "critical",
+                area: "convex_json",
+                message: "convex.json is invalid JSON. Convex CLI won't work.",
+                fix: "Fix the JSON syntax in convex.json or delete and run `npx convex dev` to regenerate",
+            });
+        }
+    }
+    // Check 4: package.json has convex as dependency
+    const pkgJsonPath = join(projectDir, "package.json");
+    if (existsSync(pkgJsonPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps.convex) {
+                checks.push({ area: "convex_dep", status: "pass", detail: `convex@${deps.convex} installed` });
+            }
+            else {
+                checks.push({ area: "convex_dep", status: "fail", detail: "convex not in dependencies" });
+                issues.push({
+                    severity: "critical",
+                    area: "convex_dep",
+                    message: "convex package is not in dependencies. Install it first.",
+                    fix: "Run: npm install convex",
+                });
+            }
+        }
+        catch { /* ignore parse errors */ }
+    }
+    // Check 5: tsconfig.json configured for Convex
+    const tsconfigPath = join(projectDir, "tsconfig.json");
+    if (existsSync(tsconfigPath)) {
+        const tsconfig = readFileSync(tsconfigPath, "utf-8");
+        if (/\"strict\"\s*:\s*true/.test(tsconfig)) {
+            checks.push({ area: "tsconfig", status: "pass", detail: "TypeScript strict mode enabled" });
+        }
+        else {
+            checks.push({ area: "tsconfig", status: "info", detail: "TypeScript strict mode not enabled — recommended for Convex" });
+        }
+    }
+    // Check 6: _generated/ directory exists (project initialized)
+    const convexDir = join(projectDir, "convex");
+    const generatedDir = join(convexDir, "_generated");
+    if (existsSync(generatedDir)) {
+        checks.push({ area: "initialization", status: "pass", detail: "_generated/ exists — project is initialized" });
+    }
+    else if (existsSync(convexDir)) {
+        checks.push({ area: "initialization", status: "warn", detail: "_generated/ not found — run `npx convex dev` to initialize" });
+        issues.push({
+            severity: "warning",
+            area: "initialization",
+            message: "Convex project not initialized — _generated/ directory is missing.",
+            fix: "Run `npx convex dev` to generate types and initialize the project",
+        });
+    }
+    // Check 7: Node modules installed
+    const nodeModulesPath = join(projectDir, "node_modules", "convex");
+    if (existsSync(nodeModulesPath)) {
+        checks.push({ area: "node_modules", status: "pass", detail: "convex package installed in node_modules" });
+    }
+    else if (existsSync(pkgJsonPath)) {
+        checks.push({ area: "node_modules", status: "warn", detail: "convex not in node_modules — run npm install" });
+    }
+    return { issues, checks };
+}
+// ── Tool Definition ─────────────────────────────────────────────────
+export const devSetupTools = [
+    {
+        name: "convex_audit_dev_setup",
+        description: "Audit Convex project development setup: .gitignore includes _generated/, .env.example exists, convex.json is valid, convex is in dependencies, TypeScript strict mode, project initialization status.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectDir: {
+                    type: "string",
+                    description: "Absolute path to the project root",
+                },
+            },
+            required: ["projectDir"],
+        },
+        handler: async (args) => {
+            const projectDir = resolve(args.projectDir);
+            const { issues, checks } = auditDevSetup(projectDir);
+            const db = getDb();
+            db.prepare("INSERT INTO audit_results (id, project_dir, audit_type, issues_json, issue_count) VALUES (?, ?, ?, ?, ?)").run(genId("audit"), projectDir, "dev_setup", JSON.stringify(issues), issues.length);
+            const passed = checks.filter((c) => c.status === "pass").length;
+            const warned = checks.filter((c) => c.status === "warn").length;
+            const failed = checks.filter((c) => c.status === "fail").length;
+            return {
+                summary: {
+                    totalChecks: checks.length,
+                    passed,
+                    warned,
+                    failed,
+                    totalIssues: issues.length,
+                },
+                checks,
+                issues,
+                quickRef: getQuickRef("convex_audit_dev_setup"),
+            };
+        },
+    },
+];
+//# sourceMappingURL=devSetupTools.js.map

package/dist/tools/embeddingProvider.d.ts

@@ -11,19 +11,25 @@ export interface EmbeddingProvider {
     dimensions: number;
     embed(texts: string[]): Promise<Float32Array[]>;
 }
+/** Node type in the bipartite graph: tool nodes vs domain (agent) nodes */
+export type GraphNodeType = "tool" | "domain";
 interface EmbeddingIndexEntry {
     name: string;
     vector: Float32Array;
+    /** Node type for Agent-as-a-Graph bipartite scoring */
+    nodeType: GraphNodeType;
 }
 export declare function getEmbeddingProvider(): Promise<EmbeddingProvider | null>;
 export declare function initEmbeddingIndex(corpus: Array<{
     name: string;
     text: string;
+    nodeType?: GraphNodeType;
 }>): Promise<void>;
 export declare function embedQuery(text: string): Promise<Float32Array | null>;
 export declare function embeddingSearch(queryVec: Float32Array, limit?: number): Array<{
     name: string;
     similarity: number;
+    nodeType: GraphNodeType;
 }>;
 export declare function isEmbeddingReady(): boolean;
 export declare function getProviderName(): string | null;

package/dist/tools/embeddingProvider.js

@@ -120,6 +120,7 @@ async function _doInit(corpus) {
         _embeddingIndex = corpus.map((c) => ({
             name: c.name,
             vector: new Float32Array(cached.entries[c.name]),
+            nodeType: c.nodeType ?? "tool",
         }));
         return;
     }
@@ -129,6 +130,7 @@ async function _doInit(corpus) {
         _embeddingIndex = corpus.map((c, i) => ({
             name: c.name,
             vector: vectors[i],
+            nodeType: c.nodeType ?? "tool",
         }));
         const cacheData = {
             providerName: provider.name,
@@ -165,6 +167,7 @@ export function embeddingSearch(queryVec, limit = 30) {
     const scored = _embeddingIndex.map((entry) => ({
         name: entry.name,
         similarity: cosineSim(queryVec, entry.vector),
+        nodeType: entry.nodeType,
     }));
     scored.sort((a, b) => b.similarity - a.similarity);
     return scored.slice(0, limit);

package/dist/tools/functionTools.js

@@ -287,6 +287,22 @@ export const functionTools = [
             db.prepare("INSERT INTO audit_results (id, project_dir, audit_type, issues_json, issue_count) VALUES (?, ?, ?, ?, ?)").run(genId("audit"), projectDir, "function_audit", JSON.stringify(issues), issues.length);
             const critical = issues.filter((i) => i.severity === "critical");
             const warnings = issues.filter((i) => i.severity === "warning");
+            // Aggregate issues by category for cleaner output
+            const categories = {};
+            for (const issue of issues) {
+                const cat = issue.message.includes("missing args") ? "missing_args_validator" :
+                    issue.message.includes("missing returns") ? "missing_returns_validator" :
+                        issue.message.includes("missing handler") ? "missing_handler_old_syntax" :
+                            issue.message.includes("sensitive") ? "sensitive_function_public" :
+                                issue.message.includes("queries cannot") ? "query_cross_call_violation" :
+                                    issue.message.includes("multiple actions") ? "action_from_action" :
+                                        "other";
+                if (!categories[cat])
+                    categories[cat] = { severity: issue.severity, count: 0, examples: [] };
+                categories[cat].count++;
+                if (categories[cat].examples.length < 5)
+                    categories[cat].examples.push(issue);
+            }
             return {
                 summary: {
                     totalFunctions: functions.length,
@@ -296,7 +312,14 @@ export const functionTools = [
                     critical: critical.length,
                     warnings: warnings.length,
                 },
-                issues,
+                issuesByCategory: Object.entries(categories)
+                    .sort(([, a], [, b]) => (b.severity === "critical" ? 1 : 0) - (a.severity === "critical" ? 1 : 0) || b.count - a.count)
+                    .map(([cat, data]) => ({
+                    category: cat,
+                    severity: data.severity,
+                    count: data.count,
+                    examples: data.examples,
+                })),
                 quickRef: getQuickRef("convex_audit_functions"),
             };
         },

package/dist/tools/httpTools.js

@@ -1,5 +1,5 @@
 import { readFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { join, resolve, dirname } from "node:path";
 import { getQuickRef } from "./toolRegistry.js";
 // ── Helpers ──────────────────────────────────────────────────────────
 function findConvexDir(projectDir) {
@@ -10,21 +10,28 @@ function findConvexDir(projectDir) {
     }
     return null;
 }
-function analyzeHttpEndpoints(convexDir) {
-    const httpPath = join(convexDir, "http.ts");
-    if (!existsSync(httpPath)) {
-        return { hasHttp: false, routes: [], issues: [], hasCors: false, hasOptionsHandler: false };
+/** Resolve a relative import to a .ts file path */
+function resolveImport(fromFile, importPath) {
+    const dir = dirname(fromFile);
+    const candidates = [
+        join(dir, importPath + ".ts"),
+        join(dir, importPath, "index.ts"),
+        join(dir, importPath + ".tsx"),
+    ];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
     }
-    const content = readFileSync(httpPath, "utf-8");
-    const lines = content.split("\n");
+    return null;
+}
+/** Extract http.route() calls from a file's content, supporting both path and pathPrefix */
+function extractRoutesFromContent(content, sourceFile) {
     const routes = [];
-    const issues = [];
-    // Extract routes: http.route({ path: "...", method: "...", handler: ... })
-    const routeBlockPattern = /http\.route\s*\(\s*\{/g;
+    // Match any variable name followed by .route({ ... })
+    const routeBlockPattern = /\w+\.route\s*\(\s*\{/g;
     let routeMatch;
     while ((routeMatch = routeBlockPattern.exec(content)) !== null) {
         const startIdx = routeMatch.index;
-        // Find the closing of this route block (rough — find next })
         let depth = 0;
         let endIdx = startIdx;
         for (let i = startIdx; i < content.length; i++) {
@@ -39,21 +46,91 @@ function analyzeHttpEndpoints(convexDir) {
             }
         }
         const block = content.slice(startIdx, endIdx + 1);
-        const pathMatch = block.match(/path\s*:\s*["']([^"']+)["']/);
+        // Support both path: and pathPrefix:
+        const pathMatch = block.match(/(?:path|pathPrefix)\s*:\s*["']([^"']+)["']/);
         const methodMatch = block.match(/method\s*:\s*["']([^"']+)["']/);
+        const isWildcard = /pathPrefix\s*:/.test(block) || /\/\*/.test(block) || /:\w+/.test(pathMatch?.[1] || "");
         const line = content.slice(0, startIdx).split("\n").length;
         if (pathMatch && methodMatch) {
             routes.push({
                 path: pathMatch[1],
                 method: methodMatch[1].toUpperCase(),
                 line,
+                sourceFile,
                 handlerType: /handler\s*:\s*httpAction/.test(block) ? "inline" : "imported",
+                isWildcard,
             });
         }
     }
+    return routes;
+}
+/** Follow imports from http.ts to find all router files */
+function findRouterFiles(convexDir, httpPath) {
+    const files = [httpPath];
+    const visited = new Set([httpPath]);
+    const content = readFileSync(httpPath, "utf-8");
+    // Find relative imports that look like router sources
+    const importPattern = /import\s+(?:[\w{},\s]+\s+from\s+)?["'](\.[^"']+)["']/g;
+    let m;
+    while ((m = importPattern.exec(content)) !== null) {
+        const resolved = resolveImport(httpPath, m[1]);
+        if (resolved && !visited.has(resolved)) {
+            visited.add(resolved);
+            // Only include files that contain .route( or httpRouter or httpAction
+            try {
+                const fc = readFileSync(resolved, "utf-8");
+                if (/\.route\s*\(/.test(fc) || /httpRouter/.test(fc) || /httpAction/.test(fc)) {
+                    files.push(resolved);
+                }
+            }
+            catch { /* skip unreadable */ }
+        }
+    }
+    return files;
+}
+/** Detect .registerRoutes(http), .addHttpRoutes(http) and similar composite calls */
+function detectCompositeRouteSources(content, sourceFile) {
+    const composites = [];
+    const pattern = /(\w+)\.(registerRoutes|addHttpRoutes)\s*\(\s*\w+\s*\)/g;
+    let m;
+    while ((m = pattern.exec(content)) !== null) {
+        const line = content.slice(0, m.index).split("\n").length;
+        composites.push({
+            callee: `${m[1]}.${m[2]}()`,
+            sourceFile,
+            line,
+        });
+    }
+    return composites;
+}
+function analyzeHttpEndpoints(convexDir) {
+    const httpPath = join(convexDir, "http.ts");
+    if (!existsSync(httpPath)) {
+        return { hasHttp: false, routes: [], compositeRouteSources: [], issues: [], hasCors: false, hasOptionsHandler: false, filesScanned: [] };
+    }
+    const routerFiles = findRouterFiles(convexDir, httpPath);
+    const allRoutes = [];
+    const allComposites = [];
+    const issues = [];
+    let hasCorsInAny = false;
+    for (const filePath of routerFiles) {
+        const content = readFileSync(filePath, "utf-8");
+        const relPath = filePath.replace(convexDir, "").replace(/^[\\/]/, "");
+        // Extract routes
+        const routes = extractRoutesFromContent(content, relPath);
+        allRoutes.push(...routes);
+        // Detect composite route sources
+        const composites = detectCompositeRouteSources(content, relPath);
+        allComposites.push(...composites);
+        // Check for CORS in any file
+        if (/Access-Control-Allow-Origin/i.test(content) || /cors/i.test(content)) {
+            hasCorsInAny = true;
+        }
+    }
+    const hasOptionsHandler = allRoutes.some((r) => r.method === "OPTIONS");
     // Check for duplicate routes (same path + method)
     const routeKeys = new Map();
-    for (const route of routes) {
+    for (const route of allRoutes) {
         const key = `${route.method} ${route.path}`;
         const count = (routeKeys.get(key) || 0) + 1;
         routeKeys.set(key, count);
@@ -61,57 +138,46 @@ function analyzeHttpEndpoints(convexDir) {
             issues.push({
                 severity: "critical",
                 message: `Duplicate route: ${key} — only the last registration will be used`,
-                location: `http.ts:${route.line}`,
+                location: `${route.sourceFile}:${route.line}`,
             });
         }
     }
-    // Check for CORS handling
-    const hasCors = /Access-Control-Allow-Origin/i.test(content) ||
-        /cors/i.test(content);
-    const hasOptionsHandler = routes.some((r) => r.method === "OPTIONS");
-    if (!hasCors && routes.length > 0) {
+    if (!hasCorsInAny && allRoutes.length > 0) {
         issues.push({
             severity: "warning",
-            message: "No CORS headers detected. Browser requests from different origins will fail. Add Access-Control-Allow-Origin headers.",
+            message: "No CORS headers detected in any HTTP router file. Browser requests from different origins will fail.",
         });
     }
-    if (hasCors && !hasOptionsHandler) {
+    if (hasCorsInAny && !hasOptionsHandler) {
         issues.push({
             severity: "warning",
-            message: "CORS headers found but no OPTIONS handler registered. Preflight requests will fail. Add http.route({ path: '...', method: 'OPTIONS', handler: ... }).",
+            message: "CORS headers found but no OPTIONS handler registered. Preflight requests will fail.",
         });
     }
-    // Check for paths that look like they should be grouped
-    const pathPrefixes = new Map();
-    for (const route of routes) {
-        const parts = route.path.split("/").filter(Boolean);
-        if (parts.length >= 2) {
-            const prefix = `/${parts[0]}/${parts[1]}`;
-            pathPrefixes.set(prefix, (pathPrefixes.get(prefix) || 0) + 1);
-        }
-    }
-    // Check for missing httpRouter import
-    if (!/httpRouter/.test(content)) {
+    // Check http.ts specifically for required exports
+    const httpContent = readFileSync(httpPath, "utf-8");
+    if (!/export\s+default/.test(httpContent)) {
         issues.push({
             severity: "critical",
-            message: "Missing httpRouter import. HTTP endpoints require: import { httpRouter } from 'convex/server';",
+            message: "Missing 'export default' in http.ts. The httpRouter must be exported as default.",
         });
     }
-    // Check for export default
-    if (!/export\s+default\s+http/.test(content)) {
+    // Info about composite routes that can't be statically analyzed
+    if (allComposites.length > 0) {
         issues.push({
-            severity: "critical",
-            message: "Missing 'export default http'. The httpRouter must be exported as default.",
+            severity: "info",
+            message: `${allComposites.length} composite route source(s) detected (${allComposites.map(c => c.callee).join(", ")}). These add routes dynamically — actual route count may be higher than statically detected.`,
         });
     }
-    // Check for httpAction import
-    if (!/httpAction/.test(content) && routes.length > 0) {
-        issues.push({
-            severity: "warning",
-            message: "No httpAction usage found. HTTP route handlers should use httpAction().",
-        });
-    }
-    return { hasHttp: true, routes, issues, hasCors, hasOptionsHandler };
+    return {
+        hasHttp: true,
+        routes: allRoutes,
+        compositeRouteSources: allComposites,
+        issues,
+        hasCors: hasCorsInAny,
+        hasOptionsHandler,
+        filesScanned: routerFiles.map(f => f.replace(convexDir, "").replace(/^[\\/]/, "")),
+    };
 }
 // ── Tool Definitions ────────────────────────────────────────────────
 export const httpTools = [
@@ -142,18 +208,32 @@ export const httpTools = [
                     quickRef: getQuickRef("convex_analyze_http"),
                 };
             }
-            // Group routes by path prefix
+            // Group routes by method
             const byMethod = {};
             for (const r of result.routes) {
                 byMethod[r.method] = (byMethod[r.method] || 0) + 1;
             }
+            // Group routes by source file
+            const byFile = {};
+            for (const r of result.routes) {
+                byFile[r.sourceFile] = (byFile[r.sourceFile] || 0) + 1;
+            }
             return {
                 hasHttp: true,
-                totalRoutes: result.routes.length,
+                totalStaticRoutes: result.routes.length,
+                compositeRouteSources: result.compositeRouteSources.length,
+                estimatedTotalRoutes: result.compositeRouteSources.length > 0
+                    ? `${result.routes.length}+ (${result.compositeRouteSources.length} dynamic source(s) add additional routes)`
+                    : result.routes.length,
+                filesScanned: result.filesScanned,
                 byMethod,
+                byFile,
                 hasCors: result.hasCors,
                 hasOptionsHandler: result.hasOptionsHandler,
                 routes: result.routes,
+                composites: result.compositeRouteSources.length > 0
+                    ? result.compositeRouteSources
+                    : undefined,
                 issues: {
                     total: result.issues.length,
                     critical: result.issues.filter((i) => i.severity === "critical").length,

package/dist/tools/migrationTools.d.ts

@@ -0,0 +1,2 @@
+import type { McpTool } from "../types.js";
+export declare const migrationTools: McpTool[];