uloop-cli 0.51.0 → 0.53.0

package/dist/cli.bundle.cjs

@@ -5383,7 +5383,7 @@ var require_semver2 = __commonJS({
 });
 
 // src/cli.ts
-var import_fs5 = require("fs");
+var import_fs6 = require("fs");
 var import_path6 = require("path");
 var import_os2 = require("os");
 var import_child_process = require("child_process");
@@ -5407,7 +5407,7 @@ var {
 
 // src/execute-tool.ts
 var readline = __toESM(require("readline"), 1);
-var import_fs3 = require("fs");
+var import_fs4 = require("fs");
 var import_path4 = require("path");
 var semver = __toESM(require_semver2(), 1);
 
@@ -5555,19 +5555,72 @@ var DirectUnityClient = class {
 
 // src/port-resolver.ts
 var import_promises = require("fs/promises");
+var import_fs2 = require("fs");
 var import_path2 = require("path");
 
 // src/project-root.ts
 var import_fs = require("fs");
 var import_path = require("path");
-function findUnityProjectRoot(startPath = process.cwd()) {
+var CHILD_SEARCH_MAX_DEPTH = 3;
+var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "Temp",
+  "obj",
+  "Build",
+  "Builds",
+  "Logs",
+  "Library"
+]);
+function isUnityProjectWithUloop(dirPath) {
+  const hasAssets = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "Assets"));
+  const hasProjectSettings = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "ProjectSettings"));
+  const hasUloopSettings = (0, import_fs.existsSync)((0, import_path.join)(dirPath, "UserSettings/UnityMcpSettings.json"));
+  return hasAssets && hasProjectSettings && hasUloopSettings;
+}
+function findUnityProjectsInChildren(startPath, maxDepth) {
+  const projects = [];
+  function scan(currentPath, depth) {
+    if (depth > maxDepth) {
+      return;
+    }
+    if (!(0, import_fs.existsSync)(currentPath)) {
+      return;
+    }
+    if (isUnityProjectWithUloop(currentPath)) {
+      projects.push(currentPath);
+      return;
+    }
+    let entries;
+    try {
+      entries = (0, import_fs.readdirSync)(currentPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+      const fullPath = (0, import_path.join)(currentPath, entry.name);
+      scan(fullPath, depth + 1);
+    }
+  }
+  scan(startPath, 0);
+  return projects.sort();
+}
+function findUnityProjectInParents(startPath) {
   let currentPath = startPath;
   while (true) {
-    const hasAssets = (0, import_fs.existsSync)((0, import_path.join)(currentPath, "Assets"));
-    const hasProjectSettings = (0, import_fs.existsSync)((0, import_path.join)(currentPath, "ProjectSettings"));
-    if (hasAssets && hasProjectSettings) {
+    if (isUnityProjectWithUloop(currentPath)) {
       return currentPath;
     }
+    const isGitRoot = (0, import_fs.existsSync)((0, import_path.join)(currentPath, ".git"));
+    if (isGitRoot) {
+      return null;
+    }
     const parentPath = (0, import_path.dirname)(currentPath);
     if (parentPath === currentPath) {
       return null;
@@ -5575,6 +5628,21 @@ function findUnityProjectRoot(startPath = process.cwd()) {
     currentPath = parentPath;
   }
 }
+function findUnityProjectRoot(startPath = process.cwd()) {
+  const childProjects = findUnityProjectsInChildren(startPath, CHILD_SEARCH_MAX_DEPTH);
+  if (childProjects.length > 0) {
+    if (childProjects.length > 1) {
+      console.error("\x1B[33mWarning: Multiple Unity projects found in child directories:\x1B[0m");
+      for (const project of childProjects) {
+        console.error(`  - ${project}`);
+      }
+      console.error(`\x1B[33mUsing: ${childProjects[0]}\x1B[0m`);
+      console.error("");
+    }
+    return childProjects[0];
+  }
+  return findUnityProjectInParents(startPath);
+}
 
 // src/port-resolver.ts
 var DEFAULT_PORT = 8700;
@@ -5582,18 +5650,21 @@ async function resolveUnityPort(explicitPort) {
   if (explicitPort !== void 0) {
     return explicitPort;
   }
-  const settingsPort = await readPortFromSettings();
+  const projectRoot = findUnityProjectRoot();
+  if (projectRoot === null) {
+    throw new Error("Unity project not found. Use --port option to specify the port explicitly.");
+  }
+  const settingsPort = await readPortFromSettings(projectRoot);
   if (settingsPort !== null) {
     return settingsPort;
   }
   return DEFAULT_PORT;
 }
-async function readPortFromSettings() {
-  const projectRoot = findUnityProjectRoot();
-  if (projectRoot === null) {
+async function readPortFromSettings(projectRoot) {
+  const settingsPath = (0, import_path2.join)(projectRoot, "UserSettings/UnityMcpSettings.json");
+  if (!(0, import_fs2.existsSync)(settingsPath)) {
     return null;
   }
-  const settingsPath = (0, import_path2.join)(projectRoot, "UserSettings/UnityMcpSettings.json");
   let content;
   try {
     content = await (0, import_promises.readFile)(settingsPath, "utf-8");
@@ -5616,12 +5687,12 @@ async function readPortFromSettings() {
 }
 
 // src/tool-cache.ts
-var import_fs2 = require("fs");
+var import_fs3 = require("fs");
 var import_path3 = require("path");
 
 // src/default-tools.json
 var default_tools_default = {
-  version: "0.51.0",
+  version: "0.53.0",
   tools: [
     {
       name: "compile",
@@ -6028,9 +6099,9 @@ function getDefaultTools() {
 }
 function loadToolsCache() {
   const cachePath = getCachePath();
-  if ((0, import_fs2.existsSync)(cachePath)) {
+  if ((0, import_fs3.existsSync)(cachePath)) {
     try {
-      const content = (0, import_fs2.readFileSync)(cachePath, "utf-8");
+      const content = (0, import_fs3.readFileSync)(cachePath, "utf-8");
       return JSON.parse(content);
     } catch {
       return getDefaultTools();
@@ -6041,18 +6112,18 @@ function loadToolsCache() {
 function saveToolsCache(cache) {
   const cacheDir = getCacheDir();
   const cachePath = getCachePath();
-  if (!(0, import_fs2.existsSync)(cacheDir)) {
-    (0, import_fs2.mkdirSync)(cacheDir, { recursive: true });
+  if (!(0, import_fs3.existsSync)(cacheDir)) {
+    (0, import_fs3.mkdirSync)(cacheDir, { recursive: true });
   }
   const content = JSON.stringify(cache, null, 2);
-  (0, import_fs2.writeFileSync)(cachePath, content, "utf-8");
+  (0, import_fs3.writeFileSync)(cachePath, content, "utf-8");
 }
 function getCacheFilePath() {
   return getCachePath();
 }
 
 // src/version.ts
-var VERSION = "0.51.0";
+var VERSION = "0.53.0";
 
 // src/spinner.ts
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -6156,15 +6227,15 @@ function checkUnityBusyState() {
     return;
   }
   const compilingLock = (0, import_path4.join)(projectRoot, "Temp", "compiling.lock");
-  if ((0, import_fs3.existsSync)(compilingLock)) {
+  if ((0, import_fs4.existsSync)(compilingLock)) {
     throw new Error("UNITY_COMPILING");
   }
   const domainReloadLock = (0, import_path4.join)(projectRoot, "Temp", "domainreload.lock");
-  if ((0, import_fs3.existsSync)(domainReloadLock)) {
+  if ((0, import_fs4.existsSync)(domainReloadLock)) {
     throw new Error("UNITY_DOMAIN_RELOAD");
   }
   const serverStartingLock = (0, import_path4.join)(projectRoot, "Temp", "serverstarting.lock");
-  if ((0, import_fs3.existsSync)(serverStartingLock)) {
+  if ((0, import_fs4.existsSync)(serverStartingLock)) {
     throw new Error("UNITY_SERVER_STARTING");
   }
 }
@@ -6339,7 +6410,7 @@ function pascalToKebabCase(pascal) {
 }
 
 // src/skills/skills-manager.ts
-var import_fs4 = require("fs");
+var import_fs5 = require("fs");
 var import_path5 = require("path");
 var import_os = require("os");
 
@@ -6356,7 +6427,7 @@ var SKILL_default3 = '---\nname: uloop-compile\ndescription: Compile Unity proje
 var SKILL_default4 = "---\nname: uloop-control-play-mode\ndescription: Control Unity Editor play mode via uloop CLI. Use when you need to: (1) Start play mode for testing, (2) Stop play mode after testing, (3) Pause play mode for debugging.\n---\n\n# uloop control-play-mode\n\nControl Unity Editor play mode (play/stop/pause).\n\n## Usage\n\n```bash\nuloop control-play-mode [options]\n```\n\n## Parameters\n\n| Parameter | Type | Default | Description |\n|-----------|------|---------|-------------|\n| `--action` | string | `Play` | Action to perform: `Play`, `Stop`, `Pause` |\n\n## Examples\n\n```bash\n# Start play mode\nuloop control-play-mode --action Play\n\n# Stop play mode\nuloop control-play-mode --action Stop\n\n# Pause play mode\nuloop control-play-mode --action Pause\n```\n\n## Output\n\nReturns JSON with the current play mode state:\n- `IsPlaying`: Whether Unity is currently in play mode\n- `IsPaused`: Whether play mode is paused\n- `Message`: Description of the action performed\n\n## Notes\n\n- Play action starts the game in the Unity Editor (also resumes from pause)\n- Stop action exits play mode and returns to edit mode\n- Pause action pauses the game while remaining in play mode\n- Useful for automated testing workflows\n";
 
 // ../Editor/Api/McpTools/ExecuteDynamicCode/SKILL.md
-var SKILL_default5 = "---\nname: uloop-execute-dynamic-code\ndescription: Execute C# code dynamically in Unity Editor via uloop CLI. Use for editor automation: (1) Prefab/material wiring and AddComponent operations, (2) Reference wiring with SerializedObject, (3) Scene/hierarchy edits and batch operations. NOT for file I/O or script authoring.\n---\n\n# uloop execute-dynamic-code\n\nExecute C# code dynamically in Unity Editor.\n\n## Usage\n\n```bash\nuloop execute-dynamic-code --code '<c# code>'\n```\n\n## Parameters\n\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| `--code` | string | C# code to execute (direct statements, no class wrapper) |\n| `--compile-only` | boolean | Compile without execution |\n| `--auto-qualify-unity-types-once` | boolean | Auto-qualify Unity types |\n\n## Code Format\n\nWrite direct statements only (no classes/namespaces/methods). Return is optional.\n\n```csharp\n// Using directives at top are hoisted\nusing UnityEngine;\nvar x = Mathf.PI;\nreturn x;\n```\n\n## String Literals (Shell-specific)\n\n| Shell | Method |\n|-------|--------|\n| bash/zsh/MINGW64/Git Bash | `'Debug.Log(\"Hello!\");'` |\n| PowerShell | `'Debug.Log(\"\"Hello!\"\");'` |\n\n## Allowed Operations\n\n- Prefab/material wiring (PrefabUtility)\n- AddComponent + reference wiring (SerializedObject)\n- Scene/hierarchy edits\n- Inspector modifications\n\n## Forbidden Operations\n\n- System.IO.* (File/Directory/Path)\n- AssetDatabase.CreateFolder / file writes\n- Create/edit .cs/.asmdef files\n\n## Examples\n\n### bash / zsh / MINGW64 / Git Bash\n\n```bash\nuloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'\nuloop execute-dynamic-code --code 'new GameObject(\"MyObject\");'\nuloop execute-dynamic-code --code 'UnityEngine.Debug.Log(\"Hello from CLI!\");'\n```\n\n### PowerShell\n\n```powershell\nuloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'\nuloop execute-dynamic-code --code 'new GameObject(\"\"MyObject\"\");'\nuloop execute-dynamic-code --code 'UnityEngine.Debug.Log(\"\"Hello from CLI!\"\");'\n```\n\n## Output\n\nReturns JSON with execution result or compile errors.\n\n## Notes\n\nFor file/directory operations, use terminal commands instead.\n";
+var SKILL_default5 = "---\nname: uloop-execute-dynamic-code\ndescription: Execute C# code dynamically in Unity Editor via uloop CLI. Use for editor automation: (1) Prefab/material wiring and AddComponent operations, (2) Reference wiring with SerializedObject, (3) Scene/hierarchy edits and batch operations. NOT for file I/O or script authoring.\n---\n\n# uloop execute-dynamic-code\n\nExecute C# code dynamically in Unity Editor.\n\n## Usage\n\n```bash\nuloop execute-dynamic-code --code '<c# code>'\n```\n\n## Parameters\n\n| Parameter | Type | Description |\n|-----------|------|-------------|\n| `--code` | string | C# code to execute (direct statements, no class wrapper) |\n| `--compile-only` | boolean | Compile without execution |\n| `--auto-qualify-unity-types-once` | boolean | Auto-qualify Unity types |\n\n## Code Format\n\nWrite direct statements only (no classes/namespaces/methods). Return is optional.\n\n```csharp\n// Using directives at top are hoisted\nusing UnityEngine;\nvar x = Mathf.PI;\nreturn x;\n```\n\n## String Literals (Shell-specific)\n\n| Shell | Method |\n|-------|--------|\n| bash/zsh/MINGW64/Git Bash | `'Debug.Log(\"Hello!\");'` |\n| PowerShell | `'Debug.Log(\"\"Hello!\"\");'` |\n\n## Allowed Operations\n\n- Prefab/material wiring (PrefabUtility)\n- AddComponent + reference wiring (SerializedObject)\n- Scene/hierarchy edits\n- Inspector modifications\n\n## Forbidden Operations\n\n- System.IO.* (File/Directory/Path)\n- AssetDatabase.CreateFolder / file writes\n- Create/edit .cs/.asmdef files\n\n## Examples\n\n### bash / zsh / MINGW64 / Git Bash\n\n```bash\nuloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'\nuloop execute-dynamic-code --code 'new GameObject(\"MyObject\");'\nuloop execute-dynamic-code --code 'UnityEngine.Debug.Log(\"Hello from CLI!\");'\n```\n\n### PowerShell\n\n```powershell\nuloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'\nuloop execute-dynamic-code --code 'new GameObject(\"\"MyObject\"\");'\nuloop execute-dynamic-code --code 'UnityEngine.Debug.Log(\"\"Hello from CLI!\"\");'\n```\n\n## Output\n\nReturns JSON with execution result or compile errors.\n\n## Notes\n\nFor file/directory operations, use terminal commands instead.\n\n## Code Examples by Category\n\nFor detailed code examples, refer to these files:\n\n- **Prefab operations**: See [examples/prefab-operations.md](examples/prefab-operations.md)\n  - Create prefabs, instantiate, add components, modify properties\n- **Material operations**: See [examples/material-operations.md](examples/material-operations.md)\n  - Create materials, set shaders/textures, modify properties\n- **Asset operations**: See [examples/asset-operations.md](examples/asset-operations.md)\n  - Find/search assets, duplicate, move, rename, load\n- **ScriptableObject**: See [examples/scriptableobject.md](examples/scriptableobject.md)\n  - Create ScriptableObjects, modify with SerializedObject\n- **Scene operations**: See [examples/scene-operations.md](examples/scene-operations.md)\n  - Create/modify GameObjects, set parents, wire references, load scenes\n";
 
 // ../Editor/Api/McpTools/ExecuteMenuItem/SKILL.md
 var SKILL_default6 = '---\nname: uloop-execute-menu-item\ndescription: Execute Unity MenuItem via uloop CLI. Use when you need to: (1) Trigger menu commands programmatically, (2) Automate editor actions (save, build, refresh), (3) Run custom menu items defined in scripts.\n---\n\n# uloop execute-menu-item\n\nExecute Unity MenuItem.\n\n## Usage\n\n```bash\nuloop execute-menu-item --menu-item-path "<path>"\n```\n\n## Parameters\n\n| Parameter | Type | Default | Description |\n|-----------|------|---------|-------------|\n| `--menu-item-path` | string | - | Menu item path (e.g., "GameObject/Create Empty") |\n| `--use-reflection-fallback` | boolean | `true` | Use reflection fallback |\n\n## Examples\n\n```bash\n# Create empty GameObject\nuloop execute-menu-item --menu-item-path "GameObject/Create Empty"\n\n# Save scene\nuloop execute-menu-item --menu-item-path "File/Save"\n\n# Open project settings\nuloop execute-menu-item --menu-item-path "Edit/Project Settings..."\n```\n\n## Output\n\nReturns JSON with execution result.\n\n## Notes\n\n- Use `uloop get-menu-items` to discover available menu paths\n- Some menu items may require specific context or selection\n';
@@ -6410,175 +6481,2416 @@ var BUNDLED_SKILLS = [
   {
     name: "uloop-execute-dynamic-code",
     dirName: "uloop-execute-dynamic-code",
-    content: SKILL_default5
-  },
-  {
-    name: "uloop-execute-menu-item",
-    dirName: "uloop-execute-menu-item",
-    content: SKILL_default6
-  },
-  {
-    name: "uloop-find-game-objects",
-    dirName: "uloop-find-game-objects",
-    content: SKILL_default7
-  },
-  {
-    name: "uloop-focus-window",
-    dirName: "uloop-focus-window",
-    content: SKILL_default8
-  },
-  {
-    name: "uloop-get-hierarchy",
-    dirName: "uloop-get-hierarchy",
-    content: SKILL_default9
-  },
-  {
-    name: "uloop-get-logs",
-    dirName: "uloop-get-logs",
-    content: SKILL_default10
-  },
-  {
-    name: "uloop-get-menu-items",
-    dirName: "uloop-get-menu-items",
-    content: SKILL_default11
-  },
-  {
-    name: "uloop-get-provider-details",
-    dirName: "uloop-get-provider-details",
-    content: SKILL_default12
-  },
-  {
-    name: "uloop-run-tests",
-    dirName: "uloop-run-tests",
-    content: SKILL_default13
-  },
-  {
-    name: "uloop-unity-search",
-    dirName: "uloop-unity-search",
-    content: SKILL_default14
-  }
-];
+    content: SKILL_default5,
+    additionalFiles: {
+      "examples/asset-operations.md": `# Asset Operations
 
-// src/skills/skills-manager.ts
-var EXCLUDED_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "Temp", "obj", "Build", "Builds", "Logs"]);
-function getGlobalSkillsDir(target) {
-  return (0, import_path5.join)((0, import_os.homedir)(), target.projectDir, "skills");
+Code examples for AssetDatabase operations using \`execute-dynamic-code\`.
+
+## Find Assets by Type
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string[] prefabGuids = AssetDatabase.FindAssets("t:Prefab");
+List<string> paths = new List<string>();
+
+foreach (string guid in prefabGuids)
+{
+    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
 }
-function getProjectSkillsDir(target) {
-  return (0, import_path5.join)(process.cwd(), target.projectDir, "skills");
+return $"Found {paths.Count} prefabs";
+\`\`\`
+
+## Find Assets by Name
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string searchName = "Player";
+string[] guids = AssetDatabase.FindAssets(searchName);
+List<string> paths = new List<string>();
+
+foreach (string guid in guids)
+{
+    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
 }
-function getSkillPath(skillDirName, target, global) {
-  const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
-  return (0, import_path5.join)(baseDir, skillDirName, target.skillFileName);
+return $"Found {paths.Count} assets matching '{searchName}'";
+\`\`\`
+
+## Find Assets in Folder
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string folder = "Assets/Prefabs";
+string[] guids = AssetDatabase.FindAssets("t:Prefab", new[] { folder });
+List<string> paths = new List<string>();
+
+foreach (string guid in guids)
+{
+    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
 }
-function isSkillInstalled(skill, target, global) {
-  const skillPath = getSkillPath(skill.dirName, target, global);
-  return (0, import_fs4.existsSync)(skillPath);
+return $"Found {paths.Count} prefabs in {folder}";
+\`\`\`
+
+## Duplicate Asset
+
+\`\`\`csharp
+using UnityEditor;
+
+string sourcePath = "Assets/Materials/MyMaterial.mat";
+string destPath = "Assets/Materials/MyMaterial_Backup.mat";
+
+bool success = AssetDatabase.CopyAsset(sourcePath, destPath);
+return success ? $"Copied to {destPath}" : "Copy failed";
+\`\`\`
+
+## Move Asset
+
+\`\`\`csharp
+using UnityEditor;
+
+string sourcePath = "Assets/OldFolder/MyAsset.asset";
+string destPath = "Assets/NewFolder/MyAsset.asset";
+
+string error = AssetDatabase.MoveAsset(sourcePath, destPath);
+return string.IsNullOrEmpty(error) ? $"Moved to {destPath}" : $"Error: {error}";
+\`\`\`
+
+## Rename Asset
+
+\`\`\`csharp
+using UnityEditor;
+
+string assetPath = "Assets/Materials/OldName.mat";
+string newName = "NewName";
+
+string error = AssetDatabase.RenameAsset(assetPath, newName);
+return string.IsNullOrEmpty(error) ? $"Renamed to {newName}" : $"Error: {error}";
+\`\`\`
+
+## Rename Asset (Undo-supported)
+
+\`\`\`csharp
+using UnityEditor;
+
+// ObjectNames.SetNameSmart() supports Undo (AssetDatabase.RenameAsset() does NOT)
+Object selected = Selection.activeObject;
+if (selected == null)
+{
+    return "No asset selected";
 }
-function isSkillOutdated(skill, target, global) {
-  const skillPath = getSkillPath(skill.dirName, target, global);
-  if (!(0, import_fs4.existsSync)(skillPath)) {
-    return false;
-  }
-  const installedContent = (0, import_fs4.readFileSync)(skillPath, "utf-8");
-  return installedContent !== skill.content;
+
+string oldName = selected.name;
+ObjectNames.SetNameSmart(selected, "NewName");
+AssetDatabase.SaveAssets();
+return $"Renamed {oldName} to {selected.name}";
+\`\`\`
+
+## Get Asset Path from Object
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No object selected";
 }
-function getSkillStatus(skill, target, global) {
-  if (!isSkillInstalled(skill, target, global)) {
-    return "not_installed";
-  }
-  if (isSkillOutdated(skill, target, global)) {
-    return "outdated";
-  }
-  return "installed";
+
+string path = AssetDatabase.GetAssetPath(selected);
+if (string.IsNullOrEmpty(path))
+{
+    return "Selected object is not an asset (scene object)";
 }
-function parseFrontmatter(content) {
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!frontmatterMatch) {
-    return {};
-  }
-  const frontmatter = {};
-  const lines = frontmatterMatch[1].split("\n");
-  for (const line of lines) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1) {
-      continue;
-    }
-    const key = line.slice(0, colonIndex).trim();
-    const value = line.slice(colonIndex + 1).trim();
-    if (value === "true") {
-      frontmatter[key] = true;
-    } else if (value === "false") {
-      frontmatter[key] = false;
-    } else {
-      frontmatter[key] = value;
-    }
-  }
-  return frontmatter;
+return $"Asset path: {path}";
+\`\`\`
+
+## Load Asset at Path
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Prefabs/Player.prefab";
+GameObject asset = AssetDatabase.LoadAssetAtPath<GameObject>(path);
+
+if (asset == null)
+{
+    return $"Asset not found at {path}";
 }
-function scanEditorFolderForSkills(editorPath, skills) {
-  if (!(0, import_fs4.existsSync)(editorPath)) {
-    return;
-  }
-  const entries = (0, import_fs4.readdirSync)(editorPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (EXCLUDED_DIRS.has(entry.name)) {
-      continue;
-    }
-    const fullPath = (0, import_path5.join)(editorPath, entry.name);
-    if (entry.isDirectory()) {
-      const skillMdPath = (0, import_path5.join)(fullPath, "SKILL.md");
-      if ((0, import_fs4.existsSync)(skillMdPath)) {
-        const content = (0, import_fs4.readFileSync)(skillMdPath, "utf-8");
-        const frontmatter = parseFrontmatter(content);
-        if (frontmatter.internal === true) {
-          continue;
-        }
-        const name = typeof frontmatter.name === "string" ? frontmatter.name : entry.name;
-        skills.push({
-          name,
-          dirName: name,
-          content,
-          sourcePath: skillMdPath
-        });
-      }
-      scanEditorFolderForSkills(fullPath, skills);
+return $"Loaded: {asset.name}";
+\`\`\`
+
+## Get All Assets of Type
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] scriptGuids = AssetDatabase.FindAssets("t:MonoScript");
+int count = 0;
+
+foreach (string guid in scriptGuids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    if (path.StartsWith("Assets/"))
+    {
+        count++;
     }
-  }
 }
-function findEditorFolders(basePath, maxDepth = 2) {
-  const editorFolders = [];
-  function scan(currentPath, depth) {
-    if (depth > maxDepth || !(0, import_fs4.existsSync)(currentPath)) {
-      return;
-    }
-    const entries = (0, import_fs4.readdirSync)(currentPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (!entry.isDirectory() || EXCLUDED_DIRS.has(entry.name)) {
-        continue;
-      }
-      const fullPath = (0, import_path5.join)(currentPath, entry.name);
-      if (entry.name === "Editor") {
-        editorFolders.push(fullPath);
-      } else {
-        scan(fullPath, depth + 1);
-      }
+return $"Found {count} scripts in Assets folder";
+\`\`\`
+
+## Check if Asset Exists
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Prefabs/Player.prefab";
+string guid = AssetDatabase.AssetPathToGUID(path);
+
+bool exists = !string.IsNullOrEmpty(guid);
+return exists ? $"Asset exists: {path}" : $"Asset not found: {path}";
+\`\`\`
+
+## Get Asset Dependencies
+
+\`\`\`csharp
+using UnityEditor;
+
+string assetPath = "Assets/Prefabs/Player.prefab";
+string[] dependencies = AssetDatabase.GetDependencies(assetPath, true);
+
+return $"Asset has {dependencies.Length} dependencies";
+\`\`\`
+
+## Refresh AssetDatabase
+
+\`\`\`csharp
+using UnityEditor;
+
+AssetDatabase.Refresh();
+return "AssetDatabase refreshed";
+\`\`\`
+`,
+      "examples/batch-operations.md": `# Batch Operations
+
+Code examples for batch processing using \`execute-dynamic-code\`.
+
+## Batch Modify Selected Objects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Modify");
+
+foreach (GameObject obj in selected)
+{
+    Undo.RecordObject(obj.transform, "");
+    obj.transform.localScale = Vector3.one * 2;
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Scaled {selected.Length} objects (Single undo step)";
+\`\`\`
+
+## Edit Multiple Objects with SerializedObject
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+List<Transform> transforms = new List<Transform>();
+foreach (GameObject obj in selected)
+{
+    transforms.Add(obj.transform);
+}
+
+SerializedObject serializedObj = new SerializedObject(transforms.ToArray());
+SerializedProperty positionProp = serializedObj.FindProperty("m_LocalPosition");
+positionProp.vector3Value = Vector3.zero;
+serializedObj.ApplyModifiedProperties();
+
+return $"Reset position of {selected.Length} objects";
+\`\`\`
+
+## Batch Add Component
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Add Rigidbody");
+
+int addedCount = 0;
+foreach (GameObject obj in selected)
+{
+    if (obj.GetComponent<Rigidbody>() == null)
+    {
+        Undo.AddComponent<Rigidbody>(obj);
+        addedCount++;
     }
-  }
-  scan(basePath, 0);
-  return editorFolders;
 }
-function collectProjectSkills() {
-  const projectRoot = process.cwd();
-  const skills = [];
-  const seenNames = /* @__PURE__ */ new Set();
-  const searchPaths = [
-    (0, import_path5.join)(projectRoot, "Assets"),
-    (0, import_path5.join)(projectRoot, "Packages"),
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Added Rigidbody to {addedCount} objects";
+\`\`\`
+
+## Batch Process Assets with StartAssetEditing
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] guids = AssetDatabase.FindAssets("t:Material", new[] { "Assets/Materials" });
+if (guids.Length == 0)
+{
+    return "No materials found";
+}
+
+AssetDatabase.StartAssetEditing();
+
+int modified = 0;
+foreach (string guid in guids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+    if (mat != null)
+    {
+        mat.color = Color.white;
+        EditorUtility.SetDirty(mat);
+        modified++;
+    }
+}
+
+AssetDatabase.StopAssetEditing();
+AssetDatabase.SaveAssets();
+
+return $"Reset color of {modified} materials";
+\`\`\`
+
+## Batch Rename GameObjects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Rename");
+
+for (int i = 0; i < selected.Length; i++)
+{
+    Undo.RecordObject(selected[i], "");
+    selected[i].name = $"Item_{i:D3}";
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Renamed {selected.Length} objects";
+\`\`\`
+
+## Batch Set Layer
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int layer = LayerMask.NameToLayer("Default");
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Set Layer");
+
+foreach (GameObject obj in selected)
+{
+    Undo.RecordObject(obj, "");
+    obj.layer = layer;
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Set layer of {selected.Length} objects to Default";
+\`\`\`
+
+## Batch Set Tag
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Set Tag");
+
+foreach (GameObject obj in selected)
+{
+    Undo.RecordObject(obj, "");
+    obj.tag = "Enemy";
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Tagged {selected.Length} objects as Enemy";
+\`\`\`
+
+## Batch Modify ScriptableObjects
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] guids = AssetDatabase.FindAssets("t:ScriptableObject", new[] { "Assets/Data" });
+if (guids.Length == 0)
+{
+    return "No ScriptableObjects found";
+}
+
+int modified = 0;
+foreach (string guid in guids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+    if (so == null) continue;
+
+    SerializedObject serializedObj = new SerializedObject(so);
+    SerializedProperty prop = serializedObj.FindProperty("isEnabled");
+    if (prop != null)
+    {
+        prop.boolValue = true;
+        serializedObj.ApplyModifiedProperties();
+        EditorUtility.SetDirty(so);
+        modified++;
+    }
+}
+
+AssetDatabase.SaveAssets();
+return $"Enabled {modified} ScriptableObjects";
+\`\`\`
+
+## Batch Remove Component
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Remove Rigidbody");
+
+int removedCount = 0;
+foreach (GameObject obj in selected)
+{
+    Rigidbody rb = obj.GetComponent<Rigidbody>();
+    if (rb != null)
+    {
+        Undo.DestroyObjectImmediate(rb);
+        removedCount++;
+    }
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Removed Rigidbody from {removedCount} objects";
+\`\`\`
+
+## Batch Set Static Flags
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Set Static");
+
+foreach (GameObject obj in selected)
+{
+    Undo.RecordObject(obj, "");
+    GameObjectUtility.SetStaticEditorFlags(obj, StaticEditorFlags.BatchingStatic | StaticEditorFlags.OccludeeStatic);
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Set static flags on {selected.Length} objects";
+\`\`\`
+
+## Batch Process with Progress Bar
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] guids = AssetDatabase.FindAssets("t:Texture2D");
+if (guids.Length == 0)
+{
+    return "No textures found";
+}
+
+int processed = 0;
+foreach (string guid in guids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    TextureImporter importer = AssetImporter.GetAtPath(path) as TextureImporter;
+    if (importer != null && importer.maxTextureSize > 1024)
+    {
+        importer.maxTextureSize = 1024;
+        importer.SaveAndReimport();
+        processed++;
+    }
+
+    if (processed % 10 == 0)
+    {
+        EditorUtility.DisplayProgressBar("Processing Textures", path, (float)processed / guids.Length);
+    }
+}
+
+EditorUtility.ClearProgressBar();
+return $"Resized {processed} textures to max 1024";
+\`\`\`
+
+## Batch Align Objects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length < 2)
+{
+    return "Select at least 2 objects";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Align Objects");
+
+float startX = selected[0].transform.position.x;
+float spacing = 2f;
+
+for (int i = 0; i < selected.Length; i++)
+{
+    Undo.RecordObject(selected[i].transform, "");
+    Vector3 pos = selected[i].transform.position;
+    pos.x = startX + (i * spacing);
+    selected[i].transform.position = pos;
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Aligned {selected.Length} objects with {spacing}m spacing";
+\`\`\`
+
+## Batch Rename Assets (Undo-supported)
+
+\`\`\`csharp
+using UnityEditor;
+
+// ObjectNames.SetNameSmart() supports Undo (AssetDatabase.RenameAsset() does NOT)
+Object[] selected = Selection.objects;
+if (selected.Length == 0)
+{
+    return "No assets selected";
+}
+
+for (int i = 0; i < selected.Length; i++)
+{
+    string newName = $"{i:D3}_{selected[i].name}";
+    ObjectNames.SetNameSmart(selected[i], newName);
+}
+
+AssetDatabase.SaveAssets();
+return $"Renamed {selected.Length} assets";
+\`\`\`
+
+## Batch Replace Material
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+string materialPath = "Assets/Materials/NewMaterial.mat";
+Material newMat = AssetDatabase.LoadAssetAtPath<Material>(materialPath);
+if (newMat == null)
+{
+    return $"Material not found at {materialPath}";
+}
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Replace Material");
+
+int replaced = 0;
+foreach (GameObject obj in selected)
+{
+    MeshRenderer renderer = obj.GetComponent<MeshRenderer>();
+    if (renderer != null)
+    {
+        Undo.RecordObject(renderer, "");
+        renderer.sharedMaterial = newMat;
+        replaced++;
+    }
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Replaced material on {replaced} objects";
+\`\`\`
+
+`,
+      "examples/cleanup-operations.md": `# Cleanup Operations
+
+Code examples for project cleanup operations using \`execute-dynamic-code\`.
+
+## Detect Missing Scripts on GameObject
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+int missingCount = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(selected);
+return $"{selected.name} has {missingCount} missing script(s)";
+\`\`\`
+
+## Remove Missing Scripts from GameObject
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+int removedCount = GameObjectUtility.RemoveMonoBehavioursWithMissingScript(selected);
+return $"Removed {removedCount} missing script(s) from {selected.name}";
+\`\`\`
+
+## Scan Scene for Missing Scripts
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<string> objectsWithMissing = new List<string>();
+
+foreach (GameObject obj in allObjects)
+{
+    int count = GameObjectUtility.GetMonoBehavioursWithMissingScriptCount(obj);
+    if (count > 0)
+    {
+        objectsWithMissing.Add($"{obj.name} ({count})");
+    }
+}
+
+if (objectsWithMissing.Count == 0)
+{
+    return "No missing scripts found in scene";
+}
+
+return $"Objects with missing scripts: {string.Join(", ", objectsWithMissing)}";
+\`\`\`
+
+## Remove All Missing Scripts from Scene
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+int totalRemoved = 0;
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Remove All Missing Scripts");
+
+foreach (GameObject obj in allObjects)
+{
+    int removed = GameObjectUtility.RemoveMonoBehavioursWithMissingScript(obj);
+    totalRemoved += removed;
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Removed {totalRemoved} missing scripts from scene";
+\`\`\`
+
+## Detect Missing References in Component
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+List<string> missingRefs = new List<string>();
+
+Component[] components = selected.GetComponents<Component>();
+foreach (Component comp in components)
+{
+    if (comp == null) continue;
+
+    SerializedObject so = new SerializedObject(comp);
+    SerializedProperty prop = so.GetIterator();
+
+    while (prop.NextVisible(true))
+    {
+        if (prop.propertyType == SerializedPropertyType.ObjectReference)
+        {
+            if (prop.objectReferenceValue == null && prop.objectReferenceInstanceIDValue != 0)
+            {
+                missingRefs.Add($"{comp.GetType().Name}.{prop.name}");
+            }
+        }
+    }
+}
+
+if (missingRefs.Count == 0)
+{
+    return "No missing references found";
+}
+
+return $"Missing references: {string.Join(", ", missingRefs)}";
+\`\`\`
+
+## Scan Scene for Missing References
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<string> results = new List<string>();
+
+foreach (GameObject obj in allObjects)
+{
+    Component[] components = obj.GetComponents<Component>();
+    foreach (Component comp in components)
+    {
+        if (comp == null) continue;
+
+        SerializedObject so = new SerializedObject(comp);
+        SerializedProperty prop = so.GetIterator();
+
+        while (prop.NextVisible(true))
+        {
+            if (prop.propertyType == SerializedPropertyType.ObjectReference)
+            {
+                if (prop.objectReferenceValue == null && prop.objectReferenceInstanceIDValue != 0)
+                {
+                    results.Add($"{obj.name}/{comp.GetType().Name}.{prop.name}");
+                }
+            }
+        }
+    }
+}
+
+if (results.Count == 0)
+{
+    return "No missing references found in scene";
+}
+
+return $"Missing references ({results.Count}): {string.Join(", ", results.Take(10))}...";
+\`\`\`
+
+## Find Unused Materials in Project
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] materialGuids = AssetDatabase.FindAssets("t:Material");
+HashSet<string> usedMaterials = new HashSet<string>();
+
+string[] prefabGuids = AssetDatabase.FindAssets("t:Prefab");
+foreach (string guid in prefabGuids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    string[] deps = AssetDatabase.GetDependencies(path, true);
+    foreach (string dep in deps)
+    {
+        if (dep.EndsWith(".mat"))
+        {
+            usedMaterials.Add(dep);
+        }
+    }
+}
+
+List<string> unusedMaterials = new List<string>();
+foreach (string guid in materialGuids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    if (!usedMaterials.Contains(path))
+    {
+        unusedMaterials.Add(path);
+    }
+}
+
+return $"Found {unusedMaterials.Count} potentially unused materials";
+\`\`\`
+
+## Find Empty GameObjects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<string> emptyObjects = new List<string>();
+
+foreach (GameObject obj in allObjects)
+{
+    Component[] components = obj.GetComponents<Component>();
+    if (components.Length == 1 && obj.transform.childCount == 0)
+    {
+        emptyObjects.Add(obj.name);
+    }
+}
+
+if (emptyObjects.Count == 0)
+{
+    return "No empty GameObjects found";
+}
+
+return $"Empty objects ({emptyObjects.Count}): {string.Join(", ", emptyObjects.Take(20))}";
+\`\`\`
+
+## Find Duplicate Names in Hierarchy
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+Dictionary<string, int> nameCounts = new Dictionary<string, int>();
+
+foreach (GameObject obj in allObjects)
+{
+    if (nameCounts.ContainsKey(obj.name))
+    {
+        nameCounts[obj.name]++;
+    }
+    else
+    {
+        nameCounts[obj.name] = 1;
+    }
+}
+
+List<string> duplicates = new List<string>();
+foreach (KeyValuePair<string, int> kvp in nameCounts)
+{
+    if (kvp.Value > 1)
+    {
+        duplicates.Add($"{kvp.Key} ({kvp.Value})");
+    }
+}
+
+if (duplicates.Count == 0)
+{
+    return "No duplicate names found";
+}
+
+return $"Duplicate names: {string.Join(", ", duplicates.Take(15))}";
+\`\`\`
+
+## Check for Broken Prefab Instances
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<string> brokenPrefabs = new List<string>();
+
+foreach (GameObject obj in allObjects)
+{
+    if (PrefabUtility.IsPartOfPrefabInstance(obj))
+    {
+        GameObject prefabAsset = PrefabUtility.GetCorrespondingObjectFromSource(obj);
+        if (prefabAsset == null)
+        {
+            brokenPrefabs.Add(obj.name);
+        }
+    }
+}
+
+if (brokenPrefabs.Count == 0)
+{
+    return "No broken prefab instances found";
+}
+
+return $"Broken prefab instances: {string.Join(", ", brokenPrefabs)}";
+\`\`\`
+
+## Find Objects with Negative Scale
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<string> negativeScale = new List<string>();
+
+foreach (GameObject obj in allObjects)
+{
+    Vector3 scale = obj.transform.localScale;
+    if (scale.x < 0 || scale.y < 0 || scale.z < 0)
+    {
+        negativeScale.Add($"{obj.name} ({scale})");
+    }
+}
+
+if (negativeScale.Count == 0)
+{
+    return "No objects with negative scale found";
+}
+
+return $"Negative scale objects: {string.Join(", ", negativeScale.Take(10))}";
+\`\`\`
+
+## Remove Empty Parent GameObjects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Remove Empty Parents");
+
+int removedCount = 0;
+foreach (GameObject obj in allObjects)
+{
+    if (obj == null) continue;
+
+    Component[] components = obj.GetComponents<Component>();
+    if (components.Length == 1 && obj.transform.childCount == 0)
+    {
+        Undo.DestroyObjectImmediate(obj);
+        removedCount++;
+    }
+}
+
+Undo.CollapseUndoOperations(undoGroup);
+return $"Removed {removedCount} empty GameObjects";
+\`\`\`
+
+## Find Large Meshes
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] meshGuids = AssetDatabase.FindAssets("t:Mesh");
+List<string> largeMeshes = new List<string>();
+int threshold = 10000;
+
+foreach (string guid in meshGuids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    Mesh mesh = AssetDatabase.LoadAssetAtPath<Mesh>(path);
+    if (mesh != null && mesh.vertexCount > threshold)
+    {
+        largeMeshes.Add($"{path} ({mesh.vertexCount} verts)");
+    }
+}
+
+if (largeMeshes.Count == 0)
+{
+    return $"No meshes with more than {threshold} vertices found";
+}
+
+return $"Large meshes: {string.Join(", ", largeMeshes.Take(10))}";
+\`\`\`
+
+## Validate Asset References
+
+\`\`\`csharp
+using UnityEditor;
+
+string[] guids = AssetDatabase.FindAssets("t:ScriptableObject", new[] { "Assets/Data" });
+List<string> invalidRefs = new List<string>();
+
+foreach (string guid in guids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+    if (so == null) continue;
+
+    SerializedObject serializedObj = new SerializedObject(so);
+    SerializedProperty prop = serializedObj.GetIterator();
+
+    while (prop.NextVisible(true))
+    {
+        if (prop.propertyType == SerializedPropertyType.ObjectReference)
+        {
+            if (prop.objectReferenceValue == null && prop.objectReferenceInstanceIDValue != 0)
+            {
+                invalidRefs.Add($"{path}: {prop.name}");
+            }
+        }
+    }
+}
+
+if (invalidRefs.Count == 0)
+{
+    return "All asset references are valid";
+}
+
+return $"Invalid references ({invalidRefs.Count}): {string.Join(", ", invalidRefs.Take(10))}";
+\`\`\`
+
+`,
+      "examples/material-operations.md": `# Material Operations
+
+Code examples for Material operations using \`execute-dynamic-code\`.
+
+## Create a New Material
+
+\`\`\`csharp
+using UnityEditor;
+
+Shader shader = Shader.Find("Standard");
+Material mat = new Material(shader);
+mat.name = "MyMaterial";
+string path = "Assets/Materials/MyMaterial.mat";
+AssetDatabase.CreateAsset(mat, path);
+AssetDatabase.SaveAssets();
+return $"Material created at {path}";
+\`\`\`
+
+## Set Material Color
+
+\`\`\`csharp
+using UnityEditor;
+
+string matPath = "Assets/Materials/MyMaterial.mat";
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
+mat.SetColor("_Color", new Color(1f, 0.5f, 0f, 1f));
+EditorUtility.SetDirty(mat);
+AssetDatabase.SaveAssets();
+return "Material color set to orange";
+\`\`\`
+
+## Set Material Properties (Float, Vector)
+
+\`\`\`csharp
+using UnityEditor;
+
+string matPath = "Assets/Materials/MyMaterial.mat";
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
+
+mat.SetFloat("_Metallic", 0.8f);
+mat.SetFloat("_Glossiness", 0.6f);
+mat.SetVector("_EmissionColor", new Vector4(1, 1, 0, 1));
+
+EditorUtility.SetDirty(mat);
+AssetDatabase.SaveAssets();
+return "Material properties updated";
+\`\`\`
+
+## Assign Texture to Material
+
+\`\`\`csharp
+using UnityEditor;
+
+string matPath = "Assets/Materials/MyMaterial.mat";
+string texPath = "Assets/Textures/MyTexture.png";
+
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
+Texture2D tex = AssetDatabase.LoadAssetAtPath<Texture2D>(texPath);
+
+mat.SetTexture("_MainTex", tex);
+EditorUtility.SetDirty(mat);
+AssetDatabase.SaveAssets();
+return $"Assigned {tex.name} to material";
+\`\`\`
+
+## Assign Material to GameObject
+
+\`\`\`csharp
+using UnityEditor;
+
+string matPath = "Assets/Materials/MyMaterial.mat";
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Renderer renderer = selected.GetComponent<Renderer>();
+if (renderer == null)
+{
+    return "Selected object has no Renderer";
+}
+
+renderer.sharedMaterial = mat;
+EditorUtility.SetDirty(selected);
+return $"Assigned {mat.name} to {selected.name}";
+\`\`\`
+
+## Enable/Disable Material Keywords
+
+\`\`\`csharp
+using UnityEditor;
+
+string matPath = "Assets/Materials/MyMaterial.mat";
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(matPath);
+
+mat.EnableKeyword("_EMISSION");
+mat.globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
+
+EditorUtility.SetDirty(mat);
+AssetDatabase.SaveAssets();
+return "Emission enabled on material";
+\`\`\`
+
+## Find All Materials Using a Shader
+
+\`\`\`csharp
+using UnityEditor;
+
+string shaderName = "Standard";
+string[] guids = AssetDatabase.FindAssets("t:Material");
+List<string> matchingMaterials = new List<string>();
+
+foreach (string guid in guids)
+{
+    string path = AssetDatabase.GUIDToAssetPath(guid);
+    Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+    if (mat != null && mat.shader != null && mat.shader.name == shaderName)
+    {
+        matchingMaterials.Add(path);
+    }
+}
+return $"Found {matchingMaterials.Count} materials using {shaderName}";
+\`\`\`
+
+## Duplicate Material
+
+\`\`\`csharp
+using UnityEditor;
+
+string sourcePath = "Assets/Materials/MyMaterial.mat";
+string destPath = "Assets/Materials/MyMaterial_Copy.mat";
+
+Material source = AssetDatabase.LoadAssetAtPath<Material>(sourcePath);
+Material copy = new Material(source);
+AssetDatabase.CreateAsset(copy, destPath);
+AssetDatabase.SaveAssets();
+return $"Material duplicated to {destPath}";
+\`\`\`
+`,
+      "examples/prefab-operations.md": `# Prefab Operations
+
+Code examples for Prefab operations using \`execute-dynamic-code\`.
+
+## Create a Prefab from GameObject
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube.name = "MyCube";
+string path = "Assets/Prefabs/MyCube.prefab";
+PrefabUtility.SaveAsPrefabAsset(cube, path);
+Object.DestroyImmediate(cube);
+return $"Prefab created at {path}";
+\`\`\`
+
+## Instantiate a Prefab
+
+\`\`\`csharp
+using UnityEditor;
+
+string prefabPath = "Assets/Prefabs/MyCube.prefab";
+GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+if (prefab == null)
+{
+    return $"Prefab not found at {prefabPath}";
+}
+
+GameObject instance = (GameObject)PrefabUtility.InstantiatePrefab(prefab);
+instance.transform.position = new Vector3(0, 1, 0);
+return $"Instantiated {instance.name}";
+\`\`\`
+
+## Add Component to Prefab
+
+\`\`\`csharp
+using UnityEditor;
+
+string prefabPath = "Assets/Prefabs/MyCube.prefab";
+GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+string assetPath = AssetDatabase.GetAssetPath(prefab);
+
+using (PrefabUtility.EditPrefabContentsScope scope = new PrefabUtility.EditPrefabContentsScope(assetPath))
+{
+    GameObject root = scope.prefabContentsRoot;
+    if (root.GetComponent<Rigidbody>() == null)
+    {
+        root.AddComponent<Rigidbody>();
+    }
+}
+return "Added Rigidbody to prefab";
+\`\`\`
+
+## Modify Prefab Properties
+
+\`\`\`csharp
+using UnityEditor;
+
+string prefabPath = "Assets/Prefabs/MyCube.prefab";
+GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+
+using (PrefabUtility.EditPrefabContentsScope scope = new PrefabUtility.EditPrefabContentsScope(prefabPath))
+{
+    GameObject root = scope.prefabContentsRoot;
+    root.transform.localScale = new Vector3(2, 2, 2);
+
+    MeshRenderer renderer = root.GetComponent<MeshRenderer>();
+    if (renderer != null)
+    {
+        renderer.sharedMaterial.color = Color.red;
+    }
+}
+return "Modified prefab properties";
+\`\`\`
+
+## Find All Prefab Instances in Scene
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string prefabPath = "Assets/Prefabs/MyCube.prefab";
+GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+if (prefab == null)
+{
+    return $"Prefab not found at {prefabPath}";
+}
+
+List<GameObject> instances = new List<GameObject>();
+
+foreach (GameObject obj in Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None))
+{
+    if (PrefabUtility.GetCorrespondingObjectFromSource(obj) == prefab)
+    {
+        instances.Add(obj);
+    }
+}
+return $"Found {instances.Count} instances of {prefab.name}";
+\`\`\`
+
+## Apply Prefab Overrides
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+if (!PrefabUtility.IsPartOfPrefabInstance(selected))
+{
+    return "Selected object is not a prefab instance";
+}
+
+PrefabUtility.ApplyPrefabInstance(selected, InteractionMode.UserAction);
+return $"Applied overrides from {selected.name} to prefab";
+\`\`\`
+`,
+      "examples/scene-operations.md": `# Scene Operations
+
+Code examples for Scene and Hierarchy operations using \`execute-dynamic-code\`.
+
+## Create GameObject
+
+\`\`\`csharp
+GameObject obj = new GameObject("MyObject");
+obj.transform.position = new Vector3(0, 1, 0);
+return $"Created {obj.name}";
+\`\`\`
+
+## Create UI GameObject (under Canvas)
+
+\`\`\`csharp
+using UnityEngine.UI;
+
+// UI objects require RectTransform, which is auto-added when parented to Canvas
+GameObject canvas = GameObject.Find("Canvas");
+if (canvas == null)
+{
+    return "Canvas not found in scene";
+}
+
+GameObject uiObj = new GameObject("MyUIElement");
+uiObj.transform.SetParent(canvas.transform, false);
+uiObj.AddComponent<RectTransform>();
+uiObj.AddComponent<Image>();
+return $"Created UI element: {uiObj.name}";
+\`\`\`
+
+## Create Primitive
+
+\`\`\`csharp
+GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube.name = "MyCube";
+cube.transform.position = new Vector3(2, 0, 0);
+return $"Created {cube.name}";
+\`\`\`
+
+## Add Component to GameObject
+
+\`\`\`csharp
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Rigidbody rb = selected.AddComponent<Rigidbody>();
+rb.mass = 2f;
+rb.useGravity = true;
+return $"Added Rigidbody to {selected.name}";
+\`\`\`
+
+## Find GameObject by Name
+
+\`\`\`csharp
+GameObject obj = GameObject.Find("Player");
+if (obj == null)
+{
+    return "GameObject 'Player' not found";
+}
+return $"Found: {obj.name} at {obj.transform.position}";
+\`\`\`
+
+## Find GameObjects by Tag
+
+\`\`\`csharp
+GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
+return $"Found {enemies.Length} GameObjects with tag 'Enemy'";
+\`\`\`
+
+## Set Parent
+
+\`\`\`csharp
+GameObject child = GameObject.Find("Child");
+GameObject parent = GameObject.Find("Parent");
+
+if (child == null || parent == null)
+{
+    return "Child or Parent not found";
+}
+
+child.transform.SetParent(parent.transform);
+return $"Set {child.name}'s parent to {parent.name}";
+\`\`\`
+
+## Get All Children
+
+\`\`\`csharp
+GameObject parent = Selection.activeGameObject;
+if (parent == null)
+{
+    return "No GameObject selected";
+}
+
+List<string> children = new List<string>();
+foreach (Transform child in parent.transform)
+{
+    children.Add(child.name);
+}
+return $"Children: {string.Join(", ", children)}";
+\`\`\`
+
+## Wire Component References
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject player = GameObject.Find("Player");
+GameObject target = GameObject.Find("Target");
+
+if (player == null || target == null)
+{
+    return "Player or Target not found";
+}
+
+MonoBehaviour script = player.GetComponent("PlayerController") as MonoBehaviour;
+if (script == null)
+{
+    return "PlayerController not found on Player";
+}
+
+SerializedObject serializedScript = new SerializedObject(script);
+SerializedProperty targetProp = serializedScript.FindProperty("target");
+
+if (targetProp != null)
+{
+    targetProp.objectReferenceValue = target.transform;
+    serializedScript.ApplyModifiedProperties();
+    return "Target reference wired";
+}
+return "Property 'target' not found";
+\`\`\`
+
+## Load Scene (Editor)
+
+\`\`\`csharp
+using UnityEditor.SceneManagement;
+
+string scenePath = "Assets/Scenes/MainMenu.unity";
+EditorSceneManager.OpenScene(scenePath, OpenSceneMode.Single);
+return $"Loaded scene: {scenePath}";
+\`\`\`
+
+## Save Current Scene
+
+\`\`\`csharp
+using UnityEditor.SceneManagement;
+
+UnityEngine.SceneManagement.Scene scene = EditorSceneManager.GetActiveScene();
+EditorSceneManager.SaveScene(scene);
+return $"Saved scene: {scene.name}";
+\`\`\`
+
+## Create New Scene
+
+\`\`\`csharp
+using UnityEditor.SceneManagement;
+
+UnityEngine.SceneManagement.Scene newScene = EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
+return $"Created new scene: {newScene.name}";
+\`\`\`
+
+## Get All Root GameObjects in Scene
+
+\`\`\`csharp
+UnityEngine.SceneManagement.Scene scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+GameObject[] roots = scene.GetRootGameObjects();
+
+List<string> names = new List<string>();
+foreach (GameObject root in roots)
+{
+    names.Add(root.name);
+}
+return $"Root objects: {string.Join(", ", names)}";
+\`\`\`
+
+## Destroy GameObject
+
+\`\`\`csharp
+GameObject obj = GameObject.Find("OldObject");
+if (obj == null)
+{
+    return "GameObject not found";
+}
+
+Object.DestroyImmediate(obj);
+return "GameObject destroyed";
+\`\`\`
+
+## Duplicate GameObject
+
+\`\`\`csharp
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+GameObject copy = Object.Instantiate(selected);
+copy.name = selected.name + "_Copy";
+copy.transform.position = selected.transform.position + Vector3.right * 2;
+return $"Created duplicate: {copy.name}";
+\`\`\`
+
+## Set Active/Inactive
+
+\`\`\`csharp
+GameObject obj = GameObject.Find("MyObject");
+if (obj == null)
+{
+    return "GameObject not found";
+}
+
+obj.SetActive(!obj.activeSelf);
+return $"{obj.name} is now {(obj.activeSelf ? "active" : "inactive")}";
+\`\`\`
+
+## Modify Transform
+
+\`\`\`csharp
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+selected.transform.position = new Vector3(0, 5, 0);
+selected.transform.rotation = Quaternion.Euler(0, 45, 0);
+selected.transform.localScale = new Vector3(2, 2, 2);
+return "Transform modified";
+\`\`\`
+`,
+      "examples/scriptableobject.md": `# ScriptableObject Operations
+
+Code examples for ScriptableObject operations using \`execute-dynamic-code\`.
+
+## Create ScriptableObject Instance
+
+\`\`\`csharp
+using UnityEditor;
+
+ScriptableObject so = ScriptableObject.CreateInstance<ScriptableObject>();
+string path = "Assets/Data/MyData.asset";
+AssetDatabase.CreateAsset(so, path);
+AssetDatabase.SaveAssets();
+return $"ScriptableObject created at {path}";
+\`\`\`
+
+## Create Custom ScriptableObject
+
+\`\`\`csharp
+using UnityEditor;
+
+ScriptableObject so = ScriptableObject.CreateInstance("MyCustomSO");
+if (so == null)
+{
+    return "Type 'MyCustomSO' not found. Ensure the class exists.";
+}
+
+string path = "Assets/Data/MyCustomData.asset";
+AssetDatabase.CreateAsset(so, path);
+AssetDatabase.SaveAssets();
+return $"Created {so.GetType().Name} at {path}";
+\`\`\`
+
+## Modify ScriptableObject with SerializedObject
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Data/MyData.asset";
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+
+if (so == null)
+{
+    return $"Asset not found at {path}";
+}
+
+SerializedObject serializedObj = new SerializedObject(so);
+SerializedProperty prop = serializedObj.FindProperty("myField");
+
+if (prop != null)
+{
+    prop.stringValue = "New Value";
+    serializedObj.ApplyModifiedProperties();
+    EditorUtility.SetDirty(so);
+    AssetDatabase.SaveAssets();
+    return "Property updated";
+}
+return "Property 'myField' not found";
+\`\`\`
+
+## Set Int/Float/Bool Properties
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Data/GameSettings.asset";
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+
+SerializedObject serializedObj = new SerializedObject(so);
+
+SerializedProperty intProp = serializedObj.FindProperty("maxHealth");
+if (intProp != null) intProp.intValue = 100;
+
+SerializedProperty floatProp = serializedObj.FindProperty("moveSpeed");
+if (floatProp != null) floatProp.floatValue = 5.5f;
+
+SerializedProperty boolProp = serializedObj.FindProperty("isEnabled");
+if (boolProp != null) boolProp.boolValue = true;
+
+serializedObj.ApplyModifiedProperties();
+EditorUtility.SetDirty(so);
+AssetDatabase.SaveAssets();
+return "Properties updated";
+\`\`\`
+
+## Set Reference Properties
+
+\`\`\`csharp
+using UnityEditor;
+
+string soPath = "Assets/Data/CharacterData.asset";
+string prefabPath = "Assets/Prefabs/Player.prefab";
+
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(soPath);
+GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+
+if (so == null)
+{
+    return $"ScriptableObject not found at {soPath}";
+}
+if (prefab == null)
+{
+    return $"Prefab not found at {prefabPath}";
+}
+
+SerializedObject serializedObj = new SerializedObject(so);
+SerializedProperty prop = serializedObj.FindProperty("playerPrefab");
+
+if (prop != null)
+{
+    prop.objectReferenceValue = prefab;
+    serializedObj.ApplyModifiedProperties();
+    EditorUtility.SetDirty(so);
+    AssetDatabase.SaveAssets();
+    return "Reference set successfully";
+}
+return "Property not found";
+\`\`\`
+
+## Set Array/List Properties
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Data/ItemDatabase.asset";
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+
+if (so == null)
+{
+    return $"Asset not found at {path}";
+}
+
+SerializedObject serializedObj = new SerializedObject(so);
+SerializedProperty arrayProp = serializedObj.FindProperty("items");
+
+if (arrayProp != null && arrayProp.isArray)
+{
+    arrayProp.ClearArray();
+    arrayProp.InsertArrayElementAtIndex(0);
+    arrayProp.GetArrayElementAtIndex(0).stringValue = "Sword";
+    arrayProp.InsertArrayElementAtIndex(1);
+    arrayProp.GetArrayElementAtIndex(1).stringValue = "Shield";
+
+    serializedObj.ApplyModifiedProperties();
+    EditorUtility.SetDirty(so);
+    AssetDatabase.SaveAssets();
+    return "Array updated with 2 items";
+}
+return "Array property not found";
+\`\`\`
+
+## Find All ScriptableObjects of Type
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string typeName = "GameSettings";
+string[] guids = AssetDatabase.FindAssets($"t:{typeName}");
+List<string> paths = new List<string>();
+
+foreach (string guid in guids)
+{
+    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
+}
+return $"Found {paths.Count} {typeName} assets";
+\`\`\`
+
+## Duplicate ScriptableObject
+
+\`\`\`csharp
+using UnityEditor;
+
+string sourcePath = "Assets/Data/Template.asset";
+string destPath = "Assets/Data/NewInstance.asset";
+
+ScriptableObject source = AssetDatabase.LoadAssetAtPath<ScriptableObject>(sourcePath);
+if (source == null)
+{
+    return $"Source asset not found at {sourcePath}";
+}
+
+ScriptableObject copy = Object.Instantiate(source);
+AssetDatabase.CreateAsset(copy, destPath);
+AssetDatabase.SaveAssets();
+return $"Duplicated to {destPath}";
+\`\`\`
+
+## List All Properties of ScriptableObject
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string path = "Assets/Data/MyData.asset";
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+
+if (so == null)
+{
+    return $"Asset not found at {path}";
+}
+
+SerializedObject serializedObj = new SerializedObject(so);
+SerializedProperty prop = serializedObj.GetIterator();
+
+List<string> properties = new List<string>();
+while (prop.NextVisible(true))
+{
+    properties.Add($"{prop.name} ({prop.propertyType})");
+}
+return string.Join(", ", properties);
+\`\`\`
+`,
+      "examples/selection-operations.md": `# Selection Operations
+
+Code examples for Selection operations using \`execute-dynamic-code\`.
+
+## Get Selected GameObjects
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+GameObject[] selected = Selection.gameObjects;
+if (selected.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+List<string> names = new List<string>();
+foreach (GameObject obj in selected)
+{
+    names.Add(obj.name);
+}
+return $"Selected: {string.Join(", ", names)}";
+\`\`\`
+
+## Get Active (Last Selected) GameObject
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject active = Selection.activeGameObject;
+if (active == null)
+{
+    return "No active GameObject";
+}
+return $"Active: {active.name}";
+\`\`\`
+
+## Set Selection Programmatically
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject obj = GameObject.Find("Player");
+if (obj == null)
+{
+    return "GameObject 'Player' not found";
+}
+
+Selection.activeGameObject = obj;
+return $"Selected {obj.name}";
+\`\`\`
+
+## Select Multiple GameObjects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] enemies = GameObject.FindGameObjectsWithTag("Enemy");
+if (enemies.Length == 0)
+{
+    return "No enemies found";
+}
+
+Selection.objects = enemies;
+return $"Selected {enemies.Length} enemies";
+\`\`\`
+
+## Get Top-Level Transforms Only
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+Transform[] transforms = Selection.GetTransforms(SelectionMode.TopLevel);
+if (transforms.Length == 0)
+{
+    return "No transforms selected";
+}
+
+List<string> names = new List<string>();
+foreach (Transform t in transforms)
+{
+    names.Add(t.name);
+}
+return $"Top-level: {string.Join(", ", names)}";
+\`\`\`
+
+## Get Deep Selection (Including Children)
+
+\`\`\`csharp
+using UnityEditor;
+
+Transform[] transforms = Selection.GetTransforms(SelectionMode.Deep);
+if (transforms.Length == 0)
+{
+    return "No transforms selected";
+}
+
+return $"Deep selection count: {transforms.Length}";
+\`\`\`
+
+## Get Editable Objects Only
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+Transform[] transforms = Selection.GetTransforms(SelectionMode.Editable);
+if (transforms.Length == 0)
+{
+    return "No editable transforms selected";
+}
+
+List<string> names = new List<string>();
+foreach (Transform t in transforms)
+{
+    names.Add(t.name);
+}
+return $"Editable: {string.Join(", ", names)}";
+\`\`\`
+
+## Get Selected Assets
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+Object[] selectedAssets = Selection.GetFiltered<Object>(SelectionMode.Assets);
+if (selectedAssets.Length == 0)
+{
+    return "No assets selected";
+}
+
+List<string> paths = new List<string>();
+foreach (Object asset in selectedAssets)
+{
+    paths.Add(AssetDatabase.GetAssetPath(asset));
+}
+return $"Assets: {string.Join(", ", paths)}";
+\`\`\`
+
+## Get Selected Asset GUIDs
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+string[] guids = Selection.assetGUIDs;
+if (guids.Length == 0)
+{
+    return "No assets selected";
+}
+
+List<string> paths = new List<string>();
+foreach (string guid in guids)
+{
+    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
+}
+return $"Selected assets: {string.Join(", ", paths)}";
+\`\`\`
+
+## Select All Children of Selected Object
+
+\`\`\`csharp
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+
+GameObject parent = Selection.activeGameObject;
+if (parent == null)
+{
+    return "No GameObject selected";
+}
+
+List<GameObject> children = new List<GameObject>();
+foreach (Transform child in parent.GetComponentsInChildren<Transform>())
+{
+    if (child != parent.transform)
+    {
+        children.Add(child.gameObject);
+    }
+}
+
+if (children.Count == 0)
+{
+    return "No children found";
+}
+
+Selection.objects = children.ToArray();
+return $"Selected {children.Count} children";
+\`\`\`
+
+## Filter Selection by Component
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+GameObject[] selected = Selection.gameObjects;
+List<GameObject> withRigidbody = new List<GameObject>();
+
+foreach (GameObject obj in selected)
+{
+    if (obj.GetComponent<Rigidbody>() != null)
+    {
+        withRigidbody.Add(obj);
+    }
+}
+
+if (withRigidbody.Count == 0)
+{
+    return "No objects with Rigidbody in selection";
+}
+
+Selection.objects = withRigidbody.ToArray();
+return $"Filtered to {withRigidbody.Count} objects with Rigidbody";
+\`\`\`
+
+## Check if Object is Selected
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject player = GameObject.Find("Player");
+if (player == null)
+{
+    return "Player not found";
+}
+
+bool isSelected = Selection.Contains(player);
+return $"Player is {(isSelected ? "" : "not ")}selected";
+\`\`\`
+
+## Clear Selection
+
+\`\`\`csharp
+using UnityEditor;
+
+Selection.activeObject = null;
+return "Selection cleared";
+\`\`\`
+
+## Select Objects by Layer
+
+\`\`\`csharp
+using UnityEditor;
+using System.Collections.Generic;
+
+int layer = LayerMask.NameToLayer("UI");
+GameObject[] allObjects = Object.FindObjectsByType<GameObject>(FindObjectsSortMode.None);
+List<GameObject> layerObjects = new List<GameObject>();
+
+foreach (GameObject obj in allObjects)
+{
+    if (obj.layer == layer)
+    {
+        layerObjects.Add(obj);
+    }
+}
+
+if (layerObjects.Count == 0)
+{
+    return "No objects found on UI layer";
+}
+
+Selection.objects = layerObjects.ToArray();
+return $"Selected {layerObjects.Count} objects on UI layer";
+\`\`\`
+
+## Ping Object in Hierarchy/Project
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject obj = GameObject.Find("Player");
+if (obj == null)
+{
+    return "Player not found";
+}
+
+EditorGUIUtility.PingObject(obj);
+return $"Pinged {obj.name} in Hierarchy";
+\`\`\`
+
+## Focus on Selected Object in Scene View
+
+\`\`\`csharp
+using UnityEditor;
+
+if (Selection.activeGameObject == null)
+{
+    return "No GameObject selected";
+}
+
+SceneView.FrameLastActiveSceneView();
+return "Focused on selected object";
+\`\`\`
+
+`,
+      "examples/undo-operations.md": `# Undo Operations
+
+Code examples for Undo-supported operations using \`execute-dynamic-code\`.
+
+## Record Property Change (Undo.RecordObject)
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Undo.RecordObject(selected.transform, "Move Object");
+selected.transform.position = new Vector3(0, 5, 0);
+return $"Moved {selected.name} (Undo available)";
+\`\`\`
+
+## Record Multiple Objects
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject[] selectedObjects = Selection.gameObjects;
+if (selectedObjects.Length == 0)
+{
+    return "No GameObjects selected";
+}
+
+Object[] transforms = new Object[selectedObjects.Length];
+for (int i = 0; i < selectedObjects.Length; i++)
+{
+    transforms[i] = selectedObjects[i].transform;
+}
+
+Undo.RecordObjects(transforms, "Move Multiple Objects");
+foreach (GameObject obj in selectedObjects)
+{
+    obj.transform.position += Vector3.up * 2;
+}
+return $"Moved {selectedObjects.Length} objects (Undo available)";
+\`\`\`
+
+## Complete Object Undo (For Complex Changes)
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Undo.RegisterCompleteObjectUndo(selected, "Complete Object Change");
+selected.name = "RenamedObject";
+selected.layer = LayerMask.NameToLayer("Default");
+selected.tag = "Untagged";
+return $"Modified object completely (Undo available)";
+\`\`\`
+
+## Add Component with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Rigidbody rb = Undo.AddComponent<Rigidbody>(selected);
+rb.mass = 2f;
+rb.useGravity = true;
+return $"Added Rigidbody to {selected.name} (Undo available)";
+\`\`\`
+
+## Set Parent with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject child = GameObject.Find("Child");
+GameObject parent = GameObject.Find("Parent");
+
+if (child == null || parent == null)
+{
+    return "Child or Parent not found";
+}
+
+Undo.SetTransformParent(child.transform, parent.transform, "Set Parent");
+return $"Set {child.name}'s parent to {parent.name} (Undo available)";
+\`\`\`
+
+## Create GameObject with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube.name = "UndoableCube";
+cube.transform.position = new Vector3(0, 1, 0);
+Undo.RegisterCreatedObjectUndo(cube, "Create Cube");
+return $"Created {cube.name} (Undo available)";
+\`\`\`
+
+## Destroy GameObject with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject obj = GameObject.Find("ObjectToDelete");
+if (obj == null)
+{
+    return "GameObject not found";
+}
+
+Undo.DestroyObjectImmediate(obj);
+return "GameObject destroyed (Undo available)";
+\`\`\`
+
+## Named Undo Group
+
+\`\`\`csharp
+using UnityEditor;
+
+GameObject selected = Selection.activeGameObject;
+if (selected == null)
+{
+    return "No GameObject selected";
+}
+
+Undo.SetCurrentGroupName("Complex Transform Operation");
+
+Undo.RecordObject(selected.transform, "");
+selected.transform.position = Vector3.zero;
+selected.transform.rotation = Quaternion.identity;
+selected.transform.localScale = Vector3.one;
+
+return "Reset transform (Single undo step)";
+\`\`\`
+
+## Collapse Multiple Operations into One Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+int undoGroup = Undo.GetCurrentGroup();
+Undo.SetCurrentGroupName("Batch Operation");
+
+GameObject cube1 = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube1.name = "Cube1";
+Undo.RegisterCreatedObjectUndo(cube1, "");
+
+GameObject cube2 = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube2.name = "Cube2";
+cube2.transform.position = Vector3.right * 2;
+Undo.RegisterCreatedObjectUndo(cube2, "");
+
+GameObject cube3 = GameObject.CreatePrimitive(PrimitiveType.Cube);
+cube3.name = "Cube3";
+cube3.transform.position = Vector3.right * 4;
+Undo.RegisterCreatedObjectUndo(cube3, "");
+
+Undo.CollapseUndoOperations(undoGroup);
+return "Created 3 cubes (Single undo step)";
+\`\`\`
+
+## Modify ScriptableObject with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Data/GameSettings.asset";
+ScriptableObject so = AssetDatabase.LoadAssetAtPath<ScriptableObject>(path);
+if (so == null)
+{
+    return $"Asset not found at {path}";
+}
+
+Undo.RecordObject(so, "Modify Settings");
+SerializedObject serializedObj = new SerializedObject(so);
+SerializedProperty prop = serializedObj.FindProperty("maxHealth");
+if (prop != null)
+{
+    prop.intValue = 200;
+    serializedObj.ApplyModifiedProperties();
+}
+return "Modified ScriptableObject (Undo available)";
+\`\`\`
+
+## Modify Material with Undo
+
+\`\`\`csharp
+using UnityEditor;
+
+string path = "Assets/Materials/MyMaterial.mat";
+Material mat = AssetDatabase.LoadAssetAtPath<Material>(path);
+if (mat == null)
+{
+    return $"Material not found at {path}";
+}
+
+Undo.RecordObject(mat, "Change Material Color");
+mat.color = Color.red;
+return "Changed material color (Undo available)";
+\`\`\`
+
+`
+    }
+  },
+  {
+    name: "uloop-execute-menu-item",
+    dirName: "uloop-execute-menu-item",
+    content: SKILL_default6
+  },
+  {
+    name: "uloop-find-game-objects",
+    dirName: "uloop-find-game-objects",
+    content: SKILL_default7
+  },
+  {
+    name: "uloop-focus-window",
+    dirName: "uloop-focus-window",
+    content: SKILL_default8
+  },
+  {
+    name: "uloop-get-hierarchy",
+    dirName: "uloop-get-hierarchy",
+    content: SKILL_default9
+  },
+  {
+    name: "uloop-get-logs",
+    dirName: "uloop-get-logs",
+    content: SKILL_default10
+  },
+  {
+    name: "uloop-get-menu-items",
+    dirName: "uloop-get-menu-items",
+    content: SKILL_default11
+  },
+  {
+    name: "uloop-get-provider-details",
+    dirName: "uloop-get-provider-details",
+    content: SKILL_default12
+  },
+  {
+    name: "uloop-run-tests",
+    dirName: "uloop-run-tests",
+    content: SKILL_default13
+  },
+  {
+    name: "uloop-unity-search",
+    dirName: "uloop-unity-search",
+    content: SKILL_default14
+  }
+];
+
+// src/skills/skills-manager.ts
+var EXCLUDED_DIRS2 = /* @__PURE__ */ new Set(["node_modules", ".git", "Temp", "obj", "Build", "Builds", "Logs"]);
+function getGlobalSkillsDir(target) {
+  return (0, import_path5.join)((0, import_os.homedir)(), target.projectDir, "skills");
+}
+function getProjectSkillsDir(target) {
+  const projectRoot = findUnityProjectRoot();
+  if (!projectRoot) {
+    throw new Error(
+      "Not inside a Unity project. Run this command from within a Unity project directory."
+    );
+  }
+  return (0, import_path5.join)(projectRoot, target.projectDir, "skills");
+}
+function getSkillPath(skillDirName, target, global) {
+  const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
+  return (0, import_path5.join)(baseDir, skillDirName, target.skillFileName);
+}
+function isSkillInstalled(skill, target, global) {
+  const skillPath = getSkillPath(skill.dirName, target, global);
+  return (0, import_fs5.existsSync)(skillPath);
+}
+function isSkillOutdated(skill, target, global) {
+  const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
+  const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
+  const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
+  if (!(0, import_fs5.existsSync)(skillPath)) {
+    return false;
+  }
+  const installedContent = (0, import_fs5.readFileSync)(skillPath, "utf-8");
+  if (installedContent !== skill.content) {
+    return true;
+  }
+  if ("additionalFiles" in skill && skill.additionalFiles) {
+    const additionalFiles = skill.additionalFiles;
+    for (const [relativePath, expectedContent] of Object.entries(additionalFiles)) {
+      const filePath = (0, import_path5.join)(skillDir, relativePath);
+      if (!(0, import_fs5.existsSync)(filePath)) {
+        return true;
+      }
+      const installedFileContent = (0, import_fs5.readFileSync)(filePath, "utf-8");
+      if (installedFileContent !== expectedContent) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function getSkillStatus(skill, target, global) {
+  if (!isSkillInstalled(skill, target, global)) {
+    return "not_installed";
+  }
+  if (isSkillOutdated(skill, target, global)) {
+    return "outdated";
+  }
+  return "installed";
+}
+function parseFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return {};
+  }
+  const frontmatter = {};
+  const lines = frontmatterMatch[1].split("\n");
+  for (const line of lines) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (value === "true") {
+      frontmatter[key] = true;
+    } else if (value === "false") {
+      frontmatter[key] = false;
+    } else {
+      frontmatter[key] = value;
+    }
+  }
+  return frontmatter;
+}
+function scanEditorFolderForSkills(editorPath, skills) {
+  if (!(0, import_fs5.existsSync)(editorPath)) {
+    return;
+  }
+  const entries = (0, import_fs5.readdirSync)(editorPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (EXCLUDED_DIRS2.has(entry.name)) {
+      continue;
+    }
+    const fullPath = (0, import_path5.join)(editorPath, entry.name);
+    if (entry.isDirectory()) {
+      const skillMdPath = (0, import_path5.join)(fullPath, "SKILL.md");
+      if ((0, import_fs5.existsSync)(skillMdPath)) {
+        const content = (0, import_fs5.readFileSync)(skillMdPath, "utf-8");
+        const frontmatter = parseFrontmatter(content);
+        if (frontmatter.internal === true) {
+          continue;
+        }
+        const name = typeof frontmatter.name === "string" ? frontmatter.name : entry.name;
+        skills.push({
+          name,
+          dirName: name,
+          content,
+          sourcePath: skillMdPath
+        });
+      }
+      scanEditorFolderForSkills(fullPath, skills);
+    }
+  }
+}
+function findEditorFolders(basePath, maxDepth = 2) {
+  const editorFolders = [];
+  function scan(currentPath, depth) {
+    if (depth > maxDepth || !(0, import_fs5.existsSync)(currentPath)) {
+      return;
+    }
+    const entries = (0, import_fs5.readdirSync)(currentPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory() || EXCLUDED_DIRS2.has(entry.name)) {
+        continue;
+      }
+      const fullPath = (0, import_path5.join)(currentPath, entry.name);
+      if (entry.name === "Editor") {
+        editorFolders.push(fullPath);
+      } else {
+        scan(fullPath, depth + 1);
+      }
+    }
+  }
+  scan(basePath, 0);
+  return editorFolders;
+}
+function collectProjectSkills() {
+  const projectRoot = findUnityProjectRoot();
+  if (!projectRoot) {
+    return [];
+  }
+  const skills = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const searchPaths = [
+    (0, import_path5.join)(projectRoot, "Assets"),
+    (0, import_path5.join)(projectRoot, "Packages"),
     (0, import_path5.join)(projectRoot, "Library", "PackageCache")
   ];
   for (const searchPath of searchPaths) {
-    if (!(0, import_fs4.existsSync)(searchPath)) {
+    if (!(0, import_fs5.existsSync)(searchPath)) {
       continue;
     }
     const editorFolders = findEditorFolders(searchPath, 3);
@@ -6616,16 +8928,24 @@ function installSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
   const skillPath = (0, import_path5.join)(skillDir, target.skillFileName);
-  (0, import_fs4.mkdirSync)(skillDir, { recursive: true });
-  (0, import_fs4.writeFileSync)(skillPath, skill.content, "utf-8");
+  (0, import_fs5.mkdirSync)(skillDir, { recursive: true });
+  (0, import_fs5.writeFileSync)(skillPath, skill.content, "utf-8");
+  if ("additionalFiles" in skill && skill.additionalFiles) {
+    const additionalFiles = skill.additionalFiles;
+    for (const [relativePath, content] of Object.entries(additionalFiles)) {
+      const fullPath = (0, import_path5.join)(skillDir, relativePath);
+      (0, import_fs5.mkdirSync)((0, import_path5.dirname)(fullPath), { recursive: true });
+      (0, import_fs5.writeFileSync)(fullPath, content, "utf-8");
+    }
+  }
 }
 function uninstallSkill(skill, target, global) {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = (0, import_path5.join)(baseDir, skill.dirName);
-  if (!(0, import_fs4.existsSync)(skillDir)) {
+  if (!(0, import_fs5.existsSync)(skillDir)) {
     return false;
   }
-  (0, import_fs4.rmSync)(skillDir, { recursive: true, force: true });
+  (0, import_fs5.rmSync)(skillDir, { recursive: true, force: true });
   return true;
 }
 function installAllSkills(target, global) {
@@ -7153,8 +9473,8 @@ function cleanupLockFiles() {
   let cleaned = 0;
   for (const lockFile of LOCK_FILES) {
     const lockPath = (0, import_path6.join)(tempDir, lockFile);
-    if ((0, import_fs5.existsSync)(lockPath)) {
-      (0, import_fs5.unlinkSync)(lockPath);
+    if ((0, import_fs6.existsSync)(lockPath)) {
+      (0, import_fs6.unlinkSync)(lockPath);
       console.log(`Removed: ${lockFile}`);
       cleaned++;
     }
@@ -7190,12 +9510,12 @@ function handleCompletion(install, shellOverride) {
   }
   const configPath = getShellConfigPath(shell);
   const configDir = (0, import_path6.dirname)(configPath);
-  if (!(0, import_fs5.existsSync)(configDir)) {
-    (0, import_fs5.mkdirSync)(configDir, { recursive: true });
+  if (!(0, import_fs6.existsSync)(configDir)) {
+    (0, import_fs6.mkdirSync)(configDir, { recursive: true });
   }
   let content = "";
-  if ((0, import_fs5.existsSync)(configPath)) {
-    content = (0, import_fs5.readFileSync)(configPath, "utf-8");
+  if ((0, import_fs6.existsSync)(configPath)) {
+    content = (0, import_fs6.readFileSync)(configPath, "utf-8");
     content = content.replace(
       /\n?# >>> uloop completion >>>[\s\S]*?# <<< uloop completion <<<\n?/g,
       ""
@@ -7209,7 +9529,7 @@ ${startMarker}
 ${script}
 ${endMarker}
 `;
-    (0, import_fs5.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   } else {
     const evalLine = `eval "$(uloop completion --shell ${shell})"`;
     const lineToAdd = `
@@ -7217,7 +9537,7 @@ ${startMarker}
 ${evalLine}
 ${endMarker}
 `;
-    (0, import_fs5.writeFileSync)(configPath, content + lineToAdd, "utf-8");
+    (0, import_fs6.writeFileSync)(configPath, content + lineToAdd, "utf-8");
   }
   console.log(`Completion installed to ${configPath}`);
   if (shell === "powershell") {