@boyingliu01/xp-gate 0.5.2 → 0.6.0

package/bin/xp-gate.js

@@ -53,6 +53,11 @@ const COMMANDS = {
     description: 'Run UI review for non-sprint developers (generates .ui-gate-result.json)',
     fn: null,
     usage: 'xp-gate ui-review'
+  },
+  'audit': {
+    description: 'Gate audit logging (record, --tail, --stats)',
+    fn: null,
+    usage: 'xp-gate audit [--tail [N]|--stats|record --gate-id X --gate-name Y ...]'
   }
 };
 
@@ -153,12 +158,132 @@ function main() {
       process.exit(1);
     }
   }
+
+  if (command === 'audit') {
+    handleAudit(subargs);
+    return;
+  }
   
   console.error(`Unknown command: ${command}`);
   printHelp();
   process.exit(1);
 }
 
+function handleAudit(args) {
+  const path = require('path');
+  const auditPath = path.join(__dirname, '..', 'lib', 'gate-audit.ts');
+
+  // --tail [N]
+  const tailIdx = args.indexOf('--tail');
+  if (tailIdx !== -1) {
+    const count = parseInt(args[tailIdx + 1] || '20', 10);
+    try {
+      const { readTailEntries } = require(auditPath);
+      const entries = readTailEntries(count);
+      if (entries.length === 0) {
+        console.log('No audit entries found.');
+        return;
+      }
+      printAuditTable(entries);
+    } catch (err) {
+      console.error('Error reading audit entries:', err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // --stats
+  if (args.includes('--stats')) {
+    try {
+      const { computeStats } = require(auditPath);
+      const stats = computeStats();
+      if (stats.length === 0) {
+        console.log('No audit data found.');
+        return;
+      }
+      printStatsTable(stats);
+    } catch (err) {
+      console.error('Error computing stats:', err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // record --gate-id X --gate-name Y --passed true/false ...
+  if (args[0] === 'record') {
+    try {
+      const { appendAuditEntry } = require(auditPath);
+      const rest = args.slice(1);
+      const opts = {};
+      for (let i = 0; i < rest.length; i++) {
+        if (rest[i].startsWith('--') && i + 1 < rest.length) {
+          opts[rest[i].slice(2)] = rest[i + 1];
+          i++;
+        }
+      }
+      const entry = {
+        timestamp: new Date().toISOString(),
+        gate_id: opts['gate-id'] || 'unknown',
+        gate_name: opts['gate-name'] || 'unknown',
+        passed: opts['passed'] === 'true',
+        issues_found: parseInt(opts['issues-found'] || '0', 10),
+        duration_ms: parseInt(opts['duration-ms'] || '0', 10),
+        trigger: opts['trigger'] || 'manual',
+        repo_path: process.cwd(),
+        commit_hash: opts['commit-hash'] || 'HEAD',
+      };
+      appendAuditEntry(entry);
+    } catch (err) {
+      console.error('Error recording audit entry:', err.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  console.error('Error: Unknown audit subcommand or missing flag');
+  console.error('Usage:');
+  console.error('  xp-gate audit record --gate-id X --gate-name Y --passed true/false --issues-found N --duration-ms N --trigger commit');
+  console.error('  xp-gate audit --tail [N]     (default: 20)');
+  console.error('  xp-gate audit --stats');
+  process.exit(1);
+}
+
+function printAuditTable(entries) {
+  console.log('');
+  console.log('Recent Audit Entries:');
+  console.log('┌─────────────────────┬──────────┬─────────────────────┬────────┬────────┬───────────┬──────────┐');
+  console.log('│ Timestamp           │ Gate     │ Name                │ Passed │ Issues │ Duration  │ Trigger  │');
+  console.log('├─────────────────────┼──────────┼─────────────────────┼────────┼────────┼───────────┼──────────┤');
+  for (const e of entries) {
+    const ts = e.timestamp ? e.timestamp.slice(0, 19) : 'N/A';
+    const gid = (e.gate_id || '').padEnd(8);
+    const gname = (e.gate_name || '').slice(0, 19).padEnd(19);
+    const pass = (e.passed ? 'Y' : 'N').padEnd(6);
+    const issues = String(e.issues_found ?? 0).padEnd(6);
+    const dur = String(e.duration_ms ?? 0).padEnd(9);
+    const trig = (e.trigger || 'manual').padEnd(8);
+    console.log(`│ ${ts} │ ${gid} │ ${gname} │ ${pass} │ ${issues} │ ${dur} │ ${trig} │`);
+  }
+  console.log('└─────────────────────┴──────────┴─────────────────────┴────────┴────────┴───────────┴──────────┘');
+  console.log(`Total: ${entries.length} entries`);
+}
+
+function printStatsTable(stats) {
+  console.log('');
+  console.log('Gate Statistics:');
+  console.log('┌──────────────────┬────────┬────────┬────────────┐');
+  console.log('│ Gate             │ Pass%  │ Avg ms │ Issues Avg │');
+  console.log('├──────────────────┼────────┼────────┼────────────┤');
+  for (const s of stats) {
+    const gid = (s.gate_id || '').slice(0, 16).padEnd(16);
+    const pp = (s.pass_pct || 'N/A').padEnd(6);
+    const avg = String(s.avg_ms ?? 0).padEnd(6);
+    const iss = String(s.avg_issues ?? 0).padEnd(10);
+    console.log(`│ ${gid} │ ${pp} │ ${avg} │ ${iss} │`);
+  }
+  console.log('└──────────────────┴────────┴────────┴────────────┘');
+}
+
 function parseOptions(args) {
   const options = { offline: false, verbose: false, force: false, all: false, check: false };
   for (const arg of args) {

package/hooks/pre-push

@@ -185,20 +185,29 @@ else
   for test_file in $ALL_PUSHED_TEST_FILES; do
     if [ -f "$test_file" ]; then
       # Count mock keyword references (precise patterns only)
+      # Use grep -o piped to wc -l for reliable single-number output (grep -c can emit
+      # multi-line output with filenames under some grep versions, causing bash arithmetic
+      # syntax errors). grep -o extracts each match on its own line, wc -l counts them.
       MOCK_COUNT=0
       for kw in 'jest\.mock' 'vi\.mock' 'jest\.spyOn' 'vi\.spyOn' 'jest\.fn' 'vi\.fn' \
                 'mockResolvedValue' 'mockRejectedValue' 'mockReturnValue' 'mockImplementation' \
                 'createMock' 'mockReset' 'mockClear' 'mockRestore' 'MagicMock' 'unittest\.mock' \
-                '\.patch(' 'gomock' 'mockgen' '.EXPECT()'; do
-        c=$(grep -o -c "$kw" "$test_file" 2>/dev/null || echo "0")
+                '\.patch(' 'gomock' 'mockgen' '\.EXPECT()'; do
+        c=$(grep -o "$kw" "$test_file" 2>/dev/null | wc -l || echo "0")
+        # Guard against empty/non-numeric values that break bash arithmetic
+        c=${c//[^0-9]/}
+        c=${c:-0}
         MOCK_COUNT=$((MOCK_COUNT + c))
       done
 
       # Count total non-empty, non-comment lines for density denominator
       TOTAL_LINES=$(grep -v '^\s*$' "$test_file" | grep -v '^\s*//' | grep -v '^\s*\*' | grep -v '^\s*#' | wc -l | awk '{print $1}')
+      TOTAL_LINES=${TOTAL_LINES//[^0-9]/}
+      TOTAL_LINES=${TOTAL_LINES:-0}
 
       if [ "$TOTAL_LINES" -gt 0 ] 2>/dev/null; then
         MOCK_DENSITY=$(awk "BEGIN {printf \"%.1f\", ($MOCK_COUNT / $TOTAL_LINES) * 100}")
+        MOCK_DENSITY=${MOCK_DENSITY:-"0"}
       else
         MOCK_DENSITY="0"
       fi

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

@@ -0,0 +1,199 @@
+/**
+ * @test Gate Audit Logger
+ * @intent Verify JSONL audit logging for quality gate executions
+ * @covers AUDIT-001-01, AUDIT-001-02, AUDIT-001-03, AUDIT-001-04, AUDIT-001-05, AUDIT-001-06
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdirSync, rmSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import {
+  appendAuditEntry,
+  readTailEntries,
+  computeStats,
+  rotateIfNeeded,
+  type GateAuditEntry,
+} from '../gate-audit';
+
+const TEST_DIR = join(process.cwd(), '.xp-gate-test');
+
+function makeEntry(overrides: Partial<GateAuditEntry> = {}): GateAuditEntry {
+  return {
+    timestamp: new Date().toISOString(),
+    gate_id: 'gate-1',
+    gate_name: 'code-quality',
+    passed: true,
+    issues_found: 0,
+    duration_ms: 100,
+    trigger: 'commit',
+    repo_path: TEST_DIR,
+    commit_hash: 'abc123',
+    ...overrides,
+  };
+}
+
+describe('gate-audit', () => {
+  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', () => {
+    it('should create .xp-gate/ directory on first write', () => {
+      const repoRoot = join(TEST_DIR, 'new-project');
+      appendAuditEntry(makeEntry({ repo_path: repoRoot }), repoRoot);
+      expect(existsSync(join(repoRoot, '.xp-gate'))).toBe(true);
+    });
+
+    it('should write valid JSONL', () => {
+      const repoRoot = join(TEST_DIR, 'jsonl-test');
+      const entry = makeEntry({ repo_path: repoRoot, gate_id: 'gate-2', gate_name: 'dup-code' });
+      appendAuditEntry(entry, repoRoot);
+
+      const logPath = join(repoRoot, '.xp-gate', 'audit.jsonl');
+      expect(existsSync(logPath)).toBe(true);
+
+      const content = readFileSync(logPath, 'utf8').trim();
+      const parsed = JSON.parse(content) as GateAuditEntry;
+      expect(parsed.gate_id).toBe('gate-2');
+      expect(parsed.gate_name).toBe('dup-code');
+      expect(typeof parsed.timestamp).toBe('string');
+    });
+
+    it('should append multiple entries as separate lines', () => {
+      const repoRoot = join(TEST_DIR, 'multi-test');
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1' }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-2' }), repoRoot);
+
+      const logPath = join(repoRoot, '.xp-gate', 'audit.jsonl');
+      const lines = readFileSync(logPath, 'utf8').trim().split('\n');
+      expect(lines.length).toBe(2);
+      expect(JSON.parse(lines[0]).gate_id).toBe('gate-1');
+      expect(JSON.parse(lines[1]).gate_id).toBe('gate-2');
+    });
+
+    it('should never throw even when filesystem is broken', () => {
+      const badPath = '/nonexistent/path/that/cannot/exist/for/real';
+      expect(() => appendAuditEntry(makeEntry({ repo_path: badPath }), badPath)).not.toThrow();
+    });
+  });
+
+  describe('readTailEntries', () => {
+    it('should return last N entries', () => {
+      const repoRoot = join(TEST_DIR, 'tail-test');
+      for (let i = 1; i <= 30; i++) {
+        appendAuditEntry(
+          makeEntry({ repo_path: repoRoot, gate_id: `gate-${i % 3}`, duration_ms: i * 10 }),
+          repoRoot,
+        );
+      }
+
+      const tail = readTailEntries(5, repoRoot);
+      expect(tail.length).toBe(5);
+      expect(tail[0].duration_ms).toBe(260);
+      expect(tail[4].duration_ms).toBe(300);
+    });
+
+    it('should return empty array when log does not exist', () => {
+      const result = readTailEntries(10, join(TEST_DIR, 'empty-project'));
+      expect(result).toEqual([]);
+    });
+
+    it('should default to 20 entries', () => {
+      const repoRoot = join(TEST_DIR, 'default-tail');
+      for (let i = 0; i < 50; i++) {
+        appendAuditEntry(makeEntry({ repo_path: repoRoot, duration_ms: i }), repoRoot);
+      }
+      const tail = readTailEntries(undefined, repoRoot);
+      expect(tail.length).toBe(20);
+    });
+  });
+
+  describe('computeStats', () => {
+    it('should aggregate per-gate statistics correctly', () => {
+      const repoRoot = join(TEST_DIR, 'stats-test');
+      // gate-1: 3 runs, 2 passed, durations 100+200+300
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', passed: true, duration_ms: 100 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', passed: true, duration_ms: 200 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-1', passed: false, duration_ms: 300 }), repoRoot);
+      // gate-2: 2 runs, 2 passed
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-2', passed: true, duration_ms: 50 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-2', passed: true, duration_ms: 150 }), repoRoot);
+
+      const stats = computeStats(repoRoot);
+      expect(stats.length).toBe(2);
+
+      const g1 = stats.find(s => s.gate_id === 'gate-1')!;
+      expect(g1.pass_pct).toBe('66.7%');
+      expect(g1.avg_ms).toBe(200);
+
+      const g2 = stats.find(s => s.gate_id === 'gate-2')!;
+      expect(g2.pass_pct).toBe('100.0%');
+      expect(g2.avg_ms).toBe(100);
+    });
+
+    it('should return empty array when no log exists', () => {
+      const result = computeStats(join(TEST_DIR, 'no-stats'));
+      expect(result).toEqual([]);
+    });
+
+    it('should calculate avg_issues correctly', () => {
+      const repoRoot = join(TEST_DIR, 'issues-test');
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-3', issues_found: 5 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-3', issues_found: 3 }), repoRoot);
+      appendAuditEntry(makeEntry({ repo_path: repoRoot, gate_id: 'gate-3', issues_found: 0 }), repoRoot);
+
+      const stats = computeStats(repoRoot);
+      expect(stats[0].avg_issues).toBe(2.67);
+    });
+  });
+
+  describe('rotateIfNeeded', () => {
+    it('should not rotate when file is under 10MB', () => {
+      const logPath = join(TEST_DIR, 'small-log', '.xp-gate', 'audit.jsonl');
+      mkdirSync(join(TEST_DIR, 'small-log', '.xp-gate'), { recursive: true });
+      writeFileSync(logPath, 'small content', 'utf8');
+
+      rotateIfNeeded(logPath);
+      expect(existsSync(logPath)).toBe(true);
+      expect(existsSync(`${logPath}.1`)).toBe(false);
+    });
+
+    it('should rotate when file exceeds 10MB', () => {
+      const logPath = join(TEST_DIR, 'big-log', '.xp-gate', 'audit.jsonl');
+      mkdirSync(join(TEST_DIR, 'big-log', '.xp-gate'), { recursive: true });
+
+      // Write > 10MB of data
+      const bigContent = 'x'.repeat(10 * 1024 * 1024 + 100);
+      writeFileSync(logPath, bigContent, 'utf8');
+
+      rotateIfNeeded(logPath);
+      expect(existsSync(`${logPath}.1`)).toBe(true);
+    });
+
+    it('should keep max 3 archives', () => {
+      const logPath = join(TEST_DIR, 'archive-test', '.xp-gate', 'audit.jsonl');
+      mkdirSync(join(TEST_DIR, 'archive-test', '.xp-gate'), { recursive: true });
+      const bigContent = 'x'.repeat(10 * 1024 * 1024 + 100);
+
+      // Create 3 rotations
+      for (let i = 0; i < 3; i++) {
+        writeFileSync(logPath, `${bigContent} round ${i}`, 'utf8');
+        rotateIfNeeded(logPath);
+      }
+
+      // Should have .1, .2, .3 but NOT .4
+      expect(existsSync(`${logPath}.1`)).toBe(true);
+      expect(existsSync(`${logPath}.2`)).toBe(true);
+      expect(existsSync(`${logPath}.3`)).toBe(true);
+      expect(existsSync(`${logPath}.4`)).toBe(false);
+    });
+  });
+});

package/lib/gate-audit.ts

@@ -0,0 +1,279 @@
+/**
+ * Gate Audit Logger — structured JSONL audit for quality gate executions.
+ *
+ * Log file: .xp-gate/audit.jsonl
+ * Rotation: max 10 MB, rename to .1, keep up to 3 archives.
+ * Fail-safe: write errors never block the caller.
+ */
+import {
+  existsSync,
+  mkdirSync,
+  appendFileSync,
+  writeFileSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  chmodSync,
+} from 'fs';
+import { join } from 'path';
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const AUDIT_DIR = '.xp-gate';
+const AUDIT_FILE = 'audit.jsonl';
+const MAX_FILE_BYTES = 10 * 1024 * 1024; // 10 MB
+const MAX_ARCHIVES = 3;
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface GateAuditEntry {
+  timestamp: string;
+  gate_id: string;
+  gate_name: string;
+  passed: boolean;
+  issues_found: number;
+  duration_ms: number;
+  trigger: 'commit' | 'push' | 'manual';
+  repo_path: string;
+  commit_hash: string;
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Append one audit entry to .xp-gate/audit.jsonl.
+ * Creates the directory lazily on first write.
+ * NEVER throws — errors are logged to stderr only.
+ */
+export function appendAuditEntry(
+  entry: GateAuditEntry,
+  repoRoot: string = process.cwd(),
+): void {
+  try {
+    const logPath = join(repoRoot, AUDIT_DIR, AUDIT_FILE);
+
+    // Lazy-create directory
+    const dirPath = join(repoRoot, AUDIT_DIR);
+    if (!existsSync(dirPath)) {
+      mkdirSync(dirPath, { recursive: true });
+    }
+
+    // Rotate before write if file is too large
+    rotateIfNeeded(logPath);
+
+    const line = JSON.stringify(entry) + '\n';
+
+    // POSIX append with atomic semantics
+    try {
+      appendFileSync(logPath, line, 'utf8');
+      // Set restrictive permissions on first write (idempotent)
+      try {
+        chmodSync(logPath, 0o600);
+      } catch {
+        // chmod may fail on some filesystems — non-fatal
+      }
+    } catch {
+      // Windows fallback: open with 'a' flag
+      writeFileSync(logPath, line, { flag: 'a', encoding: 'utf8' });
+    }
+  } catch (err) {
+    // Fail-safe: never propagate errors to caller
+    console.error('[xp-gate audit] Failed to append entry:', (err as Error).message);
+  }
+}
+
+/**
+ * Read the last N entries from the audit log.
+ */
+export function readTailEntries(
+  count: number = 20,
+  repoRoot: string = process.cwd(),
+): GateAuditEntry[] {
+  const logPath = join(repoRoot, AUDIT_DIR, AUDIT_FILE);
+  if (!existsSync(logPath)) {
+    return [];
+  }
+
+  const content = readFileSync(logPath, 'utf8').trim();
+  if (!content) {
+    return [];
+  }
+
+  const allLines = content.split('\n');
+  const tailLines = allLines.slice(-count);
+  const entries: GateAuditEntry[] = [];
+
+  for (const line of tailLines) {
+    if (line.trim()) {
+      try {
+        entries.push(JSON.parse(line) as GateAuditEntry);
+      } catch {
+        // Skip malformed lines
+      }
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Compute per-gate aggregate statistics.
+ */
+export function computeStats(
+  repoRoot: string = process.cwd(),
+): { gate_id: string; pass_pct: string; avg_ms: number; avg_issues: number }[] {
+  const logPath = join(repoRoot, AUDIT_DIR, AUDIT_FILE);
+  if (!existsSync(logPath)) {
+    return [];
+  }
+
+  const content = readFileSync(logPath, 'utf8').trim();
+  if (!content) {
+    return [];
+  }
+
+  // Parse all valid entries
+  const entries: GateAuditEntry[] = [];
+  for (const line of content.split('\n')) {
+    if (line.trim()) {
+      try {
+        entries.push(JSON.parse(line) as GateAuditEntry);
+      } catch {
+        // Skip malformed
+      }
+    }
+  }
+
+  // Aggregate by gate_id
+  const buckets = new Map<string, { total: number; passed: number; ms: number; issues: number }>();
+
+  for (const e of entries) {
+    const b = buckets.get(e.gate_id) ?? { total: 0, passed: 0, ms: 0, issues: 0 };
+    b.total += 1;
+    if (e.passed) b.passed += 1;
+    b.ms += e.duration_ms;
+    b.issues += e.issues_found;
+    buckets.set(e.gate_id, b);
+  }
+
+  const results: { gate_id: string; pass_pct: string; avg_ms: number; avg_issues: number }[] = [];
+
+  for (const [gate_id, b] of Array.from(buckets.entries())) {
+    results.push({
+      gate_id,
+      pass_pct: (b.total > 0 ? ((b.passed / b.total) * 100).toFixed(1) + '%' : 'N/A'),
+      avg_ms: b.total > 0 ? Math.round(b.ms / b.total) : 0,
+      avg_issues: b.total > 0 ? parseFloat((b.issues / b.total).toFixed(2)) : 0,
+    });
+  }
+
+  // Sort by gate_id for stable output
+  results.sort((a, b) => a.gate_id.localeCompare(b.gate_id));
+  return results;
+}
+
+/**
+ * Rotate the audit log if it exceeds MAX_FILE_BYTES.
+ * 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;
+  try {
+    stats = statSync(logPath);
+  } catch {
+    return;
+  }
+
+  if (stats.size < MAX_FILE_BYTES) {
+    return;
+  }
+
+  // Shift archives: .2 -> .3, .1 -> .2
+  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
+      }
+    }
+  }
+
+  // Current -> .1
+  const firstArchive = `${logPath}.1`;
+  if (existsSync(firstArchive)) {
+    try {
+      renameSync(firstArchive, `${logPath}.2`);
+    } catch {
+      // Skip on error
+    }
+  }
+
+  try {
+    renameSync(logPath, firstArchive);
+  } 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);
+    }
+  }
+}
+
+// ── CLI entry point (direct invocation from hooks) ───────────────────────────
+
+/**
+ * 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) {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  if (command === 'record') {
+    const opts = parseCliOptions(args.slice(1));
+    const entry: GateAuditEntry = {
+      timestamp: new Date().toISOString(),
+      gate_id: opts['gate-id'] || 'unknown',
+      gate_name: opts['gate-name'] || 'unknown',
+      passed: opts['passed'] === 'true',
+      issues_found: parseInt(opts['issues-found'] || '0', 10),
+      duration_ms: parseInt(opts['duration-ms'] || '0', 10),
+      trigger: (opts['trigger'] as 'commit' | 'push' | 'manual') || 'manual',
+      repo_path: process.cwd(),
+      commit_hash: getCommitHash(),
+    };
+    appendAuditEntry(entry);
+  } else {
+    console.error(`Unknown audit command: ${command}`);
+    process.exit(1);
+  }
+}
+
+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) {
+      opts[args[i].slice(2)] = args[i + 1];
+      i++;
+    }
+  }
+  return opts;
+}
+
+function getCommitHash(): string {
+  try {
+    const { execSync } = require('child_process');
+    return execSync('git rev-parse HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+  } catch {
+    return 'unknown';
+  }
+}

package/lib/ui-detector.ts

@@ -204,21 +204,21 @@ function processOutput(input: string, repoRoot: string): void {
     .map(parseRenamedFile)
     .filter((f) => f.length > 0);
   const result = collectUiMatches(files, repoRoot);
-  // eslint-disable-next-line no-console
+   
   console.log(JSON.stringify(result, null, 2));
   process.exit(result.isUiSprint ? 0 : 1);
 }
 
-function runCheckBranch(repoRoot: string): void {
+function runCheckBranch(_repoRoot: string): void {
   const result = detectUiSprint('HEAD');
-  // eslint-disable-next-line no-console
+   
   console.log(JSON.stringify(result, null, 2));
   process.exit(result.isUiSprint ? 0 : 1);
 }
 
-function runDefault(repoRoot: string): void {
+function runDefault(_repoRoot: string): void {
   const result = detectUiSprint();
-  // eslint-disable-next-line no-console
+   
   console.log(JSON.stringify(result, null, 2));
   process.exit(result.isUiSprint ? 0 : 1);
 }