@baixfeng/godot-mcp-cli 1.0.11

package/addons/godot_mcp/commands/scene_commands.gd

@@ -0,0 +1,337 @@
+@tool
+class_name MCPSceneCommands
+extends MCPBaseCommandProcessor
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+	match command_type:
+		"save_scene":
+			_save_scene(client_id, params, command_id)
+			return true
+		"open_scene":
+			_open_scene(client_id, params, command_id)
+			return true
+		"get_current_scene":
+			_get_current_scene(client_id, params, command_id)
+			return true
+		"get_scene_structure":
+			_get_scene_structure(client_id, params, command_id)
+			return true
+		"create_scene":
+			_create_scene(client_id, params, command_id)
+			return true
+		"delete_scene":
+			_delete_scene(client_id, params, command_id)
+			return true
+	return false  # Command not handled
+
+func _save_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+	
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+	
+	var editor_interface = plugin.get_editor_interface()
+	var edited_scene_root = editor_interface.get_edited_scene_root()
+	
+	# If no path provided, use the current scene path
+	if path.is_empty() and edited_scene_root:
+		path = edited_scene_root.scene_file_path
+	
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Scene path cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not path.begins_with("res://"):
+		path = "res://" + path
+	
+	if not path.ends_with(".tscn"):
+		path += ".tscn"
+	
+	# Check if we have an edited scene
+	if not edited_scene_root:
+		return _send_error(client_id, "No scene is currently being edited", command_id)
+	
+	# Save the scene
+	var packed_scene = PackedScene.new()
+	var result = packed_scene.pack(edited_scene_root)
+	if result != OK:
+		return _send_error(client_id, "Failed to pack scene: %d" % result, command_id)
+	
+	result = ResourceSaver.save(packed_scene, path)
+	if result != OK:
+		return _send_error(client_id, "Failed to save scene: %d" % result, command_id)
+	
+	_send_success(client_id, {
+		"scene_path": path
+	}, command_id)
+
+func _open_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+	
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Scene path cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not path.begins_with("res://"):
+		path = "res://" + path
+	
+	# Check if the file exists
+	if not FileAccess.file_exists(path):
+		return _send_error(client_id, "Scene file not found: %s" % path, command_id)
+	
+	# Since we can't directly open scenes in tool scripts,
+	# we need to defer to the plugin which has access to EditorInterface
+	var plugin = Engine.get_meta("GodotMCPPlugin") if Engine.has_meta("GodotMCPPlugin") else null
+	
+	if plugin and plugin.has_method("get_editor_interface"):
+		var editor_interface = plugin.get_editor_interface()
+		editor_interface.open_scene_from_path(path)
+		_send_success(client_id, {
+			"scene_path": path
+		}, command_id)
+	else:
+		_send_error(client_id, "Cannot access EditorInterface. Please open the scene manually: %s" % path, command_id)
+
+func _get_current_scene(client_id: int, _params: Dictionary, command_id: String) -> void:
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+	
+	var editor_interface = plugin.get_editor_interface()
+	var edited_scene_root = editor_interface.get_edited_scene_root()
+	
+	if not edited_scene_root:
+		print("No scene is currently being edited")
+		# Instead of returning an error, return a valid response with empty/default values
+		_send_success(client_id, {
+			"scene_path": "None",
+			"root_node_type": "None",
+			"root_node_name": "None"
+		}, command_id)
+		return
+	
+	var scene_path = edited_scene_root.scene_file_path
+	if scene_path.is_empty():
+		scene_path = "Untitled"
+	
+	print("Current scene path: ", scene_path)
+	print("Root node type: ", edited_scene_root.get_class())
+	print("Root node name: ", edited_scene_root.name)
+	
+	_send_success(client_id, {
+		"scene_path": scene_path,
+		"root_node_type": edited_scene_root.get_class(),
+		"root_node_name": edited_scene_root.name
+	}, command_id)
+
+func _get_scene_structure(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+	
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Scene path cannot be empty", command_id)
+	
+	if not path.begins_with("res://"):
+		path = "res://" + path
+	
+	if not FileAccess.file_exists(path):
+		return _send_error(client_id, "Scene file not found: " + path, command_id)
+	
+	# Load the scene to analyze its structure
+	var packed_scene = load(path)
+	if not packed_scene:
+		return _send_error(client_id, "Failed to load scene: " + path, command_id)
+	
+	# Create a temporary instance to analyze
+	var scene_instance = packed_scene.instantiate()
+	if not scene_instance:
+		return _send_error(client_id, "Failed to instantiate scene: " + path, command_id)
+	
+	# Get the scene structure
+	var structure = _get_node_structure(scene_instance)
+	
+	# Clean up the temporary instance
+	scene_instance.queue_free()
+	
+	# Return the structure
+	_send_success(client_id, {
+		"path": path,
+		"structure": structure
+	}, command_id)
+
+func _get_node_structure(node: Node) -> Dictionary:
+	var structure = {
+		"name": node.name,
+		"type": node.get_class(),
+		"path": node.get_path()
+	}
+	
+	# Get script information
+	var script = node.get_script()
+	if script:
+		structure["script"] = script.resource_path
+	
+	# Get important properties
+	var properties = {}
+	var property_list = node.get_property_list()
+	
+	for prop in property_list:
+		var name = prop["name"]
+		# Filter to include only the most useful properties
+		if not name.begins_with("_") and name not in ["script", "children", "position", "rotation", "scale"]:
+			continue
+		
+		# Skip properties that are default values
+		if name == "position" and node.position == Vector2():
+			continue
+		if name == "rotation" and node.rotation == 0:
+			continue
+		if name == "scale" and node.scale == Vector2(1, 1):
+			continue
+		
+		properties[name] = node.get(name)
+	
+	structure["properties"] = properties
+	
+	# Get children
+	var children = []
+	for child in node.get_children():
+		children.append(_get_node_structure(child))
+	
+	structure["children"] = children
+	
+	return structure
+
+func _create_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+	var root_node_type = params.get("root_node_type", "Node")
+	
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Scene path cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not path.begins_with("res://"):
+		path = "res://" + path
+	
+	# Ensure path ends with .tscn
+	if not path.ends_with(".tscn"):
+		path += ".tscn"
+	
+	# Create directory structure if it doesn't exist
+	var dir_path = path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(dir_path):
+		var dir = DirAccess.open("res://")
+		if dir:
+			dir.make_dir_recursive(dir_path.trim_prefix("res://"))
+	
+	# Check if file already exists
+	if FileAccess.file_exists(path):
+		return _send_error(client_id, "Scene file already exists: %s" % path, command_id)
+	
+	# Create the root node of the specified type
+	var root_node = null
+	
+	match root_node_type:
+		"Node":
+			root_node = Node.new()
+		"Node2D":
+			root_node = Node2D.new()
+		"Node3D", "Spatial":
+			root_node = Node3D.new()
+		"Control":
+			root_node = Control.new()
+		"CanvasLayer":
+			root_node = CanvasLayer.new()
+		"Panel":
+			root_node = Panel.new()
+		_:
+			# Attempt to create a custom class if built-in type not recognized
+			if ClassDB.class_exists(root_node_type):
+				root_node = ClassDB.instantiate(root_node_type)
+			else:
+				return _send_error(client_id, "Invalid root node type: %s" % root_node_type, command_id)
+	
+	# Give the root node a name based on the file name
+	var file_name = path.get_file().get_basename()
+	root_node.name = file_name
+	
+	# Create a packed scene
+	var packed_scene = PackedScene.new()
+	var result = packed_scene.pack(root_node)
+	if result != OK:
+		root_node.free()
+		return _send_error(client_id, "Failed to pack scene: %d" % result, command_id)
+	
+	# Save the packed scene to disk
+	result = ResourceSaver.save(packed_scene, path)
+	if result != OK:
+		root_node.free()
+		return _send_error(client_id, "Failed to save scene: %d" % result, command_id)
+	
+	# Clean up
+	root_node.free()
+	
+	# Try to open the scene in the editor
+	var plugin = Engine.get_meta("GodotMCPPlugin") if Engine.has_meta("GodotMCPPlugin") else null
+	if plugin and plugin.has_method("get_editor_interface"):
+		var editor_interface = plugin.get_editor_interface()
+		editor_interface.open_scene_from_path(path)
+	
+	_send_success(client_id, {
+		"scene_path": path,
+		"root_node_type": root_node_type
+	}, command_id)
+
+func _delete_scene(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Scene path cannot be empty", command_id)
+
+	# Make sure we have an absolute path
+	if not path.begins_with("res://"):
+		path = "res://" + path
+
+	# Ensure path ends with .tscn
+	if not path.ends_with(".tscn"):
+		path += ".tscn"
+
+	# Check if file exists
+	if not FileAccess.file_exists(path):
+		return _send_error(client_id, "Scene file not found: %s" % path, command_id)
+
+	# Check if this is the currently open scene
+	var plugin = Engine.get_meta("GodotMCPPlugin") if Engine.has_meta("GodotMCPPlugin") else null
+	if plugin and plugin.has_method("get_editor_interface"):
+		var editor_interface = plugin.get_editor_interface()
+		var edited_scene_root = editor_interface.get_edited_scene_root()
+
+		if edited_scene_root and edited_scene_root.scene_file_path == path:
+			return _send_error(client_id, "Cannot delete currently open scene: %s. Close it first." % path, command_id)
+
+	# Delete the file
+	var dir = DirAccess.open("res://")
+	if not dir:
+		return _send_error(client_id, "Failed to access project directory", command_id)
+
+	var result = dir.remove(path)
+	if result != OK:
+		return _send_error(client_id, "Failed to delete scene file: %d" % result, command_id)
+
+	# Rescan the filesystem to update the editor
+	if plugin and plugin.has_method("get_editor_interface"):
+		var editor_interface = plugin.get_editor_interface()
+		var filesystem = editor_interface.get_resource_filesystem()
+		if filesystem:
+			filesystem.scan()
+
+	_send_success(client_id, {
+		"scene_path": path
+	}, command_id)

package/addons/godot_mcp/commands/scene_commands.gd.uid

@@ -0,0 +1 @@
+uid://n3ktd1vtbv1p

package/addons/godot_mcp/commands/script_commands.gd

@@ -0,0 +1,349 @@
+@tool
+class_name MCPScriptCommands
+extends MCPBaseCommandProcessor
+
+func process_command(client_id: int, command_type: String, params: Dictionary, command_id: String) -> bool:
+	match command_type:
+		"create_script":
+			_create_script(client_id, params, command_id)
+			return true
+		"edit_script":
+			_edit_script(client_id, params, command_id)
+			return true
+		"get_script":
+			_get_script(client_id, params, command_id)
+			return true
+		"get_script_metadata":
+			_get_script_metadata(client_id, params, command_id)
+			return true
+		"get_current_script":
+			_get_current_script(client_id, params, command_id)
+			return true
+	return false  # Command not handled
+
+# Add this function to help find script files
+func _find_script_file(script_name: String) -> String:
+	# First, normalize the path
+	var script_path = script_name
+	
+	# Add extension if missing
+	if not script_path.ends_with(".gd") and not script_path.ends_with(".cs"):
+		script_path += ".gd"  # Default to GDScript
+	
+	# If path already contains res://, use it directly
+	if script_path.begins_with("res://"):
+		if FileAccess.file_exists(script_path):
+			return script_path
+	else:
+		# Add res:// prefix if missing
+		script_path = "res://" + script_path
+		if FileAccess.file_exists(script_path):
+			return script_path
+	
+	# If not found directly, try common script locations
+	var file_name = script_path.get_file()
+	var common_dirs = [
+		"res://scripts/",
+		"res://",
+		"res://scenes/",
+		"res://addons/"
+	]
+	
+	for dir in common_dirs:
+		var test_path = dir + file_name
+		if FileAccess.file_exists(test_path):
+			return test_path
+	
+	return ""  # Not found
+
+func _create_script(client_id: int, params: Dictionary, command_id: String) -> void:
+	var script_path = params.get("script_path", "")
+	var content = params.get("content", "")
+	var node_path = params.get("node_path", "")
+	
+	# Validation
+	if script_path.is_empty():
+		return _send_error(client_id, "Script path cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not script_path.begins_with("res://"):
+		script_path = "res://" + script_path
+	
+	if not script_path.ends_with(".gd"):
+		script_path += ".gd"
+	
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+	
+	var editor_interface = plugin.get_editor_interface()
+	var script_editor = editor_interface.get_script_editor()
+	
+	# Create the directory if it doesn't exist
+	var dir = script_path.get_base_dir()
+	if not DirAccess.dir_exists_absolute(dir):
+		var err = DirAccess.make_dir_recursive_absolute(dir)
+		if err != OK:
+			return _send_error(client_id, "Failed to create directory: %s (Error code: %d)" % [dir, err], command_id)
+	
+	# Create the script file
+	var file = FileAccess.open(script_path, FileAccess.WRITE)
+	if file == null:
+		return _send_error(client_id, "Failed to create script file: %s" % script_path, command_id)
+	
+	file.store_string(content)
+	file = null  # Close the file
+	
+	# Refresh the filesystem
+	editor_interface.get_resource_filesystem().scan()
+	
+	# Attach the script to a node if specified
+	if not node_path.is_empty():
+		var node = _get_editor_node(node_path)
+		if not node:
+			# Try enhanced node resolution
+			node = _get_editor_node_enhanced(node_path)
+			if not node:
+				return _send_error(client_id, "Node not found: %s" % node_path, command_id)
+		
+		# Wait for script to be recognized in the filesystem
+		await get_tree().create_timer(0.5).timeout
+		
+		var script = load(script_path)
+		if not script:
+			return _send_error(client_id, "Failed to load script: %s" % script_path, command_id)
+		
+		# Use undo/redo for script assignment
+		var undo_redo = _get_undo_redo()
+		if not undo_redo:
+			# Fallback method if we can't get undo/redo
+			node.set_script(script)
+			_mark_scene_modified()
+		else:
+			# Use undo/redo for proper editor integration
+			undo_redo.create_action("Assign Script")
+			undo_redo.add_do_method(node, "set_script", script)
+			undo_redo.add_undo_method(node, "set_script", node.get_script())
+			undo_redo.commit_action()
+		
+		# Mark the scene as modified
+		_mark_scene_modified()
+	
+	# Open the script in the editor
+	var script_resource = load(script_path)
+	if script_resource:
+		editor_interface.edit_script(script_resource)
+	
+	_send_success(client_id, {
+		"script_path": script_path,
+		"node_path": node_path
+	}, command_id)
+
+func _edit_script(client_id: int, params: Dictionary, command_id: String) -> void:
+	var script_path = params.get("script_path", "")
+	var content = params.get("content", "")
+	
+	# Validation
+	if script_path.is_empty():
+		return _send_error(client_id, "Script path cannot be empty", command_id)
+	
+	if content.is_empty():
+		return _send_error(client_id, "Content cannot be empty", command_id)
+	
+	# Make sure we have an absolute path
+	if not script_path.begins_with("res://"):
+		script_path = "res://" + script_path
+	
+	# Try to find the script if not found directly
+	if not FileAccess.file_exists(script_path):
+		var found_path = _find_script_file(script_path)
+		if not found_path.is_empty():
+			script_path = found_path
+		else:
+			return _send_error(client_id, "Script file not found: %s" % script_path, command_id)
+	
+	# Edit the script file
+	var file = FileAccess.open(script_path, FileAccess.WRITE)
+	if file == null:
+		return _send_error(client_id, "Failed to open script file: %s" % script_path, command_id)
+	
+	file.store_string(content)
+	file = null  # Close the file
+	
+	_send_success(client_id, {
+		"script_path": script_path
+	}, command_id)
+
+func _get_script(client_id: int, params: Dictionary, command_id: String) -> void:
+	var script_path = params.get("script_path", "")
+	var node_path = params.get("node_path", "")
+	
+	# Validation - either script_path or node_path must be provided
+	if script_path.is_empty() and node_path.is_empty():
+		return _send_error(client_id, "Either script_path or node_path must be provided", command_id)
+	
+	# If node_path is provided, get the script from the node
+	if not node_path.is_empty():
+		var node = _get_editor_node(node_path)
+		if not node:
+			# Try enhanced node resolution
+			node = _get_editor_node_enhanced(node_path)
+			if not node:
+				return _send_error(client_id, "Node not found: %s" % node_path, command_id)
+		
+		var script = node.get_script()
+		if not script:
+			return _send_error(client_id, "Node does not have a script: %s" % node_path, command_id)
+		
+		# Handle various script types safely
+		if typeof(script) == TYPE_OBJECT and "resource_path" in script:
+			script_path = script.resource_path
+		elif typeof(script) == TYPE_STRING:
+			script_path = script
+		else:
+			# Try to handle other script types gracefully
+			print("Script type is not directly supported: ", typeof(script))
+			if script.has_method("get_path"):
+				script_path = script.get_path()
+			elif script.has_method("get_source_code"):
+				# Return the script content directly
+				_send_success(client_id, {
+					"script_path": node_path + " (embedded script)",
+					"content": script.get_source_code()
+				}, command_id)
+				return
+			else:
+				return _send_error(client_id, "Cannot extract script path from node: %s" % node_path, command_id)
+	
+	# Try to find the script if it's not found directly
+	if not FileAccess.file_exists(script_path):
+		var found_path = _find_script_file(script_path)
+		if not found_path.is_empty():
+			script_path = found_path
+		else:
+			return _send_error(client_id, "Script file not found: %s" % script_path, command_id)
+	
+	# Read the script file
+	var file = FileAccess.open(script_path, FileAccess.READ)
+	if file == null:
+		return _send_error(client_id, "Failed to open script file: %s" % script_path, command_id)
+	
+	var content = file.get_as_text()
+	file = null  # Close the file
+	
+	_send_success(client_id, {
+		"script_path": script_path,
+		"content": content
+	}, command_id)
+
+func _get_script_metadata(client_id: int, params: Dictionary, command_id: String) -> void:
+	var path = params.get("path", "")
+	
+	# Validation
+	if path.is_empty():
+		return _send_error(client_id, "Script path cannot be empty", command_id)
+	
+	if not path.begins_with("res://"):
+		path = "res://" + path
+	
+	# Try to find the script if it's not found directly
+	if not FileAccess.file_exists(path):
+		var found_path = _find_script_file(path)
+		if not found_path.is_empty():
+			path = found_path
+		else:
+			return _send_error(client_id, "Script file not found: " + path, command_id)
+	
+	# Load the script
+	var script = load(path)
+	if not script:
+		return _send_error(client_id, "Failed to load script: " + path, command_id)
+	
+	# Extract script metadata
+	var metadata = {
+		"path": path,
+		"language": "gdscript" if path.ends_with(".gd") else "csharp" if path.ends_with(".cs") else "unknown"
+	}
+	
+	# Attempt to get script class info
+	var class_name_str = ""
+	var extends_class = ""
+	
+	# Read the file to extract class_name and extends info
+	var file = FileAccess.open(path, FileAccess.READ)
+	if file:
+		var content = file.get_as_text()
+		
+		# Extract class_name
+		var class_regex = RegEx.new()
+		class_regex.compile("class_name\\s+([a-zA-Z_][a-zA-Z0-9_]*)")
+		var result = class_regex.search(content)
+		if result:
+			class_name_str = result.get_string(1)
+		
+		# Extract extends
+		var extends_regex = RegEx.new()
+		extends_regex.compile("extends\\s+([a-zA-Z_][a-zA-Z0-9_]*)")
+		result = extends_regex.search(content)
+		if result:
+			extends_class = result.get_string(1)
+		
+		# Add to metadata
+		metadata["class_name"] = class_name_str
+		metadata["extends"] = extends_class
+		
+		# Try to extract methods and signals
+		var methods = []
+		var signals = []
+		
+		var method_regex = RegEx.new()
+		method_regex.compile("func\\s+([a-zA-Z_][a-zA-Z0-9_]*)\\s*\\(")
+		var method_matches = method_regex.search_all(content)
+		
+		for match_result in method_matches:
+			methods.append(match_result.get_string(1))
+		
+		var signal_regex = RegEx.new()
+		signal_regex.compile("signal\\s+([a-zA-Z_][a-zA-Z0-9_]*)")
+		var signal_matches = signal_regex.search_all(content)
+		
+		for match_result in signal_matches:
+			signals.append(match_result.get_string(1))
+		
+		metadata["methods"] = methods
+		metadata["signals"] = signals
+	
+	_send_success(client_id, metadata, command_id)
+
+func _get_current_script(client_id: int, params: Dictionary, command_id: String) -> void:
+	# Get editor plugin and interfaces
+	var plugin = Engine.get_meta("GodotMCPPlugin")
+	if not plugin:
+		return _send_error(client_id, "GodotMCPPlugin not found in Engine metadata", command_id)
+	
+	var editor_interface = plugin.get_editor_interface()
+	var script_editor = editor_interface.get_script_editor()
+	var current_script = script_editor.get_current_script()
+	
+	if not current_script:
+		return _send_success(client_id, {
+			"script_found": false,
+			"message": "No script is currently being edited"
+		}, command_id)
+	
+	var script_path = current_script.resource_path
+	
+	# Read the script content
+	var file = FileAccess.open(script_path, FileAccess.READ)
+	if not file:
+		return _send_error(client_id, "Failed to open script file: %s" % script_path, command_id)
+	
+	var content = file.get_as_text()
+	file = null  # Close the file
+	
+	_send_success(client_id, {
+		"script_found": true,
+		"script_path": script_path,
+		"content": content
+	}, command_id)

package/addons/godot_mcp/commands/script_commands.gd.uid

@@ -0,0 +1 @@
+uid://bbfou75clfpg5