gdharness 0.4.1

package/build/godot/operations/plugins.gd

@@ -0,0 +1,159 @@
+extends RefCounted
+
+const Log = preload("logger.gd")
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# List all plugins in the project with their status
+func list_plugins(_params: Dictionary) -> Dictionary:
+	_log.info("Listing plugins")
+
+	var addons_path: String = "res://addons/"
+	if not DirAccess.dir_exists_absolute(ProjectSettings.globalize_path(addons_path)):
+		return {
+			"plugins": [],
+			"addons_directory_exists": false,
+			"enabled_count": 0,
+			"disabled_count": 0,
+			"message": "No addons directory found in the project"
+		}
+
+	var enabled_plugins: Array[String] = _enabled_plugin_names()
+	_log.debug("Enabled plugins: " + str(enabled_plugins))
+
+	var plugins: Array[Dictionary] = []
+	var enabled_count: int = 0
+
+	var dir: DirAccess = DirAccess.open(addons_path)
+	if dir:
+		dir.list_dir_begin()
+		var folder_name: String = dir.get_next()
+
+		while folder_name != "":
+			if dir.current_is_dir() and not folder_name.begins_with("."):
+				var plugin_cfg_path: String = addons_path + folder_name + "/plugin.cfg"
+
+				if FileAccess.file_exists(plugin_cfg_path):
+					var enabled: bool = folder_name in enabled_plugins
+					var plugin_info: Dictionary = {
+						"name": folder_name, "path": addons_path + folder_name, "enabled": enabled
+					}
+
+					var plugin_config: ConfigFile = ConfigFile.new()
+					if plugin_config.load(plugin_cfg_path) == OK:
+						plugin_info["display_name"] = plugin_config.get_value("plugin", "name", folder_name)
+						plugin_info["description"] = plugin_config.get_value("plugin", "description", "")
+						plugin_info["author"] = plugin_config.get_value("plugin", "author", "")
+						plugin_info["version"] = plugin_config.get_value("plugin", "version", "")
+						plugin_info["script"] = plugin_config.get_value("plugin", "script", "")
+
+					plugins.append(plugin_info)
+					if enabled:
+						enabled_count += 1
+
+			folder_name = dir.get_next()
+
+		dir.list_dir_end()
+
+	return {
+		"plugins": plugins,
+		"addons_directory_exists": true,
+		"enabled_count": enabled_count,
+		"disabled_count": plugins.size() - enabled_count
+	}
+
+
+# Enable a plugin
+func enable_plugin(params: Dictionary) -> Dictionary:
+	var plugin_name: String = str(params.get("plugin_name", ""))
+
+	_log.info("Enabling plugin: " + plugin_name)
+
+	var plugin_cfg_path: String = "res://addons/" + plugin_name + "/plugin.cfg"
+	if not FileAccess.file_exists(plugin_cfg_path):
+		_log.error("Plugin not found: " + plugin_name)
+		return _log.failure("Expected plugin.cfg at: " + plugin_cfg_path)
+
+	var enabled_plugins: Array[String] = _enabled_plugin_names()
+
+	if plugin_name in enabled_plugins:
+		return {
+			"plugin_name": plugin_name, "action": "already_enabled", "message": "Plugin is already enabled"
+		}
+
+	enabled_plugins.append(plugin_name)
+	var err: Error = _save_enabled_plugins(enabled_plugins)
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+
+	return {"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": enabled_plugins}
+
+
+# Disable a plugin
+func disable_plugin(params: Dictionary) -> Dictionary:
+	var plugin_name: String = str(params.get("plugin_name", ""))
+
+	_log.info("Disabling plugin: " + plugin_name)
+
+	var enabled_plugins: Array[String] = _enabled_plugin_names()
+
+	if not plugin_name in enabled_plugins:
+		return {
+			"plugin_name": plugin_name,
+			"action": "already_disabled",
+			"message": "Plugin is not currently enabled"
+		}
+
+	enabled_plugins.erase(plugin_name)
+	var err: Error = _save_enabled_plugins(enabled_plugins)
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+
+	return {"plugin_name": plugin_name, "action": "disabled", "enabled_plugins": enabled_plugins}
+
+
+# The addon directory names in [editor_plugins]. The editor stores them as the engine
+# expression PackedStringArray("res://addons/<name>/plugin.cfg", ...), which loads as that
+# type; the String form is what an older hand-edited file can carry.
+func _enabled_plugin_names() -> Array[String]:
+	var names: Array[String] = []
+	var regex: RegEx = RegEx.new()
+	regex.compile("res://addons/([^/]+)/plugin.cfg")
+
+	var enabled_value: Variant = ProjectSettings.get_setting("editor_plugins/enabled", PackedStringArray())
+	if enabled_value is PackedStringArray:
+		var paths: PackedStringArray = enabled_value
+		for path: String in paths:
+			var m: RegExMatch = regex.search(path)
+			if m:
+				names.append(m.get_string(1))
+	elif enabled_value is String:
+		var listed: String = enabled_value
+		for m: RegExMatch in regex.search_all(listed):
+			names.append(m.get_string(1))
+
+	return names
+
+
+# Written through ProjectSettings rather than a ConfigFile of project.godot: the engine saves
+# the file the way the editor does, header comment and all, where ConfigFile drops every
+# comment and reorders what it kept. A real PackedStringArray, because that is serialised as
+# the unquoted expression the editor reads, whereas the same text handed over as a String is
+# written quoted and loads as a String the editor does not recognise as a plugin list. An
+# empty list is the setting removed, which is what the editor writes for no plugins.
+func _save_enabled_plugins(names: Array[String]) -> Error:
+	if names.is_empty():
+		ProjectSettings.set_setting("editor_plugins/enabled", null)
+		return ProjectSettings.save()
+
+	var enabled_paths: PackedStringArray = PackedStringArray()
+	for name: String in names:
+		enabled_paths.append("res://addons/" + name + "/plugin.cfg")
+
+	ProjectSettings.set_setting("editor_plugins/enabled", enabled_paths)
+	return ProjectSettings.save()

package/build/godot/operations/project_config.gd

@@ -0,0 +1,153 @@
+extends RefCounted
+
+const Log = preload("logger.gd")
+const Serialisation = preload("serialisation.gd")
+
+var _log: Log
+var _values: Serialisation = Serialisation.new()
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Get a project setting value
+func get_project_setting(params: Dictionary) -> Dictionary:
+	var setting_path: String = str(params.get("setting", ""))
+
+	_log.info("Getting project setting: " + setting_path)
+
+	var result: Dictionary = {
+		"setting_path": setting_path, "exists": ProjectSettings.has_setting(setting_path)
+	}
+
+	if result["exists"]:
+		result["value"] = _values.serialize_value(ProjectSettings.get_setting(setting_path))
+	else:
+		result["value"] = null
+		result["message"] = "Setting does not exist"
+
+	return result
+
+
+# Set a project setting value
+func set_project_setting(params: Dictionary) -> Dictionary:
+	var setting_path: String = str(params.get("setting", ""))
+	if setting_path.is_empty():
+		return _log.failure("setting is required")
+	var value: Variant = params.get("value")
+
+	_log.info("Setting project setting: " + setting_path)
+
+	var old_value: Variant = null
+	var had_value: bool = ProjectSettings.has_setting(setting_path)
+	if had_value:
+		old_value = ProjectSettings.get_setting(setting_path)
+
+	var final_value: Variant = _values.deserialize_value(value)
+	ProjectSettings.set_setting(setting_path, final_value)
+	var err: Error = ProjectSettings.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+
+	return {
+		"setting_path": setting_path,
+		"old_value": _values.serialize_value(old_value) if had_value else null,
+		"new_value": _values.serialize_value(final_value),
+		"was_new": not had_value,
+		"saved": true,
+	}
+
+
+# Add an autoload singleton
+func add_autoload(params: Dictionary) -> Dictionary:
+	var name: String = str(params.get("name", ""))
+	var path: String = str(params.get("path", ""))
+	var enabled: bool = bool(params.get("enabled", true))
+
+	if not path.begins_with("res://"):
+		path = "res://" + path
+
+	_log.info("Adding autoload: " + name + " -> " + path)
+
+	if not FileAccess.file_exists(path):
+		return _log.failure("Autoload file does not exist: " + path)
+
+	# 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.
+	var setting: String = "autoload/" + name
+	var was_updated: bool = ProjectSettings.has_setting(setting)
+
+	# An asterisk in front of the path is how project.godot marks an autoload as enabled.
+	ProjectSettings.set_setting(setting, ("*" if enabled else "") + path)
+	var err: Error = ProjectSettings.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+
+	return {"name": name, "path": path, "enabled": enabled, "action": "updated" if was_updated else "added"}
+
+
+# Remove an autoload singleton
+func remove_autoload(params: Dictionary) -> Dictionary:
+	var name: String = str(params.get("name", ""))
+
+	_log.info("Removing autoload: " + name)
+
+	var setting: String = "autoload/" + name
+	if not ProjectSettings.has_setting(setting):
+		return _log.failure("Autoload not found: " + name)
+
+	var old_value: String = str(ProjectSettings.get_setting(setting))
+	ProjectSettings.set_setting(setting, null)
+	var err: Error = ProjectSettings.save()
+	if err != OK:
+		return _log.failure("Failed to save project.godot: " + error_string(err))
+
+	return {"name": name, "removed": true, "old_path": old_value.trim_prefix("*")}
+
+
+# List all autoload singletons
+func list_autoloads(_params: Dictionary) -> Dictionary:
+	_log.info("Listing autoloads")
+
+	var autoloads: Array[Dictionary] = []
+
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if not setting.begins_with("autoload/"):
+			continue
+		var value: String = str(ProjectSettings.get_setting(setting))
+		var path: String = value.trim_prefix("*")
+
+		var autoload_info: Dictionary = {
+			"name": setting.trim_prefix("autoload/"),
+			"path": path,
+			"enabled": value.begins_with("*"),
+			"file_exists": FileAccess.file_exists(path),
+		}
+		autoloads.append(autoload_info)
+
+	return {"autoloads": autoloads, "count": autoloads.size()}
+
+
+# Set the main scene
+func set_main_scene(params: Dictionary) -> Dictionary:
+	var scene_path: String = str(params.get("scene_path", ""))
+
+	if not scene_path.begins_with("res://"):
+		scene_path = "res://" + scene_path
+
+	_log.info("Setting main scene: " + scene_path)
+
+	if not FileAccess.file_exists(scene_path):
+		return _log.failure("Scene file does not exist: " + scene_path)
+
+	var old_main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
+
+	ProjectSettings.set_setting("application/run/main_scene", scene_path)
+	var err: Error = ProjectSettings.save()
+
+	if err != OK:
+		return _log.failure("Failed to save project settings: " + str(err))
+
+	return {"old_main_scene": old_main_scene, "new_main_scene": scene_path, "saved": true}

package/build/godot/operations/project_diagnostics.gd

@@ -0,0 +1,159 @@
+extends RefCounted
+
+const FileWalk = preload("file_walk.gd")
+const Log = preload("logger.gd")
+
+var _log: Log
+var _files: FileWalk = FileWalk.new()
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Get comprehensive project health check with scoring
+func get_project_health(params: Dictionary) -> Dictionary:
+	var check_categories: Array = params.get(
+		"categories", ["structure", "resources", "scripts", "scenes", "config"]
+	)
+
+	_log.info("Performing project health check")
+
+	var checks: Dictionary = {}
+	var recommendations: Array[String] = []
+	var deductions: int = 0
+
+	# 1. Project Structure Check
+	if "structure" in check_categories:
+		var passed: bool = true
+		var details: Array[String] = []
+
+		if not FileAccess.file_exists("res://project.godot"):
+			passed = false
+			details.append("Missing project.godot file")
+			deductions += 30
+
+		var recommended_dirs: Array[String] = ["res://scenes", "res://scripts", "res://assets"]
+		var missing_dirs: Array[String] = []
+		for dir: String in recommended_dirs:
+			if not DirAccess.dir_exists_absolute(ProjectSettings.globalize_path(dir)):
+				missing_dirs.append(dir)
+
+		if missing_dirs.size() > 0:
+			details.append("Consider organizing with directories: " + ", ".join(missing_dirs))
+			deductions += 2 * missing_dirs.size()
+
+		checks["structure"] = {"name": "Project Structure", "passed": passed, "details": details}
+
+	# 2. Resource Check
+	if "resources" in check_categories:
+		var details: Array[String] = []
+
+		var importable_extensions: Array[String] = ["png", "jpg", "wav", "mp3", "ogg"]
+		var resources: Array[String] = []
+		for ext: String in importable_extensions:
+			resources.append_array(_files.find_files("res://", "." + ext))
+
+		var missing_imports: int = 0
+		for res: String in resources:
+			if not FileAccess.file_exists(res + ".import"):
+				missing_imports += 1
+
+		if missing_imports > 0:
+			details.append(str(missing_imports) + " resources may need reimporting")
+			deductions += missing_imports
+
+		checks["resources"] = {
+			"name": "Resources", "passed": true, "details": details, "total_resources": resources.size()
+		}
+
+	# 3. Scripts Check
+	if "scripts" in check_categories:
+		var details: Array[String] = []
+
+		var script_files: Array[String] = _files.find_files("res://", ".gd")
+		var todo_count: int = 0
+		var empty_functions: int = 0
+
+		for script_path: String in script_files:
+			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:
+					todo_count += 1
+				if "pass # " in content or content.ends_with("pass\n"):
+					empty_functions += 1
+
+		if todo_count > 0:
+			details.append(str(todo_count) + " scripts have TODO/FIXME comments")
+			deductions += todo_count
+
+		if empty_functions > 0:
+			details.append(str(empty_functions) + " scripts may have empty functions")
+			deductions += empty_functions
+
+		checks["scripts"] = {
+			"name": "Scripts", "passed": true, "details": details, "total_scripts": script_files.size()
+		}
+
+	# 4. Scenes Check
+	if "scenes" in check_categories:
+		var details: Array[String] = []
+
+		var scene_files: Array[String] = _files.find_files("res://", ".tscn")
+		if scene_files.size() == 0:
+			details.append("No scene files found in project")
+			deductions += 5
+
+		checks["scenes"] = {
+			"name": "Scenes", "passed": true, "details": details, "total_scenes": scene_files.size()
+		}
+
+	# 5. Configuration Check
+	if "config" in check_categories:
+		var details: Array[String] = []
+
+		var main_scene: String = str(ProjectSettings.get_setting("application/run/main_scene", ""))
+		if main_scene.is_empty():
+			details.append("No main scene configured")
+			deductions += 10
+		elif not FileAccess.file_exists(main_scene):
+			details.append("Main scene file does not exist: " + main_scene)
+			deductions += 15
+
+		var project_name: String = str(ProjectSettings.get_setting("application/config/name", ""))
+		if project_name.is_empty():
+			details.append("No project name set")
+			deductions += 2
+
+		if not FileAccess.file_exists("res://export_presets.cfg"):
+			details.append("No export presets configured")
+			deductions += 3
+
+		checks["config"] = {"name": "Configuration", "passed": true, "details": details}
+
+	var score: int = maxi(0, 100 - deductions)
+
+	var grade: String
+	if score >= 90:
+		grade = "A"
+	elif score >= 80:
+		grade = "B"
+	elif score >= 70:
+		grade = "C"
+	elif score >= 60:
+		grade = "D"
+	else:
+		grade = "F"
+
+	if deductions > 0:
+		if score < 70:
+			recommendations.append("Address critical issues to improve project stability")
+		if not FileAccess.file_exists("res://export_presets.cfg"):
+			recommendations.append("Configure export presets for your target platforms")
+
+	return {
+		"score": score, "grade": grade, "checks": checks, "issues": [], "recommendations": recommendations
+	}

package/build/godot/operations/resource_files.gd

@@ -0,0 +1,132 @@
+extends RefCounted
+
+const FileWalk = preload("file_walk.gd")
+const Log = preload("logger.gd")
+
+var _log: Log
+var _files: FileWalk = FileWalk.new()
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# The UID the engine gave a file, from the .uid sidecar it writes beside scripts and shaders.
+func get_uid(params: Dictionary) -> Dictionary:
+	var file_path: String = str(params.get("resource_path", ""))
+	if file_path.is_empty():
+		return _log.failure("resource_path is required")
+	if not file_path.begins_with("res://"):
+		file_path = "res://" + file_path
+
+	_log.info("Getting UID for file: " + file_path)
+
+	var absolute_path: String = ProjectSettings.globalize_path(file_path)
+	if not FileAccess.file_exists(file_path):
+		return _log.failure("File does not exist: " + file_path)
+
+	var uid_path: String = file_path + ".uid"
+	var f: FileAccess = FileAccess.open(uid_path, FileAccess.READ)
+	if not f:
+		return {
+			"file": file_path,
+			"absolute_path": absolute_path,
+			"exists": false,
+			"message": "No .uid sidecar. refresh_uids writes one for every script and shader."
+		}
+
+	var uid_content: String = f.get_as_text()
+	f.close()
+
+	return {
+		"file": file_path, "absolute_path": absolute_path, "uid": uid_content.strip_edges(), "exists": true
+	}
+
+
+# Resave every scene, script and shader so that UID references are current.
+func resave_resources(_params: Dictionary) -> Dictionary:
+	_log.info("Resaving all resources to update UID references...")
+	var project_path: String = "res://"
+
+	var scenes: Array[String] = _files.find_files(project_path, ".tscn")
+	_log.debug("Found " + str(scenes.size()) + " scenes")
+
+	# Resave each scene
+	var success_count: int = 0
+	var error_count: int = 0
+
+	for scene_path: String in scenes:
+		_log.debug("Processing scene: " + scene_path)
+
+		if not FileAccess.file_exists(scene_path):
+			_log.error("Scene file does not exist at: " + scene_path)
+			error_count += 1
+			continue
+
+		var scene: Resource = load(scene_path)
+		if not scene:
+			error_count += 1
+			_log.error("Failed to load: " + scene_path)
+			continue
+
+		var error: Error = ResourceSaver.save(scene, scene_path)
+		if error != OK:
+			error_count += 1
+			_log.error("Failed to save: " + scene_path + ", error: " + str(error))
+			continue
+
+		success_count += 1
+		if _log.debug_mode:
+			_log.debug("Scene saved successfully: " + scene_path)
+			var file_check_after: bool = FileAccess.file_exists(scene_path)
+			_log.debug("File exists check after save: " + str(file_check_after))
+			if not file_check_after:
+				_log.error("File reported as saved but does not exist at: " + scene_path)
+
+	# A UID sits beside every script and shader as a .uid file. Outside the editor the save
+	# below answers OK and writes no sidecar, so what comes back is what was resaved and how
+	# many are still without one, rather than a count of UIDs this made.
+	var scripts: Array[String] = (
+		_files.find_files(project_path, ".gd")
+		+ _files.find_files(project_path, ".shader")
+		+ _files.find_files(project_path, ".gdshader")
+	)
+	_log.debug("Found " + str(scripts.size()) + " scripts/shaders")
+
+	var missing_uids: int = 0
+	var resaved_scripts: int = 0
+
+	for script_path: String in scripts:
+		_log.debug("Checking UID for: " + script_path)
+		var uid_path: String = script_path + ".uid"
+
+		var f: FileAccess = FileAccess.open(uid_path, FileAccess.READ)
+		if f:
+			_log.debug("UID file already exists for: " + script_path)
+			continue
+
+		missing_uids += 1
+		_log.debug("Missing UID file for: " + script_path + ", resaving...")
+
+		var res: Resource = load(script_path)
+		if not res:
+			_log.error("Failed to load resource: " + script_path)
+			continue
+
+		var error: Error = ResourceSaver.save(res, script_path)
+		if error != OK:
+			_log.error("Failed to resave: " + script_path + ", error: " + str(error))
+			continue
+
+		resaved_scripts += 1
+		_log.debug("Resaved: " + script_path)
+
+	_log.info("Resave operation complete")
+
+	return {
+		"scenes_processed": scenes.size(),
+		"scenes_saved": success_count,
+		"scenes_with_errors": error_count,
+		"scripts_missing_uids": missing_uids,
+		"scripts_resaved": resaved_scripts
+	}