@npgamedev/godot-mcp-server 0.0.1 → 1.0.1

package/dist/groups/defs/particles.js

@@ -0,0 +1,21 @@
+export const particlesGroup = {
+    name: "particles",
+    description: "Create and configure GPU particle systems for visual effects",
+    tools: ["particles_create"],
+    keywords: [
+        "particle",
+        "particles",
+        "gpu particles",
+        "vfx",
+        "visual effect",
+        "effects",
+        "fire",
+        "smoke",
+        "sparks",
+        "rain",
+        "snow",
+        "explosion",
+        "emitter",
+        "particle system",
+    ],
+};

package/dist/groups/defs/pathEditing.js

@@ -0,0 +1,22 @@
+export const pathEditingGroup = {
+    name: "path_editing",
+    description: "Edit Path2D curves and generate collision shapes from sprite textures",
+    tools: ["path2d_edit_curve", "collision_from_texture"],
+    keywords: [
+        "path",
+        "path2d",
+        "curve",
+        "bezier",
+        "spline",
+        "follow path",
+        "pathfollow",
+        "curve2d",
+        "2d",
+        "collision",
+        "collision polygon",
+        "sprite",
+        "bitmap",
+        "alpha",
+        "shape from texture",
+    ],
+};

package/dist/groups/defs/placeholders.js

@@ -0,0 +1,28 @@
+export const placeholdersGroup = {
+    name: "placeholders",
+    description: "Generate placeholder/prototype assets procedurally — textures (shapes, patterns, labels) and sound effects (tones, noise). No art or network needed.",
+    tools: ["texture_generate", "sound_generate"],
+    keywords: [
+        "placeholder",
+        "prototype",
+        "prototyping",
+        "stand-in",
+        "mock",
+        "generate",
+        "procedural",
+        "texture",
+        "sprite",
+        "image",
+        "icon",
+        "png",
+        "sound",
+        "sfx",
+        "audio",
+        "tone",
+        "beep",
+        "noise",
+        "wav",
+        "art",
+        "asset",
+    ],
+};

package/dist/groups/defs/procedural.js

@@ -0,0 +1,6 @@
+export const proceduralGroup = {
+    name: "procedural",
+    description: "Edit gradients, curves, and FastNoiseLite resources for procedural generation",
+    tools: ["procedural_edit_gradient", "procedural_edit_curve", "procedural_edit_noise"],
+    keywords: ["procedural", "generate", "gradient", "noise", "curve", "resource create", "fastnoiselite", "easing"],
+};

package/dist/groups/defs/resourceIo.js

@@ -0,0 +1,6 @@
+export const resourceIoGroup = {
+    name: "resource_io",
+    description: "Load and write Godot resources (.tres/.res) programmatically",
+    tools: ["resource_load", "resource_write"],
+    keywords: ["resource", "load", "write", "save resource", "tres", "res"],
+};

package/dist/groups/defs/runtimeAdvanced.js

@@ -0,0 +1,17 @@
+export const runtimeAdvancedGroup = {
+    name: "runtime_advanced",
+    description: "Inspect live node state, set node properties, and control AnimationPlayer during playtests",
+    tools: ["runtime_get_node_state", "runtime_set_property", "animation_player_control"],
+    keywords: [
+        "runtime",
+        "node state",
+        "set property",
+        "runtime property",
+        "animation playback",
+        "animationplayer",
+        "play animation",
+        "stop animation",
+        "animation control",
+        "inspect node",
+    ],
+};

package/dist/groups/defs/sceneAdvanced.js

@@ -0,0 +1,6 @@
+export const sceneAdvancedGroup = {
+    name: "scene_advanced",
+    description: "Diff scenes and batch-instantiate nodes from packed scenes",
+    tools: ["scene_diff", "scene_instantiate"],
+    keywords: ["instantiate", "instance", "scene diff", "compare", "prefab", "spawn", "batch instantiate"],
+};

package/dist/groups/defs/sceneInheritance.js

@@ -0,0 +1,6 @@
+export const sceneInheritanceGroup = {
+    name: "scene_inheritance",
+    description: "Create inherited scenes (variants) from base scenes",
+    tools: ["scene_create_inherited"],
+    keywords: ["inheritance", "inherited scene", "prefab", "variant", "base scene", "scene extend", "inherit"],
+};

package/dist/groups/defs/signals.js

@@ -0,0 +1,6 @@
+export const signalsGroup = {
+    name: "signals",
+    description: "Emit signals on scene nodes at editor-time or runtime",
+    tools: ["signal_emit"],
+    keywords: ["signal", "emit", "observer", "event", "handler", "callback"],
+};

package/dist/groups/defs/spriteframes.js

@@ -0,0 +1,16 @@
+export const spriteframesGroup = {
+    name: "spriteframes",
+    description: "List, create, and edit SpriteFrames animations and import from spritesheets",
+    tools: ["spriteframes_create", "spriteframes_edit", "spriteframes_from_spritesheet"],
+    keywords: [
+        "sprite",
+        "spriteframes",
+        "animated sprite",
+        "frame",
+        "flipbook",
+        "2d animation",
+        "spritesheet",
+        "atlas",
+        "2d",
+    ],
+};

package/dist/groups/defs/theme.js

@@ -0,0 +1,6 @@
+export const themeGroup = {
+    name: "theme",
+    description: "Edit UI theme overrides: styleboxes, fonts, colors, and constants",
+    tools: ["theme_edit"],
+    keywords: ["theme", "style", "stylebox", "font", "color", "ui style", "control theme"],
+};

package/dist/groups/defs/tilemap.js

@@ -0,0 +1,6 @@
+export const tilemapGroup = {
+    name: "tilemap",
+    description: "Read and paint cells on TileMap/TileMapLayer nodes — cell queries, bulk fills, and region operations",
+    tools: ["tilemap_read_cells", "tilemap_set_cells"],
+    keywords: ["tilemap", "tile", "grid", "cell", "read cells", "paint cells", "2d"],
+};

package/dist/groups/defs/tileset.js

@@ -0,0 +1,22 @@
+export const tilesetGroup = {
+    name: "tileset",
+    description: "Create TileSet resources, add atlas sources, configure layers, and manage tile alternatives",
+    tools: [
+        "tileset_create",
+        "tileset_add_source",
+        "tileset_remove_source",
+        "tileset_add_alternative",
+        "tileset_remove_alternative",
+        "tileset_setup_layers",
+    ],
+    keywords: [
+        "tileset",
+        "atlas",
+        "tile source",
+        "tile layer",
+        "terrain set",
+        "tile alternative",
+        "tile variant",
+        "create tileset",
+    ],
+};

package/dist/groups/defs/tilesetEdit.js

@@ -0,0 +1,21 @@
+export const tilesetEditGroup = {
+    name: "tileset_edit",
+    description: "Edit per-tile properties: physics, terrain, navigation, visuals, and custom data",
+    tools: [
+        "tileset_edit_physics",
+        "tileset_edit_terrain",
+        "tileset_edit_navigation",
+        "tileset_edit_visuals",
+        "tileset_edit_custom_data",
+    ],
+    keywords: [
+        "tileset collision",
+        "tile physics",
+        "tile terrain",
+        "tile navigation",
+        "tile occlusion",
+        "tile animation",
+        "tile custom data",
+        "peering bits",
+    ],
+};

package/dist/groups/defs/userData.js

@@ -0,0 +1,6 @@
+export const userDataGroup = {
+    name: "user_data",
+    description: "Read, write, delete, and list user:// save files",
+    tools: ["save_read", "save_write", "save_delete", "save_list"],
+    keywords: ["save", "save file", "user data", "persistence", "save game", "load game", "savegame"],
+};

package/dist/groups/extensionGroups.js

@@ -0,0 +1,182 @@
+import { activatedResult, alreadyLoadedResult, availableResult, readOnlyEmptyResult } from "./groupResult.js";
+import { registerToolWrapped } from "../registration/toolRegistry.js";
+import { callAndWrap } from "../registration/toolDispatch.js";
+import { removeToolByName } from "../registration/toolRefs.js";
+import { extensionNameCollides } from "../registration/extensionCollision.js";
+import { isAllowedInReadOnly, isExcludedByReadOnly } from "../security/profiles.js";
+// ── Registry state (private — read only through the accessors below) ──
+const extensionGroups = new Map();
+const loadedExtensionGroups = new Set();
+// ── Mutators ─────────────────────────────────────────────────────────
+/** Register a deferred extension group (called from discoverExtensions). Deduplicates by method name. */
+export function addExtensionGroup(name, description, commands, keywords) {
+    const existing = extensionGroups.get(name);
+    if (existing) {
+        for (const cmd of commands) {
+            if (!existing.commands.some((c) => c.method === cmd.method)) {
+                existing.commands.push(cmd);
+            }
+        }
+        // Merge description if different.
+        if (description && description !== existing.description) {
+            existing.description = existing.description + "; " + description;
+        }
+        // Merge keywords without duplicates.
+        if (keywords) {
+            for (const kw of keywords) {
+                if (!existing.keywords.includes(kw))
+                    existing.keywords.push(kw);
+            }
+        }
+    }
+    else {
+        extensionGroups.set(name, { name, description, keywords: keywords ?? [], commands });
+    }
+}
+/** Remove a single command from an extension group by method name. Returns true if found. */
+export function removeExtensionCommand(method) {
+    for (const [name, group] of extensionGroups) {
+        const idx = group.commands.findIndex((c) => c.method === method);
+        if (idx >= 0) {
+            const toolName = group.commands[idx].toolName;
+            group.commands.splice(idx, 1);
+            removeToolByName(toolName);
+            // If no commands remain, remove the entire group.
+            if (group.commands.length === 0) {
+                extensionGroups.delete(name);
+                loadedExtensionGroups.delete(name);
+            }
+            return true;
+        }
+    }
+    return false;
+}
+/** Remove an entire extension group by name. Unregisters all its tools. */
+export function removeExtensionGroup(name) {
+    const group = extensionGroups.get(name);
+    if (!group)
+        return false;
+    for (const cmd of group.commands) {
+        removeToolByName(cmd.toolName);
+    }
+    extensionGroups.delete(name);
+    loadedExtensionGroups.delete(name);
+    return true;
+}
+/** Remove an ungrouped extension tool by its method-derived tool name. */
+export function removeUngroupedExtensionTool(toolName) {
+    return removeToolByName(toolName);
+}
+/** Whether any extension groups exist (used to decide if refresh needed). */
+export function hasExtensionGroups() {
+    return extensionGroups.size > 0;
+}
+// ── Registration ─────────────────────────────────────────────────────
+/** Register an extension group's tools (called from discover_tools handler). */
+export function registerExtGroupTools(server, bridge, group, readOnly = false) {
+    const registered = [];
+    for (const cmd of group.commands) {
+        if (isExcludedByReadOnly(readOnly, cmd.annotations))
+            continue;
+        // A grouped extension tool can only clash with a built-in or another group's
+        // tool at activation time (registration is deferred + order-dependent) — refuse
+        // it here so the incumbent is never overwritten.
+        if (extensionNameCollides(cmd.toolName))
+            continue;
+        registerToolWrapped(server, bridge, cmd.toolName, {
+            description: cmd.description,
+            inputSchema: cmd.inputSchema,
+            annotations: {
+                readOnlyHint: cmd.annotations.readOnlyHint ?? false,
+                destructiveHint: cmd.annotations.destructiveHint ?? false,
+                idempotentHint: cmd.annotations.idempotentHint ?? false,
+            },
+        }, (input, signal) => callAndWrap(bridge, cmd.method, input, { signal }));
+        registered.push(cmd.toolName);
+    }
+    return registered;
+}
+// ── Activate / report (CQS split: command + query) ───────────
+/**
+ * Activate an extension group by name (the COMMAND half of the old fused
+ * activateOrReportExtGroup). Idempotent on an already-loaded group; keeps the
+ * read-only "don't waste a slot" guard. The caller dispatches on the activate
+ * flag (activate ? activateExtGroup : reportExtGroupStatus).
+ */
+export function activateExtGroup(server, bridge, name, readOnly = false) {
+    const ext = extensionGroups.get(name);
+    if (!ext) {
+        return availableResult(name, [], `Unknown group: ${name}`);
+    }
+    const toolNames = readOnly
+        ? ext.commands.filter((c) => isAllowedInReadOnly(c.annotations)).map((c) => c.toolName)
+        : ext.commands.map((c) => c.toolName);
+    const tools = toolNames.map((t) => ({ name: t }));
+    if (loadedExtensionGroups.has(name)) {
+        return alreadyLoadedResult(name, tools, ext.description);
+    }
+    const registered = registerExtGroupTools(server, bridge, ext, readOnly);
+    // In read-only mode, if all tools were filtered out, don't waste a group slot.
+    if (readOnly && registered.length === 0) {
+        return readOnlyEmptyResult(name);
+    }
+    loadedExtensionGroups.add(name);
+    return activatedResult(name, registered, ext.description);
+}
+/** Report an extension group's status without mutating (the QUERY half). */
+export function reportExtGroupStatus(name, readOnly = false) {
+    const ext = extensionGroups.get(name);
+    if (!ext)
+        return { name, status: "available", tools: [] };
+    // In read-only mode, filter the tool list to only read-only tools (mirrors the built-in reportGroupStatus,
+    // preserving the old fused activateOrReportExtGroup query behavior). Browse callers omit readOnly (unfiltered).
+    const toolNames = readOnly
+        ? ext.commands.filter((c) => isAllowedInReadOnly(c.annotations)).map((c) => c.toolName)
+        : ext.commands.map((c) => c.toolName);
+    const tools = toolNames.map((t) => ({ name: t }));
+    if (loadedExtensionGroups.has(name))
+        return alreadyLoadedResult(name, tools, ext.description);
+    return availableResult(name, tools, ext.description);
+}
+// ── Purpose accessors (the maps stay private) ──
+/** Clear both registry maps (used by resetLoadedGroups). */
+export function clearExtensionGroups() {
+    extensionGroups.clear();
+    loadedExtensionGroups.clear();
+}
+/**
+ * Unload a loaded extension group: unregister its command tools and clear its
+ * loaded flag. Returns true if the group was loaded (now deactivated), false
+ * otherwise — so deactivateGroups collects exactly the names it unloaded.
+ */
+export function deactivateExtensionGroup(name) {
+    if (!loadedExtensionGroups.has(name))
+        return false;
+    const ext = extensionGroups.get(name);
+    if (ext) {
+        for (const cmd of ext.commands)
+            removeToolByName(cmd.toolName);
+    }
+    loadedExtensionGroups.delete(name);
+    return true;
+}
+/** Iterate the registered extension groups (name → def), in insertion order. */
+export function extensionGroupEntries() {
+    return extensionGroups.entries();
+}
+/** Look up a registered extension group by name. */
+export function getExtensionGroup(name) {
+    return extensionGroups.get(name);
+}
+/** Whether an extension group is currently loaded (its tools registered). */
+export function isExtensionGroupLoaded(name) {
+    return loadedExtensionGroups.has(name);
+}
+/** How many extension groups are currently loaded. */
+export function loadedExtensionGroupCount() {
+    return loadedExtensionGroups.size;
+}
+/** The names of the currently-loaded extension groups, in insertion order. */
+export function loadedExtensionGroupNames() {
+    return [...loadedExtensionGroups];
+}

package/dist/groups/groupActivation.js

@@ -0,0 +1,210 @@
+import { GROUPS, allDefs } from "./groupCatalogue.js";
+import { loadedGroups } from "./groupState.js";
+import { activateExtGroup, reportExtGroupStatus, extensionGroupEntries, isExtensionGroupLoaded, loadedExtensionGroupNames, deactivateExtensionGroup, } from "./extensionGroups.js";
+import { createGroupToolHandler } from "./groupToolHandlers.js";
+import { isAllowedInReadOnly, isExcludedByReadOnly } from "../security/profiles.js";
+import { isVersionCompatible } from "../shared/version.js";
+import { registerToolWrapped } from "../registration/toolRegistry.js";
+import { removeToolByName } from "../registration/toolRefs.js";
+import { activatedResult, alreadyLoadedResult, availableResult, readOnlyEmptyResult } from "./groupResult.js";
+// ── Version-gated visibility ─────────────────────────────────────────
+// discover_tools' group summaries are built from the STATIC catalogue, but the
+// registration gate installs only the tools the connected editor can serve
+// (registerToolWrapped). These predicates re-apply that same gate to the
+// advertise surface, so a below-gate editor never sees a tool that tools/list
+// omits — the advertise surface matches the register surface.
+/**
+ * Whether the connected editor can serve a version-gated built-in — the same
+ * predicate the registration gate applies. Unversioned tools always pass; a gated
+ * tool needs a known connected version within its [min, max] bounds. A null
+ * connected version mirrors registration's conservative refusal (skip the
+ * unverifiable), so the advertise surface can never over-claim a tool the register
+ * surface skipped.
+ */
+function isToolVersionCompatible(bridge, def) {
+    if (def.godotMinVersion == null && def.godotMaxVersion == null)
+        return true;
+    const connected = bridge.getGodotVersion();
+    if (connected == null)
+        return false;
+    return isVersionCompatible(connected, def.godotMinVersion, def.godotMaxVersion);
+}
+/**
+ * Whether a built-in group tool belongs on the advertise surface: registrable for
+ * the connected editor version AND — in read-only mode — allowed by its
+ * annotations. The single predicate that keeps group summaries in lockstep with
+ * what registration installs.
+ */
+function isToolVisible(bridge, def, readOnly) {
+    if (readOnly && !isAllowedInReadOnly(def.annotations))
+        return false;
+    return isToolVersionCompatible(bridge, def);
+}
+/** The visible tool names of a built-in group for the connected editor version + read-only state. */
+function visibleToolNames(bridge, group, readOnly) {
+    return group.tools.filter((t) => {
+        const d = allDefs.get(t);
+        return d ? isToolVisible(bridge, d, readOnly) : false;
+    });
+}
+// ── Registration ─────────────────────────────────────────────────────
+/**
+ * Register a single group's tools dynamically.
+ * Removes any existing stub for those tools first (stub->real swap).
+ * Returns the list of newly registered tool names.
+ */
+export function registerGroupTools(server, bridge, group, readOnly) {
+    const registered = [];
+    for (const toolName of group.tools) {
+        const def = allDefs.get(toolName);
+        if (!def)
+            continue;
+        if (isExcludedByReadOnly(readOnly, def.annotations))
+            continue;
+        // Skip a tool the connected editor can't serve: registerToolWrapped would
+        // refuse it anyway, and an unconditional registered.push would make the
+        // activated summary advertise a tool that is absent from tools/list.
+        if (!isToolVersionCompatible(bridge, def))
+            continue;
+        removeToolByName(toolName); // Remove stub if present
+        registerToolWrapped(server, bridge, def.name, {
+            description: def.description,
+            inputSchema: def.inputSchema,
+            annotations: def.annotations,
+        }, createGroupToolHandler(bridge, def), { godotMinVersion: def.godotMinVersion, godotMaxVersion: def.godotMaxVersion });
+        registered.push(toolName);
+    }
+    return registered;
+}
+// ── discover_tools description builder ──────────────────────────────
+/**
+ * Format one catalogue line for the discover_tools description, shared by the
+ * built-in and extension sections: `<name> [LOADED|available] — <desc>`. The
+ * loaded-state source and the description source differ per kind, so the caller
+ * resolves both and passes them in.
+ */
+function formatGroupEntry(name, loaded, desc) {
+    return `${name} [${loaded ? "LOADED" : "available"}] — ${desc}`;
+}
+// Deliberately detailed description: as the gateway to 30+ hidden tools,
+// discoverability matters more than brevity for this meta-tool.
+//
+// Format: group name + one-line description + status tag. No tool lists —
+// agents see individual tools only after activation or via no-params catalog.
+export function buildDiscoverToolsDesc(bridge, readOnly) {
+    const parts = [];
+    for (const group of GROUPS) {
+        // Drop a group with no tool the connected editor can serve — every member is
+        // version-gated out (or, in read-only mode, read-only-excluded). Keeps the
+        // meta description's group list aligned with what activation would register.
+        if (visibleToolNames(bridge, group, readOnly).length === 0)
+            continue;
+        const loaded = loadedGroups.has(group.name);
+        parts.push(formatGroupEntry(group.name, loaded, group.description));
+    }
+    const extParts = [];
+    for (const [name, ext] of extensionGroupEntries()) {
+        if (readOnly) {
+            const hasReadOnly = ext.commands.some((c) => isAllowedInReadOnly(c.annotations));
+            if (!hasReadOnly)
+                continue;
+        }
+        const loaded = isExtensionGroupLoaded(name);
+        const desc = ext.description || name;
+        extParts.push(formatGroupEntry(name, loaded, desc));
+    }
+    let description = "Find and activate tool groups by name or domain keyword. " +
+        "Activate only the groups needed for your current task (up to ~5) — loading many groups at once floods the tool list and degrades response quality. " +
+        "No params → full catalog. reset: true → deactivate ALL groups; reset: ['group_a'] → deactivate only group_a. " +
+        "Groups: " +
+        parts.join("; ");
+    if (extParts.length > 0) {
+        description += ". Extensions: " + extParts.join("; ");
+    }
+    description += ".";
+    return description;
+}
+// ── Group deactivation ──────────────────────────────────────────────
+export function deactivateGroups(names, readOnly) {
+    const deactivated = [];
+    const targets = names === true ? [...loadedGroups, ...loadedExtensionGroupNames()] : names;
+    for (const groupName of targets) {
+        // Built-in group?
+        const group = GROUPS.find((g) => g.name === groupName);
+        if (group && loadedGroups.has(groupName)) {
+            for (const toolName of group.tools) {
+                const def = allDefs.get(toolName);
+                if (isExcludedByReadOnly(readOnly, def?.annotations))
+                    continue;
+                removeToolByName(toolName);
+            }
+            loadedGroups.delete(groupName);
+            deactivated.push(groupName);
+            continue;
+        }
+        // Extension group?
+        if (deactivateExtensionGroup(groupName)) {
+            deactivated.push(groupName);
+        }
+    }
+    return deactivated;
+}
+// ── Activate / report (CQS split: command + query) ───────────
+/**
+ * Activate a built-in group (the COMMAND side of the CQS split). Takes a
+ * resolved GroupDef and assumes activate intent; idempotent on an
+ * already-loaded group; in read-only mode an all-filtered group doesn't waste a
+ * slot. The caller dispatches built-in vs ext up front (activateGroupByName).
+ */
+export function activateGroup(server, bridge, group, readOnly) {
+    // Tools visible for this editor version + read-only state (mirrors the
+    // registration gate) — drives the already-loaded summary below; the
+    // fresh-activate summary is the registerGroupTools return, same gate.
+    const toolNames = visibleToolNames(bridge, group, readOnly);
+    const tools = toolNames.map((t) => ({ name: t }));
+    if (loadedGroups.has(group.name)) {
+        return alreadyLoadedResult(group.name, tools, group.description);
+    }
+    const registered = registerGroupTools(server, bridge, group, readOnly);
+    // In read-only mode, if all tools were filtered out, don't waste a group slot.
+    if (readOnly && registered.length === 0) {
+        return readOnlyEmptyResult(group.name);
+    }
+    loadedGroups.add(group.name);
+    return activatedResult(group.name, registered, group.description);
+}
+/**
+ * Activate a group by name (the activate-side dispatcher): built-in name →
+ * activateGroup; otherwise delegate to the extension-group command
+ * (activateExtGroup).
+ */
+export function activateGroupByName(server, bridge, name, readOnly) {
+    const group = GROUPS.find((g) => g.name === name);
+    if (!group)
+        return activateExtGroup(server, bridge, name, readOnly);
+    return activateGroup(server, bridge, group, readOnly);
+}
+/** Report a built-in group's status without mutating (the QUERY half). */
+export function reportGroupStatus(bridge, groupName, readOnly) {
+    const group = GROUPS.find((g) => g.name === groupName);
+    if (!group)
+        return { name: groupName, status: "available", tools: [] };
+    // Tools visible for this editor version + read-only state (mirrors the registration gate).
+    const tools = visibleToolNames(bridge, group, readOnly).map((t) => ({ name: t }));
+    if (loadedGroups.has(groupName))
+        return alreadyLoadedResult(groupName, tools, group.description);
+    return availableResult(groupName, tools, group.description);
+}
+/**
+ * Report a group's status by name (the query-side dispatcher): built-in →
+ * reportGroupStatus, extension → reportExtGroupStatus, with readOnly passed
+ * through to the ext query. Routing ext browse here — rather than to the
+ * built-in reportGroupStatus, which returns empty for a non-built-in name —
+ * keeps the ext group's real tool list + already_loaded status.
+ */
+export function reportGroupStatusByName(bridge, name, readOnly) {
+    const group = GROUPS.find((g) => g.name === name);
+    if (!group)
+        return reportExtGroupStatus(name, readOnly);
+    return reportGroupStatus(bridge, name, readOnly);
+}

package/dist/groups/groupCatalogue.js

@@ -0,0 +1,52 @@
+// Canonical tool inventory (single source of truth for counting + lookup).
+// A leaf module that does NOT import groups.ts, so tool-def modules never
+// cycle back here via catalogue.ts.
+import { ALL_TOOL_DEFS } from "../registration/catalogue.js";
+// Canonical group catalogue — the ordered GROUPS array, assembled from the 28
+// per-group data modules (src/groups/defs/*) by builtinGroups.ts. Imported here
+// as a local binding (NOT a bare re-export) so the eager derived sets below —
+// GROUP_TOOL_NAMES — read it directly. ESM guarantees builtinGroups.ts and its
+// 28 group imports fully execute before this module's body runs, so GROUPS is
+// fully assembled when those derivations compute.
+import { GROUPS } from "./builtinGroups.js";
+// ── Group definitions ────────────────────────────────────────────────
+// GROUP_NAMES — the canonical group order, DERIVED from GROUPS rather than
+// hand-kept, so the value can never drift from the assembly order in
+// builtinGroups.ts. ESM-safe: GROUPS is imported (fully assembled) above before
+// this module's body runs, exactly like the eager GROUP_TOOL_NAMES derivation
+// below. The GroupName[] element type is preserved (GroupDef.name is GroupName)
+// — the central GroupName union in groupTypes.ts stays the type SSOT; only this
+// value array is derived.
+export const GROUP_NAMES = GROUPS.map((g) => g.name);
+// GROUPS is assembled in builtinGroups.ts from the 28 per-group data modules
+// (src/groups/defs/*), in canonical order. Imported above as a local binding and
+// re-exported here so this module stays the single resolution point for GROUPS.
+export { GROUPS };
+/** All tool names that belong to groups (for filtering during eager tool registration). */
+export const GROUP_TOOL_NAMES = new Set(GROUPS.flatMap((g) => g.tools));
+// ── Tool lookup ──────────────────────────────────────────────────────
+// Master lookup of every ToolDef by name, derived from the canonical
+// ALL_TOOL_DEFS (catalogue.ts) so the lookup can never drift from the
+// counted set. Eager const — no cycle, because catalogue.ts does not import
+// groups.ts (group-loaded state lives in the leaf groupState.ts). This map
+// is a superset of the group tools (it also holds eager-only tools like
+// node/playtest); group code only ever looks up names it knows are group
+// tools, so the extra entries are inert.
+export const allDefs = new Map(ALL_TOOL_DEFS.map((t) => [t.name, t]));
+// Tools that route through the runtime (Mode B) bridge rather than the editor
+// bridge. runtime_set_property is an on-demand group tool (not eager) but still
+// routes via the runtime bridge, so it belongs in this set. The catalogue
+// completeness guard requires every runtime-bridge tool to resolve in
+// ALL_TOOL_NAMES.
+export const RUNTIME_TOOLS = new Set(["runtime_get_node_state", "runtime_set_property", "animation_player_control"]);
+// LSP tools — use their own TCP client, not the bridge. The catalogue
+// completeness guard requires each to resolve in ALL_TOOL_NAMES.
+export const LSP_TOOLS = new Set([
+    "lsp_diagnostics",
+    "lsp_hover",
+    "lsp_completion",
+    "lsp_definition",
+    "lsp_symbols",
+    "lsp_references",
+    "lsp_project_diagnostics",
+]);