gdharness 0.13.13 → 0.13.15

package/build/cli.js

@@ -7557,6 +7557,59 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function missingMemberIn(message) {
+  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (found === null) {
+    return null;
+  }
+  return {
+    kind: found[1] === "property" ? "property" : "method",
+    member: found[2] ?? "",
+    type: found[3] ?? ""
+  };
+}
+function declaresMember(source, missing) {
+  const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  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 = [];
+  for (const message of messages) {
+    const missing = missingMemberIn(message);
+    const declaredIn = missing === null ? undefined : classes.get(missing.type);
+    if (missing === null || declaredIn === undefined) {
+      continue;
+    }
+    if (!read.has(declaredIn)) {
+      read.set(declaredIn, sourceOf(declaredIn));
+    }
+    const source = read.get(declaredIn) ?? null;
+    if (source !== null && declaresMember(source, missing)) {
+      found.push({ ...missing, declaredIn });
+    }
+  }
+  return found;
+}
 function cacheWrittenAt(projectPath) {
   const cache = join6(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -15749,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.",
+      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
@@ -38015,14 +38068,55 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
+    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
-      diagnostics
+      diagnostics,
+      ...disagrees
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
+  whereTheFileDisagrees(diagnostics, args) {
+    const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const project = worthChecking ? this.project(args) : null;
+    if (project === null || !project.ok) {
+      return {};
+    }
+    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;
+      }
+      try {
+        return readFileSync15(contained.absolutePath, "utf8");
+      } catch {
+        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_launch restart clears it.`);
+    }
+    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);
     if (this.lspClient !== null && this.lspClient.port !== port) {
@@ -40459,7 +40553,8 @@ function headlessSection() {
     "Needing nothing is not the same as changing nothing, and a gate wants both. Most of these",
     "write to the project because that is what they are for: `script_edit create` writes a file,",
     "`project_settings set` rewrites `project.godot`, `project_import reimport` and `refresh_classes`",
-    "write under `.godot`. The reading ops are the ones to gate on, and which is which is in each",
+    "write under `.godot`, and `project_import refresh_uids` writes a `.uid` beside each script that",
+    "had none. The reading ops are the ones to gate on, and which is which is in each",
     "op's own summary below rather than assumed from this list.",
     "",
     "Everything else needs the editor (`editor_*`, `debug_*`, `scene_*`, `resource_*`) or a running",

package/build/index.js

@@ -24817,6 +24817,59 @@ function cachedClasses(projectPath) {
   }
   return listed;
 }
+function missingMemberIn(message) {
+  const found = /The (method|property) "([^"(]+)(?:\(\))?" is not present on the inferred type "([^"]+)"/.exec(message);
+  if (found === null) {
+    return null;
+  }
+  return {
+    kind: found[1] === "property" ? "property" : "method",
+    member: found[2] ?? "",
+    type: found[3] ?? ""
+  };
+}
+function declaresMember(source, missing) {
+  const name = missing.member.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  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 = [];
+  for (const message of messages) {
+    const missing = missingMemberIn(message);
+    const declaredIn = missing === null ? undefined : classes.get(missing.type);
+    if (missing === null || declaredIn === undefined) {
+      continue;
+    }
+    if (!read.has(declaredIn)) {
+      read.set(declaredIn, sourceOf(declaredIn));
+    }
+    const source = read.get(declaredIn) ?? null;
+    if (source !== null && declaresMember(source, missing)) {
+      found.push({ ...missing, declaredIn });
+    }
+  }
+  return found;
+}
 function cacheWrittenAt(projectPath) {
   const cache = join3(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
@@ -28866,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.",
+    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
@@ -30767,14 +30820,55 @@ class GodotServer {
       const severity = asParams(entry)["severity"];
       return severity === 1 || severity === "error" || severity === "ERROR";
     }).length;
+    const disagrees = this.whereTheFileDisagrees(diagnostics, args);
     return this.jsonTextResponse(markIfStale({
       scriptPath: readString(args, "scriptPath"),
       clean: errors === 0,
       errors,
       warnings: diagnostics.length - errors,
-      diagnostics
+      diagnostics,
+      ...disagrees
     }, this.godotBridge.getStatus().addonVersion, SERVER_VERSION));
   }
+  whereTheFileDisagrees(diagnostics, args) {
+    const messages = diagnostics.map((entry) => asParams(entry)["message"]).filter((message) => typeof message === "string");
+    const worthChecking = messages.some((message) => missingMemberIn(message) !== null || unknownTypeIn(message) !== null);
+    const project = worthChecking ? this.project(args) : null;
+    if (project === null || !project.ok) {
+      return {};
+    }
+    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;
+      }
+      try {
+        return readFileSync11(contained.absolutePath, "utf8");
+      } catch {
+        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_launch restart clears it.`);
+    }
+    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);
     if (this.lspClient !== null && this.lspClient.port !== port) {

package/package.json

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