@boyingliu01/xp-gate 0.8.9 → 0.8.10

package/principles/rules/__tests__/solid/lsp.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { lspRule } from '../../solid/lsp';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('lsp.ts - Liskov Substitution Principle Rule', () => {
+  it('should detect parameter type changes in override', () => {
+    const mockAdapterWithViolation = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DerivedRepo',
+        line: 1,
+        code: `class DerivedRepo extends BaseRepo { findById(id: UserId): Entity {} }`
+      }]
+    };
+    
+    const violations = lspRule.check('test.ts', mockAdapterWithViolation as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.lsp');
+  });
+
+  it('should pass for proper override', () => {
+    const mockAdapterWithProperOverride = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DerivedRepo',
+        line: 1,
+        code: `
+class DerivedRepo extends BaseRepo {
+  findById(id: string): Entity | null {}
+}
+`
+      }]
+    };
+    
+    const violations = lspRule.check('test.ts', mockAdapterWithProperOverride as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use severity from config', () => {
+    expect(lspRule.severity).toBe('info');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractClasses: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = lspRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  /**
+   * @test REQ-174 Branch coverage for lsp rule
+   * @intent Cover uncovered branches: missing class.code, no extends keyword,
+   *         non-class extractClasses returning null, params without ':',
+   *         params with ':' but no type word, cls.line missing fallback,
+   *         className startsWith paramType branch.
+   * @covers AC-174-05, AC-174-06, AC-174-07
+   */
+  it('returns no violations when extractClasses returns null (|| [] branch)', () => {
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => null as unknown as never[],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns no violations when class has no code property', () => {
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{ name: 'X', line: 1 }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns no violations when class does not extend anything', () => {
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'Plain',
+        line: 1,
+        code: `class Plain { method(id: Foo) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('ignores params with no type annotation (no colon branch)', () => {
+    // foo(id) — no colon → extractParamType returns null
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'D',
+        line: 1,
+        code: `class D extends B { foo(id) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('ignores params with colon but no matchable type word', () => {
+    // foo(id: ) — colon present but typeMatch fails → returns null
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'D',
+        line: 1,
+        code: `class D extends B { foo(id: ) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('treats primitive parameter types as compatible', () => {
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'D',
+        line: 1,
+        code: `class D extends B { foo(s: string, n: number, b: boolean, a: any, v: void, x: Object) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('treats parameter types that start with className as compatible', () => {
+    // className = 'User', paramType = 'UserId' (startsWith match)
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'User',
+        line: 1,
+        code: `class User extends Base { findById(id: UserId) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('reports violation with className undefined (className && ... false branch)', () => {
+    // cls.name undefined → className && ... short-circuits to false → incompatible
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        line: 1,
+        code: `class X extends B { foo(id: CustomId) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.lsp');
+  });
+
+  it('falls back to line 0 when cls.line is missing', () => {
+    const adapter = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'D',
+        // no line
+        code: `class D extends B { foo(id: CustomId) {} }`,
+      }],
+    };
+    const violations = lspRule.check('test.ts', adapter as never);
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].line).toBe(0);
+  });
+});

package/principles/rules/__tests__/solid/ocp.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from 'vitest';
+import { ocpRule } from '../../solid/ocp';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('ocp.ts - Open/Closed Principle Rule', () => {
+  it('should detect possible base class modification', () => {
+    const mockAdapterWithModification = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DerivedClass',
+        line: 1,
+        code: `
+class BaseClass {
+  method() {}
+}
+class DerivedClass extends BaseClass {
+  method() {}
+}
+`
+      }]
+    };
+    
+    const violations = ocpRule.check('test.ts', mockAdapterWithModification as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.ocp');
+  });
+
+  it('should pass for proper extension', () => {
+    const mockAdapterWithProperExtension = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DerivedClass',
+        line: 1,
+        code: `
+class DerivedClass extends BaseClass {
+  newMethod() {}
+}
+`
+      }]
+    };
+    
+    const violations = ocpRule.check('test.ts', mockAdapterWithProperExtension as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use severity from config', () => {
+    expect(ocpRule.severity).toBe('info');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractClasses: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = ocpRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});

package/principles/rules/__tests__/solid/srp.test.ts

@@ -0,0 +1,89 @@
+import { describe, it, expect } from 'vitest';
+import { srpRule } from '../../solid/srp';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('srp.ts - Single Responsibility Principle Rule', () => {
+  it('should detect class with too many methods (>15)', () => {
+    const mockAdapterWithManyMethods = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'MultiResponsibilityClass',
+        line: 1,
+        methodCount: 18,
+        imports: {
+          ui: ['Component', 'Styles'],
+          data: ['Repository', 'Model'],
+          business: ['Service', 'Utils']
+        }
+      }]
+    };
+    
+    const violations = srpRule.check('test.ts', mockAdapterWithManyMethods as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.srp');
+  });
+
+  it('should detect import diversity (>3 categories)', () => {
+    const mockAdapterWithImportDiversity = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'CrossDomainClass',
+        line: 1,
+        methodCount: 8,
+        imports: {
+          ui: ['Component'],
+          data: ['Repository'],
+          business: ['Service'],
+          infrastructure: ['Config']
+        }
+      }]
+    };
+    
+    const violations = srpRule.check('test.ts', mockAdapterWithImportDiversity as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].message).toContain('import');
+  });
+
+  it('should pass for focused class', () => {
+    const mockAdapterWithFocusedClass = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'FocusedClass',
+        line: 1,
+        methodCount: 8,
+        imports: {
+          data: ['Repository', 'Model']
+        }
+      }]
+    };
+    
+    const violations = srpRule.check('test.ts', mockAdapterWithFocusedClass as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(srpRule.threshold).toBe(15);
+    expect(srpRule.severity).toBe('warning');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractClasses: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = srpRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});

package/principles/rules/clean-code/code-duplication.ts

@@ -0,0 +1,31 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const codeDuplicationRule: Rule = {
+  id: 'clean-code.code-duplication',
+  name: 'Code Duplication Rule',
+  threshold: config.rules['clean-code']['code-duplication'].threshold ?? 15,
+  severity: config.rules['clean-code']['code-duplication'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      const typedAdapter = adapter as { duplicationPercentage?: number };
+      const duplicationPercentage = typedAdapter.duplicationPercentage;
+      
+      if (duplicationPercentage && duplicationPercentage > (config.rules['clean-code']['code-duplication'].threshold as number)) {
+        violations.push({
+          file,
+          line: 1,
+          ruleId: 'clean-code.code-duplication',
+          message: `Code duplication detected: ${duplicationPercentage}% (threshold: ${config.rules['clean-code']['code-duplication'].threshold}%). Consider refactoring duplicated code.`,
+          severity: config.rules['clean-code']['code-duplication'].severity as Severity
+        });
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/deep-nesting.ts

@@ -0,0 +1,38 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const deepNestingRule: Rule = {
+  id: 'clean-code.deep-nesting',
+  name: 'Deep Nesting Rule',
+  threshold: config.rules['clean-code']['deep-nesting'].threshold ?? 4,
+  severity: config.rules['clean-code']['deep-nesting'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      interface TypedAdapter {
+        extractFunctions?: () => Array<{name?: string, nestingDepth?: number, startLine?: number, line?: number}> | undefined;
+      }
+      const typedAdapter = adapter as TypedAdapter;
+      const functions = typedAdapter.extractFunctions?.() || [];
+      
+      for (const func of functions) {
+        if (func.nestingDepth && func.nestingDepth > (config.rules['clean-code']['deep-nesting'].threshold as number)) {
+          violations.push({
+            file,
+            line: func.startLine ?? func.line ?? 1,
+            ruleId: 'clean-code.deep-nesting',
+            message: `Function "${func.name}" has deep nesting: ${func.nestingDepth} levels (maximum: ${
+              config.rules['clean-code']['deep-nesting'].threshold
+            })`,
+            severity: config.rules['clean-code']['deep-nesting'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/god-class.ts

@@ -0,0 +1,54 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const godClassRule: Rule = {
+  id: 'clean-code.god-class',
+  name: 'God Class Rule',
+  threshold: config.rules['clean-code']['god-class'].threshold ?? 15,
+  severity: config.rules['clean-code']['god-class'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      interface ClassObject {
+        code?: string;
+        line: number;
+        name: string;
+      }
+      
+      interface TypedAdapter {
+        extractClasses?: () => ClassObject[] | undefined;
+      }
+      
+      const typedAdapter = adapter as TypedAdapter;
+      const classes = typedAdapter.extractClasses?.() || [];
+      
+      for (const cls of classes) {
+        const methodMatches = cls.code?.match(/(get|set)\s+\w+\s*\(|\w+\s*\([^)]*\)\s*{/g) || [];
+        
+        const methodCount = methodMatches.filter((m: string) => {
+          if (m.startsWith('get ') || m.startsWith('set ')) {
+            return false;
+          }
+          return true;
+        }).length;
+        
+        if (methodCount > (config.rules['clean-code']['god-class'].threshold as number)) {
+          violations.push({
+            file,
+            line: cls.line,
+            ruleId: 'clean-code.god-class',
+            message: `Class "${cls.name}" has too many methods: ${methodCount} (maximum: ${
+              config.rules['clean-code']['god-class'].threshold
+            })`,
+            severity: config.rules['clean-code']['god-class'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/large-file.ts

@@ -0,0 +1,34 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const largeFileRule: Rule = {
+  id: 'clean-code.large-file',
+  name: 'Large File Rule',
+  threshold: config.rules['clean-code']['large-file'].threshold ?? 500,
+  severity: config.rules['clean-code']['large-file'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      interface TypedAdapter {
+        countLines?: (file: string) => number | undefined;
+      }
+      const typedAdapter = adapter as TypedAdapter;
+      const lineCount = typedAdapter.countLines?.(file) ?? 0;
+      
+      if (lineCount > (config.rules['clean-code']['large-file'].threshold as number)) {
+        violations.push({
+          file,
+          line: 1,
+          ruleId: 'clean-code.large-file',
+          message: `File is too large: ${lineCount} lines (maximum: ${config.rules['clean-code']['large-file'].threshold})`,
+          severity: config.rules['clean-code']['large-file'].severity as Severity
+        });
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/long-function.ts

@@ -0,0 +1,47 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const longFunctionRule: Rule = {
+  id: 'clean-code.long-function',
+  name: 'Long Function Rule',
+  threshold: config.rules['clean-code']['long-function'].threshold ?? 50,
+  severity: config.rules['clean-code']['long-function'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      interface FunctionObj {
+        name: string;
+        startLine: number;
+        length: number;
+      }
+      
+      interface TypedAdapter {
+        extractFunctions?: () => FunctionObj[] | undefined;
+      }
+      
+      const typedAdapter = adapter as TypedAdapter;
+      const functions = typedAdapter.extractFunctions?.() || [];
+      
+      for (const func of functions) {
+        const { name, startLine, length } = func;
+        
+        if (length > (config.rules['clean-code']['long-function'].threshold as number)) {
+          violations.push({
+            file,
+            line: startLine ?? 1,
+            ruleId: 'clean-code.long-function',
+            message: `Function "${name}" is too long: ${length} lines (maximum: ${
+              config.rules['clean-code']['long-function'].threshold
+            })`,
+            severity: config.rules['clean-code']['long-function'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/magic-numbers.ts

@@ -0,0 +1,59 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+const EXCLUDED_NUMBERS = config.rules['clean-code']['magic-numbers'].exclude || [0, 1, -1, 2, 10, 100, 1000, 60, 24, 7, 30, 365, 256, 1024];
+
+export const magicNumbersRule: Rule = {
+  id: 'clean-code.magic-numbers',
+  name: 'Magic Numbers Rule',
+  threshold: 10,
+  severity: config.rules['clean-code']['magic-numbers'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+    
+    try {
+      interface NumberObject {
+        value: number;
+        line: number;
+      }
+      
+      interface TypedAdapter {
+        parseAST?: () => unknown | undefined;
+        extract?: () => NumberObject[] | undefined;
+      }
+      
+      const typedAdapter = adapter as TypedAdapter;
+      
+      let magicNumbers: NumberObject[] = [];
+      
+      try {
+        if (typeof typedAdapter.extract !== 'undefined') {
+          const literals = typedAdapter.extract?.();
+          if (literals && Array.isArray(literals)) {
+            magicNumbers = literals;
+          }
+        }
+      } catch { }
+      
+      const filteredNumbers = magicNumbers.filter(numObj => {
+        const numValue = numObj.value;
+        return !EXCLUDED_NUMBERS.includes(numValue);
+      });
+      
+      filteredNumbers.forEach(numObj => {
+        violations.push({
+          file,
+          line: numObj.line,
+          ruleId: 'clean-code.magic-numbers',
+          message: `Potential magic number detected: ${numObj.value}. Consider using a named constant instead.`,
+          severity: config.rules['clean-code']['magic-numbers'].severity as Severity
+        });
+      });
+      
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/many-exports.ts

@@ -0,0 +1,40 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const manyExportsRule: Rule = {
+  id: 'clean-code.many-exports',
+  name: 'Many Exports Rule',
+  threshold: config.rules['clean-code']['many-exports'].threshold ?? 10,
+  severity: config.rules['clean-code']['many-exports'].severity as Severity,
+  check: (file: string, adapter: unknown): Violation[] => {
+    const violations: Violation[] = [];
+
+    try {
+      interface ExportObj {
+        line: number;
+      }
+      
+      interface TypedAdapter {
+        extractExports?: () => ExportObj[] | undefined;
+      }
+      
+      const typedAdapter = adapter as TypedAdapter;
+      const exports = typedAdapter.extractExports ? typedAdapter.extractExports() : [];
+      const threshold = config.rules['clean-code']['many-exports'].threshold ?? 10;
+      
+      if (exports && exports.length > threshold) {
+        violations.push({
+          file,
+          line: exports[0]?.line || 1,
+          ruleId: 'clean-code.many-exports',
+          message: `Module has too many exports: ${exports.length} (maximum: ${threshold}). Consider splitting into focused sub-modules.`,
+          severity: config.rules['clean-code']['many-exports'].severity as Severity
+        });
+      }
+    } catch { }
+    
+    return violations;
+  }
+};

package/principles/rules/clean-code/missing-error-handling.ts

@@ -0,0 +1,33 @@
+import { Rule, Violation, Severity } from '../../types';
+import { getDefaultConfig } from '../../config';
+
+const config = getDefaultConfig();
+
+export const missingErrorHandlingRule: Rule = {
+  id: 'clean-code.missing-error-handling',
+  name: 'Missing Error Handling Rule',
+  threshold: 1,
+  severity: config.rules['clean-code']['missing-error-handling'].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; ioOperations?: string[]; hasTryCatch?: boolean;}> | undefined };
+      const functions = typedAdapter.extractFunctions?.() || [];
+      
+      for (const func of functions) {
+        if (func.ioOperations && func.ioOperations.length > 0 && !func.hasTryCatch) {
+          violations.push({
+            file,
+            line: func.startLine ?? func.line ?? 1,
+            ruleId: 'clean-code.missing-error-handling',
+            message: `Function "${func.name}" has IO operations (${func.ioOperations.join(', ')}) without error handling`,
+            severity: config.rules['clean-code']['missing-error-handling'].severity as Severity
+          });
+        }
+      }
+    } catch { }
+    
+    return violations;
+  }
+};