feat(orchestrator): enterprise feature support — CLI provider, submodule profiles, caching, LFS, hooks

Add generic enterprise-grade features to the orchestrator, enabling Unity projects with
complex CI/CD pipelines to adopt game-ci/unity-builder with built-in support for:

- CLI provider protocol: JSON-over-stdin/stdout bridge enabling providers in any language
  (Go, Python, Rust, shell) via the `providerExecutable` input
- Submodule profiles: YAML-based selective submodule initialization with glob patterns
  and variant overlays (`submoduleProfilePath`, `submoduleVariantPath`)
- Local build caching: Filesystem-based Library and LFS caching for local builds without
  external cache actions (`localCacheEnabled`, `localCacheRoot`)
- Custom LFS transfer agents: Register external transfer agents like elastic-git-storage
  (`lfsTransferAgent`, `lfsTransferAgentArgs`, `lfsStoragePaths`)
- Git hooks support: Detect and install lefthook/husky with configurable skip lists
  (`gitHooksEnabled`, `gitHooksSkipList`)

Also removes all `orchestrator-develop` branch references, replacing with `main`.

13 new action inputs, 13 new files, 14 new CLI provider tests, 17 submodule tests,
plus cache/LFS/hooks unit tests. All 452 tests pass.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/model/orchestrator/services/hooks/git-hooks-service.test.ts

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { GitHooksService } from './git-hooks-service';
+
+// Mock dependencies
+jest.mock('node:fs');
+jest.mock('../core/orchestrator-system', () => ({
+  OrchestratorSystem: {
+    Run: jest.fn().mockResolvedValue(''),
+  },
+}));
+jest.mock('../core/orchestrator-logger', () => ({
+  __esModule: true,
+  default: {
+    log: jest.fn(),
+    logWarning: jest.fn(),
+    error: jest.fn(),
+  },
+}));
+
+const mockFs = fs as jest.Mocked<typeof fs>;
+
+describe('GitHooksService', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('detectHookFramework', () => {
+    it('should detect lefthook.yml', () => {
+      (mockFs.existsSync as jest.Mock).mockImplementation((filePath: string) => {
+        return String(filePath).includes('lefthook.yml') && !String(filePath).startsWith('.');
+      });
+
+      const result = GitHooksService.detectHookFramework('/repo');
+      expect(result).toBe('lefthook');
+    });
+
+    it('should detect .lefthook.yml', () => {
+      (mockFs.existsSync as jest.Mock).mockImplementation((filePath: string) => {
+        return String(filePath).includes('.lefthook.yml');
+      });
+
+      const result = GitHooksService.detectHookFramework('/repo');
+      expect(result).toBe('lefthook');
+    });
+
+    it('should detect .husky directory', () => {
+      (mockFs.existsSync as jest.Mock).mockImplementation((filePath: string) => {
+        return String(filePath).endsWith('.husky');
+      });
+
+      const result = GitHooksService.detectHookFramework('/repo');
+      expect(result).toBe('husky');
+    });
+
+    it('should return none when no framework is detected', () => {
+      (mockFs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const result = GitHooksService.detectHookFramework('/repo');
+      expect(result).toBe('none');
+    });
+  });
+
+  describe('configureSkipList', () => {
+    it('should return empty object for empty skip list', () => {
+      const result = GitHooksService.configureSkipList([]);
+      expect(result).toEqual({});
+    });
+
+    it('should return LEFTHOOK_EXCLUDE with comma-separated hooks', () => {
+      const result = GitHooksService.configureSkipList(['pre-commit', 'pre-push']);
+      expect(result.LEFTHOOK_EXCLUDE).toBe('pre-commit,pre-push');
+    });
+
+    it('should set HUSKY=0 when hooks are skipped', () => {
+      const result = GitHooksService.configureSkipList(['pre-commit']);
+      expect(result.HUSKY).toBe('0');
+    });
+  });
+
+  describe('disableHooks', () => {
+    it('should set core.hooksPath to an empty directory', async () => {
+      (mockFs.mkdirSync as jest.Mock).mockReturnValue(undefined);
+
+      const { OrchestratorSystem } = require('../core/orchestrator-system');
+
+      await GitHooksService.disableHooks('/repo');
+
+      expect(OrchestratorSystem.Run).toHaveBeenCalledWith(
+        expect.stringContaining('git -C "/repo" config core.hooksPath'),
+        true,
+      );
+    });
+  });
+
+  describe('installHooks', () => {
+    it('should run npx lefthook install when lefthook is detected', async () => {
+      (mockFs.existsSync as jest.Mock).mockImplementation((filePath: string) => {
+        return String(filePath).includes('lefthook.yml') && !String(filePath).startsWith('.');
+      });
+
+      const { OrchestratorSystem } = require('../core/orchestrator-system');
+
+      await GitHooksService.installHooks('/repo');
+
+      expect(OrchestratorSystem.Run).toHaveBeenCalledWith(`cd "/repo" && npx lefthook install`, true);
+    });
+
+    it('should log and return when no framework is detected', async () => {
+      (mockFs.existsSync as jest.Mock).mockReturnValue(false);
+
+      const { OrchestratorSystem } = require('../core/orchestrator-system');
+      const OrchestratorLogger = require('../core/orchestrator-logger').default;
+
+      await GitHooksService.installHooks('/repo');
+
+      expect(OrchestratorSystem.Run).not.toHaveBeenCalled();
+      expect(OrchestratorLogger.log).toHaveBeenCalledWith(expect.stringContaining('No hook framework detected'));
+    });
+  });
+});

src/model/orchestrator/services/hooks/git-hooks-service.ts

@@ -0,0 +1,96 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { OrchestratorSystem } from '../core/orchestrator-system';
+import OrchestratorLogger from '../core/orchestrator-logger';
+
+export class GitHooksService {
+  /**
+   * Detect which git hook framework is configured in the repository.
+   * Checks for lefthook and husky configuration files.
+   */
+  static detectHookFramework(repoPath: string): 'lefthook' | 'husky' | 'none' {
+    // Check for lefthook config files
+    if (fs.existsSync(path.join(repoPath, 'lefthook.yml')) || fs.existsSync(path.join(repoPath, '.lefthook.yml'))) {
+      return 'lefthook';
+    }
+
+    // Check for husky directory
+    if (fs.existsSync(path.join(repoPath, '.husky'))) {
+      return 'husky';
+    }
+
+    return 'none';
+  }
+
+  /**
+   * Install git hooks using the detected framework.
+   * Errors are caught and logged as warnings - hook installation should not fail the build.
+   */
+  static async installHooks(repoPath: string): Promise<void> {
+    const framework = GitHooksService.detectHookFramework(repoPath);
+
+    if (framework === 'none') {
+      OrchestratorLogger.log(`[GitHooks] No hook framework detected in ${repoPath}`);
+
+      return;
+    }
+
+    OrchestratorLogger.log(`[GitHooks] Detected hook framework: ${framework}`);
+
+    try {
+      if (framework === 'lefthook') {
+        await OrchestratorSystem.Run(`cd "${repoPath}" && npx lefthook install`, true);
+        OrchestratorLogger.log(`[GitHooks] Lefthook hooks installed`);
+      } else if (framework === 'husky') {
+        await OrchestratorSystem.Run(`cd "${repoPath}" && npx husky install`, true);
+        OrchestratorLogger.log(`[GitHooks] Husky hooks installed`);
+      }
+    } catch (error: any) {
+      OrchestratorLogger.logWarning(`[GitHooks] Hook installation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Return environment variables that will skip the listed hooks.
+   * For lefthook: sets LEFTHOOK_EXCLUDE to a comma-separated list.
+   * For husky: sets HUSKY=0 to disable all hooks (husky does not support selective skipping).
+   * The caller is responsible for applying the returned env vars.
+   */
+  static configureSkipList(skipList: string[]): Record<string, string> {
+    if (skipList.length === 0) {
+      return {};
+    }
+
+    // Return both lefthook and husky env vars so the caller can apply whichever is relevant.
+    // Lefthook supports selective hook exclusion.
+    const env: Record<string, string> = {
+      LEFTHOOK_EXCLUDE: skipList.join(','),
+    };
+
+    // Husky only supports full disable (HUSKY=0), not selective skipping.
+    // If any hooks are in the skip list, disable husky entirely.
+    env.HUSKY = '0';
+
+    OrchestratorLogger.log(`[GitHooks] Skip list configured: ${skipList.join(', ')}`);
+
+    return env;
+  }
+
+  /**
+   * Disable all git hooks by pointing core.hooksPath to an empty temporary directory.
+   * This prevents any hooks from running during the build.
+   */
+  static async disableHooks(repoPath: string): Promise<void> {
+    try {
+      const emptyDir = path.join(os.tmpdir(), 'game-ci-empty-hooks');
+      fs.mkdirSync(emptyDir, { recursive: true });
+
+      await OrchestratorSystem.Run(`git -C "${repoPath}" config core.hooksPath "${emptyDir}"`, true);
+
+      OrchestratorLogger.log(`[GitHooks] Hooks disabled via core.hooksPath -> ${emptyDir}`);
+    } catch (error: any) {
+      OrchestratorLogger.logWarning(`[GitHooks] Failed to disable hooks: ${error.message}`);
+    }
+  }
+}