@boyingliu01/xp-gate 0.8.1 → 0.8.4

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__/ui-detector.test.ts

@@ -357,4 +357,98 @@ describe('ui-detector', () => {
       expect(isExcluded('src/Button.test.tsx', ['**/*.test.*'])).toBe(true);
     });
   });
+
+  /**
+   * @test #172 ui-detector CLI coverage
+   * @intent Cover CLI entry points (runCli, runPushMode, processOutput, runCheckBranch, runDefault)
+   *   via real subprocess execution with NODE_V8_COVERAGE to merge coverage profiles.
+   * @covers ui-detector-cli-push-mode, ui-detector-cli-check-branch, ui-detector-cli-default-mode
+   */
+  describe('CLI integration (subprocess)', () => {
+    const { spawnSync: realSpawnSync } = require('child_process') as typeof import('child_process');
+    const path = require('path') as typeof import('path');
+    const fs = require('fs') as typeof import('fs');
+    const os = require('os') as typeof import('os');
+
+    const UI_DETECTOR_PATH = path.resolve(__dirname, '../ui-detector.ts');
+
+    function runCli(args: string[], stdin?: string, cwd?: string): { code: number; stdout: string; stderr: string } {
+      const coverageDir = process.env.NODE_V8_COVERAGE ?? path.join(process.cwd(), 'coverage', '.tmp');
+      const result = realSpawnSync('npx', ['tsx', UI_DETECTOR_PATH, ...args], {
+        cwd: cwd ?? process.cwd(),
+        encoding: 'utf-8',
+        input: stdin,
+        env: { ...process.env, NODE_V8_COVERAGE: coverageDir },
+      });
+      return {
+        code: result.status ?? -1,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+      };
+    }
+
+    it('runs default mode with --check-branch flag (HEAD-based detection)', () => {
+      const { code, stdout } = runCli(['--check-branch']);
+      expect(code).toBeGreaterThanOrEqual(0);
+      expect(code).toBeLessThanOrEqual(1);
+      const parsed = JSON.parse(stdout);
+      expect(parsed).toHaveProperty('isUiSprint');
+      expect(parsed).toHaveProperty('matchedFiles');
+      expect(parsed).toHaveProperty('matchedRules');
+    });
+
+    it('runs push-mode via stdin', () => {
+      const { code, stdout } = runCli(['--push-mode'], 'views/index.html');
+      expect([0, 1]).toContain(code);
+      const parsed = JSON.parse(stdout);
+      expect(parsed.isUiSprint).toBe(true);
+      expect(parsed.matchedFiles).toContain('views/index.html');
+    });
+
+    it('runs push-mode with stdin input', () => {
+      const { code, stdout } = runCli(['--push-mode'], 'views/login.njk\nsrc/auth.ts\n');
+      expect([0, 1]).toContain(code);
+      const parsed = JSON.parse(stdout);
+      expect(parsed.isUiSprint).toBe(true);
+      expect(parsed.matchedFiles).toContain('views/login.njk');
+    });
+
+    it('runs push-mode with non-UI files (exit 1)', () => {
+      const { code, stdout } = runCli(['--push-mode'], 'src/auth.ts\nsrc/db.ts\n');
+      expect(code).toBe(1);
+      const parsed = JSON.parse(stdout);
+      expect(parsed.isUiSprint).toBe(false);
+      expect(parsed.matchedFiles).toEqual([]);
+    });
+
+    it('respects .ui-gate-ignore in push-mode', () => {
+      const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'ui-detector-ignore-'));
+      try {
+        fs.writeFileSync(path.join(tmp, '.ui-gate-ignore'), 'legacy/**\n');
+        const { code, stdout } = runCli(['--push-mode'], 'legacy/views/index.html', tmp);
+        expect(code).toBe(1);
+        const parsed = JSON.parse(stdout);
+        expect(parsed.isUiSprint).toBe(false);
+      } finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+      }
+    });
+
+    it('processes renamed files in push-mode', () => {
+      const { code, stdout } = runCli(['--push-mode'], 'src/a.tsx \u2192 src/components/B.tsx');
+      expect([0, 1]).toContain(code);
+      const parsed = JSON.parse(stdout);
+      expect(parsed.matchedFiles).toContain('src/components/B.tsx');
+    });
+
+    it('runs default mode (detectUiSprint in current repo)', () => {
+      const { code, stdout } = runCli([]);
+      expect([0, 1]).toContain(code);
+      const parsed = JSON.parse(stdout);
+      expect(parsed).toHaveProperty('isUiSprint');
+      expect(parsed).toHaveProperty('matchedFiles');
+      expect(parsed).toHaveProperty('matchedRules');
+    });
+  });
 });
+

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');

package/lib/baseline.js

@@ -0,0 +1,392 @@
+/**
+ * baseline.js — `xp-gate baseline` CLI handler
+ *
+ * Manages per-project lint baselines stored in .xp-gate/lint-baseline.json.
+ *
+ * Commands:
+ *   xp-gate baseline create    — Full-repo scan → save baseline
+ *   xp-gate baseline show      — Display current baseline
+ *   xp-gate baseline reset     — Force re-scan and replace baseline
+ *   xp-gate baseline diff      — Diff current state against stored baseline
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+function getXpGateDir() {
+  return path.join(process.cwd(), '.xp-gate');
+}
+
+function getBaselineFile() {
+  return path.join(getXpGateDir(), 'lint-baseline.json');
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function parseArgs(subargs) {
+  return {
+    tool: subargs[0] || null,
+    rest: subargs.slice(1),
+  };
+}
+
+/**
+ * Run a lint tool and return its JSON output.
+ */
+function runToolJson(toolCmd, pipeToJsonFlag) {
+  try {
+    const cmd = `${toolCmd} ${pipeToJsonFlag}`;
+    return execSync(cmd, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 }).trim();
+  } catch (e) {
+    // Lint tools exit non-zero when they find issues - that's expected
+    if (e.stdout) return e.stdout.trim();
+    return '';
+  }
+}
+
+/**
+ * Collect all source files for a given language.
+ */
+function findFilesByExt(extensions) {
+  try {
+    const patterns = extensions.map(e => `"**/*${e}"`).join(' ');
+    const result = execSync(`git ls-files ${patterns}`, {
+      encoding: 'utf8',
+      maxBuffer: 5 * 1024 * 1024,
+    }).trim();
+    return result ? result.split('\n') : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create baseline: scan all source files with available lint tools.
+ * Called by: xp-gate baseline create|reset
+ */
+async function createBaseline() {
+  ensureDir(getXpGateDir());
+
+  const baseline = {};
+
+  // TypeScript/JavaScript — ESLint
+  const tsFiles = findFilesByExt(['.ts', '.tsx', '.js', '.jsx']);
+  if (tsFiles.length > 0) {
+    try {
+      const eslintConfigExists = fs.existsSync('.eslintrc.json') ||
+        fs.existsSync('.eslintrc.js') ||
+        fs.existsSync('.eslintrc.cjs') ||
+        fs.existsSync('eslint.config.js');
+      const eslintBin = fs.existsSync('node_modules/.bin/eslint') ? 'node_modules/.bin/eslint' : null;
+
+      if (eslintConfigExists && (eslintBin || execSync('npx eslint --version', { encoding: 'utf8' }))) {
+        const eslintCmd = eslintBin || 'npx eslint';
+        const output = runToolJson(`${eslintCmd} ${tsFiles.join(' ')}`, '-f json --no-warn-ignored');
+        if (output && output !== '[]') {
+          const parsed = JSON.parse(output);
+          for (const fileResult of parsed) {
+            const relativePath = fileResult.filePath;
+            const fileName = tsFiles.find(f => relativePath.endsWith(f));
+            if (!fileName) continue;
+
+            baseline[fileName] = {
+              eslint: {
+                warnings: fileResult.warningCount || 0,
+                errors: fileResult.errorCount || 0,
+              },
+              totalWarnings: fileResult.warningCount || 0,
+              lastAnalyzed: new Date().toISOString(),
+            };
+          }
+        }
+      }
+    } catch {
+      // ESLint unavailable — skip
+    }
+  }
+
+  // Python — ruff
+  const pyFiles = findFilesByExt(['.py']);
+  if (pyFiles.length > 0) {
+    try {
+      execSync('ruff --version', { encoding: 'utf8' });
+      const output = runToolJson(`ruff check ${pyFiles.join(' ')}`, '--output-format json');
+      if (output && output !== '[]') {
+        const parsed = JSON.parse(output);
+        for (const fileResult of parsed) {
+          if (!baseline[fileResult.file]) {
+            const messages = fileResult.messages || [];
+            baseline[fileResult.file] = {
+              ruff: { warnings: messages.length, errors: 0 },
+              totalWarnings: messages.length,
+              lastAnalyzed: new Date().toISOString(),
+            };
+          } else {
+            const messages = fileResult.messages || [];
+            baseline[fileResult.file].ruff = { warnings: messages.length, errors: 0 };
+            baseline[fileResult.file].totalWarnings += messages.length;
+          }
+        }
+      }
+    } catch {
+      // Ruff unavailable — skip
+    }
+  }
+
+  // Go — golangci-lint
+  const goFiles = findFilesByExt(['.go']);
+  if (goFiles.length > 0) {
+    try {
+      execSync('golangci-lint --version', { encoding: 'utf8' });
+      const output = runToolJson('golangci-lint run', '--out-format json');
+      if (output) {
+        const parsed = JSON.parse(output).Issues || [];
+        const warningsByFile = {};
+        for (const issue of parsed) {
+          const matchedFile = goFiles.find(f => issue.file.endsWith(f));
+          if (!matchedFile) continue;
+          if (!warningsByFile[matchedFile]) {
+            warningsByFile[matchedFile] = { warnings: 0, errors: 0 };
+          }
+          if (issue.severity === 'error') {
+            warningsByFile[matchedFile].errors++;
+          } else {
+            warningsByFile[matchedFile].warnings++;
+          }
+        }
+        for (const [file, counts] of Object.entries(warningsByFile)) {
+          if (baseline[file]) {
+            baseline[file].golangci = counts;
+            baseline[file].totalWarnings += counts.warnings;
+          } else {
+            baseline[file] = {
+              golangci: counts,
+              totalWarnings: counts.warnings,
+              lastAnalyzed: new Date().toISOString(),
+            };
+          }
+        }
+      }
+    } catch {
+      // golangci-lint unavailable — skip
+    }
+  }
+
+  // Shell — shellcheck
+  const shFiles = findFilesByExt(['.sh']);
+  if (shFiles.length > 0) {
+    try {
+      execSync('shellcheck --version', { encoding: 'utf8' });
+      const output = runToolJson(`shellcheck -f json ${shFiles.join(' ')}`, '');
+      if (output && output !== '[]') {
+        const parsed = JSON.parse(output);
+        const warningsByFile = {};
+        for (const item of parsed) {
+          const matchedFile = shFiles.find(f => item.file.endsWith(f));
+          if (!matchedFile) continue;
+          if (!warningsByFile[matchedFile]) {
+            warningsByFile[matchedFile] = { warnings: 0, errors: 0 };
+          }
+          if (item.level === 'error') {
+            warningsByFile[matchedFile].errors++;
+          } else {
+            warningsByFile[matchedFile].warnings++;
+          }
+        }
+        for (const [file, counts] of Object.entries(warningsByFile)) {
+          if (baseline[file]) {
+            baseline[file].shellcheck = counts;
+            baseline[file].totalWarnings += counts.warnings;
+          } else {
+            baseline[file] = {
+              shellcheck: counts,
+              totalWarnings: counts.warnings,
+              lastAnalyzed: new Date().toISOString(),
+            };
+          }
+        }
+      }
+    } catch {
+      // shellcheck unavailable — skip
+    }
+  }
+
+  fs.writeFileSync(getBaselineFile(), JSON.stringify(baseline, null, 2));
+  return baseline;
+}
+
+/**
+ * Show current baseline.
+ */
+function showBaseline() {
+  if (!fs.existsSync(getBaselineFile())) {
+    console.log('No baseline found. Run `xp-gate baseline create` to initialize.');
+    return 1;
+  }
+
+  const data = JSON.parse(fs.readFileSync(getBaselineFile(), 'utf8'));
+  const files = Object.keys(data);
+
+  if (files.length === 0) {
+    console.log('Baseline is empty (no lint issues found on last scan).');
+    return 0;
+  }
+
+  const totalWarnings = files.reduce((s, f) => s + data[f].totalWarnings, 0);
+  let eslintCount = 0;
+  let ruffCount = 0;
+  let golangciCount = 0;
+  let shellcheckCount = 0;
+
+  for (const entry of Object.values(data)) {
+    if (entry.eslint) eslintCount++;
+    if (entry.ruff) ruffCount++;
+    if (entry.golangci) golangciCount++;
+    if (entry.shellcheck) shellcheckCount++;
+  }
+
+  console.log('Lint Baseline:');
+  console.log(`  Created: ${data[files[0]]?.lastAnalyzed?.slice(0, 10) || 'N/A'}`);
+  console.log(`  Files tracked: ${files.length}`);
+  console.log(`  Total warnings: ${totalWarnings}`);
+  if (eslintCount > 0) console.log(`  ESLint: ${eslintCount} files`);
+  if (ruffCount > 0) console.log(`  Ruff: ${ruffCount} files`);
+  if (golangciCount > 0) console.log(`  golangci-lint: ${golangciCount} files`);
+  if (shellcheckCount > 0) console.log(`  ShellCheck: ${shellcheckCount} files`);
+
+  return 0;
+}
+
+/**
+ * Reset baseline: force re-scan and replace.
+ */
+async function resetBaseline() {
+  const baseline = await createBaseline();
+  console.log(`Baseline reset. ${Object.keys(baseline).length} files tracked.`);
+  return 0;
+}
+
+/**
+ * Diff current lint state against stored baseline.
+ */
+async function diffBaseline() {
+  if (!fs.existsSync(getBaselineFile())) {
+    console.log('No baseline found. Run `xp-gate baseline create` first.');
+    return 1;
+  }
+
+  const oldBaseline = JSON.parse(fs.readFileSync(getBaselineFile(), 'utf8'));
+  const currentBaseline = await createBaseline();
+
+  const allFiles = new Set([
+    ...Object.keys(oldBaseline),
+    ...Object.keys(currentBaseline),
+  ]);
+
+  let totalWarningsDelta = 0;
+  const increased = [];
+  const decreased = [];
+  const added = [];
+  const removed = [];
+
+  for (const file of allFiles) {
+    const oldW = oldBaseline[file]?.totalWarnings || 0;
+    const newW = currentBaseline[file]?.totalWarnings || 0;
+    const delta = newW - oldW;
+
+    totalWarningsDelta += delta;
+
+    if (!oldBaseline[file] && currentBaseline[file]) {
+      added.push(`  + ${file} (${newW} warnings)`);
+    } else if (oldBaseline[file] && !currentBaseline[file]) {
+      removed.push(`  - ${file} (all ${oldW} warnings cleared)`);
+    } else if (delta > 0) {
+      increased.push(`  ↑ ${file} (${oldW} → ${newW}, +${delta})`);
+    } else if (delta < 0) {
+      decreased.push(`  ↓ ${file} (${oldW} → ${newW}, ${delta})`);
+    }
+  }
+
+  console.log('Lint Baseline Diff:');
+  console.log(`  Total warnings delta: ${totalWarningsDelta >= 0 ? '+' : ''}${totalWarningsDelta}`);
+
+  if (added.length > 0) {
+    console.log(`\nFiles added (${added.length}):`);
+    added.forEach(l => console.log(l));
+  }
+  if (removed.length > 0) {
+    console.log(`\nFiles removed (${removed.length}):`);
+    removed.forEach(l => console.log(l));
+  }
+  if (increased.length > 0) {
+    console.log(`\nWarnings increased (${increased.length}):`);
+    increased.forEach(l => console.log(l));
+  }
+  if (decreased.length > 0) {
+    console.log(`\nWarnings decreased (${decreased.length}):`);
+    decreased.forEach(l => console.log(l));
+  }
+
+  if (added.length === 0 && removed.length === 0 && increased.length === 0 && decreased.length === 0) {
+    console.log('  No change from baseline.');
+  }
+
+  return totalWarningsDelta > 0 ? 1 : 0;
+}
+
+/**
+ * Main handler called from xp-gate CLI.
+ * @param {string[]} subargs CLI sub-arguments
+ * @returns {Promise<number>} exit code
+ */
+async function handleBaseline(subargs) {
+  const { tool, rest } = parseArgs(subargs);
+
+  switch (tool) {
+    case 'create':
+      console.log('Creating lint baseline...');
+      const created = await createBaseline();
+      console.log(`✅ Baseline created — ${Object.keys(created).length} files tracked.`);
+      return 0;
+
+    case 'show':
+      return showBaseline();
+
+    case 'reset':
+      console.log('Resetting lint baseline...');
+      return resetBaseline();
+
+    case 'diff':
+      return diffBaseline();
+
+    case 'help':
+    case '--help':
+    case null:
+      console.log(`Usage: xp-gate baseline <subcommand>
+
+Subcommands:
+  create    Scan all source files and save lint baseline
+  show      Display current lint baseline summary
+  reset     Force re-scan and replace baseline
+  diff      Compare current lint state against baseline
+
+Examples:
+  xp-gate baseline create
+  xp-gate baseline show
+  xp-gate baseline reset
+  xp-gate baseline diff`);
+      return 0;
+
+    default:
+      console.error(`Unknown baseline subcommand: ${tool}`);
+      console.error('Run `xp-gate baseline --help` for usage.');
+      return 1;
+  }
+}
+
+module.exports = { handleBaseline, createBaseline, showBaseline, resetBaseline, diffBaseline };