gdharness 1.3.41 → 1.3.42

package/build/godot/operations/gdscript_authoring.gd

@@ -100,6 +100,9 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	file.close()
 	if not stored:
 		return _log.failure("Failed to write to script file: " + full_script_path)
+	# The editor gives a script it makes a .uid beside it. A headless engine writes none until the
+	# project is imported, so a script made here was missing from every check tracking the sidecars.
+	var uid: String = _uid_beside(full_script_path)
 
 	var written: Script = ResourceLoader.load(full_script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
 	var parses: bool = _parses(written)
@@ -110,7 +113,10 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 		"absolute_path": ProjectSettings.globalize_path(full_script_path),
 		"template_used": template if not template.is_empty() else "none",
 		"parses": parses,
+		"uid": null,
 	}
+	if not uid.is_empty():
+		answer["uid"] = uid
 	# Read off the file as the engine parsed it rather than off the arguments, which content leaves
 	# out. A script that does not parse tells the engine nothing, and its empty base and name were
 	# answered for a file whose header says otherwise, so those are read off the text instead.
@@ -125,6 +131,22 @@ func create_gdscript(params: Dictionary) -> Dictionary:
 	return answer
 
 
+## The uid in the .uid file beside [param path], written first when there is none, as the editor
+## writes it for a script it makes; empty when it could not be written. A sidecar already there is
+## the one the engine reads the script's uid from, so it is kept.
+static func _uid_beside(path: String) -> String:
+	var sidecar: String = path + ".uid"
+	if FileAccess.file_exists(sidecar):
+		return FileAccess.get_file_as_string(sidecar).strip_edges()
+	var text: String = ResourceUID.id_to_text(ResourceUID.create_id_for_path(path))
+	var file: FileAccess = FileAccess.open(sidecar, FileAccess.WRITE)
+	if file == null:
+		return ""
+	var stored: bool = file.store_string(text + "\n")
+	file.close()
+	return text if stored else ""
+
+
 ## The refusal for [param path], which is no GDScript file, naming what [param doing] it instead:
 ## a shader is made with resource_edit, and once it exists its text is edited as a file's.
 static func _not_gdscript(path: String, doing: String) -> String:
@@ -640,9 +662,24 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 
 	# The body's statements relative to the function, whether or not the caller indented them for
 	# it: a body written with its tab already on came out two levels in. A blank line stays empty,
-	# since an indent alone on it is trailing whitespace to every formatter.
-	for bl: String in body.dedent().split("\n"):
-		func_lines.append("" if bl.strip_edges().is_empty() else "\t" + bl)
+	# since an indent alone on it is trailing whitespace to every formatter. Each level is the
+	# file's own unit, because the engine refuses a file indented with spaces in one place and tabs
+	# in another, so a tab put into a script indented with spaces stopped it parsing.
+	var unit: String = _indent_unit(lines)
+	var body_lines: Array[String] = []
+	body_lines.assign(body.dedent().strip_edges(false, true).split("\n"))
+	var given_unit: String = _indent_unit(body_lines)
+	for bl: String in body_lines:
+		if bl.strip_edges().is_empty():
+			func_lines.append("")
+			continue
+		var stripped: String = bl.lstrip(" \t")
+		var leading: String = bl.substr(0, bl.length() - stripped.length())
+		var levels: int = floori(float(leading.length()) / given_unit.length())
+		if leading != given_unit.repeat(levels):
+			func_lines.append(unit + bl)
+			continue
+		func_lines.append(unit.repeat(levels + 1) + stripped)
 
 	var below: int = _blank_run(lines, insert_line, 1)
 	if insert_line + below < lines.size():
@@ -654,6 +691,21 @@ func _add_function(lines: Array[String], mod: Dictionary, placed: Array[Dictiona
 	return declared_at if _insert(lines, insert_line, func_lines, placed) else -1
 
 
+## One level of indentation in [param lines]: what the first line indented below an unindented
+## line ending a block opens with, or a tab, the engine's default, when no line is.
+static func _indent_unit(lines: Array[String]) -> String:
+	var opener: bool = false
+	for line: String in lines:
+		var stripped: String = line.strip_edges()
+		if stripped.is_empty() or stripped.begins_with("#"):
+			continue
+		var leading: String = line.substr(0, line.length() - line.lstrip(" \t").length())
+		if opener and not leading.is_empty():
+			return leading
+		opener = leading.is_empty() and stripped.ends_with(":")
+	return "\t"
+
+
 # How many blank lines run from [param from] on in the direction of [param step], 1 or -1.
 static func _blank_run(lines: Array[String], from: int, step: int) -> int:
 	var count: int = 0

package/build/godot/operations/input_actions.gd

@@ -280,6 +280,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		"deadzone": deadzone,
 		"events": events_config,
 		"was_new": not ProjectSettings.has_setting(setting),
+		"saved": true,
 	}
 	if not answer["was_new"]:
 		var old_events: Array[Dictionary] = []

package/build/godot/operations/project_config.gd

@@ -7,6 +7,52 @@ const GdhProjectFile = preload("project_file.gd")
 const GdhSerialisation = preload("serialisation.gd")
 const GdhSettingReads = preload("setting_reads.gd")
 const GdhShapes = preload("value_shapes.gd")
+## The words GDScript reserves, which no script could reach an autoload by.
+const GDSCRIPT_KEYWORDS: Array[String] = [
+	"and",
+	"as",
+	"assert",
+	"await",
+	"break",
+	"breakpoint",
+	"class",
+	"class_name",
+	"const",
+	"continue",
+	"elif",
+	"else",
+	"enum",
+	"extends",
+	"false",
+	"for",
+	"func",
+	"if",
+	"in",
+	"INF",
+	"is",
+	"match",
+	"NAN",
+	"namespace",
+	"not",
+	"null",
+	"or",
+	"pass",
+	"PI",
+	"preload",
+	"return",
+	"self",
+	"signal",
+	"static",
+	"super",
+	"TAU",
+	"trait",
+	"true",
+	"var",
+	"void",
+	"when",
+	"while",
+	"yield",
+]
 
 var _log: GdhLog
 var _values: GdhSerialisation = GdhSerialisation.new()
@@ -133,6 +179,23 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	var err: Error = GdhProjectFile.save([setting_path])
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
+	# An override still replaces what was written wherever its feature is, and a write of the base
+	# value read as if it reached every build.
+	var overrides: Dictionary = GdhSettingReads.overrides_of(setting_path, _values)
+	if not overrides.is_empty():
+		answer["overrides"] = overrides
+		var parts: Array[String] = []
+		for feature: Variant in overrides:
+			parts.append(
+				(
+					"one with the feature %s reads %s from %s.%s"
+					% [feature, JSON.stringify(overrides[feature]), setting_path, feature]
+				)
+			)
+		answer["overridesNote"] = (
+			"Not every build reads what was written: %s. Set or unset an override to change what its builds read."
+			% "; ".join(parts)
+		)
 	return answer
 
 
@@ -321,6 +384,10 @@ func add_autoload(params: Dictionary) -> Dictionary:
 			)
 		)
 
+	var clash: String = _autoload_name_refusal(name)
+	if not clash.is_empty():
+		return _log.failure(clash)
+
 	if not path.begins_with("res://"):
 		path = "res://" + path
 
@@ -364,6 +431,32 @@ func add_autoload(params: Dictionary) -> Dictionary:
 	}
 
 
+## Why [param name] cannot name an autoload, or empty when it can. The editor's Autoload tab refuses
+## the same names: an autoload named after an engine class or a built-in type takes that name in
+## every script, so an autoload called Input made every Input.is_action_pressed call the autoload.
+static func _autoload_name_refusal(name: String) -> String:
+	var reason: String = ""
+	if not name.is_valid_ascii_identifier():
+		reason = "it is not an identifier, which a script could name"
+	elif name in GDSCRIPT_KEYWORDS:
+		reason = "it is a GDScript keyword"
+	elif ClassDB.class_exists(name):
+		reason = (
+			"it is the engine class %s, and every script naming %s would reach the autoload instead"
+			% [name, name]
+		)
+	else:
+		for type: int in TYPE_MAX:
+			if type_string(type) == name:
+				reason = "it is the built-in type %s" % name
+	if reason.is_empty():
+		return ""
+	return (
+		"%s cannot name an autoload: %s. Nothing was written; the editor's Autoload tab refuses it too."
+		% [JSON.stringify(name), reason]
+	)
+
+
 # Remove an autoload singleton
 func remove_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.41",
+  "version": "1.3.42",
   "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",