@boyingliu01/xp-gate 0.14.8 → 0.14.10

package/bin/xp-gate.js

@@ -14,6 +14,7 @@ const { arch } = require('../lib/arch.js');
 const { upgrade } = require('../lib/upgrade.js');
 const { bootstrap } = require('../lib/bootstrap.js');
 const { updateHooks } = require('../lib/update-hooks.js');
+const gateRunner = require('../lib/gate-runner.js');
 
 function handleUIReview() {
   const { execSync } = require('child_process');
@@ -105,9 +106,9 @@ const COMMANDS = {
     usage: 'xp-gate baseline <create|show|reset|diff>'
   },
   'check': {
-    description: 'Run user-invokable quality gates (Gate 4 Principles + Gate 6 Architecture) on a path',
+    description: 'Run quality gates (--list, --all, --gates <ids>, or <gate-id>)',
     run: subargs => check(subargs).then(code => process.exit(code)),
-    usage: 'xp-gate check <file_or_directory> [--gates principles,arch]'
+    usage: 'xp-gate check <file_or_directory|gate_number> [--gates gates] [--all] [--list]'
   },
   'principles': {
     description: 'Run Clean Code + SOLID principles checker (Gate 4 standalone)',
@@ -173,9 +174,29 @@ const COMMANDS = {
       install(subargs).then(code => process.exit(code));
     },
     usage: 'xp-gate install [--global]'
+  },
+  'gate-list': {
+    description: 'List all quality gates and their availability',
+    run: subargs => check(['--list']).then(code => process.exit(code)),
+    usage: 'xp-gate gate-list'
+  },
+  'gate-all': {
+    description: 'Run all invokable quality gates',
+    run: subargs => check(['--all', ...subargs]).then(code => process.exit(code)),
+    usage: 'xp-gate gate-all [<path>]'
   }
 };
 
+for (let i = 0; i <= 11; i++) {
+  const gateId = String(i);
+  const gateInfo = gateRunner.GATE_REGISTRY[gateId];
+  COMMANDS[`gate-${gateId}`] = {
+    description: `Run Gate ${gateId}: ${gateInfo?.name || 'Unknown'}`,
+    run: subargs => gateRunner.runGate(gateId, subargs[0]).then(code => process.exit(code)),
+    usage: `xp-gate gate-${gateId} [<path>]`
+  };
+}
+
 function printHelp() {
   console.log('xp-gate - AI development workflow tool');
   console.log('');

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

@@ -178,7 +178,8 @@ describe('install-skill', () => {
     expect(fs.existsSync(configFile)).toBe(true);
     const config = JSON.parse(fs.readFileSync(configFile, 'utf8'));
     expect(config.installedSkills).toHaveProperty('delphi-review');
-    expect(config.installedSkills['delphi-review'].version).toBe('1.0.0');
+    // Version should be actual CLI version (0.14.10.0), not hardcoded '1.0.0'
+    expect(config.installedSkills['delphi-review'].version).toBe('0.14.10.0');
     expect(config.installedSkills['delphi-review'].installedAt).toMatch(/^\d{4}-/);
   });
 

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

@@ -322,10 +322,12 @@ describe('sprint-discovery: discoverActiveSprints', () => {
       // no id, no status, no started_at
       task_description: 'Partial fields only',
     });
-    // Should not throw, result should be skipped (no valid id)
+    // After migration, missing id gets auto-generated, so result is found
     const results = sprintDiscovery.discoverActiveSprints(TMP_ROOT);
     const partials = results.filter(r => r.state.task_description === 'Partial fields only');
-    expect(partials.length).toBe(0);
+    expect(partials.length).toBe(1);
+    // Migrated state should have auto-generated id
+    expect(partials[0].state.id).toMatch(/^sprint-\d+$/);
   });
 
   test('handles EACCES on .sprint-state/ directory gracefully', () => {
@@ -359,7 +361,7 @@ describe('sprint-discovery: discoverActiveSprints', () => {
     const results = sprintDiscovery.discoverActiveSprints(TMP_ROOT);
     const desc = results.filter(r => r.state.id === 'sprint-2026-06-23-nodesc');
     expect(desc.length).toBe(1);
-    // task_description will be null/undefined, but entry should still be returned
-    expect(desc[0].state.task_description).toBeUndefined();
+    // After migration, missing task_description gets default '-'
+    expect(desc[0].state.task_description).toBe('-');
   });
 });

package/lib/__tests__/sprint-state-manager.test.js

@@ -0,0 +1,279 @@
+/**
+ * Tests for Sprint State Manager
+ * @test REQ-001 Sprint State Manager
+ * @intent Verify read/write/migration/transitionPhase/rollback
+ * @covers AC-001-01, AC-001-02, AC-001-03
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { SprintStateManager, LEGACY_PHASE_MAP } from '../sprint-state-manager.js';
+import { migrateState, createInitialState } from '../sprint-state-migrator.js';
+
+describe('SprintStateManager', () => {
+  let tmpDir;
+  let manager;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sprint-state-test-'));
+    manager = new SprintStateManager(tmpDir);
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('read()', () => {
+    it('returns null when file does not exist', () => {
+      const state = manager.read();
+      expect(state).toBeNull();
+    });
+
+    it('reads valid state file', () => {
+      const state = {
+        _schema_version: 1,
+        id: 'sprint-123',
+        task_description: 'Test sprint',
+        phase: 2,
+        status: 'in_progress',
+        started_at: '2026-07-14T10:00:00Z',
+        phase_history: [],
+        isolation: { worktree_path: tmpDir, branch: 'test' },
+      };
+      fs.mkdirSync(path.join(tmpDir, '.sprint-state'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, '.sprint-state', 'sprint-state.json'),
+        JSON.stringify(state, null, 2)
+      );
+
+      const result = manager.read();
+      expect(result.id).toBe('sprint-123');
+      expect(result._schema_version).toBe(1);
+    });
+
+    it('auto-migrates legacy state and creates backup', () => {
+      const legacyState = {
+        id: 'sprint-legacy',
+        task_description: 'Legacy sprint',
+        phase: -1, // Legacy ISOLATE → 1 (PREP)
+        status: 'completed',
+        phase_history: [
+          { phase: -1, phase_name: 'ISOLATE', status: 'completed', timestamp: '2026-07-14T10:00:00Z' },
+        ],
+        isolation: { worktree_path: tmpDir, branch: 'test' },
+      };
+      fs.mkdirSync(path.join(tmpDir, '.sprint-state'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, '.sprint-state', 'sprint-state.json'),
+        JSON.stringify(legacyState, null, 2)
+      );
+
+      const result = manager.read();
+
+      // Should be migrated
+      expect(result._schema_version).toBe(1);
+      expect(result.phase).toBe(1); // -1 → 1
+      expect(result.phase_history[0].phase).toBe(1);
+      expect(result.phase_history[0].phase_name).toBe('PREP');
+      expect(result.phase_history[0].started_at).toBe('2026-07-14T10:00:00Z'); // timestamp → started_at
+
+      // Backup should exist
+      const backupExists = fs.existsSync(path.join(tmpDir, '.sprint-state', 'sprint-state.json.backup'));
+      expect(backupExists).toBe(true);
+    });
+  });
+
+  describe('write()', () => {
+    it('writes state atomically', () => {
+      const state = {
+        _schema_version: 1,
+        id: 'sprint-test',
+        task_description: 'Test',
+        phase: 1,
+        status: 'in_progress',
+        started_at: new Date().toISOString(),
+        phase_history: [],
+        isolation: { worktree_path: tmpDir, branch: 'test' },
+      };
+
+      manager.write(state);
+
+      const written = JSON.parse(
+        fs.readFileSync(path.join(tmpDir, '.sprint-state', 'sprint-state.json'), 'utf8')
+      );
+      expect(written.id).toBe('sprint-test');
+
+      // Tmp file should not exist (atomic write completed)
+      const tmpExists = fs.existsSync(path.join(tmpDir, '.sprint-state', 'sprint-state.json.tmp'));
+      expect(tmpExists).toBe(false);
+    });
+  });
+
+  describe('transitionPhase()', () => {
+    it('creates new phase_history entry', () => {
+      // Create initial state
+      const initialState = createInitialState(tmpDir);
+      manager.write(initialState);
+
+      // Transition to phase 2
+      const result = manager.transitionPhase(2, 'in_progress');
+
+      expect(result.phase).toBe(2);
+      expect(result.phase_history.length).toBe(1);
+      expect(result.phase_history[0].phase).toBe(2);
+      expect(result.phase_history[0].phase_name).toBe('DESIGN');
+      expect(result.phase_history[0].status).toBe('in_progress');
+      expect(result.phase_history[0].started_at).toBeDefined();
+    });
+
+    it('updates existing phase_history entry', () => {
+      const initialState = createInitialState(tmpDir);
+      manager.write(initialState);
+
+      // Start phase 2
+      manager.transitionPhase(2, 'in_progress');
+
+      // Complete phase 2
+      const result = manager.transitionPhase(2, 'completed');
+
+      expect(result.phase_history[0].status).toBe('completed');
+      expect(result.phase_history[0].completed_at).toBeDefined();
+      expect(result.phase_history[0].duration_seconds).toBeGreaterThanOrEqual(0);
+    });
+
+    it('calls onTransition callback', () => {
+      const initialState = createInitialState(tmpDir);
+      manager.write(initialState);
+
+      let callbackCalled = false;
+      let callbackState = null;
+
+      manager.transitionPhase(2, 'in_progress', {
+        onTransition: (state) => {
+          callbackCalled = true;
+          callbackState = state;
+        },
+      });
+
+      expect(callbackCalled).toBe(true);
+      expect(callbackState.phase).toBe(2);
+    });
+
+    it('handles onTransition callback errors gracefully', () => {
+      const initialState = createInitialState(tmpDir);
+      manager.write(initialState);
+
+      // Should not throw
+      expect(() => {
+        manager.transitionPhase(2, 'in_progress', {
+          onTransition: () => {
+            throw new Error('Render failed');
+          },
+        });
+      }).not.toThrow();
+
+      // State should still be updated
+      const state = manager.read();
+      expect(state.phase).toBe(2);
+    });
+
+    it('updates outputs when provided', () => {
+      const initialState = createInitialState(tmpDir);
+      manager.write(initialState);
+
+      const result = manager.transitionPhase(2, 'completed', {
+        outputs: { specification: 'spec.yaml' },
+      });
+
+      expect(result.outputs.specification).toBe('spec.yaml');
+    });
+  });
+
+  describe('migrate()', () => {
+    it('adds _schema_version', () => {
+      const state = { id: 'test', phase: 1, phase_history: [] };
+      const migrated = migrateState(state, manager.stateDir);
+      expect(migrated._schema_version).toBe(1);
+    });
+
+    it('sets default task_description if missing', () => {
+      const state = { id: 'test', phase: 1, phase_history: [] };
+      const migrated = migrateState(state, manager.stateDir);
+      expect(migrated.task_description).toBe('-');
+    });
+
+    it('migrates all legacy phase numbers', () => {
+      for (const [legacy, expected] of Object.entries(LEGACY_PHASE_MAP)) {
+        const state = {
+          id: 'test',
+          phase: Number(legacy),
+          phase_history: [{ phase: Number(legacy), status: 'completed' }],
+        };
+        const migrated = migrateState(state, manager.stateDir);
+        expect(migrated.phase).toBe(expected.phase);
+        expect(migrated.phase_history[0].phase).toBe(expected.phase);
+        expect(migrated.phase_history[0].phase_name).toBe(expected.phase_name);
+      }
+    });
+
+    it('preserves unknown fields', () => {
+      const state = {
+        id: 'test',
+        phase: 1,
+        phase_history: [],
+        custom_field: 'preserved',
+      };
+      const migrated = migrateState(state, manager.stateDir);
+      expect(migrated.custom_field).toBe('preserved');
+    });
+  });
+
+  describe('rollback()', () => {
+    it('returns false when no backup exists', () => {
+      const result = manager.rollback();
+      expect(result).toBe(false);
+    });
+
+    it('restores from backup', () => {
+      // Create initial state and backup
+      const originalState = {
+        _schema_version: 1,
+        id: 'original',
+        task_description: 'Original',
+        phase: 1,
+        status: 'in_progress',
+        started_at: '2026-07-14T10:00:00Z',
+        phase_history: [],
+        isolation: { worktree_path: tmpDir, branch: 'test' },
+      };
+      fs.mkdirSync(path.join(tmpDir, '.sprint-state'), { recursive: true });
+      fs.writeFileSync(
+        path.join(tmpDir, '.sprint-state', 'sprint-state.json'),
+        JSON.stringify(originalState, null, 2)
+      );
+      fs.writeFileSync(
+        path.join(tmpDir, '.sprint-state', 'sprint-state.json.backup'),
+        JSON.stringify(originalState, null, 2)
+      );
+
+      // Modify current state
+      const modifiedState = { ...originalState, id: 'modified' };
+      fs.writeFileSync(
+        path.join(tmpDir, '.sprint-state', 'sprint-state.json'),
+        JSON.stringify(modifiedState, null, 2)
+      );
+
+      // Rollback
+      const result = manager.rollback();
+      expect(result).toBe(true);
+
+      // Verify restored
+      const restored = JSON.parse(
+        fs.readFileSync(path.join(tmpDir, '.sprint-state', 'sprint-state.json'), 'utf8')
+      );
+      expect(restored.id).toBe('original');
+    });
+  });
+});

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

@@ -14,12 +14,13 @@ 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)
+// Active sprint state (v1 schema per sprint-state-manager.js)
 const ACTIVE_STATE = {
+  _schema_version: 1,
   id: 'sprint-2026-06-16-01',
   task_description: 'Test sprint',
-  phase: 2,
-  status: 'running',
+  phase: 3,
+  status: 'in_progress',
   started_at: '2026-06-16T10:00:00Z',
   isolation: {
     worktree_path: '.worktrees/sprint/sprint-2026-06-16-01',
@@ -33,15 +34,11 @@ const ACTIVE_STATE = {
     user_decision: 'accepted'
   },
   phase_history: [
-    { phase: -1, phase_name: 'ISOLATE', status: 'completed',
+    { phase: 1, phase_name: 'PREP', 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',
+    { phase: 2, phase_name: 'DESIGN', 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',
+    { phase: 3, 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' },
@@ -87,8 +84,8 @@ describe('sprint-status: readSprintState', () => {
     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(state.phase).toBe(3);
+    expect(state.status).toBe('in_progress');
     expect(Array.isArray(state.phase_history)).toBe(true);
     expect(state.phase_history.length).toBeGreaterThan(0);
   });
@@ -166,7 +163,7 @@ describe('sprint-status: formatSprintTable', () => {
     const json = sprintStatus.jsonMode(ACTIVE_STATE);
     const parsed = JSON.parse(json);
     expect(parsed.task_description).toBe('Test sprint');
-    expect(parsed.phase).toBe(2);
+    expect(parsed.phase).toBe(3);
   });
 
   // AC-SPRINTSTATUS-001-09: Stale state detection

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

@@ -16,12 +16,13 @@ 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, 6-phase schema)
+// Active sprint state (v1 schema per sprint-state-manager.js, 6-phase schema)
 const ACTIVE_STATE = {
+  _schema_version: 1,
   id: 'sprint-2026-06-16-01',
   task_description: 'Test sprint',
   phase: 3,
-  status: 'running',
+  status: 'in_progress',
   started_at: '2026-06-16T10:00:00Z',
   isolation: {
     worktree_path: '.worktrees/sprint/sprint-2026-06-16-01',
@@ -95,7 +96,7 @@ describe('sprint-status: readSprintState', () => {
     const stateObj = state as Record<string, unknown>;
     expect(stateObj.task_description).toBe('Test sprint');
     expect(stateObj.phase).toBe(3);
-    expect(stateObj.status).toBe('running');
+    expect(stateObj.status).toBe('in_progress');
     expect(Array.isArray(stateObj.phase_history)).toBe(true);
   });
 

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

@@ -140,6 +140,18 @@ describe('updateHooks', () => {
       expect(fs.readFileSync(path.join(dest, 'gate-4.sh'), 'utf8')).toContain('gate4-v2');
     });
 
+    it('copies sprint-gate.sh alongside gate-*.sh scripts (#335)', () => {
+      createPackageSource();
+      fs.writeFileSync(path.join(tmpPackage, 'sprint-gate.sh'), '#!/bin/bash\necho "sprint-gate-v1"');
+      const mod = getModule();
+      const dest = path.join(tmpProject, 'gates-sprint');
+      fs.mkdirSync(dest, { recursive: true });
+
+      mod.copyGateScripts(tmpPackage, dest, false, true);
+
+      expect(fs.readFileSync(path.join(dest, 'sprint-gate.sh'), 'utf8')).toContain('sprint-gate-v1');
+    });
+
     it('does not copy non-gate files', () => {
       createPackageSource();
       fs.writeFileSync(path.join(tmpPackage, 'some-other.sh'), 'echo other');

package/lib/__tests__/upgrade-skill-sync.test.js

@@ -0,0 +1,65 @@
+/**
+ * @test REQ-332 xp-gate upgrade --apply must update installed skills
+ * @intent After upgrade --apply, all installed skills should be refreshed to match the new package version
+ * @covers AC-332-01, AC-332-02, AC-332-03, AC-332-04
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+describe('upgrade --apply skill sync — #332', () => {
+  // AC-332-01: upgrade.js handleApplyMode calls updateSkill after successful upgrade
+  it('AC-332-01: upgrade.js contains updateSkill call after plugin upgrade', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    expect(source).toContain("require('./update-skill.js')");
+    expect(source).toContain('updateSkill(null, { all: true');
+  });
+
+  // AC-332-02: updateSkill call is inside try/catch (non-blocking)
+  it('AC-332-02: updateSkill call is wrapped in try/catch for non-blocking behavior', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    const lines = source.split('\n');
+    let foundRequire = false;
+    let inTryBlock = false;
+    for (let i = 0; i < lines.length; i++) {
+      if (lines[i].includes("require('./update-skill.js')")) {
+        foundRequire = true;
+        for (let j = i - 1; j >= 0; j--) {
+          if (/^\s*try\s*\{/.test(lines[j])) {
+            inTryBlock = true;
+            break;
+          }
+          if (/^\s*(function|async function|=>)/.test(lines[j])) break;
+        }
+        break;
+      }
+    }
+    expect(foundRequire).toBe(true);
+    expect(inTryBlock).toBe(true);
+  });
+
+  // AC-332-03: updateSkill call is placed after upgradeOpenCodePlugin (correct ordering)
+  it('AC-332-03: updateSkill is called after upgradeOpenCodePlugin in handleApplyMode', () => {
+    const source = fs.readFileSync(require.resolve('../upgrade.js'), 'utf8');
+    const pluginIdx = source.indexOf('upgradeOpenCodePlugin()');
+    const skillIdx = source.indexOf("require('./update-skill.js')");
+    expect(pluginIdx).toBeGreaterThan(-1);
+    expect(skillIdx).toBeGreaterThan(pluginIdx);
+  });
+});
+
+describe('doctor skill version check — #332', () => {
+  // AC-332-04: doctor.js diagnose() includes skill version consistency check
+  it('AC-332-04: doctor.js diagnose() contains diagnoseInstalledSkills call', () => {
+    const source = fs.readFileSync(require.resolve('../doctor.js'), 'utf8');
+    expect(source).toContain('diagnoseInstalledSkills');
+  });
+
+  // AC-332-05: diagnoseInstalledSkills compares installed skills against package-bundled skills
+  it('AC-332-05: diagnoseInstalledSkills reads config installedSkills and package skills dir', () => {
+    const source = fs.readFileSync(require.resolve('../doctor.js'), 'utf8');
+    expect(source).toContain('installedSkills');
+    expect(source).toContain('diagnoseInstalledSkills');
+    expect(source).toContain('skills');
+  });
+});