@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/mutation/init-baseline.ts

@@ -0,0 +1,192 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+interface MutantStatus {
+  id: string;
+  mutatorName: string;
+  replacement: string;
+  location: {
+    start: { line: number; column: number };
+    end: { line: number; column: number };
+  };
+  status: string;
+}
+
+interface StrykerFileReport {
+  source: string;
+  mutants: MutantStatus[];
+}
+
+interface StrykerReport {
+  schemaVersion: string;
+  thresholds: {
+    high: number;
+    low: number;
+    break: number | null;
+  };
+  files: Record<string, StrykerFileReport>;
+}
+
+interface MutationScoreEntry {
+  score: number;
+  mutants: number;
+  killed: number;
+  survived: number;
+}
+
+interface MutationBaseline {
+  version: string;
+  generatedAt: string;
+  source: 'local' | 'ci';
+  scores: Record<string, MutationScoreEntry>;
+}
+
+function parseArgs(): { filesPattern: string; source: 'local' | 'ci' } {
+  const args = process.argv.slice(2);
+  let filesPattern = 'src/**/*.ts';
+  let source: 'local' | 'ci' = 'local';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--files' && args[i + 1]) {
+      filesPattern = args[i + 1];
+      i++;
+    }
+    if (args[i] === '--source' && args[i + 1]) {
+      source = args[i + 1] as 'local' | 'ci';
+      i++;
+    }
+  }
+
+  return { filesPattern, source };
+}
+
+async function scanFiles(dir: string, results: string[], basePath: string): Promise<void> {
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(basePath, fullPath);
+
+    if (entry.isDirectory()) {
+      await scanFiles(fullPath, results, basePath);
+    } else if (entry.isFile()) {
+      results.push(relativePath);
+    }
+  }
+}
+
+async function getSourceFiles(pattern: string): Promise<string[]> {
+  const baseDir = process.cwd();
+  const allFiles: string[] = [];
+
+  const patternParts = pattern.split('/');
+  const baseSearchDir = path.join(baseDir, patternParts[0]);
+
+  await scanFiles(baseSearchDir, allFiles, baseDir);
+
+  return allFiles.filter(file => {
+    return (
+      file.endsWith('.ts') &&
+      !file.endsWith('.d.ts') &&
+      !file.endsWith('.test.ts') &&
+      !file.includes('/__tests__/') &&
+      !file.includes('/adapters/')
+    );
+  });
+}
+
+async function runStryker(): Promise<void> {
+  console.log('Running Stryker mutation testing...');
+  try {
+    const { stdout, stderr } = await execAsync('npx stryker run', {
+      cwd: process.cwd(),
+      timeout: 600000
+    });
+    console.log(stdout);
+    if (stderr) {
+      console.error(stderr);
+    }
+  } catch {
+    console.log('Stryker finished (possible threshold violations).');
+  }
+}
+
+async function parseStrykerReport(reportPath: string): Promise<StrykerReport> {
+  const reportContent = await fs.readFile(reportPath, 'utf-8');
+  return JSON.parse(reportContent) as StrykerReport;
+}
+
+function calculateScore(entry: StrykerFileReport): MutationScoreEntry {
+  const total = entry.mutants.length;
+  const killed = entry.mutants.filter(m => m.status === 'Killed').length;
+  const survived = entry.mutants.filter(m => m.status === 'Survived').length;
+
+  return {
+    score: total > 0 ? parseFloat(((killed / total) * 100).toFixed(1)) : 100,
+    mutants: total,
+    killed,
+    survived
+  };
+}
+
+function buildBaseline(
+  report: StrykerReport,
+  sourceFiles: string[],
+  source: 'local' | 'ci'
+): MutationBaseline {
+  const scores: Record<string, MutationScoreEntry> = {};
+
+  for (const [filePath, fileReport] of Object.entries(report.files)) {
+    const relativePath = filePath.replace(/^\//, '');
+    if (sourceFiles.includes(relativePath) || sourceFiles.some(sf => relativePath.endsWith(sf))) {
+      scores[relativePath] = calculateScore(fileReport);
+    }
+  }
+
+  return {
+    version: '1.0',
+    generatedAt: new Date().toISOString(),
+    source,
+    scores
+  };
+}
+
+async function saveBaseline(baseline: MutationBaseline, outputPath: string): Promise<void> {
+  await fs.writeFile(outputPath, JSON.stringify(baseline, null, 2));
+}
+
+async function main(): Promise<void> {
+  const { filesPattern, source } = parseArgs();
+
+  console.log(`Scanning source files with pattern: ${filesPattern}`);
+  const sourceFiles = await getSourceFiles(filesPattern);
+  console.log(`Found ${sourceFiles.length} source files`);
+
+  await runStryker();
+
+  const reportPath = path.join(process.cwd(), 'reports', 'mutation', 'report.json');
+  console.log(`Parsing Stryker report: ${reportPath}`);
+
+  const report = await parseStrykerReport(reportPath);
+  const baseline = buildBaseline(report, sourceFiles, source);
+
+  const outputPath = path.join(process.cwd(), '.mutation-baseline.json');
+  await saveBaseline(baseline, outputPath);
+
+  console.log(`Mutation baseline saved to ${outputPath}`);
+  console.log(`Total files: ${Object.keys(baseline.scores).length}`);
+  console.log(`Average score: ${
+    Object.values(baseline.scores).reduce((sum, e) => sum + e.score, 0) /
+    (Object.keys(baseline.scores).length || 1)
+  }%`);
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : 'Unknown error';
+  console.error(`Failed to initialize mutation baseline: ${message}`);
+  process.exit(1);
+});

package/mutation/stryker-types.ts

@@ -0,0 +1,14 @@
+export interface StrykerFileReport {
+  mutationScore: number;
+  nrOfMutants: number;
+  nrOfKilledMutants: number;
+  nrOfSurvivedMutants: number;
+}
+
+export interface StrykerReport {
+  mutationScore: number;
+  nrOfMutants: number;
+  nrOfKilledMutants: number;
+  nrOfSurvivedMutants: number;
+  files?: Record<string, StrykerFileReport>;
+}

package/mutation/types.ts

@@ -0,0 +1,70 @@
+export interface MutationScore {
+  score: number;
+  mutants: number;
+  killed: number;
+  survived: number;
+}
+
+export interface MutationBaseline {
+  version: string;
+  generatedAt: string;
+  source: 'local' | 'ci';
+  scores: Record<string, MutationScore>;
+}
+
+export interface GateMOptions {
+  changedFiles: string[];
+  baselinePath: string;
+  criticalPathsPath: string;
+  timeoutMs: number;
+}
+
+export type GateMStatus = 'pass' | 'block' | 'skip' | 'timeout';
+
+export interface GateMResult {
+  exitCode: number;
+  status: GateMStatus;
+  filesChecked: number;
+  scores: Record<string, MutationScore>;
+  warnings: string[];
+  errors: string[];
+}
+
+export type TestLayer = 'unit' | 'integration' | 'e2e' | 'unknown';
+
+export interface AITestDetectionResult {
+  isAiGenerated: boolean;
+  mockDensity: number;
+  layer: TestLayer;
+  explicitThreshold?: number;
+  annotations: {
+    hasTest: boolean;
+    hasIntent: boolean;
+    hasCovers: boolean;
+  };
+}
+
+export interface TestIntentCheckResult {
+  sourceFile: string;
+  testFile: string | null;
+  hasTestAnnotation: boolean;
+  hasIntentAnnotation: boolean;
+  hasCoversAnnotation: boolean;
+  missingAnnotations: string[];
+}
+
+export interface FileThreshold {
+  file: string;
+  threshold: number;
+  isCriticalPath: boolean;
+  explicitThreshold?: number;
+}
+
+export interface ScoreEvaluation {
+  file: string;
+  score: number;
+  threshold: number;
+  baselineScore?: number;
+  passed: boolean;
+  isRegression: boolean;
+}

package/mutation/update-baseline.ts

@@ -0,0 +1,160 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+interface MutationScoreEntry {
+  score: number;
+  mutants: number;
+  killed: number;
+  survived: number;
+}
+
+interface MutationBaseline {
+  version: string;
+  generatedAt: string;
+  source: 'local' | 'ci';
+  scores: Record<string, MutationScoreEntry>;
+}
+
+interface ParsedScoreInput {
+  filePath: string;
+  score: number;
+}
+
+function parseArgs(): { scores: ParsedScoreInput[] } {
+  const args = process.argv.slice(2);
+  let scoresInput = '';
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--scores' && args[i + 1]) {
+      scoresInput = args[i + 1];
+      i++;
+    }
+  }
+
+  if (!scoresInput) {
+    throw new Error('Missing required argument: --scores "file1.ts:65.2,file2.ts:58.0"');
+  }
+
+  const scores: ParsedScoreInput[] = [];
+  const entries = scoresInput.split(',');
+
+  for (const entry of entries) {
+    const parts = entry.split(':');
+    if (parts.length !== 2) {
+      throw new Error(`Invalid score format: ${entry}. Expected "file.ts:score"`);
+    }
+
+    const [filePath, scoreStr] = parts;
+    const score = parseFloat(scoreStr);
+
+    if (Number.isNaN(score) || score < 0 || score > 100) {
+      throw new Error(`Invalid score value for ${filePath}: ${scoreStr}. Must be between 0 and 100.`);
+    }
+
+    scores.push({ filePath: filePath.trim(), score });
+  }
+
+  return { scores };
+}
+
+async function readBaseline(baselinePath: string): Promise<MutationBaseline> {
+  try {
+    const content = await fs.readFile(baselinePath, 'utf-8');
+    return JSON.parse(content) as MutationBaseline;
+  } catch (error: unknown) {
+    throw new Error(
+      `Failed to read baseline file at ${baselinePath}: ${error instanceof Error ? error.message : 'Unknown error'}`
+    );
+  }
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function updateBaseline(
+  baseline: MutationBaseline,
+  newScores: ParsedScoreInput[]
+): MutationBaseline {
+  const updatedScores: Record<string, MutationScoreEntry> = { ...baseline.scores };
+
+    for (const { filePath, score } of newScores) {
+      const existing = updatedScores[filePath];
+
+      if (existing) {
+        updatedScores[filePath] = {
+          ...existing,
+          score: parseFloat(score.toFixed(1))
+        };
+      } else {
+        updatedScores[filePath] = {
+          score: parseFloat(score.toFixed(1)),
+          mutants: 0,
+          killed: 0,
+          survived: 0
+        };
+      }
+    }
+
+  return {
+    ...baseline,
+    generatedAt: new Date().toISOString(),
+    scores: updatedScores
+  };
+}
+
+async function removeDeletedFiles(baseline: MutationBaseline): Promise<MutationBaseline> {
+  const validScores: Record<string, MutationScoreEntry> = {};
+
+  for (const [filePath, entry] of Object.entries(baseline.scores)) {
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    if (await fileExists(absolutePath)) {
+      validScores[filePath] = entry;
+    } else {
+      console.log(`Removing deleted file from baseline: ${filePath}`);
+    }
+  }
+
+  return {
+    ...baseline,
+    scores: validScores
+  };
+}
+
+async function saveBaseline(baseline: MutationBaseline, baselinePath: string): Promise<void> {
+  await fs.writeFile(baselinePath, JSON.stringify(baseline, null, 2));
+}
+
+async function main(): Promise<void> {
+  const { scores } = parseArgs();
+  const baselinePath = path.join(process.cwd(), '.mutation-baseline.json');
+
+  console.log('Reading existing mutation baseline...');
+  const baseline = await readBaseline(baselinePath);
+
+  console.log(`Updating ${scores.length} file score(s)...`);
+  let updatedBaseline = updateBaseline(baseline, scores);
+
+  console.log('Checking for deleted files...');
+  updatedBaseline = await removeDeletedFiles(updatedBaseline);
+
+  await saveBaseline(updatedBaseline, baselinePath);
+
+  console.log(`Mutation baseline updated and saved to ${baselinePath}`);
+  console.log(`Total files: ${Object.keys(updatedBaseline.scores).length}`);
+
+  for (const { filePath, score } of scores) {
+    console.log(`  ${filePath}: ${score}%`);
+  }
+}
+
+main().catch((error: unknown) => {
+  const message = error instanceof Error ? error.message : 'Unknown error';
+  console.error(`Failed to update mutation baseline: ${message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"
@@ -12,7 +12,10 @@
     "lib/",
     "skills/",
     "plugins/",
-    "adapter-common.sh"
+    "adapter-common.sh",
+    "principles/",
+    "mutation/",
+    "mock-policy/"
   ],
   "repository": {
     "type": "git",

package/plugins/claude-code/.claude-plugin/plugin.json

@@ -1,8 +1,8 @@
 {
   "name": "xp-gate",
-  "version": "0.8.8",
+  "version": "0.8.10",
   "displayName": "XP-Gate",
-  "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 6 quality gates, Sprint Flow, and Delphi multi-expert review.",
+  "description": "Extreme Programming quality gates + AI workflow skills for Claude Code. Includes 10 quality gates (Gate 0-9), Sprint Flow (11 phases), and Delphi multi-expert review (>=90% consensus).",
   "author": {
     "name": "boyingliu01"
   },

package/plugins/claude-code/skills/delphi-review/AGENTS.md

@@ -1,12 +1,12 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-05-30
-**Commit:** 4517f2b
+**Generated:** 2026-06-14
+**Commit:** e215a50
 **Branch:** main
-**Version:** v0.8.1
+**Version:** 0.8.10.0
 
 ## OVERVIEW
-Delphi Consensus Review — multi-round anonymous expert review (≥91% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.
+Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.
 
 ## STRUCTURE
 ```
@@ -30,7 +30,7 @@ skills/delphi-review/
 
 ## CONVENTIONS
 - 3 experts anonymous in Round 1 (no cross-expert bias)
-- ≥91% consensus threshold (was 95%, lowered to 91%)
+- ≥90% consensus threshold (was 95%, now unified to 90%)
 - Max 5 rounds before forcing decision
 - Cross-provider required: experts from ≥2 different providers
 - Domestic models only: glm, kimi, minimax, qwen, deepseek
@@ -39,7 +39,7 @@ skills/delphi-review/
 - Code-walkthrough skipped on main/master pushes (by design)
 
 ## ANTI-PATTERNS (THIS PROJECT)
-- Do NOT terminate before achieving true consensus (≥91%)
+- Do NOT terminate before achieving true consensus (≥90%)
 - Do NOT reveal other experts' opinions during Round 1
 - Do NOT accept partial agreement without resolution
 - Do NOT skip code-walkthrough when over thresholds (BLOCK + user decision)
@@ -49,7 +49,7 @@ skills/delphi-review/
 
 ## UNIQUE STYLES
 - Anonymous expert reviews (Round 1)
-- Statistical consensus measurement (≥91% threshold)
+- Statistical consensus measurement (≥90% threshold)
 - Two modes: design review + code-walkthrough
 - Pre-push integration: .code-walkthrough-result.json stores commit hash + verdict
 - Delphi guard in claude-code plugin: blocks Edit/Write before APPROVAL

package/plugins/claude-code/skills/delphi-review/INSTALL.md

@@ -96,7 +96,7 @@ The skill requires at least 2 experts for code changes, 3 for architecture decis
 | `experts.architecture` | Architecture reviewer configuration | Required |
 | `experts.technical` | Technical reviewer configuration | Required |
 | `experts.feasibility` | Feasibility reviewer configuration | Required for 3-expert mode |
-    | `consensus.threshold_percent` | Agreement threshold | 95 |
+    | `consensus.threshold_percent` | Agreement threshold | 90 |
 | `consensus.max_review_rounds` | Maximum review rounds | 5 |
 | `consensus.cross_provider_required` | Require different providers | true |
 

package/plugins/claude-code/skills/delphi-review/SKILL.md

@@ -9,7 +9,7 @@ description: "Use when asked to review a design, plan, or architecture; before i
 
 **In Scope:**
 - Multi-round anonymous expert consensus review (design + code-walkthrough modes)
-- 2-3 experts from different providers with statistical consensus (>= 91%)
+- 2-3 experts from different providers with statistical consensus (>= 90%)
 - Structured verdict: APPROVED / PASS_WITH_CAVEATS / REQUEST_CHANGES
 - Domestic models only (no Anthropic/OpenAI/Google)
 
@@ -27,7 +27,7 @@ description: "Use when asked to review a design, plan, or architecture; before i
 1. **匿名性** — Round 1 专家互不知道对方意见
 2. **迭代** — 多轮直到共识，不是固定轮数
 3. **受控反馈** — 每轮看到其他专家意见
-4. **统计共识** — >=91% 一致才算共识
+4. **统计共识** — >=90% 一致才算共识
 
 ### 质量优先
 
@@ -95,7 +95,7 @@ description: "Use when asked to review a design, plan, or architecture; before i
 
 | 阈值 | 说明 |
 |------|------|
-| **>=91%** | 推荐默认 |
+| **>=90%** | 推荐默认 |
 | 100% | 完全一致（更严格） |
 
 ---
@@ -105,14 +105,14 @@ description: "Use when asked to review a design, plan, or architecture; before i
 ```
 Phase 0: 准备 → Round 1: 匿名独立评审 → 共识检查
     │
-    ├─ 一致 + >=91% + APPROVED → ✅ 完成
+    ├─ 一致 + >=90% + APPROVED → ✅ 完成
     │
-    └─ 不一致 或 <91% 或 REQUEST_CHANGES
+    └─ 不一致 或 <90% 或 REQUEST_CHANGES
           │
           ▼
        Round 2: 交换意见 → 共识检查
           │
-          ├─ 一致 + >=91% + APPROVED → ✅ 完成
+          ├─ 一致 + >=90% + APPROVED → ✅ 完成
           │
           └─ 仍分歧 或 REQUEST_CHANGES
                 │
@@ -248,11 +248,11 @@ This skill activates on any request for multi-expert review. Common triggers:
 2. **Dispatch anonymous experts** - 2-3 experts from ≥2 different domestic model providers
 3. **Collect Round 1 independent reviews** - Anonymous, no cross-expert bias
 4. **Synthesize feedback** - Measure consensus, identify disagreements
-5. **Run Round 2+ until consensus** - Exchange opinions, iterate until ≥91% agreement
+5. **Run Round 2+ until consensus** - Exchange opinions, iterate until ≥90% agreement
 6. **Block on unresolved Critical/Major** - Zero-tolerance: all Critical/Major must be resolved
 7. **Emit verdict** - APPROVED (with specification.yaml) or REQUEST_CHANGES (fix + re-review)
 
-**Consensus threshold:** ≥91% (project standard for Delphi review approval)
+**Consensus threshold:** ≥90% (project standard for Delphi review approval)
 **Model policy:** Domestic models only (DeepSeek, Qwen, Kimi, GLM, MiniMax). Foreign models (Anthropic/OpenAI/Google) forbidden.
 
 ---
@@ -340,7 +340,7 @@ Every review round output MUST follow this exact JSON structure for design mode:
 - [ ] Round 2+ 完成（交换意见 / 最终立场）
 
 **CRITICAL — 共识验证:**
-- [ ] 问题共识比例 >=91%
+- [ ] 问题共识比例 >=90%
 - [ ] 所有 Critical Issues 已解决
 - [ ] 所有 Major Concerns 已处理
 
@@ -422,7 +422,7 @@ Every review round output MUST follow this exact JSON structure for design mode:
 | 只处理 Critical，忽略 Major | 零容忍：Critical/Major 全部必须处理，不可跳过或降级 |
 | 单专家自评 | 至少 2 位不同 provider 的专家 |
 | 用户说"时间紧急"就跳过 | 评审是投资不是开销，跳过后期返工成本更高 |
-| "专家几乎一致"就通过 | "几乎" = 不一致，继续到 >=91% |
+| "专家几乎一致"就通过 | "几乎" = 不一致，继续到 >=90% |
 | 使用 Anthropic/GPT/Gemini 等国外昂贵模型 | 必须使用国产开源模型（DeepSeek, Qwen, Kimi, GLM, MiniMax） |
 | 三个专家使用同一厂家模型 | 必须来自至少 2 家不同厂家 |
 
@@ -437,7 +437,7 @@ Every review round output MUST follow this exact JSON structure for design mode:
 | "这只是小变更" | 所有变更都需要评审 |
 | "Round 1 就够了" | 不够，必须多轮直到共识 |
 | "生成报告就完成了" | APPROVED 才算完成 |
-| "2/3 同意就是共识" | 还要检查问题共识比例 >=91% |
+| "2/3 同意就是共识" | 还要检查问题共识比例 >=90% |
 
 ---
 
@@ -445,7 +445,7 @@ Every review round output MUST follow this exact JSON structure for design mode:
 
 **Delphi 评审完成的唯一标准：**
 1. ✅ 所有专家裁决 APPROVED
-2. ✅ 问题共识 >=91%
+2. ✅ 问题共识 >=90%
 3. ✅ 所有 Critical Issues 已修复验证
 4. ✅ 所有 Major Concerns 已处理
 5. ✅ 共识报告已生成

package/plugins/claude-code/skills/delphi-review/references/code-walkthrough.md

@@ -393,7 +393,7 @@ IF 任何检查失败:
 | `confidence` | number | 整体置信度 (1-10) |
 | `experts` | array | 专家评审结果 |
 | `issues` | array | 未解决的问题（如有） |
-| `consensus_ratio` | number | 问题共识比例 (≥0.95 为共识) |
+| `consensus_ratio` | number | 问题共识比例 (≥0.90 为共识) |
 
 **有效期机制**：