uloop-cli 0.48.3 → 0.49.0

package/jest.config.cjs

@@ -2,10 +2,11 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  moduleFileExtensions: ['ts', 'js', 'json'],
+  moduleFileExtensions: ['ts', 'js', 'json', 'md'],
   testMatch: ['**/__tests__/**/*.test.ts'],
   transform: {
     '^.+\\.ts$': 'ts-jest',
+    '^.+\\.md$': '<rootDir>/md-transformer.cjs',
   },
   moduleNameMapper: {
     '^(\\.{1,2}/.*)\\.js$': '$1',

package/md-transformer.cjs

@@ -0,0 +1,11 @@
+/**
+ * Jest transformer for .md files
+ * Converts markdown files to string exports (similar to esbuild's --loader:.md=text)
+ */
+module.exports = {
+  process(sourceText) {
+    return {
+      code: `module.exports = ${JSON.stringify(sourceText)};`,
+    };
+  },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uloop-cli",
-  "version": "0.48.3",
+  "version": "0.49.0",
   "//version": "x-release-please-version",
   "description": "CLI tool for Unity Editor communication via uLoopMCP",
   "main": "dist/cli.bundle.cjs",

package/scripts/generate-bundled-skills.ts

@@ -1,25 +1,31 @@
 /**
- * Auto-generates bundled-skills.ts from skill-definitions directory.
- * Scans all SKILL.md files and generates import statements and BUNDLED_SKILLS array.
+ * Auto-generates bundled-skills.ts from multiple source directories.
+ * Scans SKILL.md files from:
+ *   1. Editor/Api/McpTools/SKILL.md (C# tool folders)
+ *   2. skill-definitions/cli-only/SKILL.md (CLI-only skills)
+ *
  * Skills with `internal: true` in frontmatter are excluded from generation.
  *
  * Usage: npx tsx scripts/generate-bundled-skills.ts
  */
 
 import { readdirSync, readFileSync, writeFileSync, existsSync } from 'fs';
-import { join, dirname } from 'path';
+import { join, dirname, relative } from 'path';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-const SKILL_DEFINITIONS_DIR = join(__dirname, '../src/skills/skill-definitions');
+const MCPTOOLS_DIR = join(__dirname, '../../Editor/Api/McpTools');
+const CLI_ONLY_DIR = join(__dirname, '../src/skills/skill-definitions/cli-only');
 const OUTPUT_FILE = join(__dirname, '../src/skills/bundled-skills.ts');
+const OUTPUT_DIR = dirname(OUTPUT_FILE);
 
 interface SkillMetadata {
   dirName: string;
   name: string;
   isInternal: boolean;
+  importPath: string;
 }
 
 function parseFrontmatter(content: string): Record<string, string | boolean> {
@@ -52,26 +58,79 @@ function parseFrontmatter(content: string): Record<string, string | boolean> {
   return frontmatter;
 }
 
-function getSkillMetadata(dirName: string): SkillMetadata | null {
-  const skillPath = join(SKILL_DEFINITIONS_DIR, dirName, 'SKILL.md');
-
-  if (!existsSync(skillPath)) {
+function getSkillMetadataFromPath(
+  skillMdPath: string,
+  folderName: string
+): SkillMetadata | null {
+  if (!existsSync(skillMdPath)) {
     return null;
   }
 
-  const content = readFileSync(skillPath, 'utf-8');
+  const content = readFileSync(skillMdPath, 'utf-8');
   const frontmatter = parseFrontmatter(content);
 
-  const name = typeof frontmatter.name === 'string' ? frontmatter.name : dirName;
+  const name = typeof frontmatter.name === 'string' ? frontmatter.name : folderName;
   const isInternal = frontmatter.internal === true;
+  const dirName = name;
+
+  const relativePath = relative(OUTPUT_DIR, skillMdPath).replace(/\\/g, '/');
+  const importPath = relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+
+  return { dirName, name, isInternal, importPath };
+}
+
+function collectSkillsFromMcpTools(): SkillMetadata[] {
+  if (!existsSync(MCPTOOLS_DIR)) {
+    console.warn(`Warning: McpTools directory not found: ${MCPTOOLS_DIR}`);
+    return [];
+  }
+
+  const dirs = readdirSync(MCPTOOLS_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name)
+    .sort();
+
+  const skills: SkillMetadata[] = [];
+
+  for (const dirName of dirs) {
+    const skillPath = join(MCPTOOLS_DIR, dirName, 'SKILL.md');
+    const metadata = getSkillMetadataFromPath(skillPath, dirName);
+    if (metadata !== null) {
+      skills.push(metadata);
+    }
+  }
+
+  return skills;
+}
+
+function collectSkillsFromCliOnly(): SkillMetadata[] {
+  if (!existsSync(CLI_ONLY_DIR)) {
+    console.warn(`Warning: CLI-only directory not found: ${CLI_ONLY_DIR}`);
+    return [];
+  }
 
-  return { dirName, name, isInternal };
+  const dirs = readdirSync(CLI_ONLY_DIR, { withFileTypes: true })
+    .filter((dirent) => dirent.isDirectory())
+    .map((dirent) => dirent.name)
+    .sort();
+
+  const skills: SkillMetadata[] = [];
+
+  for (const dirName of dirs) {
+    const skillPath = join(CLI_ONLY_DIR, dirName, 'SKILL.md');
+    const metadata = getSkillMetadataFromPath(skillPath, dirName);
+    if (metadata !== null) {
+      skills.push(metadata);
+    }
+  }
+
+  return skills;
 }
 
 function toVariableName(dirName: string): string {
   return dirName
     .replace(/^uloop-/, '')
-    .replace(/-([a-z])/g, (_, char) => char.toUpperCase())
+    .replace(/-([a-z])/g, (_, char: string) => char.toUpperCase())
     .concat('Skill');
 }
 
@@ -79,7 +138,7 @@ function generateBundledSkillsFile(skills: SkillMetadata[]): string {
   const imports = skills
     .map((skill) => {
       const varName = toVariableName(skill.dirName);
-      return `import ${varName} from './skill-definitions/${skill.dirName}/SKILL.md';`;
+      return `import ${varName} from '${skill.importPath}';`;
     })
     .join('\n');
 
@@ -98,8 +157,11 @@ function generateBundledSkillsFile(skills: SkillMetadata[]): string {
  * AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
  * Generated by: scripts/generate-bundled-skills.ts
  *
- * This file is automatically generated from skill-definitions directory.
- * To add a new skill, create a new directory in skill-definitions with a SKILL.md file.
+ * This file is automatically generated from:
+ *   - Editor/Api/McpTools/<ToolFolder>/SKILL.md
+ *   - skill-definitions/cli-only/<SkillFolder>/SKILL.md
+ *
+ * To add a new skill, create a SKILL.md file in the appropriate location.
  * To exclude a skill from bundling, add \`internal: true\` to its frontmatter.
  */
 
@@ -122,33 +184,28 @@ export function getBundledSkillByName(name: string): BundledSkill | undefined {
 }
 
 function main(): void {
-  const dirs = readdirSync(SKILL_DEFINITIONS_DIR, { withFileTypes: true })
-    .filter((dirent) => dirent.isDirectory())
-    .map((dirent) => dirent.name)
-    .sort();
+  const mcpToolsSkills = collectSkillsFromMcpTools();
+  const cliOnlySkills = collectSkillsFromCliOnly();
 
   const allSkills: SkillMetadata[] = [];
   const internalSkills: string[] = [];
 
-  for (const dirName of dirs) {
-    const metadata = getSkillMetadata(dirName);
-    if (metadata === null) {
-      console.warn(`Warning: No SKILL.md found in ${dirName}, skipping`);
-      continue;
-    }
-
-    if (metadata.isInternal) {
-      internalSkills.push(metadata.name);
+  for (const skill of [...mcpToolsSkills, ...cliOnlySkills]) {
+    if (skill.isInternal) {
+      internalSkills.push(skill.name);
       continue;
     }
-
-    allSkills.push(metadata);
+    allSkills.push(skill);
   }
 
+  allSkills.sort((a, b) => a.name.localeCompare(b.name));
+
   const output = generateBundledSkillsFile(allSkills);
   writeFileSync(OUTPUT_FILE, output, 'utf-8');
 
   console.log(`Generated ${OUTPUT_FILE}`);
+  console.log(`  - From McpTools: ${mcpToolsSkills.length} skills found`);
+  console.log(`  - From cli-only: ${cliOnlySkills.length} skills found`);
   console.log(`  - Included: ${allSkills.length} skills`);
   if (internalSkills.length > 0) {
     console.log(`  - Excluded (internal): ${internalSkills.join(', ')}`);
@@ -156,4 +213,3 @@ function main(): void {
 }
 
 main();
-

package/src/__tests__/cli-e2e.test.ts

@@ -92,22 +92,19 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       expect(result.Success).toBe(true);
       expect(result.ErrorCount).toBe(0);
     });
-
-    it('should support --force-recompile option', () => {
-      const { exitCode } = runCli('compile --force-recompile');
-
-      // Domain Reload causes connection to be lost, so we just verify the command runs
-      // The exit code may be non-zero due to connection being dropped during reload
-      expect(typeof exitCode).toBe('number');
-    });
   });
 
   describe('get-logs', () => {
     const TEST_LOG_MENU_PATH = 'uLoopMCP/Debug/LogGetter Tests/Output Test Logs';
+    const MENU_ITEM_WAIT_MS = 1000;
 
     function setupTestLogs(): void {
-      runCli('clear-console');
-      runCli(`execute-menu-item --menu-item-path "${TEST_LOG_MENU_PATH}"`);
+      runCliWithRetry('clear-console');
+      const result = runCliWithRetry(`execute-menu-item --menu-item-path "${TEST_LOG_MENU_PATH}"`);
+      if (result.exitCode !== 0) {
+        throw new Error(`execute-menu-item failed: ${result.stderr || result.stdout}`);
+      }
+      sleepSync(MENU_ITEM_WAIT_MS);
     }
 
     it('should retrieve test logs after executing Output Test Logs menu item', () => {
@@ -339,6 +336,64 @@ describe('CLI E2E Tests (requires running Unity)', () => {
     });
   });
 
+  describe('skills', () => {
+    it('should list skills for claude target', () => {
+      const { stdout, exitCode } = runCli('skills list --claude');
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toContain('uloop-compile');
+      expect(stdout).toContain('uloop-get-logs');
+      expect(stdout).toContain('uloop-run-tests');
+    });
+
+    it('should show bundled and project skills count', () => {
+      const { stdout, exitCode } = runCli('skills list --claude');
+
+      expect(exitCode).toBe(0);
+      // Should show total skills count
+      expect(stdout).toMatch(/total:\s*\d+/i);
+    });
+
+    it('should install skills for claude target', () => {
+      // First uninstall to ensure clean state
+      runCli('skills uninstall --claude');
+
+      const { stdout, exitCode } = runCli('skills install --claude');
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toMatch(/installed|updated|skipped/i);
+    });
+
+    it('should uninstall skills for claude target', () => {
+      // First install to ensure there are skills to uninstall
+      runCli('skills install --claude');
+
+      const { stdout, exitCode } = runCli('skills uninstall --claude');
+
+      expect(exitCode).toBe(0);
+      expect(stdout).toMatch(/removed|not found/i);
+    });
+
+    it('should include project skills in list when available', () => {
+      const { stdout, exitCode } = runCli('skills list --claude');
+
+      expect(exitCode).toBe(0);
+      // HelloWorld sample should be detected as a project skill
+      expect(stdout).toContain('uloop-hello-world');
+    });
+
+    it('should install project skills along with bundled skills', () => {
+      // First uninstall
+      runCli('skills uninstall --claude');
+
+      const { stdout, exitCode } = runCli('skills install --claude');
+
+      expect(exitCode).toBe(0);
+      // Should mention project skills were installed
+      expect(stdout).toMatch(/project|installed/i);
+    });
+  });
+
   describe('error handling', () => {
     it('should handle unknown commands gracefully', () => {
       const { exitCode } = runCli('unknown-command');
@@ -346,4 +401,15 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       expect(exitCode).not.toBe(0);
     });
   });
+
+  // Domain Reload tests must run last to avoid affecting other tests
+  describe('compile --force-recompile (Domain Reload)', () => {
+    it('should support --force-recompile option', () => {
+      const { exitCode } = runCli('compile --force-recompile');
+
+      // Domain Reload causes connection to be lost, so we just verify the command runs
+      // The exit code may be non-zero due to connection being dropped during reload
+      expect(typeof exitCode).toBe('number');
+    });
+  });
 });

package/src/__tests__/skills-manager.test.ts

@@ -0,0 +1,158 @@
+/**
+ * Unit tests for skills-manager.ts
+ *
+ * Tests pure functions that don't require Unity connection.
+ */
+
+import { parseFrontmatter } from '../skills/skills-manager.js';
+
+describe('parseFrontmatter', () => {
+  it('should parse basic frontmatter with string values', () => {
+    const content = `---
+name: uloop-test-skill
+description: A test skill for testing
+---
+
+# Test Skill
+
+Some content here.
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('uloop-test-skill');
+    expect(result.description).toBe('A test skill for testing');
+  });
+
+  it('should parse boolean true value', () => {
+    const content = `---
+name: internal-skill
+internal: true
+---
+
+# Internal Skill
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('internal-skill');
+    expect(result.internal).toBe(true);
+  });
+
+  it('should parse boolean false value', () => {
+    const content = `---
+name: public-skill
+internal: false
+---
+
+# Public Skill
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('public-skill');
+    expect(result.internal).toBe(false);
+  });
+
+  it('should return empty object for content without frontmatter', () => {
+    const content = `# No Frontmatter
+
+Just some markdown content.
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result).toEqual({});
+  });
+
+  it('should return empty object for empty content', () => {
+    const result = parseFrontmatter('');
+
+    expect(result).toEqual({});
+  });
+
+  it('should handle frontmatter with colons in value', () => {
+    const content = `---
+name: uloop-test
+description: Use when: (1) first case, (2) second case
+---
+
+# Test
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('uloop-test');
+    expect(result.description).toBe('Use when: (1) first case, (2) second case');
+  });
+
+  it('should handle frontmatter with empty values', () => {
+    const content = `---
+name: uloop-test
+description:
+---
+
+# Test
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('uloop-test');
+    expect(result.description).toBe('');
+  });
+
+  it('should skip lines without colons', () => {
+    const content = `---
+name: uloop-test
+this line has no colon
+description: valid description
+---
+
+# Test
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('uloop-test');
+    expect(result.description).toBe('valid description');
+    expect(Object.keys(result)).toHaveLength(2);
+  });
+
+  it('should trim whitespace from keys and values', () => {
+    const content = `---
+  name  :   uloop-test
+  description  :   spaced description
+---
+
+# Test
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('uloop-test');
+    expect(result.description).toBe('spaced description');
+  });
+
+  it('should handle incomplete frontmatter (missing closing)', () => {
+    const content = `---
+name: uloop-test
+description: incomplete
+
+# No closing delimiter
+`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result).toEqual({});
+  });
+
+  it('should handle frontmatter-only content (no body)', () => {
+    const content = `---
+name: minimal-skill
+---`;
+
+    const result = parseFrontmatter(content);
+
+    expect(result.name).toBe('minimal-skill');
+  });
+});

package/src/cli.ts

@@ -595,7 +595,49 @@ function listOptionsForCommand(cmdName: string): void {
   console.log(options.join('\n'));
 }
 
-// Handle completion options first (before commander parsing)
-if (!handleCompletionOptions()) {
+/**
+ * Check if a command exists in the current program.
+ */
+function commandExists(cmdName: string): boolean {
+  if (BUILTIN_COMMANDS.includes(cmdName as (typeof BUILTIN_COMMANDS)[number])) {
+    return true;
+  }
+  const tools = loadToolsCache();
+  return tools.tools.some((t) => t.name === cmdName);
+}
+
+/**
+ * Main entry point with auto-sync for unknown commands.
+ */
+async function main(): Promise<void> {
+  if (handleCompletionOptions()) {
+    return;
+  }
+
+  const args = process.argv.slice(2);
+  const cmdName = args.find((arg) => !arg.startsWith('-'));
+
+  if (cmdName && !commandExists(cmdName)) {
+    console.log(`\x1b[33mUnknown command '${cmdName}'. Syncing tools from Unity...\x1b[0m`);
+    try {
+      await syncTools({});
+      const newCache = loadToolsCache();
+      const tool = newCache.tools.find((t) => t.name === cmdName);
+      if (tool) {
+        registerToolCommand(tool);
+        console.log(`\x1b[32m✓ Found '${cmdName}' after sync.\x1b[0m\n`);
+      } else {
+        console.error(`\x1b[31mError: Command '${cmdName}' not found even after sync.\x1b[0m`);
+        process.exit(1);
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.error(`\x1b[31mError: Failed to sync tools: ${message}\x1b[0m`);
+      process.exit(1);
+    }
+  }
+
   program.parse();
 }
+
+void main();

package/src/default-tools.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.48.3",
+  "version": "0.49.0",
   "tools": [
     {
       "name": "compile",

package/src/skills/bundled-skills.ts

@@ -2,25 +2,28 @@
  * AUTO-GENERATED FILE - DO NOT EDIT MANUALLY
  * Generated by: scripts/generate-bundled-skills.ts
  *
- * This file is automatically generated from skill-definitions directory.
- * To add a new skill, create a new directory in skill-definitions with a SKILL.md file.
+ * This file is automatically generated from:
+ *   - Editor/Api/McpTools/<ToolFolder>/SKILL.md
+ *   - skill-definitions/cli-only/<SkillFolder>/SKILL.md
+ *
+ * To add a new skill, create a SKILL.md file in the appropriate location.
  * To exclude a skill from bundling, add `internal: true` to its frontmatter.
  */
 
-import captureUnityWindowSkill from './skill-definitions/uloop-capture-unity-window/SKILL.md';
-import clearConsoleSkill from './skill-definitions/uloop-clear-console/SKILL.md';
-import compileSkill from './skill-definitions/uloop-compile/SKILL.md';
-import controlPlayModeSkill from './skill-definitions/uloop-control-play-mode/SKILL.md';
-import executeDynamicCodeSkill from './skill-definitions/uloop-execute-dynamic-code/SKILL.md';
-import executeMenuItemSkill from './skill-definitions/uloop-execute-menu-item/SKILL.md';
-import findGameObjectsSkill from './skill-definitions/uloop-find-game-objects/SKILL.md';
-import focusWindowSkill from './skill-definitions/uloop-focus-window/SKILL.md';
-import getHierarchySkill from './skill-definitions/uloop-get-hierarchy/SKILL.md';
-import getLogsSkill from './skill-definitions/uloop-get-logs/SKILL.md';
-import getMenuItemsSkill from './skill-definitions/uloop-get-menu-items/SKILL.md';
-import getProviderDetailsSkill from './skill-definitions/uloop-get-provider-details/SKILL.md';
-import runTestsSkill from './skill-definitions/uloop-run-tests/SKILL.md';
-import unitySearchSkill from './skill-definitions/uloop-unity-search/SKILL.md';
+import captureUnityWindowSkill from '../../../Editor/Api/McpTools/CaptureUnityWindow/SKILL.md';
+import clearConsoleSkill from '../../../Editor/Api/McpTools/ClearConsole/SKILL.md';
+import compileSkill from '../../../Editor/Api/McpTools/Compile/SKILL.md';
+import controlPlayModeSkill from '../../../Editor/Api/McpTools/ControlPlayMode/SKILL.md';
+import executeDynamicCodeSkill from '../../../Editor/Api/McpTools/ExecuteDynamicCode/SKILL.md';
+import executeMenuItemSkill from '../../../Editor/Api/McpTools/ExecuteMenuItem/SKILL.md';
+import findGameObjectsSkill from '../../../Editor/Api/McpTools/FindGameObjects/SKILL.md';
+import focusWindowSkill from '../../../Editor/Api/McpTools/FocusUnityWindow/SKILL.md';
+import getHierarchySkill from '../../../Editor/Api/McpTools/GetHierarchy/SKILL.md';
+import getLogsSkill from '../../../Editor/Api/McpTools/GetLogs/SKILL.md';
+import getMenuItemsSkill from '../../../Editor/Api/McpTools/GetMenuItems/SKILL.md';
+import getProviderDetailsSkill from '../../../Editor/Api/McpTools/UnitySearchProviderDetails/SKILL.md';
+import runTestsSkill from '../../../Editor/Api/McpTools/RunTests/SKILL.md';
+import unitySearchSkill from '../../../Editor/Api/McpTools/UnitySearch/SKILL.md';
 
 export interface BundledSkill {
   name: string;

package/src/skills/skill-definitions/cli-only/uloop-get-version/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: uloop-get-version
+description: Get Unity and project information via uloop CLI. Use when you need to verify Unity version, check project settings (ProductName, CompanyName, Version), or troubleshoot environment issues.
+internal: true
+---
+
+# uloop get-version
+
+Get Unity version and project information.
+
+## Usage
+
+```bash
+uloop get-version
+```
+
+## Parameters
+
+None.
+
+## Output
+
+Returns JSON with:
+- `UnityVersion`: Unity Editor version
+- `Platform`: Current platform
+- `DataPath`: Assets folder path
+- `PersistentDataPath`: Persistent data path
+- `TemporaryCachePath`: Temporary cache path
+- `IsEditor`: Whether running in editor
+- `ProductName`: Application product name
+- `CompanyName`: Company name
+- `Version`: Application version
+- `Ver`: uLoopMCP package version
+
+## Notes
+
+This is a sample custom tool demonstrating how to create MCP tools.