gdharness 0.13.12 → 0.13.13

package/build/cli.js

@@ -7621,6 +7621,36 @@ function reason2(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
+async function runImport(godotPath, projectPath) {
+  const logDir = mkdtempSync2(join7(tmpdir3(), "gdharness-import-"));
+  try {
+    const { stderr } = await run3(godotPath, [
+      "--headless",
+      "--log-file",
+      join7(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
+    return { ok: true, messages: problems2(stderr) };
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason2(failed.stdout, failed.stderr)}`,
+        messages: problems2(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(logDir);
+  }
+}
 async function runOperation2(engine, operation, params, projectPath) {
   const paramsDir = mkdtempSync2(join7(tmpdir3(), "gdharness-params-"));
   const paramsFile = join7(paramsDir, `${operation}.json`);
@@ -15475,7 +15505,10 @@ var init_tool_definitions = __esm(() => {
           requires: []
         },
         uid: { summary: "the UID of one file", requires: ["resourcePath"] },
-        refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
+        refresh_uids: {
+          summary: "import the project so every script and shader has its .uid sidecar, and name under uidsCreated the ones this made and under stillWithoutUid the ones the engine would not import: it writes no scene and no script, so a project whose sidecars are all present is left untouched",
+          requires: []
+        },
         refresh_classes: {
           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: []
@@ -16223,7 +16256,7 @@ var init_tool_definitions = __esm(() => {
 });
 
 // src/headless-operations.ts
-var HEADLESS_OPERATIONS, EDITOR_READS;
+var HEADLESS_OPERATIONS, ENGINE_PASSES, EDITOR_READS;
 var init_headless_operations = __esm(() => {
   HEADLESS_OPERATIONS = dictionary({
     project_settings: dictionary({
@@ -16245,7 +16278,6 @@ var init_headless_operations = __esm(() => {
       set_options: "set_import_options",
       reimport: "reimport_resource",
       uid: "get_uid",
-      refresh_uids: "resave_resources",
       refresh_classes: "refresh_class_cache"
     }),
     project_export: dictionary({ list: "list_export_presets" }),
@@ -16257,6 +16289,9 @@ var init_headless_operations = __esm(() => {
       inheritance: "inspect_inheritance"
     })
   });
+  ENGINE_PASSES = dictionary({
+    project_import: dictionary({ refresh_uids: "import" })
+  });
   EDITOR_READS = dictionary({
     project_settings: dictionary({ get: "get_project_setting" })
   });
@@ -36049,6 +36084,33 @@ function projectStructure(projectPath) {
   visit(projectPath);
   return structure;
 }
+function scriptsWithoutUid(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join13(directory, entry.name), spelled);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+      if (CARRIES_A_UID.has(extension) && !existsSync11(join13(directory, `${entry.name}.uid`))) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
 function searchProject(projectPath, options) {
   const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -36108,10 +36170,11 @@ function searchProject(projectPath, options) {
   visit(projectPath);
   return result;
 }
-var SKIPPED, ASSET_EXTENSIONS;
+var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
 var init_project_scan = __esm(() => {
   SKIPPED = new Set(["node_modules"]);
   ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
 });
 
 // src/runtime-client.ts
@@ -37218,6 +37281,9 @@ class GodotServer {
     return { ok: true, op };
   }
   async dispatch(tool, op, args) {
+    if (ENGINE_PASSES[tool]?.[op] !== undefined) {
+      return await this.handleRefreshUids(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -37588,6 +37654,33 @@ class GodotServer {
     const { op: _op, projectPath: _projectPath, ...params } = contained.value;
     return this.answer(await this.operation(operation, params, project.value.path));
   }
+  async handleRefreshUids(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return this.createErrorResponse("No Godot executable found.");
+    }
+    const projectPath = project.value.path;
+    const before = scriptsWithoutUid(projectPath);
+    const imported = await runImport(engine.value, projectPath);
+    if (!imported.ok) {
+      return this.answer(imported);
+    }
+    const after = scriptsWithoutUid(projectPath);
+    const given = before.filter((script) => !after.includes(script));
+    return this.answer({
+      ok: true,
+      messages: imported.messages,
+      payload: {
+        uidsCreated: given,
+        stillWithoutUid: after,
+        note: after.length > 0 ? `${after.length} still have no .uid, which is the engine declining to import them rather than this op skipping them. No scene was written.` : "No scene was written: this reads the project and imports it, and does not resave anything."
+      }
+    });
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {
@@ -40347,7 +40440,13 @@ function namedType(declared) {
   return "any";
 }
 function headlessSection() {
-  const byTool = Object.entries(HEADLESS_OPERATIONS).map(([tool, ops]) => `\`${tool}\` (${Object.keys(ops).join(", ")})`).sort();
+  const everyOp = new Map;
+  for (const table of [HEADLESS_OPERATIONS, ENGINE_PASSES]) {
+    for (const [tool, ops] of Object.entries(table)) {
+      everyOp.set(tool, [...everyOp.get(tool) ?? [], ...Object.keys(ops)]);
+    }
+  }
+  const byTool = [...everyOp].map(([tool, ops]) => `\`${tool}\` (${ops.join(", ")})`).sort();
   return [
     "## What a gate can call",
     "",

package/build/godot/operations/godot_operations.gd

@@ -108,8 +108,6 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 		# Resource files
 		"get_uid":
 			payload = ResourceFiles.new(_log).get_uid(params)
-		"resave_resources":
-			payload = ResourceFiles.new(_log).resave_resources(params)
 		"refresh_class_cache":
 			payload = ClassCache.new(_log).refresh_class_cache(params)
 

package/build/godot/operations/resource_files.gd

@@ -1,10 +1,8 @@
 extends RefCounted
 
-const FileWalk = preload("file_walk.gd")
 const Log = preload("logger.gd")
 
 var _log: Log
-var _files: FileWalk = FileWalk.new()
 
 
 func _init(p_log: Log) -> void:
@@ -41,92 +39,3 @@ func get_uid(params: Dictionary) -> Dictionary:
 	return {
 		"file": file_path, "absolute_path": absolute_path, "uid": uid_content.strip_edges(), "exists": true
 	}
-
-
-# Resave every scene, script and shader so that UID references are current.
-func resave_resources(_params: Dictionary) -> Dictionary:
-	_log.info("Resaving all resources to update UID references...")
-	var project_path: String = "res://"
-
-	var scenes: Array[String] = _files.find_files(project_path, ".tscn")
-	_log.debug("Found " + str(scenes.size()) + " scenes")
-
-	# Resave each scene
-	var success_count: int = 0
-	var error_count: int = 0
-
-	for scene_path: String in scenes:
-		_log.debug("Processing scene: " + scene_path)
-
-		if not FileAccess.file_exists(scene_path):
-			_log.error("Scene file does not exist at: " + scene_path)
-			error_count += 1
-			continue
-
-		var scene: Resource = load(scene_path)
-		if not scene:
-			error_count += 1
-			_log.error("Failed to load: " + scene_path)
-			continue
-
-		var error: Error = ResourceSaver.save(scene, scene_path)
-		if error != OK:
-			error_count += 1
-			_log.error("Failed to save: " + scene_path + ", error: " + str(error))
-			continue
-
-		success_count += 1
-		if _log.debug_mode:
-			_log.debug("Scene saved successfully: " + scene_path)
-			var file_check_after: bool = FileAccess.file_exists(scene_path)
-			_log.debug("File exists check after save: " + str(file_check_after))
-			if not file_check_after:
-				_log.error("File reported as saved but does not exist at: " + scene_path)
-
-	# A UID sits beside every script and shader as a .uid file. Outside the editor the save
-	# below answers OK and writes no sidecar, so what comes back is what was resaved and how
-	# many are still without one, rather than a count of UIDs this made.
-	var scripts: Array[String] = (
-		_files.find_files(project_path, ".gd")
-		+ _files.find_files(project_path, ".shader")
-		+ _files.find_files(project_path, ".gdshader")
-	)
-	_log.debug("Found " + str(scripts.size()) + " scripts/shaders")
-
-	var missing_uids: int = 0
-	var resaved_scripts: int = 0
-
-	for script_path: String in scripts:
-		_log.debug("Checking UID for: " + script_path)
-		var uid_path: String = script_path + ".uid"
-
-		var f: FileAccess = FileAccess.open(uid_path, FileAccess.READ)
-		if f:
-			_log.debug("UID file already exists for: " + script_path)
-			continue
-
-		missing_uids += 1
-		_log.debug("Missing UID file for: " + script_path + ", resaving...")
-
-		var res: Resource = load(script_path)
-		if not res:
-			_log.error("Failed to load resource: " + script_path)
-			continue
-
-		var error: Error = ResourceSaver.save(res, script_path)
-		if error != OK:
-			_log.error("Failed to resave: " + script_path + ", error: " + str(error))
-			continue
-
-		resaved_scripts += 1
-		_log.debug("Resaved: " + script_path)
-
-	_log.info("Resave operation complete")
-
-	return {
-		"scenes_processed": scenes.size(),
-		"scenes_saved": success_count,
-		"scenes_with_errors": error_count,
-		"scripts_missing_uids": missing_uids,
-		"scripts_resaved": resaved_scripts
-	}

package/build/index.js

@@ -26390,6 +26390,36 @@ function reason(stdout, stderr) {
   }
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
+async function runImport(godotPath, projectPath) {
+  const logDir = mkdtempSync(join6(tmpdir2(), "gdharness-import-"));
+  try {
+    const { stderr } = await run2(godotPath, [
+      "--headless",
+      "--log-file",
+      join6(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
+    return { ok: true, messages: problems(stderr) };
+  } catch (error) {
+    if (error instanceof Error && "stdout" in error && "stderr" in error) {
+      const failed = error;
+      return {
+        ok: false,
+        message: `the import pass failed (exit ${failed.code ?? "unknown"}): ${reason(failed.stdout, failed.stderr)}`,
+        messages: problems(failed.stderr)
+      };
+    }
+    return {
+      ok: false,
+      message: `the import pass could not be run: ${error instanceof Error ? error.message : String(error)}`,
+      messages: []
+    };
+  } finally {
+    discard(logDir);
+  }
+}
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = mkdtempSync(join6(tmpdir2(), "gdharness-params-"));
   const paramsFile = join6(paramsDir, `${operation}.json`);
@@ -26459,7 +26489,6 @@ var HEADLESS_OPERATIONS = dictionary({
     set_options: "set_import_options",
     reimport: "reimport_resource",
     uid: "get_uid",
-    refresh_uids: "resave_resources",
     refresh_classes: "refresh_class_cache"
   }),
   project_export: dictionary({ list: "list_export_presets" }),
@@ -26471,6 +26500,9 @@ var HEADLESS_OPERATIONS = dictionary({
     inheritance: "inspect_inheritance"
   })
 });
+var ENGINE_PASSES = dictionary({
+  project_import: dictionary({ refresh_uids: "import" })
+});
 var EDITOR_READS = dictionary({
   project_settings: dictionary({ get: "get_project_setting" })
 });
@@ -27408,6 +27440,34 @@ function projectStructure(projectPath) {
   visit(projectPath);
   return structure;
 }
+var CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+function scriptsWithoutUid(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join7(directory, entry.name), spelled);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+      if (CARRIES_A_UID.has(extension) && !existsSync6(join7(directory, `${entry.name}.uid`))) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
 function searchProject(projectPath, options) {
   const extensions = new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
   const result = {
@@ -28562,7 +28622,10 @@ var TOOL_SPECS = [
         requires: []
       },
       uid: { summary: "the UID of one file", requires: ["resourcePath"] },
-      refresh_uids: { summary: "resave every resource so UID references are current", requires: [] },
+      refresh_uids: {
+        summary: "import the project so every script and shader has its .uid sidecar, and name under uidsCreated the ones this made and under stillWithoutUid the ones the engine would not import: it writes no scene and no script, so a project whose sidecars are all present is left untouched",
+        requires: []
+      },
       refresh_classes: {
         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: []
@@ -29970,6 +30033,9 @@ class GodotServer {
     return { ok: true, op };
   }
   async dispatch(tool, op, args) {
+    if (ENGINE_PASSES[tool]?.[op] !== undefined) {
+      return await this.handleRefreshUids(args);
+    }
     const headless = HEADLESS_OPERATIONS[tool]?.[op];
     if (headless !== undefined) {
       const { from: asked, ...answerable } = args;
@@ -30340,6 +30406,33 @@ class GodotServer {
     const { op: _op, projectPath: _projectPath, ...params } = contained.value;
     return this.answer(await this.operation(operation, params, project.value.path));
   }
+  async handleRefreshUids(args) {
+    const project = this.project(args);
+    if (!project.ok) {
+      return project.response;
+    }
+    const engine = await this.engine();
+    if (!engine.ok) {
+      return this.createErrorResponse("No Godot executable found.");
+    }
+    const projectPath = project.value.path;
+    const before = scriptsWithoutUid(projectPath);
+    const imported = await runImport(engine.value, projectPath);
+    if (!imported.ok) {
+      return this.answer(imported);
+    }
+    const after = scriptsWithoutUid(projectPath);
+    const given = before.filter((script) => !after.includes(script));
+    return this.answer({
+      ok: true,
+      messages: imported.messages,
+      payload: {
+        uidsCreated: given,
+        stillWithoutUid: after,
+        note: after.length > 0 ? `${after.length} still have no .uid, which is the engine declining to import them rather than this op skipping them. No scene was written.` : "No scene was written: this reads the project and imports it, and does not resave anything."
+      }
+    });
+  }
   async operation(operation, params, projectPath) {
     const engine = await this.engine();
     if (!engine.ok) {

package/package.json

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