nodebench-mcp 1.0.0

package/README.md

@@ -0,0 +1,237 @@
+# NodeBench MCP Server
+
+A fully local, zero-config MCP server with 46 tools for AI-powered development workflows.
+
+**Features:**
+- Web search (Gemini/OpenAI/Perplexity)
+- GitHub repository discovery and analysis
+- Job market research
+- AGENTS.md self-maintenance
+- AI vision for screenshot analysis
+- 6-phase verification flywheel
+- SQLite-backed learning database
+
+## Quick Start (1 minute)
+
+### 1. Add to Claude Code settings
+
+Add to `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "nodebench": {
+      "command": "npx",
+      "args": ["-y", "nodebench-mcp"]
+    }
+  }
+}
+```
+
+That's it. Restart Claude Code and you have 46 tools.
+
+---
+
+## Alternative: Build from source
+
+```bash
+git clone https://github.com/nodebench/nodebench-ai.git
+cd nodebench-ai/packages/mcp-local
+npm install && npm run build
+```
+
+Then use absolute path in settings:
+
+```json
+{
+  "mcpServers": {
+    "nodebench": {
+      "command": "node",
+      "args": ["/path/to/packages/mcp-local/dist/index.js"]
+    }
+  }
+}
+```
+
+### 3. Add API keys (optional but recommended)
+
+Add to your shell profile (`~/.bashrc`, `~/.zshrc`, or Windows Environment Variables):
+
+```bash
+# Required for web search (pick one)
+export GEMINI_API_KEY="your-key"        # Best: Google Search grounding
+export OPENAI_API_KEY="your-key"        # Alternative: GPT-4o web search
+export PERPLEXITY_API_KEY="your-key"    # Alternative: Perplexity
+
+# Required for GitHub (higher rate limits)
+export GITHUB_TOKEN="your-token"        # github.com/settings/tokens
+
+# Required for vision analysis (pick one)
+export GEMINI_API_KEY="your-key"        # Best: Gemini 2.5 Flash
+export OPENAI_API_KEY="your-key"        # Alternative: GPT-4o
+export ANTHROPIC_API_KEY="your-key"     # Alternative: Claude
+```
+
+### 4. Restart Claude Code
+
+```bash
+# Quit and reopen Claude Code, or run:
+claude --mcp-debug
+```
+
+### 5. Test it works
+
+In Claude Code, try these prompts:
+
+```
+# Check your environment
+> Use setup_local_env to check my development environment
+
+# Search GitHub
+> Use search_github to find TypeScript MCP servers with at least 100 stars
+
+# Fetch documentation
+> Use fetch_url to read https://modelcontextprotocol.io/introduction
+
+# Get methodology
+> Use getMethodology("overview") to see all available workflows
+```
+
+---
+
+## Tool Categories
+
+| Category | Tools | Description |
+|----------|-------|-------------|
+| **Web** | `web_search`, `fetch_url` | Search the web, fetch URLs as markdown |
+| **GitHub** | `search_github`, `analyze_repo` | Find repos, analyze tech stacks |
+| **Documentation** | `update_agents_md`, `research_job_market`, `setup_local_env` | Self-maintaining docs, job research |
+| **Vision** | `discover_vision_env`, `analyze_screenshot`, `manipulate_screenshot` | AI-powered image analysis |
+| **UI Capture** | `capture_ui_screenshot`, `capture_responsive_suite` | Browser screenshots (requires Playwright) |
+| **Verification** | `start_cycle`, `log_phase`, `complete_cycle` | 6-phase dev workflow |
+| **Eval** | `start_eval_run`, `log_test_result`, `list_eval_runs` | Test case tracking |
+| **Quality Gates** | `run_quality_gate`, `get_gate_history` | Pass/fail checkpoints |
+| **Learning** | `record_learning`, `search_learnings`, `search_all_knowledge` | Persistent knowledge base |
+| **Flywheel** | `run_closed_loop`, `check_framework_updates` | Automated workflows |
+| **Recon** | `run_recon`, `log_recon_finding`, `log_gap` | Discovery and gap tracking |
+| **Meta** | `findTools`, `getMethodology` | Tool discovery, methodology guides |
+
+---
+
+## Methodology Topics (15 total)
+
+Ask Claude: `Use getMethodology("topic_name")`
+
+- `overview` — See all methodologies
+- `verification` — 6-phase development cycle
+- `eval` — Test case management
+- `flywheel` — Continuous improvement loop
+- `mandatory_flywheel` — Required verification for changes
+- `reconnaissance` — Codebase discovery
+- `quality_gates` — Pass/fail checkpoints
+- `ui_ux_qa` — Frontend verification
+- `agentic_vision` — AI-powered visual QA
+- `closed_loop` — Build/test before presenting
+- `learnings` — Knowledge persistence
+- `project_ideation` — Validate ideas before building
+- `tech_stack_2026` — Dependency management
+- `telemetry_setup` — Observability setup
+- `agents_md_maintenance` — Keep docs in sync
+
+---
+
+## VSCode Extension Setup
+
+If using the Claude Code VSCode extension:
+
+1. Open VSCode Settings (Ctrl/Cmd + ,)
+2. Search for "Claude Code MCP"
+3. Add server configuration:
+
+```json
+{
+  "claude-code.mcpServers": {
+    "nodebench": {
+      "command": "node",
+      "args": ["/absolute/path/to/packages/mcp-local/dist/index.js"]
+    }
+  }
+}
+```
+
+---
+
+## Optional Dependencies
+
+Install for additional features:
+
+```bash
+# Screenshot capture (headless browser)
+npm install playwright
+npx playwright install chromium
+
+# Image manipulation
+npm install sharp
+
+# HTML parsing (already included)
+npm install cheerio
+
+# AI providers (pick your preferred)
+npm install @google/genai    # Gemini
+npm install openai           # OpenAI
+npm install @anthropic-ai/sdk # Anthropic
+```
+
+---
+
+## Troubleshooting
+
+**"No search provider available"**
+- Set at least one API key: `GEMINI_API_KEY`, `OPENAI_API_KEY`, or `PERPLEXITY_API_KEY`
+
+**"GitHub API error 403"**
+- Set `GITHUB_TOKEN` for higher rate limits (60/hour without, 5000/hour with)
+
+**"Cannot find module"**
+- Run `npm run build` in the mcp-local directory
+
+**MCP not connecting**
+- Check path is absolute in settings.json
+- Run `claude --mcp-debug` to see connection errors
+- Ensure Node.js >= 18
+
+---
+
+## Example Workflows
+
+### Research a new project idea
+
+```
+1. Use getMethodology("project_ideation") for the 6-step process
+2. Use web_search to validate market demand
+3. Use search_github to find similar projects
+4. Use analyze_repo to study competitor implementations
+5. Use research_job_market to understand skill demand
+```
+
+### Analyze a GitHub repo before using it
+
+```
+1. Use search_github({ query: "mcp server", language: "typescript", minStars: 100 })
+2. Use analyze_repo({ repoUrl: "owner/repo" }) to see tech stack and patterns
+3. Use fetch_url to read their documentation
+```
+
+### Set up a new development environment
+
+```
+1. Use setup_local_env to scan current environment
+2. Follow the recommendations to install missing SDKs
+3. Use getMethodology("tech_stack_2026") for ongoing maintenance
+```
+
+---
+
+## License
+
+MIT

package/dist/__tests__/tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/tools.test.js

@@ -0,0 +1,402 @@
+/**
+ * Automated tests for NodeBench MCP tools.
+ * Covers: static, unit, integration layers.
+ * Live E2E layer is tested via bash pipe in the flywheel step.
+ */
+import { describe, it, expect } from "vitest";
+import { verificationTools } from "../tools/verificationTools.js";
+import { reconTools } from "../tools/reconTools.js";
+import { uiCaptureTools } from "../tools/uiCaptureTools.js";
+import { visionTools } from "../tools/visionTools.js";
+import { evalTools } from "../tools/evalTools.js";
+import { qualityGateTools } from "../tools/qualityGateTools.js";
+import { flywheelTools } from "../tools/flywheelTools.js";
+import { learningTools } from "../tools/learningTools.js";
+import { createMetaTools } from "../tools/metaTools.js";
+import { webTools } from "../tools/webTools.js";
+import { githubTools } from "../tools/githubTools.js";
+import { documentationTools } from "../tools/documentationTools.js";
+// Assemble all tools like index.ts does
+const domainTools = [
+    ...verificationTools,
+    ...evalTools,
+    ...qualityGateTools,
+    ...learningTools,
+    ...flywheelTools,
+    ...reconTools,
+    ...uiCaptureTools,
+    ...visionTools,
+    ...webTools,
+    ...githubTools,
+    ...documentationTools,
+];
+const allTools = [...domainTools, ...createMetaTools(domainTools)];
+// ═══════════════════════════════════════════════════════════════════════════
+// STATIC LAYER — structure validation
+// ═══════════════════════════════════════════════════════════════════════════
+describe("Static: tool structure", () => {
+    it("should have 46 tools total", () => {
+        expect(allTools.length).toBe(46);
+    });
+    it("every tool has name, description, inputSchema, handler", () => {
+        for (const tool of allTools) {
+            expect(tool.name).toBeTruthy();
+            expect(typeof tool.name).toBe("string");
+            expect(tool.description).toBeTruthy();
+            expect(typeof tool.description).toBe("string");
+            expect(tool.inputSchema).toBeTruthy();
+            expect(typeof tool.handler).toBe("function");
+        }
+    });
+    it("tool names are unique", () => {
+        const names = allTools.map((t) => t.name);
+        expect(new Set(names).size).toBe(names.length);
+    });
+    it("abandon_cycle tool exists in verificationTools", () => {
+        const tool = verificationTools.find((t) => t.name === "abandon_cycle");
+        expect(tool).toBeDefined();
+        expect(tool.inputSchema.required).toContain("cycleId");
+    });
+});
+describe("Static: ui_ux_qa preset", () => {
+    it("should return 8 rules from get_gate_preset", async () => {
+        const tool = findTool("get_gate_preset");
+        const result = (await tool.handler({ preset: "ui_ux_qa" }));
+        expect(result.preset).toBe("ui_ux_qa");
+        expect(result.ruleCount).toBe(8);
+        expect(result.rules.map((r) => r.name)).toContain("component_renders");
+        expect(result.rules.map((r) => r.name)).toContain("keyboard_navigable");
+        expect(result.rules.map((r) => r.name)).toContain("aria_labels_present");
+        expect(result.rules.map((r) => r.name)).toContain("storybook_story_exists");
+    });
+    it("should accept ui_ux_qa gate results via run_quality_gate", async () => {
+        const tool = findTool("run_quality_gate");
+        const result = (await tool.handler({
+            gateName: "ui_ux_qa",
+            target: "TestComponent",
+            rules: [
+                { name: "component_renders", passed: true },
+                { name: "responsive_check", passed: true },
+                { name: "keyboard_navigable", passed: false },
+                { name: "aria_labels_present", passed: true },
+                { name: "loading_states_handled", passed: true },
+                { name: "no_console_errors", passed: true },
+                { name: "visual_consistency", passed: true },
+                { name: "storybook_story_exists", passed: false },
+            ],
+        }));
+        expect(result.passed).toBe(false);
+        expect(result.totalRules).toBe(8);
+        expect(result.passedCount).toBe(6);
+        expect(result.failures).toContain("keyboard_navigable");
+        expect(result.failures).toContain("storybook_story_exists");
+    });
+});
+describe("Static: ui capture tools", () => {
+    it("should include capture_ui_screenshot and capture_responsive_suite", () => {
+        const names = allTools.map((t) => t.name);
+        expect(names).toContain("capture_ui_screenshot");
+        expect(names).toContain("capture_responsive_suite");
+    });
+    it("capture_ui_screenshot requires url parameter", () => {
+        const tool = allTools.find((t) => t.name === "capture_ui_screenshot");
+        expect(tool.inputSchema.required).toContain("url");
+    });
+    it("capture_responsive_suite requires url and label", () => {
+        const tool = allTools.find((t) => t.name === "capture_responsive_suite");
+        expect(tool.inputSchema.required).toContain("url");
+        expect(tool.inputSchema.required).toContain("label");
+    });
+    it("capture_ui_screenshot has viewport enum with expected presets", () => {
+        const tool = allTools.find((t) => t.name === "capture_ui_screenshot");
+        const viewportProp = tool.inputSchema.properties.viewport;
+        expect(viewportProp.enum).toContain("mobile");
+        expect(viewportProp.enum).toContain("tablet");
+        expect(viewportProp.enum).toContain("desktop");
+        expect(viewportProp.enum).toContain("wide");
+        expect(viewportProp.enum).toContain("custom");
+    });
+});
+describe("Static: vision tools", () => {
+    it("should include discover_vision_env, analyze_screenshot, manipulate_screenshot", () => {
+        const names = allTools.map((t) => t.name);
+        expect(names).toContain("discover_vision_env");
+        expect(names).toContain("analyze_screenshot");
+        expect(names).toContain("manipulate_screenshot");
+    });
+    it("analyze_screenshot requires imageBase64 and has rawContent", () => {
+        const tool = allTools.find((t) => t.name === "analyze_screenshot");
+        expect(tool.inputSchema.required).toContain("imageBase64");
+        expect(tool.rawContent).toBe(true);
+    });
+    it("manipulate_screenshot requires imageBase64 and operation", () => {
+        const tool = allTools.find((t) => t.name === "manipulate_screenshot");
+        expect(tool.inputSchema.required).toContain("imageBase64");
+        expect(tool.inputSchema.required).toContain("operation");
+        expect(tool.rawContent).toBe(true);
+    });
+    it("discover_vision_env has no required params", () => {
+        const tool = allTools.find((t) => t.name === "discover_vision_env");
+        const required = tool.inputSchema.required;
+        expect(required ?? []).toEqual([]);
+    });
+});
+describe("Unit: discover_vision_env", () => {
+    it("should return environment scan without errors", async () => {
+        const tool = allTools.find((t) => t.name === "discover_vision_env");
+        const result = (await tool.handler({}));
+        expect(result).toHaveProperty("apiKeys");
+        expect(result).toHaveProperty("sdks");
+        expect(result).toHaveProperty("providers");
+        expect(result).toHaveProperty("canAnalyze");
+        expect(result).toHaveProperty("canManipulate");
+        expect(result).toHaveProperty("canCapture");
+        expect(typeof result.canAnalyze).toBe("boolean");
+    }, 15000); // Allow time for dynamic imports
+});
+describe("Static: agentic_vision methodology", () => {
+    it("should return agentic_vision methodology from getMethodology", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "agentic_vision" }));
+        expect(result.title).toContain("Agentic Vision");
+        expect(result.steps.length).toBe(6);
+        expect(result.steps[0].name).toBe("Discover");
+        expect(result.steps[2].name).toBe("Analyze");
+    });
+});
+describe("Static: web tools", () => {
+    it("should include web_search and fetch_url tools", () => {
+        const names = allTools.map((t) => t.name);
+        expect(names).toContain("web_search");
+        expect(names).toContain("fetch_url");
+    });
+    it("web_search requires query parameter", () => {
+        const tool = allTools.find((t) => t.name === "web_search");
+        expect(tool.inputSchema.required).toContain("query");
+    });
+    it("fetch_url requires url parameter", () => {
+        const tool = allTools.find((t) => t.name === "fetch_url");
+        expect(tool.inputSchema.required).toContain("url");
+    });
+});
+describe("Static: github tools", () => {
+    it("should include search_github and analyze_repo tools", () => {
+        const names = allTools.map((t) => t.name);
+        expect(names).toContain("search_github");
+        expect(names).toContain("analyze_repo");
+    });
+    it("search_github requires query parameter", () => {
+        const tool = allTools.find((t) => t.name === "search_github");
+        expect(tool.inputSchema.required).toContain("query");
+    });
+    it("analyze_repo requires repoUrl parameter", () => {
+        const tool = allTools.find((t) => t.name === "analyze_repo");
+        expect(tool.inputSchema.required).toContain("repoUrl");
+    });
+});
+describe("Static: documentation tools", () => {
+    it("should include update_agents_md, research_job_market, and setup_local_env tools", () => {
+        const names = allTools.map((t) => t.name);
+        expect(names).toContain("update_agents_md");
+        expect(names).toContain("research_job_market");
+        expect(names).toContain("setup_local_env");
+    });
+    it("update_agents_md requires operation parameter", () => {
+        const tool = allTools.find((t) => t.name === "update_agents_md");
+        expect(tool.inputSchema.required).toContain("operation");
+    });
+    it("research_job_market requires role parameter", () => {
+        const tool = allTools.find((t) => t.name === "research_job_market");
+        expect(tool.inputSchema.required).toContain("role");
+    });
+});
+describe("Static: new methodology topics", () => {
+    it("should return project_ideation methodology with 6 steps", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "project_ideation" }));
+        expect(result.title).toContain("Project Ideation");
+        expect(result.steps.length).toBe(6);
+        expect(result.steps[0].name).toBe("Define Concept");
+    });
+    it("should return tech_stack_2026 methodology with 5 steps", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "tech_stack_2026" }));
+        expect(result.title).toContain("Tech Stack");
+        expect(result.steps.length).toBe(5);
+    });
+    it("should return telemetry_setup methodology with 5 steps", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "telemetry_setup" }));
+        expect(result.title).toContain("Telemetry");
+        expect(result.steps.length).toBe(5);
+    });
+    it("should return agents_md_maintenance methodology with 5 steps", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "agents_md_maintenance" }));
+        expect(result.title).toContain("AGENTS.md");
+        expect(result.steps.length).toBe(5);
+    });
+    it("overview should include all 15 methodology topics", async () => {
+        const tool = allTools.find((t) => t.name === "getMethodology");
+        const result = (await tool.handler({ topic: "overview" }));
+        const topics = Object.keys(result.steps[0].topics);
+        expect(topics).toContain("project_ideation");
+        expect(topics).toContain("tech_stack_2026");
+        expect(topics).toContain("telemetry_setup");
+        expect(topics).toContain("agents_md_maintenance");
+        expect(topics.length).toBe(14); // All topics listed in overview
+    });
+});
+describe("Unit: setup_local_env", () => {
+    it("should return environment status without errors", async () => {
+        const tool = allTools.find((t) => t.name === "setup_local_env");
+        // Skip SDK checks to avoid timeout from dynamic imports
+        const result = (await tool.handler({ checkSdks: false }));
+        expect(result).toHaveProperty("environment");
+        expect(result).toHaveProperty("apiKeys");
+        expect(result).toHaveProperty("capabilities");
+        expect(result).toHaveProperty("recommendation");
+        expect(result.environment).toHaveProperty("nodeVersion");
+        expect(result.environment).toHaveProperty("packageManager");
+    });
+});
+describe("Unit: research_job_market", () => {
+    it("should return job market data for known roles", async () => {
+        const tool = allTools.find((t) => t.name === "research_job_market");
+        const result = (await tool.handler({ role: "AI Engineer" }));
+        expect(result.role).toBe("AI Engineer");
+        expect(result).toHaveProperty("commonRequirements");
+        expect(result).toHaveProperty("emergingSkills");
+        expect(result).toHaveProperty("salaryRange");
+        expect(result).toHaveProperty("recommendation");
+        expect(result.commonRequirements.length).toBeGreaterThan(0);
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// UNIT LAYER — individual tool behavior
+// ═══════════════════════════════════════════════════════════════════════════
+const findTool = (name) => allTools.find((t) => t.name === name);
+describe("Unit: abandon_cycle", () => {
+    it("should abandon an active cycle", async () => {
+        // Create a cycle first
+        const startTool = findTool("start_verification_cycle");
+        const cycle = (await startTool.handler({
+            title: "test-abandon-cycle",
+            description: "test cycle for abandon",
+        }));
+        expect(cycle.cycleId).toBeTruthy();
+        // Abandon it
+        const abandonTool = findTool("abandon_cycle");
+        const result = (await abandonTool.handler({
+            cycleId: cycle.cycleId,
+            reason: "test cleanup",
+        }));
+        expect(result.abandoned).toBe(true);
+        expect(result.reason).toBe("test cleanup");
+    });
+    it("should skip already-abandoned cycles", async () => {
+        const startTool = findTool("start_verification_cycle");
+        const cycle = (await startTool.handler({
+            title: "test-double-abandon",
+            description: "test",
+        }));
+        const abandonTool = findTool("abandon_cycle");
+        await abandonTool.handler({ cycleId: cycle.cycleId });
+        const result2 = (await abandonTool.handler({
+            cycleId: cycle.cycleId,
+        }));
+        expect(result2.skipped).toBe(true);
+    });
+    it("should throw on nonexistent cycle", async () => {
+        const abandonTool = findTool("abandon_cycle");
+        await expect(abandonTool.handler({ cycleId: "nonexistent_cycle_id" })).rejects.toThrow("Cycle not found");
+    });
+});
+describe("Unit: search_all_knowledge", () => {
+    it("should return results structure with gaps field", async () => {
+        const tool = findTool("search_all_knowledge");
+        const result = (await tool.handler({
+            query: "test",
+        }));
+        expect(result).toHaveProperty("query");
+        expect(result).toHaveProperty("totalResults");
+        expect(result).toHaveProperty("learnings");
+        expect(result).toHaveProperty("reconFindings");
+        expect(result).toHaveProperty("gaps");
+        expect(result).toHaveProperty("_contributeBack");
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════════
+// INTEGRATION LAYER — multi-tool chain
+// ═══════════════════════════════════════════════════════════════════════════
+describe("Integration: full verification cycle chain", () => {
+    it("start → log_phase → log_gap → resolve_gap → abandon", async () => {
+        // 1. Start cycle
+        const cycle = (await findTool("start_verification_cycle").handler({
+            title: "integration-test-cycle",
+            description: "full chain test",
+        }));
+        expect(cycle.cycleId).toBeTruthy();
+        // 2. Log phase 1 findings
+        const phase1 = (await findTool("log_phase_findings").handler({
+            cycleId: cycle.cycleId,
+            phaseNumber: 1,
+            status: "passed",
+            findings: { summary: "context gathered" },
+        }));
+        expect(phase1.phaseRecorded).toBe(1);
+        expect(phase1.phaseStatus).toBe("passed");
+        // 3. Log a gap
+        const gap = (await findTool("log_gap").handler({
+            cycleId: cycle.cycleId,
+            severity: "LOW",
+            title: "test gap for integration",
+            description: "This is a test gap",
+            rootCause: "testing",
+            fixStrategy: "resolve in test",
+        }));
+        expect(gap.gapId).toBeTruthy();
+        // 4. Resolve the gap
+        const resolved = (await findTool("resolve_gap").handler({
+            gapId: gap.gapId,
+        }));
+        expect(resolved.status).toBe("resolved");
+        // 5. Abandon the cycle (cleanup)
+        const abandoned = (await findTool("abandon_cycle").handler({
+            cycleId: cycle.cycleId,
+            reason: "integration test cleanup",
+        }));
+        expect(abandoned.abandoned).toBe(true);
+    });
+});
+describe("Integration: search finds logged gaps", () => {
+    it("should find gaps via search_all_knowledge after logging", async () => {
+        const uniqueMarker = `vitest-marker-${Date.now()}`;
+        // Create a cycle and gap with a unique marker
+        const cycle = (await findTool("start_verification_cycle").handler({
+            title: `search-test-${uniqueMarker}`,
+            description: "test",
+        }));
+        await findTool("log_gap").handler({
+            cycleId: cycle.cycleId,
+            severity: "LOW",
+            title: `gap-${uniqueMarker}`,
+            description: `Testing search finds this gap ${uniqueMarker}`,
+            rootCause: "test",
+            fixStrategy: "none",
+        });
+        // Search for it
+        const results = (await findTool("search_all_knowledge").handler({
+            query: uniqueMarker,
+        }));
+        expect(results.gaps.length).toBeGreaterThanOrEqual(1);
+        expect(results.gaps[0].title).toContain(uniqueMarker);
+        expect(results.gaps[0].status).toBe("open");
+        // Cleanup
+        await findTool("abandon_cycle").handler({
+            cycleId: cycle.cycleId,
+            reason: "test cleanup",
+        });
+    });
+});
+//# sourceMappingURL=tools.test.js.map