@boyingliu01/xp-gate 0.27.6 → 0.28.0

package/plugins/opencode/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-10-18
-**Commit:** 17c3c043
+**Generated:** 2026-10-19
+**Commit:** 07d3036f
 **Branch:** main
-**Version:** 0.27.6.0
+**Version:** 0.28.0.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/plugins/qoder/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "xp-gate",
-  "version": "0.27.6",
+  "version": "0.28.0",
   "displayName": "XP-Gate",
   "description": "Extreme Programming quality gates + AI workflow skills for Qoder. Includes 12 pre-commit gates (Gate 0-11), 8 pre-push gates, Sprint Flow (6 phases), and Delphi multi-expert review (>=90% consensus).",
   "author": {

package/plugins/qoder/skills/delphi-review/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/DELPHI-REVIEW KNOWLEDGE BASE
 
-**Generated:** 2026-10-18
-**Commit:** 17c3c043
+**Generated:** 2026-10-19
+**Commit:** 07d3036f
 **Branch:** main
-**Version:** 0.27.6.0
+**Version:** 0.28.0.0
 
 ## OVERVIEW
 Delphi Consensus Review — multi-round anonymous expert review (≥90% threshold, exactly 3 experts with distinct executable model IDs). Supports design, requirements, and code-walkthrough modes.

package/plugins/qoder/skills/sprint-flow/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/SPRINT-FLOW KNOWLEDGE BASE
 
-**Generated:** 2026-10-18
-**Commit:** 17c3c043
+**Generated:** 2026-10-19
+**Commit:** 07d3036f
 **Branch:** main
-**Version:** 0.27.6.0
+**Version:** 0.28.0.0
 
 ## OVERVIEW
 **6-phase** development pipeline (v2.0 compact redesign, Issue #290): PREP → DESIGN → BUILD → VERIFY → SHIP → CLOSE. Phase 3/6 BUILD default build mode is **ralph-loop** (REQ-level iteration, 40-67% token savings vs parallel). HARD-GATE between DESIGN (2/6) and BUILD (3/6): design must pass Delphi review (≥90% consensus) before any coding.

package/plugins/qoder/skills/test-specification-alignment/AGENTS.md

@@ -1,9 +1,9 @@
 # SKILLS/TEST-SPECIFICATION-ALIGNMENT KNOWLEDGE BASE
 
-**Generated:** 2026-10-18
-**Commit:** 17c3c043
+**Generated:** 2026-10-19
+**Commit:** 07d3036f
 **Branch:** main
-**Version:** 0.27.6.0
+**Version:** 0.28.0.0
 
 ## OVERVIEW
 Test-Specification Alignment Engine — two-stage validation ensuring tests accurately reflect requirements and design specs.

package/principles/AGENTS.md

@@ -1,9 +1,9 @@
 # PRINCIPLES CHECKER MODULE
 
-**Generated:** 2026-10-18
-**Commit:** 17c3c043
+**Generated:** 2026-10-19
+**Commit:** 07d3036f
 **Branch:** main
-**Version:** 0.27.6.0
+**Version:** 0.28.0.0
 
 ## OVERVIEW
 Clean Code & SOLID principles checker — **Gate 4** of pre-commit. 14 rules × 9 language adapters, SARIF 2.1.0 output. Houses the **Boy Scout Rule** enforcement engine (Gate 6) and warning-baseline storage.

package/principles/__tests__/many-exports-reexport.test.ts

@@ -0,0 +1,40 @@
+/**
+ * @test REQ-CCLINT-001
+ * @intent a pure re-export barrel (export { … } from './x') forwards names but
+ *         adds no module surface; counting each forwarded member inflates the
+ *         many-exports metric and blocks Boy-Scout splits that are exactly what
+ *         the rule asks for (common.ts → common-process.ts)
+ * @covers AC-CCLINT-001-01
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { readFileSync } from 'fs';
+import { TypeScriptAdapter } from '../adapters/typescript';
+
+vi.mock('fs', () => ({ readFileSync: vi.fn() }));
+
+function exportCount(content: string): number {
+  (readFileSync as ReturnType<typeof vi.fn>).mockReturnValue(content);
+  return new TypeScriptAdapter('t.ts').extractExports().length;
+}
+
+describe('extractExports counts module surface, not forwarded names', () => {
+  it('does not count members of an export-from re-export block', () => {
+    const content = [
+      "export {",
+      '  type ToolAvailability,',
+      '  isToolAvailable,',
+      '  runTool,',
+      "  getChangedFiles,",
+      "} from './common-process';",
+      'export function local(): void {}',
+      '',
+    ].join('\n');
+    // One local export only — the six forwarded names are not this module's surface.
+    expect(exportCount(content)).toBe(1);
+  });
+
+  it('still counts local export { A, B } blocks without a from clause', () => {
+    const content = ['export { alpha, beta };', 'const alpha = 1;', 'const beta = 2;', ''].join('\n');
+    expect(exportCount(content)).toBe(2);
+  });
+});

package/principles/adapters/typescript.ts

@@ -36,49 +36,68 @@ const CONTROL_KEYWORDS = new Set([
   'case', 'break', 'continue', 'const', 'let', 'var', 'as', 'satisfies', 'keyof',
 ]);
 
-/**
- * Find the index of the `{` that opens a declaration body for the parameter
- * list starting at `parenIndex`.
- *
- * Everything between the closing `)` and the body is scanned with a small depth
- * tracker so that a `{` belonging to a type literal in the return annotation
- * (`extract(): Array<{value: number}> {`) is not mistaken for the body. The
- * body brace is the first `{` seen at depth 0.
- */
+// ---------------------------------------------------------------------------
+// Lizard parse note: these two helpers are laid out so that no declaration
+// carrying a return type annotation is immediately followed by a JSDoc block.
+// lizard 1.21.3 mis-scopes that combination and reports the pairing as one row
+// spanning every following function (measured here: findBodyBrace swallowed the
+// rest of the file at CCN 69). Keep the plain comment style above them.
+// ---------------------------------------------------------------------------
+
+// Advance one scan character against the type-literal depth. Returns the new
+// depth plus the index to resume from, so parenthesised groups are skipped whole.
+// The inline typed-return form is avoided deliberately: lizard 1.21.3 loses the
+// function boundary when a return annotation contains a brace literal.
+type ScanStep = { depth: number; resume: number };
+
+const stepDepth = (masked: string, c: string, i: number, depth: number): ScanStep => {
+  if (c === '(') {
+    const { end } = readParenGroup(masked, i);
+    return { depth, resume: end - 1 };
+  }
+  if (c === '<' || c === '[') return { depth: depth + 1, resume: i };
+  if (c === '>' || c === ']') return { depth: Math.max(0, depth - 1), resume: i };
+  if (c === '}') return { depth: Math.max(0, depth - 1), resume: i };
+  return { depth, resume: i };
+};
+
 function findBodyBrace(masked: string, parenIndex: number): number {
   if (masked[parenIndex] !== '(') return -1;
   const { end } = readParenGroup(masked, parenIndex);
   let depth = 0;
-  for (let i = end; i < masked.length; i++) {
+  let i = end;
+  while (i < masked.length) {
     const c = masked[i];
-    if (c === '(') { const g = readParenGroup(masked, i); i = g.end - 1; continue; }
-    if (c === '<' || c === '[') { depth++; continue; }
-    if (c === '>' || c === ']') { if (depth > 0) depth--; continue; }
     if (c === '{') {
       if (depth === 0) return i;
       depth++;
+      i++;
       continue;
     }
-    if (c === '}') { if (depth > 0) depth--; continue; }
-    if (c === ';' || c === '\n') {
-      // A line break before any `{` means this header has no braced body
-      // (e.g. an interface member or an overload signature).
-      if (depth === 0) return -1;
-    }
+    // A line break or semicolon before any brace means this header has no
+    // braced body (an interface member or an overload signature).
+    if ((c === ';' || c === '\n') && depth === 0) return -1;
+    const stepped = stepDepth(masked, c, i, depth);
+    depth = stepped.depth;
+    i = stepped.resume + 1;
   }
   return -1;
 }
 
-/** Index just past the matching `}` for the block opened at `open`. */
+// Index just past the matching closing brace for the block opened at open.
+// Written with explicit braces throughout: an unbraced else-if chain here made
+// lizard 1.21.3 extend the PREVIOUS function's span over this whole region.
 function findBlockEnd(masked: string, open: number): number {
   let depth = 0;
   for (let i = open; i < masked.length; i++) {
     const c = masked[i];
-    if (c === '{') depth++;
-    else if (c === '}') {
-      depth--;
-      if (depth === 0) return i + 1;
+    if (c === '{') {
+      depth++;
+      continue;
     }
+    if (c !== '}') continue;
+    depth--;
+    if (depth === 0) return i + 1;
   }
   return masked.length;
 }
@@ -651,14 +670,26 @@ export class TypeScriptAdapter extends BaseAdapter implements Adapter {
       });
     }
 
-    const reExportRegex = /^export\s*{/gm;
+    // A re-export block lists names this module FORWARDS, not names it
+    // defines. Counting every forwarded member punishes exactly the barrel
+    // split (many-exports → sub-module + `export { … } from`) that the rule
+    // recommends, so only local `export { A, B };` blocks count — and each
+    // counts once per exported name, as before for single-line blocks.
+    const reExportRegex = /^export\s*\{([^}]*)\}(\s+from\s+[^;{]+)?;/gm;
     let reMatch;
     while ((reMatch = reExportRegex.exec(this.fileContent)) !== null) {
-      exportMatches.push({
-        name: reMatch[0],
-        type: 're-export',
-        line: this.getLineNumber(reMatch.index)
-      });
+      if (reMatch[2]) continue; // `export { … } from '…'` forwards: no new surface
+      const names = reMatch[1]
+        .split(',')
+        .map((part) => part.replace(/^type\s+/, '').trim())
+        .filter((part) => part.length > 0);
+      for (const name of names) {
+        exportMatches.push({
+          name,
+          type: 're-export',
+          line: this.getLineNumber(reMatch.index),
+        });
+      }
     }
 
     return exportMatches;

package/principles/boy-scout.ts

@@ -147,6 +147,11 @@ export function classifyFiles(gitDiffLines: string[]): FileClassification {
  * cannot be trusted is worse than no baseline, because the gate still reports
  * "PASSED" and nobody looks.
  */
+/** True when a stored budget is usable: a real, finite number. */
+function hasFiniteBudget(entry: BaselineEntry): boolean {
+  return typeof entry.totalWarnings === 'number' && Number.isFinite(entry.totalWarnings);
+}
+
 function assertValidEntry(file: string, entry: unknown): asserts entry is BaselineEntry {
   const malformed = (detail: string): never => {
     throw new Error(
@@ -159,8 +164,8 @@ function assertValidEntry(file: string, entry: unknown): asserts entry is Baseli
   if (entry === null || typeof entry !== 'object' || Array.isArray(entry)) {
     malformed(`got ${Array.isArray(entry) ? 'an array' : typeof entry}`);
   }
-  const total = (entry as BaselineEntry).totalWarnings;
-  if (typeof total !== 'number' || !Number.isFinite(total)) {
+  if (!hasFiniteBudget(entry as BaselineEntry)) {
+    const total = (entry as BaselineEntry).totalWarnings;
     malformed(`totalWarnings is ${total === undefined ? 'missing' : String(total)}`);
   }
 }
@@ -190,22 +195,26 @@ export async function loadBaseline(baselinePath: string): Promise<Record<string,
     throw new Error(`Cannot read baseline ${baselinePath}: ${reason}`);
   }
 
+  const parsed = parseBaselineObject(baselineContent, baselinePath);
+  for (const [file, entry] of Object.entries(parsed)) {
+    assertValidEntry(file, entry);
+  }
+  return parsed as Record<string, BaselineEntry>;
+}
+
+/** Parse baseline JSON into an object map, or throw a located error. */
+function parseBaselineObject(content: string, baselinePath: string): Record<string, unknown> {
   let parsed: unknown;
   try {
-    parsed = JSON.parse(baselineContent);
+    parsed = JSON.parse(content);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     throw new Error(`Baseline ${baselinePath} is not valid JSON: ${reason}`);
   }
-
   if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
     throw new Error(`Baseline ${baselinePath} must be a JSON object mapping paths to entries.`);
   }
-
-  for (const [file, entry] of Object.entries(parsed as Record<string, unknown>)) {
-    assertValidEntry(file, entry);
-  }
-  return parsed as Record<string, BaselineEntry>;
+  return parsed as Record<string, unknown>;
 }
 
 /**
@@ -254,17 +263,13 @@ async function readBaselineText(baselinePath: string): Promise<string | null | {
 
 /** Parse the baseline JSON. Returns the object, or a human-readable failure. */
 function parseBaselineJson(content: string, baselinePath: string): Record<string, unknown> | string {
-  let parsed: unknown;
+  // Same grammar as parseBaselineObject, reported instead of thrown: the
+  // repair path must keep going with an empty set where loadBaseline aborts.
   try {
-    parsed = JSON.parse(content);
+    return parseBaselineObject(content, baselinePath);
   } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error);
-    return `Baseline ${baselinePath} is not valid JSON: ${reason}`;
+    return error instanceof Error ? error.message : String(error);
   }
-  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
-    return `Baseline ${baselinePath} must be a JSON object mapping paths to entries.`;
-  }
-  return parsed as Record<string, unknown>;
 }
 
 /** Split entries into the valid ones and the names of the malformed ones. */