uloop-cli 0.48.3 → 0.49.0

package/src/skills/skills-manager.ts

@@ -1,11 +1,12 @@
 /**
  * Skills manager for installing/uninstalling/listing uloop skills.
+ * Supports both bundled skills and project-local skills.
  */
 
 // File paths are constructed from home directory and skill names, not from untrusted user input
 /* eslint-disable security/detect-non-literal-fs-filename */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
 import { BUNDLED_SKILLS, BundledSkill } from './bundled-skills.js';
@@ -17,8 +18,18 @@ export interface SkillInfo {
   name: string;
   status: SkillStatus;
   path?: string;
+  source?: 'bundled' | 'project';
 }
 
+export interface ProjectSkill {
+  name: string;
+  dirName: string;
+  content: string;
+  sourcePath: string;
+}
+
+const EXCLUDED_DIRS = new Set(['node_modules', '.git', 'Temp', 'obj', 'Build', 'Builds', 'Logs']);
+
 function getGlobalSkillsDir(target: TargetConfig): string {
   return join(homedir(), target.projectDir, 'skills');
 }
@@ -32,12 +43,20 @@ function getSkillPath(skillDirName: string, target: TargetConfig, global: boolea
   return join(baseDir, skillDirName, target.skillFileName);
 }
 
-function isSkillInstalled(skill: BundledSkill, target: TargetConfig, global: boolean): boolean {
+function isSkillInstalled(
+  skill: BundledSkill | ProjectSkill,
+  target: TargetConfig,
+  global: boolean,
+): boolean {
   const skillPath = getSkillPath(skill.dirName, target, global);
   return existsSync(skillPath);
 }
 
-function isSkillOutdated(skill: BundledSkill, target: TargetConfig, global: boolean): boolean {
+function isSkillOutdated(
+  skill: BundledSkill | ProjectSkill,
+  target: TargetConfig,
+  global: boolean,
+): boolean {
   const skillPath = getSkillPath(skill.dirName, target, global);
   if (!existsSync(skillPath)) {
     return false;
@@ -47,7 +66,7 @@ function isSkillOutdated(skill: BundledSkill, target: TargetConfig, global: bool
 }
 
 export function getSkillStatus(
-  skill: BundledSkill,
+  skill: BundledSkill | ProjectSkill,
   target: TargetConfig,
   global: boolean,
 ): SkillStatus {
@@ -60,17 +79,170 @@ export function getSkillStatus(
   return 'installed';
 }
 
+export function parseFrontmatter(content: string): Record<string, string | boolean> {
+  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) {
+    return {};
+  }
+
+  const frontmatter: Record<string, string | boolean> = {};
+  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: string, skills: ProjectSkill[]): void {
+  if (!existsSync(editorPath)) {
+    return;
+  }
+
+  const entries = readdirSync(editorPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (EXCLUDED_DIRS.has(entry.name)) {
+      continue;
+    }
+
+    const fullPath = join(editorPath, entry.name);
+
+    if (entry.isDirectory()) {
+      const skillMdPath = join(fullPath, 'SKILL.md');
+      if (existsSync(skillMdPath)) {
+        const content = 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: string, maxDepth: number = 2): string[] {
+  const editorFolders: string[] = [];
+
+  function scan(currentPath: string, depth: number): void {
+    if (depth > maxDepth || !existsSync(currentPath)) {
+      return;
+    }
+
+    const entries = readdirSync(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (!entry.isDirectory() || EXCLUDED_DIRS.has(entry.name)) {
+        continue;
+      }
+
+      const fullPath = join(currentPath, entry.name);
+
+      if (entry.name === 'Editor') {
+        editorFolders.push(fullPath);
+      } else {
+        scan(fullPath, depth + 1);
+      }
+    }
+  }
+
+  scan(basePath, 0);
+  return editorFolders;
+}
+
+export function collectProjectSkills(): ProjectSkill[] {
+  const projectRoot = process.cwd();
+  const skills: ProjectSkill[] = [];
+  const seenNames = new Set<string>();
+
+  const searchPaths = [
+    join(projectRoot, 'Assets'),
+    join(projectRoot, 'Packages'),
+    join(projectRoot, 'Library', 'PackageCache'),
+  ];
+
+  for (const searchPath of searchPaths) {
+    if (!existsSync(searchPath)) {
+      continue;
+    }
+
+    const editorFolders = findEditorFolders(searchPath, 3);
+
+    for (const editorFolder of editorFolders) {
+      scanEditorFolderForSkills(editorFolder, skills);
+    }
+  }
+
+  const uniqueSkills: ProjectSkill[] = [];
+  for (const skill of skills) {
+    if (!seenNames.has(skill.name)) {
+      seenNames.add(skill.name);
+      uniqueSkills.push(skill);
+    }
+  }
+
+  return uniqueSkills;
+}
+
 export function getAllSkillStatuses(target: TargetConfig, global: boolean): SkillInfo[] {
-  return BUNDLED_SKILLS.map((skill) => ({
+  const bundledStatuses: SkillInfo[] = BUNDLED_SKILLS.map((skill) => ({
     name: skill.name,
     status: getSkillStatus(skill, target, global),
     path: isSkillInstalled(skill, target, global)
       ? getSkillPath(skill.dirName, target, global)
       : undefined,
+    source: 'bundled' as const,
   }));
+
+  const projectSkills = collectProjectSkills();
+  const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
+
+  const projectStatuses: SkillInfo[] = projectSkills
+    .filter((skill) => !bundledNames.has(skill.name))
+    .map((skill) => ({
+      name: skill.name,
+      status: getSkillStatus(skill, target, global),
+      path: isSkillInstalled(skill, target, global)
+        ? getSkillPath(skill.dirName, target, global)
+        : undefined,
+      source: 'project' as const,
+    }));
+
+  return [...bundledStatuses, ...projectStatuses];
 }
 
-export function installSkill(skill: BundledSkill, target: TargetConfig, global: boolean): void {
+export function installSkill(
+  skill: BundledSkill | ProjectSkill,
+  target: TargetConfig,
+  global: boolean,
+): void {
   const baseDir = global ? getGlobalSkillsDir(target) : getProjectSkillsDir(target);
   const skillDir = join(baseDir, skill.dirName);
   const skillPath = join(skillDir, target.skillFileName);
@@ -80,7 +252,7 @@ export function installSkill(skill: BundledSkill, target: TargetConfig, global:
 }
 
 export function uninstallSkill(
-  skill: BundledSkill,
+  skill: BundledSkill | ProjectSkill,
   target: TargetConfig,
   global: boolean,
 ): boolean {
@@ -99,10 +271,18 @@ export interface InstallResult {
   installed: number;
   updated: number;
   skipped: number;
+  bundledCount: number;
+  projectCount: number;
 }
 
 export function installAllSkills(target: TargetConfig, global: boolean): InstallResult {
-  const result: InstallResult = { installed: 0, updated: 0, skipped: 0 };
+  const result: InstallResult = {
+    installed: 0,
+    updated: 0,
+    skipped: 0,
+    bundledCount: 0,
+    projectCount: 0,
+  };
 
   for (const skill of BUNDLED_SKILLS) {
     const status = getSkillStatus(skill, target, global);
@@ -117,6 +297,31 @@ export function installAllSkills(target: TargetConfig, global: boolean): Install
       result.skipped++;
     }
   }
+  result.bundledCount = BUNDLED_SKILLS.length;
+
+  const projectSkills = collectProjectSkills();
+  const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
+
+  for (const skill of projectSkills) {
+    if (bundledNames.has(skill.name)) {
+      continue;
+    }
+
+    const status = getSkillStatus(skill, target, global);
+
+    if (status === 'not_installed') {
+      installSkill(skill, target, global);
+      result.installed++;
+      result.projectCount++;
+    } else if (status === 'outdated') {
+      installSkill(skill, target, global);
+      result.updated++;
+      result.projectCount++;
+    } else {
+      result.skipped++;
+      result.projectCount++;
+    }
+  }
 
   return result;
 }
@@ -137,6 +342,21 @@ export function uninstallAllSkills(target: TargetConfig, global: boolean): Unins
     }
   }
 
+  const projectSkills = collectProjectSkills();
+  const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
+
+  for (const skill of projectSkills) {
+    if (bundledNames.has(skill.name)) {
+      continue;
+    }
+
+    if (uninstallSkill(skill, target, global)) {
+      result.removed++;
+    } else {
+      result.notFound++;
+    }
+  }
+
   return result;
 }
 
@@ -145,5 +365,8 @@ export function getInstallDir(target: TargetConfig, global: boolean): string {
 }
 
 export function getTotalSkillCount(): number {
-  return BUNDLED_SKILLS.length;
+  const projectSkills = collectProjectSkills();
+  const bundledNames = new Set(BUNDLED_SKILLS.map((s) => s.name));
+  const uniqueProjectCount = projectSkills.filter((s) => !bundledNames.has(s.name)).length;
+  return BUNDLED_SKILLS.length + uniqueProjectCount;
 }

package/src/version.ts

@@ -4,4 +4,4 @@
  * This file exists to avoid bundling the entire package.json into the CLI bundle.
  * This version is automatically updated by release-please.
  */
-export const VERSION = '0.48.3'; // x-release-please-version
+export const VERSION = '0.49.0'; // x-release-please-version

package/CLAUDE.md

@@ -1,61 +0,0 @@
-# uloop CLI
-
-A CLI tool for communicating with Unity Editor. Completely independent from the MCP server (TypeScriptServer~).
-
-## Architecture
-
-- **Zero dependency on TypeScriptServer~**
-- Communicates with Unity directly via TCP connection in `direct-unity-client.ts`
-- Interacts directly with Unity TCP server without going through MCP server
-
-## Directory Structure
-
-```text
-src/
-├── cli.ts                 # Entry point (commander.js)
-├── version.ts             # Version management (auto-updated by release-please)
-├── execute-tool.ts        # Tool execution logic
-├── direct-unity-client.ts # Direct Unity TCP communication
-├── simple-framer.ts       # TCP framing
-├── port-resolver.ts       # Port detection
-├── tool-cache.ts          # Tool cache (.uloop/tools.json)
-├── arg-parser.ts          # Argument parsing
-├── default-tools.json     # Default tool definitions
-├── skills/                # Claude Code skills feature
-│   ├── skills-command.ts
-│   ├── skills-manager.ts
-│   ├── bundled-skills.ts
-│   └── skill-definitions/ # 13 skill definitions (.md)
-└── __tests__/
-    └── cli-e2e.test.ts    # E2E tests
-```
-
-## Build
-
-```bash
-npm run build    # Generates dist/cli.bundle.cjs
-npm run lint     # Run ESLint
-```
-
-## E2E Tests
-
-E2E tests communicate with actual Unity Editor, so the following prerequisites are required:
-
-1. Unity Editor must be running
-2. uLoopMCP package must be installed
-3. CLI must be built (`npm run build`)
-
-```bash
-npm run test:cli # Run E2E tests (Unity must be running)
-```
-
-## npm Publishing
-
-This directory is published to npm as the `uloop-cli` package.
-Version is synchronized with `Packages/src/package.json` (managed by release-please).
-
-## Notes
-
-- `version.ts` is a separate file from TypeScriptServer~ (not a copy)
-- Build artifact `dist/cli.bundle.cjs` is excluded via `.gitignore`
-- `node_modules/` is also excluded via `.gitignore`

package/src/skills/skill-definitions/uloop-capture-unity-window/SKILL.md

@@ -1,81 +0,0 @@
----
-name: uloop-capture-unity-window
-description: Capture Unity EditorWindow and save as PNG image. Use when you need to: (1) Take a screenshot of Game View, Scene View, Console, Inspector, etc., (2) Capture visual state for debugging or verification, (3) Save editor output as an image file.
----
-
-# uloop capture-unity-window
-
-Capture any Unity EditorWindow by name and save as PNG image.
-
-## Usage
-
-```bash
-uloop capture-unity-window [--window-name <name>] [--resolution-scale <scale>]
-```
-
-## Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `--window-name` | string | `Game` | Window name to capture (e.g., "Game", "Scene", "Console", "Inspector", "Project", "Hierarchy", or any EditorWindow title) |
-| `--resolution-scale` | number | `1.0` | Resolution scale (0.1 to 1.0) |
-
-## Window Name
-
-The window name is the text displayed in the window's title bar (tab). The user (human) will tell you which window to capture. Common window names include:
-
-- **Game**: Game View window
-- **Scene**: Scene View window
-- **Console**: Console window
-- **Inspector**: Inspector window
-- **Project**: Project browser window
-- **Hierarchy**: Hierarchy window
-- **Animation**: Animation window
-- **Animator**: Animator window
-- **Profiler**: Profiler window
-- **Audio Mixer**: Audio Mixer window
-
-You can also specify custom EditorWindow titles (e.g., "EditorWindow Capture Test").
-
-## Examples
-
-```bash
-# Capture Game View at full resolution
-uloop capture-unity-window
-
-# Capture Game View at half resolution
-uloop capture-unity-window --window-name Game --resolution-scale 0.5
-
-# Capture Scene View
-uloop capture-unity-window --window-name Scene
-
-# Capture Console window
-uloop capture-unity-window --window-name Console
-
-# Capture Inspector window
-uloop capture-unity-window --window-name Inspector
-
-# Capture Project browser
-uloop capture-unity-window --window-name Project
-
-# Capture custom EditorWindow by title
-uloop capture-unity-window --window-name "My Custom Window"
-```
-
-## Output
-
-Returns JSON with:
-- `CapturedCount`: Number of windows captured
-- `CapturedWindows`: Array of captured window info, each containing:
-  - `ImagePath`: Absolute path to the saved PNG image
-  - `FileSizeBytes`: Size of the saved file in bytes
-  - `Width`: Captured image width in pixels
-  - `Height`: Captured image height in pixels
-
-When multiple windows of the same type are open (e.g., multiple Inspector windows), all matching windows are captured with numbered filenames (e.g., `Inspector_1_*.png`, `Inspector_2_*.png`).
-
-## Notes
-
-- Use `uloop focus-window` first if needed
-- Target window must be open in Unity Editor
-- Window name matching is case-insensitive

package/src/skills/skill-definitions/uloop-clear-console/SKILL.md

@@ -1,34 +0,0 @@
----
-name: uloop-clear-console
-description: Clear Unity console logs via uloop CLI. Use when you need to: (1) Clear the console before running tests, (2) Start a fresh debugging session, (3) Clean up log output for better readability.
----
-
-# uloop clear-console
-
-Clear Unity console logs.
-
-## Usage
-
-```bash
-uloop clear-console [--add-confirmation-message]
-```
-
-## Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `--add-confirmation-message` | boolean | `false` | Add confirmation message after clearing |
-
-## Examples
-
-```bash
-# Clear console
-uloop clear-console
-
-# Clear with confirmation
-uloop clear-console --add-confirmation-message
-```
-
-## Output
-
-Returns JSON confirming the console was cleared.

package/src/skills/skill-definitions/uloop-compile/SKILL.md

@@ -1,47 +0,0 @@
----
-name: uloop-compile
-description: Compile Unity project via uloop CLI. Use when you need to: (1) Verify C# code compiles successfully after editing scripts, (2) Check for compile errors or warnings, (3) Validate script changes before running tests.
----
-
-# uloop compile
-
-Execute Unity project compilation.
-
-## Usage
-
-```bash
-uloop compile [--force-recompile]
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `--force-recompile` | boolean | Force full recompilation (triggers Domain Reload) |
-
-## Examples
-
-```bash
-# Check compilation
-uloop compile
-
-# Force full recompilation
-uloop compile --force-recompile
-```
-
-## Output
-
-Returns JSON:
-- `Success`: boolean
-- `ErrorCount`: number
-- `WarningCount`: number
-
-## Troubleshooting
-
-If CLI hangs or shows "Unity is busy" errors after compilation, stale lock files may be preventing connection. Run the following to clean them up:
-
-```bash
-uloop fix
-```
-
-This removes any leftover lock files (`compiling.lock`, `domainreload.lock`, `serverstarting.lock`) from the Unity project's Temp directory.

package/src/skills/skill-definitions/uloop-control-play-mode/SKILL.md

@@ -1,48 +0,0 @@
----
-name: uloop-control-play-mode
-description: 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.
----
-
-# uloop control-play-mode
-
-Control Unity Editor play mode (play/stop/pause).
-
-## Usage
-
-```bash
-uloop control-play-mode [options]
-```
-
-## Parameters
-
-| Parameter | Type | Default | Description |
-|-----------|------|---------|-------------|
-| `--action` | string | `Play` | Action to perform: `Play`, `Stop`, `Pause` |
-
-## Examples
-
-```bash
-# Start play mode
-uloop control-play-mode --action Play
-
-# Stop play mode
-uloop control-play-mode --action Stop
-
-# Pause play mode
-uloop control-play-mode --action Pause
-```
-
-## Output
-
-Returns JSON with the current play mode state:
-- `IsPlaying`: Whether Unity is currently in play mode
-- `IsPaused`: Whether play mode is paused
-- `Message`: Description of the action performed
-
-## Notes
-
-- Play action starts the game in the Unity Editor (also resumes from pause)
-- Stop action exits play mode and returns to edit mode
-- Pause action pauses the game while remaining in play mode
-- Useful for automated testing workflows
-

package/src/skills/skill-definitions/uloop-execute-dynamic-code/SKILL.md

@@ -1,79 +0,0 @@
----
-name: uloop-execute-dynamic-code
-description: 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.
----
-
-# uloop execute-dynamic-code
-
-Execute C# code dynamically in Unity Editor.
-
-## Usage
-
-```bash
-uloop execute-dynamic-code --code '<c# code>'
-```
-
-## Parameters
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `--code` | string | C# code to execute (direct statements, no class wrapper) |
-| `--compile-only` | boolean | Compile without execution |
-| `--auto-qualify-unity-types-once` | boolean | Auto-qualify Unity types |
-
-## Code Format
-
-Write direct statements only (no classes/namespaces/methods). Return is optional.
-
-```csharp
-// Using directives at top are hoisted
-using UnityEngine;
-var x = Mathf.PI;
-return x;
-```
-
-## String Literals (Shell-specific)
-
-| Shell | Method |
-|-------|--------|
-| bash/zsh/MINGW64/Git Bash | `'Debug.Log("Hello!");'` |
-| PowerShell | `'Debug.Log(""Hello!"");'` |
-
-## Allowed Operations
-
-- Prefab/material wiring (PrefabUtility)
-- AddComponent + reference wiring (SerializedObject)
-- Scene/hierarchy edits
-- Inspector modifications
-
-## Forbidden Operations
-
-- System.IO.* (File/Directory/Path)
-- AssetDatabase.CreateFolder / file writes
-- Create/edit .cs/.asmdef files
-
-## Examples
-
-### bash / zsh / MINGW64 / Git Bash
-
-```bash
-uloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'
-uloop execute-dynamic-code --code 'new GameObject("MyObject");'
-uloop execute-dynamic-code --code 'UnityEngine.Debug.Log("Hello from CLI!");'
-```
-
-### PowerShell
-
-```powershell
-uloop execute-dynamic-code --code 'return Selection.activeGameObject?.name;'
-uloop execute-dynamic-code --code 'new GameObject(""MyObject"");'
-uloop execute-dynamic-code --code 'UnityEngine.Debug.Log(""Hello from CLI!"");'
-```
-
-## Output
-
-Returns JSON with execution result or compile errors.
-
-## Notes
-
-For file/directory operations, use terminal commands instead.