@boyingliu01/xp-gate 0.7.0 → 0.7.1

package/lib/__tests__/ui-detector.test.ts

@@ -79,14 +79,7 @@ describe('ui-detector', () => {
       expect(result.matchedFiles).toContain('views/login.html');
     });
 
-    it('should return true for deleted UI files', async () => {
-      mockExecSync.mockReturnValue('views/old.html\n');
-      const { detectUiSprint } = await import('../ui-detector');
-      const result = detectUiSprint();
-      expect(result.isUiSprint).toBe(true);
-    });
-
-    it('should handle renamed files correctly', async () => {
+    it('should return true for renamed UI files', async () => {
       mockExecSync.mockReturnValue('views/a.html → views/b.html\n');
       const { detectUiSprint } = await import('../ui-detector');
       const result = detectUiSprint();
@@ -129,6 +122,29 @@ describe('ui-detector', () => {
     });
   });
 
+  describe('getChangedFiles', () => {
+    it('parses git diff output into file array', async () => {
+      mockExecSync.mockReturnValue('src/a.ts\nsrc/b.ts\n');
+      const { getChangedFiles } = await import('../ui-detector');
+      const files = getChangedFiles('main');
+      expect(files).toEqual(['src/a.ts', 'src/b.ts']);
+    });
+
+    it('returns empty array for empty diff', async () => {
+      mockExecSync.mockReturnValue('');
+      const { getChangedFiles } = await import('../ui-detector');
+      const files = getChangedFiles('main');
+      expect(files).toEqual([]);
+    });
+
+    it('filters out empty lines', async () => {
+      mockExecSync.mockReturnValue('src/a.ts\n\nsrc/b.ts\n');
+      const { getChangedFiles } = await import('../ui-detector');
+      const files = getChangedFiles('main');
+      expect(files).toEqual(['src/a.ts', 'src/b.ts']);
+    });
+  });
+
   describe('parseRenamedFile', () => {
     it('should extract new path from renamed file', async () => {
       const { parseRenamedFile } = await import('../ui-detector');
@@ -197,4 +213,102 @@ describe('ui-detector', () => {
       expect(rules).toContain('style-.css');
     });
   });
+
+  describe('collectUiMatches', () => {
+    it('should detect UI files in components directory', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['src/components/Button.tsx', 'src/utils/helper.ts']);
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toEqual(['src/components/Button.tsx']);
+      expect(result.matchedRules.length).toBeGreaterThan(0);
+    });
+
+    it('should exclude __tests__ directory files', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['src/__tests__/Button.test.tsx']);
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('excludes files under src/coverage/', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['src/coverage/components/Coverage.tsx']);
+      expect(result.isUiSprint).toBe(false);
+    });
+
+    it('should handle empty file list', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches([]);
+      expect(result.isUiSprint).toBe(false);
+      expect(result.matchedFiles).toEqual([]);
+    });
+
+    it('should collect multiple UI files', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches([
+        'src/components/Header.tsx',
+        'src/utils/api.ts',
+        'views/styles/app.css',
+      ]);
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles).toHaveLength(2);
+    });
+
+    it('should aggregate unique rules across files', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches([
+        'src/components/Button.tsx',
+        'src/components/Card.tsx',
+      ]);
+      expect(result.isUiSprint).toBe(true);
+      expect(result.matchedFiles.length).toBeGreaterThan(0);
+    });
+
+    it('should respect .ui-gate-ignore patterns', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const withoutIgnore = collectUiMatches(['legacy/components/Old.tsx']);
+      expect(withoutIgnore.isUiSprint).toBe(true);
+    });
+  });
+
+  describe('isExcluded and loadUiGateIgnore', () => {
+    it('excludes paths matching **/coverage/** with leading directory', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/coverage/report.html', ['**/coverage/**'])).toBe(true);
+    });
+
+    it('does not match non-excluded paths', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/app.ts', ['**/coverage/**'])).toBe(false);
+    });
+
+    it('returns empty array when .ui-gate-ignore does not exist', async () => {
+      const { loadUiGateIgnore } = await import('../ui-detector');
+      expect(loadUiGateIgnore('/tmp')).toEqual([]);
+    });
+
+    it('excludes paths matching **/node_modules/** with leading directory', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('lib/node_modules/pkg/index.js', ['**/node_modules/**'])).toBe(true);
+    });
+
+    it('excludes paths matching **/dist/** with leading directory', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/dist/bundle.js', ['**/dist/**'])).toBe(true);
+    });
+
+    it('excludes paths matching **/build/** with leading directory', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/build/output.js', ['**/build/**'])).toBe(true);
+    });
+
+    it('excludes paths matching **/__tests__/**', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/__tests__/Button.test.tsx', ['**/__tests__/**'])).toBe(true);
+    });
+
+    it('excludes paths matching **/*.test.*', async () => {
+      const { isExcluded } = await import('../ui-detector');
+      expect(isExcluded('src/Button.test.tsx', ['**/*.test.*'])).toBe(true);
+    });
+  });
 });

package/lib/__tests__/ui-review.test.ts

@@ -0,0 +1,119 @@
+/**
+ * @test ui-review
+ * @intent Verify UI review file generation helpers
+ * @covers UI-REVIEW-001
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+
+vi.mock('child_process', () => ({
+  execSync: vi.fn(),
+}));
+
+const mockExecSync = vi.mocked(execSync);
+const TEST_DIR = join(process.cwd(), '.ui-review-test');
+
+describe('ui-review', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  it('should parse file list and renamed paths', async () => {
+    const { parseFileList } = await import('../ui-review');
+    expect(parseFileList('views/a.html → views/b.html\n\nsrc/auth.ts\n')).toEqual([
+      'views/b.html',
+      'src/auth.ts',
+    ]);
+  });
+
+  it('should return changed files from staged and modified diff', async () => {
+    mockExecSync.mockReturnValue('src/components/Button.tsx\nviews/index.html\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['src/components/Button.tsx', 'views/index.html']);
+  });
+
+  it('should fall back to tracked files when no changes are present', async () => {
+    mockExecSync
+      .mockReturnValueOnce('')
+      .mockReturnValueOnce('src/components/Fallback.tsx\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['src/components/Fallback.tsx']);
+  });
+
+  it('should fall back to find command when git ls-files fails', async () => {
+    mockExecSync
+      .mockReturnValueOnce('')
+      .mockImplementationOnce(() => { throw new Error('not git'); })
+      .mockReturnValueOnce('views/index.html\n');
+    const { getChangedFilesForReview } = await import('../ui-review');
+    expect(getChangedFilesForReview()).toEqual(['views/index.html']);
+  });
+
+  it('should build an approved review result with 24h expiry', async () => {
+    mockExecSync.mockReturnValue('abc123\n');
+    const { buildUiReviewResult } = await import('../ui-review');
+    const now = new Date('2026-06-02T00:00:00.000Z');
+    const result = buildUiReviewResult(['views/index.html'], now);
+    expect(result).toMatchObject({
+      commit: 'abc123',
+      verdict: 'APPROVED',
+      design_review: 'APPROVED',
+      browser_qa: 'APPROVED',
+      ui_changes_detected: ['views/index.html'],
+    });
+    expect(result.expires).toBe('2026-06-03T00:00:00.000Z');
+  });
+
+  it('should run main and exit 0 when no UI changes are detected', async () => {
+    mockExecSync.mockReturnValue('src/auth.ts\n');
+    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => undefined) as never);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const { main } = await import('../ui-review');
+    main();
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(logSpy).toHaveBeenCalledWith('ℹ️ No UI changes detected in staged/modified files.');
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should run main and write result when UI changes are detected', async () => {
+    const cwdSpy = vi.spyOn(process, 'cwd').mockReturnValue(TEST_DIR);
+    mockExecSync
+      .mockReturnValueOnce('views/index.html\n')
+      .mockReturnValueOnce('abc123\n');
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+    const { main } = await import('../ui-review');
+    main();
+    expect(existsSync(join(TEST_DIR, '.ui-gate-result.json'))).toBe(true);
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Generated .ui-gate-result.json'));
+    cwdSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should write .ui-gate-result.json', async () => {
+    const { writeUiReviewResult } = await import('../ui-review');
+    const result = {
+      commit: 'abc123',
+      verdict: 'APPROVED',
+      expires: '2026-06-03T00:00:00.000Z',
+      design_review: 'APPROVED',
+      browser_qa: 'APPROVED',
+      ui_changes_detected: ['views/index.html'],
+    };
+    writeUiReviewResult(result, TEST_DIR);
+    const parsed = JSON.parse(readFileSync(join(TEST_DIR, '.ui-gate-result.json'), 'utf8'));
+    expect(parsed.ui_changes_detected).toEqual(['views/index.html']);
+  });
+});

package/lib/__tests__/uninstall.test.js

@@ -27,6 +27,7 @@ describe('uninstall', () => {
     delete require.cache[require.resolve('../uninstall')];
     delete require.cache[require.resolve('../init')];
     delete require.cache[require.resolve('../detect-deps.js')];
+    delete require.cache[require.resolve('../shared-paths')];
     logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
     errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});

package/lib/detect-deps.js

@@ -3,29 +3,73 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-/**
- * Resolve the user's home directory cross-platform.
- * Fallback chain: HOME → USERPROFILE → os.homedir()
- * This covers all known Windows/Linux/macOS/edge cases.
- */
-const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const SKILLS_DIR = path.join(HOME, '.config', 'opencode', 'skills');
-const OPENCODE_DIR = path.join(HOME, '.config', 'opencode');
+const { HOME_DIR } = require('./shared-paths.js');
 
 const REQUIRED_DEPS = [
-  { name: 'superpowers', minVersion: '1.0.0' },
-  { name: 'gstack', minVersion: '1.0.0' }
+  { name: 'superpowers', repo: 'obra/superpowers', minVersion: '1.0.0' },
+  { name: 'gstack', repo: 'garrytan/gstack', minVersion: '1.0.0' }
 ];
 
-// Platform-specific dependency profiles
-// Qoder has no external skill dependencies (superpowers/gstack not required)
+/**
+ * Platform profiles — each AI agent platform has its own skills directory.
+ * All platforms require the same dependencies (superpowers, gstack).
+ *
+ * @covers Issue #128 Bug 1 — Qoder platform was excluded from dependency checks
+ */
 const PLATFORM_PROFILES = {
-  opencode: { requiredDeps: REQUIRED_DEPS, skillsDirs: [SKILLS_DIR, OPENCODE_DIR] },
-  qoder:    { requiredDeps: [],              skillsDirs: [path.join(HOME, '.qoder', 'skills')] },
-  'claude-code': { requiredDeps: REQUIRED_DEPS, skillsDirs: [SKILLS_DIR, OPENCODE_DIR] },
+  opencode: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.config', 'opencode', 'skills'),
+      path.join(HOME_DIR, '.config', 'opencode'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  'claude-code': {
+    skillsDirs: [
+      path.join(HOME_DIR, '.claude', 'skills'),
+      path.join(HOME_DIR, '.claude'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
+  qoder: {
+    skillsDirs: [
+      path.join(HOME_DIR, '.qoder', 'skills'),
+      path.join(HOME_DIR, '.qoder'),
+    ],
+    requiredDeps: REQUIRED_DEPS,
+  },
 };
 
+/**
+ * Detect which AI agent platform is currently in use.
+ * Checks for platform-specific directories in the user's home.
+ * Falls back to 'opencode' if no platform is detected.
+ *
+ * @returns {'opencode' | 'claude-code' | 'qoder'}
+ */
+function detectPlatform() {
+  // Check for Qoder-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.qoder', 'skills'))) {
+    return 'qoder';
+  }
+  // Check for Claude Code-specific marker
+  if (fs.existsSync(path.join(HOME_DIR, '.claude', 'skills'))) {
+    return 'claude-code';
+  }
+  // Default to opencode (most common, backward compatible)
+  return 'opencode';
+}
+
+/**
+ * Get the skills directories for a given platform.
+ * @param {string} platform - 'opencode' | 'claude-code' | 'qoder'
+ * @returns {string[]}
+ */
+function getSkillsDirs(platform) {
+  const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
+  return profile.skillsDirs;
+}
+
 /**
  * Check if bash is available on the system.
  * XP-Gate hooks are bash scripts — Windows users need Git Bash installed.
@@ -92,30 +136,28 @@ function checkBash() {
   }
 }
 
+/**
+ * Check if required dependencies are installed for the given platform.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, missing?: string, versionMismatch?: object}>}
+ */
 async function checkDeps(platform = 'opencode') {
-  const profile = PLATFORM_PROFILES[platform] || PLATFORM_PROFILES.opencode;
-  const { requiredDeps, skillsDirs } = profile;
-
-  // Qoder and other platforms with no hard dependencies pass immediately
-  if (requiredDeps.length === 0) {
-    return { ok: true, platform };
-  }
+  const skillsDirs = getSkillsDirs(platform);
 
-  for (const dep of requiredDeps) {
-    const possiblePaths = skillsDirs.map(dir => path.join(dir, dep.name));
-    
+  for (const dep of REQUIRED_DEPS) {
     let depDir = null;
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        depDir = p;
+    for (const baseDir of skillsDirs) {
+      const candidate = path.join(baseDir, dep.name);
+      if (fs.existsSync(candidate)) {
+        depDir = candidate;
         break;
       }
     }
-    
+
     if (!depDir) {
       return { ok: false, missing: dep.name };
     }
-    
+
     const version = await getSkillVersion(depDir);
     if (version && compareVersions(version, dep.minVersion) < 0) {
       return {
@@ -128,10 +170,101 @@ async function checkDeps(platform = 'opencode') {
       };
     }
   }
-  
+
   return { ok: true };
 }
 
+/**
+ * Auto-install missing dependencies by cloning from GitHub.
+ * @param {string} [platform='opencode'] - AI agent platform
+ * @returns {Promise<{ok: boolean, installed?: string[], errors?: Array<{name: string, message: string}>}>}
+ */
+async function autoInstallDeps(platform = 'opencode') {
+  const skillsDirs = getSkillsDirs(platform);
+  const targetDir = skillsDirs[0]; // Install to the primary skills directory
+
+  if (!fs.existsSync(targetDir)) {
+    try {
+      fs.mkdirSync(targetDir, { recursive: true });
+    } catch (e) {
+      return {
+        ok: false,
+        errors: [{ name: 'mkdir', message: `Cannot create skills directory: ${e.message}` }]
+      };
+    }
+  }
+
+  const check = await checkDeps(platform);
+  if (check.ok) {
+    return { ok: true, installed: [] };
+  }
+
+  const errors = [];
+  const installed = [];
+
+  // Check each dep: missing → install, version mismatch → can't auto-fix
+  const depCheck = await checkDeps(platform);
+  if (depCheck.ok) {
+    return { ok: true, installed: [] };
+  }
+
+  // If the issue is version mismatch, auto-install can't help
+  if (depCheck.versionMismatch) {
+    return {
+      ok: false,
+      installed: [],
+      errors: [{
+        name: depCheck.versionMismatch.name,
+        message: `version mismatch: need ${depCheck.versionMismatch.required}, found ${depCheck.versionMismatch.found} (auto-install cannot upgrade)`
+      }]
+    };
+  }
+
+  for (const dep of REQUIRED_DEPS) {
+    // Re-check if this specific dep is missing
+    let exists = false;
+    for (const baseDir of skillsDirs) {
+      if (fs.existsSync(path.join(baseDir, dep.name))) {
+        exists = true;
+        break;
+      }
+    }
+    if (exists) continue;
+
+    const destPath = path.join(targetDir, dep.name);
+    const repoUrl = `https://github.com/${dep.repo}.git`;
+
+    try {
+      console.log(`  ${dep.name}: not found → installing from ${repoUrl} ...`);
+      const cp = require('child_process');
+      cp.execSync(`git clone --depth 1 "${repoUrl}" "${destPath}"`, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        timeout: 120000, // 2 minute timeout
+      });
+      installed.push(dep.name);
+      console.log(`  ${dep.name}: OK`);
+    } catch (e) {
+      errors.push({ name: dep.name, message: e.message || 'git clone failed' });
+      console.warn(`  ${dep.name}: FAILED (${e.message || 'unknown error'})`);
+      // Clean up partial clone
+      try {
+        if (fs.existsSync(destPath)) {
+          fs.rmSync(destPath, { recursive: true, force: true });
+        }
+      } catch {
+        // Ignore cleanup failures
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, installed, errors };
+  }
+
+  return { ok: true, installed };
+}
+
 async function getSkillVersion(skillDir) {
   const pkgFile = path.join(skillDir, 'package.json');
   if (fs.existsSync(pkgFile)) {
@@ -140,7 +273,7 @@ async function getSkillVersion(skillDir) {
       return pkg.version;
     } catch {}
   }
-  
+
   const skillFile = path.join(skillDir, 'SKILL.md');
   if (fs.existsSync(skillFile)) {
     const content = fs.readFileSync(skillFile, 'utf8');
@@ -149,22 +282,30 @@ async function getSkillVersion(skillDir) {
       return versionMatch[1];
     }
   }
-  
+
   return null;
 }
 
 function compareVersions(a, b) {
   const partsA = a.split('.').map(Number);
   const partsB = b.split('.').map(Number);
-  
+
   for (let i = 0; i < 3; i++) {
     const partA = partsA[i] || 0;
     const partB = partsB[i] || 0;
     if (partA > partB) return 1;
     if (partA < partB) return -1;
   }
-  
+
   return 0;
 }
 
-module.exports = { checkDeps, checkBash };
+module.exports = {
+  checkDeps,
+  checkBash,
+  autoInstallDeps,
+  detectPlatform,
+  getSkillsDirs,
+  PLATFORM_PROFILES,
+  REQUIRED_DEPS,
+};

package/lib/doctor.js

@@ -1,15 +1,13 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const { execSync } = require('child_process');
-
-// Cross-platform home directory resolution
-const HOME_DIR = process.env.HOME || process.env.USERPROFILE || os.homedir();
-
-const CONFIG_DIR = path.join(HOME_DIR, '.config', 'xp-gate');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'xp-gate.json');
-const GLOBAL_HOOKS_DIR = path.join(CONFIG_DIR, 'hooks');
-const GLOBAL_ADAPTERS_DIR = path.join(CONFIG_DIR, 'adapters');
+const {
+  HOME_DIR,
+  CONFIG_DIR,
+  CONFIG_FILE,
+  GLOBAL_HOOKS_DIR,
+  GLOBAL_ADAPTERS_DIR,
+} = require('./shared-paths.js');
 
 // npm package source dir (template hooks/adapters)
 const PKG_DIR = path.dirname(__dirname);

package/lib/gate-audit.ts

@@ -177,64 +177,44 @@ export function computeStats(
  * Renames current file to .1, shifts existing archives.
  * Keeps at most MAX_ARCHIVES archived files.
  */
-export function rotateIfNeeded(logPath: string): void {
-  if (!existsSync(logPath)) {
-    return;
-  }
-
-  let stats;
+function shouldRotate(logPath: string): boolean {
+  if (!existsSync(logPath)) return false;
   try {
-    stats = statSync(logPath);
+    return statSync(logPath).size >= MAX_FILE_BYTES;
   } catch {
-    return;
-  }
-
-  if (stats.size < MAX_FILE_BYTES) {
-    return;
+    return false;
   }
+}
 
-  // Shift archives: .2 -> .3, .1 -> .2
+function shiftOldArchives(logPath: string): void {
   for (let i = MAX_ARCHIVES; i >= 2; i--) {
     const from = `${logPath}.${i - 1}`;
     const to = `${logPath}.${i}`;
     if (existsSync(from)) {
-      try {
-        renameSync(from, to);
-      } catch {
-        // Race condition or permission issue — skip
-      }
+      try { renameSync(from, to); } catch { /* skip */ }
     }
   }
+}
 
-  // Current -> .1
-  const firstArchive = `${logPath}.1`;
-  if (existsSync(firstArchive)) {
-    try {
-      renameSync(firstArchive, `${logPath}.2`);
-    } catch {
-      // Skip on error
-    }
+function archiveCurrent(logPath: string): void {
+  const first = `${logPath}.1`;
+  if (existsSync(first)) {
+    try { renameSync(first, `${logPath}.2`); } catch { /* skip */ }
   }
-
   try {
-    renameSync(logPath, firstArchive);
+    renameSync(logPath, first);
   } catch {
-    // If rename fails, truncate the current file instead
-    try {
-      writeFileSync(logPath, '', 'utf8');
-    } catch {
-      console.error('[xp-gate audit] Failed to rotate or truncate log:', logPath);
-    }
+    try { writeFileSync(logPath, '', 'utf8'); } catch { /* skip */ }
   }
 }
 
-// ── CLI entry point (direct invocation from hooks) ───────────────────────────
+export function rotateIfNeeded(logPath: string): void {
+  if (!shouldRotate(logPath)) return;
+  shiftOldArchives(logPath);
+  archiveCurrent(logPath);
+}
 
-/**
- * When called directly via `npx tsx gate-audit.ts record --gate-id ...`,
- * this block handles CLI argument parsing and appends the entry.
- */
-if (require.main === module) {
+function runCli(): void {
   const args = process.argv.slice(2);
   const command = args[0];
 
@@ -258,7 +238,11 @@ if (require.main === module) {
   }
 }
 
-function parseCliOptions(args: string[]): Record<string, string> {
+if (require.main === module) {
+  runCli();
+}
+
+export function parseCliOptions(args: string[]): Record<string, string> {
   const opts: Record<string, string> = {};
   for (let i = 0; i < args.length; i++) {
     if (args[i].startsWith('--') && i + 1 < args.length) {
@@ -269,7 +253,7 @@ function parseCliOptions(args: string[]): Record<string, string> {
   return opts;
 }
 
-function getCommitHash(): string {
+export function getCommitHash(): string {
   try {
     const { execSync } = require('child_process');
     return execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();