gdharness 0.4.1

package/build/godot/operations/gdscript_authoring.gd

@@ -0,0 +1,419 @@
+extends RefCounted
+
+const Log = preload("logger.gd")
+
+var _log: Log
+
+
+func _init(p_log: Log) -> void:
+	_log = p_log
+
+
+# Create a new GDScript file with proper structure and optional templates
+func create_gdscript(params: Dictionary) -> Dictionary:
+	var script_path: String = str(params.get("script_path", ""))
+	var cls_name_param: String = str(params.get("class_name", ""))
+	var extends_class: String = str(params.get("extends", "Node"))
+	if extends_class.is_empty():
+		extends_class = "Node"
+	var content: String = str(params.get("content", ""))
+	var template: String = str(params.get("template", ""))
+
+	_log.info("Creating GDScript: " + script_path)
+
+	var full_script_path: String = script_path
+	if not full_script_path.begins_with("res://"):
+		full_script_path = "res://" + full_script_path
+
+	if not full_script_path.ends_with(".gd"):
+		return _log.failure("Script path must end with .gd extension")
+
+	if FileAccess.file_exists(full_script_path):
+		return _log.failure("Script file already exists: " + full_script_path)
+
+	var dir: DirAccess = DirAccess.open("res://")
+	var script_dir: String = full_script_path.get_base_dir()
+	if script_dir != "res://" and not dir.dir_exists(script_dir.substr(6)):
+		_log.debug("Creating directory: " + script_dir)
+		var error: Error = dir.make_dir_recursive(script_dir.substr(6))
+		if error != OK:
+			return _log.failure("Failed to create directory: " + script_dir + ", error: " + str(error))
+
+	var script_content: String = ""
+
+	if not cls_name_param.is_empty():
+		script_content += "class_name " + cls_name_param + "\n"
+
+	script_content += "extends " + extends_class + "\n\n"
+
+	if not template.is_empty():
+		script_content += _script_template(template)
+	elif not content.is_empty():
+		script_content += content
+	else:
+		script_content += "func _ready() -> void:\n"
+		script_content += "\tpass\n"
+
+	var file: FileAccess = FileAccess.open(full_script_path, FileAccess.WRITE)
+	if not file:
+		return _log.failure("Failed to create script file: " + full_script_path)
+
+	file.store_string(script_content)
+	file.close()
+
+	# Whether the engine accepts what was written, parsed under this project's own warning
+	# settings: a script that does not load is a script the caller wants to hear about now,
+	# and the reason is on stderr, which comes back with the answer.
+	var written: Script = ResourceLoader.load(full_script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
+
+	return {
+		"success": true,
+		"script_path": script_path,
+		"full_path": full_script_path,
+		"absolute_path": ProjectSettings.globalize_path(full_script_path),
+		"registered": not cls_name_param.is_empty(),
+		"extends": extends_class,
+		"template_used": template if not template.is_empty() else "none",
+		"parses": written != null and written.can_instantiate(),
+	}
+
+
+# Modify an existing GDScript file by adding functions, variables, or signals
+func modify_gdscript(params: Dictionary) -> Dictionary:
+	var script_path: String = str(params.get("script_path", ""))
+	var modifications: Array = params.get("modifications", [])
+
+	_log.info("Modifying GDScript: " + script_path)
+
+	var full_script_path: String = script_path
+	if not full_script_path.begins_with("res://"):
+		full_script_path = "res://" + full_script_path
+
+	if not FileAccess.file_exists(full_script_path):
+		return _log.failure("Script file does not exist: " + full_script_path)
+
+	var file: FileAccess = FileAccess.open(full_script_path, FileAccess.READ)
+	if not file:
+		return _log.failure("Failed to open script file: " + full_script_path)
+
+	var original_content: String = file.get_as_text()
+	file.close()
+
+	var lines: Array[String] = []
+	lines.assign(original_content.split("\n"))
+	var modifications_applied: Array[Dictionary] = []
+
+	for mod: Variant in modifications:
+		if not mod is Dictionary:
+			_log.error("Modification must be an object")
+			continue
+		var fields: Dictionary = mod
+		var mod_type: String = str(fields.get("type", ""))
+		var mod_name: String = str(fields.get("name", ""))
+
+		if mod_name.is_empty():
+			_log.error("Modification missing 'name' field")
+			continue
+
+		match mod_type:
+			"add_variable":
+				var line: int = _add_variable(lines, fields)
+				modifications_applied.append({"type": "add_variable", "name": mod_name, "line": line})
+			"add_signal":
+				var line: int = _add_signal(lines, fields)
+				modifications_applied.append({"type": "add_signal", "name": mod_name, "line": line})
+			"add_function":
+				var line: int = _add_function(lines, fields)
+				modifications_applied.append({"type": "add_function", "name": mod_name, "line": line})
+			_:
+				_log.error("Unknown modification type: " + mod_type)
+
+	file = FileAccess.open(full_script_path, FileAccess.WRITE)
+	if not file:
+		return _log.failure("Failed to write to script file: " + full_script_path)
+
+	file.store_string("\n".join(lines))
+	file.close()
+
+	return {
+		"success": true,
+		"script_path": script_path,
+		"modifications_applied": modifications_applied,
+		"total_modifications": modifications_applied.size()
+	}
+
+
+# Inserts the declaration and answers with its one-based line number.
+func _add_variable(lines: Array[String], mod: Dictionary) -> int:
+	var var_name: String = str(mod.get("name", ""))
+	var var_type: String = str(mod.get("varType", ""))
+	var default_value: String = str(mod.get("defaultValue", ""))
+	var is_export: bool = bool(mod.get("isExport", false))
+	var export_hint: String = str(mod.get("exportHint", ""))
+	var is_onready: bool = bool(mod.get("isOnready", false))
+
+	var var_line: String = ""
+
+	if is_export:
+		if not export_hint.is_empty():
+			var_line += "@export_" + export_hint + " "
+		else:
+			var_line += "@export "
+
+	if is_onready:
+		var_line += "@onready "
+
+	var_line += "var " + var_name
+
+	# Every declaration this writes carries a type, so it parses in a project that treats an
+	# untyped or an inferred declaration as an error, which is the strictest setting Godot has.
+	# A value with no type gets the type the value evaluates to; a value nothing can evaluate
+	# here, and a declaration with neither, are spelled out as Variant.
+	if not var_type.is_empty():
+		var_line += ": " + var_type
+		if not default_value.is_empty():
+			var_line += " = " + default_value
+	elif not default_value.is_empty():
+		var_line += ": " + _type_of_literal(default_value) + " = " + default_value
+	else:
+		var_line += ": Variant"
+
+	var insert_line: int = _variable_insertion_point(lines)
+	lines.insert(insert_line, var_line)
+	return insert_line + 1
+
+
+# The type name a constant expression evaluates to, or Variant when it is not one: a call
+# into the script's own scope cannot be evaluated from here, and a type guessed for it would
+# be a claim the engine then refuses at load.
+func _type_of_literal(expression: String) -> String:
+	var parser: Expression = Expression.new()
+	if parser.parse(expression) != OK:
+		return "Variant"
+	var value: Variant = parser.execute([], null, false)
+	if parser.has_execute_failed() or value == null:
+		return "Variant"
+	if value is Object:
+		var object: Object = value
+		return object.get_class()
+	return type_string(typeof(value))
+
+
+func _add_signal(lines: Array[String], mod: Dictionary) -> int:
+	var signal_name: String = str(mod.get("name", ""))
+	var signal_params: String = str(mod.get("params", ""))
+
+	var signal_line: String = "signal " + signal_name
+	if not signal_params.is_empty():
+		signal_line += "(" + signal_params + ")"
+
+	var insert_line: int = _signal_insertion_point(lines)
+	lines.insert(insert_line, signal_line)
+	return insert_line + 1
+
+
+func _add_function(lines: Array[String], mod: Dictionary) -> int:
+	var func_name: String = str(mod.get("name", ""))
+	var func_params: String = str(mod.get("params", ""))
+	# A function that names no return type returns nothing, and says so, for the same reason
+	# the variable above does.
+	var return_type: String = str(mod.get("returnType", ""))
+	if return_type.is_empty():
+		return_type = "void"
+	var body: String = str(mod.get("body", "pass"))
+	var position: String = str(mod.get("position", "end"))
+
+	var func_lines: Array[String] = []
+	var func_decl: String = "func " + func_name + "(" + func_params + ") -> " + return_type + ":"
+	func_lines.append("")
+	func_lines.append(func_decl)
+
+	for bl: String in body.split("\n"):
+		func_lines.append("\t" + bl)
+
+	var insert_line: int = _function_insertion_point(lines, position)
+
+	for i: int in range(func_lines.size() - 1, -1, -1):
+		lines.insert(insert_line, func_lines[i])
+
+	return insert_line + 1
+
+
+func _variable_insertion_point(lines: Array[String]) -> int:
+	var after_header: int = 0
+	var before_func: int = lines.size()
+
+	for i: int in range(lines.size()):
+		var line: String = lines[i].strip_edges()
+		if line.begins_with("extends ") or line.begins_with("class_name "):
+			after_header = i + 1
+		elif line.begins_with("signal "):
+			after_header = i + 1
+		elif line.begins_with("func ") or line.begins_with("static func "):
+			before_func = i
+			break
+
+	for i: int in range(after_header, before_func):
+		var line: String = lines[i].strip_edges()
+		if line.begins_with("var ") or line.begins_with("@export") or line.begins_with("@onready"):
+			after_header = i + 1
+
+	return after_header
+
+
+func _signal_insertion_point(lines: Array[String]) -> int:
+	var after_header: int = 0
+
+	for i: int in range(lines.size()):
+		var line: String = lines[i].strip_edges()
+		if line.begins_with("extends ") or line.begins_with("class_name "):
+			after_header = i + 1
+		elif line.begins_with("signal "):
+			after_header = i + 1
+		elif (
+			line.begins_with("var ")
+			or line.begins_with("@export")
+			or line.begins_with("@onready")
+			or line.begins_with("func ")
+		):
+			break
+
+	return after_header
+
+
+func _function_insertion_point(lines: Array[String], position: String) -> int:
+	match position:
+		"after_ready":
+			return _line_after_function(lines, "func _ready")
+		"after_init":
+			return _line_after_function(lines, "func _init")
+		_:
+			return lines.size()
+
+
+# The line the next function starts on after the one whose declaration begins with `prefix`,
+# or the end of the file when it is the last one or is not there at all.
+func _line_after_function(lines: Array[String], prefix: String) -> int:
+	var inside: bool = false
+	for i: int in range(lines.size()):
+		var line: String = lines[i].strip_edges()
+		if line.begins_with(prefix):
+			inside = true
+		elif inside and (line.begins_with("func ") or line.begins_with("static func ")):
+			return i
+	return lines.size()
+
+
+func _script_template(template_name: String) -> String:
+	match template_name:
+		"singleton":
+			return """## Singleton (Autoload) script
+## Add to Project Settings -> Autoload to use as a global singleton
+
+var _instance: Object = null
+
+func _init() -> void:
+\tif _instance != null:
+\t\tpush_error("Singleton instance already exists!")
+\t\treturn
+\t_instance = self
+
+func _ready() -> void:
+\tpass
+
+# Add your singleton methods here
+"""
+		"state_machine":
+			return """## Finite State Machine implementation
+
+signal state_changed(old_state: String, new_state: String)
+
+var current_state: String = ""
+## State objects by name. A state may define enter(), exit(), process(delta) and
+## physics_process(delta); whichever it has are called.
+var states: Dictionary = {}
+
+func _ready() -> void:
+\t_setup_states()
+\tif states.size() > 0:
+\t\tchange_state(str(states.keys()[0]))
+
+func _setup_states() -> void:
+\t# Override this to add states
+\t# Example: states["idle"] = IdleState.new()
+\tpass
+
+func _process(delta: float) -> void:
+\t_call_state(current_state, "process", [delta])
+
+func _physics_process(delta: float) -> void:
+\t_call_state(current_state, "physics_process", [delta])
+
+func change_state(new_state: String) -> void:
+\tif not states.has(new_state):
+\t\tpush_error("State not found: " + new_state)
+\t\treturn
+
+\tvar old_state: String = current_state
+\t_call_state(old_state, "exit", [])
+\tcurrent_state = new_state
+\t_call_state(current_state, "enter", [])
+\tstate_changed.emit(old_state, new_state)
+
+## Calls a method on the named state when it has one; a state without it is left alone.
+func _call_state(state_name: String, method: String, args: Array) -> void:
+\tif state_name.is_empty() or not states.has(state_name):
+\t\treturn
+\tvar state: Object = states[state_name]
+\tif state != null and state.has_method(method):
+\t\tstate.callv(method, args)
+"""
+		"component":
+			return """## Component pattern - attach to nodes to add behavior
+
+@export var enabled: bool = true
+
+func _ready() -> void:
+\tif not enabled:
+\t\tset_process(false)
+\t\tset_physics_process(false)
+
+func _process(_delta: float) -> void:
+\tif not enabled:
+\t\treturn
+\t# Component logic here
+\tpass
+
+func enable() -> void:
+\tenabled = true
+\tset_process(true)
+\tset_physics_process(true)
+
+func disable() -> void:
+\tenabled = false
+\tset_process(false)
+\tset_physics_process(false)
+"""
+		"resource":
+			return """## Custom Resource - save and load data
+
+@export var id: String = ""
+@export var display_name: String = ""
+@export var description: String = ""
+
+func _init(p_id: String = "", p_name: String = "", p_desc: String = "") -> void:
+\tid = p_id
+\tdisplay_name = p_name
+\tdescription = p_desc
+
+func duplicate_resource() -> Resource:
+\tvar new_resource: Resource = duplicate()
+\treturn new_resource
+"""
+		_:
+			return """func _ready() -> void:
+\tpass
+
+func _process(_delta: float) -> void:
+\tpass
+"""

package/build/godot/operations/godot_operations.gd

@@ -0,0 +1,186 @@
+#!/usr/bin/env -S godot --headless --script
+extends SceneTree
+
+# The command line the server runs is `godot --headless --path <project> --script <this>
+# <operation> @file:<params.json>`, and one JSON object on stdout is the answer. Everything an
+# operation does lives in a sibling module; this file is the command table and the wire format.
+#
+# Each module is preloaded by a path relative to this script rather than a res:// one, because
+# the operations directory ships inside the server package and is handed to the engine as an
+# absolute path outside the project. A res:// path would only resolve in the test fixture.
+
+const AudioBuses = preload("audio_buses.gd")
+const ClassCache = preload("class_cache.gd")
+const ClassDbQueries = preload("classdb_queries.gd")
+const Dependencies = preload("dependencies.gd")
+const GdscriptAnalysis = preload("gdscript_analysis.gd")
+const GdscriptAuthoring = preload("gdscript_authoring.gd")
+const ImportPipeline = preload("import_pipeline.gd")
+const InputActions = preload("input_actions.gd")
+const Log = preload("logger.gd")
+const Plugins = preload("plugins.gd")
+const ProjectConfig = preload("project_config.gd")
+const ProjectDiagnostics = preload("project_diagnostics.gd")
+const ResourceFiles = preload("resource_files.gd")
+
+var _log: Log
+
+
+func _init() -> void:
+	var args: PackedStringArray = OS.get_cmdline_args()
+	_log = Log.new("--debug-godot" in args)
+
+	# The script path is the argument after --script, so the operation and its parameters are
+	# the two that follow it.
+	var script_index: int = args.find("--script")
+	if script_index == -1:
+		_log.error("Could not find --script argument")
+		quit(1)
+		return
+
+	var params_index: int = script_index + 3
+	if args.size() <= params_index:
+		_log.error("Usage: godot --headless --script godot_operations.gd <operation> <json_params>")
+		_log.error("Not enough command-line arguments provided.")
+		quit(1)
+		return
+
+	_log.debug("All arguments: " + str(args))
+
+	var operation: String = args[script_index + 2]
+	var params: Variant = _read_params(args[params_index])
+	if not params is Dictionary:
+		quit(1)
+		return
+
+	_log.info("Executing operation: " + operation)
+
+	var payload: Dictionary = _run(operation, params)
+	if payload.is_empty():
+		quit(1)
+		return
+
+	print(JSON.stringify(payload))
+	quit()
+
+
+# The operation parameters. They arrive as a path to a JSON file rather than as JSON on argv
+# because a blob on the command line runs into Windows parsing of \t, \r and \" whatever the
+# quoting. Null means the parameters could not be read, and the reason is already on stderr.
+func _read_params(argument: String) -> Variant:
+	var params_json: String = argument
+
+	if params_json.begins_with("@file:"):
+		var params_file_path: String = params_json.substr(6)
+		var params_file: FileAccess = FileAccess.open(params_file_path, FileAccess.READ)
+		if params_file == null:
+			_log.error("Failed to open params file: " + params_file_path)
+			return null
+		params_json = params_file.get_as_text()
+		params_file.close()
+
+	_log.debug("Params JSON: " + params_json)
+
+	var json: JSON = JSON.new()
+	if json.parse(params_json) != OK:
+		_log.error("Failed to parse JSON parameters: " + params_json)
+		_log.error("JSON Error: " + json.get_error_message() + " at line " + str(json.get_error_line()))
+		return null
+
+	var params: Variant = json.get_data()
+	if not params is Dictionary:
+		_log.error("Parameters must be a JSON object: " + params_json)
+		return null
+	return params
+
+
+# The payload one operation answers with, or an empty dictionary when it failed or nobody
+# owns the name.
+func _run(operation: String, params: Dictionary) -> Dictionary:
+	var payload: Dictionary = {}
+
+	match operation:
+		# Resource files
+		"get_uid":
+			payload = ResourceFiles.new(_log).get_uid(params)
+		"resave_resources":
+			payload = ResourceFiles.new(_log).resave_resources(params)
+		"refresh_class_cache":
+			payload = ClassCache.new(_log).refresh_class_cache(params)
+
+		# Import and export pipeline
+		"get_import_status":
+			payload = ImportPipeline.new(_log).get_import_status(params)
+		"get_import_options":
+			payload = ImportPipeline.new(_log).get_import_options(params)
+		"set_import_options":
+			payload = ImportPipeline.new(_log).set_import_options(params)
+		"reimport_resource":
+			payload = ImportPipeline.new(_log).reimport_resource(params)
+		"list_export_presets":
+			payload = ImportPipeline.new(_log).list_export_presets(params)
+		"validate_project":
+			payload = ImportPipeline.new(_log).validate_project(params)
+
+		# Dependencies and project inspection
+		"get_dependencies":
+			payload = Dependencies.new(_log).get_dependencies(params)
+		"find_resource_usages":
+			payload = Dependencies.new(_log).find_resource_usages(params)
+		"get_project_health":
+			payload = ProjectDiagnostics.new(_log).get_project_health(params)
+
+		# project.godot
+		"get_project_setting":
+			payload = ProjectConfig.new(_log).get_project_setting(params)
+		"set_project_setting":
+			payload = ProjectConfig.new(_log).set_project_setting(params)
+		"add_autoload":
+			payload = ProjectConfig.new(_log).add_autoload(params)
+		"remove_autoload":
+			payload = ProjectConfig.new(_log).remove_autoload(params)
+		"list_autoloads":
+			payload = ProjectConfig.new(_log).list_autoloads(params)
+		"set_main_scene":
+			payload = ProjectConfig.new(_log).set_main_scene(params)
+
+		# GDScript files
+		"create_script":
+			payload = GdscriptAuthoring.new(_log).create_gdscript(params)
+		"modify_script":
+			payload = GdscriptAuthoring.new(_log).modify_gdscript(params)
+		"get_script_info":
+			payload = GdscriptAnalysis.new(_log).get_gdscript_info(params)
+
+		# Plugins and input
+		"list_plugins":
+			payload = Plugins.new(_log).list_plugins(params)
+		"enable_plugin":
+			payload = Plugins.new(_log).enable_plugin(params)
+		"disable_plugin":
+			payload = Plugins.new(_log).disable_plugin(params)
+		"add_input_action":
+			payload = InputActions.new(_log).add_input_action(params)
+
+		# Audio
+		"create_audio_bus":
+			payload = AudioBuses.new(_log).create_audio_bus(params)
+		"get_audio_buses":
+			payload = AudioBuses.new(_log).get_audio_buses(params)
+		"set_audio_bus_effect":
+			payload = AudioBuses.new(_log).set_audio_bus_effect(params)
+		"set_audio_bus_volume":
+			payload = AudioBuses.new(_log).set_audio_bus_volume(params)
+
+		# ClassDB
+		"query_classes":
+			payload = ClassDbQueries.new(_log).query_classes(params)
+		"query_class_info":
+			payload = ClassDbQueries.new(_log).query_class_info(params)
+		"inspect_inheritance":
+			payload = ClassDbQueries.new(_log).inspect_inheritance(params)
+
+		_:
+			_log.error("Unknown operation: " + operation)
+
+	return payload