@boyingliu01/xp-gate 0.14.6 → 0.14.8

package/mock-policy/__tests__/gate-m3.test.ts

@@ -0,0 +1,384 @@
+/**
+ * @test REQ-327 mock-policy test coverage
+ * @intent Verify gate-m3 orchestrator (runGateM3) and CLI entry (main)
+ * @covers AC-327-01
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdirSync, writeFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { runGateM3, main } from '../gate-m3';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createTempProject(name: string): string {
+  const tmpDir = join(tmpdir(), `gate-m3-test-${name}-${Date.now()}`);
+  mkdirSync(tmpDir, { recursive: true });
+
+  writeFileSync(
+    join(tmpDir, 'package.json'),
+    JSON.stringify({
+      dependencies: { stripe: '^12.0.0', axios: '^1.0.0' },
+      devDependencies: { vitest: '^1.0.0' },
+    }),
+  );
+
+  mkdirSync(join(tmpDir, 'src', '__tests__'), { recursive: true });
+  mkdirSync(join(tmpDir, 'src', 'services'), { recursive: true });
+
+  return tmpDir;
+}
+
+// ---------------------------------------------------------------------------
+// runGateM3 — orchestrator
+// ---------------------------------------------------------------------------
+describe('runGateM3', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = createTempProject('orchestrator');
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns skip status for empty file list', async () => {
+    const result = await runGateM3([], tmpDir);
+
+    expect(result.status).toBe('skip');
+    expect(result.exitCode).toBe(0);
+    expect(result.violations).toEqual([]);
+    expect(result.scores.totalTests).toBe(0);
+    expect(result.scores.integrationTests).toBe(0);
+    expect(result.scores.mockDensity).toBe(0);
+    expect(result.scores.pendingMocks).toBe(0);
+  });
+
+  it('returns skip when only non-test files are provided', async () => {
+    const result = await runGateM3(
+      ['src/services/user.ts', 'src/services/order.ts'],
+      tmpDir,
+    );
+
+    expect(result.status).toBe('skip');
+    expect(result.exitCode).toBe(0);
+    expect(result.scores.totalTests).toBe(0);
+  });
+
+  it('filters out non-test files and processes only test files', async () => {
+    const testFile = join(tmpDir, 'src/__tests__/user.test.ts');
+    writeFileSync(testFile, [
+      "import { describe, it, expect } from 'vitest';",
+      '',
+      "describe('user', () => {",
+      "  it('works', () => {",
+      '    expect(true).toBe(true);',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3(
+      ['src/services/user.ts', testFile],
+      tmpDir,
+    );
+
+    expect(result.status).toBe('pass');
+    expect(result.scores.totalTests).toBe(1);
+  });
+
+  it('counts integration tests correctly in scores', async () => {
+    const intTest = join(tmpDir, 'src/__tests__/payment.integration.test.ts');
+    writeFileSync(intTest, [
+      "import Stripe from 'stripe';",
+      '',
+      "describe('payment', () => {",
+      "  it('creates charge', async () => {",
+      "    const s = new Stripe('sk_test');",
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const unitTest = join(tmpDir, 'src/__tests__/helper.test.ts');
+    writeFileSync(unitTest, [
+      "import { describe, it, expect } from 'vitest';",
+      '',
+      "describe('helper', () => {",
+      "  it('works', () => {",
+      '    expect(1 + 1).toBe(2);',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3([intTest, unitTest], tmpDir);
+
+    expect(result.scores.totalTests).toBe(2);
+    expect(result.scores.integrationTests).toBe(1);
+  });
+
+  it('returns pass with warning severity even when violations exist', async () => {
+    const testFile = join(tmpDir, 'src/__tests__/payment.integration.test.ts');
+    writeFileSync(testFile, [
+      "import Stripe from 'stripe';",
+      '',
+      "describe('payment', () => {",
+      "  it('creates charge', async () => {",
+      "    const s = new Stripe('sk_test');",
+      '  });',
+      '});',
+    ].join('\n'));
+
+    // No .mockpolicyrc → default severity is 'warning'
+    const result = await runGateM3([testFile], tmpDir);
+
+    expect(result.status).toBe('pass');
+    expect(result.exitCode).toBe(0);
+    // Violations may exist but severity=warning means no block
+    if (result.violations.length > 0) {
+      expect(result.violations.every(v => v.severity === 'warning')).toBe(true);
+    }
+  });
+
+  it('returns block with error severity when violations exist', async () => {
+    writeFileSync(
+      join(tmpDir, '.mockpolicyrc'),
+      JSON.stringify({ severity: 'error' }),
+    );
+
+    const testFile = join(tmpDir, 'src/__tests__/payment.integration.test.ts');
+    writeFileSync(testFile, [
+      "import Stripe from 'stripe';",
+      '',
+      "describe('payment', () => {",
+      "  it('creates charge', async () => {",
+      "    const s = new Stripe('sk_test');",
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3([testFile], tmpDir);
+
+    expect(result.status).toBe('block');
+    expect(result.exitCode).toBe(1);
+    expect(result.violations.length).toBeGreaterThan(0);
+  });
+
+  it('returns pass with error severity when no violations exist', async () => {
+    writeFileSync(
+      join(tmpDir, '.mockpolicyrc'),
+      JSON.stringify({ severity: 'error' }),
+    );
+
+    // Test file with no imports → no violations possible
+    const testFile = join(tmpDir, 'src/__tests__/clean.test.ts');
+    writeFileSync(testFile, [
+      'describe("clean", () => {',
+      '  it("works", () => {',
+      '    // no imports, no violations',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3([testFile], tmpDir);
+
+    expect(result.status).toBe('pass');
+    expect(result.exitCode).toBe(0);
+    expect(result.violations).toHaveLength(0);
+  });
+
+  it('throws when a test file is unreadable during validation', async () => {
+    const nonExistentTest = join(tmpDir, 'src/__tests__/missing.test.ts');
+
+    await expect(runGateM3([nonExistentTest], tmpDir)).rejects.toThrow('ENOENT');
+  });
+
+  it('processes .spec.ts files as test files', async () => {
+    const specFile = join(tmpDir, 'src/__tests__/helper.spec.ts');
+    writeFileSync(specFile, [
+      "import { describe, it, expect } from 'vitest';",
+      '',
+      "describe('helper', () => {",
+      "  it('works', () => {",
+      '    expect(1).toBe(1);',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3([specFile], tmpDir);
+
+    expect(result.scores.totalTests).toBe(1);
+    expect(result.status).toBe('pass');
+  });
+
+  it('uses process.cwd() as default projectRoot when not specified', async () => {
+    // This test verifies the default parameter behavior
+    // We can't easily test the actual cwd behavior without side effects,
+    // but we verify the function accepts being called without projectRoot
+    const result = await runGateM3([]);
+
+    expect(result.status).toBe('skip');
+    expect(result.scores.totalTests).toBe(0);
+  });
+
+  it('produces correct result shape with all required fields', async () => {
+    const result = await runGateM3([], tmpDir);
+
+    expect(result).toHaveProperty('exitCode');
+    expect(result).toHaveProperty('status');
+    expect(result).toHaveProperty('violations');
+    expect(result).toHaveProperty('scores');
+    expect(result.scores).toHaveProperty('totalTests');
+    expect(result.scores).toHaveProperty('integrationTests');
+    expect(result.scores).toHaveProperty('mockDensity');
+    expect(result.scores).toHaveProperty('pendingMocks');
+    expect(typeof result.exitCode).toBe('number');
+    expect(['pass', 'block', 'skip']).toContain(result.status);
+    expect(Array.isArray(result.violations)).toBe(true);
+  });
+
+  it('counts pendingMocks in scores when pending violations exist', async () => {
+    // Create an integration test that imports a non-existent module
+    // which may be classified as pending by the scope scanner
+    const testFile = join(tmpDir, 'src/__tests__/feature.integration.test.ts');
+    writeFileSync(testFile, [
+      '',
+      "vi.mock('../services/not-implemented', () => {",
+      '  return { doSomething: vi.fn() };',
+      '});',
+      '',
+      "import { doSomething } from '../services/not-implemented';",
+      '',
+      "describe('feature', () => {",
+      "  it('does something', () => {",
+      '    doSomething();',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const result = await runGateM3([testFile], tmpDir);
+
+    // pendingMocks counts violations whose reason includes 'pending'
+    expect(typeof result.scores.pendingMocks).toBe('number');
+    expect(result.scores.pendingMocks).toBeGreaterThanOrEqual(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// main — CLI entry point
+// ---------------------------------------------------------------------------
+describe('main', () => {
+  let tmpDir: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let consoleErrorSpy: any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let consoleLogSpy: any;
+
+  beforeEach(() => {
+    tmpDir = createTempProject('main-cli');
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { /* noop */ });
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { /* noop */ });
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+    consoleErrorSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+
+  it('returns 1 and prints usage when no args provided', async () => {
+    const exitCode = await main([]);
+
+    expect(exitCode).toBe(1);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Usage:'),
+    );
+  });
+
+  it('returns 0 for valid test files with no violations', async () => {
+    const testFile = join(tmpDir, 'src/__tests__/clean.test.ts');
+    writeFileSync(testFile, [
+      "import { describe, it, expect } from 'vitest';",
+      '',
+      "describe('clean', () => {",
+      "  it('works', () => {",
+      '    expect(true).toBe(true);',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const exitCode = await main([testFile]);
+
+    expect(exitCode).toBe(0);
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Gate M3'),
+    );
+  });
+
+  it('prints violation details when violations exist', async () => {
+    // main() uses process.cwd(), so we cannot control config via tmpDir.
+    // Instead, we verify that when violations are found, the "Violations:"
+    // header is printed. With default config (severity=warning), exitCode=0.
+    const testFile = join(tmpDir, 'src/__tests__/payment.integration.test.ts');
+    writeFileSync(testFile, [
+      "import Stripe from 'stripe';",
+      '',
+      "describe('payment', () => {",
+      "  it('creates charge', async () => {",
+      "    const s = new Stripe('sk_test');",
+      '  });',
+      '});',
+    ].join('\n'));
+
+    const exitCode = await main([testFile]);
+
+    const logCalls: string[] = consoleLogSpy.mock.calls.map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (c: any[]) => String(c[0]),
+    );
+    expect(logCalls.some((msg) => msg.includes('Gate M3'))).toBe(true);
+    expect(exitCode).toBe(0);
+  });
+
+  it('prints PASS label when no blocking violations', async () => {
+    const testFile = join(tmpDir, 'src/__tests__/clean.test.ts');
+    writeFileSync(testFile, [
+      "import { describe, it, expect } from 'vitest';",
+      '',
+      "describe('clean', () => {",
+      "  it('works', () => {",
+      '    expect(true).toBe(true);',
+      '  });',
+      '});',
+    ].join('\n'));
+
+    await main([testFile]);
+
+    const logCalls: string[] = consoleLogSpy.mock.calls.map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (c: any[]) => String(c[0]),
+    );
+    const hasPassLabel = logCalls.some(
+      (msg) => msg.includes('PASS'),
+    );
+    expect(hasPassLabel).toBe(true);
+  });
+
+  it('prints file count in header', async () => {
+    const testFile = join(tmpDir, 'src/__tests__/clean.test.ts');
+    writeFileSync(testFile, "import { describe } from 'vitest';");
+
+    await main([testFile]);
+
+    const logCalls: string[] = consoleLogSpy.mock.calls.map(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      (c: any[]) => String(c[0]),
+    );
+    const hasFileCount = logCalls.some(
+      (msg) => msg.includes('Changed files: 1'),
+    );
+    expect(hasFileCount).toBe(true);
+  });
+});

package/mock-policy/__tests__/schema.test.ts

@@ -0,0 +1,239 @@
+/**
+ * @test REQ-327 mock-policy test coverage
+ * @intent Verify config schema validation for valid and invalid configurations
+ * @covers AC-327-02
+ */
+
+import { describe, it, expect } from 'vitest';
+import { MockPolicyConfigSchema, MockPolicyLayerRulesSchema } from '../schema';
+
+// ---------------------------------------------------------------------------
+// MockPolicyLayerRulesSchema
+// ---------------------------------------------------------------------------
+describe('MockPolicyLayerRulesSchema', () => {
+  const validLayerRules = {
+    mockPolicy: 'strict' as const,
+    requireRealForImplemented: true,
+    allowExternalMock: false,
+    requirePendingRemoval: true,
+  };
+
+  it('accepts valid layer rules without optional maxMockDensity', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse(validLayerRules);
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts valid layer rules with optional maxMockDensity', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      maxMockDensity: 50,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts maxMockDensity of 0', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      maxMockDensity: 0,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts maxMockDensity of 100', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      maxMockDensity: 100,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects maxMockDensity below 0', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      maxMockDensity: -1,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects maxMockDensity above 100', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      maxMockDensity: 101,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid mockPolicy value', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      mockPolicy: 'invalid',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing required field mockPolicy', () => {
+    const rest = { ...validLayerRules };
+    delete (rest as Record<string, unknown>).mockPolicy;
+    const result = MockPolicyLayerRulesSchema.safeParse(rest);
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing required field requireRealForImplemented', () => {
+    const rest = { ...validLayerRules };
+    delete (rest as Record<string, unknown>).requireRealForImplemented;
+    const result = MockPolicyLayerRulesSchema.safeParse(rest);
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects wrong type for boolean field', () => {
+    const result = MockPolicyLayerRulesSchema.safeParse({
+      ...validLayerRules,
+      allowExternalMock: 'yes',
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// MockPolicyConfigSchema
+// ---------------------------------------------------------------------------
+describe('MockPolicyConfigSchema', () => {
+  const validConfig = {
+    version: 1 as const,
+    layers: {
+      unit: {
+        mockPolicy: 'lenient' as const,
+        requireRealForImplemented: false,
+        allowExternalMock: true,
+        requirePendingRemoval: false,
+        maxMockDensity: 100,
+      },
+      integration: {
+        mockPolicy: 'strict' as const,
+        requireRealForImplemented: true,
+        allowExternalMock: true,
+        requirePendingRemoval: true,
+        maxMockDensity: 30,
+      },
+      e2e: {
+        mockPolicy: 'strict' as const,
+        requireRealForImplemented: true,
+        allowExternalMock: false,
+        requirePendingRemoval: false,
+        maxMockDensity: 0,
+      },
+    },
+    projectBoundary: ['src/**'],
+    severity: 'warning' as const,
+  };
+
+  it('accepts a valid full config', () => {
+    const result = MockPolicyConfigSchema.safeParse(validConfig);
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts config with severity=error', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      severity: 'error',
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('accepts config with multiple projectBoundary entries', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      projectBoundary: ['src/**', 'lib/**'],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects version other than 1', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      version: 2,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing version', () => {
+    const rest = { ...validConfig };
+    delete (rest as Record<string, unknown>).version;
+    const result = MockPolicyConfigSchema.safeParse(rest);
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects empty projectBoundary array', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      projectBoundary: [],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid severity value', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      severity: 'critical',
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing layers object', () => {
+    const rest = { ...validConfig };
+    delete (rest as Record<string, unknown>).layers;
+    const result = MockPolicyConfigSchema.safeParse(rest);
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing unit layer', () => {
+    const restLayers = { ...validConfig.layers };
+    delete (restLayers as Record<string, unknown>).unit;
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      layers: restLayers,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing integration layer', () => {
+    const restLayers = { ...validConfig.layers };
+    delete (restLayers as Record<string, unknown>).integration;
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      layers: restLayers,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects missing e2e layer', () => {
+    const restLayers = { ...validConfig.layers };
+    delete (restLayers as Record<string, unknown>).e2e;
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      layers: restLayers,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects non-string projectBoundary entries', () => {
+    const result = MockPolicyConfigSchema.safeParse({
+      ...validConfig,
+      projectBoundary: [123],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('produces correct inferred type for valid config', () => {
+    const result = MockPolicyConfigSchema.safeParse(validConfig);
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.version).toBe(1);
+      expect(result.data.severity).toBe('warning');
+      expect(result.data.projectBoundary).toEqual(['src/**']);
+      expect(result.data.layers.unit.mockPolicy).toBe('lenient');
+      expect(result.data.layers.integration.mockPolicy).toBe('strict');
+      expect(result.data.layers.e2e.allowExternalMock).toBe(false);
+    }
+  });
+});

package/mutation/AGENTS.md

@@ -1,9 +1,9 @@
 # SRC/MUTATION 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
 **Gate M** (incremental mutation testing) + **Gate M2** helpers (test-layer detection used by `src/mock-policy/`). Pre-push quality gate. TypeScript-only; uses Stryker.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boyingliu01/xp-gate",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "description": "AI-driven development workflow: 6 quality gates + Delphi review + Sprint Flow",
   "bin": {
     "xp-gate": "./bin/xp-gate.js"

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

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.14.6",
+  "version": "0.14.8",
   "displayName": "XP-Gate",
   "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": {

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

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW 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
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, 3 experts from ≥2 providers, domestic models only). Supports design + code-walkthrough modes.