@homenshum/convex-mcp-nodebench 0.4.0 → 0.4.1

package/dist/tools/critterTools.js

@@ -32,22 +32,26 @@ function scoreCritterCheck(input) {
     const taskLower = input.task.toLowerCase().trim();
     const whyLower = input.why.toLowerCase().trim();
     const whoLower = input.who.toLowerCase().trim();
-    // Check 1: Circular reasoning
+    // Check 1: Circular reasoning (threshold 0.5)
     const taskWords = new Set(taskLower.split(/\s+/).filter((w) => w.length > 3));
     const whyWords = whyLower.split(/\s+/).filter((w) => w.length > 3);
     const overlap = whyWords.filter((w) => taskWords.has(w));
-    if (whyWords.length > 0 && overlap.length / whyWords.length > 0.7) {
+    if (whyWords.length > 0 && overlap.length / whyWords.length > 0.5) {
         score -= 30;
         feedback.push("Circular: your 'why' mostly restates the task. What user outcome does this enable?");
     }
     // Check 2: Vague audience
-    const vagueAudiences = ["users", "everyone", "people", "the team", "stakeholders", "clients"];
+    const vagueAudiences = ["users", "everyone", "people", "the team", "stakeholders", "clients", "customers", "developers"];
     if (vagueAudiences.includes(whoLower)) {
         score -= 20;
         feedback.push(`"${input.who}" is too broad. Which user role or API consumer specifically?`);
     }
-    // Check 3: Too short
-    if (whyLower.length < 10) {
+    // Check 3: Empty or too short
+    if (whyLower.length === 0) {
+        score -= 40;
+        feedback.push("Empty 'why': you haven't stated any purpose at all.");
+    }
+    else if (whyLower.length < 10) {
         score -= 25;
         feedback.push("The 'why' is too short. What problem does this solve?");
     }
@@ -61,6 +65,73 @@ function scoreCritterCheck(input) {
         score -= 15;
         feedback.push("Citing authority instead of understanding purpose. Why does this matter to the product?");
     }
+    // Check 5: Non-answer patterns (count matches, -20 each, cap -40)
+    const nonAnswerPatterns = [
+        "just because", "don't know", "not sure", "why not", "might need it",
+        "no reason", "no idea", "whatever", "idk", "tbd",
+    ];
+    const nonAnswerHits = nonAnswerPatterns.filter((p) => whyLower.includes(p)).length;
+    if (nonAnswerHits > 0) {
+        const nonAnswerPenalty = Math.min(nonAnswerHits * 20, 40);
+        score -= nonAnswerPenalty;
+        feedback.push("Non-answer: your 'why' signals unclear purpose. What specific problem does this solve?");
+    }
+    // Check 6: Repetitive padding (why + who)
+    const whyAllWords = whyLower.split(/\s+/).filter((w) => w.length > 2);
+    if (whyAllWords.length >= 5) {
+        const whyUniqueWords = new Set(whyAllWords);
+        if (whyUniqueWords.size / whyAllWords.length < 0.4) {
+            score -= 25;
+            feedback.push("Repetitive: your 'why' repeats the same words. Articulate distinct reasoning.");
+        }
+    }
+    const whoAllWords = whoLower.split(/\s+/).filter((w) => w.length > 2);
+    if (whoAllWords.length >= 5) {
+        const whoUniqueWords = new Set(whoAllWords);
+        if (whoUniqueWords.size / whoAllWords.length < 0.4) {
+            score -= 25;
+            feedback.push("Repetitive: your 'who' repeats the same words. Name a real audience.");
+        }
+    }
+    // Check 7: Buzzword-heavy corporate-speak (scans why + who)
+    const buzzwords = [
+        "leverage", "synergies", "synergy", "paradigm", "holistic", "alignment",
+        "transformation", "innovative", "disruptive", "best practices",
+        "streamline", "ecosystem", "actionable", "circle back",
+    ];
+    const allText = `${whyLower} ${whoLower}`;
+    const buzzCount = buzzwords.filter((b) => allText.includes(b)).length;
+    if (buzzCount >= 4) {
+        score -= 35;
+        feedback.push("Buzzword-heavy: corporate-speak without concrete meaning. What specific problem does this solve?");
+    }
+    else if (buzzCount >= 3) {
+        score -= 30;
+        feedback.push("Buzzword-heavy: corporate-speak without concrete meaning. What specific problem does this solve?");
+    }
+    else if (buzzCount >= 2) {
+        score -= 20;
+        feedback.push("Buzzword-heavy: corporate-speak without concrete meaning. What specific problem does this solve?");
+    }
+    // Check 8: Hedging language
+    const hedgeWords = ["could", "potentially", "maybe", "possibly", "might", "perhaps", "hopefully"];
+    const hedgeCount = hedgeWords.filter((h) => {
+        const regex = new RegExp(`\\b${h}\\b`, "i");
+        return regex.test(whyLower);
+    }).length;
+    if (hedgeCount >= 2) {
+        score -= 15;
+        feedback.push("Hedging: too many 'could/maybe/potentially' signals uncertain value. Be definitive.");
+    }
+    // Check 9: Task-word echo — same word from task repeated 3+ times in why
+    for (const tw of taskWords) {
+        const twCount = whyWords.filter((w) => w === tw).length;
+        if (twCount >= 3) {
+            score -= 20;
+            feedback.push(`Echo: "${tw}" appears ${twCount} times in your 'why' — this is filler, not reasoning.`);
+            break;
+        }
+    }
     // Bonus for specificity
     if (input.success_looks_like && input.success_looks_like.length > 20) {
         score += 10;

package/dist/tools/integrationBridgeTools.js

@@ -235,9 +235,13 @@ export const integrationBridgeTools = [
                 }
                 catch { /* ignore */ }
             }
+            const parsed = JSON.parse(snapshot.schemaJson);
             return {
                 snapshotId: id,
                 tableCount: snapshot.tableCount,
+                tables: parsed.tables,
+                totalIndexes: parsed.totalIndexes,
+                indexes: parsed.indexes,
                 diff,
                 quickRef: getQuickRef("convex_audit_schema"),
             };

package/dist/tools/methodologyTools.js

@@ -108,7 +108,13 @@ export const methodologyTools = [
             required: ["topic"],
         },
         handler: async (args) => {
-            const content = METHODOLOGY_CONTENT[args.topic];
+            // Default to overview when topic is missing
+            let topic = args.topic || "overview";
+            // Accept short names: "schema_audit" -> "convex_schema_audit"
+            if (!METHODOLOGY_CONTENT[topic] && METHODOLOGY_CONTENT[`convex_${topic}`]) {
+                topic = `convex_${topic}`;
+            }
+            const content = METHODOLOGY_CONTENT[topic];
             if (!content) {
                 return {
                     error: `Unknown topic: ${args.topic}`,
@@ -149,6 +155,7 @@ export const methodologyTools = [
                 matchingTools: results.length,
                 tools: results.map((r) => ({
                     name: r.name,
+                    score: Math.round(r._score * 100) / 100,
                     category: r.category,
                     phase: r.phase,
                     complexity: r.complexity,

package/dist/tools/toolRegistry.d.ts

@@ -2,9 +2,12 @@ import type { ConvexQuickRef, ToolRegistryEntry } from "../types.js";
 export declare const REGISTRY: ToolRegistryEntry[];
 export declare function getQuickRef(toolName: string): ConvexQuickRef | null;
 export declare function getToolsByCategory(category: string): ToolRegistryEntry[];
-export declare function findTools(query: string): ToolRegistryEntry[];
+export interface ScoredToolEntry extends ToolRegistryEntry {
+    _score: number;
+}
+export declare function findTools(query: string): ScoredToolEntry[];
 /**
  * Async wrapper around findTools that fuses BM25 results with embedding RRF
  * when a neural embedding provider is available. Falls back to plain findTools otherwise.
  */
-export declare function findToolsWithEmbedding(query: string): Promise<ToolRegistryEntry[]>;
+export declare function findToolsWithEmbedding(query: string): Promise<ScoredToolEntry[]>;

package/dist/tools/toolRegistry.js

@@ -329,12 +329,11 @@ export function findTools(query) {
             const termIdf = index.idf.get(qt) ?? 0;
             score += termIdf * (termTf * (k1 + 1)) / (termTf + k1 * (1 - b + b * (dl / index.avgDl)));
         }
-        return { entry, score };
+        return { ...entry, _score: score };
     });
     return scored
-        .filter((s) => s.score > 0)
-        .sort((a, b) => b.score - a.score)
-        .map((s) => s.entry);
+        .filter((s) => s._score > 0)
+        .sort((a, b) => b._score - a._score);
 }
 /**
  * Async wrapper around findTools that fuses BM25 results with embedding RRF
@@ -375,6 +374,7 @@ export async function findToolsWithEmbedding(query) {
     }
     return [...allEntries.values()]
         .filter((e) => fusedScores.has(e.name))
-        .sort((a, b) => (fusedScores.get(b.name) ?? 0) - (fusedScores.get(a.name) ?? 0));
+        .sort((a, b) => (fusedScores.get(b.name) ?? 0) - (fusedScores.get(a.name) ?? 0))
+        .map((e) => ({ ...e, _score: fusedScores.get(e.name) ?? 0 }));
 }
 //# sourceMappingURL=toolRegistry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@homenshum/convex-mcp-nodebench",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "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": {