nodebench-mcp 2.22.0 → 2.25.0

package/dist/__tests__/tools.test.js

@@ -46,6 +46,8 @@ import { architectTools } from "../tools/architectTools.js";
 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 { 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 = [
@@ -86,6 +88,8 @@ const domainTools = [
     ...uiUxDiveTools,
     ...mcpBridgeTools,
     ...uiUxDiveAdvancedTools,
+    ...skillUpdateTools,
+    ...prReportTools,
 ];
 const metaTools = createMetaTools(domainTools);
 const allToolsWithoutDiscovery = [...domainTools, ...metaTools];
@@ -95,9 +99,9 @@ const allTools = [...allToolsWithoutDiscovery, ...discoveryTools];
 // STATIC LAYER — structure validation
 // ═══════════════════════════════════════════════════════════════════════════
 describe("Static: tool structure", () => {
-    it("should have 175 tools total", () => {
-        // 169 domain tools + 3 meta tools (findTools, getMethodology, check_mcp_setup) + 3 progressive discovery tools
-        expect(allTools.length).toBe(203);
+    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("every tool has name, description, inputSchema, handler", () => {
         for (const tool of allTools) {
@@ -1629,6 +1633,153 @@ 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);
@@ -2817,10 +2968,11 @@ describe("Agent-as-a-Graph: execution trace edges", () => {
             limit: 15,
             explain: true,
         });
-        expect(baseline.length).toBeGreaterThanOrEqual(6);
+        expect(baseline.length).toBeGreaterThanOrEqual(10);
         const topTool = baseline[0].name;
-        const boostTarget = baseline[5].name; // position 6 — NOT in top 5
-        const baselineScore = baseline[5].score;
+        // 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;
         // Step 2: Inject trace edge from top tool → boost target
         _resetCooccurrenceCache();
         const edges = new Map();