nodebench-mcp 2.11.0 → 2.14.0

package/dist/tools/toolRegistry.js

@@ -1494,6 +1494,336 @@ const REGISTRY_ENTRIES = [
         },
         phase: "meta",
     },
+    // ── Image solver tools (GAIA media lane) ──────────────────────────────
+    {
+        name: "solve_red_green_deviation_average_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "ocr", "statistics", "deviation", "red", "green", "color", "pixel", "media"],
+        quickRef: {
+            nextAction: "Pass the image path. Tool extracts red/green numbers via color masking, computes population/sample std-dev, returns average.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Specify decimals parameter for precision control (default 2).",
+        },
+        phase: "utility",
+    },
+    {
+        name: "solve_green_polygon_area_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "polygon", "area", "green", "geometry", "pixel", "ocr", "media"],
+        quickRef: {
+            nextAction: "Pass the image path. Tool segments green pixels, traces boundary, reads purple labels for scale, computes area via Shoelace formula.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Works best on clean diagrams with distinct green fill and purple numeric labels.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "grade_fraction_quiz_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "ocr", "fractions", "quiz", "grading", "math", "score", "media"],
+        quickRef: {
+            nextAction: "Pass image path and scoring params (bonusPoints, pointsAddSubtract, etc.). Tool OCRs problems, computes correct answers, grades each.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Extracts problem types (add/sub, mul/div, improper, mixed) and scores per type.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "extract_fractions_and_simplify_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "ocr", "fractions", "simplify", "math", "worksheet", "media"],
+        quickRef: {
+            nextAction: "Pass image path. Tool detects slash fractions in body text and stacked fractions in worksheet region, simplifies all via GCD.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Returns comma-separated simplified fractions. Handles both 3/4 and stacked numerator-over-denominator formats.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "solve_bass_clef_age_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "ocr", "music", "bass-clef", "notes", "staff", "media"],
+        quickRef: {
+            nextAction: "Pass image path. Tool detects staff lines, maps note positions to bass-clef letters, forms a word, and derives the age value.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Works on simple single-staff bass-clef images. Upscales small images for robust detection.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "solve_storage_upgrade_cost_per_file_from_image",
+        category: "gaia_solvers",
+        tags: ["image", "ocr", "storage", "pricing", "cost", "upgrade", "media"],
+        quickRef: {
+            nextAction: "Pass image path and plan params (currentPlanName, filesUploaded, overLimitGb, additionalFiles). Tool OCRs pricing table and computes cost/file.",
+            nextTools: ["read_image_ocr_text", "log_test_result"],
+            methodology: "gaia_media_solve",
+            tip: "Detects plan tiers (Standard/Plus/Premium) and their storage limits from the image.",
+        },
+        phase: "utility",
+    },
+    // ═══ SESSION MEMORY (inspired by claude-mem, planning-with-files, oh-my-claudecode) ═══
+    {
+        name: "save_session_note",
+        category: "session_memory",
+        tags: ["note", "save", "persist", "compaction", "memory", "finding", "decision", "progress", "filesystem"],
+        quickRef: {
+            nextAction: "Note saved to filesystem. Continue working — it survives context compaction. Use load_session_notes after /clear to recover.",
+            nextTools: ["load_session_notes", "refresh_task_context", "record_learning"],
+            methodology: "session_recovery",
+            tip: "Call after every major finding or decision. 2-action save rule: save after every 2 web searches.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "load_session_notes",
+        category: "session_memory",
+        tags: ["note", "load", "recover", "compaction", "resume", "session", "filesystem", "context"],
+        quickRef: {
+            nextAction: "Notes loaded. Review findings and decisions, then continue where you left off. Use refresh_task_context for a full context refresher.",
+            nextTools: ["refresh_task_context", "search_all_knowledge", "save_session_note"],
+            methodology: "session_recovery",
+            tip: "Use date='all' to search across sessions. Use keyword filter to find specific topics.",
+        },
+        phase: "research",
+    },
+    {
+        name: "refresh_task_context",
+        category: "session_memory",
+        tags: ["refresh", "context", "attention", "drift", "goal", "focus", "recite", "mid-session", "compaction"],
+        quickRef: {
+            nextAction: "Context refreshed. Re-read the taskDescription and open gaps. Focus on the highest-severity gap first.",
+            nextTools: ["save_session_note", "get_verification_status", "search_all_knowledge"],
+            methodology: "session_recovery",
+            tip: "Call after 30+ tool calls to prevent attention drift. Re-state your original goal in taskDescription.",
+        },
+        phase: "meta",
+    },
+    // ═══ TOON FORMAT ═══
+    {
+        name: "toon_encode",
+        category: "toon",
+        tags: ["toon", "encode", "token", "compress", "serialize", "format", "json", "optimize"],
+        quickRef: {
+            nextAction: "Data encoded to TOON. Pass the toon string to another LLM call or agent for ~40% token savings.",
+            nextTools: ["toon_decode", "save_session_note"],
+            methodology: "toon_format",
+            tip: "Use for large data payloads before LLM calls. Savings compound in iterative workflows.",
+        },
+        phase: "utility",
+    },
+    {
+        name: "toon_decode",
+        category: "toon",
+        tags: ["toon", "decode", "parse", "deserialize", "format", "json"],
+        quickRef: {
+            nextAction: "Data decoded to JSON. Process the result with any standard tool.",
+            nextTools: ["toon_encode"],
+            methodology: "toon_format",
+        },
+        phase: "utility",
+    },
+    // ═══ PATTERN MINING ═══
+    {
+        name: "mine_session_patterns",
+        category: "pattern",
+        tags: ["pattern", "mine", "session", "trajectory", "bigram", "trigram", "sequence", "analytics"],
+        quickRef: {
+            nextAction: "Patterns extracted. Review success rates — high-failure sequences indicate workflow issues. Use predict_risks_from_patterns before your next task.",
+            nextTools: ["predict_risks_from_patterns", "record_learning"],
+            methodology: "self_reinforced_learning",
+            tip: "Run periodically to discover which tool sequences reliably succeed vs fail.",
+        },
+        phase: "meta",
+    },
+    {
+        name: "predict_risks_from_patterns",
+        category: "pattern",
+        tags: ["predict", "risk", "pattern", "failure", "session", "forecast", "gap"],
+        quickRef: {
+            nextAction: "Risk predictions generated. Address high-confidence risks before starting. Use assess_risk for formal risk assessment.",
+            nextTools: ["assess_risk", "search_all_knowledge", "mine_session_patterns"],
+            methodology: "self_reinforced_learning",
+            tip: "Run at the start of every task to catch known failure modes before they bite.",
+        },
+        phase: "research",
+    },
+    // ═══ AGENT MAILBOX ═══
+    {
+        name: "send_agent_message",
+        category: "parallel_agents",
+        tags: ["message", "send", "mailbox", "agent", "handoff", "communication", "blocker"],
+        quickRef: {
+            nextAction: "Message sent. The recipient will see it when they call check_agent_inbox. For urgent blockers, use broadcast_agent_update instead.",
+            nextTools: ["check_agent_inbox", "broadcast_agent_update", "get_parallel_status"],
+            methodology: "parallel_agent_teams",
+        },
+        phase: "implement",
+    },
+    {
+        name: "check_agent_inbox",
+        category: "parallel_agents",
+        tags: ["inbox", "check", "message", "mailbox", "agent", "read", "handoff"],
+        quickRef: {
+            nextAction: "Messages retrieved. Handle blockers first (CRITICAL priority). Task assignments should be claimed with claim_agent_task.",
+            nextTools: ["claim_agent_task", "send_agent_message", "get_parallel_status"],
+            methodology: "parallel_agent_teams",
+            tip: "Call at session start to pick up handoffs and blockers from other agents.",
+        },
+        phase: "research",
+    },
+    {
+        name: "broadcast_agent_update",
+        category: "parallel_agents",
+        tags: ["broadcast", "update", "agent", "status", "announce", "milestone"],
+        quickRef: {
+            nextAction: "Broadcast sent to all agents. Continue your work — others will see it in their inbox.",
+            nextTools: ["get_parallel_status", "send_agent_message"],
+            methodology: "parallel_agent_teams",
+        },
+        phase: "implement",
+    },
+    // ═══ GIT WORKFLOW ═══
+    {
+        name: "check_git_compliance",
+        category: "git_workflow",
+        tags: ["git", "compliance", "branch", "commit", "conventional", "protected"],
+        quickRef: {
+            nextAction: "Git compliance checked. Fix any warnings before proceeding. If on a protected branch, create a feature branch first.",
+            nextTools: ["review_pr_checklist", "enforce_merge_gate", "assess_risk"],
+            methodology: "verification",
+            tip: "Run before starting work to ensure you're on the right branch with clean state.",
+        },
+        phase: "verify",
+    },
+    {
+        name: "review_pr_checklist",
+        category: "git_workflow",
+        tags: ["pr", "pull-request", "review", "checklist", "merge", "code-review"],
+        quickRef: {
+            nextAction: "PR checklist evaluated. Address failing items. If verificationCycleId provided, cross-references NodeBench verification status.",
+            nextTools: ["enforce_merge_gate", "run_quality_gate", "record_learning"],
+        },
+        phase: "verify",
+    },
+    {
+        name: "enforce_merge_gate",
+        category: "git_workflow",
+        tags: ["merge", "gate", "pre-merge", "validation", "branch", "deploy"],
+        quickRef: {
+            nextAction: "Merge gate evaluated. If canMerge=false, resolve all blockingIssues before merging.",
+            nextTools: ["check_git_compliance", "run_quality_gate", "run_mandatory_flywheel"],
+            methodology: "verification",
+            tip: "Enable requireVerification and requireTests for maximum safety.",
+        },
+        phase: "ship",
+    },
+    // ═══ SEO ═══
+    {
+        name: "seo_audit_url",
+        category: "seo",
+        tags: ["seo", "audit", "meta", "title", "description", "og", "heading", "structured-data"],
+        quickRef: {
+            nextAction: "SEO audit complete. Address low-scoring elements first. Use analyze_seo_content for deeper content analysis.",
+            nextTools: ["analyze_seo_content", "check_page_performance", "check_wordpress_site"],
+            methodology: "seo_audit",
+        },
+        phase: "verify",
+    },
+    {
+        name: "check_page_performance",
+        category: "seo",
+        tags: ["performance", "speed", "response-time", "compression", "cache", "lighthouse"],
+        quickRef: {
+            nextAction: "Performance checked. Enable compression and caching if missing. For deeper analysis, use browser dev tools.",
+            nextTools: ["seo_audit_url", "record_learning"],
+            methodology: "seo_audit",
+        },
+        phase: "verify",
+    },
+    {
+        name: "analyze_seo_content",
+        category: "seo",
+        tags: ["content", "readability", "keyword", "density", "flesch-kincaid", "headings", "links"],
+        quickRef: {
+            nextAction: "Content analyzed. Target readability score 60-80. Keyword density 0.5-3% is optimal.",
+            nextTools: ["seo_audit_url", "record_learning"],
+            methodology: "seo_audit",
+        },
+        phase: "verify",
+    },
+    {
+        name: "check_wordpress_site",
+        category: "seo",
+        tags: ["wordpress", "wp", "security", "login", "xmlrpc", "plugin", "theme"],
+        quickRef: {
+            nextAction: "WordPress check complete. Address security risks (xmlrpc, exposed login) immediately. Use scan_wordpress_updates for vulnerability details.",
+            nextTools: ["scan_wordpress_updates", "seo_audit_url", "record_learning"],
+            methodology: "seo_audit",
+        },
+        phase: "verify",
+    },
+    {
+        name: "scan_wordpress_updates",
+        category: "seo",
+        tags: ["wordpress", "plugin", "theme", "vulnerability", "wpscan", "update", "cve"],
+        quickRef: {
+            nextAction: "WordPress scan complete. Update plugins with known vulnerabilities immediately. Provide wpscanApiToken for full vulnerability data.",
+            nextTools: ["check_wordpress_site", "record_learning"],
+            methodology: "seo_audit",
+        },
+        phase: "verify",
+    },
+    // ═══ VOICE BRIDGE ═══
+    {
+        name: "design_voice_pipeline",
+        category: "voice_bridge",
+        tags: ["voice", "pipeline", "stt", "tts", "architecture", "design", "latency", "whisper", "deepgram"],
+        quickRef: {
+            nextAction: "Pipeline designed. Review the recommended stack. Use analyze_voice_config to validate compatibility, then generate_voice_scaffold for starter code.",
+            nextTools: ["analyze_voice_config", "generate_voice_scaffold", "benchmark_voice_latency"],
+            methodology: "voice_bridge",
+        },
+        phase: "research",
+    },
+    {
+        name: "analyze_voice_config",
+        category: "voice_bridge",
+        tags: ["voice", "config", "validate", "compatibility", "cost", "bottleneck"],
+        quickRef: {
+            nextAction: "Config analyzed. Address compatibility issues and bottlenecks. Use benchmark_voice_latency to compare alternatives.",
+            nextTools: ["benchmark_voice_latency", "generate_voice_scaffold", "design_voice_pipeline"],
+            methodology: "voice_bridge",
+        },
+        phase: "research",
+    },
+    {
+        name: "generate_voice_scaffold",
+        category: "voice_bridge",
+        tags: ["voice", "scaffold", "code", "template", "whisper", "deepgram", "webspeech", "piper"],
+        quickRef: {
+            nextAction: "Scaffold generated. Write files to disk, install dependencies, and test the pipeline. Use run_closed_loop for build verification.",
+            nextTools: ["run_closed_loop", "log_test_result", "record_learning"],
+            methodology: "voice_bridge",
+        },
+        phase: "implement",
+    },
+    {
+        name: "benchmark_voice_latency",
+        category: "voice_bridge",
+        tags: ["voice", "benchmark", "latency", "comparison", "performance", "streaming"],
+        quickRef: {
+            nextAction: "Latency benchmarked. Pick the config rated 'excellent' or 'good'. Use generate_voice_scaffold with the winning stack.",
+            nextTools: ["generate_voice_scaffold", "design_voice_pipeline", "record_learning"],
+            methodology: "voice_bridge",
+        },
+        phase: "research",
+    },
 ];
 // ── Exported lookup structures ───────────────────────────────────────────
 /** Map of tool name → registry entry for O(1) lookup */
@@ -1512,6 +1842,108 @@ export function getToolsByCategory(category) {
 export function getToolsByPhase(phase) {
     return REGISTRY_ENTRIES.filter((e) => e.phase === phase);
 }
+// ── Model-tier complexity routing ─────────────────────────────────────────
+/** Default complexity by category (tools can override via the complexity field) */
+const CATEGORY_COMPLEXITY = {
+    verification: "medium",
+    eval: "medium",
+    quality_gate: "medium",
+    learning: "low",
+    flywheel: "medium",
+    reconnaissance: "medium",
+    ui_capture: "medium",
+    vision: "high",
+    local_file: "low",
+    web: "medium",
+    github: "medium",
+    documentation: "medium",
+    bootstrap: "medium",
+    self_eval: "high",
+    parallel_agents: "medium",
+    llm: "high",
+    security: "medium",
+    platform: "medium",
+    research_writing: "high",
+    flicker_detection: "high",
+    figma_flow: "high",
+    boilerplate: "low",
+    benchmark: "high",
+    progressive_discovery: "low",
+    meta: "low",
+    session_memory: "low",
+    gaia_solvers: "high",
+    toon: "low",
+    pattern: "medium",
+    git_workflow: "medium",
+    seo: "medium",
+    voice_bridge: "medium",
+};
+/** Per-tool complexity overrides (when category default is wrong) */
+const TOOL_COMPLEXITY_OVERRIDES = {
+    // Verification: logging is low
+    log_phase_findings: "low",
+    log_gap: "low",
+    resolve_gap: "low",
+    log_test_result: "low",
+    get_verification_status: "low",
+    list_verification_cycles: "low",
+    // Eval: recording is low, comparison is high
+    record_eval_result: "low",
+    list_eval_runs: "low",
+    compare_eval_runs: "high",
+    // Quality gate
+    get_gate_history: "low",
+    get_gate_preset: "low",
+    // Flywheel
+    get_flywheel_status: "low",
+    // Recon
+    log_recon_finding: "low",
+    get_recon_summary: "low",
+    // Self-eval: logging is low
+    log_tool_call: "low",
+    cleanup_stale_runs: "low",
+    // Parallel: simple operations are low
+    claim_agent_task: "low",
+    release_agent_task: "low",
+    get_parallel_status: "low",
+    get_agent_role: "low",
+    log_context_budget: "low",
+    list_agent_tasks: "low",
+    // Bootstrap
+    get_project_context: "low",
+    // Local file: image/audio processing is medium/high
+    read_image_ocr_text: "medium",
+    transcribe_audio_file: "medium",
+    extract_structured_data: "medium",
+    solve_red_green_deviation_average_from_image: "high",
+    solve_green_polygon_area_from_image: "high",
+    grade_fraction_quiz_from_image: "high",
+    extract_fractions_and_simplify_from_image: "high",
+    solve_bass_clef_age_from_image: "high",
+    solve_storage_upgrade_cost_per_file_from_image: "high",
+    // Web
+    fetch_url: "low",
+    // GitHub
+    search_github: "low",
+    // Boilerplate
+    get_boilerplate_status: "low",
+    // Benchmark
+    log_benchmark_milestone: "low",
+};
+/** Get the recommended model complexity tier for a tool */
+export function getToolComplexity(toolName) {
+    // 1. Check per-tool override
+    if (TOOL_COMPLEXITY_OVERRIDES[toolName])
+        return TOOL_COMPLEXITY_OVERRIDES[toolName];
+    // 2. Check explicit field on registry entry
+    const entry = TOOL_REGISTRY.get(toolName);
+    if (entry?.complexity)
+        return entry.complexity;
+    // 3. Fall back to category default
+    if (entry)
+        return CATEGORY_COMPLEXITY[entry.category] ?? "medium";
+    return "medium";
+}
 // ── Synonym / semantic expansion map ──────────────────────────────────────
 const SYNONYM_MAP = {
     verify: ["validate", "check", "confirm", "test", "assert", "ensure"],
@@ -2232,6 +2664,28 @@ export const WORKFLOW_CHAINS = {
             { tool: "record_learning", action: "Step 10: Bank findings — which tools, gates, and knowledge types contributed most" },
         ],
     },
+    session_recovery: {
+        name: "Session Recovery (Post-Compaction)",
+        description: "Recover state after context compaction, /clear, or session resume. Loads filesystem notes, refreshes task context, and continues where you left off.",
+        steps: [
+            { tool: "load_session_notes", action: "Step 1: Load today's session notes from filesystem" },
+            { tool: "refresh_task_context", action: "Step 2: Re-inject active verification cycle, open gaps, and recent learnings" },
+            { tool: "search_all_knowledge", action: "Step 3: Search for relevant prior findings" },
+            { tool: "get_verification_status", action: "Step 4: Check progress on active verification cycle" },
+            { tool: "get_parallel_status", action: "Step 5: Check if other agents are working (parallel scenarios)" },
+            { tool: "save_session_note", action: "Step 6: Save a 'session resumed' note with current state" },
+        ],
+    },
+    attention_refresh: {
+        name: "Attention Refresh (Mid-Session)",
+        description: "Combat attention drift after 30+ tool calls. Re-injects original goals, checks for drift, and re-anchors focus. Based on Manus 'Manipulate Attention Through Recitation' principle.",
+        steps: [
+            { tool: "refresh_task_context", action: "Step 1: Re-inject current goals, open gaps, and session stats" },
+            { tool: "save_session_note", action: "Step 2: Save progress checkpoint before continuing" },
+            { tool: "get_verification_status", action: "Step 3: Check which phases remain" },
+            { tool: "search_all_knowledge", action: "Step 4: Re-check learnings for current phase" },
+        ],
+    },
     task_bank_setup: {
         name: "Task Bank Setup (50-Task Starter Kit)",
         description: "Build a statistically meaningful task bank for agent evaluation. Covers 7 categories (bugfix/refactor/integration/ui/security/performance/migration) × 4 difficulty levels with deterministic grading criteria.",
@@ -2247,5 +2701,40 @@ export const WORKFLOW_CHAINS = {
             { tool: "record_learning", action: "Step 9: Record task bank design patterns for future expansion" },
         ],
     },
+    pr_review: {
+        name: "Pull Request Review",
+        description: "Structured PR review with git compliance, verification cross-reference, and merge gate",
+        steps: [
+            { tool: "check_git_compliance", action: "Verify branch state and commit conventions" },
+            { tool: "review_pr_checklist", action: "Run structured PR checklist with verification cross-reference" },
+            { tool: "run_quality_gate", action: "Validate against quality rules" },
+            { tool: "enforce_merge_gate", action: "Pre-merge validation combining all checks" },
+            { tool: "record_learning", action: "Record PR patterns and review feedback" },
+        ],
+    },
+    seo_audit: {
+        name: "Full SEO Audit",
+        description: "End-to-end SEO audit: technical SEO, content analysis, performance, WordPress security",
+        steps: [
+            { tool: "seo_audit_url", action: "Analyze meta tags, headings, images, structured data" },
+            { tool: "analyze_seo_content", action: "Check readability, keyword density, link ratios" },
+            { tool: "check_page_performance", action: "Measure response time, compression, caching" },
+            { tool: "check_wordpress_site", action: "Detect WordPress, assess security posture" },
+            { tool: "scan_wordpress_updates", action: "Check plugins/themes for known vulnerabilities" },
+            { tool: "record_learning", action: "Record SEO patterns and findings" },
+        ],
+    },
+    voice_pipeline: {
+        name: "Voice Pipeline Implementation",
+        description: "Design, validate, scaffold, and benchmark a voice interface",
+        steps: [
+            { tool: "design_voice_pipeline", action: "Get architecture recommendation based on requirements" },
+            { tool: "analyze_voice_config", action: "Validate component compatibility and estimate costs" },
+            { tool: "benchmark_voice_latency", action: "Compare pipeline configurations side-by-side" },
+            { tool: "generate_voice_scaffold", action: "Generate starter code for chosen stack" },
+            { tool: "run_closed_loop", action: "Build and test the scaffold" },
+            { tool: "record_learning", action: "Record voice pipeline implementation patterns" },
+        ],
+    },
 };
 //# sourceMappingURL=toolRegistry.js.map