@boyingliu01/xp-gate 0.8.16 → 0.8.18

package/bin/xp-gate.js

@@ -121,6 +121,14 @@ const COMMANDS = {
     description: 'Check for xp-gate updates (--preview for JSON, --apply to upgrade)',
     run: subargs => upgrade(subargs).then(code => process.exit(code)),
     usage: 'xp-gate upgrade [--preview] [--apply]'
+  },
+  'sprint-status': {
+    description: 'Show Sprint Flow progress (reads .sprint-state/sprint-state.json)',
+    run: subargs => {
+      const { handleSprintStatus } = require('../lib/sprint-status.js');
+      handleSprintStatus(subargs).then(code => process.exit(code));
+    },
+    usage: 'xp-gate sprint-status [--json] [--watch] [--dir <path>]'
   }
 };
 

package/lib/__tests__/check-version.test.js

@@ -74,8 +74,9 @@ describe('check-version.js — REQ-001-01', () => {
   // ──────────────────────────────────────────
   describe('getLocalVersion() — AC-001-01', () => {
     it('returns version from package.json', () => {
+      const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf8'));
       mod = require('../check-version');
-      expect(mod.getLocalVersion()).toBe('0.8.12');
+      expect(mod.getLocalVersion()).toBe(pkg.version);
     });
 
     it('returns null when read fails', () => {
@@ -104,13 +105,14 @@ describe('check-version.js — REQ-001-01', () => {
     beforeEach(() => { mod = require('../check-version'); });
 
     it('a < b → negative', () => {
-      expect(mod.compareVersions('0.8.12', '0.8.13')).toBeLessThan(0);
+      expect(mod.compareVersions('0.8.15', '0.8.17')).toBeLessThan(0);
     });
     it('a > b → positive', () => {
-      expect(mod.compareVersions('0.8.13', '0.8.12')).toBeGreaterThan(0);
+      expect(mod.compareVersions('0.8.17', '0.8.15')).toBeGreaterThan(0);
     });
     it('equal → 0', () => {
-      expect(mod.compareVersions('0.8.12', '0.8.12')).toBe(0);
+      expect(mod.compareVersions('0.8.17', '0.8.17')).toBe(0);
+
     });
     it('handles different segment counts', () => {
       expect(mod.compareVersions('1.0', '1.0.1')).toBeLessThan(0);
@@ -121,34 +123,24 @@ describe('check-version.js — REQ-001-01', () => {
   });
 
   // ──────────────────────────────────────────
-  // AC-001-08: calcLagDays() (internal — tested via checkUpgrade)
+  // AC-001-08: calcLagDays() — directly tested, no network/cache dependency
   // ──────────────────────────────────────────
-  describe('calcLagDays() behavior via checkUpgrade — AC-001-08', () => {
-    it('checkUpgrade returns lagDays=0 when no remote version', async () => {
-      mod = require('../check-version');
-      const r = await mod.checkUpgrade('@nonexistent/pkg-test-only');
-      expect(r.lagDays).toBe(0);
+  describe('calcLagDays() — AC-001-08', () => {
+    beforeEach(() => { mod = require('../check-version'); });
+
+    it('returns 0 when no publishedAt', () => {
+      expect(mod.calcLagDays('')).toBe(0);
+      expect(mod.calcLagDays(null)).toBe(0);
+      expect(mod.calcLagDays(undefined)).toBe(0);
     });
 
-    it('checkUpgrade uses calcLagDays with publishedAt when available', async () => {
-      const https = require('https');
-      const origGet = https.get;
-      const body = JSON.stringify({ latest: '99.99.99' });
-      https.get = (_url, _opts, cb) => {
-        const callback = typeof _opts === 'function' ? _opts : cb;
-        if (!callback) return { on: () => this, destroy: () => {} };
-        const mockRes = {
-          statusCode: 200,
-          on: (evt, handler) => { if (evt === 'end') handler(); return mockRes; },
-        };
-        callback(mockRes);
-        return { on: () => this, destroy: () => {} };
-      };
-      vi.resetModules();
-      mod = require('../check-version');
-      const r = await mod.checkUpgrade('@nonexistent/pkg-test-only');
-      expect(r.lagDays).toBe(0);
-      https.get = origGet;
+    it('returns 0 when publishedAt is unparseable', () => {
+      expect(mod.calcLagDays('not-a-date')).toBe(0);
+    });
+
+    it('returns >= 0 for a past date', () => {
+      const lag = mod.calcLagDays('2026-06-15T00:00:00.000Z');
+      expect(lag).toBeGreaterThanOrEqual(0);
     });
   });
 
@@ -222,17 +214,17 @@ describe('check-version.js — REQ-001-01', () => {
 
     it('returns safe defaults (outdated:false) without network', async () => {
       // Mock https to return the SAME version as local → outdated=false, no network dependency
-      const result = await withMockedHttps('0.8.12', async (m) => m.checkUpgrade('@nonexistent/pkg-test-only'));
+      const result = await withMockedHttps('0.8.18', async (m) => m.checkUpgrade('@nonexistent/pkg-test-only'));
       expect(result.outdated).toBe(false);
-      expect(result.local).toBe('0.8.12');
-      expect(result.remote).toBe('0.8.12');
+      expect(result.local).toBe('0.8.18');
+      expect(result.remote).toBe('0.8.18');
       expect(result.lagDays).toBe(0);
     });
 
     it('returns outdated=true when remote > local', async () => {
       const result = await withMockedHttps('99.99.99', async (m) => m.checkUpgrade('@nonexistent/pkg-test-only'));
       expect(result.outdated).toBe(true);
-      expect(result.local).toBe('0.8.12');
+      expect(result.local).toBe('0.8.18');
       expect(result.remote).toBe('99.99.99');
     });
   });
@@ -254,7 +246,7 @@ describe('check-version.js — REQ-001-01', () => {
   // ──────────────────────────────────────────
   describe('formatUpgradeMsg() — up to date', () => {
     beforeEach(() => { mod = require('../check-version'); });
-    const r = { outdated: false, local: '0.8.12', remote: '0.8.12', lagDays: 0 };
+    const r = { outdated: false, local: '0.8.17', remote: '0.8.17', lagDays: 0 };
 
     it('cli shows checkmark', () => {
       expect(mod.formatUpgradeMsg(r, 'cli')).toContain('up to date');
@@ -272,7 +264,7 @@ describe('check-version.js — REQ-001-01', () => {
   // ──────────────────────────────────────────
   describe('formatUpgradeMsg() — outdated (AC-003-01/02/03)', () => {
     beforeEach(() => { mod = require('../check-version'); });
-    const r = { outdated: true, local: '0.8.12', remote: '0.8.13', lagDays: 10 };
+    const r = { outdated: true, local: '0.8.17', remote: '0.8.13', lagDays: 10 };
 
     it('cli: full release link + upgrade cmd (AC-003-01)', () => {
       const msg = mod.formatUpgradeMsg(r, 'cli');

package/lib/__tests__/sprint-status.test.js

@@ -0,0 +1,196 @@
+/**
+ * @test REQ-SPRINTSTATUS-001 Sprint Status CLI
+ * @intent Validate xp-gate sprint-status command reads sprint-state.json and renders table
+ * @covers AC-SPRINTSTATUS-001-01 through AC-SPRINTSTATUS-001-09
+ */
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// Import the module
+const sprintStatus = require('../sprint-status');
+
+const TMP_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'sprint-status-test-'));
+const STATE_DIR = path.join(TMP_DIR, '.sprint-state');
+const STATE_FILE = path.join(STATE_DIR, 'sprint-state.json');
+
+// Active sprint state (canonical format per SKILL.md L893-942)
+const ACTIVE_STATE = {
+  id: 'sprint-2026-06-16-01',
+  task_description: 'Test sprint',
+  phase: 2,
+  status: 'running',
+  started_at: '2026-06-16T10:00:00Z',
+  isolation: {
+    worktree_path: '.worktrees/sprint/sprint-2026-06-16-01',
+    branch: 'sprint/2026-06-16-01',
+    created_from: 'main',
+    created_from_commit: 'abc123'
+  },
+  auto_estimate: {
+    change_type: '新增功能',
+    estimated_level: '轻量',
+    user_decision: 'accepted'
+  },
+  phase_history: [
+    { phase: -1, phase_name: 'ISOLATE', status: 'completed',
+      started_at: '2026-06-16T10:00:00Z', completed_at: '2026-06-16T10:03:00Z', duration_seconds: 180 },
+    { phase: -0.5, phase_name: 'AUTO-ESTIMATE', status: 'completed',
+      started_at: '2026-06-16T10:03:00Z', completed_at: '2026-06-16T10:05:00Z', duration_seconds: 120 },
+    { phase: 0, phase_name: 'THINK', status: 'completed',
+      started_at: '2026-06-16T10:05:00Z', completed_at: '2026-06-16T10:15:00Z', duration_seconds: 600 },
+    { phase: 1, phase_name: 'PLAN', status: 'completed',
+      started_at: '2026-06-16T10:15:00Z', completed_at: '2026-06-16T10:25:00Z', duration_seconds: 600 },
+    { phase: 2, phase_name: 'BUILD', status: 'in_progress',
+      started_at: '2026-06-16T10:25:00Z', completed_at: null, duration_seconds: null,
+      reqs: {
+        'REQ-001': { name: 'Feature A', status: 'completed' },
+        'REQ-002': { name: 'Feature B', status: 'in_progress' }
+      }
+    }
+  ],
+  outputs: { specification: '.sprint-state/phase-outputs/specification.yaml' },
+  metrics: { tests_passed: 5, tests_failed: 0, coverage_pct: 85 }
+};
+
+const EMPTY_STATE = {};
+
+const MINIMAL_STATE = {
+  id: 'sprint-minimal',
+  task_description: 'Minimal sprint',
+  phase: 0,
+  status: 'running',
+  started_at: '2026-06-16T10:00:00Z',
+  phase_history: []
+};
+
+beforeAll(() => {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+});
+
+afterAll(() => {
+  fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+function writeState(data) {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+}
+
+function deleteState() {
+  try { fs.unlinkSync(STATE_FILE); } catch {}
+}
+
+describe('sprint-status: readSprintState', () => {
+  // AC-SPRINTSTATUS-001-01: Reads state correctly
+  test('reads active sprint-state.json', () => {
+    writeState(ACTIVE_STATE);
+    const state = sprintStatus.readSprintState(TMP_DIR);
+    expect(state).not.toBeNull();
+    expect(state.task_description).toBe('Test sprint');
+    expect(state.phase).toBe(2);
+    expect(state.status).toBe('running');
+    expect(Array.isArray(state.phase_history)).toBe(true);
+    expect(state.phase_history.length).toBeGreaterThan(0);
+  });
+
+  // AC-SPRINTSTATUS-001-02: No active sprint
+  test('returns null when no sprint-state.json exists', () => {
+    deleteState();
+    const state = sprintStatus.readSprintState(TMP_DIR);
+    expect(state).toBeNull();
+  });
+
+  // AC-SPRINTSTATUS-001-05: Malformed JSON with graceful defaults
+  test('handles malformed sprint-state.json gracefully', () => {
+    fs.writeFileSync(STATE_FILE, '{not valid json!!!');
+    const state = sprintStatus.readSprintState(TMP_DIR);
+    expect(state).toBeNull();
+  });
+
+  // AC-SPRINTSTATUS-001-05: Missing fields use defaults
+  test('handles empty/partial state with defaults', () => {
+    writeState(EMPTY_STATE);
+    const state = sprintStatus.readSprintState(TMP_DIR);
+    // Should return the empty object without crashing
+    expect(state).toBeDefined();
+  });
+
+  // AC-SPRINTSTATUS-001-08: --dir parameter works
+  test('reads state from custom directory', () => {
+    writeState(ACTIVE_STATE);
+    const state = sprintStatus.readSprintState(TMP_DIR);
+    expect(state).not.toBeNull();
+    expect(state.task_description).toBe('Test sprint');
+  });
+});
+
+describe('sprint-status: formatSprintTable', () => {
+  beforeEach(() => writeState(ACTIVE_STATE));
+
+  // AC-SPRINTSTATUS-001-01: Table contains sprint info
+  test('renders table with task_description and branch', () => {
+    const output = sprintStatus.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('Test sprint');
+    expect(output).toContain('sprint/2026-06-16-01');
+  });
+
+  // AC-SPRINTSTATUS-001-03: Completed phases have ✅
+  test('marks completed phases with ✅', () => {
+    const output = sprintStatus.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('✅');
+  });
+
+  // AC-SPRINTSTATUS-001-03: In-progress phases have 🔄
+  test('marks in-progress phases with 🔄', () => {
+    const output = sprintStatus.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('🔄');
+  });
+
+  // AC-SPRINTSTATUS-001-04: Missing phases show ⏳ Pending
+  test('shows pending for phases not in phase_history', () => {
+    const output = sprintStatus.formatSprintTable(ACTIVE_STATE);
+    // Phase 3-8 are missing from phase_history
+    expect(output).toContain('⏳');
+    expect(output).toContain('Pending');
+  });
+
+  // AC-SPRINTSTATUS-001-05: Missing fields don't crash
+  test('handles minimal state without crashing', () => {
+    const output = sprintStatus.formatSprintTable(MINIMAL_STATE);
+    expect(output).toBeDefined();
+    expect(typeof output).toBe('string');
+  });
+
+  // AC-SPRINTSTATUS-001-06: JSON mode
+  test('jsonMode returns raw state as JSON string', () => {
+    const json = sprintStatus.jsonMode(ACTIVE_STATE);
+    const parsed = JSON.parse(json);
+    expect(parsed.task_description).toBe('Test sprint');
+    expect(parsed.phase).toBe(2);
+  });
+
+  // AC-SPRINTSTATUS-001-09: Stale state detection
+  test('detects stale state (>1h old)', () => {
+    const staleState = JSON.parse(JSON.stringify(ACTIVE_STATE));
+    const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+    staleState.started_at = twoHoursAgo;
+    // Also backdate all phase_history timestamps so isStale() triggers
+    if (Array.isArray(staleState.phase_history)) {
+      for (const ph of staleState.phase_history) {
+        if (ph.started_at) ph.started_at = twoHoursAgo;
+        if (ph.completed_at) ph.completed_at = twoHoursAgo;
+      }
+    }
+    const output = sprintStatus.formatSprintTable(staleState);
+    expect(output).toContain('State may be stale');
+  });
+
+  // REQ-level progress in BUILD phase
+  test('shows REQ-level progress in BUILD phase', () => {
+    const output = sprintStatus.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('REQ-001');
+    expect(output).toContain('Feature A');
+    expect(output).toContain('REQ-002');
+    expect(output).toContain('Feature B');
+  });
+});

package/lib/__tests__/sprint-status.test.ts

@@ -0,0 +1,220 @@
+/**
+ * @test REQ-SPRINTSTATUS-001 Sprint Status CLI
+ * @intent Validate xp-gate sprint-status command reads sprint-state.json and renders table
+ * @covers AC-SPRINTSTATUS-001-01 through AC-SPRINTSTATUS-001-09
+ */
+import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'vitest';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+// We need to wait until sprint-status.js exists before importing it
+// For now, use a dynamic import pattern
+let sprintStatus: typeof import('../sprint-status');
+
+const TMP_DIR = fs.mkdtempSync(path.join(os.tmpdir(), 'sprint-status-test-'));
+const STATE_DIR = path.join(TMP_DIR, '.sprint-state');
+const STATE_FILE = path.join(STATE_DIR, 'sprint-state.json');
+
+// Active sprint state (canonical format per SKILL.md L893-942)
+const ACTIVE_STATE = {
+  id: 'sprint-2026-06-16-01',
+  task_description: 'Test sprint',
+  phase: 2,
+  status: 'running',
+  started_at: '2026-06-16T10:00:00Z',
+  isolation: {
+    worktree_path: '.worktrees/sprint/sprint-2026-06-16-01',
+    branch: 'sprint/2026-06-16-01',
+    created_from: 'main',
+    created_from_commit: 'abc123'
+  },
+  auto_estimate: {
+    change_type: '新增功能',
+    estimated_level: '轻量',
+    user_decision: 'accepted'
+  },
+  phase_history: [
+    { phase: -1, phase_name: 'ISOLATE', status: 'completed',
+      started_at: '2026-06-16T10:00:00Z', completed_at: '2026-06-16T10:03:00Z', duration_seconds: 180 },
+    { phase: -0.5, phase_name: 'AUTO-ESTIMATE', status: 'completed',
+      started_at: '2026-06-16T10:03:00Z', completed_at: '2026-06-16T10:05:00Z', duration_seconds: 120 },
+    { phase: 0, phase_name: 'THINK', status: 'completed',
+      started_at: '2026-06-16T10:05:00Z', completed_at: '2026-06-16T10:15:00Z', duration_seconds: 600 },
+    { phase: 1, phase_name: 'PLAN', status: 'completed',
+      started_at: '2026-06-16T10:15:00Z', completed_at: '2026-06-16T10:25:00Z', duration_seconds: 600 },
+    { phase: 2, phase_name: 'BUILD', status: 'in_progress',
+      started_at: '2026-06-16T10:25:00Z', completed_at: null, duration_seconds: null,
+      reqs: {
+        'REQ-001': { name: 'Feature A', status: 'completed' },
+        'REQ-002': { name: 'Feature B', status: 'in_progress' }
+      }
+    }
+  ],
+  outputs: { specification: '.sprint-state/phase-outputs/specification.yaml' },
+  metrics: { tests_passed: 5, tests_failed: 0, coverage_pct: 85 }
+};
+
+const MINIMAL_STATE = {
+  id: 'sprint-minimal',
+  task_description: 'Minimal sprint',
+  phase: 0,
+  status: 'running',
+  started_at: '2026-06-16T10:00:00Z',
+  phase_history: []
+};
+
+beforeAll(async () => {
+  fs.mkdirSync(STATE_DIR, { recursive: true });
+  // Import after module is created
+  try {
+    sprintStatus = await import('../sprint-status.js');
+  } catch {
+    // Module not yet created — tests will fail until GREEN phase
+  }
+});
+
+afterAll(() => {
+  fs.rmSync(TMP_DIR, { recursive: true, force: true });
+});
+
+function writeState(data: Record<string, unknown>) {
+  fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2));
+}
+
+function deleteState() {
+  try { fs.unlinkSync(STATE_FILE); } catch { /* ignore */ }
+}
+
+// Helper to skip tests when module not yet implemented
+function skipIfModuleMissing() {
+  if (!sprintStatus) {
+    console.warn('[SKIP] sprint-status module not yet implemented');
+  }
+  return !sprintStatus;
+}
+
+describe('sprint-status: readSprintState', () => {
+  // AC-SPRINTSTATUS-001-01: Reads state correctly
+  test('reads active sprint-state.json', () => {
+    if (skipIfModuleMissing()) return;
+    writeState(ACTIVE_STATE);
+    const state = sprintStatus!.readSprintState(TMP_DIR);
+    expect(state).not.toBeNull();
+    expect(state?.task_description).toBe('Test sprint');
+    expect(state?.phase).toBe(2);
+    expect(state?.status).toBe('running');
+    expect(Array.isArray(state?.phase_history)).toBe(true);
+  });
+
+  // AC-SPRINTSTATUS-001-02: No active sprint
+  test('returns null when no sprint-state.json exists', () => {
+    if (skipIfModuleMissing()) return;
+    deleteState();
+    const state = sprintStatus!.readSprintState(TMP_DIR);
+    expect(state).toBeNull();
+  });
+
+  // AC-SPRINTSTATUS-001-05: Malformed JSON handled gracefully
+  test('handles malformed sprint-state.json gracefully', () => {
+    if (skipIfModuleMissing()) return;
+    fs.writeFileSync(STATE_FILE, '{not valid json!!!');
+    const state = sprintStatus!.readSprintState(TMP_DIR);
+    expect(state).toBeNull();
+  });
+
+  // AC-SPRINTSTATUS-001-05: Missing fields use defaults
+  test('handles empty/partial state with defaults', () => {
+    if (skipIfModuleMissing()) return;
+    writeState({});
+    const state = sprintStatus!.readSprintState(TMP_DIR);
+    expect(state).toBeDefined();
+  });
+
+  // AC-SPRINTSTATUS-001-08: --dir parameter works  
+  test('reads from custom directory', () => {
+    if (skipIfModuleMissing()) return;
+    writeState(ACTIVE_STATE);
+    const state = sprintStatus!.readSprintState(TMP_DIR);
+    expect(state).not.toBeNull();
+  });
+});
+
+describe('sprint-status: formatSprintTable', () => {
+  beforeEach(() => writeState(ACTIVE_STATE));
+
+  // AC-SPRINTSTATUS-001-01: Table contains sprint info
+  test('renders table with task_description and branch', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('Test sprint');
+    expect(output).toContain('sprint/2026-06-16-01');
+  });
+
+  // AC-SPRINTSTATUS-001-03: Completed phases show ✅
+  test('marks completed phases with ✅', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('✅');
+  });
+
+  // AC-SPRINTSTATUS-001-03: In-progress shows 🔄
+  test('marks in-progress phases with 🔄', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('🔄');
+  });
+
+  // AC-SPRINTSTATUS-001-04: Missing phases show ⏳ Pending
+  test('shows pending for phases not in phase_history', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('⏳');
+    expect(output).toContain('Pending');
+  });
+
+  // AC-SPRINTSTATUS-001-05: No crash on minimal state
+  test('handles minimal state without crashing', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(MINIMAL_STATE);
+    expect(output).toBeDefined();
+    expect(typeof output).toBe('string');
+  });
+
+  // AC-SPRINTSTATUS-001-09: Stale state detection (>1h)
+  test('detects stale state (>1h old)', () => {
+    if (skipIfModuleMissing()) return;
+    const oldDate = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString();
+    const staleState = JSON.parse(JSON.stringify(ACTIVE_STATE));
+    staleState.started_at = oldDate;
+    if (Array.isArray(staleState.phase_history)) {
+      for (const ph of staleState.phase_history) {
+        if (ph.started_at) ph.started_at = oldDate;
+        if (ph.completed_at) ph.completed_at = oldDate;
+      }
+    }
+    const output = sprintStatus!.formatSprintTable(staleState);
+    expect(output).toContain('stale');
+  });
+
+  // REQ-level progress in BUILD
+  test('shows REQ-level progress in BUILD phase', () => {
+    if (skipIfModuleMissing()) return;
+    const output = sprintStatus!.formatSprintTable(ACTIVE_STATE);
+    expect(output).toContain('REQ-001');
+    expect(output).toContain('Feature A');
+    expect(output).toContain('REQ-002');
+    expect(output).toContain('Feature B');
+  });
+});
+
+describe('sprint-status: jsonMode', () => {
+  // AC-SPRINTSTATUS-001-06: JSON mode
+  test('returns raw state as parseable JSON', () => {
+    if (skipIfModuleMissing()) return;
+    const json = sprintStatus!.jsonMode(ACTIVE_STATE);
+    const parsed = JSON.parse(json);
+    expect(parsed.task_description).toBe('Test sprint');
+    expect(parsed.phase).toBe(2);
+  });
+});

package/lib/check-version.js

@@ -285,4 +285,5 @@ module.exports = {
   formatUpgradeMsg,
   compareVersions,
   clearCache,
+  calcLagDays,
 };