nodebench-mcp 2.25.0 → 2.27.0

package/dist/__tests__/tools.test.js

@@ -47,7 +47,7 @@ import { uiUxDiveTools } from "../tools/uiUxDiveTools.js";
 import { mcpBridgeTools } from "../tools/mcpBridgeTools.js";
 import { uiUxDiveAdvancedTools } from "../tools/uiUxDiveAdvancedTools.js";
 import { skillUpdateTools } from "../tools/skillUpdateTools.js";
-import { prReportTools } from "../tools/prReportTools.js";
+import { overstoryTools } from "../tools/overstoryTools.js";
 import { getQuickRef, hybridSearch, TOOL_REGISTRY, SEARCH_MODES, ALL_REGISTRY_ENTRIES, WORKFLOW_CHAINS, tokenize, buildDenseIndex, getToolComplexity } from "../tools/toolRegistry.js";
 // Assemble all tools like index.ts does
 const domainTools = [
@@ -89,7 +89,7 @@ const domainTools = [
     ...mcpBridgeTools,
     ...uiUxDiveAdvancedTools,
     ...skillUpdateTools,
-    ...prReportTools,
+    ...overstoryTools,
 ];
 const metaTools = createMetaTools(domainTools);
 const allToolsWithoutDiscovery = [...domainTools, ...metaTools];
@@ -99,9 +99,9 @@ const allTools = [...allToolsWithoutDiscovery, ...discoveryTools];
 // STATIC LAYER — structure validation
 // ═══════════════════════════════════════════════════════════════════════════
 describe("Static: tool structure", () => {
-    it("should have 206 domain + 6 meta/discovery = 212 tools total", () => {
-        // 206 domain tools + 3 meta tools (findTools, getMethodology, check_mcp_setup) + 3 progressive discovery tools
-        expect(allTools.length).toBe(212);
+    it("should have 175 tools total", () => {
+        // domain tools + 3 meta tools (findTools, getMethodology, check_mcp_setup) + 3 progressive discovery tools
+        expect(allTools.length).toBe(213);
     });
     it("every tool has name, description, inputSchema, handler", () => {
         for (const tool of allTools) {
@@ -325,7 +325,7 @@ describe("Static: new methodology topics", () => {
         expect(topics).toContain("agent_bootstrap");
         expect(topics).toContain("autonomous_maintenance");
         expect(topics).toContain("parallel_agent_teams");
-        expect(topics.length).toBe(24); // All topics listed in overview
+        expect(topics.length).toBe(26); // All topics listed in overview (includes scenario_testing added v2.26.0)
     });
 });
 describe("Unit: setup_local_env", () => {
@@ -1633,153 +1633,6 @@ describe("Unit: get_workflow_chain", () => {
         expect(result.error).toBe(true);
     });
 });
-// ═══════════════════════════════════════════════════════════════════════
-// MULTI-HOP TRAVERSAL, RELATED TOOLS, PAGINATION & EXPANSION TESTS
-// ═══════════════════════════════════════════════════════════════════════
-describe("Static: relatedTools auto-derivation", () => {
-    it("every registry entry should have relatedTools populated", () => {
-        for (const entry of ALL_REGISTRY_ENTRIES) {
-            expect(entry.quickRef.relatedTools, `Missing relatedTools for ${entry.name}`).toBeDefined();
-            expect(entry.quickRef.relatedTools.length, `Empty relatedTools for ${entry.name}`).toBeGreaterThan(0);
-        }
-    });
-    it("relatedTools should not overlap with nextTools", () => {
-        for (const entry of ALL_REGISTRY_ENTRIES) {
-            const nextSet = new Set(entry.quickRef.nextTools);
-            for (const related of entry.quickRef.relatedTools ?? []) {
-                expect(nextSet.has(related), `${entry.name}: '${related}' appears in both nextTools and relatedTools`).toBe(false);
-            }
-        }
-    });
-    it("relatedTools should not contain self", () => {
-        for (const entry of ALL_REGISTRY_ENTRIES) {
-            expect(entry.quickRef.relatedTools).not.toContain(entry.name);
-        }
-    });
-    it("relatedTools should cap at 7 entries", () => {
-        for (const entry of ALL_REGISTRY_ENTRIES) {
-            expect(entry.quickRef.relatedTools.length, `${entry.name} has too many relatedTools`).toBeLessThanOrEqual(7);
-        }
-    });
-    it("relatedTools should reference valid registry tools", () => {
-        for (const entry of ALL_REGISTRY_ENTRIES) {
-            for (const related of entry.quickRef.relatedTools ?? []) {
-                expect(TOOL_REGISTRY.has(related), `${entry.name} relatedTools references unknown tool: ${related}`).toBe(true);
-            }
-        }
-    });
-});
-describe("Unit: discover_tools pagination", () => {
-    it("should return hasMore when more results available", async () => {
-        const tool = findTool("discover_tools");
-        const result = (await tool.handler({ query: "verify", limit: 3 }));
-        expect(result.hasMore).toBe(true);
-        expect(result.resultCount).toBe(3);
-        expect(result.offset).toBe(0);
-        expect(result.totalMatches).toBeGreaterThan(3);
-    });
-    it("should support offset parameter for paging", async () => {
-        const tool = findTool("discover_tools");
-        const page1 = (await tool.handler({ query: "verify", limit: 3, offset: 0 }));
-        const page2 = (await tool.handler({ query: "verify", limit: 3, offset: 3 }));
-        // Pages should have different results
-        const page1Names = page1.results.map((r) => r.name);
-        const page2Names = page2.results.map((r) => r.name);
-        const overlap = page1Names.filter((n) => page2Names.includes(n));
-        expect(overlap.length).toBe(0);
-    });
-    it("should return hasMore=false when exhausted", async () => {
-        const tool = findTool("discover_tools");
-        const result = (await tool.handler({ query: "very_unique_nonexistent_query_xyz_abc", limit: 10 }));
-        expect(result.hasMore).toBe(false);
-    });
-});
-describe("Unit: discover_tools expansion", () => {
-    it("should expand top results via relatedTools", async () => {
-        const tool = findTool("discover_tools");
-        const withExpand = (await tool.handler({ query: "verify", limit: 20, expand: 3 }));
-        const without = (await tool.handler({ query: "verify", limit: 20 }));
-        // Expansion should discover additional or equal tools
-        expect(withExpand.totalMatches).toBeGreaterThanOrEqual(without.totalMatches);
-    });
-    it("expanded results should have depth and expandedFrom", async () => {
-        const tool = findTool("discover_tools");
-        const result = (await tool.handler({ query: "verify", limit: 30, expand: 3, explain: true }));
-        const expanded = result.results.filter((r) => r.depth && r.depth > 0);
-        // Verify structure of any expanded results
-        for (const r of expanded) {
-            expect(r.expandedFrom).toBeDefined();
-            expect(r.expandedFrom.length).toBeGreaterThan(0);
-        }
-    });
-});
-describe("Unit: get_tool_quick_ref multi-hop", () => {
-    it("depth=1 should return direct neighbors only (hopDistance=1)", async () => {
-        const tool = findTool("get_tool_quick_ref");
-        const result = (await tool.handler({
-            toolName: "start_verification_cycle",
-            includeRelatedDetails: true,
-            depth: 1,
-        }));
-        expect(result.depth).toBe(1);
-        expect(result.relatedToolDetails).toBeDefined();
-        for (const details of Object.values(result.relatedToolDetails)) {
-            expect(details.hopDistance).toBe(1);
-        }
-    });
-    it("depth=2 should discover tools 2 hops away", async () => {
-        const tool = findTool("get_tool_quick_ref");
-        const depth1Result = (await tool.handler({
-            toolName: "start_verification_cycle",
-            includeRelatedDetails: true,
-            depth: 1,
-        }));
-        const depth2Result = (await tool.handler({
-            toolName: "start_verification_cycle",
-            includeRelatedDetails: true,
-            depth: 2,
-        }));
-        // Depth 2 should discover more tools
-        expect(depth2Result.totalDiscovered).toBeGreaterThan(depth1Result.totalDiscovered);
-        // Should have both hop distances
-        const distances = Object.values(depth2Result.relatedToolDetails).map((d) => d.hopDistance);
-        expect(distances).toContain(1);
-        expect(distances).toContain(2);
-    });
-    it("depth > 3 should be capped at 3", async () => {
-        const tool = findTool("get_tool_quick_ref");
-        const result = (await tool.handler({
-            toolName: "start_verification_cycle",
-            includeRelatedDetails: true,
-            depth: 10,
-        }));
-        expect(result.depth).toBe(3);
-        const maxHop = Math.max(...Object.values(result.relatedToolDetails).map((d) => d.hopDistance));
-        expect(maxHop).toBeLessThanOrEqual(3);
-    });
-    it("default depth should be 1 (backward compatible)", async () => {
-        const tool = findTool("get_tool_quick_ref");
-        const result = (await tool.handler({
-            toolName: "run_mandatory_flywheel",
-            includeRelatedDetails: true,
-        }));
-        expect(result.depth).toBe(1);
-        for (const details of Object.values(result.relatedToolDetails)) {
-            expect(details.hopDistance).toBe(1);
-        }
-    });
-    it("each discovered tool should have reachedVia field", async () => {
-        const tool = findTool("get_tool_quick_ref");
-        const result = (await tool.handler({
-            toolName: "start_verification_cycle",
-            depth: 2,
-        }));
-        for (const [, details] of Object.entries(result.relatedToolDetails)) {
-            expect(details.reachedVia).toBeDefined();
-            expect(typeof details.reachedVia).toBe("string");
-        }
-    });
-});
 describe("Static: boilerplate tools", () => {
     it("should include scaffold_nodebench_project and get_boilerplate_status", () => {
         const names = allTools.map((t) => t.name);
@@ -2968,11 +2821,10 @@ describe("Agent-as-a-Graph: execution trace edges", () => {
             limit: 15,
             explain: true,
         });
-        expect(baseline.length).toBeGreaterThanOrEqual(10);
+        expect(baseline.length).toBeGreaterThanOrEqual(6);
         const topTool = baseline[0].name;
-        // Use position 8 (well outside top 5) to avoid tie-boundary issues when corpus changes
-        const boostTarget = baseline[7].name;
-        const baselineScore = baseline[7].score;
+        const boostTarget = baseline[5].name; // position 6 — NOT in top 5
+        const baselineScore = baseline[5].score;
         // Step 2: Inject trace edge from top tool → boost target
         _resetCooccurrenceCache();
         const edges = new Map();