breakpoint-mcp 1.0.0 → 1.2.0

package/dist/tools/editor/particles.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+/** GPUParticles authoring (process material, amount, lifetime, texture). */
+export function registerParticleTools(server, call) {
+    server.registerTool("particles_create", {
+        title: "Create particles",
+        description: "Add a GPUParticles2D/3D node under a parent in the edited scene (undoable). Optional initial amount (> 0), lifetime (> 0), emitting. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default, GPUParticles2D) or \"3d\" (GPUParticles3D)"),
+            name: z.string().optional().describe("Node name (default \"GPUParticles2D\"/\"GPUParticles3D\")"),
+            amount: z.number().optional().describe("Number of particles (> 0, default 8)"),
+            lifetime: z.number().optional().describe("Particle lifetime in seconds (> 0, default 1)"),
+            emitting: z.boolean().optional().describe("Whether the system is emitting (default true)"),
+        },
+    }, async ({ parent_path, dim, name, amount, lifetime, emitting }) => {
+        const params = { parent_path };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (amount !== undefined)
+            params.amount = amount;
+        if (lifetime !== undefined)
+            params.lifetime = lifetime;
+        if (emitting !== undefined)
+            params.emitting = emitting;
+        return call("particles.create", params);
+    });
+    server.registerTool("particles_set_process_material", {
+        title: "Set particles process material",
+        description: "Create a ParticleProcessMaterial and assign it as process_material on a GPUParticles2D/3D in the edited scene (undoable). Optional knobs: gravity [x, y, z], direction [x, y, z], spread, initial_velocity_min/max, scale_min/max, color [r, g, b, a]. GPU particles need a process material to emit. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            gravity: z.array(z.number()).optional().describe("Gravity vector [x, y, z]"),
+            direction: z.array(z.number()).optional().describe("Emission direction [x, y, z]"),
+            spread: z.number().optional().describe("Emission spread in degrees"),
+            initial_velocity_min: z.number().optional().describe("Minimum initial velocity"),
+            initial_velocity_max: z.number().optional().describe("Maximum initial velocity"),
+            scale_min: z.number().optional().describe("Minimum particle scale"),
+            scale_max: z.number().optional().describe("Maximum particle scale"),
+            color: z.array(z.number()).optional().describe("Base color [r, g, b] or [r, g, b, a] (0..1)"),
+        },
+    }, async ({ path, gravity, direction, spread, initial_velocity_min, initial_velocity_max, scale_min, scale_max, color }) => {
+        const params = { path };
+        if (gravity !== undefined)
+            params.gravity = gravity;
+        if (direction !== undefined)
+            params.direction = direction;
+        if (spread !== undefined)
+            params.spread = spread;
+        if (initial_velocity_min !== undefined)
+            params.initial_velocity_min = initial_velocity_min;
+        if (initial_velocity_max !== undefined)
+            params.initial_velocity_max = initial_velocity_max;
+        if (scale_min !== undefined)
+            params.scale_min = scale_min;
+        if (scale_max !== undefined)
+            params.scale_max = scale_max;
+        if (color !== undefined)
+            params.color = color;
+        return call("particles.set_process_material", params);
+    });
+    server.registerTool("particles_set_amount", {
+        title: "Set particles amount",
+        description: "Set the number of particles (amount, > 0) on a GPUParticles2D/3D in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            amount: z.number().describe("Number of particles (> 0)"),
+        },
+    }, async ({ path, amount }) => call("particles.set_amount", { path, amount }));
+    server.registerTool("particles_set_lifetime", {
+        title: "Set particles lifetime",
+        description: "Set the particle lifetime in seconds (> 0) on a GPUParticles2D/3D in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            lifetime: z.number().describe("Lifetime in seconds (> 0)"),
+        },
+    }, async ({ path, lifetime }) => call("particles.set_lifetime", { path, lifetime }));
+    server.registerTool("particles_set_emitting", {
+        title: "Set particles emitting",
+        description: "Toggle whether a GPUParticles2D/3D is emitting in the edited scene (undoable). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D/3D node path relative to the scene root"),
+            emitting: z.boolean().describe("Whether the system is emitting"),
+        },
+    }, async ({ path, emitting }) => call("particles.set_emitting", { path, emitting }));
+    server.registerTool("particles_set_texture", {
+        title: "Set particles texture",
+        description: "Load a Texture2D from a res:// path and assign it as texture on a GPUParticles2D in the edited scene (undoable). GPUParticles2D only — GPUParticles3D draws meshes and has no texture (returns unsupported). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("GPUParticles2D node path relative to the scene root"),
+            texture_path: z.string().describe("res:// path to a Texture2D resource"),
+        },
+    }, async ({ path, texture_path }) => call("particles.set_texture", { path, texture_path }));
+}
+//# sourceMappingURL=particles.js.map

package/dist/tools/editor/physics.js

@@ -0,0 +1,236 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Physics & collision: bodies, shapes, areas, joints, rigidbody tuning, gravity. */
+export function registerPhysicsTools(server, call) {
+    server.registerTool("body_create", {
+        title: "Create physics body",
+        description: "Add a physics body node under a parent in the edited scene (undoable): a StaticBody, RigidBody, CharacterBody, or Area, in 2D or 3D. In-scene and undoable — not gated. Attach collision shapes with collisionshape_add.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.enum(["static", "rigid", "character", "area"]).describe("Body kind: static | rigid | character | area"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default the class name, e.g. \"StaticBody2D\")"),
+        },
+    }, async ({ parent_path, type, dim, name }) => {
+        const params = { parent_path, type };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        return call("body.create", params);
+    });
+    server.registerTool("collisionshape_add", {
+        title: "Add collision shape",
+        description: "Add a CollisionShape2D/3D node carrying a shape resource under a parent (usually a body) in the edited scene (undoable). shape is rect | circle | capsule | polygon; dim selects 2D (Rectangle/Circle/Capsule/ConvexPolygon 2D) or 3D (Box/Sphere/Capsule/ConvexPolygon 3D). In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path (usually a body) relative to the scene root; \".\" for the root"),
+            shape: z.enum(["rect", "circle", "capsule", "polygon"]).describe("Shape kind: rect | circle | capsule | polygon"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default \"CollisionShape2D\"/\"CollisionShape3D\")"),
+            size: z.array(z.number()).optional().describe("rect: [w, h] (2D) or [w, h, d] (3D)"),
+            radius: z.number().optional().describe("circle/capsule radius"),
+            height: z.number().optional().describe("capsule height"),
+            points: z.array(z.array(z.number())).optional().describe("polygon: convex-hull points, [[x, y], …] (2D, ≥3) or [[x, y, z], …] (3D, ≥4)"),
+        },
+    }, async ({ parent_path, shape, dim, name, size, radius, height, points }) => {
+        const params = { parent_path, shape };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (size !== undefined)
+            params.size = size;
+        if (radius !== undefined)
+            params.radius = radius;
+        if (height !== undefined)
+            params.height = height;
+        if (points !== undefined)
+            params.points = points;
+        return call("collisionshape.add", params);
+    });
+    server.registerTool("body_set_collision_layer", {
+        title: "Set collision layer",
+        description: "Set the collision_layer bitmask on a physics body or area (CollisionObject2D/3D) in the edited scene (undoable). layer is the integer bitmask of layers this object occupies.",
+        inputSchema: {
+            path: z.string().describe("Body/Area node path relative to the scene root"),
+            layer: z.number().int().describe("collision_layer bitmask (non-negative integer)"),
+        },
+    }, async ({ path, layer }) => call("body.set_collision_layer", { path, layer }));
+    server.registerTool("body_set_collision_mask", {
+        title: "Set collision mask",
+        description: "Set the collision_mask bitmask on a physics body or area (CollisionObject2D/3D) in the edited scene (undoable). mask is the integer bitmask of layers this object scans for collisions.",
+        inputSchema: {
+            path: z.string().describe("Body/Area node path relative to the scene root"),
+            mask: z.number().int().describe("collision_mask bitmask (non-negative integer)"),
+        },
+    }, async ({ path, mask }) => call("body.set_collision_mask", { path, mask }));
+    server.registerTool("area_set_monitoring", {
+        title: "Set area monitoring",
+        description: "Set monitoring and/or monitorable on an Area2D/3D in the edited scene (undoable). monitoring = the area detects overlapping bodies/areas; monitorable = other areas can detect it. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Area2D/3D node path relative to the scene root"),
+            monitoring: z.boolean().optional().describe("Whether the area detects overlapping bodies/areas"),
+            monitorable: z.boolean().optional().describe("Whether other areas can detect this area"),
+        },
+    }, async ({ path, monitoring, monitorable }) => {
+        const params = { path };
+        if (monitoring !== undefined)
+            params.monitoring = monitoring;
+        if (monitorable !== undefined)
+            params.monitorable = monitorable;
+        return call("area.set_monitoring", params);
+    });
+    server.registerTool("area_set_gravity", {
+        title: "Set area gravity",
+        description: "Set the local gravity override of an Area2D/3D in the edited scene (undoable): space_override mode, gravity magnitude, direction, and whether gravity points toward a center (point). In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Area2D/3D node path relative to the scene root"),
+            space_override: z.enum(["disabled", "combine", "combine_replace", "replace", "replace_combine"]).optional().describe("How this area's gravity combines with the global/other areas"),
+            gravity: z.number().optional().describe("Gravity magnitude (units/s^2)"),
+            direction: z.array(z.number()).optional().describe("Gravity direction [x, y] (2D) or [x, y, z] (3D)"),
+            point: z.boolean().optional().describe("If true, gravity pulls toward the area's gravity point instead of a direction"),
+        },
+    }, async ({ path, space_override, gravity, direction, point }) => {
+        const params = { path };
+        if (space_override !== undefined)
+            params.space_override = space_override;
+        if (gravity !== undefined)
+            params.gravity = gravity;
+        if (direction !== undefined)
+            params.direction = direction;
+        if (point !== undefined)
+            params.point = point;
+        return call("area.set_gravity", params);
+    });
+    server.registerTool("joint_create", {
+        title: "Create physics joint",
+        description: "Add a physics joint node under a parent in the edited scene (undoable). 2D types: pin | groove | spring (PinJoint2D/GrooveJoint2D/DampedSpringJoint2D); 3D types: pin | hinge | slider | cone_twist | generic6dof (PinJoint3D/HingeJoint3D/SliderJoint3D/ConeTwistJoint3D/Generic6DOFJoint3D). Optionally wire node_a/node_b to the two bodies. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            type: z.enum(["pin", "groove", "spring", "hinge", "slider", "cone_twist", "generic6dof"]).describe("Joint kind; pin works in both dims, the rest are dim-specific"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default the class name, e.g. \"PinJoint2D\")"),
+            node_a: z.string().optional().describe("NodePath (relative to the joint) of the first body"),
+            node_b: z.string().optional().describe("NodePath (relative to the joint) of the second body"),
+        },
+    }, async ({ parent_path, type, dim, name, node_a, node_b }) => {
+        const params = { parent_path, type };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (node_a !== undefined)
+            params.node_a = node_a;
+        if (node_b !== undefined)
+            params.node_b = node_b;
+        return call("joint.create", params);
+    });
+    server.registerTool("joint_set_bodies", {
+        title: "Set joint bodies",
+        description: "Set node_a and/or node_b on an existing Joint2D/3D in the edited scene (undoable) — the NodePaths of the two bodies the joint connects, relative to the joint node. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("Joint2D/3D node path relative to the scene root"),
+            node_a: z.string().optional().describe("NodePath (relative to the joint) of the first body"),
+            node_b: z.string().optional().describe("NodePath (relative to the joint) of the second body"),
+        },
+    }, async ({ path, node_a, node_b }) => {
+        const params = { path };
+        if (node_a !== undefined)
+            params.node_a = node_a;
+        if (node_b !== undefined)
+            params.node_b = node_b;
+        return call("joint.set_bodies", params);
+    });
+    server.registerTool("collisionpolygon_add", {
+        title: "Add collision polygon",
+        description: "Add a CollisionPolygon2D/3D node carrying a polygon under a parent (usually a body) in the edited scene (undoable). points is a 2D outline [[x, y], …] (≥3); for 3D it is extruded along Z by depth. 2D build_mode is solids | segments. In-scene and undoable — not gated.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path (usually a body) relative to the scene root; \".\" for the root"),
+            points: z.array(z.array(z.number())).describe("Polygon outline points [[x, y], …] (≥3); a 2D outline even for 3D"),
+            dim: z.enum(["2d", "3d"]).optional().describe("Dimension: \"2d\" (default) or \"3d\""),
+            name: z.string().optional().describe("Node name (default \"CollisionPolygon2D\"/\"CollisionPolygon3D\")"),
+            build_mode: z.enum(["solids", "segments"]).optional().describe("2D only: solids (default) or segments"),
+            depth: z.number().optional().describe("3D only: extrusion depth along Z (default 1.0)"),
+        },
+    }, async ({ parent_path, points, dim, name, build_mode, depth }) => {
+        const params = { parent_path, points };
+        if (dim !== undefined)
+            params.dim = dim;
+        if (name !== undefined)
+            params.name = name;
+        if (build_mode !== undefined)
+            params.build_mode = build_mode;
+        if (depth !== undefined)
+            params.depth = depth;
+        return call("collisionpolygon.add", params);
+    });
+    server.registerTool("rigidbody_set_properties", {
+        title: "Set rigidbody properties",
+        description: "Tune a RigidBody2D/3D in the edited scene (undoable): mass (> 0), gravity_scale, linear_damp, angular_damp. Only the provided properties change. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("RigidBody2D/3D node path relative to the scene root"),
+            mass: z.number().optional().describe("Body mass (> 0)"),
+            gravity_scale: z.number().optional().describe("Multiplier on gravity (1 = normal, 0 = float)"),
+            linear_damp: z.number().optional().describe("Linear damping (≥ 0)"),
+            angular_damp: z.number().optional().describe("Angular damping (≥ 0)"),
+        },
+    }, async ({ path, mass, gravity_scale, linear_damp, angular_damp }) => {
+        const params = { path };
+        if (mass !== undefined)
+            params.mass = mass;
+        if (gravity_scale !== undefined)
+            params.gravity_scale = gravity_scale;
+        if (linear_damp !== undefined)
+            params.linear_damp = linear_damp;
+        if (angular_damp !== undefined)
+            params.angular_damp = angular_damp;
+        return call("rigidbody.set_properties", params);
+    });
+    server.registerTool("body_set_physics_material", {
+        title: "Set body physics material",
+        description: "Create a PhysicsMaterial and assign it as physics_material_override on a StaticBody/RigidBody (2D or 3D) in the edited scene (undoable): friction (default 1), bounce (default 0), rough, absorbent. In-scene and undoable — not gated.",
+        inputSchema: {
+            path: z.string().describe("StaticBody/RigidBody 2D/3D node path relative to the scene root"),
+            friction: z.number().optional().describe("Surface friction 0..1 (default 1)"),
+            bounce: z.number().optional().describe("Restitution/bounciness 0..1 (default 0)"),
+            rough: z.boolean().optional().describe("Rough friction combine mode (default false)"),
+            absorbent: z.boolean().optional().describe("Absorbent bounce combine mode (default false)"),
+        },
+    }, async ({ path, friction, bounce, rough, absorbent }) => {
+        const params = { path };
+        if (friction !== undefined)
+            params.friction = friction;
+        if (bounce !== undefined)
+            params.bounce = bounce;
+        if (rough !== undefined)
+            params.rough = rough;
+        if (absorbent !== undefined)
+            params.absorbent = absorbent;
+        return call("body.set_physics_material", params);
+    });
+    server.registerTool("physics_set_gravity", {
+        title: "Set project gravity",
+        description: "Write the project's default gravity for 2D or 3D (ProjectSettings physics/{2d,3d}/default_gravity + default_gravity_vector). Set save=true to persist to project.godot. DESTRUCTIVE (project-wide setting) — gated by confirmation.",
+        inputSchema: {
+            dim: z.enum(["2d", "3d"]).optional().describe("Which gravity to set: \"2d\" (default) or \"3d\""),
+            magnitude: z.number().optional().describe("Gravity magnitude (default 2D 980, 3D 9.8)"),
+            direction: z.array(z.number()).optional().describe("Gravity direction vector [x, y] (2D) or [x, y, z] (3D)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ dim, magnitude, direction, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Set project ${dim ?? "2d"} gravity${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = {};
+        if (dim !== undefined)
+            params.dim = dim;
+        if (magnitude !== undefined)
+            params.magnitude = magnitude;
+        if (direction !== undefined)
+            params.direction = direction;
+        params.save = save ?? false;
+        return call("physics.set_gravity", params);
+    });
+}
+//# sourceMappingURL=physics.js.map

package/dist/tools/editor/project_input_test.js

@@ -0,0 +1,187 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** InputMap, extended project config (autoloads / export presets / main scene / settings), editor settings, and test-framework detection. */
+export function registerProjectInputTestTools(server, call) {
+    server.registerTool("inputmap_add_action", {
+        title: "Add input action",
+        description: "Define a project input action (ProjectSettings input/<name>) with an empty event list and a deadzone. Set save=true to persist to project.godot. DESTRUCTIVE (project-wide input map) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Action name (without the input/ prefix)"),
+            deadzone: z.number().optional().describe("Analog deadzone 0..1 (default 0.5)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, deadzone, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add input action "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (deadzone !== undefined)
+            params.deadzone = deadzone;
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.add_action", params);
+    });
+    server.registerTool("inputmap_add_event", {
+        title: "Add input event to action",
+        description: "Append an input event to an existing project input action. 'event' is { type: key|mouse_button|joy_button|joy_motion, ... } — key: keycode or physical_keycode as a name like \"A\"/\"Space\" or an int; mouse_button/joy_button: button_index; joy_motion: axis + axis_value. Set save=true to persist. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Existing action name (without the input/ prefix)"),
+            event: z
+                .object({
+                type: z.enum(["key", "mouse_button", "joy_button", "joy_motion"]).describe("Event type"),
+                keycode: z.union([z.string(), z.number()]).optional().describe("Key name or code (type=key)"),
+                physical_keycode: z.union([z.string(), z.number()]).optional().describe("Physical key name or code (type=key)"),
+                button_index: z.number().optional().describe("Button index (mouse_button/joy_button)"),
+                axis: z.number().optional().describe("Joypad axis (joy_motion)"),
+                axis_value: z.number().optional().describe("Joypad axis value (joy_motion)"),
+            })
+                .describe("Input event descriptor"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, event, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add input event to "${name}"`);
+        if (blocked)
+            return blocked;
+        const params = { name, event };
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.add_event", params);
+    });
+    server.registerTool("inputmap_list", {
+        title: "List input actions",
+        description: "List all project-defined input actions (ProjectSettings input/*) with their deadzone and events (class + human-readable text). Read-only.",
+        inputSchema: {},
+    }, async () => call("inputmap.list"));
+    server.registerTool("inputmap_erase_action", {
+        title: "Erase input action",
+        description: "Remove a project input action (ProjectSettings input/<name>). Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Action name (without the input/ prefix)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Erase input action "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (save !== undefined)
+            params.save = save;
+        return call("inputmap.erase_action", params);
+    });
+    server.registerTool("project_add_autoload", {
+        title: "Add autoload singleton",
+        description: "Register an autoload (ProjectSettings autoload/<name>) pointing at a res:// script or scene, enabled as a global singleton by default. Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Autoload / singleton name"),
+            path: z.string().describe("res:// path to a .gd script or .tscn scene"),
+            enabled: z.boolean().optional().describe("Enable as a global singleton (default true)"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, path, enabled, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Add autoload "${name}" -> ${path}${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name, path };
+        if (enabled !== undefined)
+            params.enabled = enabled;
+        if (save !== undefined)
+            params.save = save;
+        return call("project.add_autoload", params);
+    });
+    server.registerTool("project_remove_autoload", {
+        title: "Remove autoload singleton",
+        description: "Remove an autoload (ProjectSettings autoload/<name>). Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Autoload / singleton name"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Remove autoload "${name}"${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { name };
+        if (save !== undefined)
+            params.save = save;
+        return call("project.remove_autoload", params);
+    });
+    server.registerTool("project_add_export_preset", {
+        title: "Add export preset",
+        description: "Append an export preset to res://export_presets.cfg for a platform (e.g. \"Windows Desktop\", \"Web\", \"Linux/X11\", \"macOS\"). Returns the preset's index. DESTRUCTIVE (writes export_presets.cfg) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("Preset display name"),
+            platform: z.string().describe("Export platform name as shown in the editor"),
+            runnable: z.boolean().optional().describe("Mark the preset runnable (default true)"),
+            export_path: z.string().optional().describe("Default export output path"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ name, platform, runnable, export_path, confirm }) => {
+        const blocked = await gate(server, confirm, `Add export preset "${name}" (${platform})`);
+        if (blocked)
+            return blocked;
+        const params = { name, platform };
+        if (runnable !== undefined)
+            params.runnable = runnable;
+        if (export_path !== undefined)
+            params.export_path = export_path;
+        return call("project.add_export_preset", params);
+    });
+    server.registerTool("project_set_main_scene", {
+        title: "Set main scene",
+        description: "Set the project's main scene (ProjectSettings application/run/main_scene) to an existing res:// .tscn/.scn. Set save=true to persist to project.godot. DESTRUCTIVE — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("res:// path to the scene to run first"),
+            save: z.boolean().optional().describe("Persist to project.godot (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, save, confirm }) => {
+        const blocked = await gate(server, confirm, `Set main scene to ${path}${save ? " and save project.godot" : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { path };
+        if (save !== undefined)
+            params.save = save;
+        return call("project.set_main_scene", params);
+    });
+    server.registerTool("project_list_settings", {
+        title: "List project settings",
+        description: "List ProjectSettings keys and values, optionally filtered by a dotted-key prefix (e.g. \"input/\", \"autoload/\", \"application/\"). Read-only.",
+        inputSchema: {
+            prefix: z.string().optional().describe("Only return keys starting with this prefix (default: all)"),
+        },
+    }, async ({ prefix }) => call("project.list_settings", prefix !== undefined ? { prefix } : {}));
+    server.registerTool("editorsettings_get_set", {
+        title: "Get or set an editor setting",
+        description: "Read an EditorSettings value by name; if 'value' is provided, write it instead (persists to the editor's global config). Reading is read-only; writing is DESTRUCTIVE (mutates the editor config) — gated by confirmation.",
+        inputSchema: {
+            name: z.string().describe("EditorSettings key, e.g. interface/editor/code_font_size"),
+            value: z.any().optional().describe("If provided, set this value (rich types use the {\"__type__\":...} tagging convention)"),
+            confirm: z.boolean().optional().describe("Auto-approve the write (skip the confirmation prompt)"),
+        },
+    }, async ({ name, value, confirm }) => {
+        if (value !== undefined) {
+            const blocked = await gate(server, confirm, `Set editor setting "${name}"`);
+            if (blocked)
+                return blocked;
+            return call("editorsettings.get_set", { name, value });
+        }
+        return call("editorsettings.get_set", { name });
+    });
+    server.registerTool("test_detect", {
+        title: "Detect test framework",
+        description: "Detect an installed GDScript test framework (GUT or GdUnit4) in the project. Returns { framework: gut|gdunit4|none, path, version }. Read-only.",
+        inputSchema: {},
+    }, async () => call("test.detect"));
+    server.registerTool("test_list", {
+        title: "List test scripts",
+        description: "List GDScript test scripts (files named test_*.gd or *_test.gd) under a directory (default res://test), searched recursively. Read-only.",
+        inputSchema: {
+            dir: z.string().optional().describe("Directory to search (default res://test)"),
+        },
+    }, async ({ dir }) => call("test.list", dir !== undefined ? { dir } : {}));
+}
+//# sourceMappingURL=project_input_test.js.map

package/dist/tools/editor/resource.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { gate } from "../../confirm.js";
+/** Resource (.tres/.res) create / load / save / property / import ops. */
+export function registerResourceTools(server, call) {
+    server.registerTool("resource_create", {
+        title: "Create resource",
+        description: "Instantiate a Resource subclass and save it as a new file. DESTRUCTIVE (writes a file) — gated by confirmation. Optional initial properties use the tagged-Variant convention.",
+        inputSchema: {
+            class_name: z.string().describe("Resource subclass to instantiate, e.g. StyleBoxFlat, Theme, GDScript"),
+            to_path: z.string().describe("Destination res:// path, e.g. res://styles/panel.tres"),
+            properties: z.record(z.any()).optional().describe("Initial property values (JSON scalars or __type__-tagged Variants)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ class_name, to_path, properties, confirm }) => {
+        const blocked = await gate(server, confirm, `Create ${class_name} resource at ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.create", properties !== undefined ? { class_name, to_path, properties } : { class_name, to_path });
+    });
+    server.registerTool("resource_load", {
+        title: "Load resource",
+        description: "Load a resource file and return its class, resource_name, and inspector-visible property list. Read-only.",
+        inputSchema: { path: z.string().describe("Resource res:// path") },
+    }, async ({ path }) => call("resource.load", { path }));
+    server.registerTool("resource_save", {
+        title: "Save resource",
+        description: "Load a resource and (re-)save it, optionally to a new path and with ResourceSaver flags. DESTRUCTIVE (writes a file) — gated by confirmation. Shares subresources by reference; use resource_duplicate for an independent copy.",
+        inputSchema: {
+            from_path: z.string().describe("Source resource res:// path"),
+            to_path: z.string().optional().describe("Destination res:// path (default: overwrite from_path)"),
+            flags: z.number().int().optional().describe("ResourceSaver.SaverFlags bitmask (e.g. 32 = FLAG_COMPRESS)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ from_path, to_path, flags, confirm }) => {
+        const blocked = await gate(server, confirm, `Save resource ${from_path}${to_path ? ` to ${to_path}` : ""}`);
+        if (blocked)
+            return blocked;
+        const params = { from_path };
+        if (to_path !== undefined)
+            params.to_path = to_path;
+        if (flags !== undefined)
+            params.flags = flags;
+        return call("resource.save", params);
+    });
+    server.registerTool("resource_duplicate", {
+        title: "Duplicate resource",
+        description: "Load a resource, duplicate it (optionally deep, cloning subresources), and save the copy to a new path. DESTRUCTIVE (writes a file) — gated by confirmation.",
+        inputSchema: {
+            path: z.string().describe("Source resource res:// path"),
+            to_path: z.string().describe("Destination res:// path for the copy"),
+            deep: z.boolean().optional().describe("Deep-duplicate subresources (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, to_path, deep, confirm }) => {
+        const blocked = await gate(server, confirm, `Duplicate resource ${path} to ${to_path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.duplicate", deep !== undefined ? { path, to_path, deep } : { path, to_path });
+    });
+    server.registerTool("resource_get_property", {
+        title: "Get resource property",
+        description: "Read a single property of a resource file by name. Read-only. The value comes back tagged (Variant convention).",
+        inputSchema: {
+            path: z.string().describe("Resource res:// path"),
+            property: z.string().describe("Property name"),
+        },
+    }, async ({ path, property }) => call("resource.get_property", { path, property }));
+    server.registerTool("resource_set_property", {
+        title: "Set resource property",
+        description: "Set a single property on a resource file and save it. DESTRUCTIVE (writes a file) — gated by confirmation. The value uses the tagged-Variant convention.",
+        inputSchema: {
+            path: z.string().describe("Resource res:// path"),
+            property: z.string().describe("Property name"),
+            value: z.any().describe("New value (JSON scalar or __type__-tagged Variant)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, property, value, confirm }) => {
+        const blocked = await gate(server, confirm, `Set ${property} on ${path}`);
+        if (blocked)
+            return blocked;
+        return call("resource.set_property", { path, property, value });
+    });
+    server.registerTool("resource_get_import_settings", {
+        title: "Get import settings",
+        description: "Read an asset's import metadata (.import): the importer and its parameters. Read-only. Returns imported=false when the asset has no .import sidecar.",
+        inputSchema: { path: z.string().describe("Asset res:// path (e.g. res://icon.png)") },
+    }, async ({ path }) => call("resource.get_import_settings", { path }));
+    server.registerTool("resource_set_import_settings", {
+        title: "Set import settings",
+        description: "Update import parameters in an asset's .import metadata and trigger a reimport. DESTRUCTIVE (rewrites metadata + reimports) — gated by confirmation. Errors if the asset has no .import sidecar.",
+        inputSchema: {
+            path: z.string().describe("Asset res:// path"),
+            settings: z.record(z.any()).describe("Import params to set (name -> JSON scalar or __type__-tagged Variant)"),
+            reimport: z.boolean().optional().describe("Reimport after writing (default true)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, settings, reimport, confirm }) => {
+        const blocked = await gate(server, confirm, `Set import settings on ${path} and reimport`);
+        if (blocked)
+            return blocked;
+        return call("resource.set_import_settings", reimport !== undefined ? { path, settings, reimport } : { path, settings });
+    });
+}
+//# sourceMappingURL=resource.js.map