@homenshum/convex-mcp-nodebench 0.7.0 → 0.9.0

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.9.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