gdharness 0.13.20 → 0.13.22

package/build/cli.js

@@ -7591,6 +7591,15 @@ function unloadedTypes(messages, declared, cached) {
   }
   return found;
 }
+function classesNamedIn(source, known) {
+  const named = new Set;
+  for (const [word] of source.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
+    if (known.has(word)) {
+      named.add(word);
+    }
+  }
+  return [...named].sort();
+}
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
   const found = [];
@@ -15955,7 +15964,11 @@ var init_tool_definitions = __esm(() => {
       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 measured downstream is a change to the declaring script, saved, and then a rescan: the change on its own left every affected file reporting the same errors, and the rescan after it cleared them. Whether a rescan alone would have done it there is not known, because the rescans in that report may have answered before the scan ran, which is the timing this tool no longer has. editor_launch restart also does it, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
-        timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
+        timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." },
+        reloadScript: {
+          type: "string",
+          description: "A script to recompile in the editor after the scan, for the fault a scan cannot reach: a script the editor has loaded keeps the copy it built, and that copy is refreshed when one of its dependencies changes rather than when it changes itself, so a method added to a loaded class reads as missing at every caller. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching."
+        }
       },
       requires: ["projectPath"]
     },
@@ -38105,7 +38118,19 @@ class GodotServer {
     const unloaded = messages.some((message) => unknownTypeIn(message) !== null) ? unloadedTypes(messages, declaredClasses(projectPath), cached) : [];
     const notes = [];
     if (contradicted.length > 0) {
-      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, changing anything the named type itself depends on and rescanning again cleared it on the one occasion that has been tried. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
+      const dependsOn = new Set;
+      for (const one of contradicted) {
+        const source = cached === null ? null : this.sourceOfClass(projectPath, one.declaredIn);
+        if (source === null || cached === null) {
+          continue;
+        }
+        for (const name of classesNamedIn(source, cached)) {
+          if (name !== one.type) {
+            dependsOn.add(name);
+          }
+        }
+      }
+      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, the lever is that a held type is refreshed when something it depends on changes rather than when it changes itself${dependsOn.size === 0 ? ", though the named types depend on no other global class, which leaves only the restart" : `, so change ${[...dependsOn].sort().join(", ")} and rescan again`}. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {
@@ -38121,6 +38146,17 @@ class GodotServer {
       ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
     };
   }
+  sourceOfClass(projectPath, resourcePath) {
+    const contained = resolveWithinProject(projectPath, resourcePath);
+    if (!contained.ok || !existsSync14(contained.absolutePath)) {
+      return null;
+    }
+    try {
+      return readFileSync15(contained.absolutePath, "utf8");
+    } catch {
+      return null;
+    }
+  }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -38958,6 +38994,17 @@ class GodotServer {
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
     const restored = lost.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
+    const reloading = readNonEmptyString(args, "reloadScript");
+    let reloaded = {};
+    if (reloading !== undefined) {
+      try {
+        const answer = asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
+        const methods = readArray(answer, "methods");
+        reloaded = methods ? { methods: methods.map(String) } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+      } catch (error) {
+        reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
+      }
+    }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
     const stillGone = lost.filter((name) => !restored.includes(name));
@@ -38965,6 +39012,8 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      reloadedMethods: reloaded.methods,
+      reloadProblem: reloaded.problem,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       cacheLost: lost.length > 0 ? lost : undefined,
       cacheRestored: restored.length > 0 ? restored : undefined,

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

@@ -80,6 +80,7 @@ func _init_tools() -> void:
 		"list_connections": [_scene_tools, "list_connections"],
 		"rescan_filesystem": [_scene_tools, "rescan_filesystem"],
 		"global_classes": [_class_tools, "global_classes"],
+		"reload_script": [_class_tools, "reload_script"],
 		# Settings, for a caller that asked the editor rather than the file on disk
 		"get_project_setting": [_settings_tools, "get_project_setting"],
 		# Resource tools

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

@@ -29,6 +29,59 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_editor_plugin = plugin
 
 
+## Recompiles a script the editor is already holding, in place.
+##
+## The fault this exists for: a script the editor has loaded keeps the copy it compiled, and that
+## copy is refreshed when one of its own dependencies changes rather than when it changes itself.
+## So a method added to a loaded class is reported missing at every caller until something
+## recompiles it, and a filesystem scan does not, because the scan updates what the editor knows
+## about files rather than what it has already built from them.
+##
+## `reload` is the only call that reaches the built copy. It recompiles from source into the same
+## object, so everything holding a reference sees the new version rather than a second one, which
+## is the whole point: the holders are why the stale copy survived a scan.
+##
+## `keep_state` is true so instances that already exist keep their properties. A caller asking for
+## this is mid-edit with a scene open, and dropping the state of every node using the script would
+## be a larger surprise than the wrong diagnostic it is here to clear.
+##
+## The list of methods afterwards is the evidence rather than an `ok` beside it. A reload that
+## returned OK and compiled nothing is exactly the failure worth catching, and the members it now
+## has are the only thing that can tell those apart.
+func reload_script(args: Dictionary) -> Dictionary:
+	var path: String = str(args.get("scriptPath", ""))
+	if path.is_empty():
+		return {"ok": false, "error": "scriptPath is required"}
+	if not ResourceLoader.exists(path):
+		return {"ok": false, "error": "No script at " + path}
+
+	var loaded: Resource = load(path)
+	var script: GDScript = loaded as GDScript
+	if script == null:
+		return {"ok": false, "error": path + " is not a GDScript"}
+
+	# The source is read off disk and put back before reloading, which is the whole of the fix and
+	# is not obvious. `reload` recompiles from the object's own `source_code`, not from the file, so
+	# a script the editor loaded before the change recompiles the text it was holding and comes back
+	# with exactly the members it already had. Measured: reloading without this answers OK and the
+	# method added since is still absent from the method list.
+	var reader: FileAccess = FileAccess.open(path, FileAccess.READ)
+	if reader == null:
+		return {"ok": false, "error": "Could not read " + path + ": " + str(FileAccess.get_open_error())}
+	script.source_code = reader.get_as_text()
+	reader.close()
+
+	var failed: Error = script.reload(true)
+	if failed != OK:
+		return {"ok": false, "error": "Reloading " + path + " answered error " + str(failed)}
+
+	var methods: Array[String] = []
+	for entry: Dictionary in script.get_script_method_list():
+		methods.append(str(entry.get("name", "")))
+	methods.sort()
+	return {"ok": true, "script": path, "methods": methods}
+
+
 func global_classes(_args: Dictionary) -> Dictionary:
 	if not _editor_plugin:
 		return {"ok": false, "error": "Editor plugin unavailable"}

package/build/index.js

@@ -24851,6 +24851,15 @@ function unloadedTypes(messages, declared, cached) {
   }
   return found;
 }
+function classesNamedIn(source, known) {
+  const named = new Set;
+  for (const [word] of source.matchAll(/\b[A-Z][A-Za-z0-9_]*\b/g)) {
+    if (known.has(word)) {
+      named.add(word);
+    }
+  }
+  return [...named].sort();
+}
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
   const found = [];
@@ -29072,7 +29081,11 @@ var TOOL_SPECS = [
     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 measured downstream is a change to the declaring script, saved, and then a rescan: the change on its own left every affected file reporting the same errors, and the rescan after it cleared them. Whether a rescan alone would have done it there is not known, because the rescans in that report may have answered before the scan ran, which is the timing this tool no longer has. editor_launch restart also does it, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
-      timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
+      timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." },
+      reloadScript: {
+        type: "string",
+        description: "A script to recompile in the editor after the scan, for the fault a scan cannot reach: a script the editor has loaded keeps the copy it built, and that copy is refreshed when one of its dependencies changes rather than when it changes itself, so a method added to a loaded class reads as missing at every caller. This recompiles into the same object, so the holders that kept the stale copy alive see the new one. The methods it has afterwards come back under reloadedMethods, because a reload that compiled nothing and answered OK is the failure worth catching."
+      }
     },
     requires: ["projectPath"]
   },
@@ -30857,7 +30870,19 @@ class GodotServer {
     const unloaded = messages.some((message) => unknownTypeIn(message) !== null) ? unloadedTypes(messages, declaredClasses(projectPath), cached) : [];
     const notes = [];
     if (contradicted.length > 0) {
-      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, changing anything the named type itself depends on and rescanning again cleared it on the one occasion that has been tried. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
+      const dependsOn = new Set;
+      for (const one of contradicted) {
+        const source = cached === null ? null : this.sourceOfClass(projectPath, one.declaredIn);
+        if (source === null || cached === null) {
+          continue;
+        }
+        for (const name of classesNamedIn(source, cached)) {
+          if (name !== one.type) {
+            dependsOn.add(name);
+          }
+        }
+      }
+      notes.push(`The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named under contradictedByTheFile. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. Try editor_rescan first: it costs about half a second and cleared this in one of five measured attempts. If it does not, the lever is that a held type is refreshed when something it depends on changes rather than when it changes itself${dependsOn.size === 0 ? ", though the named types depend on no other global class, which leaves only the restart" : `, so change ${[...dependsOn].sort().join(", ")} and rescan again`}. editor_launch restart is the only remedy that has always worked, and is the one to reach for when the count above is not good enough odds. project_import refresh_classes does not, and answers added: [] while this is happening.`);
     }
     const uncached = unloaded.filter((type) => !type.inTheClassCache);
     if (uncached.length > 0) {
@@ -30873,6 +30898,17 @@ class GodotServer {
       ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
     };
   }
+  sourceOfClass(projectPath, resourcePath) {
+    const contained = resolveWithinProject(projectPath, resourcePath);
+    if (!contained.ok || !existsSync9(contained.absolutePath)) {
+      return null;
+    }
+    try {
+      return readFileSync11(contained.absolutePath, "utf8");
+    } catch {
+      return null;
+    }
+  }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -31710,6 +31746,17 @@ class GodotServer {
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
     const restored = lost.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
+    const reloading = readNonEmptyString(args, "reloadScript");
+    let reloaded = {};
+    if (reloading !== undefined) {
+      try {
+        const answer = asParams(await this.godotBridge.invokeTool("reload_script", { ...args, scriptPath: reloading }));
+        const methods = readArray(answer, "methods");
+        reloaded = methods ? { methods: methods.map(String) } : { problem: `the editor would not say what ${reloading} has after reloading it` };
+      } catch (error) {
+        reloaded = { problem: `${reloading} could not be reloaded: ${errorMessage(error)}` };
+      }
+    }
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
     const stillGone = lost.filter((name) => !restored.includes(name));
@@ -31717,6 +31764,8 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      reloadedMethods: reloaded.methods,
+      reloadProblem: reloaded.problem,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       cacheLost: lost.length > 0 ? lost : undefined,
       cacheRestored: restored.length > 0 ? restored : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "0.13.20",
+  "version": "0.13.22",
   "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",