@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/principles/rules/clean-code/too-many-params.ts

@@ -0,0 +1,35 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const tooManyParamsRule: Rule = {
+  id: 'clean-code.too-many-params',
+  name: 'Too Many Parameters Rule',
+  threshold: config.rules['clean-code']['too-many-params'].threshold ?? 7,
+  severity: config.rules['clean-code']['too-many-params'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      const typedAdapter = adapter as { extractFunctions?: () => Array<{name?: string; startLine?: number; line?: number; paramCount?: number;}> | undefined };
+      const functions = typedAdapter.extractFunctions?.() || [];
+      
+      for (const func of functions) {
+        if (func.paramCount && func.paramCount > (config.rules['clean-code']['too-many-params'].threshold as number)) {
+          violations.push({
+            file,
+            line: func.startLine ?? func.line ?? 1,
+            ruleId: 'clean-code.too-many-params',
+            message: `Function "${func.name}" has too many parameters: ${func.paramCount} (maximum: ${
+              config.rules['clean-code']['too-many-params'].threshold
+            })`,
+            severity: config.rules['clean-code']['too-many-params'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/unused-imports.ts

@@ -0,0 +1,33 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const unusedImportsRule: Rule = {
+  id: 'clean-code.unused-imports',
+  name: 'Unused Imports Rule',
+  threshold: 1,
+  severity: config.rules['clean-code']['unused-imports'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      const typedAdapter = adapter as { imports?: Array<{name?: string; line?: number; used?: boolean; type?: string;}> | undefined };
+      const imports = typedAdapter.imports || [];
+      
+      for (const imp of imports) {
+        if (!imp.used && imp.type !== 'type') {
+          violations.push({
+            file,
+            line: imp.line ?? 1,
+            ruleId: 'clean-code.unused-imports',
+            message: `Unused import "${imp.name}" - consider removing`,
+            severity: config.rules['clean-code']['unused-imports'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/index.ts

@@ -0,0 +1,61 @@
+import { Rule } from '../types';
+import { longFunctionRule } from './clean-code/long-function';
+import { largeFileRule } from './clean-code/large-file';
+import { magicNumbersRule } from './clean-code/magic-numbers';
+import { godClassRule } from './clean-code/god-class';
+import { deepNestingRule } from './clean-code/deep-nesting';
+import { tooManyParamsRule } from './clean-code/too-many-params';
+import { missingErrorHandlingRule } from './clean-code/missing-error-handling';
+import { unusedImportsRule } from './clean-code/unused-imports';
+import { codeDuplicationRule } from './clean-code/code-duplication';
+import { manyExportsRule } from './clean-code/many-exports';
+import { srpRule } from './solid/srp';
+import { ocpRule } from './solid/ocp';
+import { lspRule } from './solid/lsp';
+import { ispRule } from './solid/isp';
+import { dipRule } from './solid/dip';
+
+export {
+  longFunctionRule,
+  largeFileRule,
+  magicNumbersRule,
+  godClassRule,
+  deepNestingRule,
+  tooManyParamsRule,
+  missingErrorHandlingRule,
+  unusedImportsRule,
+  codeDuplicationRule,
+  manyExportsRule,
+  srpRule,
+  ocpRule,
+  lspRule,
+  ispRule,
+  dipRule,
+};
+
+const CLEAN_CODE_RULES: Rule[] = [
+  longFunctionRule,
+  largeFileRule,
+  magicNumbersRule,
+  godClassRule,
+  deepNestingRule,
+  tooManyParamsRule,
+  missingErrorHandlingRule,
+  unusedImportsRule,
+  codeDuplicationRule,
+  manyExportsRule,
+];
+
+const SOLID_RULES: Rule[] = [srpRule, ocpRule, lspRule, ispRule, dipRule];
+
+export function getAllPrincipleRules(): Rule[] {
+  return [...CLEAN_CODE_RULES, ...SOLID_RULES];
+}
+
+export function getCleanCodeRules(): Rule[] {
+  return [...CLEAN_CODE_RULES];
+}
+
+export function getSolidRules(): Rule[] {
+  return [...SOLID_RULES];
+}

package/principles/rules/solid/dip.ts

@@ -0,0 +1,47 @@
+import { Rule, Violation } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+const { severity } = config.rules['solid']['dip'];
+const EXCLUDED_CLASSES = config.rules['solid']['dip'].exclude || [
+  'Date', 'Map', 'Set', 'Error', 'Array', 'Object', 'Promise'
+];
+
+function shouldSkipInstantiation(className: string): boolean {
+  if (EXCLUDED_CLASSES.includes(className)) return true;
+  if (className.endsWith('Factory') || className.endsWith('Builder')) return true;
+  return false;
+}
+
+export const dipRule: Rule = {
+  id: 'solid.dip',
+  name: 'Dependency Inversion Principle Rule',
+  threshold: 0,
+  severity: severity as 'error' | 'warning' | 'info',
+  check: (file: string, adapter: import('../../types').Adapter): Violation[] => {
+    const violations: Violation[] = [];
+
+    try {
+      for (const cls_any of adapter.extractClasses() || []) {
+        const cls = cls_any as {code?: string; line?: number};
+        const code = cls.code;
+        if (!code) continue;
+
+        const newMatches = code.match(/new\s+(\w+)\s*\(/g) || [];
+        for (const match of newMatches) {
+          const className = match.replace(/new\s+/, '').replace(/\s*\(/, '');
+          if (shouldSkipInstantiation(className)) continue;
+
+          violations.push({
+            file,
+            line: cls.line || 0,
+            ruleId: 'solid.dip',
+            severity: severity as 'error' | 'warning' | 'info',
+            message: `Direct instantiation detected: new ${className}(). Prefer dependency injection for flexibility.`,
+          });
+        }
+      }
+    } catch { }
+    return violations;
+  }
+};

package/principles/rules/solid/isp.ts

@@ -0,0 +1,37 @@
+import { Rule, Violation } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const ispRule: Rule = {
+  id: 'solid.isp',
+  name: 'Interface Segregation Principle Rule',
+  threshold: config.rules['solid']['isp'].methodThreshold ?? 10,
+  severity: config.rules['solid']['isp'].severity as 'error' | 'warning' | 'info',
+  check: (file: string, adapter: import('../../types').Adapter): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      const typedAdapter = adapter as { extractInterfaces?: () => Array<{name?: string; line?: number; methodCount?: number;}> | undefined };
+      const interfaces = typedAdapter.extractInterfaces?.() || [];
+      
+      for (const iface of interfaces) {
+        const methodCount = iface.methodCount || 0;
+        
+        if (methodCount > (config.rules['solid']['isp'].methodThreshold as number)) {
+          violations.push({
+            file,
+            line: iface.line ?? 1,
+            ruleId: 'solid.isp',
+            message: `Interface "${iface.name}" has too many methods: ${methodCount} (maximum: ${
+              config.rules['solid']['isp'].methodThreshold
+            }). Consider splitting into focused interfaces.`,
+            severity: config.rules['solid']['isp'].severity as "error" | "warning" | "info"
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/solid/lsp.ts

@@ -0,0 +1,79 @@
+import { Rule, Violation, Adapter } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+const severity = config.rules['solid']['lsp'].severity as 'error' | 'warning' | 'info';
+const PRIMITIVE_TYPES = new Set([
+  'string', 'number', 'boolean', 'any', 'void', 'null', 'undefined', 'Object', 'Array',
+]);
+
+interface ClassInfo {
+  code?: string;
+  line?: number;
+  name?: string;
+}
+
+function extractParamType(param: string): string | null {
+  if (!param.includes(':')) return null;
+  const typeMatch = param.match(/:\s*(\w+)/);
+  return typeMatch ? typeMatch[1] : null;
+}
+
+function isCompatibleParamType(paramType: string, className: string | undefined): boolean {
+  if (PRIMITIVE_TYPES.has(paramType)) return true;
+  if (className && paramType.startsWith(className)) return true;
+  return false;
+}
+
+function collectMethodParamTypes(methodSignature: string): string[] {
+  const paramsMatch = methodSignature.match(/\(([^)]+)\)/);
+  if (!paramsMatch) return [];
+  const types: string[] = [];
+  for (const param of paramsMatch[1].split(',').map((p) => p.trim())) {
+    const paramType = extractParamType(param);
+    if (paramType) types.push(paramType);
+  }
+  return types;
+}
+
+function buildViolation(file: string, cls: ClassInfo, paramType: string): Violation {
+  return {
+    file,
+    line: cls.line ?? 0,
+    ruleId: 'solid.lsp',
+    message: `Possible LSP violation in "${cls.name}". Parameter type "${paramType}" may not be compatible with base class contract.`,
+    severity,
+  };
+}
+
+function checkClass(file: string, cls: ClassInfo): Violation[] {
+  if (!cls.code || !cls.code.includes('extends')) return [];
+
+  const violations: Violation[] = [];
+  const methodSignatures = cls.code.match(/\w+\s*\(([^)]+)\)/g) || [];
+
+  for (const methodSignature of methodSignatures) {
+    for (const paramType of collectMethodParamTypes(methodSignature)) {
+      if (!isCompatibleParamType(paramType, cls.name)) {
+        violations.push(buildViolation(file, cls, paramType));
+      }
+    }
+  }
+
+  return violations;
+}
+
+export const lspRule: Rule = {
+  id: 'solid.lsp',
+  name: 'Liskov Substitution Principle Rule',
+  threshold: 0,
+  severity,
+  check: (file: string, adapter: Adapter): Violation[] => {
+    try {
+      const classes = (adapter.extractClasses() || []) as ClassInfo[];
+      return classes.flatMap((cls) => checkClass(file, cls));
+    } catch {
+      return [];
+    }
+  },
+};

package/principles/rules/solid/ocp.ts

@@ -0,0 +1,40 @@
+import { Rule, Violation } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const ocpRule: Rule = {
+  id: 'solid.ocp',
+  name: 'Open/Closed Principle Rule',
+  threshold: 0,
+  severity: config.rules['solid']['ocp'].severity as "error" | "warning" | "info",
+  check: (file: string, adapter: import('../../types').Adapter): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      const classes = adapter.extractClasses() || [];
+      
+      for (const raw of classes) {
+        const cls = raw as { code?: string; line?: number; name?: string };
+        if (!cls.code) continue;
+        
+        const extendsMatch = cls.code.match(/extends\s+(\w+)/);
+        if (extendsMatch) {
+          const baseClass = extendsMatch[1];
+          
+          if (cls.code.includes(`class ${baseClass}`)) {
+            violations.push({
+              file,
+              line: cls.line ?? 1,
+              ruleId: 'solid.ocp',
+              message: `Possible modification of base class "${baseClass}" while extending. Extension should not require modifying the base.`,
+              severity: config.rules['solid']['ocp'].severity as "error" | "warning" | "info"
+            });
+          }
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/solid/srp.ts

@@ -0,0 +1,44 @@
+import { Rule, Violation } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+const { methodThreshold, severity } = config.rules['solid']['srp'];
+
+export const srpRule: Rule = {
+  id: 'solid.srp',
+  name: 'Single Responsibility Principle Rule',
+  threshold: methodThreshold as number,
+  severity: severity as "error" | "warning" | "info",
+  check: (file: string, adapter: import('../../types').Adapter): Violation[] => {
+    const violations: Violation[] = [];
+
+    try {
+      const classes = adapter.extractClasses() || [];
+      const maxMethods = methodThreshold as number;
+      const sev = severity as "error" | "warning" | "info";
+
+      for (const raw of classes) {
+        const cls = raw as { code?: string; line?: number; name?: string; methodCount?: number; imports?: Record<string, unknown> };
+        const methodCount = cls.methodCount || 0;
+        const importCategories = cls.imports ? Object.keys(cls.imports).length : 0;
+        const line = cls.line ?? 1;
+
+        if (methodCount > maxMethods) {
+          violations.push({
+            file, line, ruleId: 'solid.srp', severity: sev,
+            message: `Class "${cls.name}" has too many methods: ${methodCount} (maximum: ${maxMethods}). Consider splitting into focused classes.`,
+          });
+        }
+
+        if (importCategories > 3) {
+          violations.push({
+            file, line, ruleId: 'solid.srp', severity: sev,
+            message: `Class "${cls.name}" imports from ${importCategories} different domains. Each class should focus on one responsibility.`,
+          });
+        }
+      }
+    } catch { }
+
+    return violations;
+  },
+};

package/principles/types.ts

@@ -0,0 +1,27 @@
+export type Severity = 'error' | 'warning' | 'info';
+
+export interface Rule {
+  id: string;
+  name: string;
+  threshold: number;
+  severity: Severity;
+  check: (file: string, adapter: Adapter) => Violation[];
+}
+
+export interface Violation {
+  file: string;
+  line: number;
+  column?: number;
+  ruleId: string;
+  message: string;
+  severity: Severity;
+}
+
+export interface Adapter {
+  detectLanguage: () => string;
+  parseAST: () => unknown;
+  extractFunctions: () => unknown[];
+  extractClasses: () => unknown[];
+  extractExports: () => unknown[];
+  countLines: () => number;
+}

package/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/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/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/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 为共识) |
 
 **有效期机制**：