@boyingliu01/xp-gate 0.6.0 → 0.6.1

package/lib/__tests__/audit-log.test.ts

@@ -0,0 +1,107 @@
+/**
+ * @test audit-log
+ * @intent Verify UI gate bypass audit logging and threshold reporting
+ * @covers AUDIT-LOG-001
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import {
+  appendAuditEntry,
+  readAllEntries,
+  countBypassesInWindow,
+  exceedsBypassThreshold,
+  formatRetroReport,
+  type AuditEntry,
+} from '../audit-log';
+
+const TEST_DIR = join(process.cwd(), '.audit-log-test');
+
+function baseEntry(overrides: Partial<Omit<AuditEntry, 'gate_count'>> = {}): Omit<AuditEntry, 'gate_count'> {
+  return {
+    timestamp: new Date().toISOString(),
+    branch: 'main',
+    commit: 'abc123',
+    user: 'tester',
+    reason: 'manual approval for test',
+    bypass_type: 'ui-gates',
+    ...overrides,
+  };
+}
+
+describe('audit-log', () => {
+  beforeEach(() => {
+    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 });
+    }
+  });
+
+  describe('appendAuditEntry and readAllEntries', () => {
+    it('should append an entry and compute gate_count', () => {
+      const first = appendAuditEntry(baseEntry(), TEST_DIR);
+      const second = appendAuditEntry(baseEntry({ commit: 'def456' }), TEST_DIR);
+
+      expect(first.gate_count).toBe(0);
+      expect(second.gate_count).toBe(1);
+
+      const entries = readAllEntries(join(TEST_DIR, '.audit-log.jsonl'));
+      expect(entries).toHaveLength(2);
+      expect(entries[1].commit).toBe('def456');
+    });
+
+    it('should return empty array when log file is missing or empty', () => {
+      expect(readAllEntries(join(TEST_DIR, 'missing.jsonl'))).toEqual([]);
+      const emptyLog = join(TEST_DIR, '.audit-log.jsonl');
+      writeFileSync(emptyLog, '', 'utf8');
+      expect(readAllEntries(emptyLog)).toEqual([]);
+    });
+  });
+
+  describe('rolling window calculations', () => {
+    it('should count only matching bypass type in rolling window', () => {
+      const now = new Date();
+      const old = new Date(now.getTime() - 40 * 24 * 60 * 60 * 1000).toISOString();
+      const entries: AuditEntry[] = [
+        { ...baseEntry({ timestamp: now.toISOString(), bypass_type: 'ui-gates' }), gate_count: 0 },
+        { ...baseEntry({ timestamp: now.toISOString(), bypass_type: 'other' }), gate_count: 0 },
+        { ...baseEntry({ timestamp: old, bypass_type: 'ui-gates' }), gate_count: 0 },
+      ];
+
+      expect(countBypassesInWindow(entries, 'ui-gates')).toBe(1);
+    });
+
+    it('should report threshold exceedance', () => {
+      const entries: AuditEntry[] = Array.from({ length: 4 }, (_, i) => ({
+        ...baseEntry({ commit: `commit-${i}` }),
+        gate_count: i,
+      }));
+      expect(exceedsBypassThreshold(entries, 'ui-gates')).toEqual({ exceeded: true, count: 4 });
+    });
+  });
+
+  describe('formatRetroReport', () => {
+    it('should include recent bypasses and threshold warning', () => {
+      const entries: AuditEntry[] = Array.from({ length: 4 }, (_, i) => ({
+        ...baseEntry({ reason: `reason-${i}`, branch: `branch-${i}` }),
+        gate_count: i,
+      }));
+      const report = formatRetroReport(entries, 'ui-gates');
+      expect(report).toContain('Last 30 days: 4 bypasses');
+      expect(report).toContain('EXCEEDS threshold');
+      expect(report).toContain('reason-3');
+    });
+
+    it('should omit recent section when no matching bypasses exist', () => {
+      const report = formatRetroReport([], 'ui-gates');
+      expect(report).toContain('Last 30 days: 0 bypasses');
+      expect(report).not.toContain('Recent bypasses');
+    });
+  });
+});

package/lib/__tests__/gate-audit.test.ts

@@ -11,6 +11,8 @@ import {
   readTailEntries,
   computeStats,
   rotateIfNeeded,
+  parseCliOptions,
+  getCommitHash,
   type GateAuditEntry,
 } from '../gate-audit';
 
@@ -114,6 +116,28 @@ describe('gate-audit', () => {
       const tail = readTailEntries(undefined, repoRoot);
       expect(tail.length).toBe(20);
     });
+
+    it('should skip malformed JSON lines', () => {
+      const repoRoot = join(TEST_DIR, 'malformed-tail');
+      const logDir = join(repoRoot, '.xp-gate');
+      mkdirSync(logDir, { recursive: true });
+      writeFileSync(
+        join(logDir, 'audit.jsonl'),
+        `not-json\n${JSON.stringify(makeEntry({ repo_path: repoRoot, gate_id: 'gate-valid' }))}\n`,
+        'utf8',
+      );
+      const tail = readTailEntries(10, repoRoot);
+      expect(tail.length).toBe(1);
+      expect(tail[0].gate_id).toBe('gate-valid');
+    });
+
+    it('should return empty array for empty log file', () => {
+      const repoRoot = join(TEST_DIR, 'empty-log');
+      const logDir = join(repoRoot, '.xp-gate');
+      mkdirSync(logDir, { recursive: true });
+      writeFileSync(join(logDir, 'audit.jsonl'), '', 'utf8');
+      expect(readTailEntries(10, repoRoot)).toEqual([]);
+    });
   });
 
   describe('computeStats', () => {
@@ -153,6 +177,41 @@ describe('gate-audit', () => {
       const stats = computeStats(repoRoot);
       expect(stats[0].avg_issues).toBe(2.67);
     });
+
+    it('should return empty array for empty stats log', () => {
+      const repoRoot = join(TEST_DIR, 'empty-stats-log');
+      const logDir = join(repoRoot, '.xp-gate');
+      mkdirSync(logDir, { recursive: true });
+      writeFileSync(join(logDir, 'audit.jsonl'), '', 'utf8');
+      expect(computeStats(repoRoot)).toEqual([]);
+    });
+
+    it('should skip malformed lines during stats aggregation', () => {
+      const repoRoot = join(TEST_DIR, 'malformed-stats');
+      const logDir = join(repoRoot, '.xp-gate');
+      mkdirSync(logDir, { recursive: true });
+      writeFileSync(
+        join(logDir, 'audit.jsonl'),
+        `${JSON.stringify(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1' }))}\n{bad json}\n`,
+        'utf8',
+      );
+      const stats = computeStats(repoRoot);
+      expect(stats).toHaveLength(1);
+      expect(stats[0].gate_id).toBe('gate-1');
+    });
+  });
+
+  describe('CLI helpers', () => {
+    it('should parse CLI options and skip dangling flags', () => {
+      expect(parseCliOptions(['--gate-id', 'gate-1', '--passed', 'true', '--dangling'])).toEqual({
+        'gate-id': 'gate-1',
+        passed: 'true',
+      });
+    });
+
+    it('should return a commit hash string or unknown', () => {
+      expect(typeof getCommitHash()).toBe('string');
+    });
   });
 
   describe('rotateIfNeeded', () => {

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

@@ -114,7 +114,63 @@ describe('ui-detector', () => {
     it('should handle git command failure gracefully', async () => {
       mockExecSync.mockImplementation(() => {
         throw new Error('git not available');
-      });
+  describe('collectUiMatches and detectUiSprint', () => {
+    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 test files from matching', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['src/components/Button.test.tsx']);
+      expect(result.isUiSprint).toBe(false);
+      expect(result.matchedFiles).toEqual([]);
+    });
+
+    it('should exclude coverage directory files', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['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);
+    });
+  });
+});
       const { detectUiSprint } = await import('../ui-detector');
       const result = detectUiSprint();
       expect(result.isUiSprint).toBe(false);
@@ -197,4 +253,59 @@ 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('should exclude src/__snapshots__ directory files', async () => {
+      const { collectUiMatches } = await import('../ui-detector');
+      const result = collectUiMatches(['src/__snapshots__/Button.test.tsx.snap']);
+      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);
+    });
+
+    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 collect 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);
+    });
+  });
 });

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/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();

package/lib/install-skill.js

@@ -144,21 +144,7 @@ async function downloadFile(url, dest, verbose) {
   });
 }
 
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
+const { copyDirRecursive } = require('./shared-utils');
 
 function ensureConfigDir() {
   fs.mkdirSync(CONFIG_DIR, { recursive: true });

package/lib/rollback.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { copyDirRecursive } = require('./shared-utils');
 
 // Cross-platform home directory resolution
 const HOME = process.env.HOME || process.env.USERPROFILE || os.homedir();
@@ -51,22 +52,6 @@ async function createBackup(installId, skillName) {
   return backupDir;
 }
 
-function copyDirRecursive(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  const entries = fs.readdirSync(src, { withFileTypes: true });
-  
-  for (const entry of entries) {
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
-    
-    if (entry.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      fs.copyFileSync(srcPath, destPath);
-    }
-  }
-}
-
 function cleanupBackup(installId) {
   const backupDir = path.join(BACKUP_DIR, installId);
   

package/lib/shared-utils.js

@@ -0,0 +1,25 @@
+/**
+ * Pure utility functions shared by CLI modules.
+ * No module-level state — safe for tests that mock fs/path/os.
+ */
+const fs = require('fs');
+
+/**
+ * Recursively copy a directory.
+ * Pure function: only uses fs/path params, no global config.
+ */
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = require('path').join(src, entry.name);
+    const destPath = require('path').join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = { copyDirRecursive };