@homenshum/convex-mcp-nodebench 0.7.0 → 0.8.0

package/dist/index.js

@@ -14,7 +14,7 @@
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { ListToolsRequestSchema, CallToolRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { getDb, seedGotchasIfEmpty } from "./db.js";
 import { schemaTools } from "./tools/schemaTools.js";
 import { functionTools } from "./tools/functionTools.js";
@@ -36,6 +36,10 @@ import { paginationTools } from "./tools/paginationTools.js";
 import { dataModelingTools } from "./tools/dataModelingTools.js";
 import { devSetupTools } from "./tools/devSetupTools.js";
 import { migrationTools } from "./tools/migrationTools.js";
+import { reportingTools } from "./tools/reportingTools.js";
+import { vectorSearchTools } from "./tools/vectorSearchTools.js";
+import { schedulerTools } from "./tools/schedulerTools.js";
+import { qualityGateTools } from "./tools/qualityGateTools.js";
 import { CONVEX_GOTCHAS } from "./gotchaSeed.js";
 import { REGISTRY } from "./tools/toolRegistry.js";
 import { initEmbeddingIndex } from "./tools/embeddingProvider.js";
@@ -61,6 +65,10 @@ const ALL_TOOLS = [
     ...dataModelingTools,
     ...devSetupTools,
     ...migrationTools,
+    ...reportingTools,
+    ...vectorSearchTools,
+    ...schedulerTools,
+    ...qualityGateTools,
 ];
 const toolMap = new Map();
 for (const tool of ALL_TOOLS) {
@@ -69,10 +77,12 @@ for (const tool of ALL_TOOLS) {
 // ── Server setup ────────────────────────────────────────────────────
 const server = new Server({
     name: "convex-mcp-nodebench",
-    version: "0.1.0",
+    version: "0.8.0",
 }, {
     capabilities: {
         tools: {},
+        resources: {},
+        prompts: {},
     },
 });
 // ── Initialize DB + seed gotchas ────────────────────────────────────
@@ -169,6 +179,235 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
+// ── MCP Resources ───────────────────────────────────────────────────
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: "convex://project-health",
+                name: "Project Health Summary",
+                description: "Latest quality gate score, audit coverage, and issue counts across all audit types",
+                mimeType: "application/json",
+            },
+            {
+                uri: "convex://recent-audits",
+                name: "Recent Audit Results",
+                description: "Summary of the 10 most recent audit runs with issue counts and timestamps",
+                mimeType: "application/json",
+            },
+            {
+                uri: "convex://gotcha-db",
+                name: "Gotcha Knowledge Base",
+                description: "All stored Convex gotchas (seeded + user-recorded) with categories and severity",
+                mimeType: "application/json",
+            },
+        ],
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    const db = getDb();
+    if (uri === "convex://project-health") {
+        // Aggregate across all projects
+        const audits = db.prepare("SELECT audit_type, issue_count, audited_at FROM audit_results ORDER BY audited_at DESC LIMIT 50").all();
+        const byType = {};
+        for (const a of audits) {
+            if (!byType[a.audit_type]) {
+                byType[a.audit_type] = { count: a.issue_count, latest: a.audited_at };
+            }
+        }
+        const totalIssues = Object.values(byType).reduce((s, v) => s + v.count, 0);
+        const auditTypes = Object.keys(byType).length;
+        const latestGate = db.prepare("SELECT findings FROM deploy_checks WHERE check_type = 'quality_gate' ORDER BY checked_at DESC LIMIT 1").get();
+        let gateResult = null;
+        if (latestGate?.findings) {
+            try {
+                gateResult = JSON.parse(latestGate.findings);
+            }
+            catch { /* skip */ }
+        }
+        return {
+            contents: [{
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalIssues,
+                        auditTypesRun: auditTypes,
+                        issuesByType: byType,
+                        latestQualityGate: gateResult ? { score: gateResult.score, grade: gateResult.grade, passed: gateResult.passed } : null,
+                        toolCount: ALL_TOOLS.length,
+                    }, null, 2),
+                }],
+        };
+    }
+    if (uri === "convex://recent-audits") {
+        const audits = db.prepare("SELECT id, project_dir, audit_type, issue_count, audited_at FROM audit_results ORDER BY audited_at DESC LIMIT 10").all();
+        return {
+            contents: [{
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({ audits }, null, 2),
+                }],
+        };
+    }
+    if (uri === "convex://gotcha-db") {
+        const gotchas = db.prepare("SELECT key, category, severity, tags, source, updated_at FROM convex_gotchas ORDER BY updated_at DESC").all();
+        return {
+            contents: [{
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        totalGotchas: gotchas.length,
+                        bySource: {
+                            seed: gotchas.filter(g => g.source === "seed").length,
+                            user: gotchas.filter(g => g.source === "user").length,
+                        },
+                        gotchas,
+                    }, null, 2),
+                }],
+        };
+    }
+    return {
+        contents: [{
+                uri,
+                mimeType: "text/plain",
+                text: `Unknown resource: ${uri}`,
+            }],
+    };
+});
+// ── MCP Prompts ─────────────────────────────────────────────────────
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return {
+        prompts: [
+            {
+                name: "full-audit",
+                description: "Run a complete Convex project audit: schema, functions, auth, queries, actions, type safety, transactions, storage, pagination, data modeling, dev setup, vectors, schedulers — then quality gate",
+                arguments: [
+                    {
+                        name: "projectDir",
+                        description: "Absolute path to the project root",
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: "pre-deploy-checklist",
+                description: "Step-by-step pre-deployment verification: audit critical issues, check env vars, review migration plan, run quality gate",
+                arguments: [
+                    {
+                        name: "projectDir",
+                        description: "Absolute path to the project root",
+                        required: true,
+                    },
+                ],
+            },
+            {
+                name: "security-review",
+                description: "Security-focused audit: authorization coverage, type safety, action safety, storage permissions",
+                arguments: [
+                    {
+                        name: "projectDir",
+                        description: "Absolute path to the project root",
+                        required: true,
+                    },
+                ],
+            },
+        ],
+    };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: promptArgs } = request.params;
+    const projectDir = promptArgs?.projectDir ?? ".";
+    if (name === "full-audit") {
+        return {
+            description: "Complete Convex project audit sequence",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Run a complete audit of the Convex project at "${projectDir}". Execute these tools in order:
+
+1. convex_audit_schema — Check schema.ts for anti-patterns
+2. convex_audit_functions — Audit function registration and compliance
+3. convex_audit_authorization — Check auth coverage on public endpoints
+4. convex_audit_query_efficiency — Find unbounded queries and missing indexes
+5. convex_audit_actions — Validate action safety (no ctx.db, error handling)
+6. convex_check_type_safety — Find as-any casts and type issues
+7. convex_audit_transaction_safety — Detect race conditions
+8. convex_audit_storage_usage — Check file storage patterns
+9. convex_audit_pagination — Validate pagination implementations
+10. convex_audit_data_modeling — Check schema design quality
+11. convex_audit_vector_search — Validate vector search setup
+12. convex_audit_schedulers — Check scheduled function safety
+13. convex_audit_dev_setup — Verify project setup
+14. convex_quality_gate — Run configurable quality gate across all results
+
+After running all audits, summarize:
+- Total issues by severity (critical/warning/info)
+- Top 5 most impactful issues to fix first
+- Quality gate score and grade
+- Trend direction if previous audits exist (use convex_audit_diff)`,
+                    },
+                },
+            ],
+        };
+    }
+    if (name === "pre-deploy-checklist") {
+        return {
+            description: "Pre-deployment verification sequence",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Run pre-deployment checks for the Convex project at "${projectDir}":
+
+1. convex_pre_deploy_gate — Structural checks (schema, auth config, initialization)
+2. convex_check_env_vars — Verify all required env vars are set
+3. convex_audit_authorization — Ensure auth coverage is adequate
+4. convex_audit_actions — No ctx.db access in actions
+5. convex_snapshot_schema — Capture current schema state
+6. convex_schema_migration_plan — Compare against previous snapshot for breaking changes
+7. convex_quality_gate — Final quality check with thresholds
+
+Report: DEPLOY or DO NOT DEPLOY with specific blockers to fix.`,
+                    },
+                },
+            ],
+        };
+    }
+    if (name === "security-review") {
+        return {
+            description: "Security-focused audit sequence",
+            messages: [
+                {
+                    role: "user",
+                    content: {
+                        type: "text",
+                        text: `Run a security review of the Convex project at "${projectDir}":
+
+1. convex_audit_authorization — Auth coverage on all public endpoints
+2. convex_check_type_safety — Type safety bypasses (as any)
+3. convex_audit_actions — Action safety (ctx.db, error handling, "use node")
+4. convex_audit_storage_usage — Storage permission patterns
+5. convex_audit_pagination — Unbounded numItems (DoS risk)
+6. convex_audit_transaction_safety — Race condition risks
+
+Focus on: unauthorized data access, unvalidated inputs, missing error boundaries, and potential data corruption vectors.`,
+                    },
+                },
+            ],
+        };
+    }
+    return {
+        description: "Unknown prompt",
+        messages: [{
+                role: "user",
+                content: { type: "text", text: `Unknown prompt: ${name}` },
+            }],
+    };
+});
 // ── Start server ────────────────────────────────────────────────────
 async function main() {
     const transport = new StdioServerTransport();

package/dist/tools/qualityGateTools.d.ts

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

package/dist/tools/qualityGateTools.js

@@ -0,0 +1,204 @@
+import { resolve } from "node:path";
+import { getDb, genId } from "../db.js";
+import { getQuickRef } from "./toolRegistry.js";
+const DEFAULT_THRESHOLDS = {
+    maxCritical: 0,
+    maxWarnings: 50,
+    minAuthCoveragePercent: 10,
+    maxAsAnyCasts: 500,
+    maxUnboundedCollects: 100,
+    maxDanglingRefs: 20,
+};
+function runQualityGate(projectDir, thresholds) {
+    const db = getDb();
+    const checks = [];
+    // Helper: get latest audit by type
+    function getLatest(auditType) {
+        return db.prepare("SELECT issues_json, issue_count FROM audit_results WHERE project_dir = ? AND audit_type = ? ORDER BY audited_at DESC LIMIT 1").get(projectDir, auditType) ?? null;
+    }
+    function countBySeverity(json, severity) {
+        try {
+            const issues = JSON.parse(json);
+            return Array.isArray(issues) ? issues.filter((i) => i.severity === severity).length : 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    // Aggregate critical/warning counts across all audit types
+    const auditTypes = [
+        "schema", "functions", "authorization", "query_efficiency",
+        "action_audit", "type_safety", "transaction_safety", "storage",
+        "pagination", "data_modeling", "vector_search", "scheduler_audit",
+    ];
+    let totalCritical = 0;
+    let totalWarnings = 0;
+    let auditsRun = 0;
+    for (const type of auditTypes) {
+        const latest = getLatest(type);
+        if (!latest)
+            continue;
+        auditsRun++;
+        totalCritical += countBySeverity(latest.issues_json, "critical");
+        totalWarnings += countBySeverity(latest.issues_json, "warning");
+    }
+    // Check 1: Critical issues
+    checks.push({
+        metric: "critical_issues",
+        passed: totalCritical <= thresholds.maxCritical,
+        actual: totalCritical,
+        threshold: thresholds.maxCritical,
+        severity: totalCritical > thresholds.maxCritical ? "blocker" : "info",
+    });
+    // Check 2: Warning issues
+    checks.push({
+        metric: "warning_issues",
+        passed: totalWarnings <= thresholds.maxWarnings,
+        actual: totalWarnings,
+        threshold: thresholds.maxWarnings,
+        severity: totalWarnings > thresholds.maxWarnings ? "warning" : "info",
+    });
+    // Check 3: Authorization coverage
+    const authAudit = getLatest("authorization");
+    if (authAudit) {
+        try {
+            const issues = JSON.parse(authAudit.issues_json);
+            // Parse coverage from stored data — look for the structured result pattern
+            // The auth audit stores issues, but we need the summary... use issue counts as proxy
+            const authIssues = Array.isArray(issues) ? issues.length : 0;
+            // Use inverse metric: fewer auth issues = better coverage
+            checks.push({
+                metric: "auth_issues",
+                passed: true, // Auth coverage is informational in gate
+                actual: authIssues,
+                threshold: "tracked",
+                severity: authIssues > 50 ? "warning" : "info",
+            });
+        }
+        catch { /* skip */ }
+    }
+    // Check 4: Type safety (as any casts)
+    const typeSafety = getLatest("type_safety");
+    if (typeSafety) {
+        try {
+            const issues = JSON.parse(typeSafety.issues_json);
+            const asAnyIssues = Array.isArray(issues)
+                ? issues.filter((i) => i.message?.includes("as any")).length
+                : 0;
+            // Each as-any issue represents a FILE, count from message for actual number
+            const actualCasts = Array.isArray(issues)
+                ? issues.reduce((sum, i) => {
+                    const countMatch = i.message?.match(/(\d+)\s+`as any`/);
+                    return sum + (countMatch ? parseInt(countMatch[1], 10) : 0);
+                }, 0)
+                : 0;
+            checks.push({
+                metric: "as_any_casts",
+                passed: actualCasts <= thresholds.maxAsAnyCasts,
+                actual: actualCasts,
+                threshold: thresholds.maxAsAnyCasts,
+                severity: actualCasts > thresholds.maxAsAnyCasts ? "warning" : "info",
+            });
+        }
+        catch { /* skip */ }
+    }
+    // Check 5: Unbounded collects
+    const queryEfficiency = getLatest("query_efficiency");
+    if (queryEfficiency) {
+        try {
+            const issues = JSON.parse(queryEfficiency.issues_json);
+            const unbounded = Array.isArray(issues)
+                ? issues.filter((i) => i.message?.includes(".collect()")).length
+                : 0;
+            checks.push({
+                metric: "unbounded_collects",
+                passed: unbounded <= thresholds.maxUnboundedCollects,
+                actual: unbounded,
+                threshold: thresholds.maxUnboundedCollects,
+                severity: unbounded > thresholds.maxUnboundedCollects ? "warning" : "info",
+            });
+        }
+        catch { /* skip */ }
+    }
+    // Check 6: Dangling references
+    const dataModeling = getLatest("data_modeling");
+    if (dataModeling) {
+        try {
+            const issues = JSON.parse(dataModeling.issues_json);
+            const dangling = Array.isArray(issues)
+                ? issues.filter((i) => i.message?.includes("dangling") || i.message?.includes("non-existent")).length
+                : 0;
+            checks.push({
+                metric: "dangling_refs",
+                passed: dangling <= thresholds.maxDanglingRefs,
+                actual: dangling,
+                threshold: thresholds.maxDanglingRefs,
+                severity: dangling > thresholds.maxDanglingRefs ? "warning" : "info",
+            });
+        }
+        catch { /* skip */ }
+    }
+    // Check 7: Audit coverage — how many audit types have been run
+    checks.push({
+        metric: "audit_coverage",
+        passed: auditsRun >= 3,
+        actual: `${auditsRun}/${auditTypes.length}`,
+        threshold: "3+",
+        severity: auditsRun < 3 ? "warning" : "info",
+    });
+    // Calculate score (0-100)
+    const passedChecks = checks.filter(c => c.passed).length;
+    const totalChecks = checks.length;
+    const blockerCount = checks.filter(c => !c.passed && c.severity === "blocker").length;
+    const score = blockerCount > 0 ? Math.min(40, Math.round(100 * passedChecks / totalChecks))
+        : Math.round(100 * passedChecks / totalChecks);
+    const grade = score >= 90 ? "A" : score >= 75 ? "B" : score >= 60 ? "C" : score >= 40 ? "D" : "F";
+    const passed = blockerCount === 0 && checks.filter(c => !c.passed && c.severity === "warning").length < 3;
+    return { passed, checks, score, grade };
+}
+// ── Tool Definition ─────────────────────────────────────────────────
+export const qualityGateTools = [
+    {
+        name: "convex_quality_gate",
+        description: "Run a configurable quality gate across all stored audit results. Like SonarQube's quality gate — scores your project (A-F), checks configurable thresholds (max critical issues, min auth coverage, max as-any casts), and returns pass/fail with detailed metrics. Run individual audit tools first to populate data.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectDir: {
+                    type: "string",
+                    description: "Absolute path to the project root",
+                },
+                thresholds: {
+                    type: "object",
+                    description: "Custom thresholds. Defaults: maxCritical=0, maxWarnings=50, minAuthCoveragePercent=10, maxAsAnyCasts=500, maxUnboundedCollects=100, maxDanglingRefs=20",
+                    properties: {
+                        maxCritical: { type: "number" },
+                        maxWarnings: { type: "number" },
+                        minAuthCoveragePercent: { type: "number" },
+                        maxAsAnyCasts: { type: "number" },
+                        maxUnboundedCollects: { type: "number" },
+                        maxDanglingRefs: { type: "number" },
+                    },
+                },
+            },
+            required: ["projectDir"],
+        },
+        handler: async (args) => {
+            const projectDir = resolve(args.projectDir);
+            const thresholds = {
+                ...DEFAULT_THRESHOLDS,
+                ...(args.thresholds ?? {}),
+            };
+            const result = runQualityGate(projectDir, thresholds);
+            // Store quality gate result
+            const db = getDb();
+            db.prepare("INSERT INTO deploy_checks (id, project_dir, check_type, passed, findings) VALUES (?, ?, ?, ?, ?)").run(genId("deploy"), projectDir, "quality_gate", result.passed ? 1 : 0, JSON.stringify(result));
+            return {
+                ...result,
+                thresholdsUsed: thresholds,
+                quickRef: getQuickRef("convex_quality_gate"),
+            };
+        },
+    },
+];
+//# sourceMappingURL=qualityGateTools.js.map

package/dist/tools/reportingTools.d.ts

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

package/dist/tools/reportingTools.js

@@ -0,0 +1,240 @@
+import { resolve } from "node:path";
+import { getDb, genId } from "../db.js";
+import { getQuickRef } from "./toolRegistry.js";
+function severityToSarif(sev) {
+    if (sev === "critical")
+        return "error";
+    if (sev === "warning")
+        return "warning";
+    return "note";
+}
+function buildSarif(projectDir, auditTypes, limit) {
+    const db = getDb();
+    const placeholders = auditTypes.map(() => "?").join(", ");
+    const rows = db.prepare(`SELECT audit_type, issues_json, issue_count, audited_at
+     FROM audit_results
+     WHERE project_dir = ? AND audit_type IN (${placeholders})
+     ORDER BY audited_at DESC`).all(projectDir, ...auditTypes);
+    // Dedupe: keep only latest per audit_type
+    const seen = new Set();
+    const latestRows = [];
+    for (const row of rows) {
+        if (!seen.has(row.audit_type)) {
+            seen.add(row.audit_type);
+            latestRows.push(row);
+        }
+    }
+    const rulesMap = new Map();
+    const results = [];
+    for (const row of latestRows) {
+        let issues;
+        try {
+            issues = JSON.parse(row.issues_json);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(issues))
+            continue;
+        for (const issue of issues.slice(0, limit)) {
+            const ruleId = `convex/${row.audit_type}/${issue.message?.slice(0, 40)?.replace(/[^a-zA-Z0-9]/g, "-") ?? "unknown"}`;
+            if (!rulesMap.has(ruleId)) {
+                rulesMap.set(ruleId, {
+                    id: ruleId,
+                    name: row.audit_type,
+                    shortDescription: { text: issue.message?.slice(0, 120) ?? "Issue found" },
+                    defaultConfiguration: { level: severityToSarif(issue.severity ?? "warning") },
+                });
+            }
+            // Parse location "file:line" format
+            const loc = issue.location ?? "";
+            const colonIdx = loc.lastIndexOf(":");
+            const file = colonIdx > 0 ? loc.slice(0, colonIdx) : loc;
+            const line = colonIdx > 0 ? parseInt(loc.slice(colonIdx + 1), 10) : undefined;
+            const sarifResult = {
+                ruleId,
+                level: severityToSarif(issue.severity ?? "warning"),
+                message: { text: issue.message ?? "Issue detected" },
+                locations: [{
+                        physicalLocation: {
+                            artifactLocation: { uri: file || "unknown" },
+                            ...(line && !isNaN(line) ? { region: { startLine: line } } : {}),
+                        },
+                    }],
+            };
+            if (issue.fix) {
+                sarifResult.fixes = [{ description: { text: issue.fix } }];
+            }
+            results.push(sarifResult);
+        }
+    }
+    return {
+        $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/main/sarif-2.1/schema/sarif-schema-2.1.0.json",
+        version: "2.1.0",
+        runs: [{
+                tool: {
+                    driver: {
+                        name: "convex-mcp-nodebench",
+                        version: "0.8.0",
+                        informationUri: "https://www.npmjs.com/package/@homenshum/convex-mcp-nodebench",
+                        rules: [...rulesMap.values()],
+                    },
+                },
+                results,
+            }],
+    };
+}
+function fingerprint(issue) {
+    // Deterministic fingerprint from location + message prefix (ignoring counts)
+    const loc = (issue.location ?? "").replace(/:\d+$/, ""); // strip line number for stability
+    const msgPrefix = (issue.message ?? "").slice(0, 60);
+    return `${loc}::${msgPrefix}`;
+}
+function computeBaselineDiff(projectDir) {
+    const db = getDb();
+    // Get all audit types that have at least 2 runs
+    const auditTypes = db.prepare(`SELECT DISTINCT audit_type FROM audit_results
+     WHERE project_dir = ?
+     GROUP BY audit_type
+     HAVING COUNT(*) >= 2`).all(projectDir);
+    const newIssues = [];
+    const fixedIssues = [];
+    const existingIssues = [];
+    for (const { audit_type } of auditTypes) {
+        const rows = db.prepare(`SELECT issues_json FROM audit_results
+       WHERE project_dir = ? AND audit_type = ?
+       ORDER BY audited_at DESC LIMIT 2`).all(projectDir, audit_type);
+        if (rows.length < 2)
+            continue;
+        let currentIssues, previousIssues;
+        try {
+            currentIssues = JSON.parse(rows[0].issues_json);
+            previousIssues = JSON.parse(rows[1].issues_json);
+        }
+        catch {
+            continue;
+        }
+        if (!Array.isArray(currentIssues) || !Array.isArray(previousIssues))
+            continue;
+        const prevFingerprints = new Set(previousIssues.map(fingerprint));
+        const currFingerprints = new Set(currentIssues.map(fingerprint));
+        // New: in current but not in previous
+        for (const issue of currentIssues) {
+            const fp = fingerprint(issue);
+            const diffIssue = {
+                status: prevFingerprints.has(fp) ? "existing" : "new",
+                auditType: audit_type,
+                severity: issue.severity ?? "warning",
+                location: issue.location ?? "",
+                message: issue.message ?? "",
+                fix: issue.fix,
+            };
+            if (diffIssue.status === "new")
+                newIssues.push(diffIssue);
+            else
+                existingIssues.push(diffIssue);
+        }
+        // Fixed: in previous but not in current
+        for (const issue of previousIssues) {
+            const fp = fingerprint(issue);
+            if (!currFingerprints.has(fp)) {
+                fixedIssues.push({
+                    status: "fixed",
+                    auditType: audit_type,
+                    severity: issue.severity ?? "warning",
+                    location: issue.location ?? "",
+                    message: issue.message ?? "",
+                });
+            }
+        }
+    }
+    const trend = fixedIssues.length > newIssues.length ? "improving" :
+        newIssues.length > fixedIssues.length ? "degrading" : "stable";
+    return {
+        newIssues,
+        fixedIssues,
+        existingIssues,
+        summary: {
+            totalNew: newIssues.length,
+            totalFixed: fixedIssues.length,
+            totalExisting: existingIssues.length,
+            trend,
+        },
+    };
+}
+// ── Tool Definitions ────────────────────────────────────────────────
+export const reportingTools = [
+    {
+        name: "convex_export_sarif",
+        description: "Export stored audit results as SARIF 2.1.0 JSON. SARIF is the industry standard for static analysis results — integrates with GitHub Code Scanning, VS Code Problems panel, and CI pipelines. Outputs file:line locations, severity levels, and fix suggestions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectDir: {
+                    type: "string",
+                    description: "Absolute path to the project root",
+                },
+                auditTypes: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Which audit types to include. Defaults to all. Options: schema, functions, authorization, query_efficiency, action_audit, type_safety, transaction_safety, storage, pagination, data_modeling, dev_setup, migration_plan",
+                },
+                maxResults: {
+                    type: "number",
+                    description: "Max results per audit type (default 100)",
+                },
+            },
+            required: ["projectDir"],
+        },
+        handler: async (args) => {
+            const projectDir = resolve(args.projectDir);
+            const allTypes = [
+                "schema", "functions", "authorization", "query_efficiency",
+                "action_audit", "type_safety", "transaction_safety", "storage",
+                "pagination", "data_modeling", "dev_setup", "migration_plan",
+            ];
+            const auditTypes = args.auditTypes?.length ? args.auditTypes : allTypes;
+            const sarif = buildSarif(projectDir, auditTypes, args.maxResults ?? 100);
+            const resultCount = sarif.runs?.[0]?.results?.length ?? 0;
+            return {
+                sarif,
+                summary: {
+                    format: "SARIF 2.1.0",
+                    totalResults: resultCount,
+                    auditTypesIncluded: auditTypes,
+                    usage: "Pipe this JSON to a .sarif file, then upload to GitHub Code Scanning or open in VS Code SARIF Viewer",
+                },
+                quickRef: getQuickRef("convex_export_sarif"),
+            };
+        },
+    },
+    {
+        name: "convex_audit_diff",
+        description: "Compare the latest audit run against the previous run to show new issues, fixed issues, and trend direction (improving/stable/degrading). Like SonarQube's new code analysis — tells you whether your changes introduced or resolved issues.",
+        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 diff = computeBaselineDiff(projectDir);
+            // Store the diff result
+            const db = getDb();
+            db.prepare("INSERT INTO audit_results (id, project_dir, audit_type, issues_json, issue_count) VALUES (?, ?, ?, ?, ?)").run(genId("audit"), projectDir, "baseline_diff", JSON.stringify(diff.summary), diff.summary.totalNew);
+            return {
+                ...diff,
+                newIssues: diff.newIssues.slice(0, 30),
+                fixedIssues: diff.fixedIssues.slice(0, 30),
+                existingIssues: undefined, // Too verbose — available via full audit
+                quickRef: getQuickRef("convex_audit_diff"),
+            };
+        },
+    },
+];
+//# sourceMappingURL=reportingTools.js.map

package/dist/tools/schedulerTools.d.ts

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

package/dist/tools/schedulerTools.js

@@ -0,0 +1,197 @@
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getDb, genId } from "../db.js";
+import { getQuickRef } from "./toolRegistry.js";
+// ── Helpers ──────────────────────────────────────────────────────────
+function findConvexDir(projectDir) {
+    const candidates = [join(projectDir, "convex"), join(projectDir, "src", "convex")];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+function collectTsFiles(dir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "_generated") {
+            results.push(...collectTsFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".ts")) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+function auditSchedulers(convexDir) {
+    const files = collectTsFiles(convexDir);
+    const issues = [];
+    let totalSchedulerCalls = 0;
+    let runAfterCalls = 0;
+    let runAtCalls = 0;
+    let selfSchedulingFunctions = 0;
+    const filesWithSchedulers = new Set();
+    for (const filePath of files) {
+        const content = readFileSync(filePath, "utf-8");
+        const relativePath = filePath.replace(convexDir, "").replace(/^[\\/]/, "");
+        const lines = content.split("\n");
+        // Find all exported functions (mutation/action) and their bodies
+        const funcPattern = /export\s+(?:const\s+(\w+)\s*=|default)\s+(mutation|internalMutation|action|internalAction)\s*\(/g;
+        let m;
+        while ((m = funcPattern.exec(content)) !== null) {
+            const funcName = m[1] || "default";
+            const funcType = m[2];
+            const startLine = content.slice(0, m.index).split("\n").length - 1;
+            // Extract body
+            let depth = 0;
+            let foundOpen = false;
+            let endLine = Math.min(startLine + 100, lines.length);
+            for (let j = startLine; j < lines.length; j++) {
+                for (const ch of lines[j]) {
+                    if (ch === "{") {
+                        depth++;
+                        foundOpen = true;
+                    }
+                    if (ch === "}")
+                        depth--;
+                }
+                if (foundOpen && depth <= 0) {
+                    endLine = j + 1;
+                    break;
+                }
+            }
+            const body = lines.slice(startLine, endLine).join("\n");
+            // Check scheduler calls in body
+            const runAfterMatches = [...body.matchAll(/ctx\.scheduler\.runAfter\s*\(/g)];
+            const runAtMatches = [...body.matchAll(/ctx\.scheduler\.runAt\s*\(/g)];
+            const allSchedulerCalls = runAfterMatches.length + runAtMatches.length;
+            if (allSchedulerCalls === 0)
+                continue;
+            filesWithSchedulers.add(relativePath);
+            totalSchedulerCalls += allSchedulerCalls;
+            runAfterCalls += runAfterMatches.length;
+            runAtCalls += runAtMatches.length;
+            // Check 1: Self-scheduling (infinite loop risk)
+            // Detect: function schedules itself by name
+            const selfRefPattern = new RegExp(`ctx\\.scheduler\\.run(?:After|At)\\s*\\([^,]*,\\s*(?:internal|api)\\.[^,]*\\.${funcName}\\b`);
+            if (selfRefPattern.test(body)) {
+                selfSchedulingFunctions++;
+                // Check if there's a termination condition
+                const hasTermination = /if\s*\(|return\s+(?:null|undefined|void)|\.length\s*(?:===?|<=?)\s*0/.test(body);
+                issues.push({
+                    severity: hasTermination ? "warning" : "critical",
+                    location: `${relativePath}:${startLine + 1}`,
+                    functionName: funcName,
+                    message: `${funcType} "${funcName}" schedules itself${hasTermination ? " (has conditional guard)" : " without clear termination — infinite loop risk"}.`,
+                    fix: hasTermination
+                        ? "Verify the termination condition covers all edge cases"
+                        : "Add a termination condition (max retries, empty queue check) before self-scheduling",
+                });
+            }
+            // Check 2: Very short delay (< 1 second) — may indicate missing backoff
+            for (const match of runAfterMatches) {
+                const callIdx = content.indexOf(match[0], m.index);
+                const callLine = content.slice(0, callIdx).split("\n").length;
+                const afterCall = content.slice(callIdx, callIdx + 100);
+                const delayMatch = afterCall.match(/runAfter\s*\(\s*(\d+(?:\.\d+)?)\s*[,)]/);
+                if (delayMatch) {
+                    const delay = parseFloat(delayMatch[1]);
+                    if (delay < 1) {
+                        issues.push({
+                            severity: "warning",
+                            location: `${relativePath}:${callLine}`,
+                            functionName: funcName,
+                            message: `scheduler.runAfter(${delay}, ...) uses sub-second delay. In retry/loop patterns this can overwhelm the scheduler.`,
+                            fix: "Use at least 1-second delay. For retries, implement exponential backoff (e.g., delay * 2^attempt)",
+                        });
+                    }
+                }
+            }
+            // Check 3: Scheduler in action without try/catch
+            if ((funcType === "action" || funcType === "internalAction") && allSchedulerCalls > 0) {
+                // Check if the scheduler call is wrapped in try/catch
+                if (!/try\s*\{/.test(body)) {
+                    issues.push({
+                        severity: "info",
+                        location: `${relativePath}:${startLine + 1}`,
+                        functionName: funcName,
+                        message: `${funcType} "${funcName}" uses scheduler without try/catch. If the action fails before scheduling, work may be lost.`,
+                        fix: "Wrap scheduler calls in try/catch or move scheduling to a mutation for transactional guarantees",
+                    });
+                }
+            }
+            // Check 4: Multiple scheduler calls in same function (fan-out)
+            if (allSchedulerCalls > 3) {
+                issues.push({
+                    severity: "info",
+                    location: `${relativePath}:${startLine + 1}`,
+                    functionName: funcName,
+                    message: `${funcType} "${funcName}" makes ${allSchedulerCalls} scheduler calls. Consider if a single orchestrator action would be cleaner.`,
+                    fix: "Group related work into fewer scheduled calls or use a queue-based pattern",
+                });
+            }
+            // Check 5: Scheduling from a query (not possible — queries are read-only)
+            if (funcType.includes("Query") || funcType === "query" || funcType === "internalQuery") {
+                issues.push({
+                    severity: "critical",
+                    location: `${relativePath}:${startLine + 1}`,
+                    functionName: funcName,
+                    message: `Query "${funcName}" tries to use ctx.scheduler — queries are read-only and cannot schedule functions.`,
+                    fix: "Move scheduler calls to a mutation or action",
+                });
+            }
+        }
+    }
+    return {
+        issues,
+        stats: {
+            totalSchedulerCalls,
+            runAfterCalls,
+            runAtCalls,
+            selfSchedulingFunctions,
+            filesWithSchedulers: filesWithSchedulers.size,
+        },
+    };
+}
+// ── Tool Definition ─────────────────────────────────────────────────
+export const schedulerTools = [
+    {
+        name: "convex_audit_schedulers",
+        description: "Audit Convex scheduled function usage (ctx.scheduler.runAfter/runAt): detects infinite self-scheduling loops, sub-second delays without backoff, scheduler calls in queries (impossible), unprotected scheduler calls in actions, and excessive fan-out patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectDir: {
+                    type: "string",
+                    description: "Absolute path to the project root containing a convex/ directory",
+                },
+            },
+            required: ["projectDir"],
+        },
+        handler: async (args) => {
+            const projectDir = resolve(args.projectDir);
+            const convexDir = findConvexDir(projectDir);
+            if (!convexDir) {
+                return { error: "No convex/ directory found" };
+            }
+            const { issues, stats } = auditSchedulers(convexDir);
+            const db = getDb();
+            db.prepare("INSERT INTO audit_results (id, project_dir, audit_type, issues_json, issue_count) VALUES (?, ?, ?, ?, ?)").run(genId("audit"), projectDir, "scheduler_audit", JSON.stringify(issues), issues.length);
+            return {
+                summary: {
+                    ...stats,
+                    totalIssues: issues.length,
+                    critical: issues.filter(i => i.severity === "critical").length,
+                    warnings: issues.filter(i => i.severity === "warning").length,
+                },
+                issues: issues.slice(0, 30),
+                quickRef: getQuickRef("convex_audit_schedulers"),
+            };
+        },
+    },
+];
+//# sourceMappingURL=schedulerTools.js.map

package/dist/tools/toolRegistry.js

@@ -411,6 +411,80 @@ export const REGISTRY = [
         phase: "deploy",
         complexity: "medium",
     },
+    // ── Reporting Tools ─────────────────────
+    {
+        name: "convex_export_sarif",
+        category: "integration",
+        tags: ["sarif", "export", "report", "github", "code-scanning", "ci", "static-analysis"],
+        quickRef: {
+            nextAction: "Upload the SARIF file to GitHub Code Scanning or open in VS Code SARIF Viewer",
+            nextTools: ["convex_audit_diff", "convex_quality_gate"],
+            methodology: "convex_deploy_verification",
+            relatedGotchas: [],
+            confidence: "high",
+        },
+        phase: "deploy",
+        complexity: "low",
+    },
+    {
+        name: "convex_audit_diff",
+        category: "deployment",
+        tags: ["diff", "baseline", "trend", "new-issues", "fixed", "improving", "degrading", "comparison"],
+        quickRef: {
+            nextAction: "Focus on fixing new issues first, then tackle existing ones",
+            nextTools: ["convex_export_sarif", "convex_quality_gate"],
+            methodology: "convex_deploy_verification",
+            relatedGotchas: [],
+            confidence: "high",
+        },
+        phase: "deploy",
+        complexity: "medium",
+    },
+    // ── Vector Search Tools ─────────────────
+    {
+        name: "convex_audit_vector_search",
+        category: "schema",
+        tags: ["vector", "search", "embedding", "dimension", "similarity", "vectorIndex", "float64", "AI", "RAG"],
+        quickRef: {
+            nextAction: "Fix dimension mismatches and add filterFields to vector indexes for better performance",
+            nextTools: ["convex_audit_schema", "convex_suggest_indexes"],
+            methodology: "convex_schema_audit",
+            relatedGotchas: [],
+            confidence: "high",
+        },
+        phase: "audit",
+        complexity: "medium",
+    },
+    // ── Scheduler Tools ─────────────────────
+    {
+        name: "convex_audit_schedulers",
+        category: "function",
+        tags: ["scheduler", "runAfter", "runAt", "schedule", "cron", "infinite-loop", "backoff", "retry", "delayed"],
+        quickRef: {
+            nextAction: "Fix self-scheduling loops (add termination conditions) and implement exponential backoff",
+            nextTools: ["convex_check_crons", "convex_audit_actions"],
+            methodology: "convex_function_compliance",
+            relatedGotchas: [],
+            confidence: "high",
+        },
+        phase: "audit",
+        complexity: "medium",
+    },
+    // ── Quality Gate Tools ──────────────────
+    {
+        name: "convex_quality_gate",
+        category: "deployment",
+        tags: ["quality", "gate", "score", "grade", "threshold", "sonarqube", "metrics", "pass-fail", "A-F"],
+        quickRef: {
+            nextAction: "Fix blockers to raise your grade, then run again to verify improvement",
+            nextTools: ["convex_audit_diff", "convex_export_sarif", "convex_pre_deploy_gate"],
+            methodology: "convex_deploy_verification",
+            relatedGotchas: [],
+            confidence: "high",
+        },
+        phase: "deploy",
+        complexity: "high",
+    },
 ];
 export function getQuickRef(toolName) {
     const entry = REGISTRY.find((e) => e.name === toolName);

package/dist/tools/vectorSearchTools.d.ts

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

package/dist/tools/vectorSearchTools.js

@@ -0,0 +1,192 @@
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { getDb, genId } from "../db.js";
+import { getQuickRef } from "./toolRegistry.js";
+// ── Helpers ──────────────────────────────────────────────────────────
+function findConvexDir(projectDir) {
+    const candidates = [join(projectDir, "convex"), join(projectDir, "src", "convex")];
+    for (const c of candidates) {
+        if (existsSync(c))
+            return c;
+    }
+    return null;
+}
+function collectTsFiles(dir) {
+    const results = [];
+    if (!existsSync(dir))
+        return results;
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = join(dir, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "_generated") {
+            results.push(...collectTsFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".ts")) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+// Common embedding model dimensions
+const KNOWN_DIMENSIONS = {
+    384: "all-MiniLM-L6-v2",
+    512: "e5-small",
+    768: "text-embedding-004 / all-mpnet-base-v2",
+    1024: "e5-large / cohere-embed-v3",
+    1536: "text-embedding-3-small / text-embedding-ada-002",
+    3072: "text-embedding-3-large",
+};
+function auditVectorSearch(convexDir) {
+    const issues = [];
+    const schemaPath = join(convexDir, "schema.ts");
+    // Parse schema for vectorIndex definitions
+    const vectorIndexes = [];
+    if (existsSync(schemaPath)) {
+        const schema = readFileSync(schemaPath, "utf-8");
+        const lines = schema.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            // Match .vectorIndex("name", { ... })
+            const viMatch = lines[i].match(/\.vectorIndex\s*\(\s*["']([^"']+)["']/);
+            if (viMatch) {
+                // Look ahead for dimensions and filterFields
+                const chunk = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                const dimMatch = chunk.match(/dimensions\s*:\s*(\d+)/);
+                const filterMatch = chunk.match(/filterFields\s*:\s*\[([^\]]*)\]/);
+                const dims = dimMatch ? parseInt(dimMatch[1], 10) : 0;
+                const filters = filterMatch
+                    ? filterMatch[1].match(/["']([^"']+)["']/g)?.map(s => s.replace(/["']/g, "")) ?? []
+                    : [];
+                vectorIndexes.push({ table: viMatch[1], dimensions: dims, filterFields: filters, line: i + 1 });
+                // Check: uncommon dimension size
+                if (dims > 0 && !KNOWN_DIMENSIONS[dims]) {
+                    const nearest = Object.keys(KNOWN_DIMENSIONS)
+                        .map(Number)
+                        .sort((a, b) => Math.abs(a - dims) - Math.abs(b - dims))[0];
+                    issues.push({
+                        severity: "warning",
+                        location: `schema.ts:${i + 1}`,
+                        message: `Vector index "${viMatch[1]}" has ${dims} dimensions — not a standard embedding size. Did you mean ${nearest} (${KNOWN_DIMENSIONS[nearest]})?`,
+                        fix: `Verify your embedding model output size matches ${dims} dimensions`,
+                    });
+                }
+                // Check: no filter fields
+                if (filters.length === 0) {
+                    issues.push({
+                        severity: "info",
+                        location: `schema.ts:${i + 1}`,
+                        message: `Vector index "${viMatch[1]}" has no filterFields. Vector searches will scan all vectors — add filters for better performance.`,
+                        fix: 'Add filterFields: ["field1", "field2"] to narrow vector search scope',
+                    });
+                }
+            }
+            // Check: vector field declared as v.array(v.number()) instead of v.array(v.float64())
+            if (/v\.array\s*\(\s*v\.number\s*\(\s*\)\s*\)/.test(lines[i]) &&
+                /embed|vector|embedding/i.test(lines.slice(Math.max(0, i - 3), i + 1).join("\n"))) {
+                issues.push({
+                    severity: "warning",
+                    location: `schema.ts:${i + 1}`,
+                    message: "Vector field uses v.array(v.number()) — Convex vector search requires v.array(v.float64()) for proper storage.",
+                    fix: "Change to v.array(v.float64()) for vector fields",
+                });
+            }
+        }
+    }
+    // Scan code files for .vectorSearch() usage
+    const files = collectTsFiles(convexDir);
+    let vectorSearchCallCount = 0;
+    for (const filePath of files) {
+        const content = readFileSync(filePath, "utf-8");
+        const relativePath = filePath.replace(convexDir, "").replace(/^[\\/]/, "");
+        const lines = content.split("\n");
+        for (let i = 0; i < lines.length; i++) {
+            const vsMatch = lines[i].match(/\.vectorSearch\s*\(\s*["']([^"']+)["']/);
+            if (vsMatch) {
+                vectorSearchCallCount++;
+                const indexName = vsMatch[1];
+                // Check if the referenced index exists
+                const matchingIdx = vectorIndexes.find(vi => vi.table === indexName);
+                if (!matchingIdx && vectorIndexes.length > 0) {
+                    issues.push({
+                        severity: "critical",
+                        location: `${relativePath}:${i + 1}`,
+                        message: `vectorSearch references index "${indexName}" which is not defined in schema.ts.`,
+                        fix: `Add a .vectorIndex("${indexName}", { ... }) to the appropriate table in schema.ts`,
+                    });
+                }
+                // Check: no filter parameter when filterFields exist
+                const chunk = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                if (matchingIdx && matchingIdx.filterFields.length > 0 && !/filter\s*:/.test(chunk)) {
+                    issues.push({
+                        severity: "info",
+                        location: `${relativePath}:${i + 1}`,
+                        message: `vectorSearch on "${indexName}" doesn't use filter — available filterFields: ${matchingIdx.filterFields.join(", ")}`,
+                        fix: "Add filter parameter to narrow results and improve performance",
+                    });
+                }
+                // Check: hardcoded vector dimensions in code (should match schema)
+                const vecLiteralMatch = chunk.match(/new\s+Float64Array\s*\(\s*(\d+)\s*\)|Array\s*\(\s*(\d+)\s*\)\.fill/);
+                if (vecLiteralMatch && matchingIdx) {
+                    const codeDims = parseInt(vecLiteralMatch[1] || vecLiteralMatch[2], 10);
+                    if (codeDims !== matchingIdx.dimensions && matchingIdx.dimensions > 0) {
+                        issues.push({
+                            severity: "critical",
+                            location: `${relativePath}:${i + 1}`,
+                            message: `Vector dimensions mismatch: code uses ${codeDims} but schema defines ${matchingIdx.dimensions} for index "${indexName}".`,
+                            fix: `Ensure embedding model output (${codeDims}) matches schema dimensions (${matchingIdx.dimensions})`,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    const tablesWithVectors = [...new Set(vectorIndexes.map(vi => vi.table))];
+    const dimensions = [...new Set(vectorIndexes.map(vi => vi.dimensions).filter(d => d > 0))];
+    return {
+        issues,
+        stats: {
+            vectorIndexCount: vectorIndexes.length,
+            vectorSearchCallCount,
+            tablesWithVectors,
+            dimensions,
+        },
+    };
+}
+// ── Tool Definition ─────────────────────────────────────────────────
+export const vectorSearchTools = [
+    {
+        name: "convex_audit_vector_search",
+        description: "Audit Convex vector search implementation: validates vectorIndex dimensions against known embedding models, checks for missing filterFields, v.array(v.float64()) usage, dimension mismatches between schema and code, and undefined index references.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                projectDir: {
+                    type: "string",
+                    description: "Absolute path to the project root containing a convex/ directory",
+                },
+            },
+            required: ["projectDir"],
+        },
+        handler: async (args) => {
+            const projectDir = resolve(args.projectDir);
+            const convexDir = findConvexDir(projectDir);
+            if (!convexDir) {
+                return { error: "No convex/ directory found" };
+            }
+            const { issues, stats } = auditVectorSearch(convexDir);
+            const db = getDb();
+            db.prepare("INSERT INTO audit_results (id, project_dir, audit_type, issues_json, issue_count) VALUES (?, ?, ?, ?, ?)").run(genId("audit"), projectDir, "vector_search", JSON.stringify(issues), issues.length);
+            return {
+                summary: {
+                    ...stats,
+                    totalIssues: issues.length,
+                    critical: issues.filter(i => i.severity === "critical").length,
+                    warnings: issues.filter(i => i.severity === "warning").length,
+                    knownDimensions: KNOWN_DIMENSIONS,
+                },
+                issues: issues.slice(0, 30),
+                quickRef: getQuickRef("convex_audit_vector_search"),
+            };
+        },
+    },
+];
+//# sourceMappingURL=vectorSearchTools.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homenshum/convex-mcp-nodebench",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Convex-specific MCP server applying NodeBench self-instruct diligence patterns to Convex development. Schema audit, function compliance, deployment gates, persistent gotcha DB, and methodology guidance. Complements Context7 (raw docs) and official Convex MCP (deployment introspection) with structured verification workflows.",
   "type": "module",
   "bin": {