@boyingliu01/xp-gate 0.14.6 → 0.14.8

package/adapters/plugins/whalecloud-java/scripts/install-maven-whalecloud.sh

@@ -74,8 +74,10 @@ else
   <!-- Security: J000078 SQL injection -->
   <rule ref="category/java/security.xml/MethodRequiresCheck"/>
 
-  <!-- TODO: Add custom rules for J-rules not covered by standard PMD rulesets -->
-  <!-- Custom rules via XPath will be added here as the plugin matures -->
+  <!-- Deferred: Custom XPath rules for J-rules not covered by standard PMD categories.
+       All 106 whalecloud rules currently map to standard PMD 7.x category XMLs.
+       Custom XPath rules will be added here when enterprise-specific rules
+       cannot be expressed via built-in PMD checks. Track via issue backlog. -->
 
 </ruleset>
 RULESET

package/bin/xp-gate.js

@@ -137,6 +137,14 @@ const COMMANDS = {
     },
     usage: 'xp-gate sprint-status [--json] [--watch] [--dir <path>]'
   },
+  'next-sprint': {
+    description: 'Analyze remaining open issues and plan next iteration',
+    run: subargs => {
+      const { handleNextSprint } = require('../lib/next-sprint.js');
+      handleNextSprint(subargs).then(code => process.exit(code));
+    },
+    usage: 'xp-gate next-sprint [--json] [--plan] [--dir <path>]'
+  },
   'update-hooks': {
     description: 'Sync latest hooks from xp-gate package to project',
     run: subargs => {

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

@@ -0,0 +1,231 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+describe('next-sprint', () => {
+  let tmpDir;
+  let consoleSpy;
+  let processExitSpy;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'next-sprint-test-'));
+    consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    processExitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+    // Clear require cache to ensure fresh module for each test
+    delete require.cache[require.resolve('../next-sprint')];
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  function createState(overrides = {}) {
+    const stateDir = path.join(tmpDir, '.sprint-state');
+    fs.mkdirSync(stateDir, { recursive: true });
+    const state = {
+      id: 'sprint-2026-06-30-01',
+      task_description: 'Test Sprint',
+      phase: 4,
+      status: 'completed',
+      started_at: new Date().toISOString(),
+      phase_history: [
+        {
+          phase: 2,
+          phase_name: 'BUILD',
+          status: 'completed',
+          reqs: {
+            'REQ-001': { name: 'Implement login', status: 'completed' },
+            'REQ-002': { name: 'Implement logout', status: 'completed' },
+          },
+        },
+      ],
+      ...overrides,
+    };
+    fs.writeFileSync(path.join(stateDir, 'sprint-state.json'), JSON.stringify(state));
+    return state;
+  }
+
+  function mockGhCli(issues) {
+    const { execSync } = require('child_process');
+    vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+      if (cmd.includes('gh issue list')) {
+        return JSON.stringify(issues);
+      }
+      return '';
+    });
+  }
+
+  describe('readSprintState', () => {
+    it('returns null when no sprint state exists', () => {
+      const { readSprintState } = require('../next-sprint');
+      const result = readSprintState(tmpDir);
+      expect(result).toBeNull();
+    });
+
+    it('returns parsed state when sprint state exists', () => {
+      const state = createState();
+      const { readSprintState } = require('../next-sprint');
+      const result = readSprintState(tmpDir);
+      expect(result).toBeDefined();
+      expect(result.id).toBe('sprint-2026-06-30-01');
+    });
+  });
+
+  describe('getCurrentSprintReqs', () => {
+    it('extracts requirements from sprint state', () => {
+      createState();
+      const { readSprintState, getCurrentSprintReqs } = require('../next-sprint');
+      const state = readSprintState(tmpDir);
+      const reqs = getCurrentSprintReqs(state);
+      expect(reqs).toHaveLength(2);
+      expect(reqs[0].name).toBe('Implement login');
+      expect(reqs[1].name).toBe('Implement logout');
+    });
+
+    it('returns empty array when no phase history', () => {
+      const { getCurrentSprintReqs } = require('../next-sprint');
+      const reqs = getCurrentSprintReqs({ phase_history: [] });
+      expect(reqs).toEqual([]);
+    });
+  });
+
+  describe('filterRemainingIssues', () => {
+    it('filters out issues already in sprint', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 3, title: 'Implement signup', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const sprintReqs = [{ name: 'Implement login' }, { name: 'Implement logout' }];
+      const { filterRemainingIssues } = require('../next-sprint');
+      const result = filterRemainingIssues(issues, sprintReqs);
+      expect(result).toHaveLength(1);
+      expect(result[0].number).toBe(3);
+    });
+
+    it('returns all issues when no sprint reqs', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { filterRemainingIssues } = require('../next-sprint');
+      const result = filterRemainingIssues(issues, []);
+      expect(result).toHaveLength(2);
+    });
+  });
+
+  describe('formatIssuesTable', () => {
+    it('formats issues as table', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [{ name: 'feature' }], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [{ name: 'bug' }], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { formatIssuesTable } = require('../next-sprint');
+      const result = formatIssuesTable(issues);
+      expect(result).toContain('Remaining Open Issues');
+      expect(result).toContain('Implement login');
+      expect(result).toContain('feature');
+    });
+
+    it('handles empty issues', () => {
+      const { formatIssuesTable } = require('../next-sprint');
+      const result = formatIssuesTable([]);
+      expect(result).toBe('No remaining issues found.');
+    });
+  });
+
+  describe('generateSprintPlan', () => {
+    it('generates sprint plan for remaining issues', () => {
+      const issues = [
+        { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+        { number: 2, title: 'Implement logout', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+      ];
+      const { generateSprintPlan } = require('../next-sprint');
+      const result = generateSprintPlan(issues);
+      expect(result).toContain('Suggested Next Sprint Plan');
+      expect(result).toContain('#1');
+      expect(result).toContain('sprint-flow');
+    });
+
+    it('returns null when no issues', () => {
+      const { generateSprintPlan } = require('../next-sprint');
+      const result = generateSprintPlan([]);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('handleNextSprint', () => {
+    it('outputs remaining issues in table format', async () => {
+      createState();
+      const { execSync } = require('child_process');
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 1, title: 'Implement login', labels: [{ name: 'feature' }], createdAt: '2026-06-30T00:00:00Z' },
+            { number: 2, title: 'Implement logout', labels: [{ name: 'bug' }], createdAt: '2026-06-30T00:00:00Z' },
+            { number: 3, title: 'Implement signup', labels: [{ name: 'enhancement' }], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--dir', tmpDir]);
+      expect(result).toBe(0);
+      expect(consoleSpy).toHaveBeenCalled();
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('Remaining Open Issues');
+      expect(output).toContain('Implement signup');
+    });
+
+    it('outputs JSON when --json flag', async () => {
+      createState();
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 1, title: 'Implement login', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--json', '--dir', tmpDir]);
+      expect(result).toBe(0);
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      const parsed = JSON.parse(output);
+      expect(parsed).toHaveProperty('current_sprint');
+      expect(parsed).toHaveProperty('remaining_issues');
+    });
+
+    it('outputs plan when --plan flag', async () => {
+      createState();
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation((cmd) => {
+        if (cmd.includes('gh issue list')) {
+          return JSON.stringify([
+            { number: 5, title: 'Implement password reset', labels: [], createdAt: '2026-06-30T00:00:00Z' },
+          ]);
+        }
+        return '';
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--plan', '--dir', tmpDir]);
+      expect(result).toBe(0);
+      const output = consoleSpy.mock.calls.map(c => c[0]).join('\n');
+      expect(output).toContain('Suggested Next Sprint Plan');
+    });
+
+    it('returns 1 when gh CLI not available', async () => {
+      vi.spyOn(require('child_process'), 'execSync').mockImplementation(() => {
+        throw new Error('gh: command not found');
+      });
+      delete require.cache[require.resolve('../next-sprint')];
+      const { handleNextSprint } = require('../next-sprint');
+      const result = await handleNextSprint(['--dir', tmpDir]);
+      expect(result).toBe(1);
+    });
+  });
+});

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

@@ -16,11 +16,11 @@ 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 (canonical format per SKILL.md L893-942, 6-phase schema)
 const ACTIVE_STATE = {
   id: 'sprint-2026-06-16-01',
   task_description: 'Test sprint',
-  phase: 2,
+  phase: 3,
   status: 'running',
   started_at: '2026-06-16T10:00:00Z',
   isolation: {
@@ -29,22 +29,13 @@ const ACTIVE_STATE = {
     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',
+    { 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',
-      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,
+    { phase: 2, phase_name: 'DESIGN', status: 'completed',
+      started_at: '2026-06-16T10:03:00Z', completed_at: '2026-06-16T10:15:00Z', duration_seconds: 720 },
+    { phase: 3, phase_name: 'BUILD', status: 'in_progress',
+      started_at: '2026-06-16T10:15:00Z', completed_at: null, duration_seconds: null,
       reqs: {
         'REQ-001': { name: 'Feature A', status: 'completed' },
         'REQ-002': { name: 'Feature B', status: 'in_progress' }
@@ -103,7 +94,7 @@ describe('sprint-status: readSprintState', () => {
     expect(state).not.toBeNull();
     const stateObj = state as Record<string, unknown>;
     expect(stateObj.task_description).toBe('Test sprint');
-    expect(stateObj.phase).toBe(2);
+    expect(stateObj.phase).toBe(3);
     expect(stateObj.status).toBe('running');
     expect(Array.isArray(stateObj.phase_history)).toBe(true);
   });
@@ -216,6 +207,6 @@ describe('sprint-status: jsonMode', () => {
     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);
   });
 });

package/lib/next-sprint.js

@@ -0,0 +1,129 @@
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function readSprintState(dir) {
+  try {
+    const stateFile = path.join(dir, '.sprint-state', 'sprint-state.json');
+    if (!fs.existsSync(stateFile)) return null;
+    return JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function getCurrentSprintReqs(state) {
+  if (!state?.phase_history) return [];
+  const reqs = [];
+  for (const phase of state.phase_history) {
+    if (phase.reqs) {
+      for (const [id, req] of Object.entries(phase.reqs)) {
+        reqs.push({ id, name: req.name, status: req.status });
+      }
+    }
+  }
+  return reqs;
+}
+
+function fetchOpenIssues(repoRoot) {
+  try {
+    const result = childProcess.execSync('gh issue list --state open --json number,title,labels,createdAt', {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      timeout: 30000,
+    });
+    return JSON.parse(result);
+  } catch (err) {
+    if (err.message.includes('gh: command not found')) {
+      console.error('Error: gh CLI not found. Install it from https://cli.github.com/');
+      return null;
+    }
+    if (err.message.includes('not logged in')) {
+      console.error('Error: Not logged in to GitHub. Run "gh auth login" first.');
+      return null;
+    }
+    console.error('Error fetching issues:', err.message);
+    return null;
+  }
+}
+
+function filterRemainingIssues(issues, sprintReqs) {
+  const sprintTitles = new Set(sprintReqs.map(r => r.name?.toLowerCase()));
+  return issues.filter(issue => {
+    const titleLower = issue.title.toLowerCase();
+    return !sprintTitles.has(titleLower);
+  });
+}
+
+function formatIssuesTable(issues) {
+  if (issues.length === 0) return 'No remaining issues found.';
+  const lines = ['Remaining Open Issues:', ''];
+  lines.push('┌──────┬────────────────────────────────────────────┬─────────────────────┬───────────┐');
+  lines.push('│ #    │ Title                                      │ Labels              │ Created   │');
+  lines.push('├──────┼────────────────────────────────────────────┼─────────────────────┼───────────┤');
+  for (const issue of issues) {
+    const num = String(issue.number).padEnd(4);
+    const title = issue.title.slice(0, 40).padEnd(40);
+    const labels = (issue.labels || []).map(l => l.name).join(', ').slice(0, 19).padEnd(19);
+    const created = issue.createdAt ? issue.createdAt.slice(0, 10) : 'N/A';
+    lines.push(`│ ${num} │ ${title} │ ${labels} │ ${created} │`);
+  }
+  lines.push('└──────┴────────────────────────────────────────────┴─────────────────────┴───────────┘');
+  lines.push(`Total: ${issues.length} remaining issues`);
+  return lines.join('\n');
+}
+
+function generateSprintPlan(issues) {
+  if (issues.length === 0) return null;
+  const lines = ['Suggested Next Sprint Plan:', ''];
+  const prioritized = issues.slice(0, 5);
+  for (let i = 0; i < prioritized.length; i++) {
+    const issue = prioritized[i];
+    lines.push(`${i + 1}. #${issue.number} - ${issue.title}`);
+  }
+  if (issues.length > 5) {
+    lines.push(`... and ${issues.length - 5} more issues`);
+  }
+  lines.push('');
+  lines.push('To start a sprint, run:');
+  lines.push(`  /sprint-flow "Implement #${prioritized[0].number}: ${prioritized[0].title}"`);
+  return lines.join('\n');
+}
+
+async function handleNextSprint(args = []) {
+  const jsonFlag = args.includes('--json');
+  const planFlag = args.includes('--plan');
+  const dirIdx = args.indexOf('--dir');
+  let repoRoot = process.cwd();
+  if (dirIdx >= 0 && dirIdx + 1 < args.length) {
+    repoRoot = path.resolve(args[dirIdx + 1]);
+  }
+  const state = readSprintState(repoRoot);
+  const sprintReqs = state ? getCurrentSprintReqs(state) : [];
+  const issues = fetchOpenIssues(repoRoot);
+  if (issues === null) return 1;
+  const remaining = filterRemainingIssues(issues, sprintReqs);
+  if (jsonFlag) {
+    console.log(JSON.stringify({ current_sprint: state?.id || null, sprint_reqs: sprintReqs, remaining_issues: remaining }, null, 2));
+    return 0;
+  }
+  console.log(formatIssuesTable(remaining));
+  if (planFlag) {
+    const plan = generateSprintPlan(remaining);
+    if (plan) {
+      console.log('');
+      console.log(plan);
+    }
+  }
+  return 0;
+}
+
+module.exports = {
+  handleNextSprint,
+  fetchOpenIssues,
+  filterRemainingIssues,
+  formatIssuesTable,
+  generateSprintPlan,
+  readSprintState,
+  getCurrentSprintReqs,
+};

package/lib/sprint-status.js

@@ -13,11 +13,10 @@ const { discoverActiveSprints } = require('./sprint-discovery');
 
 // Phase constants (inlined; was shared-phase-constants.js, removed in v0.13.0 slimming)
 const PHASE_NAMES = {
-  '-1': 'ISOLATE', '-0.5': 'AUTO-ESTIMATE',
-  '0': 'THINK', '1': 'PLAN', '2': 'BUILD', '3': 'REVIEW',
-  '4': 'USER ACCEPTANCE', '5': 'FEEDBACK', '6': 'SHIP', '7': 'LAND', '8': 'CLEANUP',
+  '1': 'PREP', '2': 'DESIGN', '3': 'BUILD',
+  '4': 'VERIFY', '5': 'SHIP', '6': 'CLOSE',
 };
-const PHASE_ORDER = ['-1', '-0.5', '0', '1', '2', '3', '4', '5', '6', '7', '8'];
+const PHASE_ORDER = ['1', '2', '3', '4', '5', '6'];
 
 function parseTime(value) {
   if (!value) return 0;

package/mock-policy/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MOCK-POLICY KNOWLEDGE BASE
 
-**Generated:** 2026-07-09
-**Commit:** df2023f
+**Generated:** 2026-07-13
+**Commit:** d83bb96
 **Branch:** main
-**Version:** 0.14.6.0
+**Version:** 0.14.8.0
 
 ## OVERVIEW
 Mock layering policy enforcement — Gate M3 of pre-push hook. Ensures integration tests use real implementations for internal dependencies, mock external dependencies, and annotate pending mocks with removal plans. Combines project scope scanning, mock decision engine, and per-file validation into a single pipeline.