@boyingliu01/xp-gate 0.14.7 → 0.14.9

package/lib/gate-runner.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const { execSync, execFileSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Gate metadata registry — maps gate IDs to names, descriptions, and how to run them.
+// Standalone gates (<gate-id>: { run }) are invokable via xp-gate gate-<id>.
+// Pre-commit-only gates (<gate-id>: { preCommitOnly: true }) run only in git commit context.
+const GATE_REGISTRY = {
+  '0': {
+    name: 'Version Consistency',
+    description: 'Check VERSION file matches all package.json versions',
+    preCommitOnly: true,
+    reason: 'Requires git-staged context to compare VERSION with package.json files',
+  },
+  '1': {
+    name: 'Code Quality',
+    description: 'Language-specific static analysis and linting (ESLint, Ruff, govet, etc.)',
+    preCommitOnly: true,
+    reason: 'Requires language detection from changed files and adapter routing',
+  },
+  '2': {
+    name: 'Duplicate Code',
+    description: 'jscpd duplicate code detection',
+    run: (targetPath) => {
+      const jscpdConfig = findConfig(targetPath, 'jscpd.conf.json');
+      const args = [targetPath || '.'];
+      if (jscpdConfig) args.push('--config', jscpdConfig);
+      execFileSync('npx', ['-y', 'jscpd', ...args], { stdio: 'inherit' });
+    },
+  },
+  '3': {
+    name: 'Cyclomatic Complexity',
+    description: 'lizard cyclomatic complexity analysis',
+    run: (targetPath) => {
+      const script = resolveGateScript('3');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        const target = targetPath || '.';
+        console.log(`Running lizard on ${target}...`);
+        execFileSync('lizard', [target, '--CCN', '10', '--length', '50', '--arguments', '5', '--warnings_only'], { stdio: 'inherit' });
+      }
+    },
+  },
+  '4': {
+    name: 'Clean Code + SOLID Principles',
+    description: '14 Clean Code/SOLID rules across 9 languages',
+    run: (targetPath) => {
+      const { principles } = require('./principles.js');
+      return principles([targetPath || '.']);
+    },
+  },
+  '5': {
+    name: 'Tests + Coverage',
+    description: 'Unit test execution and code coverage enforcement (≥80%)',
+    preCommitOnly: true,
+    reason: 'Requires language detection and adapter-sourced test execution with coverage reports',
+  },
+  '6': {
+    name: 'Architecture + Boy Scout Rule',
+    description: 'Architecture layer boundary validation and warning baseline enforcement',
+    run: (targetPath) => {
+      const { arch } = require('./arch.js');
+      return arch([]);
+    },
+  },
+  '7': {
+    name: 'IaC Security',
+    description: 'Infrastructure-as-Code security scanning (checkov, hadolint, kube-score, tflint)',
+    run: (targetPath) => {
+      const script = resolveGateScript('7');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('IaC security scan requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 7 automatically.');
+      }
+    },
+  },
+  '8': {
+    name: 'Secret Scanning',
+    description: 'gitleaks secret and credential detection',
+    run: (targetPath) => {
+      const script = resolveGateScript('8');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('Secret scanning requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 8 automatically.');
+      }
+    },
+  },
+  '9': {
+    name: 'SAST Security',
+    description: 'semgrep static application security testing',
+    run: (targetPath) => {
+      const script = resolveGateScript('9');
+      if (script) {
+        execSync(`bash "${script}"`, { stdio: 'inherit' });
+      } else {
+        console.log('SAST scanning requires git-staged context for changed files detection.');
+        console.log('Run: git commit to trigger Gate 9 automatically.');
+      }
+    },
+  },
+  '10': {
+    name: 'Build Integrity',
+    description: 'TypeScript compilation, npm pack, and import validation',
+    preCommitOnly: true,
+    reason: 'Build integrity checks require language detection and build tool context',
+  },
+  '11': {
+    name: 'Sprint Flow Enforcement',
+    description: 'Sprint state and delphi-review validation',
+    preCommitOnly: true,
+    reason: 'Requires sprint state (.sprint-state/) and git branch context',
+  },
+};
+
+function findConfig(basePath, fileName) {
+  const candidates = [
+    path.join(basePath || '.', fileName),
+    path.join(process.cwd(), fileName),
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function resolveGateScript(gateNum) {
+  const candidates = [
+    path.join(process.cwd(), 'githooks', 'gates', `gate-${gateNum}-*.sh`),
+    path.join(process.cwd(), 'githooks', `gate-${gateNum}.sh`),
+  ];
+
+  // Try glob patterns
+  for (const pattern of candidates) {
+    if (pattern.includes('*')) {
+      const dir = path.dirname(pattern);
+      const prefix = path.basename(pattern).replace('*', '');
+      if (fs.existsSync(dir)) {
+        const match = fs.readdirSync(dir).find(f => f.startsWith(`gate-${gateNum}-`) && f.endsWith('.sh'));
+        if (match) return path.join(dir, match);
+      }
+    } else if (fs.existsSync(pattern)) {
+      return pattern;
+    }
+  }
+
+  // Check global install
+  const globalDir = path.join(require('os').homedir(), '.config', 'xp-gate', 'adapters');
+  const globalScript = path.join(globalDir, `gate-${gateNum}.sh`);
+  if (fs.existsSync(globalScript)) return globalScript;
+
+  return null;
+}
+
+function getGateInfo(gateId) {
+  return GATE_REGISTRY[String(gateId)] || null;
+}
+
+function getAllGates() {
+  return Object.entries(GATE_REGISTRY).map(([id, info]) => ({
+    id,
+    name: info.name,
+    description: info.description,
+    preCommitOnly: info.preCommitOnly || false,
+    reason: info.reason || null,
+  }));
+}
+
+async function runGate(gateId, targetPath) {
+  const gate = GATE_REGISTRY[String(gateId)];
+  if (!gate) {
+    console.error(`Unknown gate: ${gateId}`);
+    console.error('Available gates: ' + Object.keys(GATE_REGISTRY).join(', '));
+    return 1;
+  }
+
+  if (gate.preCommitOnly) {
+    console.log(`━━━ Gate ${gateId}: ${gate.name} ━━━`);
+    console.log(`⏭️  SKIPPED - ${gate.reason}`);
+    console.log('   This gate runs automatically during git commit.');
+    console.log('   Run: git commit to trigger all gates.');
+    return 0;
+  }
+
+  if (gate.run) {
+    console.log(`━━━ Gate ${gateId}: ${gate.name} ━━━`);
+    try {
+      const result = gate.run(targetPath);
+      if (result && typeof result.then === 'function') {
+        return await result;
+      }
+      return 0;
+    } catch (err) {
+      console.error(` Gate ${gateId} FAILED: ${err.message}`);
+      return 1;
+    }
+  }
+
+  console.error(`Gate ${gateId}: ${gate.name} — no execution handler available`);
+  return 1;
+}
+
+module.exports = { GATE_REGISTRY, getGateInfo, getAllGates, runGate };

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/shared-utils.js

@@ -60,7 +60,7 @@ function copyAdapters(srcDir, destDir) {
   const githooksDir = path.resolve(srcDir, '..', '..', '..', 'githooks');
   if (fs.existsSync(githooksDir)) {
     fs.readdirSync(githooksDir).forEach(f => {
-      if (f.startsWith('gate-') && f.endsWith('.sh')) {
+      if ((f.startsWith('gate-') || f === 'sprint-gate.sh') && f.endsWith('.sh')) {
         fs.copyFileSync(path.join(githooksDir, f), path.join(destDir, f));
       }
     });

package/lib/sprint-status.js

@@ -70,6 +70,7 @@ function statusIcon(status) {
   switch (status) {
     case 'completed': return '✅';
     case 'in_progress': return '🔄';
+    case 'skipped': return '⏭️';
     default: return '⏳';
   }
 }
@@ -145,7 +146,8 @@ function formatPhaseLine(key, history, maxNameLen) {
   const icon = statusIcon(status);
   const dur = formatDuration(history?.duration_seconds);
   const statusLabel = status === 'completed' ? 'Completed' :
-    status === 'in_progress' ? 'In Progress' : 'Pending';
+    status === 'in_progress' ? 'In Progress' :
+    status === 'skipped' ? 'Skipped' : 'Pending';
   return `  Phase ${key.padStart(4)}  ${name.padEnd(maxNameLen + 1)} ${icon} ${dur.padEnd(5)} ${statusLabel}`;
 }
 

package/lib/update-hooks.js

@@ -190,7 +190,7 @@ function copyAdapters(srcDir, destDir, dryRun, noBackup) {
 function copyGateScripts(srcDir, destDir, dryRun, noBackup) {
   if (!fs.existsSync(srcDir)) return;
   fs.readdirSync(srcDir).forEach(f => {
-    if (f.startsWith('gate-') && f.endsWith('.sh')) {
+    if ((f.startsWith('gate-') || f === 'sprint-gate.sh') && f.endsWith('.sh')) {
       const src = path.join(srcDir, f);
       const dest = path.join(destDir, f);
       atomicCopyFile(src, dest, dryRun, noBackup, f);

package/lib/upgrade.js

@@ -95,6 +95,14 @@ async function handleApplyMode(result, pkgName) {
     // Also check for and update the local OpenCode plugin if installed.
     await upgradeOpenCodePlugin();
 
+    // Update all installed skills to match the newly upgraded package (#332)
+    try {
+      const { updateSkill } = require('./update-skill.js');
+      await updateSkill(null, { all: true, verbose: false });
+    } catch {
+      // Non-blocking: skill update failure should never break the main upgrade flow.
+    }
+
     return 0;
   } catch (err) {
     const msg = err.message || '';

package/mock-policy/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MOCK-POLICY KNOWLEDGE BASE
 
-**Generated:** 2026-07-10
-**Commit:** a9276f6
-**Branch:** main
-**Version:** 0.14.6.2
+**Generated:** 2026-07-13
+**Commit:** cb954fe
+**Branch:** sprint/2026-07-13-01
+**Version:** 0.14.9.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.