@boyingliu01/xp-gate 0.9.3 → 0.9.4

package/lib/__tests__/baseline.test.js

@@ -66,6 +66,95 @@ describe('baseline.js - CLI handler', () => {
     });
   });
 
+  // === TECH-005/006/007: Extracted helper unit tests (CCN reduction) ===
+
+  describe('countBaselineByTool', () => {
+    it('counts files by tool type from baseline data', () => {
+      const doc = require('../baseline.js');
+      const data = {
+        'a.ts': { eslint: { warnings: 3, errors: 0 }, totalWarnings: 3, lastAnalyzed: '2026-01-01' },
+        'b.py': { ruff: { warnings: 2, errors: 0 }, totalWarnings: 2, lastAnalyzed: '2026-01-01' },
+        'c.go': { golangci: { warnings: 1, errors: 1 }, totalWarnings: 1, lastAnalyzed: '2026-01-01' },
+        'd.sh': { shellcheck: { warnings: 4, errors: 0 }, totalWarnings: 4, lastAnalyzed: '2026-01-01' },
+      };
+      const result = doc.countBaselineByTool(data);
+      expect(result.eslintCount).toBe(1);
+      expect(result.ruffCount).toBe(1);
+      expect(result.golangciCount).toBe(1);
+      expect(result.shellcheckCount).toBe(1);
+      expect(result.totalFiles).toBe(4);
+      expect(result.totalWarnings).toBe(10);
+    });
+
+    it('returns zeroes for empty baseline', () => {
+      const doc = require('../baseline.js');
+      const result = doc.countBaselineByTool({});
+      expect(result.eslintCount).toBe(0);
+      expect(result.ruffCount).toBe(0);
+      expect(result.totalFiles).toBe(0);
+      expect(result.totalWarnings).toBe(0);
+    });
+
+    it('handles mixed entries with some missing tool fields', () => {
+      const doc = require('../baseline.js');
+      const data = {
+        'a.ts': { eslint: { warnings: 3, errors: 0 }, totalWarnings: 3, lastAnalyzed: '2026-01-01' },
+        'b.ts': { totalWarnings: 0, lastAnalyzed: '2026-01-01' },
+      };
+      const result = doc.countBaselineByTool(data);
+      expect(result.eslintCount).toBe(1);
+      expect(result.totalFiles).toBe(2);
+      expect(result.totalWarnings).toBe(3);
+    });
+  });
+
+  describe('compareBaselines', () => {
+    it('detects added, removed, increased, and decreased files', () => {
+      const doc = require('../baseline.js');
+      const oldB = {
+        'stable.ts': { totalWarnings: 3 },
+        'increased.ts': { totalWarnings: 2 },
+        'decreased.ts': { totalWarnings: 5 },
+        'removed.ts': { totalWarnings: 1 },
+      };
+      const newB = {
+        'stable.ts': { totalWarnings: 3 },
+        'increased.ts': { totalWarnings: 5 },
+        'decreased.ts': { totalWarnings: 1 },
+        'added.ts': { totalWarnings: 4 },
+      };
+      const result = doc.compareBaselines(oldB, newB);
+      expect(result.totalWarningsDelta).toBe(2);
+      expect(result.increased.length).toBe(1);
+      expect(result.increased[0]).toContain('increased.ts');
+      expect(result.decreased.length).toBe(1);
+      expect(result.decreased[0]).toContain('decreased.ts');
+      expect(result.added.length).toBe(1);
+      expect(result.added[0]).toContain('added.ts');
+      expect(result.removed.length).toBe(1);
+      expect(result.removed[0]).toContain('removed.ts');
+    });
+
+    it('returns empty arrays when baselines are identical', () => {
+      const doc = require('../baseline.js');
+      const baseline = { 'file.ts': { totalWarnings: 3 } };
+      const result = doc.compareBaselines(baseline, baseline);
+      expect(result.totalWarningsDelta).toBe(0);
+      expect(result.increased).toEqual([]);
+      expect(result.decreased).toEqual([]);
+      expect(result.added).toEqual([]);
+      expect(result.removed).toEqual([]);
+    });
+
+    it('handles empty old or new baseline', () => {
+      const doc = require('../baseline.js');
+      const baseline = { 'file.ts': { totalWarnings: 3 } };
+      const result = doc.compareBaselines({}, baseline);
+      expect(result.added.length).toBe(1);
+      expect(result.totalWarningsDelta).toBe(3);
+    });
+  });
+
   describe('showBaseline - no baseline file', () => {
     it('shows message when no baseline exists', () => {
       const logs = [];

package/lib/__tests__/doctor-helpers.test.js

@@ -0,0 +1,139 @@
+/**
+ * @test TECH-001 Extracted doctor.js fix helpers (CCN reduction)
+ * @intent Unit-test each extracted helper in isolation
+ * @covers TECH-001
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('fixVersionMismatch', () => {
+  let tmpHome;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dh-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../doctor')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (tmpHome && fs.existsSync(tmpHome)) {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+  });
+
+  function ensureConfigDir() {
+    const cfgDir = path.join(tmpHome, '.config', 'xp-gate');
+    fs.mkdirSync(cfgDir, { recursive: true });
+  }
+
+  it('updates config version when package version differs', () => {
+    ensureConfigDir();
+    delete require.cache[require.resolve('../doctor')];
+    const doc = require('../doctor');
+    const config = { version: '0.3.1.1', mode: 'local' };
+    const result = doc.fixVersionMismatch(config, '0.9.3.0');
+    expect(result).toBe(true);
+    expect(config.version).toBe('0.9.3.0');
+  });
+
+  it('skips when package version is null', () => {
+    delete require.cache[require.resolve('../doctor')];
+    const doc = require('../doctor');
+    const config = { version: '0.3.1.1', mode: 'local' };
+    const result = doc.fixVersionMismatch(config, null);
+    expect(result).toBe(false);
+    expect(config.version).toBe('0.3.1.1');
+  });
+
+  it('skips when versions already match', () => {
+    delete require.cache[require.resolve('../doctor')];
+    const doc = require('../doctor');
+    const config = { version: '0.9.3.0', mode: 'local' };
+    const result = doc.fixVersionMismatch(config, '0.9.3.0');
+    expect(result).toBe(false);
+    expect(config.version).toBe('0.9.3.0');
+  });
+});
+
+describe('fixMissingHooks', () => {
+  let tmpHome;
+  let tmpProject;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dh-'));
+    tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dh-proj-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../doctor')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (tmpHome && fs.existsSync(tmpHome)) {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+    if (tmpProject && fs.existsSync(tmpProject)) {
+      fs.rmSync(tmpProject, { recursive: true, force: true });
+    }
+  });
+
+  it('restores pre-commit and pre-push hooks for local mode', () => {
+    delete require.cache[require.resolve('../doctor')];
+    const srcDir = path.join(__dirname, '..', '..');
+    const hooksDir = path.join(tmpProject, '.git', 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    const preCommit = path.join(hooksDir, 'pre-commit');
+    if (fs.existsSync(preCommit)) fs.unlinkSync(preCommit);
+    const doc = require('../doctor');
+    const result = doc.fixMissingHooks('local', srcDir, hooksDir);
+    expect(result).toBe(true);
+    expect(fs.existsSync(preCommit)).toBe(true);
+  });
+});
+
+describe('fixMissingAdapters', () => {
+  let tmpHome;
+  let tmpProject;
+  let originalHome;
+
+  beforeEach(() => {
+    originalHome = process.env.HOME;
+    tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dh-'));
+    tmpProject = fs.mkdtempSync(path.join(os.tmpdir(), 'xpgate-dh-proj-'));
+    process.env.HOME = tmpHome;
+    vi.resetModules();
+    delete require.cache[require.resolve('../doctor')];
+  });
+
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    if (tmpHome && fs.existsSync(tmpHome)) {
+      fs.rmSync(tmpHome, { recursive: true, force: true });
+    }
+    if (tmpProject && fs.existsSync(tmpProject)) {
+      fs.rmSync(tmpProject, { recursive: true, force: true });
+    }
+  });
+
+  it('copies adapters when directory is missing', () => {
+    delete require.cache[require.resolve('../doctor')];
+    const srcDir = path.join(__dirname, '..', '..');
+    const adaptersDir = path.join(tmpProject, 'githooks', 'adapters');
+    if (fs.existsSync(adaptersDir)) {
+      fs.rmSync(path.join(tmpProject, 'githooks'), { recursive: true, force: true });
+    }
+    const doc = require('../doctor');
+    const result = doc.fixMissingAdapters('local', srcDir, adaptersDir);
+    expect(result).toBe(true);
+    expect(fs.existsSync(adaptersDir)).toBe(true);
+    const files = fs.readdirSync(adaptersDir).filter(f => f.endsWith('.sh'));
+    expect(files.length).toBeGreaterThan(0);
+  });
+});

package/lib/__tests__/upgrade-exec.test.js

@@ -12,6 +12,8 @@
  * standalone test verification.
  */
 
+const { EventEmitter } = require('events');
+
 describe('upgrade.js --apply execSync path', () => {
   function evictCache() {
     const resolved = require.resolve('../upgrade');
@@ -24,7 +26,19 @@ describe('upgrade.js --apply execSync path', () => {
     delete require.cache[cvResolved];
   }
 
-  function withMockedEnv(latestVersion, execSyncImpl, fn) {
+  function spawnEE(closeCode) {
+    const ee = new EventEmitter();
+    process.nextTick(() => ee.emit('close', closeCode));
+    return ee;
+  }
+
+  function spawnErr(err) {
+    const ee = new EventEmitter();
+    process.nextTick(() => ee.emit('error', err));
+    return ee;
+  }
+
+  function withMockedEnv(latestVersion, spawnImpl, fn) {
     const fs = require('fs');
     const os = require('os');
     const cpPath = require('path').join(os.homedir(), '.xp-gate', 'version-cache.json');
@@ -34,8 +48,8 @@ describe('upgrade.js --apply execSync path', () => {
     evictCache();
     const cp = require('child_process');
     const https = require('https');
-    const saved = { execSync: cp.execSync, httpsGet: https.get };
-    cp.execSync = execSyncImpl;
+    const saved = { spawn: cp.spawn, httpsGet: https.get };
+    cp.spawn = spawnImpl;
     const body = JSON.stringify({ latest: latestVersion });
     https.get = (_url, _opts, cb) => {
       const callback = typeof _opts === 'function' ? _opts : cb;
@@ -55,61 +69,56 @@ describe('upgrade.js --apply execSync path', () => {
       const m = require('../upgrade');
       return fn(m);
     } finally {
-      cp.execSync = saved.execSync;
+      cp.spawn = saved.spawn;
       https.get = saved.httpsGet;
     }
   }
 
-  it('returns 0 when execSync succeeds', async () => {
-    const code = await withMockedEnv('99.99.99', vi.fn().mockReturnValue(Buffer.from('')), async (m) => {
+  it('returns 0 when spawn succeeds', async () => {
+    const code = await withMockedEnv('99.99.99', vi.fn(() => spawnEE(0)), async (m) => {
       return m.upgrade(['--apply']);
     });
     expect(code).toBe(0);
   }, 10000);
 
-  it('returns 1 when execSync throws EACCES', async () => {
-    const err = new Error('EACCES');
-    err.stderr = Buffer.from('EACCES: permission denied');
-    const code = await withMockedEnv('99.99.99', vi.fn(() => { throw err; }), async (m) => {
+  it('returns 1 when spawn errors with EACCES', async () => {
+    const err = new Error('EACCES: permission denied');
+    const code = await withMockedEnv('99.99.99', vi.fn(() => spawnErr(err)), async (m) => {
       return m.upgrade(['--apply']);
     });
     expect(code).toBe(1);
   }, 10000);
 
-  it('returns 1 when execSync throws ETIMEDOUT', async () => {
+  it('returns 1 when spawn errors with ETIMEDOUT', async () => {
     const err = new Error('ETIMEDOUT');
-    err.code = 'ETIMEDOUT';
-    err.stderr = Buffer.from('');
-    const code = await withMockedEnv('99.99.99', vi.fn(() => { throw err; }), async (m) => {
+    const code = await withMockedEnv('99.99.99', vi.fn(() => spawnErr(err)), async (m) => {
       return m.upgrade(['--apply']);
     });
     expect(code).toBe(1);
   }, 10000);
 
-  it('returns 1 when execSync throws generic error', async () => {
-    const err = new Error('generic failure');
-    err.stderr = Buffer.from('');
-    const code = await withMockedEnv('99.99.99', vi.fn(() => { throw err; }), async (m) => {
+  it('returns 1 when spawn exits with non-zero code', async () => {
+    const code = await withMockedEnv('99.99.99', vi.fn(() => spawnEE(1)), async (m) => {
       return m.upgrade(['--apply']);
     });
     expect(code).toBe(1);
   }, 10000);
 
-  it('calls execSync with correct pkgName and version', async () => {
-    const mockFn = vi.fn().mockReturnValue(Buffer.from(''));
-    await withMockedEnv('99.99.99', mockFn, async (m) => {
+  it('calls spawn with correct args', async () => {
+    const mockSpawn = vi.fn(() => spawnEE(0));
+    await withMockedEnv('99.99.99', mockSpawn, async (m) => {
       await m.upgrade(['--apply']);
-      expect(mockFn).toHaveBeenCalledWith(
-        expect.stringMatching(/npm install -g .+@99\.99\.99/),
+      expect(mockSpawn).toHaveBeenCalledWith(
+        'npm',
+        ['install', '-g', expect.stringMatching(/@99\.99\.99/)],
         expect.objectContaining({ stdio: 'inherit', timeout: 120000 }),
       );
     });
   }, 10000);
 
   // ── default mode (no --apply/--preview) outdated path ──
-  // Covers upgrade.js L110-112: formatUpgradeMsg + console.log
   it('default mode: shows upgrade msg when outdated', async () => {
-    await withMockedEnv('99.99.99', vi.fn().mockReturnValue(Buffer.from('')), async (m) => {
+    await withMockedEnv('99.99.99', vi.fn(() => spawnEE(0)), async (m) => {
       const out = [];
       const origLog = console.log;
       console.log = (...a) => { out.push(a.join(' ')); };
@@ -125,7 +134,7 @@ describe('upgrade.js --apply execSync path', () => {
   }, 10000);
 
   // ── withMockedEnv variant: also mocks getLocalVersion() to return null ──
-  function withMockedEnvNoLocal(latestVersion, execSyncImpl, fn) {
+  function withMockedEnvNoLocal(latestVersion, spawnImpl, fn) {
     const fs = require('fs');
     const os = require('os');
     const cpPath = require('path').join(os.homedir(), '.xp-gate', 'version-cache.json');
@@ -135,8 +144,8 @@ describe('upgrade.js --apply execSync path', () => {
     evictCache();
     const cp = require('child_process');
     const https = require('https');
-    const saved = { execSync: cp.execSync, httpsGet: https.get, fsReadFileSync: fs.readFileSync };
-    cp.execSync = execSyncImpl;
+    const saved = { spawn: cp.spawn, httpsGet: https.get, fsReadFileSync: fs.readFileSync };
+    cp.spawn = spawnImpl;
     // Make getLocalVersion() return null by making fs.readFileSync throw for package.json
     fs.readFileSync = (filePath, encoding) => {
       if (typeof filePath === 'string' && filePath.includes('package.json')) {
@@ -165,7 +174,7 @@ describe('upgrade.js --apply execSync path', () => {
       const m = require('../upgrade');
       return fn(m);
     } finally {
-      cp.execSync = saved.execSync;
+      cp.spawn = saved.spawn;
       https.get = saved.httpsGet;
       fs.readFileSync = saved.fsReadFileSync;
     }
@@ -178,7 +187,7 @@ describe('upgrade.js --apply execSync path', () => {
     const origLog = console.log;
     console.log = (...a) => { out.push(a.join(' ')); };
     try {
-      const code = await withMockedEnvNoLocal('0.8.12', vi.fn().mockReturnValue(Buffer.from('')), async (m) => m.upgrade(['--apply']));
+      const code = await withMockedEnvNoLocal('0.8.12', vi.fn(() => spawnEE(0)), async (m) => m.upgrade(['--apply']));
       expect(code).toBe(0);
       expect(out.join(' ')).toBe('xp-gate is up to date.');
     } finally {
@@ -192,7 +201,7 @@ describe('upgrade.js --apply execSync path', () => {
     const origLog = console.log;
     console.log = (...a) => { out.push(a.join(' ')); };
     try {
-      const code = await withMockedEnvNoLocal('0.8.12', vi.fn().mockReturnValue(Buffer.from('')), async (m) => m.upgrade([]));
+      const code = await withMockedEnvNoLocal('0.8.12', vi.fn(() => spawnEE(0)), async (m) => m.upgrade([]));
       expect(code).toBe(0);
       expect(out.join(' ')).toBe('xp-gate is up to date.');
     } finally {
@@ -206,7 +215,7 @@ describe('upgrade.js --apply execSync path', () => {
     const origLog = console.log;
     console.log = (...a) => { out.push(a.join(' ')); };
     try {
-      const code = await withMockedEnv('99.99.99', vi.fn().mockReturnValue(Buffer.from('')), async (m) => m.upgrade([]));
+      const code = await withMockedEnv('99.99.99', vi.fn(() => spawnEE(0)), async (m) => m.upgrade([]));
       expect(code).toBe(0);
       expect(out.length + (out.join(' ').length > 0 ? 1 : 0)).toBeGreaterThan(0);
     } finally {
@@ -220,7 +229,7 @@ describe('upgrade.js --apply execSync path', () => {
     const origLog = console.log;
     console.log = (...a) => { out.push(a.join(' ')); };
     try {
-      const code = await withMockedEnv('1.0.0', vi.fn().mockReturnValue(Buffer.from('')), async (m) => m.upgrade(['--preview']));
+      const code = await withMockedEnv('1.0.0', vi.fn(() => spawnEE(0)), async (m) => m.upgrade(['--preview']));
       expect(code).toBe(0);
       expect(out.length).toBe(1);
       const parsed = JSON.parse(out[0]);

package/lib/baseline.js

@@ -220,6 +220,29 @@ async function createBaseline() {
   return baseline;
 }
 
+/**
+ * Count baseline entries grouped by tool type.
+ * @param {object} data - Parsed baseline object (filePath → entry)
+ * @returns {{ totalFiles: number, totalWarnings: number, eslintCount: number, ruffCount: number, golangciCount: number, shellcheckCount: number }}
+ */
+function countBaselineByTool(data) {
+  const files = Object.keys(data);
+  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++;
+  }
+
+  return { totalFiles: files.length, totalWarnings, eslintCount, ruffCount, golangciCount, shellcheckCount };
+}
+
 /**
  * Show current baseline.
  */
@@ -237,27 +260,16 @@ function showBaseline() {
     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++;
-  }
+  const counts = countBaselineByTool(data);
 
   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`);
+  console.log(`  Files tracked: ${counts.totalFiles}`);
+  console.log(`  Total warnings: ${counts.totalWarnings}`);
+  if (counts.eslintCount > 0) console.log(`  ESLint: ${counts.eslintCount} files`);
+  if (counts.ruffCount > 0) console.log(`  Ruff: ${counts.ruffCount} files`);
+  if (counts.golangciCount > 0) console.log(`  golangci-lint: ${counts.golangciCount} files`);
+  if (counts.shellcheckCount > 0) console.log(`  ShellCheck: ${counts.shellcheckCount} files`);
 
   return 0;
 }
@@ -272,21 +284,13 @@ async function resetBaseline() {
 }
 
 /**
- * Diff current lint state against stored baseline.
+ * Compare two baselines and produce diff data.
+ * @param {object} oldBaseline
+ * @param {object} currentBaseline
+ * @returns {{ totalWarningsDelta: number, increased: string[], decreased: string[], added: string[], removed: string[] }}
  */
-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),
-  ]);
+function compareBaselines(oldBaseline, currentBaseline) {
+  const allFiles = new Set([...Object.keys(oldBaseline), ...Object.keys(currentBaseline)]);
 
   let totalWarningsDelta = 0;
   const increased = [];
@@ -312,31 +316,54 @@ async function diffBaseline() {
     }
   }
 
+  return { totalWarningsDelta, increased, decreased, added, removed };
+}
+
+/**
+ * Print a diff result report to console.
+ */
+function printDiffReport(result) {
   console.log('Lint Baseline Diff:');
-  console.log(`  Total warnings delta: ${totalWarningsDelta >= 0 ? '+' : ''}${totalWarningsDelta}`);
+  console.log(`  Total warnings delta: ${result.totalWarningsDelta >= 0 ? '+' : ''}${result.totalWarningsDelta}`);
 
-  if (added.length > 0) {
-    console.log(`\nFiles added (${added.length}):`);
-    added.forEach(l => console.log(l));
+  if (result.added.length > 0) {
+    console.log(`\nFiles added (${result.added.length}):`);
+    result.added.forEach(l => console.log(l));
   }
-  if (removed.length > 0) {
-    console.log(`\nFiles removed (${removed.length}):`);
-    removed.forEach(l => console.log(l));
+  if (result.removed.length > 0) {
+    console.log(`\nFiles removed (${result.removed.length}):`);
+    result.removed.forEach(l => console.log(l));
   }
-  if (increased.length > 0) {
-    console.log(`\nWarnings increased (${increased.length}):`);
-    increased.forEach(l => console.log(l));
+  if (result.increased.length > 0) {
+    console.log(`\nWarnings increased (${result.increased.length}):`);
+    result.increased.forEach(l => console.log(l));
   }
-  if (decreased.length > 0) {
-    console.log(`\nWarnings decreased (${decreased.length}):`);
-    decreased.forEach(l => console.log(l));
+  if (result.decreased.length > 0) {
+    console.log(`\nWarnings decreased (${result.decreased.length}):`);
+    result.decreased.forEach(l => console.log(l));
   }
 
-  if (added.length === 0 && removed.length === 0 && increased.length === 0 && decreased.length === 0) {
+  if (result.added.length === 0 && result.removed.length === 0 && result.increased.length === 0 && result.decreased.length === 0) {
     console.log('  No change from baseline.');
   }
+}
+
+/**
+ * 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 result = compareBaselines(oldBaseline, currentBaseline);
+  printDiffReport(result);
 
-  return totalWarningsDelta > 0 ? 1 : 0;
+  return result.totalWarningsDelta > 0 ? 1 : 0;
 }
 
 /**
@@ -389,4 +416,4 @@ Examples:
   }
 }
 
-module.exports = { handleBaseline, createBaseline, showBaseline, resetBaseline, diffBaseline };
+module.exports = { handleBaseline, createBaseline, showBaseline, resetBaseline, diffBaseline, countBaselineByTool, compareBaselines };