@npgamedev/godot-mcp-server 0.0.1 → 1.0.0

package/dist/extensions/extensionChanges.js

@@ -0,0 +1,131 @@
+import { isExcludedByReadOnly } from "../security/profiles.js";
+import { registerGroupSystem, addExtensionGroup, removeExtensionCommand, removeUngroupedExtensionTool, } from "../groups/groups.js";
+import { removeToolByName, updateToolRef, hasToolRef } from "../registration/toolRefs.js";
+import { batchToolRegistration } from "../registration/toolRegistry.js";
+import { extensionNameCollides } from "../registration/extensionCollision.js";
+import { extensionAnnotations, toolNameFromMethod, toExtensionCommand } from "./extensionCommand.js";
+/**
+ * Construct the extension change-application service. The registrar is injected
+ * (the SAME shared instance the facade hands to discovery) so all ledger reads and
+ * mutations land on one consistency boundary; getReadOnly is injected (a live read
+ * of profiles.isReadOnly) so this module depends on no other composition module —
+ * maximising unit-testability with a fake bridge + fake server.
+ */
+export function createExtensionChangeHandler(deps) {
+    const { server, bridge, getReadOnly, registrar } = deps;
+    /**
+     * Handle "extensions.changed" push notification from the toolkit plugin.
+     * Reconciles the tool list inside one batchToolRegistration — adds new tools,
+     * removes dropped ones, updates known ones in-place — so the delta collapses to
+     * a single tools/list_changed; a following discover_tools description refresh
+     * (registerGroupSystem, only when something changed) may emit one more.
+     */
+    function handleExtensionsChanged(params) {
+        const commands = params?.commands;
+        const removedMethods = params?.removed ?? [];
+        if (!Array.isArray(commands)) {
+            process.stderr.write("[godot-mcp] extensions.changed: invalid payload (no commands array)\n");
+            return;
+        }
+        let added = 0;
+        let removed = 0;
+        batchToolRegistration(server, () => {
+            // 1. Remove tools for methods listed in 'removed'.
+            for (const method of removedMethods) {
+                const toolName = toolNameFromMethod(method);
+                if (registrar.isRegistered(toolName)) {
+                    // Try grouped removal first, then ungrouped.
+                    if (!removeExtensionCommand(method)) {
+                        removeUngroupedExtensionTool(toolName);
+                    }
+                    registrar.deregister(toolName);
+                    removed++;
+                }
+            }
+            // 2. Process current command set — register new tools, reconcile known ones.
+            const ungrouped = [];
+            for (const cmd of commands) {
+                const toolName = toolNameFromMethod(cmd.method);
+                const annotations = extensionAnnotations(cmd);
+                if (registrar.isRegistered(toolName)) {
+                    // Known tool — reconcile annotation/description changes in-place.
+                    if (!cmd.group?.name) {
+                        // Ungrouped: update or register/remove based on read-only eligibility.
+                        const isToolRegistered = hasToolRef(toolName);
+                        const shouldBeRegistered = !isExcludedByReadOnly(getReadOnly(), annotations);
+                        if (isToolRegistered && !shouldBeRegistered) {
+                            // Was eligible, now excluded (e.g., readOnlyHint removed in read-only mode).
+                            removeUngroupedExtensionTool(toolName);
+                            removed++;
+                        }
+                        else if (!isToolRegistered && shouldBeRegistered) {
+                            // Was excluded, now eligible (e.g., readOnlyHint added in read-only mode).
+                            // Feed into the ungrouped registration path below.
+                            registrar.deregister(toolName);
+                            ungrouped.push(cmd);
+                        }
+                        else if (isToolRegistered) {
+                            // Still registered — update description + annotations in-place.
+                            updateToolRef(toolName, {
+                                description: cmd.description || `Extension: ${cmd.method}`,
+                                annotations,
+                            });
+                        }
+                    }
+                    // Grouped: addExtensionGroup replaces commands, so re-add to pick up changes.
+                    // Already-loaded group tools are updated via updateToolRef if registered.
+                    if (cmd.group?.name) {
+                        const extCmd = toExtensionCommand(cmd, annotations);
+                        addExtensionGroup(cmd.group.name, cmd.group.description ?? "", [extCmd], cmd.group.keywords);
+                        // If the group is loaded and the tool is registered, update in-place.
+                        if (hasToolRef(toolName)) {
+                            const shouldBeRegistered = !isExcludedByReadOnly(getReadOnly(), annotations);
+                            if (!shouldBeRegistered) {
+                                removeToolByName(toolName);
+                                removed++;
+                            }
+                            else {
+                                updateToolRef(toolName, {
+                                    description: cmd.description || `Extension: ${cmd.method}`,
+                                    annotations,
+                                });
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // New tool — refuse a name that shadows a built-in or another tool (before
+                // it can enter the ledger or a group; the incumbent wins), then partition.
+                if (extensionNameCollides(toolName))
+                    continue;
+                if (cmd.group?.name) {
+                    const extCmd = toExtensionCommand(cmd, annotations);
+                    addExtensionGroup(cmd.group.name, cmd.group.description ?? "", [extCmd], cmd.group.keywords);
+                    registrar.register(toolName);
+                    added++;
+                }
+                else {
+                    ungrouped.push(cmd);
+                }
+            }
+            // Register ungrouped tools (new + newly-eligible from annotation changes).
+            for (const cmd of ungrouped) {
+                const toolName = toolNameFromMethod(cmd.method);
+                if (hasToolRef(toolName))
+                    continue; // Dedup guard.
+                if (registrar.registerExtensionTool(cmd)) {
+                    registrar.register(toolName);
+                    added++;
+                }
+            }
+        });
+        // Update discover_tools description if extension groups changed.
+        if (added > 0 || removed > 0) {
+            registerGroupSystem(server, bridge, getReadOnly());
+        }
+        if (added > 0 || removed > 0) {
+            process.stderr.write(`[godot-mcp] extensions.changed: +${added} -${removed} tools\n`);
+        }
+    }
+    return { handleExtensionsChanged };
+}

package/dist/extensions/extensionCommand.js

@@ -0,0 +1,25 @@
+/** Map an extension method name ("a.b.c") to its MCP tool name ("a_b_c"). */
+export function toolNameFromMethod(method) {
+    return method.replace(/\./g, "_");
+}
+/** Build the MCP annotation object for an extension command, defaulting each
+ *  hint to false when the plugin omits it. */
+export function extensionAnnotations(cmd) {
+    return {
+        readOnlyHint: cmd.annotations?.readOnlyHint ?? false,
+        destructiveHint: cmd.annotations?.destructiveHint ?? false,
+        idempotentHint: cmd.annotations?.idempotentHint ?? false,
+    };
+}
+/** Build the grouped ExtensionCmd model from a wire command and its already-computed
+ *  annotations. Callers compute annotations once (they also need it for the read-only
+ *  eligibility check), so it is passed in rather than recomputed here. */
+export function toExtensionCommand(cmd, annotations) {
+    return {
+        method: cmd.method,
+        toolName: toolNameFromMethod(cmd.method),
+        description: cmd.description || `Extension: ${cmd.method}`,
+        inputSchema: cmd.input_schema ?? {},
+        annotations,
+    };
+}

package/dist/extensions/extensionDiscovery.js

@@ -0,0 +1,141 @@
+import { registerGroupSystem, addExtensionGroup } from "../groups/groups.js";
+import { batchToolRegistration } from "../registration/toolRegistry.js";
+import { extensionNameCollides } from "../registration/extensionCollision.js";
+import { extensionAnnotations, toolNameFromMethod, toExtensionCommand } from "./extensionCommand.js";
+// Generous for the editor-running case (<1s); protects against the rare
+// hanging-WebSocket-handshake scenario (editor partially started, port
+// open but not yet accepting). When the editor is fully down,
+// ECONNREFUSED fires in ~50ms — the deadline is irrelevant.
+const EXTENSION_DISCOVERY_DEADLINE_MS = 8000;
+/**
+ * Construct the extension discovery service. The registrar is injected (the SAME
+ * shared instance the facade hands to change-application) so all ledger mutation
+ * lands on one consistency boundary; getReadOnly is injected (a live read of
+ * profiles.isReadOnly) so this module depends on no other composition module —
+ * maximising unit-testability with a fake bridge + fake server.
+ */
+export function createExtensionDiscovery(deps) {
+    const { server, bridge, getReadOnly, registrar } = deps;
+    // Single-flight latch for discoverExtensions. Holds the currently-running
+    // discovery promise so a concurrent caller joins it instead of starting a
+    // second pass.
+    let discoveryInFlight = undefined;
+    // Discover third-party extensions from the toolkit and register them as
+    // MCP tools. Called eagerly before transport (deadline-wrapped) at startup,
+    // and again from handleConfigReload on config changes.
+    //
+    // Single-flight: if a discovery is already running, JOIN it rather than start
+    // a second concurrent pass. Without this, the eager
+    // discovery losing the 8s Promise.race deadline stays in-flight, and the
+    // immediate startup reconcile (maybeStartupReconcile → handleConfigReload) would
+    // fire a second discoverExtensions() — two concurrent passes issuing duplicate
+    // extensions.refresh RPCs and double-registering the same ungrouped tools (a
+    // swallowed "already registered" throw + up to 2× tools/list_changed). The latch
+    // engages ONLY when a discovery is genuinely concurrent; in the common case and
+    // the server-before-editor fast-fail the eager pass settles (and clears the
+    // latch) before any reconcile fires, so this is a transparent pass-through.
+    //
+    // Safe against handleConfigReload's removeAllTools(): a joined pass always
+    // registers AFTER the reconcile's synchronous removeAllTools()+module rebuild
+    // (the eager pass is still awaiting its RPC when the timeout fires, so it has
+    // registered nothing yet), landing the extension tools exactly once on the
+    // freshly-rebuilt surface. If a prior pass had already registered, it has
+    // settled → the latch is clear → a fresh discovery runs. Either way: registered
+    // exactly once. registrar.register() (the ledger add) is idempotent across joins.
+    //
+    // Accepted residual (deferred fix, post-1.0): a join inherits a FAILING eager
+    // pass — if the joined discovery's RPC fails, the reconcile registers zero
+    // extensions and consumes its one-shot, so extensions recover only on the next
+    // extensions.changed / extensions_refresh / reconnect. Ultra-narrow + self-
+    // healing; built-ins unaffected. Deferred fix = retry a fresh pass on an empty join.
+    function discoverExtensions() {
+        if (discoveryInFlight)
+            return discoveryInFlight;
+        const run = runDiscovery().finally(() => {
+            // Clear only if still ours — a later pass may have replaced the latch.
+            if (discoveryInFlight === run)
+                discoveryInFlight = undefined;
+        });
+        discoveryInFlight = run;
+        return run;
+    }
+    async function runDiscovery() {
+        let registered = 0;
+        let deferredCount = 0;
+        try {
+            let result;
+            try {
+                result = (await bridge.call("extensions.refresh", {}, 5000));
+            }
+            catch {
+                result = (await bridge.call("extensions.list", {}, 5000));
+            }
+            if (result?.success && Array.isArray(result.commands)) {
+                // Partition commands: ungrouped → immediate, grouped → deferred.
+                // Collect ungrouped for batched registration (1 notification).
+                const ungrouped = [];
+                for (const cmd of result.commands) {
+                    const toolName = toolNameFromMethod(cmd.method);
+                    // Skip a name that shadows a built-in or another tool before it can enter
+                    // the known-extension ledger or a deferred group — the incumbent wins.
+                    if (extensionNameCollides(toolName))
+                        continue;
+                    registrar.register(toolName);
+                    const annotations = extensionAnnotations(cmd);
+                    if (cmd.group?.name) {
+                        const extCmd = toExtensionCommand(cmd, annotations);
+                        addExtensionGroup(cmd.group.name, cmd.group.description ?? "", [extCmd], cmd.group.keywords);
+                        deferredCount++;
+                    }
+                    else {
+                        ungrouped.push(cmd);
+                    }
+                }
+                // Batch ungrouped extension tool registrations into a single notification.
+                // Grouped extensions stay deferred — loaded via discover_tools.
+                if (ungrouped.length > 0) {
+                    batchToolRegistration(server, () => {
+                        for (const cmd of ungrouped) {
+                            if (registrar.registerExtensionTool(cmd))
+                                registered++;
+                        }
+                    });
+                }
+            }
+        }
+        catch {
+            // Editor unreachable or extensions.list not available — not an error.
+            // Fall through to register discover_tools with built-in groups only.
+        }
+        // Update discover_tools description to include extension groups.
+        // Uses in-place update (1 notification). For the common case
+        // (no extensions), discover_tools was already registered at startup.
+        if (deferredCount > 0) {
+            registerGroupSystem(server, bridge, getReadOnly());
+        }
+        if (registered > 0 || deferredCount > 0) {
+            const parts = [];
+            if (registered > 0)
+                parts.push(`${registered} registered`);
+            if (deferredCount > 0)
+                parts.push(`${deferredCount} deferred in groups`);
+            process.stderr.write(`[godot-mcp] extensions: ${parts.join(" + ")}\n`);
+        }
+        // Defensive re-registration: on the handleConfigReload path,
+        // removeAllTools() has cleared extensions_refresh, so re-add it.
+        // Delegates to registrar.registerRefreshTool() (self-guards via hasToolRef),
+        // which is the same helper used by the startup path.
+        registrar.registerRefreshTool();
+    }
+    function discoverEagerly(deadlineMs = EXTENSION_DISCOVERY_DEADLINE_MS) {
+        // Wrap discovery in the deadline so a slow/hanging editor handshake can't
+        // block startup. On deadline or discovery error, the caller (the startup
+        // reconcile) re-runs discovery once the version is known (immediately if it
+        // already is); the LLM can also call extensions_refresh (always registered).
+        return Promise.race([
+            discoverExtensions(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("extension discovery deadline")), deadlineMs)),
+        ]).then(() => ({ timedOut: false }), () => ({ timedOut: true }));
+    }
+    return { discoverExtensions, discoverEagerly };
+}

package/dist/extensions/extensionRegistrar.js

@@ -0,0 +1,82 @@
+import { isExcludedByReadOnly } from "../security/profiles.js";
+import { hasToolRef } from "../registration/toolRefs.js";
+import { registerToolWrapped } from "../registration/toolRegistry.js";
+import { extensionNameCollides } from "../registration/extensionCollision.js";
+import { callAndWrap } from "../registration/toolDispatch.js";
+import { extensionAnnotations, toolNameFromMethod } from "./extensionCommand.js";
+const DEFAULT_EXTENSION_TIMEOUT_MS = 30_000;
+/**
+ * Construct the extension registrar. getReadOnly is injected (a live read of
+ * profiles.isReadOnly) so this module depends on no other composition module —
+ * maximising unit-testability with a fake bridge + fake server.
+ */
+export function createExtensionRegistrar(deps) {
+    const { server, bridge, getReadOnly } = deps;
+    // The known-extension ledger: the names the subsystem currently considers
+    // registered. The raw Set is never exposed — all access goes through the
+    // register / isRegistered / deregister accessors below.
+    const knownExtensionTools = new Set();
+    /** Build a context-aware timeout hint for extension tools. */
+    function buildExtensionTimeoutHint(method, timeoutMs) {
+        const effectiveMs = timeoutMs ?? DEFAULT_EXTENSION_TIMEOUT_MS;
+        if (timeoutMs != null) {
+            return (`Extension tool '${method}' timed out after ${effectiveMs}ms (custom timeout). ` +
+                "If this exceeds 5 minutes, consider restructuring the tool to start work and return a polling handle rather than blocking the bridge.");
+        }
+        return (`Extension tool '${method}' timed out after ${effectiveMs / 1000}s. ` +
+            "If this tool calls external services, the extension author can increase timeout_ms in registry.add() options.");
+    }
+    function registerRefreshTool() {
+        if (!hasToolRef("extensions_refresh")) {
+            registerToolWrapped(server, bridge, "extensions_refresh", {
+                description: "Force a filesystem rescan and re-discover extension scripts. " +
+                    "Call after creating, modifying, or deleting extension files from outside the Godot editor. " +
+                    "Returns the updated list of extension commands.",
+                annotations: { readOnlyHint: true, idempotentHint: true },
+            }, (input, signal) => callAndWrap(bridge, "extensions.refresh", input, { signal }));
+        }
+    }
+    /**
+     * Register one ungrouped extension command as an MCP tool. Returns true when the
+     * tool was registered, false when skipped by read-only exclusion. Callers own
+     * their own pre-checks (dedup guard), counters, and knownExtensionTools
+     * bookkeeping — this encapsulates only the shared registration recipe common to
+     * the eager-discovery and live-reconciliation ungrouped paths.
+     */
+    function registerExtensionTool(cmd) {
+        const toolName = toolNameFromMethod(cmd.method);
+        // Refuse a name that shadows a built-in or an already-registered tool — the
+        // incumbent keeps the name (defence-in-depth at the registration choke point).
+        if (extensionNameCollides(toolName))
+            return false;
+        const annotations = extensionAnnotations(cmd);
+        // Read-only mode: skip extension tools that aren't read-only.
+        if (isExcludedByReadOnly(getReadOnly(), annotations))
+            return false;
+        const timeoutMs = cmd.timeout_ms ?? undefined;
+        const extensionTimeoutHint = buildExtensionTimeoutHint(cmd.method, timeoutMs);
+        registerToolWrapped(server, bridge, toolName, {
+            description: cmd.description || `Extension: ${cmd.method}`,
+            inputSchema: cmd.input_schema ?? {},
+            annotations,
+        }, (input, signal) => callAndWrap(bridge, cmd.method, input, {
+            timeoutMs,
+            extensionTimeoutHint,
+            signal,
+        }), {
+            godotMinVersion: cmd.min_godot_version,
+            godotMaxVersion: cmd.max_godot_version,
+        });
+        return true;
+    }
+    function register(toolName) {
+        knownExtensionTools.add(toolName);
+    }
+    function isRegistered(toolName) {
+        return knownExtensionTools.has(toolName);
+    }
+    function deregister(toolName) {
+        knownExtensionTools.delete(toolName);
+    }
+    return { registerExtensionTool, registerRefreshTool, register, isRegistered, deregister };
+}

package/dist/extensions/extensions.js

@@ -0,0 +1,33 @@
+import { createExtensionRegistrar } from "./extensionRegistrar.js";
+import { createExtensionDiscovery } from "./extensionDiscovery.js";
+import { createExtensionChangeHandler } from "./extensionChanges.js";
+/**
+ * Construct the extension manager. getReadOnly is injected (a live read of
+ * profiles.isReadOnly) so this module depends on no other composition module —
+ * maximising unit-testability with a fake bridge + fake server.
+ *
+ * @returns the {@link ExtensionManager} facade over one shared registrar (single
+ *   ledger), the discovery service, and the change-application service
+ */
+export function createExtensionManager(deps) {
+    const { server, bridge, getReadOnly } = deps;
+    // One shared registrar — owns the known-extension ledger + the register-one-tool
+    // recipe + the always-on refresh tool. The discovery and change-application
+    // services operate on THIS instance, so the ledger stays a single shared
+    // consistency boundary (two registrars would fork it).
+    const registrar = createExtensionRegistrar({ server, bridge, getReadOnly });
+    // The discovery service — the eager, deadline-wrapped, single-flight pull of
+    // extensions and their bulk registration. Injected the SAME registrar so its
+    // ledger mutations land on the one shared consistency boundary.
+    const discovery = createExtensionDiscovery({ server, bridge, getReadOnly, registrar });
+    // The change-application service — applies one extensions.changed delta
+    // (removed[] + commands) to the live surface. Injected the SAME registrar so its
+    // ledger reads/mutations land on the one shared consistency boundary.
+    const changes = createExtensionChangeHandler({ server, bridge, getReadOnly, registrar });
+    return {
+        registerRefreshTool: registrar.registerRefreshTool,
+        discoverExtensions: discovery.discoverExtensions,
+        discoverEagerly: discovery.discoverEagerly,
+        handleExtensionsChanged: changes.handleExtensionsChanged,
+    };
+}

package/dist/groups/builtinGroups.js

@@ -0,0 +1,60 @@
+import { runtimeAdvancedGroup } from "./defs/runtimeAdvanced.js";
+import { signalsGroup } from "./defs/signals.js";
+import { animationAuthoringGroup } from "./defs/animationAuthoring.js";
+import { inputMapGroup } from "./defs/inputMap.js";
+import { resourceIoGroup } from "./defs/resourceIo.js";
+import { assetOpsGroup } from "./defs/assetOps.js";
+import { placeholdersGroup } from "./defs/placeholders.js";
+import { cleanupGroup } from "./defs/cleanup.js";
+import { userDataGroup } from "./defs/userData.js";
+import { sceneAdvancedGroup } from "./defs/sceneAdvanced.js";
+import { editorAdvancedGroup } from "./defs/editorAdvanced.js";
+import { tilemapGroup } from "./defs/tilemap.js";
+import { tilesetGroup } from "./defs/tileset.js";
+import { tilesetEditGroup } from "./defs/tilesetEdit.js";
+import { themeGroup } from "./defs/theme.js";
+import { layerNamingGroup } from "./defs/layerNaming.js";
+import { pathEditingGroup } from "./defs/pathEditing.js";
+import { threeDToolsGroup } from "./defs/3dTools.js";
+import { proceduralGroup } from "./defs/procedural.js";
+import { sceneInheritanceGroup } from "./defs/sceneInheritance.js";
+import { audioGroup } from "./defs/audio.js";
+import { spriteframesGroup } from "./defs/spriteframes.js";
+import { particlesGroup } from "./defs/particles.js";
+import { navigationGroup } from "./defs/navigation.js";
+import { lspCodeAnalysisGroup } from "./defs/lspCodeAnalysis.js";
+import { lspCodeNavigationGroup } from "./defs/lspCodeNavigation.js";
+import { debuggerGroup } from "./defs/debugger.js";
+import { classdbGroup } from "./defs/classdb.js";
+// Canonical group order — the single source of truth for discover_tools
+// enumeration (placeholders is 7th; classdb is last). Do NOT reorder.
+export const GROUPS = [
+    runtimeAdvancedGroup,
+    signalsGroup,
+    animationAuthoringGroup,
+    inputMapGroup,
+    resourceIoGroup,
+    assetOpsGroup,
+    placeholdersGroup,
+    cleanupGroup,
+    userDataGroup,
+    sceneAdvancedGroup,
+    editorAdvancedGroup,
+    tilemapGroup,
+    tilesetGroup,
+    tilesetEditGroup,
+    themeGroup,
+    layerNamingGroup,
+    pathEditingGroup,
+    threeDToolsGroup,
+    proceduralGroup,
+    sceneInheritanceGroup,
+    audioGroup,
+    spriteframesGroup,
+    particlesGroup,
+    navigationGroup,
+    lspCodeAnalysisGroup,
+    lspCodeNavigationGroup,
+    debuggerGroup,
+    classdbGroup,
+];

package/dist/groups/defs/3dTools.js

@@ -0,0 +1,17 @@
+export const threeDToolsGroup = {
+    name: "3d_tools",
+    description: "Create 3D primitives, lights, cameras, and environment setups",
+    tools: ["3d_create_primitive", "3d_setup_environment", "3d_create_light", "3d_create_camera"],
+    keywords: [
+        "3d",
+        "mesh",
+        "meshinstance",
+        "primitive",
+        "camera3d",
+        "light",
+        "environment",
+        "directional light",
+        "world environment",
+        "sky",
+    ],
+};

package/dist/groups/defs/animationAuthoring.js

@@ -0,0 +1,16 @@
+export const animationAuthoringGroup = {
+    name: "animation_authoring",
+    description: "Inspect and author keyframes, edit tracks, and configure AnimationTree state machines",
+    tools: ["animation_keyframe", "animation_get_keys", "animationtree_edit", "animationtree_list"],
+    keywords: [
+        "animation",
+        "keyframe",
+        "track",
+        "animate",
+        "animationtree",
+        "state machine",
+        "blend tree",
+        "transition",
+        "blend",
+    ],
+};

package/dist/groups/defs/assetOps.js

@@ -0,0 +1,6 @@
+export const assetOpsGroup = {
+    name: "asset_ops",
+    description: "List assets, query dependencies, and import binary files into the project",
+    tools: ["asset_list", "asset_get_dependencies", "asset_import"],
+    keywords: ["asset", "import", "dependencies", "texture", "image", "list assets", "files", "browse"],
+};

package/dist/groups/defs/audio.js

@@ -0,0 +1,6 @@
+export const audioGroup = {
+    name: "audio",
+    description: "List and configure audio buses, effects, and volume settings",
+    tools: ["audiobus_edit", "audiobus_list"],
+    keywords: ["audio", "audiobus", "sound", "music", "volume", "bus", "effect", "reverb", "sfx"],
+};

package/dist/groups/defs/classdb.js

@@ -0,0 +1,6 @@
+export const classdbGroup = {
+    name: "classdb",
+    description: "Search and inspect Godot class hierarchy — properties, methods, signals, inheritance",
+    tools: ["classdb_get_info", "classdb_search"],
+    keywords: ["class", "classdb", "api", "inheritance", "introspection"],
+};

package/dist/groups/defs/cleanup.js

@@ -0,0 +1,6 @@
+export const cleanupGroup = {
+    name: "cleanup",
+    description: "Delete files, scripts, scenes, resources, and folders; close open scenes",
+    tools: ["file_delete", "scene_delete", "script_delete", "resource_delete", "folder_delete", "scene_close"],
+    keywords: ["delete", "cleanup", "close", "remove", "delete file", "delete scene", "delete script"],
+};

package/dist/groups/defs/debugger.js

@@ -0,0 +1,6 @@
+export const debuggerGroup = {
+    name: "debugger",
+    description: "Inspect debugger state, manage breakpoints, and control execution flow",
+    tools: ["debug_state", "debug_list_breakpoints", "debug_set_breakpoint", "debug_continue"],
+    keywords: ["debug", "breakpoint", "pause", "continue", "step", "debugger", "state", "breaked"],
+};

package/dist/groups/defs/editorAdvanced.js

@@ -0,0 +1,16 @@
+export const editorAdvancedGroup = {
+    name: "editor_advanced",
+    description: "Capture editor screenshots, refresh the filesystem, and wait for idle",
+    tools: ["editor_screenshot", "editor_refresh", "editor_wait_for_idle"],
+    keywords: [
+        "screenshot",
+        "editor screenshot",
+        "refresh",
+        "reload scripts",
+        "rescan",
+        "filesystem",
+        "reimport",
+        "wait idle",
+        "editor capture",
+    ],
+};

package/dist/groups/defs/inputMap.js

@@ -0,0 +1,6 @@
+export const inputMapGroup = {
+    name: "input_map",
+    description: "List, create, and edit input actions and their key/controller bindings",
+    tools: ["input_map_action", "input_map_event"],
+    keywords: ["input", "input map", "action", "key binding", "keybind", "keyboard", "controller", "gamepad", "joystick"],
+};

package/dist/groups/defs/layerNaming.js

@@ -0,0 +1,6 @@
+export const layerNamingGroup = {
+    name: "layer_naming",
+    description: "Get and set physics, render, and navigation layer names",
+    tools: ["layer_names_set", "layer_names_get"],
+    keywords: ["layer", "layer name", "physics layer", "render layer", "collision layer", "collision mask", "mask"],
+};

package/dist/groups/defs/lspCodeAnalysis.js

@@ -0,0 +1,23 @@
+export const lspCodeAnalysisGroup = {
+    name: "lsp_code_analysis",
+    description: "GDScript diagnostics, symbols, hover info, and a project-wide compile check via the language server",
+    tools: ["lsp_diagnostics", "lsp_symbols", "lsp_hover", "lsp_project_diagnostics"],
+    keywords: [
+        "lsp",
+        "diagnostics",
+        "symbols",
+        "hover",
+        "type",
+        "gdscript",
+        "shader",
+        "gdshader",
+        "errors",
+        "warnings",
+        "validate",
+        "analyze",
+        "project",
+        "whole project",
+        "all scripts",
+        "compile",
+    ],
+};

package/dist/groups/defs/lspCodeNavigation.js

@@ -0,0 +1,15 @@
+export const lspCodeNavigationGroup = {
+    name: "lsp_code_navigation",
+    description: "Code completion, go-to-definition, and find references via the language server",
+    tools: ["lsp_completion", "lsp_definition", "lsp_references"],
+    keywords: [
+        "completion",
+        "definition",
+        "references",
+        "go to definition",
+        "find references",
+        "autocomplete",
+        "navigate",
+        "cross-file",
+    ],
+};

package/dist/groups/defs/navigation.js

@@ -0,0 +1,17 @@
+export const navigationGroup = {
+    name: "navigation",
+    description: "Set up navigation regions, meshes, and obstacle avoidance",
+    tools: ["navigation_edit"],
+    keywords: [
+        "nav",
+        "navigation",
+        "navmesh",
+        "pathfinding",
+        "navigate",
+        "obstacle",
+        "avoidance",
+        "navigation region",
+        "nav polygon",
+        "ai pathfinding",
+    ],
+};