unity-agentic-tools 0.6.1 → 0.7.0

package/dist/index.js

@@ -1,35 +1,11 @@
 // @bun @bun-cjs
-(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 function __accessProp(key) {
   return this[key];
 }
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
 var __toCommonJS = (from) => {
   var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
@@ -47,7 +23,6 @@ var __toCommonJS = (from) => {
   return entry;
 };
 var __moduleCache;
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -62,419 +37,32 @@ var __export = (target, all) => {
     });
 };
 
-// package.json
-var require_package = __commonJS((exports2, module2) => {
-  module2.exports = {
-    name: "unity-agentic-tools",
-    packageManager: "bun@latest",
-    version: "0.6.1",
-    description: "Compact Unity Editor command runner for AI agents",
-    exports: {
-      ".": {
-        import: "./dist/index.js",
-        types: "./dist/index.d.ts"
-      },
-      "./cli": "./dist/cli.js",
-      "./scanner": "./dist/scanner.js"
-    },
-    files: [
-      "dist",
-      "native",
-      "README.md",
-      "LICENSE"
-    ],
-    scripts: {
-      build: "bun run clean && bun run build:types && bun run build:lib && bun run build:cli && cp ../doc-indexer/dist/cli.js dist/doc-indexer-cli.js",
-      "build:types": "tsc --project tsconfig.json",
-      "build:lib": "bun build src/index.ts --outdir=dist --target=bun --format=cjs --external unity-file-tools",
-      "build:cli": "bun build src/cli.ts --outdir=dist --target=bun --format=cjs --external unity-file-tools",
-      "build:rust": "cd ../rust-core && bun run build",
-      "build:all": "bun run build:rust || echo 'Rust build skipped' && bun run build",
-      dev: "bun build src/index.ts --watch",
-      clean: "rm -rf dist",
-      rebuild: "bun run clean && bun run build",
-      test: "bun test",
-      "test:watch": "bun test --watch",
-      "test:coverage": "bun test --coverage",
-      "test:unity-headless": "bun test/run-headless-validation.ts"
-    },
-    dependencies: {
-      commander: "^14.0.2"
-    },
-    devDependencies: {
-      "@types/node": "^25.0.0",
-      "@vitest/ui": "^4.0.16",
-      typescript: "^5.3.0",
-      "unity-file-tools": "workspace:*",
-      vitest: "^4.0.16"
-    },
-    type: "commonjs",
-    bin: {
-      "unity-agentic-tools": "./dist/cli.js"
-    },
-    engines: {
-      bun: ">=1.0.0"
-    },
-    repository: {
-      type: "git",
-      url: "https://github.com/taconotsandwich/unity-agentic-tools"
-    },
-    keywords: [
-      "unity",
-      "yaml",
-      "parser",
-      "scene",
-      "prefab",
-      "gameobject",
-      "ai",
-      "cli"
-    ],
-    license: "Apache-2.0"
-  };
-});
-
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  walk_project_files: () => walk_project_files,
-  setup: () => setup,
-  search_project: () => search_project,
-  isNativeModuleAvailable: () => isNativeModuleAvailable,
-  grep_project: () => grep_project,
-  getNativeModuleError: () => getNativeModuleError,
-  getNativeExtractDllTypes: () => getNativeExtractDllTypes,
-  getNativeExtractCsharpTypes: () => getNativeExtractCsharpTypes,
-  getNativeBuildTypeRegistry: () => getNativeBuildTypeRegistry,
   generateGuid: () => generateGuid,
   find_unity_project_root: () => find_unity_project_root,
   cleanup: () => cleanup,
-  atomicWrite: () => atomicWrite,
-  UnityScanner: () => UnityScanner
+  atomicWrite: () => atomicWrite
 });
 module.exports = __toCommonJS(exports_src);
 
-// src/scanner.ts
-var import_module = require("module");
+// src/cleanup.ts
 var import_fs = require("fs");
 var import_path = require("path");
-var __dirname = "/home/runner/work/unity-agentic-tools/unity-agentic-tools/unity-agentic-tools/src";
-var RustScanner = null;
-var nativeModuleError = null;
-var nativeWalkProjectFiles = null;
-var nativeGrepProject = null;
-var nativeBuildGuidCache = null;
-var nativeExtractCsharpTypes = null;
-var nativeBuildTypeRegistry = null;
-var nativeExtractDllTypes = null;
-var nativeBuildPackageGuidCache = null;
-var nativeBuildLocalPackageGuidCache = null;
-var nativeExtractSerializedFields = null;
-var nativeExtractDllFields = null;
-try {
-  const scriptDir = process.argv[1] ? import_path.dirname(import_path.resolve(process.argv[1])) : __dirname;
-  let rustModule;
-  const nativeLoaderPath = import_path.join(scriptDir, "..", "native", "index.js");
-  if (import_fs.existsSync(nativeLoaderPath)) {
-    const nativeRequire = import_module.createRequire(nativeLoaderPath);
-    rustModule = nativeRequire(nativeLoaderPath);
-  } else {
-    const wsRequire = import_module.createRequire(import_path.join(scriptDir, "_"));
-    rustModule = wsRequire("unity-file-tools");
-  }
-  RustScanner = rustModule.Scanner;
-  nativeWalkProjectFiles = rustModule.walkProjectFiles || null;
-  nativeGrepProject = rustModule.grepProject || null;
-  nativeBuildGuidCache = rustModule.buildGuidCache || null;
-  nativeExtractCsharpTypes = rustModule.extractCsharpTypes || null;
-  nativeBuildTypeRegistry = rustModule.buildTypeRegistry || null;
-  nativeExtractDllTypes = rustModule.extractDllTypes || null;
-  nativeBuildPackageGuidCache = rustModule.buildPackageGuidCache || null;
-  nativeBuildLocalPackageGuidCache = rustModule.buildLocalPackageGuidCache || null;
-  nativeExtractSerializedFields = rustModule.extractSerializedFields || null;
-  nativeExtractDllFields = rustModule.extractDllFields || null;
-} catch (err) {
-  nativeModuleError = `Failed to load native Rust module.
-` + `Run: bun install (in the project root)
-` + `Original error: ${err.message}`;
-}
-function isNativeModuleAvailable() {
-  return RustScanner !== null;
-}
-function getNativeModuleError() {
-  return nativeModuleError;
-}
-
-class UnityScanner {
-  scanner;
-  constructor() {
-    if (!RustScanner) {
-      throw new Error(nativeModuleError || "Native module not available");
-    }
-    this.scanner = new RustScanner;
-  }
-  setProjectRoot(path) {
-    this.scanner.setProjectRoot(path);
-  }
-  scan_scene_minimal(file) {
-    return this.scanner.scanSceneMinimal(file);
-  }
-  scan_scene_with_components(file, options) {
-    return this.scanner.scanSceneWithComponents(file, options);
-  }
-  scan_scene_metadata(file) {
-    return this.scanner.scanSceneMetadata(file);
-  }
-  find_by_name(file, pattern, fuzzy = true) {
-    return this.scanner.findByName(file, pattern, fuzzy);
-  }
-  inspect(options) {
-    return this.scanner.inspect({
-      file: options.file,
-      identifier: options.identifier,
-      includeProperties: options.include_properties,
-      verbose: options.verbose
-    });
-  }
-  inspect_all(file, include_properties = false, verbose = false) {
-    return this.scanner.inspectAll(file, include_properties, verbose);
-  }
-  inspect_all_paginated(options) {
-    return this.scanner.inspectAllPaginated({
-      file: options.file,
-      includeProperties: options.include_properties,
-      verbose: options.verbose,
-      pageSize: options.page_size,
-      cursor: options.cursor,
-      maxDepth: options.max_depth,
-      filterComponent: options.filter_component
-    });
-  }
-  read_asset(file, decode_mesh) {
-    return this.scanner.readAsset(file, decode_mesh);
-  }
-}
-function getNativeWalkProjectFiles() {
-  return nativeWalkProjectFiles;
-}
-function getNativeGrepProject() {
-  return nativeGrepProject;
-}
-function getNativeBuildGuidCache() {
-  return nativeBuildGuidCache;
-}
-function getNativeExtractCsharpTypes() {
-  return nativeExtractCsharpTypes;
-}
-function getNativeBuildTypeRegistry() {
-  return nativeBuildTypeRegistry;
-}
-function getNativeExtractDllTypes() {
-  return nativeExtractDllTypes;
-}
-function getNativeBuildPackageGuidCache() {
-  return nativeBuildPackageGuidCache;
-}
-function getNativeBuildLocalPackageGuidCache() {
-  return nativeBuildLocalPackageGuidCache;
-}
-// src/setup.ts
-var import_fs3 = require("fs");
-var import_path3 = require("path");
-
-// src/gitignore.ts
-var import_fs2 = require("fs");
-var import_path2 = require("path");
-var AGENTIC_DIR = ".unity-agentic";
-var GITIGNORE_ENTRY = `${AGENTIC_DIR}/`;
-var ACCEPTED_AGENTIC_PATTERNS = new Set([
-  AGENTIC_DIR,
-  GITIGNORE_ENTRY,
-  `/${AGENTIC_DIR}`,
-  `/${GITIGNORE_ENTRY}`
-]);
-function ensure_gitignore_ignores_agentic_dir(project_path) {
-  const gitignore_path = import_path2.join(project_path, ".gitignore");
-  if (!import_fs2.existsSync(gitignore_path)) {
-    import_fs2.writeFileSync(gitignore_path, `${GITIGNORE_ENTRY}
-`);
-    return;
-  }
-  const content = import_fs2.readFileSync(gitignore_path, "utf-8");
-  if (gitignore_ignores_agentic_dir(content)) {
-    return;
-  }
-  const separator = content.length === 0 || content.endsWith(`
-`) ? "" : `
-`;
-  import_fs2.writeFileSync(gitignore_path, `${content}${separator}${GITIGNORE_ENTRY}
-`);
-}
-function gitignore_ignores_agentic_dir(content) {
-  for (const raw_line of content.split(/\r?\n/)) {
-    const line = raw_line.trim();
-    if (line.length === 0 || line.startsWith("#")) {
-      continue;
-    }
-    if (ACCEPTED_AGENTIC_PATTERNS.has(line)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// src/setup.ts
-var VERSION = require_package().version;
 var CONFIG_DIR = ".unity-agentic";
-var CONFIG_FILE = "config.json";
 var GUID_CACHE_FILE = "guid-cache.json";
 var PACKAGE_CACHE_FILE = "package-cache.json";
 var LOCAL_PACKAGE_CACHE_FILE = "local-package-cache.json";
 var TYPE_REGISTRY_FILE = "type-registry.json";
 var DOC_INDEX_FILE = "doc-index.json";
-function setup(options = {}) {
-  const projectPath = import_path3.resolve(options.project || process.cwd());
-  const assetsPath = import_path3.join(projectPath, "Assets");
-  if (!import_fs3.existsSync(assetsPath)) {
-    return {
-      success: false,
-      project_path: projectPath,
-      config_path: "",
-      guid_cache_created: false,
-      package_cache_created: false,
-      type_registry_created: false,
-      doc_index_created: false,
-      error: `Not a Unity project: Assets folder not found at ${assetsPath}`
-    };
-  }
-  const configPath = import_path3.join(projectPath, CONFIG_DIR);
-  if (!import_fs3.existsSync(configPath)) {
-    import_fs3.mkdirSync(configPath, { recursive: true });
-  }
-  ensure_gitignore_ignores_agentic_dir(projectPath);
-  const config = {
-    version: VERSION,
-    project_path: projectPath,
-    created_at: new Date().toISOString(),
-    rust_enabled: isRustAvailable()
-  };
-  import_fs3.writeFileSync(import_path3.join(configPath, CONFIG_FILE), JSON.stringify(config, null, 2));
-  const guidCache = buildGuidCache(projectPath);
-  const guidCachePath = import_path3.join(configPath, GUID_CACHE_FILE);
-  import_fs3.writeFileSync(guidCachePath, JSON.stringify(guidCache, null, 2));
-  let packageCacheCreated = false;
-  let packageGuidCount;
-  const nativePkgBuild = getNativeBuildPackageGuidCache();
-  if (nativePkgBuild) {
-    try {
-      const packageCache = nativePkgBuild(projectPath);
-      const packageCachePath = import_path3.join(configPath, PACKAGE_CACHE_FILE);
-      import_fs3.writeFileSync(packageCachePath, JSON.stringify(packageCache, null, 2));
-      packageCacheCreated = true;
-      packageGuidCount = Object.keys(packageCache).length;
-    } catch {}
-  }
-  const nativeLocalPkgBuild = getNativeBuildLocalPackageGuidCache();
-  if (nativeLocalPkgBuild) {
-    try {
-      const localPackageCache = nativeLocalPkgBuild(projectPath);
-      const localPkgCount = Object.keys(localPackageCache).length;
-      if (localPkgCount > 0) {
-        const localPkgCachePath = import_path3.join(configPath, LOCAL_PACKAGE_CACHE_FILE);
-        import_fs3.writeFileSync(localPkgCachePath, JSON.stringify(localPackageCache, null, 2));
-      }
-    } catch {}
-  }
-  let typeRegistryCreated = false;
-  let typeCount;
-  const nativeRegistryBuild = getNativeBuildTypeRegistry();
-  if (nativeRegistryBuild) {
-    try {
-      const types = nativeRegistryBuild(projectPath, true, true);
-      const registryPath = import_path3.join(configPath, TYPE_REGISTRY_FILE);
-      import_fs3.writeFileSync(registryPath, JSON.stringify(types, null, 2));
-      typeRegistryCreated = true;
-      typeCount = types.length;
-    } catch {}
-  }
-  let docIndexCreated = false;
-  if (options.indexDocs) {
-    const docIndex = { chunks: {}, last_updated: Date.now() };
-    import_fs3.writeFileSync(import_path3.join(configPath, DOC_INDEX_FILE), JSON.stringify(docIndex, null, 2));
-    docIndexCreated = true;
-  }
-  return {
-    success: true,
-    project_path: projectPath,
-    config_path: configPath,
-    guid_cache_created: true,
-    package_cache_created: packageCacheCreated,
-    type_registry_created: typeRegistryCreated,
-    doc_index_created: docIndexCreated,
-    guid_count: Object.keys(guidCache).length,
-    package_guid_count: packageGuidCount,
-    type_count: typeCount
-  };
-}
-function buildGuidCache(projectRoot) {
-  const nativeBuild = getNativeBuildGuidCache();
-  if (nativeBuild) {
-    try {
-      return nativeBuild(projectRoot);
-    } catch {}
-  }
-  return buildGuidCacheJs(projectRoot);
-}
-function buildGuidCacheJs(projectRoot) {
-  const cache = {};
-  const assetsDir = import_path3.join(projectRoot, "Assets");
-  if (!import_fs3.existsSync(assetsDir)) {
-    return cache;
-  }
-  scanMetaFiles(assetsDir, projectRoot, cache);
-  return cache;
-}
-function scanMetaFiles(dir, projectRoot, cache) {
-  try {
-    const entries = import_fs3.readdirSync(dir);
-    for (const entry of entries) {
-      const fullPath = import_path3.join(dir, entry);
-      const stat = import_fs3.statSync(fullPath);
-      if (stat.isDirectory()) {
-        scanMetaFiles(fullPath, projectRoot, cache);
-      } else if (entry.endsWith(".meta")) {
-        try {
-          const content = import_fs3.readFileSync(fullPath, "utf-8");
-          const guidMatch = content.match(/^guid:\s*([a-f0-9]{32})/m);
-          if (guidMatch) {
-            const guid = guidMatch[1];
-            const assetPath = fullPath.slice(0, -5);
-            const relativePath = import_path3.relative(projectRoot, assetPath);
-            cache[guid] = relativePath;
-          }
-        } catch {}
-      }
-    }
-  } catch {}
-}
-function isRustAvailable() {
-  return isNativeModuleAvailable();
-}
-// src/cleanup.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
-var CONFIG_DIR2 = ".unity-agentic";
-var GUID_CACHE_FILE2 = "guid-cache.json";
-var PACKAGE_CACHE_FILE2 = "package-cache.json";
-var LOCAL_PACKAGE_CACHE_FILE2 = "local-package-cache.json";
-var TYPE_REGISTRY_FILE2 = "type-registry.json";
-var DOC_INDEX_FILE2 = "doc-index.json";
 var EDITOR_LOCK_FILE = "editor.json";
 var LAST_EDITOR_CONFIG_FILE = "editor.last.json";
 function cleanup(options = {}) {
-  const projectPath = import_path4.resolve(options.project || process.cwd());
-  const configPath = import_path4.join(projectPath, CONFIG_DIR2);
+  const projectPath = import_path.resolve(options.project || process.cwd());
+  const configPath = import_path.join(projectPath, CONFIG_DIR);
   const modes = resolve_cleanup_modes(options);
-  if (!import_fs4.existsSync(configPath)) {
+  if (!import_fs.existsSync(configPath)) {
     return {
       success: true,
       project_path: projectPath,
@@ -489,7 +77,7 @@ function cleanup(options = {}) {
     try {
       removeDirectoryRecursive(configPath);
       directoryRemoved = true;
-      filesRemoved.push(CONFIG_DIR2);
+      filesRemoved.push(CONFIG_DIR);
     } catch (err) {
       return {
         success: false,
@@ -513,11 +101,11 @@ function cleanup(options = {}) {
   }
   if (modes.includes("cache")) {
     remove_files(configPath, [
-      GUID_CACHE_FILE2,
-      PACKAGE_CACHE_FILE2,
-      LOCAL_PACKAGE_CACHE_FILE2,
-      TYPE_REGISTRY_FILE2,
-      DOC_INDEX_FILE2
+      GUID_CACHE_FILE,
+      PACKAGE_CACHE_FILE,
+      LOCAL_PACKAGE_CACHE_FILE,
+      TYPE_REGISTRY_FILE,
+      DOC_INDEX_FILE
     ], filesRemoved);
   }
   return {
@@ -542,15 +130,15 @@ function resolve_cleanup_modes(options) {
   return modes;
 }
 function remove_stale_lock_files(configPath, filesRemoved) {
-  const editorLockPath = import_path4.join(configPath, EDITOR_LOCK_FILE);
-  if (import_fs4.existsSync(editorLockPath) && is_stale_editor_lock(editorLockPath)) {
+  const editorLockPath = import_path.join(configPath, EDITOR_LOCK_FILE);
+  if (import_fs.existsSync(editorLockPath) && is_stale_editor_lock(editorLockPath)) {
     remove_file(configPath, EDITOR_LOCK_FILE, filesRemoved);
   }
   remove_file(configPath, LAST_EDITOR_CONFIG_FILE, filesRemoved);
 }
 function is_stale_editor_lock(filePath) {
   try {
-    const parsed = JSON.parse(import_fs4.readFileSync(filePath, "utf-8"));
+    const parsed = JSON.parse(import_fs.readFileSync(filePath, "utf-8"));
     if (!is_record(parsed)) {
       return true;
     }
@@ -580,48 +168,44 @@ function remove_files(configPath, files, filesRemoved) {
   }
 }
 function remove_file(configPath, file, filesRemoved) {
-  const filePath = import_path4.join(configPath, file);
-  if (!import_fs4.existsSync(filePath)) {
+  const filePath = import_path.join(configPath, file);
+  if (!import_fs.existsSync(filePath)) {
     return;
   }
   try {
-    import_fs4.unlinkSync(filePath);
+    import_fs.unlinkSync(filePath);
     filesRemoved.push(file);
   } catch {}
 }
 function removeDirectoryRecursive(dir) {
-  if (!import_fs4.existsSync(dir)) {
+  if (!import_fs.existsSync(dir)) {
     return;
   }
-  const entries = import_fs4.readdirSync(dir, { withFileTypes: true });
+  const entries = import_fs.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = import_path4.join(dir, entry.name);
+    const fullPath = import_path.join(dir, entry.name);
     if (entry.isDirectory()) {
       removeDirectoryRecursive(fullPath);
     } else {
-      import_fs4.unlinkSync(fullPath);
+      import_fs.unlinkSync(fullPath);
     }
   }
-  import_fs4.rmdirSync(dir);
+  import_fs.rmdirSync(dir);
 }
-// src/project-search.ts
-var import_fs6 = require("fs");
-var path = __toESM(require("path"));
-
 // src/utils.ts
-var import_fs5 = require("fs");
-var import_path5 = require("path");
+var import_fs2 = require("fs");
+var import_path2 = require("path");
 function find_unity_project_root(startDir) {
-  let dir = import_path5.resolve(startDir || process.cwd());
-  const root = import_path5.resolve("/");
+  let dir = import_path2.resolve(startDir || process.cwd());
+  const root = import_path2.resolve("/");
   while (dir !== root) {
-    if (import_fs5.existsSync(import_path5.join(dir, ".unity-agentic")))
+    if (import_fs2.existsSync(import_path2.join(dir, ".unity-agentic")))
       return dir;
-    if (import_fs5.existsSync(import_path5.join(dir, "Assets")) && import_fs5.existsSync(import_path5.join(dir, "ProjectSettings")))
+    if (import_fs2.existsSync(import_path2.join(dir, "Assets")) && import_fs2.existsSync(import_path2.join(dir, "ProjectSettings")))
       return dir;
-    if (import_fs5.existsSync(import_path5.join(dir, "Assets")))
+    if (import_fs2.existsSync(import_path2.join(dir, "Assets")))
       return dir;
-    const parent = import_path5.dirname(dir);
+    const parent = import_path2.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -629,9 +213,9 @@ function find_unity_project_root(startDir) {
   return null;
 }
 function atomicWrite(filePath, content) {
-  if (import_fs5.existsSync(filePath)) {
+  if (import_fs2.existsSync(filePath)) {
     try {
-      import_fs5.accessSync(filePath, import_fs5.constants.W_OK);
+      import_fs2.accessSync(filePath, import_fs2.constants.W_OK);
     } catch {
       return {
         success: false,
@@ -645,9 +229,9 @@ function atomicWrite(filePath, content) {
   const bakPath = `${filePath}.${suffix}.bak`;
   let bakCreated = false;
   try {
-    import_fs5.writeFileSync(tmpPath, content, "utf-8");
+    import_fs2.writeFileSync(tmpPath, content, "utf-8");
     try {
-      import_fs5.renameSync(filePath, bakPath);
+      import_fs2.renameSync(filePath, bakPath);
       bakCreated = true;
     } catch (err) {
       if (is_enoent(err)) {
@@ -656,10 +240,10 @@ function atomicWrite(filePath, content) {
         throw err;
       }
     }
-    import_fs5.renameSync(tmpPath, filePath);
+    import_fs2.renameSync(tmpPath, filePath);
     if (bakCreated) {
       try {
-        import_fs5.unlinkSync(bakPath);
+        import_fs2.unlinkSync(bakPath);
       } catch {}
     }
     return {
@@ -670,13 +254,13 @@ function atomicWrite(filePath, content) {
   } catch (error) {
     if (bakCreated) {
       try {
-        import_fs5.renameSync(bakPath, filePath);
+        import_fs2.renameSync(bakPath, filePath);
       } catch (restoreError) {
         console.error("Failed to restore backup:", restoreError);
       }
     }
     try {
-      import_fs5.unlinkSync(tmpPath);
+      import_fs2.unlinkSync(tmpPath);
     } catch {}
     return {
       success: false,
@@ -688,17 +272,6 @@ function atomicWrite(filePath, content) {
 function is_enoent(err) {
   return err instanceof Error && "code" in err && err.code === "ENOENT";
 }
-function is_match_all(pattern) {
-  return pattern === "*" || pattern === "." || pattern === "**" || pattern === ".*";
-}
-function glob_match(pattern, text) {
-  if (!pattern.includes("*") && !pattern.includes("?")) {
-    return pattern.toLowerCase() === text.toLowerCase();
-  }
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
-  const regex_str = escaped.replace(/\*/g, ".*").replace(/\?/g, ".");
-  return new RegExp(`^${regex_str}$`, "i").test(text);
-}
 function generateGuid() {
   const hex = "0123456789abcdef";
   let guid = "";
@@ -707,510 +280,4 @@ function generateGuid() {
   }
   return guid;
 }
-
-// src/project-search.ts
-var BINARY_EXTENSIONS = new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".bmp",
-  ".tga",
-  ".psd",
-  ".tif",
-  ".tiff",
-  ".fbx",
-  ".obj",
-  ".dae",
-  ".blend",
-  ".3ds",
-  ".max",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".exe",
-  ".a",
-  ".lib",
-  ".mp3",
-  ".wav",
-  ".ogg",
-  ".aif",
-  ".aiff",
-  ".mp4",
-  ".mov",
-  ".avi",
-  ".wmv",
-  ".zip",
-  ".gz",
-  ".tar",
-  ".rar",
-  ".7z",
-  ".ttf",
-  ".otf",
-  ".woff",
-  ".woff2",
-  ".bank",
-  ".bytes",
-  ".db"
-]);
-var SKIP_DIRS = new Set(["Library", "Temp", "obj", "Logs", ".git", ".unity-agentic", "node_modules"]);
-function walk_project_files(project_path, extensions, exclude_dirs) {
-  const nativeWalk = getNativeWalkProjectFiles();
-  if (nativeWalk) {
-    try {
-      return nativeWalk(project_path, extensions, exclude_dirs ?? null);
-    } catch {}
-  }
-  return walk_project_files_js(project_path, extensions, exclude_dirs);
-}
-function walk_project_files_js(project_path, extensions, exclude_dirs) {
-  const result = [];
-  const skipSet = new Set([...SKIP_DIRS, ...exclude_dirs || []]);
-  const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
-  function walk(dir) {
-    let entries;
-    try {
-      entries = import_fs6.readdirSync(dir);
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = path.join(dir, entry);
-      let stat;
-      try {
-        stat = import_fs6.statSync(full);
-      } catch {
-        continue;
-      }
-      if (stat.isDirectory()) {
-        if (!skipSet.has(entry)) {
-          walk(full);
-        }
-      } else if (stat.isFile()) {
-        const ext = path.extname(entry).toLowerCase();
-        if (extSet.has(ext)) {
-          result.push(full);
-        }
-      }
-    }
-  }
-  const assetsDir = path.join(project_path, "Assets");
-  if (import_fs6.existsSync(assetsDir)) {
-    walk(assetsDir);
-  } else {
-    walk(project_path);
-  }
-  if (extSet.has(".asset")) {
-    const settingsDir = path.join(project_path, "ProjectSettings");
-    if (import_fs6.existsSync(settingsDir)) {
-      walk(settingsDir);
-    }
-  }
-  return result;
-}
-function search_project(options) {
-  const {
-    project_path,
-    name,
-    exact = false,
-    component,
-    tag,
-    layer,
-    file_type = "all",
-    max_matches
-  } = options;
-  if (max_matches !== undefined && max_matches < 1) {
-    return {
-      success: false,
-      project_path,
-      total_files_scanned: 0,
-      total_matches: 0,
-      cursor: 0,
-      truncated: false,
-      matches: [],
-      error: "--max-matches must be a positive integer (>= 1)"
-    };
-  }
-  if (name !== undefined && name.trim() === "") {
-    return {
-      success: false,
-      project_path,
-      total_files_scanned: 0,
-      total_matches: 0,
-      cursor: 0,
-      truncated: false,
-      matches: [],
-      error: "Name pattern must not be empty"
-    };
-  }
-  if (!import_fs6.existsSync(project_path)) {
-    return {
-      success: false,
-      project_path,
-      total_files_scanned: 0,
-      total_matches: 0,
-      cursor: 0,
-      truncated: false,
-      matches: [],
-      error: `Project path not found: ${project_path}`
-    };
-  }
-  const ASSET_TYPE_EXTENSIONS = {
-    mat: [".mat"],
-    anim: [".anim"],
-    controller: [".controller"],
-    asset: [".asset"]
-  };
-  const isAssetType = file_type in ASSET_TYPE_EXTENSIONS;
-  if (isAssetType) {
-    const extensions2 = ASSET_TYPE_EXTENSIONS[file_type];
-    const files2 = walk_project_files(project_path, extensions2);
-    const matches2 = [];
-    for (const file of files2) {
-      const relPath = path.relative(project_path, file);
-      const fileName = path.basename(file, path.extname(file));
-      if (name) {
-        const nameLower = name.toLowerCase();
-        const hasWildcard = name.includes("*") || name.includes("?");
-        if (hasWildcard) {
-          if (!glob_match(name, fileName))
-            continue;
-        } else if (exact) {
-          if (fileName !== name)
-            continue;
-        } else {
-          if (!fileName.toLowerCase().includes(nameLower))
-            continue;
-        }
-      }
-      let display_name = fileName;
-      try {
-        const content = import_fs6.readFileSync(file, "utf-8");
-        const nameMatch = /^\s*m_Name:\s*(.+)$/m.exec(content.slice(0, 2000));
-        if (nameMatch)
-          display_name = nameMatch[1].trim();
-      } catch {}
-      matches2.push({
-        file: relPath,
-        game_object: display_name,
-        file_id: "0"
-      });
-      if (max_matches !== undefined && matches2.length >= max_matches)
-        break;
-    }
-    return {
-      success: true,
-      project_path,
-      total_files_scanned: files2.length,
-      total_matches: matches2.length,
-      cursor: 0,
-      truncated: max_matches !== undefined && matches2.length >= max_matches,
-      matches: matches2
-    };
-  }
-  if (!isNativeModuleAvailable()) {
-    return {
-      success: false,
-      project_path,
-      total_files_scanned: 0,
-      total_matches: 0,
-      cursor: 0,
-      truncated: false,
-      matches: [],
-      error: "Native scanner module not available. Run bun install in the project root."
-    };
-  }
-  const extensions = [];
-  if (file_type === "scene" || file_type === "all")
-    extensions.push(".unity");
-  if (file_type === "prefab" || file_type === "all")
-    extensions.push(".prefab");
-  const files = walk_project_files(project_path, extensions);
-  const scanner = new UnityScanner;
-  const matches = [];
-  let files_with_errors = 0;
-  for (const file of files) {
-    try {
-      let gameObjects;
-      const needComponents = !!component;
-      const needMetadata = !!(tag || layer !== undefined);
-      if (name && !needMetadata && !needComponents) {
-        gameObjects = scanner.find_by_name(file, name, !exact);
-      } else if (needComponents) {
-        gameObjects = scanner.scan_scene_with_components(file);
-        if (name && !is_match_all(name)) {
-          const nameLower = name.toLowerCase();
-          const hasWildcard = name.includes("*") || name.includes("?");
-          gameObjects = gameObjects.filter((go) => {
-            if (!go.name)
-              return false;
-            if (hasWildcard) {
-              return glob_match(name, go.name);
-            }
-            if (exact) {
-              return go.name === name;
-            }
-            return go.name.toLowerCase().includes(nameLower);
-          });
-        }
-      } else if (needMetadata) {
-        gameObjects = scanner.scan_scene_metadata(file);
-        if (name && !is_match_all(name)) {
-          const nameLower = name.toLowerCase();
-          const hasWildcard = name.includes("*") || name.includes("?");
-          gameObjects = gameObjects.filter((go) => {
-            if (!go.name)
-              return false;
-            if (hasWildcard) {
-              return glob_match(name, go.name);
-            }
-            if (exact) {
-              return go.name === name;
-            }
-            return go.name.toLowerCase().includes(nameLower);
-          });
-        }
-      } else {
-        gameObjects = scanner.scan_scene_minimal(file);
-      }
-      for (const go of gameObjects) {
-        const isFindResult = "resultType" in go;
-        const isPrefab = isFindResult && go.resultType === "PrefabInstance";
-        if (isPrefab && (component || tag || layer !== undefined)) {
-          continue;
-        }
-        if (component) {
-          if ("components" in go && go.components) {
-            const hasComponent = go.components.some((c) => glob_match(component, c.type));
-            if (!hasComponent)
-              continue;
-          } else {
-            continue;
-          }
-        }
-        if (tag) {
-          if (!("tag" in go) || go.tag !== tag)
-            continue;
-        }
-        if (layer !== undefined) {
-          if (!("layer" in go) || go.layer !== layer)
-            continue;
-        }
-        const relPath = path.relative(project_path, file);
-        const fileId = isFindResult ? go.fileId : go.file_id;
-        const match = {
-          file: relPath,
-          game_object: go.name,
-          file_id: fileId,
-          tag: "tag" in go ? go.tag : undefined,
-          layer: "layer" in go ? go.layer : undefined
-        };
-        if ("components" in go && go.components) {
-          match.components = go.components.map((c) => c.type);
-        }
-        matches.push(match);
-        if (max_matches !== undefined && matches.length >= max_matches)
-          break;
-      }
-      if (max_matches !== undefined && matches.length >= max_matches)
-        break;
-    } catch {
-      files_with_errors++;
-      continue;
-    }
-  }
-  return {
-    success: true,
-    project_path,
-    total_files_scanned: files.length,
-    total_matches: matches.length,
-    files_with_errors: files_with_errors > 0 ? files_with_errors : undefined,
-    cursor: 0,
-    truncated: max_matches !== undefined && matches.length >= max_matches,
-    matches
-  };
-}
-function grep_project(options) {
-  const nativeGrep = getNativeGrepProject();
-  if (nativeGrep) {
-    try {
-      const nativeResult = nativeGrep({
-        projectPath: options.project_path,
-        pattern: options.pattern,
-        fileType: options.file_type,
-        maxResults: options.max_results,
-        contextLines: options.context_lines
-      });
-      return {
-        success: nativeResult.success,
-        project_path: nativeResult.projectPath,
-        pattern: nativeResult.pattern,
-        total_files_scanned: nativeResult.totalFilesScanned,
-        total_matches: nativeResult.totalMatches,
-        truncated: nativeResult.truncated,
-        error: nativeResult.error,
-        matches: nativeResult.matches.map((m) => ({
-          file: m.file,
-          line_number: m.lineNumber,
-          line: m.line,
-          context_before: m.contextBefore,
-          context_after: m.contextAfter
-        }))
-      };
-    } catch {}
-  }
-  return grep_project_js(options);
-}
-function grep_project_js(options) {
-  const {
-    project_path,
-    pattern,
-    file_type = "all",
-    max_results = 100,
-    context_lines = 0
-  } = options;
-  if (!import_fs6.existsSync(project_path)) {
-    return {
-      success: false,
-      project_path,
-      pattern,
-      total_files_scanned: 0,
-      total_matches: 0,
-      truncated: false,
-      matches: [],
-      error: `Project path not found: ${project_path}`
-    };
-  }
-  let regex;
-  try {
-    regex = new RegExp(pattern, "i");
-  } catch (err) {
-    return {
-      success: false,
-      project_path,
-      pattern,
-      total_files_scanned: 0,
-      total_matches: 0,
-      truncated: false,
-      matches: [],
-      error: `Invalid regex pattern: ${err instanceof Error ? err.message : String(err)}`
-    };
-  }
-  const EXTENSION_MAP = {
-    cs: [".cs"],
-    yaml: [
-      ".yaml",
-      ".yml",
-      ".unity",
-      ".prefab",
-      ".asset",
-      ".mat",
-      ".anim",
-      ".controller",
-      ".overrideController",
-      ".mask",
-      ".mixer",
-      ".lighting",
-      ".preset",
-      ".signal",
-      ".playable",
-      ".renderTexture",
-      ".flare",
-      ".guiskin",
-      ".terrainlayer",
-      ".cubemap"
-    ],
-    unity: [".unity"],
-    prefab: [".prefab"],
-    asset: [".asset"],
-    mat: [".mat"],
-    anim: [".anim"],
-    controller: [".controller"],
-    all: [
-      ".cs",
-      ".unity",
-      ".prefab",
-      ".asset",
-      ".mat",
-      ".anim",
-      ".controller",
-      ".yaml",
-      ".yml",
-      ".txt",
-      ".json",
-      ".xml",
-      ".shader",
-      ".cginc",
-      ".hlsl",
-      ".compute",
-      ".asmdef",
-      ".asmref"
-    ]
-  };
-  const extensions = EXTENSION_MAP[file_type] || EXTENSION_MAP.all;
-  const files = walk_project_files(project_path, extensions);
-  const matches = [];
-  let totalFilesScanned = 0;
-  let truncated = false;
-  for (const file of files) {
-    const ext = path.extname(file).toLowerCase();
-    if (BINARY_EXTENSIONS.has(ext))
-      continue;
-    totalFilesScanned++;
-    let content;
-    try {
-      content = import_fs6.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const lines = content.split(`
-`);
-    const relPath = path.relative(project_path, file);
-    for (let i = 0;i < lines.length; i++) {
-      if (regex.test(lines[i])) {
-        let line = lines[i];
-        if (line.length > 200) {
-          line = line.substring(0, 200) + "...";
-        }
-        const match = {
-          file: relPath,
-          line_number: i + 1,
-          line
-        };
-        if (context_lines > 0) {
-          match.context_before = [];
-          match.context_after = [];
-          for (let j = Math.max(0, i - context_lines);j < i; j++) {
-            let ctxLine = lines[j];
-            if (ctxLine.length > 200)
-              ctxLine = ctxLine.substring(0, 200) + "...";
-            match.context_before.push(ctxLine);
-          }
-          for (let j = i + 1;j <= Math.min(lines.length - 1, i + context_lines); j++) {
-            let ctxLine = lines[j];
-            if (ctxLine.length > 200)
-              ctxLine = ctxLine.substring(0, 200) + "...";
-            match.context_after.push(ctxLine);
-          }
-        }
-        matches.push(match);
-        if (matches.length >= max_results) {
-          truncated = true;
-          break;
-        }
-      }
-    }
-    if (truncated)
-      break;
-  }
-  return {
-    success: true,
-    project_path,
-    pattern,
-    total_files_scanned: totalFilesScanned,
-    total_matches: matches.length,
-    truncated,
-    matches
-  };
-}
 })