gdharness 0.4.1

package/build/godot/operations/import_pipeline.gd

@@ -0,0 +1,390 @@
+extends RefCounted
+
+const FileWalk = preload("file_walk.gd")
+const Log = preload("logger.gd")
+
+const IMPORTABLE_EXTENSIONS: Array[String] = [
+	"png", "jpg", "jpeg", "webp", "svg", "wav", "mp3", "ogg", "ttf", "otf", "glb", "gltf", "fbx", "obj"
+]
+
+var _log: Log
+var _files: FileWalk = FileWalk.new()
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Get import status for resources
+func get_import_status(params: Dictionary) -> Dictionary:
+	var resource_path: String = str(params.get("resource_path", ""))
+	var include_up_to_date: bool = bool(params.get("include_up_to_date", false))
+
+	_log.info(
+		(
+			"Getting import status"
+			+ (" for: " + resource_path if not resource_path.is_empty() else " for all resources")
+		)
+	)
+
+	var resources: Array[Dictionary] = []
+	var summary: Dictionary = {"total": 0, "needs_reimport": 0, "up_to_date": 0, "missing_source": 0}
+
+	if not resource_path.is_empty():
+		var full_path: String = resource_path
+		if not full_path.begins_with("res://"):
+			full_path = "res://" + full_path
+
+		var status: Dictionary = _import_status_of(full_path, full_path + ".import")
+		resources.append(status)
+		_tally(summary, status)
+	else:
+		for res_path: String in _files.find_files_with_extensions("res://", IMPORTABLE_EXTENSIONS):
+			var status: Dictionary = _import_status_of(res_path, res_path + ".import")
+
+			if include_up_to_date or status["status"] != "up_to_date":
+				resources.append(status)
+
+			_tally(summary, status)
+
+	return {"resources": resources, "summary": summary}
+
+
+# Get import options for a resource
+func get_import_options(params: Dictionary) -> Dictionary:
+	var resource_path: String = str(params.get("resource_path", ""))
+	if not resource_path.begins_with("res://"):
+		resource_path = "res://" + resource_path
+
+	_log.info("Getting import options for: " + resource_path)
+
+	var import_file_path: String = resource_path + ".import"
+
+	if not FileAccess.file_exists(import_file_path):
+		_log.error("Import file does not exist: " + import_file_path)
+		return _log.failure("This resource may not have been imported yet")
+
+	var config: ConfigFile = ConfigFile.new()
+	var err: Error = config.load(import_file_path)
+
+	if err != OK:
+		return _log.failure("Failed to parse import file: " + str(err))
+
+	var result: Dictionary = {
+		"resource_path": resource_path, "import_file": import_file_path, "remap": {}, "deps": {}, "params": {}
+	}
+
+	for section: String in ["remap", "deps", "params"]:
+		if config.has_section(section):
+			var values: Dictionary = result[section]
+			for key: String in config.get_section_keys(section):
+				values[key] = config.get_value(section, key)
+
+	return result
+
+
+# Set import options for a resource
+func set_import_options(params: Dictionary) -> Dictionary:
+	var resource_path: String = str(params.get("resource_path", ""))
+	if not resource_path.begins_with("res://"):
+		resource_path = "res://" + resource_path
+
+	var options: Dictionary = params.get("options", {})
+	var do_reimport: bool = bool(params.get("reimport", true))
+
+	_log.info("Setting import options for: " + resource_path)
+
+	var import_file_path: String = resource_path + ".import"
+
+	if not FileAccess.file_exists(import_file_path):
+		_log.error("Import file does not exist: " + import_file_path)
+		return _log.failure("This resource may not have been imported yet")
+
+	var config: ConfigFile = ConfigFile.new()
+	var err: Error = config.load(import_file_path)
+
+	if err != OK:
+		return _log.failure("Failed to parse import file: " + str(err))
+
+	var updated_keys: Array[String] = []
+	for key: Variant in options:
+		var name: String = str(key)
+		config.set_value("params", name, options[key])
+		updated_keys.append(name)
+		_log.debug("Set " + name + " = " + str(options[key]))
+
+	err = config.save(import_file_path)
+	if err != OK:
+		return _log.failure("Failed to save import file: " + str(err))
+
+	var result: Dictionary = {
+		"resource_path": resource_path, "updated_options": updated_keys, "reimport_triggered": do_reimport
+	}
+
+	# A headless engine has no importer to run, so the .import file is as far as this goes.
+	if do_reimport:
+		result["note"] = "Import file updated. Run the editor or use 'reimport_resource' to apply changes."
+
+	return result
+
+
+# Reimport a resource or all resources
+func reimport_resource(params: Dictionary) -> Dictionary:
+	var resource_path: String = str(params.get("resource_path", ""))
+	var force: bool = bool(params.get("force", false))
+
+	_log.info(
+		(
+			"Reimporting"
+			+ (" resource: " + resource_path if not resource_path.is_empty() else " all modified resources")
+		)
+	)
+
+	# A full reimport is editor work; headless can only report what the state is.
+	var result: Dictionary = {
+		"status": "requested",
+		"resource_path": resource_path if not resource_path.is_empty() else "all",
+		"force": force,
+		"note": "Reimport in headless mode is limited. For full reimport, open the project in the editor."
+	}
+
+	if not resource_path.is_empty():
+		var full_path: String = resource_path
+		if not full_path.begins_with("res://"):
+			full_path = "res://" + full_path
+
+		if not FileAccess.file_exists(full_path):
+			return _log.failure("Resource file does not exist: " + full_path)
+
+		result["current_status"] = _import_status_of(full_path, full_path + ".import")["status"]
+
+	return result
+
+
+# List export presets
+func list_export_presets(_params: Dictionary) -> Dictionary:
+	_log.info("Listing export presets")
+
+	var presets_file: String = "res://export_presets.cfg"
+
+	if not FileAccess.file_exists(presets_file):
+		return {
+			"presets": [],
+			"presets_file_exists": false,
+			"note": "No export_presets.cfg found. Configure export presets in the Godot editor."
+		}
+
+	var config: ConfigFile = ConfigFile.new()
+	var err: Error = config.load(presets_file)
+
+	if err != OK:
+		return _log.failure("Failed to parse export_presets.cfg: " + str(err))
+
+	# Export presets are stored as [preset.0], [preset.1], etc.
+	var presets: Array[Dictionary] = []
+	var preset_idx: int = 0
+	while config.has_section("preset." + str(preset_idx)):
+		var section: String = "preset." + str(preset_idx)
+		var preset: Dictionary = {
+			"index": preset_idx,
+			"name": config.get_value(section, "name", "Unknown"),
+			"platform": config.get_value(section, "platform", "Unknown"),
+			"runnable": config.get_value(section, "runnable", false),
+			"export_path": config.get_value(section, "export_path", ""),
+			"export_filter": config.get_value(section, "export_filter", "all_resources"),
+			"include_filter": config.get_value(section, "include_filter", ""),
+			"exclude_filter": config.get_value(section, "exclude_filter", "")
+		}
+
+		if config.has_section_key(section, "custom_features"):
+			preset["custom_features"] = config.get_value(section, "custom_features", "")
+
+		presets.append(preset)
+		preset_idx += 1
+
+	return {"presets": presets, "presets_file_exists": true, "total_presets": preset_idx}
+
+
+# Validate project for export
+func validate_project(params: Dictionary) -> Dictionary:
+	var preset_name: String = str(params.get("preset", ""))
+	var include_suggestions: bool = bool(params.get("include_suggestions", true))
+
+	_log.info("Validating project" + (" for preset: " + preset_name if not preset_name.is_empty() else ""))
+
+	var issues: Array[Dictionary] = []
+	var warnings: Array[Dictionary] = []
+	var checks_performed: Array[String] = []
+
+	checks_performed.append("project_file")
+	if not FileAccess.file_exists("res://project.godot"):
+		issues.append(
+			_finding(
+				"error",
+				"project_file",
+				"project.godot not found",
+				"Ensure you are running this from a valid Godot project directory",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("main_scene")
+	var main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
+	if main_scene.is_empty():
+		issues.append(
+			_finding(
+				"error",
+				"main_scene",
+				"No main scene set",
+				"Set a main scene in Project Settings > Application > Run > Main Scene",
+				include_suggestions
+			)
+		)
+	elif not FileAccess.file_exists(main_scene):
+		issues.append(
+			_finding(
+				"error",
+				"main_scene",
+				"Main scene file does not exist: " + main_scene,
+				"Update the main scene setting or create the missing scene file",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("export_presets")
+	if not FileAccess.file_exists("res://export_presets.cfg"):
+		warnings.append(
+			_finding(
+				"warning",
+				"export_presets",
+				"No export presets configured",
+				"Configure export presets in Godot editor: Project > Export",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("icon")
+	var icon_path: String = str(ProjectSettings.get_setting("application/config/icon", ""))
+	if icon_path.is_empty():
+		warnings.append(
+			_finding(
+				"warning",
+				"icon",
+				"No application icon set",
+				"Set an icon in Project Settings > Application > Config > Icon",
+				include_suggestions
+			)
+		)
+	elif not FileAccess.file_exists(icon_path):
+		warnings.append(
+			_finding(
+				"warning",
+				"icon",
+				"Icon file does not exist: " + icon_path,
+				"Update the icon path or add the missing icon file",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("project_name")
+	var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))
+	if project_name.is_empty():
+		warnings.append(
+			_finding(
+				"warning",
+				"project_name",
+				"No project name set",
+				"Set a project name in Project Settings > Application > Config > Name",
+				include_suggestions
+			)
+		)
+
+	checks_performed.append("scripts")
+	var script_files: Array[String] = _files.find_files_with_extensions("res://", ["gd"])
+	var scripts_checked: int = 0
+	var script_issues: Array[Dictionary] = []
+
+	# A hundred scripts is enough to say whether the project is tidy without a large one
+	# turning validation into a full read of its source tree.
+	for script_path: String in script_files:
+		scripts_checked += 1
+		if scripts_checked > 100:
+			break
+
+		var file: FileAccess = FileAccess.open(script_path, FileAccess.READ)
+		if file:
+			var content: String = file.get_as_text()
+			file.close()
+
+			if "# TODO" in content or "# FIXME" in content:
+				script_issues.append({"path": script_path, "issue": "Contains TODO/FIXME comments"})
+			if "pass # TODO" in content:
+				script_issues.append({"path": script_path, "issue": "Contains unimplemented functions"})
+
+	if script_issues.size() > 0:
+		var warning: Dictionary = _finding(
+			"warning",
+			"scripts",
+			str(script_issues.size()) + " script issues found",
+			"Review and resolve TODO/FIXME items before release",
+			include_suggestions
+		)
+		warning["details"] = script_issues.slice(0, 5)
+		warnings.append(warning)
+
+	return {
+		"valid": issues.is_empty(),
+		"issues": issues,
+		"warnings": warnings,
+		"checks_performed": checks_performed,
+		"scripts_checked": scripts_checked,
+		"issue_count": issues.size(),
+		"warning_count": warnings.size()
+	}
+
+
+func _finding(
+	type: String, check: String, message: String, suggestion: String, include_suggestion: bool
+) -> Dictionary:
+	var finding: Dictionary = {"type": type, "check": check, "message": message}
+	if include_suggestion:
+		finding["suggestion"] = suggestion
+	return finding
+
+
+func _tally(summary: Dictionary, status: Dictionary) -> void:
+	summary["total"] += 1
+	var state: String = status["status"]
+	if summary.has(state):
+		summary[state] += 1
+
+
+# Whether a resource is imported, out of date, or has lost its source file.
+func _import_status_of(resource_path: String, import_file_path: String) -> Dictionary:
+	var source_exists: bool = FileAccess.file_exists(resource_path)
+	if not source_exists:
+		return {
+			"path": resource_path,
+			"status": "missing_source",
+			"import_file_exists": false,
+			"source_exists": false
+		}
+
+	var import_file_exists: bool = FileAccess.file_exists(import_file_path)
+	if not import_file_exists:
+		return {
+			"path": resource_path,
+			"status": "needs_reimport",
+			"import_file_exists": false,
+			"source_exists": true
+		}
+
+	var source_modified: int = FileAccess.get_modified_time(resource_path)
+	var import_modified: int = FileAccess.get_modified_time(import_file_path)
+
+	return {
+		"path": resource_path,
+		"status": "needs_reimport" if source_modified > import_modified else "up_to_date",
+		"import_file_exists": true,
+		"source_exists": true
+	}

package/build/godot/operations/input_actions.gd

@@ -0,0 +1,237 @@
+extends RefCounted
+
+const Log = preload("logger.gd")
+
+# The key names a caller may write, and what the engine calls them.
+const KEY_NAMES: Dictionary = {
+	"A": KEY_A,
+	"B": KEY_B,
+	"C": KEY_C,
+	"D": KEY_D,
+	"E": KEY_E,
+	"F": KEY_F,
+	"G": KEY_G,
+	"H": KEY_H,
+	"I": KEY_I,
+	"J": KEY_J,
+	"K": KEY_K,
+	"L": KEY_L,
+	"M": KEY_M,
+	"N": KEY_N,
+	"O": KEY_O,
+	"P": KEY_P,
+	"Q": KEY_Q,
+	"R": KEY_R,
+	"S": KEY_S,
+	"T": KEY_T,
+	"U": KEY_U,
+	"V": KEY_V,
+	"W": KEY_W,
+	"X": KEY_X,
+	"Y": KEY_Y,
+	"Z": KEY_Z,
+	"0": KEY_0,
+	"1": KEY_1,
+	"2": KEY_2,
+	"3": KEY_3,
+	"4": KEY_4,
+	"5": KEY_5,
+	"6": KEY_6,
+	"7": KEY_7,
+	"8": KEY_8,
+	"9": KEY_9,
+	"F1": KEY_F1,
+	"F2": KEY_F2,
+	"F3": KEY_F3,
+	"F4": KEY_F4,
+	"F5": KEY_F5,
+	"F6": KEY_F6,
+	"F7": KEY_F7,
+	"F8": KEY_F8,
+	"F9": KEY_F9,
+	"F10": KEY_F10,
+	"F11": KEY_F11,
+	"F12": KEY_F12,
+	"Space": KEY_SPACE,
+	"Escape": KEY_ESCAPE,
+	"Tab": KEY_TAB,
+	"Enter": KEY_ENTER,
+	"Return": KEY_ENTER,
+	"Backspace": KEY_BACKSPACE,
+	"Delete": KEY_DELETE,
+	"Up": KEY_UP,
+	"Down": KEY_DOWN,
+	"Left": KEY_LEFT,
+	"Right": KEY_RIGHT,
+	"Home": KEY_HOME,
+	"End": KEY_END,
+	"PageUp": KEY_PAGEUP,
+	"PageDown": KEY_PAGEDOWN,
+	"Insert": KEY_INSERT,
+	"Shift": KEY_SHIFT,
+	"Ctrl": KEY_CTRL,
+	"Alt": KEY_ALT,
+	"CapsLock": KEY_CAPSLOCK,
+	"NumLock": KEY_NUMLOCK,
+	"KP0": KEY_KP_0,
+	"KP1": KEY_KP_1,
+	"KP2": KEY_KP_2,
+	"KP3": KEY_KP_3,
+	"KP4": KEY_KP_4,
+	"KP5": KEY_KP_5,
+	"KP6": KEY_KP_6,
+	"KP7": KEY_KP_7,
+	"KP8": KEY_KP_8,
+	"KP9": KEY_KP_9,
+	"Comma": KEY_COMMA,
+	"Period": KEY_PERIOD,
+	"Slash": KEY_SLASH,
+	"Backslash": KEY_BACKSLASH,
+	"Semicolon": KEY_SEMICOLON,
+	"Apostrophe": KEY_APOSTROPHE,
+	"BracketLeft": KEY_BRACKETLEFT,
+	"BracketRight": KEY_BRACKETRIGHT,
+	"Minus": KEY_MINUS,
+	"Equal": KEY_EQUAL,
+}
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Add an input action to the InputMap
+func add_input_action(params: Dictionary) -> Dictionary:
+	var action_name: String = str(params.get("action_name", ""))
+	var events: Array = params.get("events", [])
+	var deadzone: float = float(params.get("deadzone", 0.5))
+
+	_log.info("Adding input action: " + action_name)
+	_log.debug("Events: " + JSON.stringify(events))
+	_log.debug("Deadzone: " + str(deadzone))
+
+	# One bad event fails the whole action: an action written with the events that happened to
+	# parse is a binding the caller did not ask for, reported as the one they did.
+	var events_config: Array[Dictionary] = []
+	for event: Variant in events:
+		if not event is Dictionary:
+			return _log.failure("Every event must be an object, not " + JSON.stringify(event))
+		var fields: Dictionary = event
+		var event_type: String = str(fields.get("type", ""))
+
+		match event_type:
+			"key":
+				var keycode: String = str(fields.get("keycode", ""))
+				if keycode.is_empty():
+					return _log.failure("A key event needs keycode")
+				var key_value: int = _keycode_value(keycode)
+				if key_value == KEY_NONE:
+					return _log.failure("Unknown key: " + keycode)
+
+				var event_config: Dictionary = {"class_name": "InputEventKey", "keycode": key_value}
+				if fields.get("ctrl", false):
+					event_config["ctrl_pressed"] = true
+				if fields.get("alt", false):
+					event_config["alt_pressed"] = true
+				if fields.get("shift", false):
+					event_config["shift_pressed"] = true
+				events_config.append(event_config)
+
+			"mouse_button":
+				events_config.append(
+					{"class_name": "InputEventMouseButton", "button_index": fields.get("button", 1)}
+				)
+
+			"joypad_button":
+				events_config.append(
+					{"class_name": "InputEventJoypadButton", "button_index": fields.get("button", 0)}
+				)
+
+			"joypad_axis":
+				var motion: Dictionary = {
+					"class_name": "InputEventJoypadMotion",
+					"axis": fields.get("axis", 0),
+					"axis_value": fields.get("axisValue", 1),
+				}
+				events_config.append(motion)
+
+			_:
+				var known: String = "key, mouse_button, joypad_button, joypad_axis"
+				return _log.failure("Unknown event type: " + event_type + ". One of " + known + ".")
+
+	if events_config.is_empty():
+		return _log.failure("events must hold at least one event")
+
+	var action: Dictionary = build_input_action(deadzone, events_config)
+	if action.is_empty():
+		return {}
+
+	# 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)
+	var err: Error = ProjectSettings.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
+	}
+
+
+# The value project.godot stores for one input action.
+#
+# It has to be a Dictionary holding real InputEvent objects. The engine writes those as the
+# unquoted expression it parses back into an action; hand it the same thing as assembled
+# text and it writes a quoted, escaped string, which loads as a String and leaves InputMap
+# with no action at all while add_input_action still reports the events it was given.
+func build_input_action(deadzone: float, events: Array) -> Dictionary:
+	# Untyped on purpose: the editor writes this list untyped, and a typed one would be
+	# serialised with an Array[InputEvent] prefix the editor's own project.godot never carries.
+	var built: Array = []
+
+	for event: Dictionary in events:
+		var evt_class: String = str(event.get("class_name", ""))
+
+		match evt_class:
+			"InputEventKey":
+				var key: InputEventKey = InputEventKey.new()
+				key.keycode = int(event.get("keycode", 0)) as Key
+				key.ctrl_pressed = bool(event.get("ctrl_pressed", false))
+				key.alt_pressed = bool(event.get("alt_pressed", false))
+				key.shift_pressed = bool(event.get("shift_pressed", false))
+				built.append(key)
+
+			"InputEventMouseButton":
+				var mouse: InputEventMouseButton = InputEventMouseButton.new()
+				mouse.button_index = (int(event.get("button_index", MOUSE_BUTTON_LEFT)) as MouseButton)
+				built.append(mouse)
+
+			"InputEventJoypadButton":
+				var pad: InputEventJoypadButton = InputEventJoypadButton.new()
+				pad.button_index = int(event.get("button_index", 0)) as JoyButton
+				built.append(pad)
+
+			"InputEventJoypadMotion":
+				var motion: InputEventJoypadMotion = InputEventJoypadMotion.new()
+				motion.axis = int(event.get("axis", 0)) as JoyAxis
+				motion.axis_value = float(event.get("axis_value", 1.0))
+				built.append(motion)
+
+			_:
+				return _log.failure("Unknown input event class: " + evt_class)
+
+	return {"deadzone": deadzone, "events": built}
+
+
+# The keycode for a key name as the tool spells it, or KEY_NONE for a name the table lacks.
+func _keycode_value(key_name: String) -> int:
+	var wanted: String = key_name.to_lower()
+	for name: String in KEY_NAMES:
+		if name.to_lower() == wanted:
+			return KEY_NAMES[name]
+	return KEY_NONE

package/build/godot/operations/logger.gd

@@ -0,0 +1,33 @@
+extends RefCounted
+
+# The server reads one JSON object off stdout and everything else as diagnostics, so the
+# prefixes are what let a human tell the two apart in a log without parsing it.
+#
+# Every module preloads this as `Log`. `Logger` is a native class from Godot 4.5 on, and a
+# constant of that name is a parse error rather than a shadowing warning.
+
+var debug_mode: bool = false
+
+
+func _init(p_debug_mode: bool = false) -> void:
+	debug_mode = p_debug_mode
+
+
+func debug(message: String) -> void:
+	if debug_mode:
+		print("[DEBUG] " + message)
+
+
+func info(message: String) -> void:
+	print("[INFO] " + message)
+
+
+func error(message: String) -> void:
+	printerr("[ERROR] " + message)
+
+
+# The empty result an operation hands back when it cannot answer. Every payload an operation
+# builds has at least one key, so emptiness is unambiguous and the reason is already on stderr.
+func failure(message: String) -> Dictionary:
+	error(message)
+	return {}