uloop-cli 0.54.6 → 0.55.0

package/package.json

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

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

@@ -212,6 +212,24 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       expect(typeof result.hierarchyFilePath).toBe('string');
       expect(result.hierarchyFilePath).toContain('hierarchy_');
     });
+
+    it('should support --include-components false to disable components', () => {
+      const result = runCliJson<{ hierarchyFilePath: string }>(
+        'get-hierarchy --max-depth 1 --include-components false',
+      );
+
+      expect(typeof result.hierarchyFilePath).toBe('string');
+      expect(result.hierarchyFilePath).toContain('hierarchy_');
+    });
+
+    it('should support --include-inactive false to exclude inactive objects', () => {
+      const result = runCliJson<{ hierarchyFilePath: string }>(
+        'get-hierarchy --max-depth 1 --include-inactive false',
+      );
+
+      expect(typeof result.hierarchyFilePath).toBe('string');
+      expect(result.hierarchyFilePath).toContain('hierarchy_');
+    });
   });
 
   describe('get-menu-items', () => {
@@ -257,6 +275,14 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       const messages = logs.Logs.map((log) => log.Message);
       expect(messages.some((m) => m.includes('LogGetter test complete'))).toBe(true);
     });
+
+    it('should support --use-reflection-fallback false option', () => {
+      const result = runCliJson<{ Success: boolean }>(
+        `execute-menu-item --menu-item-path "${TEST_LOG_MENU_PATH}" --use-reflection-fallback false`,
+      );
+
+      expect(result.Success).toBe(true);
+    });
   });
 
   describe('unity-search', () => {
@@ -270,12 +296,23 @@ describe('CLI E2E Tests (requires running Unity)', () => {
   describe('find-game-objects', () => {
     it('should find game objects with name pattern', () => {
       const result = runCliJson<{ results: unknown[]; totalFound: number }>(
-        'find-game-objects --name-pattern "*" --include-inactive',
+        'find-game-objects --name-pattern "*" --include-inactive true',
       );
 
       expect(Array.isArray(result.results)).toBe(true);
       expect(typeof result.totalFound).toBe('number');
     });
+
+    it('should find Cube game object with default array parameter', () => {
+      // This test verifies that default array values (e.g., RequiredComponents: [])
+      // are correctly handled and don't cause search to fail
+      const result = runCliJson<{ results: Array<{ name: string }>; totalFound: number }>(
+        'find-game-objects --name-pattern "Cube"',
+      );
+
+      expect(result.totalFound).toBeGreaterThan(0);
+      expect(result.results.some((r) => r.name === 'Cube')).toBe(true);
+    });
   });
 
   describe('get-provider-details', () => {
@@ -284,6 +321,22 @@ describe('CLI E2E Tests (requires running Unity)', () => {
 
       expect(Array.isArray(result.Providers)).toBe(true);
     });
+
+    it('should support --include-descriptions false to exclude descriptions', () => {
+      const result = runCliJson<{ Providers: unknown[] }>(
+        'get-provider-details --include-descriptions false',
+      );
+
+      expect(Array.isArray(result.Providers)).toBe(true);
+    });
+
+    it('should support --sort-by-priority false to disable priority sorting', () => {
+      const result = runCliJson<{ Providers: unknown[] }>(
+        'get-provider-details --sort-by-priority false',
+      );
+
+      expect(Array.isArray(result.Providers)).toBe(true);
+    });
   });
 
   describe('--help', () => {
@@ -302,6 +355,16 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       expect(exitCode).toBe(0);
       expect(stdout).toContain('--force-recompile');
     });
+
+    it('should display boolean options with value format in get-hierarchy help', () => {
+      const { stdout, exitCode } = runCli('get-hierarchy --help');
+
+      expect(exitCode).toBe(0);
+      // Boolean options should show <value> format
+      expect(stdout).toContain('--include-components <value>');
+      expect(stdout).toContain('--include-inactive <value>');
+      expect(stdout).toContain('(default: "true")');
+    });
   });
 
   describe('--version', () => {

package/src/cli.ts

@@ -19,7 +19,7 @@ import {
   GlobalOptions,
   syncTools,
 } from './execute-tool.js';
-import { loadToolsCache, ToolDefinition, ToolProperty } from './tool-cache.js';
+import { loadToolsCache, hasCacheFile, ToolDefinition, ToolProperty } from './tool-cache.js';
 import { pascalToKebabCase } from './arg-parser.js';
 import { registerSkillsCommand } from './skills/skills-command.js';
 import { VERSION } from './version.js';
@@ -87,12 +87,6 @@ program
 // Register skills subcommand
 registerSkillsCommand(program);
 
-// Load tools from cache and register commands dynamically
-const toolsCache = loadToolsCache();
-for (const tool of toolsCache.tools) {
-  registerToolCommand(tool);
-}
-
 /**
  * Register a tool as a CLI command dynamically.
  */
@@ -104,9 +98,11 @@ function registerToolCommand(tool: ToolDefinition): void {
   for (const [propName, propInfo] of Object.entries(properties)) {
     const optionStr = generateOptionString(propName, propInfo);
     const description = buildOptionDescription(propInfo);
-    const defaultValue = propInfo.default as string | boolean | undefined;
-    if (defaultValue !== undefined) {
-      cmd.option(optionStr, description, defaultValue);
+    const defaultValue = propInfo.default;
+    if (defaultValue !== undefined && defaultValue !== null) {
+      // Convert default values to strings for consistent CLI handling
+      const defaultStr = convertDefaultToString(defaultValue);
+      cmd.option(optionStr, description, defaultStr);
     } else {
       cmd.option(optionStr, description);
     }
@@ -131,17 +127,26 @@ function registerToolCommand(tool: ToolDefinition): void {
   });
 }
 
+/**
+ * Convert default value to string for CLI option registration.
+ */
+function convertDefaultToString(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'boolean' || typeof value === 'number') {
+    return String(value);
+  }
+  return JSON.stringify(value);
+}
+
 /**
  * Generate commander.js option string from property info.
+ * All types use value format (--option <value>) for consistency with MCP.
  */
 function generateOptionString(propName: string, propInfo: ToolProperty): string {
   const kebabName = pascalToKebabCase(propName);
-  const lowerType = propInfo.type.toLowerCase();
-
-  if (lowerType === 'boolean') {
-    return `--${kebabName}`;
-  }
-
+  void propInfo; // All types now use value format
   return `--${kebabName} <value>`;
 }
 
@@ -184,7 +189,30 @@ function buildParams(
 function convertValue(value: unknown, propInfo: ToolProperty): unknown {
   const lowerType = propInfo.type.toLowerCase();
 
+  if (lowerType === 'boolean' && typeof value === 'string') {
+    const lower = value.toLowerCase();
+    if (lower === 'true') {
+      return true;
+    }
+    if (lower === 'false') {
+      return false;
+    }
+    throw new Error(`Invalid boolean value: ${value}. Use 'true' or 'false'.`);
+  }
+
   if (lowerType === 'array' && typeof value === 'string') {
+    // Handle JSON array format (e.g., "[]" or "[\"item1\",\"item2\"]")
+    if (value.startsWith('[') && value.endsWith(']')) {
+      try {
+        const parsed: unknown = JSON.parse(value);
+        if (Array.isArray(parsed)) {
+          return parsed;
+        }
+      } catch {
+        // Fall through to comma-separated handling
+      }
+    }
+    // Handle comma-separated format (e.g., "item1,item2")
     return value.split(',').map((s) => s.trim());
   }
 
@@ -624,6 +652,34 @@ async function main(): Promise<void> {
     return;
   }
 
+  // Check if cache version is outdated and auto-sync if needed
+  const cachedVersion = loadToolsCache().version;
+  if (hasCacheFile() && cachedVersion !== VERSION) {
+    console.log(
+      `\x1b[33mCache outdated (${cachedVersion} → ${VERSION}). Syncing tools from Unity...\x1b[0m`,
+    );
+    try {
+      await syncTools({});
+      console.log('\x1b[32m✓ Tools synced successfully.\x1b[0m\n');
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (isConnectionError(message)) {
+        console.error('\x1b[33mWarning: Failed to sync tools. Using cached definitions.\x1b[0m');
+        console.error("\x1b[33mRun 'uloop sync' manually when Unity is available.\x1b[0m\n");
+      } else {
+        console.error('\x1b[33mWarning: Failed to sync tools. Using cached definitions.\x1b[0m');
+        console.error(`\x1b[33mError: ${message}\x1b[0m`);
+        console.error("\x1b[33mRun 'uloop sync' manually when Unity is available.\x1b[0m\n");
+      }
+    }
+  }
+
+  // Register tool commands from cache (after potential auto-sync)
+  const toolsCache = loadToolsCache();
+  for (const tool of toolsCache.tools) {
+    registerToolCommand(tool);
+  }
+
   const args = process.argv.slice(2);
   const cmdName = args.find((arg) => !arg.startsWith('-'));
 

package/src/default-tools.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.54.6",
+  "version": "0.55.0",
   "tools": [
     {
       "name": "compile",
@@ -43,7 +43,7 @@
           "IncludeStackTrace": {
             "type": "boolean",
             "description": "Include stack trace in output",
-            "default": true
+            "default": false
           },
           "UseRegex": {
             "type": "boolean",

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.54.6'; // x-release-please-version
+export const VERSION = '0.55.0'; // x-release-please-version