godot-mcp-tool 0.1.0 → 0.1.1

package/addon/godot_mcp_tool/addon_info.gd

@@ -1,6 +1,6 @@
 extends RefCounted
 
-const ADDON_VERSION := "0.1.0"
+const ADDON_VERSION := "0.1.1"
 const BRIDGE_PROTOCOL_VERSION := 1
 const DISCOVERY_RELATIVE_PATH := ".godot/godot_mcp_tool/bridge.json"
 const CAPTURES_RELATIVE_PATH := ".godot/godot_mcp_tool/captures"

package/addon/godot_mcp_tool/animation/animation_reference.gd

@@ -1,10 +1,10 @@
 extends RefCounted
 
-const CommandError := preload("../commands/command_error.gd")
-const IndefiniteArticle := preload("../util/indefinite_article.gd")
-const JsonRpc := preload("../bridge/json_rpc.gd")
-const NodeFactory := preload("../scene/node_factory.gd")
-const NodeLocator := preload("../scene/node_locator.gd")
+const GodotMcpCommandError := preload("../commands/command_error.gd")
+const GodotMcpIndefiniteArticle := preload("../util/indefinite_article.gd")
+const GodotMcpJsonRpc := preload("../bridge/json_rpc.gd")
+const GodotMcpNodeFactory := preload("../scene/node_factory.gd")
+const GodotMcpNodeLocator := preload("../scene/node_locator.gd")
 
 const FORBIDDEN_NAME_CHARACTERS := ["/", ":", ",", "["]
 const LIBRARY_SEPARATOR := "/"
@@ -14,13 +14,13 @@ var animation_name := ""
 
 
 static func find_player(scene_root: Node, player_path: String) -> Variant:
-	var node := NodeLocator.find(scene_root, player_path)
+	var node := GodotMcpNodeLocator.find(scene_root, player_path)
 	if node == null:
-		return CommandError.new(JsonRpc.NOT_FOUND, "Node \"%s\" not found" % player_path, NodeLocator.not_found_hint(scene_root, player_path))
+		return GodotMcpCommandError.new(GodotMcpJsonRpc.NOT_FOUND, "Node \"%s\" not found" % player_path, GodotMcpNodeLocator.not_found_hint(scene_root, player_path))
 	if not node is AnimationPlayer:
-		return CommandError.new(
-			JsonRpc.INVALID_PARAMS,
-			"%s is %s, not an AnimationPlayer" % [player_path, IndefiniteArticle.before(NodeFactory.display_class(node))],
+		return GodotMcpCommandError.new(
+			GodotMcpJsonRpc.INVALID_PARAMS,
+			"%s is %s, not an AnimationPlayer" % [player_path, GodotMcpIndefiniteArticle.before(GodotMcpNodeFactory.display_class(node))],
 			"Add an AnimationPlayer with node_add; its tracks animate the nodes under its parent.",
 		)
 	return node
@@ -34,8 +34,8 @@ static func parse(full_name: String) -> Variant:
 		name = name.substr(reference.library_name.length() + 1)
 	reference.animation_name = name
 	if name.is_empty() or FORBIDDEN_NAME_CHARACTERS.any(func(character: String) -> bool: return name.contains(character)) or _has_forbidden_character(reference.library_name):
-		return CommandError.new(
-			JsonRpc.INVALID_PARAMS,
+		return GodotMcpCommandError.new(
+			GodotMcpJsonRpc.INVALID_PARAMS,
 			"\"%s\" is not a valid animation name" % full_name,
 			"Animation names cannot be empty or contain / : , [; write \"library/name\" for an animation of another library than the default one.",
 		)

package/addon/godot_mcp_tool/animation/animation_report.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const AnimationVocabulary := preload("animation_vocabulary.gd")
-const VariantCodec := preload("../codec/variant_codec.gd")
+const GodotMcpAnimationVocabulary := preload("animation_vocabulary.gd")
+const GodotMcpVariantCodec := preload("../codec/variant_codec.gd")
 
 const MAXIMUM_KEYS_SHOWN := 20
 const DECIMAL_SCALE := 1000.0
@@ -15,7 +15,7 @@ static func list(player: AnimationPlayer) -> Array:
 	return animations
 
 
-static func detail(animation: Animation, name: String, codec: VariantCodec) -> Dictionary:
+static func detail(animation: Animation, name: String, codec: GodotMcpVariantCodec) -> Dictionary:
 	var tracks: Array = []
 	for index in animation.get_track_count():
 		tracks.append(_track(animation, index, codec))
@@ -23,18 +23,18 @@ static func detail(animation: Animation, name: String, codec: VariantCodec) -> D
 
 
 static func loop_name(animation: Animation) -> String:
-	return AnimationVocabulary.name_of(AnimationVocabulary.LOOP_MODES, animation.loop_mode)
+	return GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.LOOP_MODES, animation.loop_mode)
 
 
-static func _track(animation: Animation, index: int, codec: VariantCodec) -> Dictionary:
+static func _track(animation: Animation, index: int, codec: GodotMcpVariantCodec) -> Dictionary:
 	var type := animation.track_get_type(index)
 	var track := {
 		"path": str(animation.track_get_path(index)),
-		"type": AnimationVocabulary.name_of(AnimationVocabulary.TRACK_TYPES, type),
-		"interpolation": AnimationVocabulary.name_of(AnimationVocabulary.INTERPOLATIONS, animation.track_get_interpolation_type(index)),
+		"type": GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.TRACK_TYPES, type),
+		"interpolation": GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.INTERPOLATIONS, animation.track_get_interpolation_type(index)),
 	}
 	if type == Animation.TYPE_VALUE:
-		track["update"] = AnimationVocabulary.name_of(AnimationVocabulary.UPDATE_MODES, animation.value_track_get_update_mode(index))
+		track["update"] = GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.UPDATE_MODES, animation.value_track_get_update_mode(index))
 	var key_count := animation.track_get_key_count(index)
 	var keys: Array = []
 	for key_index in mini(key_count, MAXIMUM_KEYS_SHOWN):

package/addon/godot_mcp_tool/animation/animation_track_planner.gd

@@ -1,20 +1,20 @@
 extends RefCounted
 
-const AnimationVocabulary := preload("animation_vocabulary.gd")
-const NodeLocator := preload("../scene/node_locator.gd")
-const SimilarNames := preload("../util/similar_names.gd")
-const VariantCodec := preload("../codec/variant_codec.gd")
+const GodotMcpAnimationVocabulary := preload("animation_vocabulary.gd")
+const GodotMcpNodeLocator := preload("../scene/node_locator.gd")
+const GodotMcpSimilarNames := preload("../util/similar_names.gd")
+const GodotMcpVariantCodec := preload("../codec/variant_codec.gd")
 
 const STEPPED_TYPES := [TYPE_BOOL, TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH, TYPE_OBJECT]
 const DEFAULT_LENGTH := 1.0
 const DECIMAL_SCALE := 1000.0
 const RESET_LENGTH := 0.001
 
-var _codec: VariantCodec
+var _codec: GodotMcpVariantCodec
 var _root: Node
 
 
-func _init(codec: VariantCodec, root: Node) -> void:
+func _init(codec: GodotMcpVariantCodec, root: Node) -> void:
 	_codec = codec
 	_root = root
 
@@ -88,8 +88,8 @@ func describe(track: Dictionary) -> Dictionary:
 	return {
 		"path": track["path"],
 		"keys": keys.size(),
-		"interpolation": AnimationVocabulary.name_of(AnimationVocabulary.INTERPOLATIONS, track["interpolation"]),
-		"update": AnimationVocabulary.name_of(AnimationVocabulary.UPDATE_MODES, track["update"]),
+		"interpolation": GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.INTERPOLATIONS, track["interpolation"]),
+		"update": GodotMcpAnimationVocabulary.name_of(GodotMcpAnimationVocabulary.UPDATE_MODES, track["update"]),
 		"from": _codec.encode(keys.front()["value"]),
 		"to": _codec.encode(keys.back()["value"]),
 	}
@@ -105,15 +105,15 @@ func _plan_track(description: Variant) -> Variant:
 		return "track paths are Node:property relative to the parent of the AnimationPlayer, such as \"Door:position\" or \".:visible\""
 	var target := _root.get_node_or_null(NodePath(node_part))
 	if target == null:
-		return "there is no node %s under %s. %s" % [node_part, _root.name, NodeLocator.not_found_hint(_root, node_part)]
+		return "there is no node %s under %s. %s" % [node_part, _root.name, GodotMcpNodeLocator.not_found_hint(_root, node_part)]
 	var property: Variant = _property_of(target, property_path)
 	if property is String:
 		return property
-	var interpolation: Variant = _named_value(description, "interpolation", AnimationVocabulary.INTERPOLATIONS, "linear")
+	var interpolation: Variant = _named_value(description, "interpolation", GodotMcpAnimationVocabulary.INTERPOLATIONS, "linear")
 	if interpolation is String:
 		return interpolation
 	var default_update := "discrete" if _is_stepped(property) else "continuous"
-	var update: Variant = _named_value(description, "update", AnimationVocabulary.UPDATE_MODES, default_update)
+	var update: Variant = _named_value(description, "update", GodotMcpAnimationVocabulary.UPDATE_MODES, default_update)
 	if update is String:
 		return update
 	var keys: Variant = _decode_keys(description.get("keys", []), property, target, property_path)
@@ -128,7 +128,7 @@ func _property_of(target: Node, property_path: String) -> Variant:
 	for property in target.get_property_list():
 		properties[str(property["name"])] = property
 	if not properties.has(property_name):
-		var similar := SimilarNames.hint(property_name, properties.keys())
+		var similar := GodotMcpSimilarNames.hint(property_name, properties.keys())
 		return "%s has no property \"%s\"%s" % [target.name, property_name, "" if similar.is_empty() else ". " + similar]
 	if property_path == property_name:
 		return properties[property_name]
@@ -157,9 +157,9 @@ func _decode_keys(key_descriptions: Variant, property: Dictionary, target: Node,
 
 static func _named_value(description: Dictionary, key: String, names: Dictionary, default_name: String) -> Variant:
 	var name: Variant = description.get(key, default_name)
-	var value: Variant = AnimationVocabulary.value_of(names, name)
+	var value: Variant = GodotMcpAnimationVocabulary.value_of(names, name)
 	if value == null:
-		return "unknown %s \"%s\"; use one of: %s" % [key, name, AnimationVocabulary.listed(names)]
+		return "unknown %s \"%s\"; use one of: %s" % [key, name, GodotMcpAnimationVocabulary.listed(names)]
 	return value
 
 

package/addon/godot_mcp_tool/animation/state_machine_plan.gd

@@ -1,6 +1,6 @@
 extends RefCounted
 
-const SimilarNames := preload("../util/similar_names.gd")
+const GodotMcpSimilarNames := preload("../util/similar_names.gd")
 
 const START := "Start"
 const END := "End"
@@ -74,7 +74,7 @@ func _plan_state(description: Variant) -> void:
 		reason = "this state is given twice"
 	elif not _player.has_animation(animation):
 		var known := Array(_player.get_animation_list()).map(func(animation_name: StringName) -> String: return str(animation_name))
-		var similar := SimilarNames.hint(animation, known)
+		var similar := GodotMcpSimilarNames.hint(animation, known)
 		reason = "%s has no animation \"%s\"%s" % [_player.name, animation, "" if similar.is_empty() else ". " + similar]
 	if not reason.is_empty():
 		rejected.append({"item": name, "reason": reason})
@@ -105,7 +105,7 @@ func _transition(description: Dictionary, from: String, to: String) -> Variant:
 		return "a state cannot have a transition to itself"
 	for state_name in [from, to]:
 		if not _is_known_state(state_name):
-			return "there is no state %s. %s" % [state_name, SimilarNames.hint(state_name, _state_names())]
+			return "there is no state %s. %s" % [state_name, GodotMcpSimilarNames.hint(state_name, _state_names())]
 	if transitions.any(func(transition: Dictionary) -> bool: return transition["from"] == from and transition["to"] == to):
 		return "this transition is given twice"
 	var planned := {"from": from, "to": to}

package/addon/godot_mcp_tool/animation/state_machine_report.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const NodeLocator := preload("../scene/node_locator.gd")
-const StateMachinePlan := preload("state_machine_plan.gd")
+const GodotMcpNodeLocator := preload("../scene/node_locator.gd")
+const GodotMcpStateMachinePlan := preload("state_machine_plan.gd")
 
 const DECIMAL_SCALE := 1000.0
 const DEFAULT_PRIORITY := 1
@@ -11,8 +11,8 @@ static func describe(tree: AnimationTree, scene_root: Node, scene_path: String)
 	var player := tree.get_node_or_null(tree.anim_player) if not tree.anim_player.is_empty() else null
 	var report := {
 		"scene": scene_path,
-		"tree": NodeLocator.path_of(scene_root, tree),
-		"player": NodeLocator.path_of(scene_root, player) if player != null else "",
+		"tree": GodotMcpNodeLocator.path_of(scene_root, tree),
+		"player": GodotMcpNodeLocator.path_of(scene_root, player) if player != null else "",
 		"active": tree.active,
 		"expression_base": str(tree.advance_expression_base_node),
 		"root": tree.tree_root.get_class() if tree.tree_root != null else "",
@@ -26,7 +26,7 @@ static func describe(tree: AnimationTree, scene_root: Node, scene_path: String)
 
 
 static func _states(machine: AnimationNodeStateMachine) -> Array:
-	var names: Array = Array(machine.get_node_list()).map(func(name: StringName) -> String: return str(name)).filter(func(name: String) -> bool: return name != StateMachinePlan.START and name != StateMachinePlan.END)
+	var names: Array = Array(machine.get_node_list()).map(func(name: StringName) -> String: return str(name)).filter(func(name: String) -> bool: return name != GodotMcpStateMachinePlan.START and name != GodotMcpStateMachinePlan.END)
 	names.sort()
 	return names.map(func(name: String) -> Dictionary: return _state(name, machine.get_node(name)))
 
@@ -44,8 +44,8 @@ static func _transitions(machine: AnimationNodeStateMachine) -> Array:
 		var entry := {
 			"from": str(machine.get_transition_from(index)),
 			"to": str(machine.get_transition_to(index)),
-			"advance": _name_of(StateMachinePlan.ADVANCE_MODES, transition.advance_mode),
-			"switch": _name_of(StateMachinePlan.SWITCH_MODES, transition.switch_mode),
+			"advance": _name_of(GodotMcpStateMachinePlan.ADVANCE_MODES, transition.advance_mode),
+			"switch": _name_of(GodotMcpStateMachinePlan.SWITCH_MODES, transition.switch_mode),
 			"xfade": roundf(transition.xfade_time * DECIMAL_SCALE) / DECIMAL_SCALE,
 		}
 		if not str(transition.advance_condition).is_empty():

package/addon/godot_mcp_tool/assets/import_options.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const EnumOptions := preload("../codec/enum_options.gd")
-const VariantCodec := preload("../codec/variant_codec.gd")
+const GodotMcpEnumOptions := preload("../codec/enum_options.gd")
+const GodotMcpVariantCodec := preload("../codec/variant_codec.gd")
 
 const OPTION_ENUMS := {
 	"meshes/light_baking": "Disabled,Static,Static Lightmaps,Dynamic",
@@ -53,13 +53,13 @@ static func node_option_names() -> Array:
 	return NODE_OPTIONS.keys()
 
 
-static func describe_option(name: String, value: Variant, codec: VariantCodec) -> Variant:
+static func describe_option(name: String, value: Variant, codec: GodotMcpVariantCodec) -> Variant:
 	if OPTION_ENUMS.has(name) and value is int:
 		return _enum_name(OPTION_ENUMS[name], value, codec)
 	return codec.encode(value)
 
 
-static func describe_node_option(name: String, value: Variant, codec: VariantCodec) -> Variant:
+static func describe_node_option(name: String, value: Variant, codec: GodotMcpVariantCodec) -> Variant:
 	var option: Dictionary = NODE_OPTIONS.get(name, {})
 	if option.get("hint") == PROPERTY_HINT_ENUM and value is int:
 		return _enum_name(option["hint_string"], value, codec)
@@ -70,6 +70,6 @@ static func _property(name: String, option: Dictionary) -> Dictionary:
 	return {"name": name, "type": option["type"], "hint": option.get("hint", PROPERTY_HINT_NONE), "hint_string": option.get("hint_string", ""), "usage": PROPERTY_USAGE_DEFAULT}
 
 
-static func _enum_name(hint_string: String, value: int, codec: VariantCodec) -> Variant:
-	var option_name := EnumOptions.name_of(EnumOptions.parse(hint_string), value)
+static func _enum_name(hint_string: String, value: int, codec: GodotMcpVariantCodec) -> Variant:
+	var option_name := GodotMcpEnumOptions.name_of(GodotMcpEnumOptions.parse(hint_string), value)
 	return option_name if not option_name.is_empty() else codec.encode(value)

package/addon/godot_mcp_tool/assets/import_settings.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const CommandError := preload("../commands/command_error.gd")
-const JsonRpc := preload("../bridge/json_rpc.gd")
+const GodotMcpCommandError := preload("../commands/command_error.gd")
+const GodotMcpJsonRpc := preload("../bridge/json_rpc.gd")
 
 const IMPORT_SUFFIX := ".import"
 const REMAP_SECTION := "remap"
@@ -17,12 +17,12 @@ var _file := ConfigFile.new()
 static func open(path: String) -> Variant:
 	var inside_project := path.begins_with("res://") and not ".." in path.trim_prefix("res://").split("/")
 	if not inside_project or path.contains("::"):
-		return CommandError.new(JsonRpc.INVALID_PARAMS, "\"%s\" is not a file in the project" % path, "Asset paths look like res://models/character.glb.")
+		return GodotMcpCommandError.new(GodotMcpJsonRpc.INVALID_PARAMS, "\"%s\" is not a file in the project" % path, "Asset paths look like res://models/character.glb.")
 	if not FileAccess.file_exists(path):
-		return CommandError.new(JsonRpc.NOT_FOUND, "%s not found" % path, "Check the path, or let the editor import new files with editor_rescan.")
+		return GodotMcpCommandError.new(GodotMcpJsonRpc.NOT_FOUND, "%s not found" % path, "Check the path, or let the editor import new files with editor_rescan.")
 	if not FileAccess.file_exists(path + IMPORT_SUFFIX):
-		return CommandError.new(
-			JsonRpc.INVALID_PARAMS,
+		return GodotMcpCommandError.new(
+			GodotMcpJsonRpc.INVALID_PARAMS,
 			"%s is not imported, so it has no import settings" % path,
 			"Godot imports files such as .glb, .gltf, .fbx, .blend, .png and .wav; scenes and .tres resources are changed with the scene_, node_ and resource_ tools.",
 		)
@@ -30,7 +30,7 @@ static func open(path: String) -> Variant:
 	settings.asset_path = path
 	var load_error := settings._file.load(path + IMPORT_SUFFIX)
 	if load_error != OK:
-		return CommandError.new(JsonRpc.OPERATION_FAILED, "%s%s could not be read: %s" % [path, IMPORT_SUFFIX, error_string(load_error)])
+		return GodotMcpCommandError.new(GodotMcpJsonRpc.OPERATION_FAILED, "%s%s could not be read: %s" % [path, IMPORT_SUFFIX, error_string(load_error)])
 	return settings
 
 

package/addon/godot_mcp_tool/assets/imported_scene_report.gd

@@ -1,21 +1,21 @@
 extends RefCounted
 
-const Bounds := preload("../capture/bounds.gd")
-const NodeFactory := preload("../scene/node_factory.gd")
-const SpatialTransforms := preload("../scene/spatial_transforms.gd")
-const VariantCodec := preload("../codec/variant_codec.gd")
+const GodotMcpBounds := preload("../capture/bounds.gd")
+const GodotMcpNodeFactory := preload("../scene/node_factory.gd")
+const GodotMcpSpatialTransforms := preload("../scene/spatial_transforms.gd")
+const GodotMcpVariantCodec := preload("../codec/variant_codec.gd")
 
 const DECIMAL_SCALE := 1000.0
 
 
-static func describe(scene_path: String, codec: VariantCodec) -> Variant:
+static func describe(scene_path: String, codec: GodotMcpVariantCodec) -> Variant:
 	var scene := ResourceLoader.load(scene_path, "", ResourceLoader.CACHE_MODE_IGNORE) as PackedScene
 	if scene == null:
 		return null
 	var root := scene.instantiate()
 	if root == null:
 		return null
-	var bounds := Bounds.measure(root)["aabb"] as AABB
+	var bounds := GodotMcpBounds.measure(root)["aabb"] as AABB
 	var report := {
 		"size": codec.encode(_rounded_vector(bounds.size)),
 		"position": codec.encode(_rounded_vector(bounds.position)),
@@ -27,11 +27,11 @@ static func describe(scene_path: String, codec: VariantCodec) -> Variant:
 	return report
 
 
-static func _describe_subtree(node: Node, root: Node, report: Dictionary, codec: VariantCodec) -> void:
+static func _describe_subtree(node: Node, root: Node, report: Dictionary, codec: GodotMcpVariantCodec) -> void:
 	var path := str(root.get_path_to(node))
-	var described := {"path": path, "type": NodeFactory.display_class(node)}
+	var described := {"path": path, "type": GodotMcpNodeFactory.display_class(node)}
 	if node is MeshInstance3D:
-		described["size"] = codec.encode(_rounded_vector((Bounds.measure(node)["aabb"] as AABB).size))
+		described["size"] = codec.encode(_rounded_vector((GodotMcpBounds.measure(node)["aabb"] as AABB).size))
 	(report["nodes"] as Array).append(described)
 	if node is CollisionShape3D and (node as CollisionShape3D).shape != null:
 		var shape := (node as CollisionShape3D).shape
@@ -39,13 +39,13 @@ static func _describe_subtree(node: Node, root: Node, report: Dictionary, codec:
 			"path": path,
 			"shape": shape.get_class(),
 			"dimensions": _dimensions_of(shape, codec),
-			"position": codec.encode(_rounded_vector(SpatialTransforms.global_of(node).origin)),
+			"position": codec.encode(_rounded_vector(GodotMcpSpatialTransforms.global_of(node).origin)),
 		})
 	for child in node.get_children():
 		_describe_subtree(child, root, report, codec)
 
 
-static func _dimensions_of(shape: Shape3D, codec: VariantCodec) -> Array:
+static func _dimensions_of(shape: Shape3D, codec: GodotMcpVariantCodec) -> Array:
 	if shape is BoxShape3D:
 		return [_dimension("size", codec.encode(_rounded_vector((shape as BoxShape3D).size)))]
 	if shape is SphereShape3D:

package/addon/godot_mcp_tool/bridge/authenticator.gd

@@ -1,7 +1,7 @@
 extends RefCounted
 
-const CommandError := preload("../commands/command_error.gd")
-const JsonRpc := preload("json_rpc.gd")
+const GodotMcpCommandError := preload("../commands/command_error.gd")
+const GodotMcpJsonRpc := preload("json_rpc.gd")
 
 var _expected_token: String
 var _protocol: int
@@ -12,17 +12,17 @@ func _init(expected_token: String, protocol: int) -> void:
 	_protocol = protocol
 
 
-func verify(params: Dictionary) -> CommandError:
+func verify(params: Dictionary) -> GodotMcpCommandError:
 	var token: Variant = params.get("token")
 	if not token is String or not _tokens_match(token, _expected_token):
-		return CommandError.new(
-			JsonRpc.UNAUTHORIZED,
+		return GodotMcpCommandError.new(
+			GodotMcpJsonRpc.UNAUTHORIZED,
 			"Invalid token",
 			"Restart the MCP server so it reads the current discovery file of this editor.")
 	var protocol: Variant = params.get("protocol")
 	if not (protocol is int or protocol is float) or int(protocol) != _protocol:
-		return CommandError.new(
-			JsonRpc.PROTOCOL_MISMATCH,
+		return GodotMcpCommandError.new(
+			GodotMcpJsonRpc.PROTOCOL_MISMATCH,
 			"Unsupported bridge protocol %s; this addon speaks protocol %d" % [str(protocol), _protocol],
 			"Install matching versions of the MCP server and the Godot addon.")
 	return null

package/addon/godot_mcp_tool/bridge/bridge_connection.gd

@@ -1,18 +1,18 @@
 extends RefCounted
 
-const BridgeSession := preload("bridge_session.gd")
-const JsonRpc := preload("json_rpc.gd")
-const NdjsonBuffer := preload("ndjson_buffer.gd")
+const GodotMcpBridgeSession := preload("bridge_session.gd")
+const GodotMcpJsonRpc := preload("json_rpc.gd")
+const GodotMcpNdjsonBuffer := preload("ndjson_buffer.gd")
 
 var is_closed := false
-var session: BridgeSession
+var session: GodotMcpBridgeSession
 
 var _peer: StreamPeerTCP
-var _incoming := NdjsonBuffer.new()
+var _incoming := GodotMcpNdjsonBuffer.new()
 var _outgoing := PackedByteArray()
 
 
-func _init(peer: StreamPeerTCP, bridge_session: BridgeSession) -> void:
+func _init(peer: StreamPeerTCP, bridge_session: GodotMcpBridgeSession) -> void:
 	_peer = peer
 	session = bridge_session
 	_peer.set_no_delay(true)
@@ -37,7 +37,7 @@ func poll() -> int:
 
 func send(message: Dictionary) -> void:
 	if not is_closed:
-		_outgoing.append_array(JsonRpc.encode(message))
+		_outgoing.append_array(GodotMcpJsonRpc.encode(message))
 
 
 func close() -> void:

package/addon/godot_mcp_tool/bridge/bridge_probe.gd

@@ -1,6 +1,6 @@
 extends RefCounted
 
-const AddonInfo := preload("../addon_info.gd")
+const GodotMcpAddonInfo := preload("../addon_info.gd")
 
 const TIMEOUT_MSEC := 1000
 const POLL_INTERVAL_MSEC := 5
@@ -8,7 +8,7 @@ const POLL_INTERVAL_MSEC := 5
 
 static func is_listening(port: int) -> bool:
 	var connection := StreamPeerTCP.new()
-	if connection.connect_to_host(AddonInfo.LOOPBACK_ADDRESS, port) != OK:
+	if connection.connect_to_host(GodotMcpAddonInfo.LOOPBACK_ADDRESS, port) != OK:
 		return false
 	_poll_until_connected_or_refused(connection)
 	var listening := _stays_connected(connection)

package/addon/godot_mcp_tool/bridge/bridge_server.gd

@@ -1,11 +1,11 @@
 extends RefCounted
 
-const BridgeConnection := preload("bridge_connection.gd")
+const GodotMcpBridgeConnection := preload("bridge_connection.gd")
 
 var last_activity_msec := -1
 
 var _tcp_server := TCPServer.new()
-var _connections: Array[BridgeConnection] = []
+var _connections: Array[GodotMcpBridgeConnection] = []
 var _create_session: Callable
 
 
@@ -26,18 +26,18 @@ func connection_count() -> int:
 
 
 func authenticated_count() -> int:
-	return _connections.filter(func(connection: BridgeConnection) -> bool: return connection.session.is_authenticated).size()
+	return _connections.filter(func(connection: GodotMcpBridgeConnection) -> bool: return connection.session.is_authenticated).size()
 
 
 func poll() -> void:
 	while _tcp_server.is_connection_available():
 		var peer := _tcp_server.take_connection()
 		if peer != null:
-			_connections.append(BridgeConnection.new(peer, _create_session.call()))
+			_connections.append(GodotMcpBridgeConnection.new(peer, _create_session.call()))
 	for connection in _connections:
 		if connection.poll() > 0:
 			last_activity_msec = Time.get_ticks_msec()
-	_connections = _connections.filter(func(connection: BridgeConnection) -> bool: return not connection.is_closed)
+	_connections = _connections.filter(func(connection: GodotMcpBridgeConnection) -> bool: return not connection.is_closed)
 
 
 func broadcast(message: Dictionary) -> void:

package/addon/godot_mcp_tool/bridge/bridge_session.gd

@@ -1,9 +1,9 @@
 extends RefCounted
 
-const Authenticator := preload("authenticator.gd")
-const CommandError := preload("../commands/command_error.gd")
-const CommandRouter := preload("../commands/command_router.gd")
-const JsonRpc := preload("json_rpc.gd")
+const GodotMcpAuthenticator := preload("authenticator.gd")
+const GodotMcpCommandError := preload("../commands/command_error.gd")
+const GodotMcpCommandRouter := preload("../commands/command_router.gd")
+const GodotMcpJsonRpc := preload("json_rpc.gd")
 
 var is_authenticated := false
 var should_close := false
@@ -11,8 +11,8 @@ var should_close := false
 const STATUS_NOTIFICATION := "log.status"
 const KEEPALIVE_METHODS := ["ping"]
 
-var _authenticator: Authenticator
-var _router: CommandRouter
+var _authenticator: GodotMcpAuthenticator
+var _router: GodotMcpCommandRouter
 var _build_hello_payload: Callable
 var _read_status: Callable
 var _wait_for_first_scan: Callable
@@ -22,8 +22,8 @@ var _notifications: Array = []
 
 
 func _init(
-	authenticator: Authenticator,
-	router: CommandRouter,
+	authenticator: GodotMcpAuthenticator,
+	router: GodotMcpCommandRouter,
 	build_hello_payload: Callable,
 	read_status: Callable = Callable(),
 	wait_for_first_scan: Callable = Callable(),
@@ -47,20 +47,20 @@ func handle_line(line: String) -> Dictionary:
 	var json := JSON.new()
 	if json.parse(line) != OK or not json.data is Dictionary:
 		should_close = true
-		return JsonRpc.failure(null, JsonRpc.PARSE_ERROR, "Expected one JSON-RPC request object per line")
+		return GodotMcpJsonRpc.failure(null, GodotMcpJsonRpc.PARSE_ERROR, "Expected one JSON-RPC request object per line")
 	var request: Dictionary = json.data
 	var request_id: Variant = _normalize_request_id(request.get("id"))
 	var method: Variant = request.get("method")
 	if not method is String:
-		return JsonRpc.failure(request_id, JsonRpc.INVALID_REQUEST, "The request has no method")
+		return GodotMcpJsonRpc.failure(request_id, GodotMcpJsonRpc.INVALID_REQUEST, "The request has no method")
 	var params: Variant = request.get("params", {})
 	if not params is Dictionary:
-		return JsonRpc.failure(request_id, JsonRpc.INVALID_PARAMS, "The params of %s must be an object" % method)
+		return GodotMcpJsonRpc.failure(request_id, GodotMcpJsonRpc.INVALID_PARAMS, "The params of %s must be an object" % method)
 	if method == "hello":
 		return _answer_hello(request_id, params)
 	if not is_authenticated:
 		should_close = true
-		return JsonRpc.failure(request_id, JsonRpc.UNAUTHORIZED, "Send hello with the token before %s" % method)
+		return GodotMcpJsonRpc.failure(request_id, GodotMcpJsonRpc.UNAUTHORIZED, "Send hello with the token before %s" % method)
 	return await _run_command(request_id, method, params)
 
 
@@ -68,10 +68,10 @@ func _answer_hello(request_id: Variant, params: Dictionary) -> Dictionary:
 	var rejection := _authenticator.verify(params)
 	if rejection != null:
 		should_close = true
-		return JsonRpc.failure(request_id, rejection.code, rejection.message, rejection.hint)
+		return GodotMcpJsonRpc.failure(request_id, rejection.code, rejection.message, rejection.hint)
 	is_authenticated = true
 	_queue_status_if_changed()
-	return JsonRpc.success(request_id, _build_hello_payload.call())
+	return GodotMcpJsonRpc.success(request_id, _build_hello_payload.call())
 
 
 func _run_command(request_id: Variant, method: String, params: Dictionary) -> Dictionary:
@@ -86,22 +86,22 @@ func _run_command(request_id: Variant, method: String, params: Dictionary) -> Di
 func _answer_command(request_id: Variant, method: String, params: Dictionary) -> Dictionary:
 	var command := _router.find(method)
 	if command == null:
-		return JsonRpc.failure(
+		return GodotMcpJsonRpc.failure(
 			request_id,
-			JsonRpc.METHOD_NOT_FOUND,
+			GodotMcpJsonRpc.METHOD_NOT_FOUND,
 			"Unknown method %s" % method,
 			"Available methods: %s" % ", ".join(_router.methods()))
 	if not await _is_editor_ready_for(method):
-		return JsonRpc.failure(
+		return GodotMcpJsonRpc.failure(
 			request_id,
-			JsonRpc.EDITOR_BUSY,
+			GodotMcpJsonRpc.EDITOR_BUSY,
 			"The editor is still scanning and importing the project, as it does after it starts",
 			"Call again in a few seconds: the first import of a large project takes a while.")
 	var outcome: Variant = await command.execute(params)
 	_queue_status_if_changed()
-	if outcome is CommandError:
-		return JsonRpc.failure(request_id, outcome.code, outcome.message, outcome.hint)
-	return JsonRpc.success(request_id, outcome)
+	if outcome is GodotMcpCommandError:
+		return GodotMcpJsonRpc.failure(request_id, outcome.code, outcome.message, outcome.hint)
+	return GodotMcpJsonRpc.success(request_id, outcome)
 
 
 func _is_editor_ready_for(method: String) -> bool:
@@ -117,7 +117,7 @@ func _queue_status_if_changed() -> void:
 	if status == _last_sent_status:
 		return
 	_last_sent_status = status
-	_notifications.append(JsonRpc.make_notification(STATUS_NOTIFICATION, status))
+	_notifications.append(GodotMcpJsonRpc.make_notification(STATUS_NOTIFICATION, status))
 
 
 static func _normalize_request_id(request_id: Variant) -> Variant:

package/addon/godot_mcp_tool/bridge/discovery_file.gd

@@ -1,6 +1,6 @@
 extends RefCounted
 
-const BridgeProbe := preload("bridge_probe.gd")
+const GodotMcpBridgeProbe := preload("bridge_probe.gd")
 
 const OWNER_ONLY_PERMISSIONS := FileAccess.UNIX_READ_OWNER | FileAccess.UNIX_WRITE_OWNER
 const NO_OWNER := -1
@@ -64,4 +64,4 @@ func _is_served_by_another_editor(current: Dictionary, record: Dictionary) -> bo
 	var current_port := int(current["port"])
 	if int(current.get("pid", NO_OWNER)) == int(record.get("pid", NO_OWNER)) or current_port == int(record.get("port", 0)):
 		return false
-	return BridgeProbe.is_listening(current_port)
+	return GodotMcpBridgeProbe.is_listening(current_port)