gdharness 0.9.7 → 0.10.0

package/build/cli.js

@@ -7474,6 +7474,9 @@ import { join as join6 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
+    if (existsSync6(join6(directory, ".gdignore"))) {
+      return;
+    }
     for (const entry of readdirSync2(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
@@ -7511,6 +7514,12 @@ function staleClassNames(projectPath) {
   const cached = cachedClasses(projectPath);
   return cached === null ? [...declaredClasses(projectPath).keys()] : staleAgainst(cached, projectPath);
 }
+function unseenByEditor(projectPath, editorHolds) {
+  const held = new Set(editorHolds);
+  const declared = declaredClasses(projectPath);
+  const source = cachedClasses(projectPath) ?? declared;
+  return [...source].filter(([name]) => !held.has(name) && declared.has(name)).map(([className, path]) => ({ className, path: declared.get(className) ?? path }));
+}
 var init_class_cache = () => {};
 
 // src/headless.ts
@@ -15371,7 +15380,7 @@ var init_tool_definitions = __esm(() => {
         uid: { summary: "the UID of one file", requires: ["resourcePath"] },
         refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
         refresh_classes: {
-          summary: "rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, for an editor whose list has gone stale",
+          summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
           requires: []
         }
       }
@@ -15716,7 +15725,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file the editor has already recorded and reads as unchanged is one it does not look inside again: a class_name usually becomes visible this way and on one project did not, with the cache on disk still missing it after the scan said it was done. project_import refresh_classes is the one that rebuilds the class list from the declarations on disk, whatever the editor thinks it has seen. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is a change to the declaring script, or editor_launch restart; project_import refresh_classes rewrites the cache and does not touch what the editor is holding. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -36092,6 +36101,10 @@ function realPathOr(path) {
     return path;
   }
 }
+function samePath(one, other) {
+  const settled = (path) => realPathOr(path).replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+  return settled(one) === settled(other);
+}
 function aboveTheRunner(entry) {
   const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
   if (runner < 0) {
@@ -36522,7 +36535,8 @@ class GodotServer {
   async dispatch(tool, op, args) {
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
-      return await this.headless(headless, args);
+      const answered = await this.headless(headless, args);
+      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -37630,13 +37644,59 @@ class GodotServer {
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]);
     }
+    const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const unseen = checked.unseen;
     return this.jsonTextResponse({
-      ok: !busy,
+      ok: !busy && unseen.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : undefined
+      unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
     });
   }
+  async alsoSayWhatTheEditorCannotSee(answered, args) {
+    const first = answered.content[0];
+    if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
+      return answered;
+    }
+    const checked = await this.classesTheEditorCannotSee(args);
+    if (checked.unseen.length === 0 && checked.unchecked === undefined) {
+      return answered;
+    }
+    return this.jsonTextResponse({
+      ...asParams(JSON.parse(first.text)),
+      unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: checked.unseen.length > 0 ? "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. Change the declaring script and editor_rescan, or restart the editor with editor_launch restart." : undefined
+    });
+  }
+  async classesTheEditorCannotSee(args) {
+    const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+    if (projectPath === "") {
+      return { unseen: [], unchecked: "no projectPath, so there was nothing to read the cache from" };
+    }
+    const open = this.godotBridge.getStatus().projectPath;
+    if (open === undefined || !samePath(open, projectPath)) {
+      return {
+        unseen: [],
+        unchecked: `the connected editor is open on ${open ?? "a project it did not name"}, not this one`
+      };
+    }
+    let held;
+    try {
+      held = asParams(await this.godotBridge.invokeTool("global_classes", args));
+    } catch (error) {
+      return {
+        unseen: [],
+        unchecked: `the editor would not say what classes it is holding: ${errorMessage(error)}`
+      };
+    }
+    if (!Array.isArray(held["classes"])) {
+      return { unseen: [], unchecked: "the editor answered without a class list in it" };
+    }
+    return { unseen: unseenByEditor(projectPath, held["classes"].map(String)) };
+  }
   async handleViaBridge(toolName, args) {
     if (!this.godotBridge.isConnected()) {
       return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
@@ -39226,6 +39286,12 @@ formatting. \`script_diagnostics\` and \`script_info\` come from the editor's ow
 \`editor_classes\` need nothing open: they run a short headless engine and are gone before the
 answer is printed.
 
+A wall of "Could not find type" on the project's own classes means the editor is not holding
+them. \`editor_rescan\` asks it to scan and names any class it still cannot resolve under
+\`unseenByEditor\`: its walk skips a file a headless engine has already imported, so the
+declaration and the cache can both be right while the editor stays blind to it. Change the
+declaring script, or restart the editor.
+
 ## Refusals are useful
 
 An unknown op, an argument the tool does not name, or a missing required one is refused with the

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -9,6 +9,7 @@ const SceneTools = preload("tools/scene_tools.gd")
 const ResourceTools = preload("tools/resource_tools.gd")
 const AnimationTools = preload("tools/animation_tools.gd")
 const PlayTools = preload("tools/play_tools.gd")
+const ClassTools = preload("tools/class_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 
@@ -16,6 +17,7 @@ var _scene_tools: SceneTools = null
 var _resource_tools: ResourceTools = null
 var _animation_tools: AnimationTools = null
 var _play_tools: PlayTools = null
+var _class_tools: ClassTools = null
 
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
@@ -28,6 +30,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_resource_tools.set_editor_plugin(plugin)
 	_animation_tools.set_editor_plugin(plugin)
 	_play_tools.set_editor_plugin(plugin)
+	_class_tools.set_editor_plugin(plugin)
 
 
 func _init_tools() -> void:
@@ -51,6 +54,10 @@ func _init_tools() -> void:
 	_play_tools.name = "PlayTools"
 	add_child(_play_tools)
 
+	_class_tools = ClassTools.new()
+	_class_tools.name = "ClassTools"
+	add_child(_class_tools)
+
 	_tool_map = {
 		# Scene tools
 		"create_scene": [_scene_tools, "create_scene"],
@@ -66,6 +73,7 @@ func _init_tools() -> void:
 		"disconnect_signal": [_scene_tools, "disconnect_signal"],
 		"list_connections": [_scene_tools, "list_connections"],
 		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
+		"global_classes": [_class_tools, "global_classes"],
 		# Resource tools
 		"create_resource": [_resource_tools, "create_resource"],
 		"modify_resource": [_resource_tools, "modify_resource"],

package/build/godot/addons/gdharness_editor/tools/class_tools.gd

@@ -0,0 +1,56 @@
+@tool
+extends Node
+
+## The global classes the running editor is holding.
+##
+## The editor fixes this list when it starts and adds to it only from a filesystem scan, and
+## that scan is change-detecting: a file another engine has already imported looks settled, so
+## the walk goes past it without reading the declaration inside. The class is then declared on
+## disk, listed in `.godot/global_script_class_cache.cfg`, and absent from the editor, whose
+## analyser reports every use of it as an unknown identifier. Rebuilding the cache does not
+## help, because nothing rereads it.
+##
+## Every check there was compares one file on disk against another, so all of them call that
+## state clean. The editor is the only thing that can say otherwise, so it is asked.
+##
+## Read off the editor's own filesystem entries rather than from
+## `ProjectSettings.get_global_class_list()`. The entries are what the scan itself recorded, so
+## nothing but a scan can change them; the settings list is loaded from the cache file when it is
+## first asked for, which makes it a poor witness against a cache that was just rewritten, and
+## rewriting the cache is the call most in need of an honest answer here.
+##
+## A file the scan skipped is either missing from the tree or recorded with no class name against
+## it, and both come back as a class the editor does not have, which is the whole of the question.
+
+var _editor_plugin: EditorPlugin = null
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+
+
+func global_classes(_args: Dictionary) -> Dictionary:
+	if not _editor_plugin:
+		return {"ok": false, "error": "Editor plugin unavailable"}
+
+	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
+	var names: PackedStringArray = []
+	_walk(filesystem.get_filesystem(), names)
+	names.sort()
+	return {
+		"ok": true,
+		"classes": names,
+		"scanning": filesystem.is_scanning(),
+		"importing": filesystem.is_importing(),
+	}
+
+
+func _walk(directory: EditorFileSystemDirectory, into: PackedStringArray) -> void:
+	if directory == null:
+		return
+	for index: int in range(directory.get_file_count()):
+		var declared: String = directory.get_file_script_class_name(index)
+		if not declared.is_empty():
+			into.append(declared)
+	for index: int in range(directory.get_subdir_count()):
+		_walk(directory.get_subdir(index), into)

package/build/godot/addons/gdharness_editor/tools/class_tools.gd.uid

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

package/build/godot/operations/project_config.gd

@@ -45,6 +45,17 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 		old_value = ProjectSettings.get_setting(setting_path)
 
 	var final_value: Variant = _values.deserialize_value(value)
+	var wanted: int = _wanted_type(setting_path, old_value if had_value else null)
+	if wanted > TYPE_NIL and final_value != null and typeof(final_value) != wanted:
+		if not _converts_faithfully(final_value, wanted):
+			return _log.failure(
+				(
+					"%s is declared as %s, and %s (%s) cannot be written as that without losing something."
+					% [setting_path, type_string(wanted), str(final_value), type_string(typeof(final_value))]
+				)
+			)
+		final_value = type_convert(final_value, wanted)
+
 	ProjectSettings.set_setting(setting_path, final_value)
 	var err: Error = ProjectSettings.save()
 	if err != OK:
@@ -59,6 +70,33 @@ func set_project_setting(params: Dictionary) -> Dictionary:
 	}
 
 
+# The type a setting wants, or TYPE_NIL where the engine names none and there is nothing to go on.
+#
+# JSON carries one number type, so every number arrives as a float and an int setting was written
+# to project.godot as "50.0". Every reader casts it back, so the tool, the editor and the running
+# game all answer 50 afterwards and only the committed file says otherwise, where it reads as
+# something having gone wrong.
+#
+# The engine's own property list is what is asked, rather than the value that is there: a setting
+# already written as "50.0" reads back as a float, so the value on hand agrees with the mistake and
+# no project that has made it once could be set right again. The property list still says int.
+# A setting the engine does not declare has only its current value to go on, and a new one has
+# neither, which is the caller's type to choose.
+func _wanted_type(setting_path: String, current: Variant) -> int:
+	for info: Dictionary in ProjectSettings.get_property_list():
+		if str(info.get("name", "")) == setting_path:
+			return int(info.get("type", TYPE_NIL))
+	return typeof(current)
+
+
+# What separates a narrowing from a guess: 50.0 through int and out again is 50.0, so it was an int
+# all along, while 50.5 comes back as 50.0 and "loud" comes back as "0". Those are a caller meaning
+# something the setting cannot hold, and are refused rather than written as whatever the cast
+# happened to produce.
+func _converts_faithfully(value: Variant, to: int) -> bool:
+	return type_convert(type_convert(value, to), typeof(value)) == value
+
+
 # Add an autoload singleton
 func add_autoload(params: Dictionary) -> Dictionary:
 	var name: String = str(params.get("name", ""))

package/build/index.js

@@ -24758,6 +24758,9 @@ import { join as join3 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
+    if (existsSync2(join3(directory, ".gdignore"))) {
+      return;
+    }
     for (const entry of readdirSync(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
@@ -24795,6 +24798,12 @@ function staleClassNames(projectPath) {
   const cached = cachedClasses(projectPath);
   return cached === null ? [...declaredClasses(projectPath).keys()] : staleAgainst(cached, projectPath);
 }
+function unseenByEditor(projectPath, editorHolds) {
+  const held = new Set(editorHolds);
+  const declared = declaredClasses(projectPath);
+  const source = cachedClasses(projectPath) ?? declared;
+  return [...source].filter(([name]) => !held.has(name) && declared.has(name)).map(([className, path]) => ({ className, path: declared.get(className) ?? path }));
+}
 
 // src/dap_client.ts
 import { createConnection } from "node:net";
@@ -27981,7 +27990,7 @@ var TOOL_SPECS = [
       uid: { summary: "the UID of one file", requires: ["resourcePath"] },
       refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
       refresh_classes: {
-        summary: "rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, for an editor whose list has gone stale",
+        summary: 'rewrite .godot/global_script_class_cache.cfg from the class_name declarations on disk, and name under unseenByEditor any class the editor open on this project still cannot resolve: rewriting the file does not reach the list a running editor loaded, so "added: []" means the file was already right rather than that nothing is wrong',
         requires: []
       }
     }
@@ -28326,7 +28335,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_rescan",
-    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file the editor has already recorded and reads as unchanged is one it does not look inside again: a class_name usually becomes visible this way and on one project did not, with the cache on disk still missing it after the scan said it was done. project_import refresh_classes is the one that rebuilds the class list from the declarations on disk, whatever the editor thinks it has seen. Needs the editor connected.",
+    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is a change to the declaring script, or editor_launch restart; project_import refresh_classes rewrites the cache and does not touch what the editor is holding. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -28871,6 +28880,10 @@ function realPathOr(path) {
     return path;
   }
 }
+function samePath(one, other) {
+  const settled = (path) => realPathOr(path).replaceAll("\\", "/").replace(/\/+$/, "").toLowerCase();
+  return settled(one) === settled(other);
+}
 var RUNNER_DIRECTORY = "addons/gdUnit4/";
 function aboveTheRunner(entry) {
   const runner = entry.detail.findIndex((line) => line.includes(RUNNER_DIRECTORY));
@@ -29302,7 +29315,8 @@ class GodotServer {
   async dispatch(tool, op, args) {
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
-      return await this.headless(headless, args);
+      const answered = await this.headless(headless, args);
+      return headless === "refresh_class_cache" && this.godotBridge.isConnected() ? await this.alsoSayWhatTheEditorCannotSee(answered, args) : answered;
     }
     const { op: _op, ...arguments_ } = args;
     const bridge = async (command, extra = {}) => {
@@ -30410,13 +30424,59 @@ class GodotServer {
       const status = asParams(await this.godotBridge.invokeTool("rescan_filesystem", { ...args, statusOnly: true }));
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]);
     }
+    const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const unseen = checked.unseen;
     return this.jsonTextResponse({
-      ok: !busy,
+      ok: !busy && unseen.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : undefined
+      unseenByEditor: unseen.length > 0 ? unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
+    });
+  }
+  async alsoSayWhatTheEditorCannotSee(answered, args) {
+    const first = answered.content[0];
+    if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {
+      return answered;
+    }
+    const checked = await this.classesTheEditorCannotSee(args);
+    if (checked.unseen.length === 0 && checked.unchecked === undefined) {
+      return answered;
+    }
+    return this.jsonTextResponse({
+      ...asParams(JSON.parse(first.text)),
+      unseenByEditor: checked.unseen.length > 0 ? checked.unseen : undefined,
+      classesUnchecked: checked.unchecked,
+      note: checked.unseen.length > 0 ? "The cache on disk is right now, and the editor holding this project is still not resolving these: rewriting the file does not reach the list it already loaded. Change the declaring script and editor_rescan, or restart the editor with editor_launch restart." : undefined
     });
   }
+  async classesTheEditorCannotSee(args) {
+    const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
+    if (projectPath === "") {
+      return { unseen: [], unchecked: "no projectPath, so there was nothing to read the cache from" };
+    }
+    const open = this.godotBridge.getStatus().projectPath;
+    if (open === undefined || !samePath(open, projectPath)) {
+      return {
+        unseen: [],
+        unchecked: `the connected editor is open on ${open ?? "a project it did not name"}, not this one`
+      };
+    }
+    let held;
+    try {
+      held = asParams(await this.godotBridge.invokeTool("global_classes", args));
+    } catch (error) {
+      return {
+        unseen: [],
+        unchecked: `the editor would not say what classes it is holding: ${errorMessage(error)}`
+      };
+    }
+    if (!Array.isArray(held["classes"])) {
+      return { unseen: [], unchecked: "the editor answered without a class list in it" };
+    }
+    return { unseen: unseenByEditor(projectPath, held["classes"].map(String)) };
+  }
   async handleViaBridge(toolName, args) {
     if (!this.godotBridge.isConnected()) {
       return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.9.7",
+  "version": "0.10.0",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",