@boyingliu01/xp-gate 0.8.2 → 0.8.5

package/bin/xp-gate.js

@@ -7,57 +7,96 @@ const { uninstall } = require('../lib/uninstall.js');
 const { doctor } = require('../lib/doctor.js');
 const { checkDeps } = require('../lib/detect-deps.js');
 const { migrate } = require('../lib/migrate.js');
+const { handleBaseline } = require('../lib/baseline.js');
+
+function handleUIReview() {
+  const { execSync } = require('child_process');
+  const uiReviewPath = path.join(__dirname, '..', 'lib', 'ui-review.ts');
+  try {
+    execSync(`npx -y tsx "${uiReviewPath}"`, { stdio: 'inherit' });
+    process.exit(0);
+  } catch (err) {
+    process.exit(1);
+  }
+}
 
 const COMMANDS = {
   'init': {
     description: 'Initialize xp-gate (use --global for all projects)',
-    fn: init,
+    run: subargs => init(subargs).then(code => process.exit(code)),
     usage: 'xp-gate init [--global]'
   },
   'setup-global': {
     description: 'Set up xp-gate globally for all git projects',
-    fn: init,
+    run: () => init(['--global']).then(code => process.exit(code)),
     usage: 'xp-gate setup-global'
   },
   'install-skill': {
     description: 'Install a xp-gate skill from GitHub',
-    fn: installSkill,
+    run: subargs => {
+      const name = subargs[0];
+      if (!name) {
+        console.error('Error: Skill name required');
+        console.error('Usage: xp-gate install-skill <name>[@<version>]');
+        process.exit(1);
+      }
+      const options = parseOptions(subargs.slice(1));
+      installSkill(name, options).then(code => process.exit(code));
+    },
     usage: 'xp-gate install-skill <name>[@<version>] [--offline] [--verbose] [--force]'
   },
   'update-skill': {
     description: 'Update installed skill(s)',
-    fn: updateSkill,
+    run: subargs => {
+      const name = subargs[0];
+      const options = parseOptions(subargs.slice(1));
+      updateSkill(name, options).then(code => process.exit(code));
+    },
     usage: 'xp-gate update-skill [<name>] [--all] [--check]'
   },
   'uninstall-skill': {
     description: 'Uninstall a xp-gate skill',
-    fn: uninstallSkill,
+    run: subargs => {
+      const name = subargs[0];
+      if (!name) {
+        console.error('Error: Skill name required');
+        console.error('Usage: xp-gate uninstall-skill <name>');
+        process.exit(1);
+      }
+      const options = parseOptions(subargs.slice(1));
+      uninstallSkill(name, options).then(code => process.exit(code));
+    },
     usage: 'xp-gate uninstall-skill <name> [--force]'
   },
   'uninstall': {
     description: 'Uninstall xp-gate (reverse of init)',
-    fn: uninstall,
+    run: subargs => uninstall(subargs).then(code => process.exit(code)),
     usage: 'xp-gate uninstall [--dry-run] [--force] [--local|--global]'
   },
   'migrate': {
     description: 'Migrate from v0.4.x (GitHub Packages) to v0.5.x (public npm)',
-    fn: migrate,
+    run: subargs => migrate(subargs).then(code => process.exit(code)),
     usage: 'xp-gate migrate [--dry-run]'
   },
   'doctor': {
     description: 'Diagnose xp-gate installation health',
-    fn: doctor,
+    run: subargs => doctor(subargs).then(code => process.exit(code)),
     usage: 'xp-gate doctor [--fix]'
   },
   'ui-review': {
     description: 'Run UI review for non-sprint developers (generates .ui-gate-result.json)',
-    fn: null,
+    run: () => handleUIReview(),
     usage: 'xp-gate ui-review'
   },
   'audit': {
     description: 'Gate audit logging (record, --tail, --stats)',
-    fn: null,
+    run: subargs => handleAudit(subargs),
     usage: 'xp-gate audit [--tail [N]|--stats|record --gate-id X --gate-name Y ...]'
+  },
+  'baseline': {
+    description: 'Manage lint baselines (create, show, reset, diff)',
+    run: subargs => handleBaseline(subargs).then(code => process.exit(code)),
+    usage: 'xp-gate baseline <create|show|reset|diff>'
   }
 };
 
@@ -92,151 +131,94 @@ function main() {
   
   const command = args[0];
   const subargs = args.slice(1);
+  const cmd = COMMANDS[command];
   
-  if (command === 'init' || command === 'setup-global') {
-    const initArgs = command === 'setup-global' ? ['--global'] : subargs;
-    init(initArgs).then(code => process.exit(code));
+  if (!cmd) {
+    console.error(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
     return;
   }
   
-  if (command === 'install-skill') {
-    const name = subargs[0];
-    if (!name) {
-      console.error('Error: Skill name required');
-      console.error('Usage: xp-gate install-skill <name>[@<version>]');
-      process.exit(1);
+  cmd.run(subargs);
+}
+
+function handleAuditTail(args, auditPath) {
+  const tailIdx = args.indexOf('--tail');
+  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;
     }
-    const options = parseOptions(subargs.slice(1));
-    installSkill(name, options).then(code => process.exit(code));
-    return;
+    printAuditTable(entries);
+  } catch (err) {
+    console.error('Error reading audit entries:', err.message);
+    process.exit(1);
   }
-  
-  if (command === 'update-skill') {
-    const name = subargs[0];
-    const options = parseOptions(subargs.slice(1));
-    updateSkill(name, options).then(code => process.exit(code));
-    return;
-  }
-  
-  if (command === 'uninstall-skill') {
-    const name = subargs[0];
-    if (!name) {
-      console.error('Error: Skill name required');
-      console.error('Usage: xp-gate uninstall-skill <name>');
-      process.exit(1);
+}
+
+function handleAuditStats(auditPath) {
+  try {
+    const { computeStats } = require(auditPath);
+    const stats = computeStats();
+    if (stats.length === 0) {
+      console.log('No audit data found.');
       return;
     }
-    const options = parseOptions(subargs.slice(1));
-    uninstallSkill(name, options).then(code => process.exit(code));
-    return;
-  }
-  
-  if (command === 'uninstall') {
-    uninstall(subargs).then(code => process.exit(code));
-    return;
-  }
-
-  if (command === 'migrate') {
-    migrate(subargs).then(code => process.exit(code));
-    return;
-  }
-  
-  if (command === 'doctor') {
-    doctor(subargs).then(code => process.exit(code));
-    return;
+    printStatsTable(stats);
+  } catch (err) {
+    console.error('Error computing stats:', err.message);
+    process.exit(1);
   }
+}
 
-  if (command === 'ui-review') {
-    const { execSync } = require('child_process');
-    const path = require('path');
-    const uiReviewPath = path.join(__dirname, '..', 'lib', 'ui-review.ts');
-    try {
-      execSync(`npx -y tsx "${uiReviewPath}"`, { stdio: 'inherit' });
-      process.exit(0);
-    } catch (err) {
-      process.exit(1);
+function handleAuditRecord(args, auditPath) {
+  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);
   }
-
-  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);
-    }
+  if (args.includes('--tail')) {
+    handleAuditTail(args, auditPath);
     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);
-    }
+    handleAuditStats(auditPath);
     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);
-    }
+    handleAuditRecord(args, auditPath);
     return;
   }
 

package/hooks/pre-commit

@@ -32,14 +32,15 @@ source "$ADAPTER_DIR/adapter-common.sh" 2>/dev/null || {
 # Trap: ensure quality report generated on ANY exit (pass or fail).
 # Using a guard prevents recursion when 'exit' is called from inside the trap.
 _QUALITY_REPORT_DONE=0
-_quality_report_on_exit() {
+  _quality_report_on_exit() {
+  local _saved_exit=$?
   if [ "$_QUALITY_REPORT_DONE" = "1" ]; then
-    exit
+    exit $_saved_exit
     return
   fi
   _QUALITY_REPORT_DONE=1
-  generate_quality_report
-  exit
+  command -v generate_quality_report >/dev/null 2>&1 && generate_quality_report 2>/dev/null || true
+  exit $_saved_exit
 }
 trap '_quality_report_on_exit' EXIT
 

package/lib/__tests__/baseline.test.js

@@ -0,0 +1,123 @@
+/**
+ * @test REQ-152 Baseline CLI handler
+ * @intent Verify baseline create/show/reset/diff commands
+ * @covers AC-152
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const { handleBaseline, showBaseline } = require('../baseline.js');
+
+describe('baseline.js - CLI handler', () => {
+  let tmpDir;
+  const originalCwd = process.cwd;
+
+  afterAll(() => {
+    process.cwd = originalCwd;
+  });
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'baseline-cli-test-'));
+    process.cwd = () => tmpDir;
+  });
+
+  describe('handleBaseline - help', () => {
+    it('prints usage when no subcommand given', async () => {
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(' '));
+
+      const code = await handleBaseline([]);
+      expect(code).toBe(0);
+      expect(logs.some(l => l.includes('Usage'))).toBe(true);
+
+      console.log = origLog;
+    });
+
+    it('prints usage for --help', async () => {
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(' '));
+
+      const code = await handleBaseline(['--help']);
+      expect(code).toBe(0);
+      expect(logs.some(l => l.includes('Usage'))).toBe(true);
+
+      console.log = origLog;
+    });
+  });
+
+  describe('handleBaseline - unknown subcommand', () => {
+    it('returns error for unknown subcommand', async () => {
+      const logs = [];
+      const errs = [];
+      const origLog = console.log;
+      const origErr = console.error;
+      console.log = (...args) => logs.push(args.join(' '));
+      console.error = (...args) => errs.push(args.join(' '));
+
+      const code = await handleBaseline(['unknown-cmd']);
+      expect(code).toBe(1);
+      expect(errs.some(l => l.includes('Unknown baseline subcommand'))).toBe(true);
+
+      console.log = origLog;
+      console.error = origErr;
+    });
+  });
+
+  describe('showBaseline - no baseline file', () => {
+    it('shows message when no baseline exists', () => {
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(' '));
+
+      const code = showBaseline();
+      expect(code).toBe(1);
+      expect(logs.some(l => l.includes('No baseline'))).toBe(true);
+
+      console.log = origLog;
+    });
+  });
+
+  describe('showBaseline - with baseline file', () => {
+    it('shows summary when baseline exists', () => {
+      const baselinePath = path.join(tmpDir, '.xp-gate', 'lint-baseline.json');
+      fs.mkdirSync(path.dirname(baselinePath), { recursive: true });
+      fs.writeFileSync(baselinePath, JSON.stringify({
+        'src/app.ts': {
+          eslint: { warnings: 3, errors: 1 },
+          totalWarnings: 3,
+          lastAnalyzed: '2026-06-01T12:00:00.000Z',
+        },
+      }));
+
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(' '));
+
+      const code = showBaseline();
+      expect(code).toBe(0);
+      expect(logs.some(l => l.includes('3'))).toBe(true);
+      expect(logs.some(l => l.includes('ESLint'))).toBe(true);
+
+      console.log = origLog;
+    });
+
+    it('shows empty message for baseline with no entries', () => {
+      const baselinePath = path.join(tmpDir, '.xp-gate', 'lint-baseline.json');
+      fs.mkdirSync(path.dirname(baselinePath), { recursive: true });
+      fs.writeFileSync(baselinePath, '{}');
+
+      const logs = [];
+      const origLog = console.log;
+      console.log = (...args) => logs.push(args.join(' '));
+
+      const code = showBaseline();
+      expect(code).toBe(0);
+      expect(logs.some(l => l.includes('empty'))).toBe(true);
+
+      console.log = origLog;
+    });
+  });
+});

package/lib/__tests__/migrate.test.js

@@ -193,6 +193,26 @@ describe('migrate', () => {
 
   // === Print summary ===
 
+  // === Phase isolation: removing npmrc should not affect cache check ===
+
+  it('phases are isolated: npmrc cleanup and cache check operate independently', async () => {
+    // Only npmrc has github packages lines, no cache dir
+    fs.writeFileSync(npmrcPath(), [
+      '//npm.pkg.github.com/:_authToken=ghp_abc123',
+      'registry=https://registry.npmjs.org/'
+    ].join('\n') + '\n');
+
+    const { migrate } = require('../migrate');
+    const result = await migrate([]);
+
+    expect(result).toBe(0);
+    // npmrc should be cleaned
+    const content = fs.readFileSync(npmrcPath(), 'utf8');
+    expect(content).not.toContain('npm.pkg.github.com');
+    // Should report no old cache (dir doesn't exist)
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('No old cache'));
+  });
+
   it('prints full summary of actions taken', async () => {
     fs.writeFileSync(npmrcPath(), [
       '//npm.pkg.github.com/:_authToken=ghp_abc123',

package/lib/__tests__/uninstall.test.js

@@ -577,6 +577,42 @@ describe('uninstall', () => {
     expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('adapter-common.sh'));
   });
 
+  // === Execution loop: mixed item types plan ===
+
+  it('executes mixed-type plan (file + dir + gitconfig items) correctly', async () => {
+    setupGlobalInstall();
+    const expectedHooksPath = globalHooksDir();
+    mockExecGlobalHooksPath(expectedHooksPath);
+    const { uninstall } = require('../uninstall');
+
+    const result = await uninstall([]);
+
+    expect(result).toBe(0);
+
+    // Gitconfig type unset core.hooksPath
+    expect(execSpy).toHaveBeenCalledWith(
+      expect.stringContaining('git config --global --unset core.hooksPath'),
+      expect.any(Object)
+    );
+    // Dir items removed: global hooks, adapters, template
+    expect(fs.existsSync(globalHooksDir())).toBe(false);
+    expect(fs.existsSync(globalAdaptersDir())).toBe(false);
+    expect(fs.existsSync(templateDir())).toBe(false);
+  });
+
+  it('skips non-existent file items in execution loop gracefully', async () => {
+    setupLocalInstall();
+    // Delete one file before uninstall
+    fs.unlinkSync(path.join(projectHooksDir(), 'pre-commit'));
+    mockExecSuccess();
+    const { uninstall } = require('../uninstall');
+
+    const result = await uninstall([]);
+    expect(result).toBe(0);
+    // Should not crash — remaining items still processed
+    expect(fs.existsSync(path.join(projectHooksDir(), 'pre-push'))).toBe(false);
+  });
+
   it('saves rollback snapshot before destructive operations', async () => {
     setupLocalInstall();
     mockExecSuccess();

package/lib/__tests__/update-skill.test.js

@@ -263,6 +263,17 @@ describe('update-skill', () => {
     expect(errorSpy).toHaveBeenCalledWith('Error: foo is not installed');
   });
 
+  // === Mode handler isolation: check/all/single operate independently ===
+
+  it('check and all modes handle empty config without crashing (edge cases)', async () => {
+    // No config file at all — getConfig returns {}
+    const { updateSkill } = require('../update-skill');
+    expect(await updateSkill(null, { check: true })).toBe(0);
+    expect(await updateSkill(null, { all: true })).toBe(0);
+    expect(await updateSkill('anything')).toBe(1);
+    expect(errorSpy).toHaveBeenCalledWith('Error: anything is not installed');
+  });
+
   it('getConfig parses valid config (single-name path succeeds)', async () => {
     writeConfig({ foo: { version: '1.0.0' } });
     const { updateSkill } = require('../update-skill');