nodebench-mcp 2.22.0 → 2.25.0

package/dist/tools/toolRegistry.js

@@ -2070,6 +2070,18 @@ const REGISTRY_ENTRIES = [
         },
         phase: "research",
     },
+    {
+        name: "ingest_dive_screenshots",
+        category: "ui_ux_dive",
+        tags: ["ui", "screenshot", "ingest", "import", "bulk", "png", "jpg", "gallery", "dive", "disk", "file"],
+        quickRef: {
+            nextAction: "Screenshots ingested into session DB. View them in the dashboard gallery or reference in dive_changelog entries.",
+            nextTools: ["dive_changelog", "get_dive_report", "open_dive_dashboard"],
+            methodology: "agentic_vision",
+            tip: "Use after external Playwright MCP captures screenshots to disk. Scans directory recursively, base64-encodes, and inserts into the session DB for dashboard display.",
+        },
+        phase: "utility",
+    },
     // ═══════════════════════════════════════════
     // UI/UX DIVE V2 — Deep interaction testing,
     // screenshots, design audit, backend links,
@@ -2235,6 +2247,92 @@ const REGISTRY_ENTRIES = [
         },
         phase: "ship",
     },
+    {
+        name: "open_dive_dashboard",
+        category: "ui_ux_dive_v2",
+        tags: ["ui", "dashboard", "dive", "flywheel", "browser", "local", "report", "overview", "session", "open", "visualization"],
+        quickRef: {
+            nextAction: "Dashboard is open. Continue the dive — the dashboard auto-refreshes every 5s to show live progress.",
+            nextTools: ["start_ui_dive", "dive_auto_discover", "dive_code_locate", "dive_fix_verify"],
+            methodology: "agentic_vision",
+            tip: "Opens a local web dashboard (port 6274) showing the full flywheel cycle: routes, components, bugs, fixes, tests, reviews. Like Serena MCP's local page but for UI dives.",
+        },
+        phase: "utility",
+    },
+    // ═══════════════════════════════════════════
+    // SKILL SELF-UPDATE PROTOCOL — Track rule
+    // file provenance, staleness, and resync
+    // ═══════════════════════════════════════════
+    {
+        name: "register_skill",
+        category: "skill_update",
+        tags: ["skill", "rule", "register", "source", "hash", "frontmatter", "provenance", "memory", "agents-md", "cursor", "windsurf", "update", "reexamine", "related_"],
+        quickRef: {
+            nextAction: "Skill registered. Use check_skill_freshness periodically to detect when source files change.",
+            nextTools: ["check_skill_freshness", "list_skills"],
+            methodology: "self_reinforced_learning",
+            tip: "Register every .md rule file (e.g. .windsurf/rules/, AGENTS.md) with its source files, triggers, and update instructions. Enables automatic staleness detection.",
+        },
+        phase: "verify",
+    },
+    {
+        name: "check_skill_freshness",
+        category: "skill_update",
+        tags: ["skill", "freshness", "stale", "hash", "check", "drift", "source", "detect", "sync", "update", "rule"],
+        quickRef: {
+            nextAction: "If stale skills found, follow their update_instructions then call sync_skill to record the resync.",
+            nextTools: ["sync_skill", "list_skills", "register_skill"],
+            methodology: "self_reinforced_learning",
+            tip: "Run at session start or after big code changes. Compares SHA-256 hashes of source files to detect drift. Auto-updates skill status in DB.",
+        },
+        phase: "verify",
+    },
+    {
+        name: "sync_skill",
+        category: "skill_update",
+        tags: ["skill", "sync", "resync", "update", "hash", "refresh", "frontmatter", "rule", "source", "stale"],
+        quickRef: {
+            nextAction: "Skill synced. Verify the updated skill file is correct, then continue with your task.",
+            nextTools: ["check_skill_freshness", "list_skills"],
+            methodology: "self_reinforced_learning",
+            tip: "Call AFTER you have read the changed source files and updated the skill .md content. This tool records the sync and updates the hash.",
+        },
+        phase: "verify",
+    },
+    {
+        name: "list_skills",
+        category: "skill_update",
+        tags: ["skill", "list", "status", "overview", "rule", "memory", "history", "sync", "fresh", "stale"],
+        quickRef: {
+            nextAction: "Review skill statuses. Register any untracked rule files, check freshness for stale ones.",
+            nextTools: ["register_skill", "check_skill_freshness", "sync_skill"],
+            methodology: "self_reinforced_learning",
+            tip: "Use includeHistory:true to see the full sync timeline for each skill. Filter by status:'stale' to focus on what needs updating.",
+        },
+        phase: "utility",
+    },
+    // ═══════════════════════════════════════════
+    // RE-EXAMINE 11/10 — Fresh-eyes quality pass
+    // Modular rules: reexamine_process → a11y,
+    // resilience, polish, keyboard, performance
+    // Cross-ref via related_ frontmatter hops
+    // ═══════════════════════════════════════════
+    // NOTE: These are not MCP tools — they are rule
+    // files in .cursor/rules/ and .windsurf/rules/.
+    // The skill_update tools above (register_skill,
+    // check_skill_freshness) track their freshness.
+    // The related_ field in each rule's frontmatter
+    // enables one-hop and two-hop cross-referencing:
+    //
+    //   reexamine_process
+    //     └─ related_: [a11y, resilience, polish, keyboard, performance]
+    //          └─ reexamine_a11y.related_: [keyboard, polish, process]
+    //          └─ reexamine_resilience.related_: [performance, process, polish]
+    //          └─ reexamine_polish.related_: [a11y, performance, process]
+    //          └─ reexamine_keyboard.related_: [a11y, process]
+    //          └─ reexamine_performance.related_: [resilience, polish, process]
+    //
+    // Two-hop example: process → a11y → keyboard (discovers keyboard via a11y)
     // ═══════════════════════════════════════════
     // MCP BRIDGE — Connect external MCP servers
     // ═══════════════════════════════════════════
@@ -2333,12 +2431,155 @@ const REGISTRY_ENTRIES = [
         },
         phase: "implement",
     },
+    // ═══════════════════════════════════════════
+    // PR REPORT — Visual PR creation from dives
+    // ═══════════════════════════════════════════
+    {
+        name: "generate_pr_report",
+        category: "pr_report",
+        tags: ["pr", "pull-request", "report", "markdown", "visual", "screenshot", "before-after", "timeline", "changelog", "dive", "github", "review", "evidence"],
+        quickRef: {
+            nextAction: "PR report generated. Use the markdown with `gh pr create --body-file` or call create_visual_pr for end-to-end PR creation.",
+            nextTools: ["create_visual_pr", "export_pr_screenshots", "review_pr_checklist"],
+            methodology: "agentic_vision",
+            tip: "Pass asset_dir to export screenshots as PNGs that can be committed alongside the PR.",
+        },
+        phase: "ship",
+    },
+    {
+        name: "export_pr_screenshots",
+        category: "pr_report",
+        tags: ["pr", "screenshot", "export", "png", "before-after", "visual", "evidence", "assets", "commit", "dive", "changelog", "fix"],
+        quickRef: {
+            nextAction: "Screenshots exported. Stage and commit them, then use generate_pr_report or create_visual_pr to reference them in the PR body.",
+            nextTools: ["generate_pr_report", "create_visual_pr"],
+            methodology: "agentic_vision",
+            tip: "Naming convention: {index}-{type}-before.png / after.png. Commit these with your branch.",
+        },
+        phase: "ship",
+    },
+    {
+        name: "create_visual_pr",
+        category: "pr_report",
+        tags: ["pr", "pull-request", "create", "github", "gh", "visual", "screenshot", "end-to-end", "push", "merge", "review", "dive", "timeline", "evidence"],
+        quickRef: {
+            nextAction: "PR created! Share the URL with reviewers. The PR body contains visual evidence and dashboard links for interactive browsing.",
+            nextTools: ["review_pr_checklist", "enforce_merge_gate"],
+            methodology: "agentic_vision",
+            tip: "Set draft:true for WIP PRs. Combines export_pr_screenshots + generate_pr_report + gh pr create in one call.",
+        },
+        phase: "ship",
+    },
 ];
 // ── Exported lookup structures ───────────────────────────────────────────
 /** Map of tool name → registry entry for O(1) lookup */
 export const TOOL_REGISTRY = new Map(REGISTRY_ENTRIES.map((e) => [e.name, e]));
 /** All registry entries as array */
 export const ALL_REGISTRY_ENTRIES = REGISTRY_ENTRIES;
+// ── Auto-derive relatedTools for entries that don't have manual overrides ──
+// Uses 3 signals: same-category siblings, DOMAIN_CLUSTERS neighbors, tag overlap.
+// Must run after REGISTRY_ENTRIES is fully built. Forward-reference to DOMAIN_CLUSTERS
+// is fine because this runs at module load time (DOMAIN_CLUSTERS is defined below).
+/** Late-init: populated by _populateRelatedTools() at bottom of file */
+let _domainClusters = null;
+export function _setDomainClustersRef(clusters) {
+    _domainClusters = clusters;
+}
+function computeRelatedTools(entry) {
+    // If manually specified, use that
+    if (entry.quickRef.relatedTools && entry.quickRef.relatedTools.length > 0) {
+        return entry.quickRef.relatedTools;
+    }
+    const related = new Set();
+    const nextToolsSet = new Set(entry.quickRef.nextTools);
+    // 1. Same-category siblings (excluding self and nextTools), up to 3
+    let sibCount = 0;
+    for (const e of REGISTRY_ENTRIES) {
+        if (sibCount >= 3)
+            break;
+        if (e.category === entry.category && e.name !== entry.name && !nextToolsSet.has(e.name)) {
+            related.add(e.name);
+            sibCount++;
+        }
+    }
+    // 2. DOMAIN_CLUSTERS neighbors: tools from related categories, up to 2
+    if (_domainClusters) {
+        let clusterCount = 0;
+        for (const cluster of Object.values(_domainClusters)) {
+            if (clusterCount >= 2)
+                break;
+            if (cluster.includes(entry.category)) {
+                for (const neighborCat of cluster) {
+                    if (clusterCount >= 2)
+                        break;
+                    if (neighborCat === entry.category)
+                        continue;
+                    for (const e of REGISTRY_ENTRIES) {
+                        if (e.category === neighborCat && !nextToolsSet.has(e.name) && !related.has(e.name)) {
+                            related.add(e.name);
+                            clusterCount++;
+                            break; // one tool per neighbor category
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 3. Tag overlap: tools sharing 2+ tags (not in nextTools or already related), up to 2
+    const myTags = new Set(entry.tags);
+    let tagCount = 0;
+    for (const other of REGISTRY_ENTRIES) {
+        if (tagCount >= 2)
+            break;
+        if (other.name === entry.name || nextToolsSet.has(other.name) || related.has(other.name))
+            continue;
+        let overlap = 0;
+        for (const t of other.tags) {
+            if (myTags.has(t))
+                overlap++;
+            if (overlap >= 2)
+                break;
+        }
+        if (overlap >= 2) {
+            related.add(other.name);
+            tagCount++;
+        }
+    }
+    // 4. Fallback: if still empty (small category, all siblings in nextTools), accept 1-tag overlap
+    if (related.size === 0) {
+        for (const other of REGISTRY_ENTRIES) {
+            if (related.size >= 3)
+                break;
+            if (other.name === entry.name || nextToolsSet.has(other.name))
+                continue;
+            const hasTagOverlap = other.tags.some((t) => myTags.has(t));
+            if (hasTagOverlap) {
+                related.add(other.name);
+            }
+        }
+    }
+    // 5. Last resort: if STILL empty, pick tools from the same phase (workflow adjacency)
+    if (related.size === 0) {
+        for (const other of REGISTRY_ENTRIES) {
+            if (related.size >= 3)
+                break;
+            if (other.name === entry.name || nextToolsSet.has(other.name))
+                continue;
+            if (other.phase === entry.phase) {
+                related.add(other.name);
+            }
+        }
+    }
+    return [...related].slice(0, 7); // hard cap at 7
+}
+/** Populate relatedTools for all registry entries. Called once at module load after DOMAIN_CLUSTERS exists. */
+export function _populateRelatedTools() {
+    for (const entry of REGISTRY_ENTRIES) {
+        if (!entry.quickRef.relatedTools || entry.quickRef.relatedTools.length === 0) {
+            entry.quickRef.relatedTools = computeRelatedTools(entry);
+        }
+    }
+}
 /** Get quick ref for a tool, with fallback for unregistered tools */
 export function getQuickRef(toolName) {
     return TOOL_REGISTRY.get(toolName)?.quickRef ?? null;
@@ -2390,6 +2631,7 @@ const CATEGORY_COMPLEXITY = {
     email: "medium",
     rss: "low",
     architect: "low",
+    pr_report: "medium",
 };
 /** Per-tool complexity overrides (when category default is wrong) */
 const TOOL_COMPLEXITY_OVERRIDES = {
@@ -2668,6 +2910,9 @@ const DOMAIN_CLUSTERS = {
     writing: ["research_writing", "documentation"],
     measurement: ["eval", "benchmark", "self_eval"],
 };
+// Wire up domain clusters and auto-populate relatedTools for all registry entries
+_setDomainClustersRef(DOMAIN_CLUSTERS);
+_populateRelatedTools();
 // ── Execution trace edges — co-occurrence mining from tool_call_log ────────
 // Based on Agent-as-a-Graph (arxiv:2511.18194): execution trace edges
 // mine sequential co-occurrence patterns to discover implicit tool relationships.
@@ -2708,17 +2953,36 @@ export function _setDbAccessor(accessor) {
  *
  * Approach: for each session, pull the ordered tool sequence, then count
  * pairs within a sliding window of 5 calls. O(n) per session, no self-join.
+ *
+ * When transitive=true, infer A→C via A→B + B→C (two-hop co-occurrence).
+ * Extended cap of 15 edges/tool (vs 10 for direct-only).
  */
-function getCooccurrenceEdges() {
+let _transitiveCooccurrenceCache = null;
+let _transitiveCooccurrenceCacheTime = 0;
+function getCooccurrenceEdges(options) {
+    const transitive = options?.transitive ?? false;
     const now = Date.now();
-    if (_cooccurrenceCache && now - _cooccurrenceCacheTime < COOCCURRENCE_TTL_MS) {
-        return _cooccurrenceCache;
+    // Check appropriate cache
+    if (transitive) {
+        if (_transitiveCooccurrenceCache && now - _transitiveCooccurrenceCacheTime < COOCCURRENCE_TTL_MS) {
+            return _transitiveCooccurrenceCache;
+        }
+    }
+    else {
+        if (_cooccurrenceCache && now - _cooccurrenceCacheTime < COOCCURRENCE_TTL_MS) {
+            return _cooccurrenceCache;
+        }
     }
-    const edges = new Map();
+    // Build direct edges first (always needed)
+    const directEdges = new Map();
     if (!_dbAccessor) {
-        _cooccurrenceCache = edges;
+        _cooccurrenceCache = directEdges;
         _cooccurrenceCacheTime = now;
-        return edges;
+        if (transitive) {
+            _transitiveCooccurrenceCache = directEdges;
+            _transitiveCooccurrenceCacheTime = now;
+        }
+        return directEdges;
     }
     try {
         const db = _dbAccessor();
@@ -2759,24 +3023,51 @@ function getCooccurrenceEdges() {
             .sort((a, b) => b[1] - a[1]);
         for (const [key] of sorted) {
             const [toolA, toolB] = key.split("\0");
-            const list = edges.get(toolA) ?? [];
+            const list = directEdges.get(toolA) ?? [];
             if (list.length < 10) {
                 list.push(toolB);
-                edges.set(toolA, list);
+                directEdges.set(toolA, list);
             }
         }
     }
     catch {
         // No DB or table not yet created — return empty (graceful degradation)
     }
-    _cooccurrenceCache = edges;
+    // Cache direct edges
+    _cooccurrenceCache = directEdges;
     _cooccurrenceCacheTime = now;
-    return edges;
+    if (!transitive)
+        return directEdges;
+    // Transitive inference: A→B and B→C ⟹ A→C (two-hop)
+    const transitiveEdges = new Map([...directEdges.entries()].map(([k, v]) => [k, [...v]]));
+    for (const [toolA, directNeighbors] of directEdges) {
+        const existingSet = new Set(directNeighbors);
+        existingSet.add(toolA); // avoid self-loops
+        for (const toolB of directNeighbors) {
+            const bNeighbors = directEdges.get(toolB);
+            if (!bNeighbors)
+                continue;
+            const list = transitiveEdges.get(toolA);
+            for (const toolC of bNeighbors) {
+                if (existingSet.has(toolC))
+                    continue;
+                if (list.length >= 15)
+                    break; // extended cap for transitive
+                list.push(toolC);
+                existingSet.add(toolC);
+            }
+        }
+    }
+    _transitiveCooccurrenceCache = transitiveEdges;
+    _transitiveCooccurrenceCacheTime = now;
+    return transitiveEdges;
 }
 /** Reset co-occurrence cache — for testing only. */
 export function _resetCooccurrenceCache() {
     _cooccurrenceCache = null;
     _cooccurrenceCacheTime = 0;
+    _transitiveCooccurrenceCache = null;
+    _transitiveCooccurrenceCacheTime = 0;
 }
 /** Inject co-occurrence edges directly — for testing only. */
 export function _setCooccurrenceForTesting(edges) {
@@ -3168,7 +3459,8 @@ export function hybridSearch(query, tools, options) {
         });
     }
     results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
+    const offset = options?.offset ?? 0;
+    return results.slice(offset, offset + limit);
 }
 /** Available search modes for discover_tools */
 export const SEARCH_MODES = ["hybrid", "fuzzy", "regex", "prefix", "semantic", "exact", "dense", "embedding"];
@@ -3532,5 +3824,17 @@ export const WORKFLOW_CHAINS = {
             { tool: "save_session_note", action: "Log sent emails so you have an audit trail that survives compaction" },
         ],
     },
+    pr_creation: {
+        name: "Visual PR Creation",
+        description: "Create a PR with visual evidence from a UI Dive session — screenshots, timeline, bug fixes, past session links",
+        steps: [
+            { tool: "get_dive_report", action: "Review the dive findings and health score before creating PR" },
+            { tool: "export_pr_screenshots", action: "Export before/after screenshot pairs to a directory for committing" },
+            { tool: "generate_pr_report", action: "Generate rich markdown PR body with visual evidence, timeline, and past session links" },
+            { tool: "create_visual_pr", action: "End-to-end PR creation: exports assets, generates markdown, pushes branch, creates GitHub PR" },
+            { tool: "review_pr_checklist", action: "Validate the PR against the checklist (title, description, tests, verification)" },
+            { tool: "enforce_merge_gate", action: "Pre-merge validation — git state, quality gates, verification cycles" },
+        ],
+    },
 };
 //# sourceMappingURL=toolRegistry.js.map