gdharness 1.2.33 → 1.2.34

package/build/godot/operations/input_actions.gd

@@ -170,19 +170,63 @@ func add_input_action(params: Dictionary) -> Dictionary:
 	if action.is_empty():
 		return {}
 
+	# An action that exists is rebound, which is how one of the engine's ui_ actions is changed, so
+	# what it held is answered rather than lost without a word.
+	var setting: String = "input/" + action_name
+	var answer: Dictionary = {
+		"action_name": action_name,
+		"events_count": events_config.size(),
+		"deadzone": deadzone,
+		"events": events_config,
+		"was_new": not ProjectSettings.has_setting(setting),
+	}
+	if not answer["was_new"]:
+		var held: Variant = ProjectSettings.get_setting(setting)
+		var old: Dictionary = held if held is Dictionary else {}
+		var old_events: Array[Dictionary] = []
+		var listed: Variant = old.get("events", [])
+		if listed is Array:
+			var events_held: Array = listed
+			for event: Variant in events_held:
+				if event is InputEvent:
+					var bound: InputEvent = event
+					old_events.append(_shaped(bound))
+		answer["old_events"] = old_events
+		answer["old_deadzone"] = Read.as_float(old.get("deadzone", 0.5), 0.5)
+
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
-	ProjectSettings.set_setting("input/" + action_name, action)
+	ProjectSettings.set_setting(setting, action)
 	var err: Error = ProjectFile.save()
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {
-		"action_name": action_name,
-		"events_count": events_config.size(),
-		"deadzone": deadzone,
-		"events": events_config
-	}
+	return answer
+
+
+## [param event] in the form add_input_action answers its events with, and as the engine names it
+## under text, which also covers a kind of event that form has no fields for.
+static func _shaped(event: InputEvent) -> Dictionary:
+	var shaped: Dictionary = {"class_name": event.get_class(), "text": event.as_text()}
+	if event is InputEventKey:
+		var key: InputEventKey = event
+		shaped["keycode"] = key.keycode
+		if key.physical_keycode != KEY_NONE:
+			shaped["physical_keycode"] = key.physical_keycode
+		for modifier: String in ["ctrl_pressed", "alt_pressed", "shift_pressed"]:
+			if key.get(modifier):
+				shaped[modifier] = true
+	elif event is InputEventMouseButton:
+		var mouse: InputEventMouseButton = event
+		shaped["button_index"] = mouse.button_index
+	elif event is InputEventJoypadButton:
+		var pad: InputEventJoypadButton = event
+		shaped["button_index"] = pad.button_index
+	elif event is InputEventJoypadMotion:
+		var motion: InputEventJoypadMotion = event
+		shaped["axis"] = motion.axis
+		shaped["axis_value"] = motion.axis_value
+	return shaped
 
 
 # Remove an input action the project defines, which add_input_action had no way back from.

package/build/index.js

@@ -25071,6 +25071,12 @@ function isWithinRoot(rootPath, candidatePath) {
   const step = relative(resolve(rootPath), resolve(candidatePath));
   return step !== ".." && !step.startsWith(`..${sep}`) && !isAbsolute(step);
 }
+var KEPT_ID = /^[A-Za-z0-9_]+$/;
+function keptInside(given) {
+  const at = given.indexOf("::");
+  const inner = at === -1 ? "" : given.slice(at + 2);
+  return KEPT_ID.test(inner) ? { file: given.slice(0, at), inner } : { file: given, inner: undefined };
+}
 function resolveWithinProject(projectPath, candidatePath, options = {}) {
   const trimmed = candidatePath.trim();
   if (trimmed === "") {
@@ -25099,6 +25105,13 @@ function resolveWithinProject(projectPath, candidatePath, options = {}) {
       reason: `Path '${trimmed}' is absolute; give a path inside the project, such as 'scenes/main.tscn'.`
     };
   }
+  const kept = keptInside(trimmed);
+  if (kept.inner !== undefined) {
+    return {
+      ok: false,
+      reason: `Path '${trimmed}' names the resource ${kept.inner} kept inside ${kept.file}, not a file. resource_edit read reads one by that path; this argument takes a file.`
+    };
+  }
   if (withoutScheme.includes(":")) {
     return {
       ok: false,
@@ -35040,7 +35053,7 @@ var TOOL_SPECS = [
   {
     name: "project_settings",
     title: "Project settings",
-    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
     parameters: {
       projectPath: PROJECT_PATH2,
       setting: {
@@ -35138,8 +35151,8 @@ var TOOL_SPECS = [
         requires: ["scenePath"]
       },
       add_input_action: {
-        effect: "additive",
-        summary: "register an input action and its events",
+        effect: "destructive",
+        summary: "register an input action and its events, or rebind one that exists",
         requires: ["actionName", "events"]
       },
       remove_input_action: {
@@ -35487,7 +35500,7 @@ var TOOL_SPECS = [
   {
     name: "scene_animation",
     title: "Animations",
-    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. Needs the editor connected.",
+    description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write need the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
@@ -35519,7 +35532,11 @@ var TOOL_SPECS = [
         ops: ["read_states", "add_state", "connect_states"],
         description: "The AnimationTree node."
       },
-      stateName: { type: "string", ops: ["add_state"], description: "add_state: the state to add." },
+      stateName: {
+        type: "string",
+        ops: ["add_state"],
+        description: "add_state: the state to add. It goes right of the rightmost state in the editor's graph, answered under position."
+      },
       stateMachinePath: {
         type: "string",
         ops: ["read_states", "add_state", "connect_states"],
@@ -35694,7 +35711,7 @@ var TOOL_SPECS = [
       projectPath: PROJECT_PATH2,
       resourcePath: {
         ...RESOURCE_PATH,
-        description: `${RESOURCE_FILE} move: a directory too.`
+        description: `${RESOURCE_FILE} move: a directory too. read: also a resource kept inside a scene or resource file, by the path a read answers a property holding it with, such as "res://hero.tscn::Animation_jump".`
       },
       resourceType: {
         type: "string",
@@ -38950,7 +38967,11 @@ class GodotServer {
       case "scene_create":
         return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
       case "scene_tree":
-        return await this.readFromFile(args, "scenePath", "read_scene_tree", async () => await bridge("list_scene_nodes"));
+        return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
+          scenePath: file,
+          depth: readNumber(args, "depth") ?? -1,
+          includeProperties: readBoolean(args, "includeProperties") ?? false
+        }), async () => await bridge("list_scene_nodes"));
       case "scene_node":
         switch (op) {
           case "add":
@@ -38980,9 +39001,17 @@ class GodotServer {
       case "scene_animation":
         switch (op) {
           case "read":
-            return await bridge("read_animations");
+            return await this.readFromFile(args, "scenePath", "read_animations", (file) => ({
+              scenePath: file,
+              playerNodePath: readNonEmptyString(args, "playerNodePath") ?? ".",
+              animationName: readString(args, "animationName") ?? ""
+            }), async () => await bridge("read_animations"));
           case "read_states":
-            return await bridge("read_animation_states");
+            return await this.readFromFile(args, "scenePath", "read_animation_states", (file) => ({
+              scenePath: file,
+              animTreePath: readString(args, "animTreePath") ?? "",
+              stateMachinePath: readString(args, "stateMachinePath") ?? ""
+            }), async () => await bridge("read_animation_states"));
           case "create":
             return await bridge("create_animation");
           case "add_track":
@@ -39009,8 +39038,14 @@ class GodotServer {
         switch (op) {
           case "move":
             return await this.handleMoveFile(args);
-          case "read":
-            return await this.readFromFile(args, "resourcePath", "read_resource", async () => await bridge("read_resource"));
+          case "read": {
+            const { file, inner } = keptInside(readString(args, "resourcePath") ?? "");
+            const kept = inner === undefined ? {} : { resourcePath: file, subResource: inner };
+            return await this.readFromFile({ ...args, ...kept }, "resourcePath", "read_resource", (found) => ({
+              resourcePath: inner === undefined ? found : `${found}::${inner}`,
+              includeDefaults: readBoolean(args, "includeDefaults") ?? false
+            }), async () => await bridge("read_resource", kept));
+          }
           case "create":
             return await bridge("create_resource");
           case "modify":
@@ -43400,7 +43435,7 @@ class GodotServer {
       ...leftChanged === undefined ? {} : { note: leftChanged }
     });
   }
-  async readFromFile(args, pathKey, operation, throughTheEditor) {
+  async readFromFile(args, pathKey, operation, paramsFor, throughTheEditor) {
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -43418,12 +43453,7 @@ class GodotServer {
     if (file === null) {
       return this.createErrorResponse(`${pathKey} must name a file inside the project.`);
     }
-    const params = operation === "read_scene_tree" ? {
-      scenePath: file,
-      depth: readNumber(args, "depth") ?? -1,
-      includeProperties: readBoolean(args, "includeProperties") ?? false
-    } : { resourcePath: file, includeDefaults: readBoolean(args, "includeDefaults") ?? false };
-    const outcome = await this.operation(operation, params, projectPath);
+    const outcome = await this.operation(operation, paramsFor(file), projectPath);
     if (!outcome.ok) {
       return this.answer(outcome);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.2.33",
+  "version": "1.2.34",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",