gdharness 0.13.14 → 0.13.16

package/build/cli.js

@@ -7573,6 +7573,24 @@ function declaresMember(source, missing) {
   const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
   return declaration.test(source);
 }
+function unknownTypeIn(message) {
+  const found = /(?:Could not find (?:base class|type)|Cannot find class|Identifier) "?([A-Za-z_][A-Za-z0-9_]*)"?(?: not declared| in the current scope|\b)/.exec(message);
+  return found?.[1] ?? null;
+}
+function unloadedTypes(messages, declared, cached) {
+  const seen = new Set;
+  const found = [];
+  for (const message of messages) {
+    const type = unknownTypeIn(message);
+    const declaredIn = type === null ? undefined : declared.get(type);
+    if (type === null || declaredIn === undefined || seen.has(type)) {
+      continue;
+    }
+    seen.add(type);
+    found.push({ type, declaredIn, inTheClassCache: cached?.has(type) === true });
+  }
+  return found;
+}
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
   const found = [];
@@ -15784,7 +15802,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "script_diagnostics",
-      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Any diagnostic saying a member is not present on an inferred type is checked against the file the class cache points at, and one the file contradicts is named under contradictedByTheFile with staleAnalysis saying what to do: the language server hands dependents the type it analysed at startup, so a method added to an existing class_name is reported missing at every caller until the editor restarts.",
+      description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says which remedy applies, because they differ: a stale analysed type needs editor_launch restart, while a class missing from the cache needs project_import refresh_classes.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: SCRIPT_PATH
@@ -38050,34 +38068,27 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
-    const contradicted = this.contradictedByTheFile(diagnostics, args);
+    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
       diagnostics,
-      ...contradicted.length === 0 ? {} : {
-        contradictedByTheFile: contradicted,
-        staleAnalysis: `The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named above. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`
-      }
+      ...disagrees
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
-  contradictedByTheFile(diagnostics, args) {
+  whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
-    if (!messages.some((message) => missingMemberIn(message) !== null)) {
-      return [];
-    }
-    const project = this.project(args);
-    if (!project.ok) {
-      return [];
-    }
-    const classes = cachedClasses(project.value.path);
-    if (classes === null) {
-      return [];
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const project = worthChecking ? this.project(args) : null;
+    if (project === null || !project.ok) {
+      return {};
     }
-    return contradictedDiagnostics(messages, classes, (resourcePath) => {
-      const contained = resolveWithinProject(project.value.path, resourcePath);
+    const projectPath = project.value.path;
+    const cached = cachedClasses(projectPath);
+    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
+      const contained = resolveWithinProject(projectPath, resourcePath);
       if (!contained.ok || !existsSync14(contained.absolutePath)) {
         return null;
       }
@@ -38087,6 +38098,24 @@ class GodotServer {
         return null;
       }
     });
+    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. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`);
+    }
+    const uncached = unloaded.filter((type) => !type.inTheClassCache);
+    if (uncached.length > 0) {
+      notes.push(`${uncached.map((type) => type.type).join(", ")} ${uncached.length === 1 ? "is declared" : "are declared"} in this project and missing from .godot/global_script_class_cache.cfg, so a game launched now would not resolve ${uncached.length === 1 ? "it" : "them"} either. project_import refresh_classes rewrites the cache from the declarations on disk.`);
+    }
+    const stale = unloaded.filter((type) => type.inTheClassCache);
+    if (stale.length > 0) {
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+    }
+    return {
+      ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
+      ...unloaded.length === 0 ? {} : { typesTheEditorHasNotLoaded: unloaded },
+      ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
+    };
   }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
@@ -38964,7 +38993,7 @@ class GodotServer {
       ...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
+      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. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more." : undefined
     });
   }
   async classesTheEditorCannotSee(args) {

package/build/index.js

@@ -24833,6 +24833,24 @@ function declaresMember(source, missing) {
   const declaration = missing.kind === "method" ? new RegExp(String.raw`^\s*(?:static\s+)?func\s+${name}\s*\(`, "m") : new RegExp(String.raw`^\s*(?:static\s+)?(?:@export\s+)?(?:var|const)\s+${name}\b`, "m");
   return declaration.test(source);
 }
+function unknownTypeIn(message) {
+  const found = /(?:Could not find (?:base class|type)|Cannot find class|Identifier) "?([A-Za-z_][A-Za-z0-9_]*)"?(?: not declared| in the current scope|\b)/.exec(message);
+  return found?.[1] ?? null;
+}
+function unloadedTypes(messages, declared, cached) {
+  const seen = new Set;
+  const found = [];
+  for (const message of messages) {
+    const type = unknownTypeIn(message);
+    const declaredIn = type === null ? undefined : declared.get(type);
+    if (type === null || declaredIn === undefined || seen.has(type)) {
+      continue;
+    }
+    seen.add(type);
+    found.push({ type, declaredIn, inTheClassCache: cached?.has(type) === true });
+  }
+  return found;
+}
 function contradictedDiagnostics(messages, classes, sourceOf) {
   const read = new Map;
   const found = [];
@@ -28901,7 +28919,7 @@ var TOOL_SPECS = [
   },
   {
     name: "script_diagnostics",
-    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Any diagnostic saying a member is not present on an inferred type is checked against the file the class cache points at, and one the file contradicts is named under contradictedByTheFile with staleAnalysis saying what to do: the language server hands dependents the type it analysed at startup, so a method added to an existing class_name is reported missing at every caller until the editor restarts.",
+    description: "Errors and warnings for a script from the editor's language server, and whether the script is clean. Needs the editor running. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares comes back under contradictedByTheFile, and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says which remedy applies, because they differ: a stale analysed type needs editor_launch restart, while a class missing from the cache needs project_import refresh_classes.",
     parameters: {
       projectPath: PROJECT_PATH,
       scriptPath: SCRIPT_PATH
@@ -30802,34 +30820,27 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
-    const contradicted = this.contradictedByTheFile(diagnostics, args);
+    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
       diagnostics,
-      ...contradicted.length === 0 ? {} : {
-        contradictedByTheFile: contradicted,
-        staleAnalysis: `The editor is reporting against an older copy of ${contradicted.length === 1 ? "a type" : "some types"} named above. Each member listed is declared in the file the class cache points at, so those diagnostics are wrong however the code is written. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`
-      }
+      ...disagrees
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
-  contradictedByTheFile(diagnostics, args) {
+  whereTheFileDisagrees(diagnostics, args) {
     const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
-    if (!messages.some((message) => missingMemberIn(message) !== null)) {
-      return [];
-    }
-    const project = this.project(args);
-    if (!project.ok) {
-      return [];
-    }
-    const classes = cachedClasses(project.value.path);
-    if (classes === null) {
-      return [];
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const project = worthChecking ? this.project(args) : null;
+    if (project === null || !project.ok) {
+      return {};
     }
-    return contradictedDiagnostics(messages, classes, (resourcePath) => {
-      const contained = resolveWithinProject(project.value.path, resourcePath);
+    const projectPath = project.value.path;
+    const cached = cachedClasses(projectPath);
+    const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
+      const contained = resolveWithinProject(projectPath, resourcePath);
       if (!contained.ok || !existsSync9(contained.absolutePath)) {
         return null;
       }
@@ -30839,6 +30850,24 @@ class GodotServer {
         return null;
       }
     });
+    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. editor_launch restart clears it; editor_rescan and project_import refresh_classes do not, because neither reaches the analysed types the language server built at startup.`);
+    }
+    const uncached = unloaded.filter((type) => !type.inTheClassCache);
+    if (uncached.length > 0) {
+      notes.push(`${uncached.map((type) => type.type).join(", ")} ${uncached.length === 1 ? "is declared" : "are declared"} in this project and missing from .godot/global_script_class_cache.cfg, so a game launched now would not resolve ${uncached.length === 1 ? "it" : "them"} either. project_import refresh_classes rewrites the cache from the declarations on disk.`);
+    }
+    const stale = unloaded.filter((type) => type.inTheClassCache);
+    if (stale.length > 0) {
+      notes.push(`${stale.map((type) => type.type).join(", ")} ${stale.length === 1 ? "is" : "are"} in the class cache and still unresolved here, which is the editor's loaded list being behind rather than anything on disk. A game launched now reads the cache and resolves ${stale.length === 1 ? "it" : "them"}, so the run and the diagnostics disagree. editor_rescan clears it, measured against a real editor with waiting the same length ruled out; editor_launch restart also does, and costs more.`);
+    }
+    return {
+      ...contradicted.length === 0 ? {} : { contradictedByTheFile: contradicted },
+      ...unloaded.length === 0 ? {} : { typesTheEditorHasNotLoaded: unloaded },
+      ...notes.length === 0 ? {} : { staleAnalysis: notes.join(" ") }
+    };
   }
   async handleLSP(toolName, args) {
     const port = this.editorServes("lspPort", "GDHARNESS_LSP_PORT", DEFAULT_LSP_PORT);
@@ -31716,7 +31745,7 @@ class GodotServer {
       ...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
+      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. editor_rescan does, on its own and with no change to the declaring script; editor_launch restart also does, and costs more." : undefined
     });
   }
   async classesTheEditorCannotSee(args) {

package/package.json

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