gdharness 0.12.7 → 0.12.10

package/build/cli.js

@@ -7401,7 +7401,7 @@ class UpdateCheck {
     }
   }
   refresh(now = Date.now()) {
-    if (!this.enabled || this.checking || now < this.retryAt || now - this.checkedAt < CACHE_MS) {
+    if (!this.enabled || this.checking || now < this.retryAt || !this.stale(now)) {
       return;
     }
     this.checking = true;
@@ -7421,15 +7421,21 @@ class UpdateCheck {
       this.checking = false;
     });
   }
+  stale(now) {
+    return now - this.checkedAt >= CACHE_MS;
+  }
   scheduleRetry(now) {
     this.retryAt = now + this.backoffMs;
     this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
   }
-  notice() {
+  notice(now = Date.now()) {
     const latest = this.latest;
     if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
       return null;
     }
+    if (this.checking && this.stale(now)) {
+      return null;
+    }
     return {
       current: this.current,
       latest,
@@ -7524,9 +7530,7 @@ function staleClassNames(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 }));
+  return [...declaredClasses(projectPath)].filter(([name]) => !held.has(name)).map(([className, path]) => ({ className, path }));
 }
 var init_class_cache = () => {};
 
@@ -15759,7 +15763,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 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.",
+      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. The scan also writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class it cannot resolve is one the scan drops out of that file: unseenByEditor names it before a fresh engine, a CI run or a clone inherits it. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -15842,7 +15846,7 @@ var init_tool_definitions = __esm(() => {
         limit: {
           type: "number",
           ops: ["find", "text"],
-          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with truncated saying whether there were more."
+          description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
         },
         includeHidden: {
           type: "boolean",
@@ -39848,7 +39852,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 
 | Ask | Tool |
 | --- | --- |
-| What a screen says | \`runtime_inspect text\`, which reads what is drawn and leaves out what is hidden |
+| What a screen says | \`runtime_inspect text\`, which reads what is drawn and leaves out what is hidden. Read \`omitted\`: a long list above a dialog pushes it past the limit, and what comes back then is the top of the screen rather than the screen |
 | Find a control by the word on it | \`runtime_inspect find\` with \`says\`, rather than listing a screen and reading each one |
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
@@ -39893,6 +39897,10 @@ them. \`editor_rescan\` asks it to scan and names any class it still cannot reso
 declaration and the cache can both be right while the editor stays blind to it. Change the
 declaring script, or restart the editor.
 
+The scan writes \`.godot/global_script_class_cache.cfg\` from the list the editor is holding, so
+a class it cannot resolve is dropped out of that file too, and the next fresh engine, CI run or
+clone starts from the narrower one. That is the same class \`unseenByEditor\` names.
+
 A diagnostic about a member rather than a type, \`Static function "x()" not found in base "Y"\`
 about something the engine compiles, is a different thing and is no longer stale here: each ask
 gives the document back when its answer arrives, so the next one is read off disk. If one turns

package/build/godot/addons/gdharness_runtime/runtime_queries.gd

@@ -258,7 +258,8 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 ##
 ## [param limit] is the first few lines rather than all of them, which is how the top of a screen
 ## is read without the hall under it: the bar along the top of a guild is eleven lines and the
-## panel it sits on is two hundred.
+## panel it sits on is two hundred. `omitted` says how many lines that left behind, so a screen
+## whose interesting half is below the cut says so in a number rather than in a flag.
 func read_text(params: Dictionary) -> Dictionary:
 	var root_path: String = str(params.get("root", "/root"))
 	var include_hidden: bool = bool(params.get("include_hidden", false))
@@ -269,19 +270,20 @@ func read_text(params: Dictionary) -> Dictionary:
 		return reached
 	var root: Node = reached["node"]
 
-	# One line further than asked for, so that whether anything was left behind is read off the
-	# walk rather than guessed at from the count: a panel of exactly as many lines as the caller
-	# asked for is one they have read all of, and saying otherwise sends them back for nothing.
-	var read: PackedStringArray = PackedStringArray()
-	_read_into(root, include_hidden, limit + 1, read)
-	var more: bool = read.size() > limit
-	var lines: PackedStringArray = read.slice(0, limit) if more else read
+	# The rest of the subtree is walked and counted rather than stopped at. A flag on its own gets
+	# read as a footnote: a screen answered with its first few hundred lines and the dialog the
+	# player is being asked to answer below them reads exactly like a dialog that is not there,
+	# and a bare `truncated: true` was looked straight past twice before the limit was suspected.
+	# A number is what sends somebody back.
+	var lines: PackedStringArray = PackedStringArray()
+	var left_out: int = _read_into(root, include_hidden, limit, lines)
 	return {
 		"type": "text",
 		"root": root_path,
 		"lines": lines,
 		"count": lines.size(),
-		"truncated": more,
+		"truncated": left_out > 0,
+		"omitted": left_out,
 	}
 
 
@@ -293,16 +295,21 @@ func read_text(params: Dictionary) -> Dictionary:
 ## screen full of forms answered with every label on it and none of the values in it. The hidden
 ## check covers a [Window] for the same walk: a dropdown's popup is a child that is not drawn
 ## until it is opened, and reading a closed menu would put every item on the screen.
-func _read_into(node: Node, include_hidden: bool, most: int, into: PackedStringArray) -> void:
-	if into.size() >= most:
-		return
+## Fills [param into] up to [param most] lines and answers with how many further lines the rest of
+## the subtree says, which is what the caller is told rather than left to infer.
+func _read_into(node: Node, include_hidden: bool, most: int, into: PackedStringArray) -> int:
 	if not include_hidden and not _drawn(node):
-		return
+		return 0
+	var left_out: int = 0
 	var said: String = said_by(node)
 	if not said.is_empty():
-		into.append(said)
+		if into.size() < most:
+			into.append(said)
+		else:
+			left_out += 1
 	for child: Node in node.get_children(true):
-		_read_into(child, include_hidden, most, into)
+		left_out += _read_into(child, include_hidden, most, into)
+	return left_out
 
 
 ## Whether [param node] is on the screen at all, for the three kinds of thing that can be hidden.

package/build/godot/operations/file_walk.gd

@@ -4,11 +4,23 @@ extends RefCounted
 # walk descends into every visible directory and matches whole names, while the extension walk
 # skips anything beginning with a dot, including .import sidecars that would otherwise answer
 # for the resource they belong to.
+#
+# Both stop at a `.gdignore`, because the engine does: nothing under one is imported, so what is
+# in there is not a resource, not a dependency and not a global class. Walking in anyway hands
+# every caller files the engine will never answer for.
+
+
+# A directory the engine steps over, marker file and all.
+func is_stepped_over(path: String) -> bool:
+	return FileAccess.file_exists(path + ".gdignore")
 
 
 # Files under `path` whose name ends with `extension`, which is passed with its dot.
 func find_files(path: String, extension: String) -> Array[String]:
 	var files: Array[String] = []
+	if is_stepped_over(path):
+		return files
+
 	var dir: DirAccess = DirAccess.open(path)
 
 	if dir:
@@ -29,6 +41,9 @@ func find_files(path: String, extension: String) -> Array[String]:
 # Files under `path` whose extension is in `extensions`, which are passed without their dot.
 func find_files_with_extensions(path: String, extensions: Array) -> Array[String]:
 	var files: Array[String] = []
+	if is_stepped_over(path):
+		return files
+
 	var dir: DirAccess = DirAccess.open(path)
 
 	if dir:

package/build/index.js

@@ -9972,7 +9972,7 @@ class UpdateCheck {
     }
   }
   refresh(now = Date.now()) {
-    if (!this.enabled || this.checking || now < this.retryAt || now - this.checkedAt < CACHE_MS) {
+    if (!this.enabled || this.checking || now < this.retryAt || !this.stale(now)) {
       return;
     }
     this.checking = true;
@@ -9992,15 +9992,21 @@ class UpdateCheck {
       this.checking = false;
     });
   }
+  stale(now) {
+    return now - this.checkedAt >= CACHE_MS;
+  }
   scheduleRetry(now) {
     this.retryAt = now + this.backoffMs;
     this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
   }
-  notice() {
+  notice(now = Date.now()) {
     const latest = this.latest;
     if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
       return null;
     }
+    if (this.checking && this.stale(now)) {
+      return null;
+    }
     return {
       current: this.current,
       latest,
@@ -24812,9 +24818,7 @@ function staleClassNames(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 }));
+  return [...declaredClasses(projectPath)].filter(([name]) => !held.has(name)).map(([className, path]) => ({ className, path }));
 }
 
 // src/dap_client.ts
@@ -28634,7 +28638,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 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.",
+    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. The scan also writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class it cannot resolve is one the scan drops out of that file: unseenByEditor names it before a fresh engine, a CI run or a clone inherits it. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -28717,7 +28721,7 @@ var TOOL_SPECS = [
       limit: {
         type: "number",
         ops: ["find", "text"],
-        description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with truncated saying whether there were more."
+        description: "find: the most nodes to answer with, default 100. text: the most lines, default 500, with omitted saying how many lines that left behind. A screen whose dialog sits under a long list is a screen read with omitted greater than zero, so raise this or point root at the dialog rather than reading the answer as what is on screen."
       },
       includeHidden: {
         type: "boolean",

package/package.json

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