breakpoint-mcp 1.14.0 → 1.19.0

package/dist/pause.js

@@ -0,0 +1,105 @@
+import { log } from "./logger.js";
+export class PauseLatch {
+    _paused;
+    waiters = new Set();
+    activity = [];
+    seq = 0;
+    cap;
+    waitTimeoutMs;
+    constructor(opts) {
+        this._paused = opts?.startPaused ?? false;
+        this.waitTimeoutMs = opts?.waitTimeoutMs ?? 120000;
+        this.cap = Math.max(1, opts?.activityCap ?? 50);
+    }
+    isPaused() {
+        return this._paused;
+    }
+    pause(reason = "signal") {
+        if (this._paused)
+            return;
+        this._paused = true;
+        log(`[pause] agent PAUSED (${reason}) — new mutating tool calls will wait for resume`);
+    }
+    resume(reason = "signal") {
+        if (!this._paused)
+            return;
+        this._paused = false;
+        const n = this.waiters.size;
+        for (const release of [...this.waiters])
+            release();
+        this.waiters.clear();
+        log(`[pause] agent RESUMED (${reason})${n ? ` — released ${n} waiting call(s)` : ""}`);
+    }
+    toggle(reason = "signal") {
+        if (this._paused)
+            this.resume(reason);
+        else
+            this.pause(reason);
+    }
+    /** Record a mutating action reaching the gate (the activity signal source). */
+    record(action) {
+        this.seq += 1;
+        this.activity.push({ seq: this.seq, action, at: Date.now() });
+        while (this.activity.length > this.cap)
+            this.activity.shift();
+    }
+    /** Last `n` recorded actions (most recent last). */
+    recent(n = 10) {
+        return this.activity.slice(-Math.max(0, n));
+    }
+    latestSeq() {
+        return this.seq;
+    }
+    /**
+     * Resolve `true` immediately when not paused. While paused, wait until resumed
+     * (→ `true`) or `timeoutMs` elapses (→ `false`). Only entry to a NEW action
+     * waits; nothing already running is affected.
+     */
+    async awaitResumed(timeoutMs = this.waitTimeoutMs) {
+        if (!this._paused)
+            return true;
+        return new Promise((resolve) => {
+            const release = () => {
+                cleanup();
+                resolve(true);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                resolve(false);
+            }, timeoutMs);
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.waiters.delete(release);
+            };
+            this.waiters.add(release);
+        });
+    }
+}
+function envFlag(name) {
+    return /^(1|true|on|yes)$/i.test(process.env[name] ?? "");
+}
+function envInt(name, dflt) {
+    const raw = process.env[name];
+    const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    return Number.isFinite(n) && n >= 0 ? n : dflt;
+}
+/**
+ * Process-wide latch, configured from the environment at load:
+ *   BREAKPOINT_START_PAUSED       start held (resume with SIGUSR2). Default off.
+ *   BREAKPOINT_PAUSE_TIMEOUT_MS   how long a held call waits before it blocks.
+ * `gate()` consults this singleton; `main()` wires the signal handlers.
+ */
+export const pauseLatch = new PauseLatch({
+    startPaused: envFlag("BREAKPOINT_START_PAUSED"),
+    waitTimeoutMs: envInt("BREAKPOINT_PAUSE_TIMEOUT_MS", 120000),
+});
+/**
+ * Wire OS-signal control onto a running host (the prototype's control surface):
+ * SIGUSR1 → pause, SIGUSR2 → resume. Call once from `main()`; never at import,
+ * so importing this module in tests registers no process-level handlers.
+ */
+export function installPauseSignalHandlers(latch = pauseLatch) {
+    process.on("SIGUSR1", () => latch.pause("SIGUSR1"));
+    process.on("SIGUSR2", () => latch.resume("SIGUSR2"));
+}
+//# sourceMappingURL=pause.js.map

package/dist/recipes.js

@@ -0,0 +1,168 @@
+/**
+ * Recipes — a free, curated task-recipe layer exposed as MCP **prompts**.
+ *
+ * A recipe is a short, opinionated workflow that drives Breakpoint's own
+ * enforced tools to accomplish a common Godot task and then *verifies* it. It
+ * is the same idea as a paid "skill pack", with two differences that matter:
+ * it's **free** (MIT, shipped in the server), and it sits **over typed,
+ * schema-validated, undoable tools** — so the contract is executed by the
+ * server, not merely described in prose the model might misapply. Recipes are
+ * discoverable via MCP `prompts/list`; they add **no tools** (the 276-tool
+ * count is unchanged) and cost nothing until a client pulls one.
+ */
+import { z } from "zod";
+const str = (a, k, dflt) => typeof a?.[k] === "string" && a[k].length ? a[k] : dflt;
+/** Wrap recipe body text as a single-message GetPromptResult. */
+function recipe(description, text) {
+    return { description, messages: [{ role: "user", content: { type: "text", text } }] };
+}
+/** The shared closing note every recipe carries — the safety/story hook. */
+const SAFETY = "Throughout: every edit goes through the editor's undo stack (editor_undo / Ctrl-Z " +
+    "reverts anything), destructive tools are confirmation-gated, and the runtime_assert_* " +
+    "verification family is free and read-only — a failed assert is one dbg_* step from *why*.";
+export const RECIPE_NAMES = [
+    "recipe_2d_player_controller",
+    "recipe_wire_signal_and_assert",
+    "recipe_debug_inspect_variable",
+    "recipe_screenshot_regression",
+    "recipe_type_safe_edit",
+    "recipe_csharp_fix_and_debug",
+];
+export function registerRecipes(server) {
+    // 1 — 2D player controller, then verify it moves.
+    server.registerPrompt("recipe_2d_player_controller", {
+        title: "2D player: CharacterBody2D + input + camera, then verify",
+        description: "Build a movable 2D player (input actions, body, collision, sprite, camera), type-check the script, then run and assert it actually moved.",
+        argsSchema: {
+            scene_path: z.string().optional().describe("Scene to edit (default res://main.tscn)"),
+            player_name: z.string().optional().describe("Node name for the player (default Player)"),
+            speed: z.string().optional().describe("Move speed in px/s (default 220)"),
+        },
+    }, (a) => {
+        const scene = str(a, "scene_path", "res://main.tscn");
+        const player = str(a, "player_name", "Player");
+        const speed = str(a, "speed", "220");
+        return recipe("2D player controller with a runtime movement check.", [
+            `Goal: add a keyboard-movable "${player}" to ${scene} and prove it moves.`,
+            "",
+            "1. Input: inputmap_add_action for move_left/right/up/down (skip any inputmap_list already reports), then inputmap_add_event to bind arrow keys / WASD.",
+            `2. Scene: scene_open ${scene} (or scene_new). node_add a CharacterBody2D named "${player}"; collisionshape_add a rectangle to it; node_add a Sprite2D (set its texture via node_set_property, or asset_gen_sprite if no art yet); camera_create as a child so the view follows.`,
+            `3. Script: author a _physics_process that reads Input.get_vector("move_left","move_right","move_up","move_down") * ${speed} into velocity and calls move_and_slide(); attach it to "${player}" (node_set_property script). Run gd_diagnostics on the script and fix until it reports zero errors BEFORE running.`,
+            `4. Verify: godot_run_project. runtime_assert_scene_structure that "${player}" (+ Camera2D, CollisionShape2D) exists. Capture the start position (runtime_get_property position), runtime_inject_input a right/up press for a few frames, then runtime_assert_node_state that position changed in the expected direction. godot_stop.`,
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+    // 2 — Wire a signal and assert at runtime that it fired.
+    server.registerPrompt("recipe_wire_signal_and_assert", {
+        title: "Wire a signal and assert at runtime that it fired",
+        description: "Connect a signal to a handler, then run the game, trigger it, and confirm the handler actually ran — the contract enforced, not assumed.",
+        argsSchema: {
+            signal_name: z.string().optional().describe("Signal to wire (e.g. body_entered, pressed, timeout)"),
+        },
+    }, (a) => {
+        const sig = str(a, "signal_name", "pressed");
+        return recipe("Signal wiring with a runtime firing assertion.", [
+            `Goal: wire the "${sig}" signal to a handler and prove the handler runs.`,
+            "",
+            `1. Inspect: signal_list on the emitter to confirm "${sig}" exists (or signal_add_user_signal to declare a custom one).`,
+            `2. Connect: signal_connect the emitter's "${sig}" to a method on the receiver (signal_list_connections to confirm the edge).`,
+            "3. Handler: author the handler so it leaves an observable trace — set a Label's text, flip a property, or print() (captured by the runtime log). Run gd_diagnostics until clean.",
+            "4. Run + trigger: godot_run_project, then cause the signal — runtime_inject_input for input signals, runtime_call_method / runtime_emit_signal for logic signals.",
+            "5. Assert: confirm the trace — runtime_assert_screen_text for the label, runtime_assert_node_state for the flipped property, or scan runtime_get_log for the print. A green assert means the wire is real, not hoped-for. godot_stop.",
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+    // 3 — Debugger loop: breakpoint, launch, inspect a real variable.
+    server.registerPrompt("recipe_debug_inspect_variable", {
+        title: "Set a breakpoint, launch under the debugger, read a real variable",
+        description: "The core differentiator: stop a running GDScript (or C#) game at a line and read actual call-stack values over Godot's Debug Adapter — not a guess from the outside.",
+        argsSchema: {
+            script_path: z.string().optional().describe("Script to break in (e.g. res://player.gd)"),
+            line: z.string().optional().describe("1-based line to break on"),
+        },
+    }, (a) => {
+        const path = str(a, "script_path", "res://player.gd");
+        const line = str(a, "line", "24");
+        return recipe("Live step-debugging with real variable inspection.", [
+            `Goal: pause the running game inside ${path}:${line} and read live state.`,
+            "",
+            `1. Breakpoint: dbg_set_breakpoints on ${path} at line ${line} (find the right line first with gd_document_symbols / gd_definition if unsure).`,
+            "2. Launch: dbg_launch to start the game under the Debug Adapter and run to the breakpoint.",
+            "3. Inspect (paused): dbg_stack_trace for the frames, dbg_scopes + dbg_variables for the real locals/members in the top frame, and dbg_evaluate to compute an expression in that frame. dbg_watch to track a value across steps.",
+            "4. Step: dbg_step over/into to watch state evolve; dbg_continue to resume (or dbg_set_exception_breakpoints to stop on the next error). dbg_restart to re-run.",
+            "",
+            "This is the capability a screenshot-and-scene-tree server can't offer: it observes from outside; Breakpoint stops execution and looks inside. (C#? the same flow with cs_dbg_* via netcoredbg.)",
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+    // 4 — Screenshot regression: reference frame, then diff.
+    server.registerPrompt("recipe_screenshot_regression", {
+        title: "Capture a reference frame and assert a scene hasn't visually regressed",
+        description: "Golden-image testing for a Godot scene using the free, read-only runtime_screenshot_diff — and the debugger on hand when it fails.",
+        argsSchema: {
+            reference_path: z.string().optional().describe("Project path for the golden PNG (default res://tests/ref.png)"),
+            tolerance: z.string().optional().describe("Max fraction of differing pixels (default 0.02)"),
+        },
+    }, (a) => {
+        const ref = str(a, "reference_path", "res://tests/ref.png");
+        const tol = str(a, "tolerance", "0.02");
+        return recipe("Golden-image regression check for a scene.", [
+            `Goal: lock a scene's look to a golden image at ${ref} and catch visual drift.`,
+            "",
+            `1. Establish the golden (first run only): godot_run_project, drive the game to the state under test (runtime_inject_input / runtime_call_method), then runtime_screenshot and save the frame to ${ref}. Commit it (vcs_add) so it's the reference.`,
+            `2. Regression run (every time after): godot_run_project, reproduce the same state, then runtime_screenshot_diff against ${ref} with tolerance ${tol} (pass a region to ignore volatile HUD areas). ok:true means no meaningful drift.`,
+            "3. On failure: the diff returns diff_ratio + differing_pixels — don't just eyeball it. runtime_get_tree / runtime_assert_node_state to find the node that changed, or dbg_* to break where the offending value is set. Update the golden deliberately (re-do step 1) only once you've confirmed the change is intended.",
+            "",
+            "The whole diff runs engine-side (Image), so there's no OCR/image dependency and it stays read-only and ungated.",
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+    // 5 — Type-safe edit with the language server before running.
+    server.registerPrompt("recipe_type_safe_edit", {
+        title: "Make a type-checked edit with the language server before running",
+        description: "Edit GDScript the way an IDE does — symbols, references, hover, and diagnostics from Godot's real LSP — so errors are caught before the game runs.",
+        argsSchema: {
+            script_path: z.string().optional().describe("Script to edit (e.g. res://player.gd)"),
+        },
+    }, (a) => {
+        const path = str(a, "script_path", "res://player.gd");
+        return recipe("Type-aware editing gated by the language server.", [
+            `Goal: change ${path} with real symbol knowledge and land it error-free.`,
+            "",
+            `1. Understand: gd_document_symbols for the file's shape; gd_definition / gd_references before touching a symbol so you know every call site; find_usages across the project for wider blast radius.`,
+            "2. Edit with help: while writing, use gd_completion and gd_hover to get exact API names and signatures (this is where a generic 'call any method' tool hallucinates — the LSP gives you the truth). gd_rename to rename safely across the project.",
+            "3. Gate: run gd_diagnostics and do not proceed until it's clean. gd_code_action for quick-fixes it suggests.",
+            "4. Prove behavior: godot_run_project and a runtime_assert_* that the change did what you intended. If it didn't, dbg_* into it.",
+            "",
+            "Every mutation is on the undo stack — editor_undo reverts a bad edit instantly.",
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+    // 6 — C#: inspect, fix with diagnostics, and debug.
+    server.registerPrompt("recipe_csharp_fix_and_debug", {
+        title: "C#: inspect, fix with diagnostics, and debug via netcoredbg",
+        description: "Full C# parity — OmniSharp for symbols and diagnostics, netcoredbg for real step-debugging — the same enforced loop GDScript gets.",
+        argsSchema: {
+            script_path: z.string().optional().describe("C# file to work in (e.g. res://Player.cs)"),
+        },
+    }, (a) => {
+        const path = str(a, "script_path", "res://Player.cs");
+        return recipe("C# fix-and-debug loop over OmniSharp + netcoredbg.", [
+            `Goal: diagnose and fix ${path}, then step through it to confirm the fix.`,
+            "",
+            `1. Locate: cs_document_symbols / cs_workspace_symbols to navigate; cs_diagnostics to list the actual compiler errors/warnings in ${path}.`,
+            "2. Fix: cs_hover / cs_definition / cs_references for correct types and call sites; cs_code_action for offered fixes; cs_rename to rename safely. Re-run cs_diagnostics until clean.",
+            `3. Debug: cs_dbg_set_breakpoints in ${path}, cs_dbg_launch, then at the stop cs_dbg_stack_trace + cs_dbg_variables + cs_dbg_evaluate to inspect real values; cs_dbg_step / cs_dbg_continue to walk the fix. (netcoredbg is spawned lazily, so this costs nothing until used.)`,
+            "",
+            "Same schema-validated, undoable discipline as the GDScript planes — C# is a first-class citizen here, not an afterthought.",
+            "",
+            SAFETY,
+        ].join("\n"));
+    });
+}
+//# sourceMappingURL=recipes.js.map

package/dist/schemas.js

@@ -451,6 +451,49 @@ export const outputSchemas = {
         // capture, no managed parent). Optional so older addons still validate.
         capture: z.boolean().optional(),
     },
+    runtime_assert_node_state: {
+        path: z.string(),
+        ok: z.boolean(),
+        checked: z.number(),
+        mismatches: z.array(z.object({ property: z.string(), expected: encodedValue, actual: encodedValue })),
+    },
+    runtime_assert_scene_structure: {
+        ok: z.boolean(),
+        checked: z.number(),
+        failures: z.array(z.object({
+            path: z.string(),
+            reason: z.string(),
+            expected: encodedValue.optional(),
+            actual: encodedValue.optional(),
+        })),
+    },
+    runtime_assert_perf: {
+        ok: z.boolean(),
+        checked: z.number(),
+        regressions: z.array(z.object({
+            key: z.string(),
+            baseline: z.number(),
+            current: z.number(),
+            direction: z.string(),
+        })),
+        monitors: z.record(z.number()),
+    },
+    runtime_assert_screen_text: {
+        ok: z.boolean(),
+        matches: z.number(),
+        present: z.boolean(),
+        samples: z.array(z.object({ path: z.string(), text: z.string() })),
+    },
+    runtime_screenshot_diff: {
+        ok: z.boolean(),
+        diff_ratio: z.number(),
+        differing_pixels: z.number(),
+        total_pixels: z.number(),
+        width: z.number(),
+        height: z.number(),
+        reference: z.string(),
+        reason: z.string().optional(),
+    },
     // ---- Group K: knowledge & search ----
     // Host-side project index (tools/knowledge.ts) — no bridge/LSP; read the project files directly.
     project_search: {

package/dist/secret.js

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Loopback-bridge shared secret (host side).
+ *
+ * The editor addon / runtime autoload mint a per-project secret to
+ * <projectPath>/.godot/breakpoint_mcp.secret (see addons/breakpoint_mcp/
+ * bridge_secret.gd). Reading the same file lets the host authenticate to the
+ * loopback bridges with ZERO configuration. An env override wins for advanced /
+ * host-launched-child cases. When no material is available (an insecure or
+ * not-yet-provisioned bridge) the resolver returns null and the client connects
+ * without an auth line — backward-compatible with a bridge that isn't enforcing.
+ */
+/** Read the minted project secret, or null if absent/empty/unreadable. */
+export function readProjectSecret(projectPath) {
+    try {
+        const p = path.join(projectPath, ".godot", "breakpoint_mcp.secret");
+        const s = fs.readFileSync(p, "utf8").trim();
+        return s.length ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the bridge secret: the first non-empty env var in `envNames` wins,
+ * else the minted project-secret file. Read lazily per connect so a secret that
+ * appears after startup (the editor launched later) is picked up on reconnect.
+ */
+export function resolveBridgeSecret(projectPath, envNames) {
+    for (const name of envNames) {
+        const v = process.env[name];
+        if (v && v.trim())
+            return v.trim();
+    }
+    return readProjectSecret(projectPath);
+}
+//# sourceMappingURL=secret.js.map

package/dist/tools/runtime.js

@@ -121,5 +121,117 @@ export function registerRuntimeTools(server, runtime) {
             levels: z.array(z.string()).optional().describe("Filter to these levels, e.g. [\"error\",\"warning\"]"),
         },
     }, async ({ since_seq, levels }) => call("runtime.get_log", { since_seq: since_seq ?? 0, levels: levels ?? [] }));
+    server.registerTool("runtime_assert_node_state", {
+        title: "Runtime assert node state",
+        description: "Assert that properties of a LIVE node equal expected values (read-only verification). " +
+            "Reports per-property mismatches; supports an optional absolute numeric tolerance.",
+        inputSchema: {
+            path: z.string().describe("Node path (relative to the current scene; '/root/...' absolute allowed)"),
+            expect: z
+                .record(z.any())
+                .describe("Map of property name -> expected value (JSON; use the tagged-Variant form for complex types like Vector2/Color)"),
+            tolerance: z
+                .number()
+                .nonnegative()
+                .optional()
+                .describe("Absolute tolerance for numeric comparisons (default 0 = exact match)"),
+        },
+    }, async ({ path, expect, tolerance }) => call("runtime.assert_node_state", tolerance !== undefined ? { path, expect, tolerance } : { path, expect }));
+    server.registerTool("runtime_assert_scene_structure", {
+        title: "Runtime assert scene structure",
+        description: "Assert the LIVE SceneTree matches structural expectations (read-only). Each entry asserts a node " +
+            "exists at a path (and, if given, is of a class via is_class); set absent:true to assert it is NOT present.",
+        inputSchema: {
+            expect: z
+                .array(z.object({
+                path: z.string(),
+                type: z.string().optional(),
+                absent: z.boolean().optional(),
+            }))
+                .describe("List of node expectations: {path, type?, absent?}."),
+        },
+    }, async ({ expect }) => call("runtime.assert_scene_structure", { expect }));
+    server.registerTool("runtime_assert_perf", {
+        title: "Runtime assert perf",
+        description: "Assert that live Performance monitors meet a caller-supplied baseline within tolerance (read-only). " +
+            "Capture the baseline earlier with runtime_get_monitors and pass it back inline. Pass direction is inferred " +
+            "(time/fps is higher-better; every other monitor is lower-better) unless overridden per key.",
+        inputSchema: {
+            baseline: z
+                .record(z.number())
+                .describe("Monitor key -> baseline value (capture earlier via runtime_get_monitors)"),
+            tolerance: z
+                .number()
+                .nonnegative()
+                .optional()
+                .describe("Fractional tolerance applied to each comparison (default 0 = exact)"),
+            direction: z
+                .record(z.enum(["higher_better", "lower_better"]))
+                .optional()
+                .describe("Per-key override of the pass direction (defaults: time/fps higher_better, else lower_better)"),
+        },
+    }, async ({ baseline, tolerance, direction }) => call("runtime.assert_perf", {
+        baseline,
+        ...(tolerance !== undefined ? { tolerance } : {}),
+        ...(direction !== undefined ? { direction } : {}),
+    }));
+    server.registerTool("runtime_assert_screen_text", {
+        title: "Runtime assert screen text",
+        description: "Assert that on-screen text is present (or absent) by scanning visible Control text in the LIVE scene tree " +
+            "(read-only; no OCR). Sees text on Label / RichTextLabel / Button / LineEdit / TextEdit / CheckBox / LinkButton " +
+            "and similar; does NOT see text drawn directly to the canvas or baked into textures.",
+        inputSchema: {
+            text: z.string().describe("Text (or regular expression) to look for"),
+            present: z
+                .boolean()
+                .optional()
+                .describe("Assert the text IS present (default true); set false to assert it is absent"),
+            regex: z.boolean().optional().describe("Treat `text` as a regular expression (default false = substring)"),
+            case_sensitive: z.boolean().optional().describe("Case-sensitive match (default false)"),
+            min_count: z
+                .number()
+                .int()
+                .positive()
+                .optional()
+                .describe("Require at least this many matches (implies present)"),
+        },
+    }, async ({ text, present, regex, case_sensitive, min_count }) => call("runtime.assert_screen_text", {
+        text,
+        ...(present !== undefined ? { present } : {}),
+        ...(regex !== undefined ? { regex } : {}),
+        ...(case_sensitive !== undefined ? { case_sensitive } : {}),
+        ...(min_count !== undefined ? { min_count } : {}),
+    }));
+    server.registerTool("runtime_screenshot_diff", {
+        title: "Runtime screenshot diff",
+        description: "Capture the current frame and compare it to a reference PNG at a project path, returning diff stats and a " +
+            "pass/fail vs tolerance (read-only; the diff is computed engine-side so the host stays dependency-free). " +
+            "Establish the reference first by saving a runtime_screenshot as a project asset.",
+        inputSchema: {
+            reference: z.string().describe("res:// or user:// path to the reference PNG"),
+            tolerance: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .describe("Max fraction of differing pixels that still passes (default 0)"),
+            per_channel_threshold: z
+                .number()
+                .int()
+                .min(0)
+                .max(255)
+                .optional()
+                .describe("Per-channel delta (0-255) for a pixel to count as different (default 0)"),
+            region: z
+                .object({ x: z.number().int(), y: z.number().int(), w: z.number().int(), h: z.number().int() })
+                .optional()
+                .describe("Optional sub-region (applied to both frame and reference) to compare"),
+        },
+    }, async ({ reference, tolerance, per_channel_threshold, region }) => call("runtime.screenshot_diff", {
+        reference,
+        ...(tolerance !== undefined ? { tolerance } : {}),
+        ...(per_channel_threshold !== undefined ? { per_channel_threshold } : {}),
+        ...(region !== undefined ? { region } : {}),
+    }));
 }
 //# sourceMappingURL=runtime.js.map

package/dist/toolsets.js

@@ -0,0 +1,44 @@
+import { registerCliTools } from "./tools/cli.js";
+import { registerEditorTools } from "./tools/editor.js";
+import { registerLspTools } from "./tools/lsp.js";
+import { registerCsLspTools } from "./tools/cslsp.js";
+import { registerDapTools } from "./tools/dap.js";
+import { registerCsDapTools } from "./tools/csdap.js";
+import { registerRuntimeTools } from "./tools/runtime.js";
+import { registerProcessTools } from "./tools/processes.js";
+import { registerKnowledgeTools } from "./tools/knowledge.js";
+import { registerVcsTools } from "./tools/vcs.js";
+import { registerAssetGenTools } from "./tools/assetgen.js";
+import { registerNetcodeTools } from "./tools/netcode.js";
+import { registerBackendTools } from "./tools/backend.js";
+import { registerTabletopTools } from "./tools/tabletop.js";
+import { registerResources } from "./tools/resources.js";
+/**
+ * Build the ordered toolset list. Order matches `index.ts` exactly so the live
+ * tool list is byte-identical whether or not filtering is applied. `resources`
+ * here registers only the MCP resources; resource *subscriptions* are wired by
+ * the caller after selection (they add no tools, only notification plumbing).
+ */
+export function buildToolsets(d) {
+    const s = d.server;
+    const c = d.config;
+    const stub = (v) => v;
+    return [
+        { id: "cli", describe: "Plane B — headless CLI (no editor required)", run: () => registerCliTools(s, c) },
+        { id: "editor", describe: "Plane A — live editor authoring (addon bridge)", run: () => registerEditorTools(s, stub(d.bridge)) },
+        { id: "lsp", describe: "Plane D — GDScript language server (LSP)", run: () => registerLspTools(s, stub(d.lsp), c) },
+        { id: "cslsp", describe: "Plane D — C# language server (OmniSharp)", run: () => registerCsLspTools(s, stub(d.csLsp), c) },
+        { id: "dap", describe: "Plane D — GDScript debug adapter (DAP)", run: () => registerDapTools(s, stub(d.dap), c) },
+        { id: "csdap", describe: "Plane D — C# debug adapter (netcoredbg)", run: () => registerCsDapTools(s, stub(d.csDap), c) },
+        { id: "runtime", describe: "Plane C — running-game runtime + verification family", run: () => registerRuntimeTools(s, stub(d.runtime)) },
+        { id: "processes", describe: "Managed run + captured console output", run: () => { const h = registerProcessTools(s, c); d.onProcesses?.(h); } },
+        { id: "knowledge", describe: "Group K — host-side project grep / symbol & idiom lookup", run: () => registerKnowledgeTools(s, c) },
+        { id: "vcs", describe: "Group L — read-only version control (git) over the project", run: () => registerVcsTools(s, c) },
+        { id: "assetgen", describe: "Group J — AI asset generation (degrades to a spec when off)", run: () => registerAssetGenTools(s, stub(d.bridge), c) },
+        { id: "netcode", describe: "Group M — multiplayer scaffolding (mp_*)", run: () => registerNetcodeTools(s, stub(d.bridge), c) },
+        { id: "backend", describe: "Group M — backend-SDK integration scaffolding", run: () => registerBackendTools(s, stub(d.bridge), c) },
+        { id: "tabletop", describe: "Group N — card/board/piece authoring composites", run: () => registerTabletopTools(s, stub(d.bridge), c) },
+        { id: "resources", describe: "MCP resources (scene tree, editor/runtime state, ClassDB)", run: () => registerResources(s, stub(d.bridge), stub(d.runtime)) },
+    ];
+}
+//# sourceMappingURL=toolsets.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "breakpoint-mcp",
-  "version": "1.14.0",
+  "version": "1.19.0",
   "description": "MCP server exposing Godot to AI coding assistants over the Model Context Protocol — developed and tested with Claude — across four planes (CLI, live editor, LSP+DAP, runtime) with elicitation-gated destructive tools, long jobs on the formal MCP task model, captured console output, and MCP resources.",
   "type": "module",
   "license": "MIT",