@boyingliu01/xp-gate 0.8.8 → 0.8.10

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

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('../../../config', () => ({
+  getDefaultConfig: () => ({
+    rules: {
+      'clean-code': {
+        'many-exports': {
+          enabled: true,
+          // threshold intentionally omitted -> exercises ?? 10 fallback branch
+          severity: 'warning',
+        },
+      },
+    },
+  }),
+}));
+
+import { manyExportsRule } from '../../clean-code/many-exports';
+
+/**
+ * @test REQ-174 Branch coverage for many-exports rule
+ * @intent Cover every branch in many-exports.ts (extractExports presence,
+ *         threshold boundary, empty/undefined exports, first-export line fallback,
+ *         and try/catch fallback) so branch coverage reaches >=80%.
+ * @covers AC-174-01, AC-174-02, AC-174-03, AC-174-04
+ */
+
+const baseAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0,
+};
+
+describe('manyExportsRule', () => {
+  it('has correct rule metadata', () => {
+    expect(manyExportsRule.id).toBe('clean-code.many-exports');
+    expect(manyExportsRule.name).toBe('Many Exports Rule');
+    expect(manyExportsRule.threshold).toBe(10);
+    expect(manyExportsRule.severity).toBe('warning');
+  });
+
+  it('returns no violations when adapter lacks extractExports (falsy branch)', () => {
+    // typedAdapter.extractExports is undefined -> exports = []
+    const violations = manyExportsRule.check('file.ts', baseAdapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns no violations when extractExports returns empty array', () => {
+    const adapter: never = {
+      ...baseAdapter,
+      extractExports: () => [],
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns no violations when export count equals threshold (boundary)', () => {
+    const adapter: never = {
+      ...baseAdapter,
+      extractExports: () =>
+        Array.from({ length: 10 }, (_, i) => ({ line: i + 1 })),
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns violation when export count exceeds threshold', () => {
+    const adapter: never = {
+      ...baseAdapter,
+      extractExports: () =>
+        Array.from({ length: 11 }, (_, i) => ({ line: i + 5 })),
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(1);
+    expect(violations[0]).toEqual({
+      file: 'file.ts',
+      line: 5,
+      ruleId: 'clean-code.many-exports',
+      message:
+        'Module has too many exports: 11 (maximum: 10). Consider splitting into focused sub-modules.',
+      severity: 'warning',
+    });
+  });
+
+  it('falls back to line 1 when first export line is missing/zero', () => {
+    const adapter: never = {
+      ...baseAdapter,
+      // first export has line 0 -> `exports[0]?.line || 1` selects 1
+      extractExports: () =>
+        Array.from({ length: 11 }, () => ({ line: 0 })),
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(1);
+    expect(violations[0].line).toBe(1);
+  });
+
+  it('returns empty violations when extractExports returns undefined', () => {
+    // covers the `exports && ...` short-circuit false branch
+    const adapter: never = {
+      ...baseAdapter,
+      extractExports: () => undefined,
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('returns empty violations when adapter throws (catch branch)', () => {
+    const adapter: never = {
+      ...baseAdapter,
+      extractExports: () => {
+        throw new Error('boom');
+      },
+    } as never;
+    const violations = manyExportsRule.check('file.ts', adapter);
+    expect(violations).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { missingErrorHandlingRule } from '../../clean-code/missing-error-handling';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('missing-error-handling.ts - Missing Error Handling Rule', () => {
+  it('should detect async function with fetch without try-catch', () => {
+    const mockAdapterWithIO = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'loadData',
+        startLine: 10,
+        code: `
+async function loadData(url: string) {
+  const response = await fetch(url);
+  return response.json();
+}
+`,
+        isAsync: true,
+        ioOperations: ['fetch']
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithIO as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.missing-error-handling');
+    expect(violations[0].message).toContain('fetch');
+  });
+
+  it('should detect async function with fs.readFile without try-catch', () => {
+    const mockAdapterWithIO = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'readConfig',
+        startLine: 20,
+        code: `
+async function readConfig(path: string) {
+  const data = await fs.readFile(path, 'utf-8');
+  return JSON.parse(data);
+}
+`,
+        isAsync: true,
+        ioOperations: ['fs.readFile']
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithIO as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.missing-error-handling');
+    expect(violations[0].message).toContain('fs.readFile');
+  });
+
+  it('should pass for async function with try-catch wrapping IO', () => {
+    const mockAdapterWithHandledIO = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'loadDataSafe',
+        startLine: 30,
+        code: `
+async function loadDataSafe(url: string) {
+  try {
+    const response = await fetch(url);
+    return response.json();
+  } catch (error) {
+    logger.error('Failed to load', error);
+    return null;
+  }
+}
+`,
+        isAsync: true,
+        ioOperations: ['fetch'],
+        hasTryCatch: true
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithHandledIO as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should pass for pure function without IO operations', () => {
+    const mockAdapterWithPureFunction = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'calculateTotal',
+        startLine: 40,
+        code: `
+function calculateTotal(items: Item[]) {
+  return items.reduce((sum, item) => sum + item.price, 0);
+}
+`,
+        isAsync: false,
+        ioOperations: []
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithPureFunction as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should detect axios call without error handling', () => {
+    const mockAdapterWithAxios = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'fetchUser',
+        startLine: 50,
+        code: `
+async function fetchUser(id: string) {
+  const response = await axios.get('/api/users/' + id);
+  return response.data;
+}
+`,
+        isAsync: true,
+        ioOperations: ['axios']
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithAxios as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.missing-error-handling');
+  });
+
+  it('should use severity from config', () => {
+    expect(missingErrorHandlingRule.severity).toBe('warning');
+  });
+
+  it('should return empty array when adapter.extractFunctions throws', () => {
+    const mockAdapterThrowing = {
+      ...mockAdapter,
+      extractFunctions: () => { throw new Error('Parse error'); }
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterThrowing as never);
+    
+    expect(violations).toEqual([]);
+  });
+
+  it('should detect multiple IO operations in one function', () => {
+    const mockAdapterWithMultipleIO = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'processData',
+        startLine: 60,
+        code: `
+async function processData() {
+  const response = await fetch('/api/data');
+  const data = await response.json();
+  await fs.writeFile('output.json', JSON.stringify(data));
+  return data;
+}
+`,
+        isAsync: true,
+        ioOperations: ['fetch', 'fs.writeFile']
+      }]
+    };
+    
+    const violations = missingErrorHandlingRule.check('test.ts', mockAdapterWithMultipleIO as never);
+    
+    // Should detect at least one violation (function needs try-catch)
+    expect(violations.length).toBeGreaterThanOrEqual(1);
+    expect(violations[0].ruleId).toBe('clean-code.missing-error-handling');
+  });
+});

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

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { tooManyParamsRule } from '../../clean-code/too-many-params';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('too-many-params.ts - Too Many Parameters Rule', () => {
+  it('should detect function with more than 7 parameters', () => {
+    const mockAdapterWithManyParams = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'lotsOfParams',
+        startLine: 1,
+        params: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'],
+        paramCount: 8
+      }]
+    };
+    
+    const violations = tooManyParamsRule.check('test.ts', mockAdapterWithManyParams as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.too-many-params');
+  });
+
+  it('should pass for function with acceptable parameters', () => {
+    const mockAdapterWithNormalParams = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'normalParams',
+        startLine: 1,
+        paramCount: 5
+      }]
+    };
+    
+    const violations = tooManyParamsRule.check('test.ts', mockAdapterWithNormalParams as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(tooManyParamsRule.threshold).toBe(7);
+    expect(tooManyParamsRule.severity).toBe('info');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractFunctions: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = tooManyParamsRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});

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

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { unusedImportsRule } from '../../clean-code/unused-imports';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('unused-imports.ts - Unused Imports Rule', () => {
+  it('should detect unused value import', () => {
+    const mockAdapterWithUnusedImport = {
+      ...mockAdapter,
+      imports: [
+        { name: 'lodash', line: 1, type: 'value', used: false },
+        { name: 'fs', line: 2, type: 'value', used: true }
+      ]
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterWithUnusedImport as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.unused-imports');
+    expect(violations[0].message).toContain('lodash');
+  });
+
+  it('should pass for used imports', () => {
+    const mockAdapterWithUsedImports = {
+      ...mockAdapter,
+      imports: [
+        { name: 'fs', line: 1, type: 'value', used: true },
+        { name: 'path', line: 2, type: 'value', used: true }
+      ]
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterWithUsedImports as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should skip type-only imports (TypeScript)', () => {
+    const mockAdapterWithTypeImports = {
+      ...mockAdapter,
+      imports: [
+        { name: 'User', line: 1, type: 'type', used: false },
+        { name: 'fs', line: 2, type: 'value', used: true }
+      ]
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterWithTypeImports as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should detect multiple unused imports', () => {
+    const mockAdapterWithMultipleUnused = {
+      ...mockAdapter,
+      imports: [
+        { name: 'lodash', line: 1, type: 'value', used: false },
+        { name: 'axios', line: 2, type: 'value', used: false },
+        { name: 'fs', line: 3, type: 'value', used: true }
+      ]
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterWithMultipleUnused as never);
+    
+    expect(violations.length).toBe(2);
+  });
+
+  it('should use severity from config', () => {
+    expect(unusedImportsRule.severity).toBe('info');
+  });
+
+  it('should return empty array when adapter.imports is undefined', () => {
+    const violations = unusedImportsRule.check('test.ts', mockAdapter as never);
+    
+    expect(violations).toEqual([]);
+  });
+
+  it('should return empty array when adapter throws', () => {
+    const mockAdapterThrowing = {
+      ...mockAdapter,
+      imports: () => { throw new Error('Parse error'); }
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterThrowing as never);
+    
+    expect(violations).toEqual([]);
+  });
+
+  it('should handle namespace imports', () => {
+    const mockAdapterWithNamespaceImport = {
+      ...mockAdapter,
+      imports: [
+        { name: '* as fs', line: 1, type: 'namespace', used: true },
+        { name: '* as lodash', line: 2, type: 'namespace', used: false }
+      ]
+    };
+    
+    const violations = unusedImportsRule.check('test.ts', mockAdapterWithNamespaceImport as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].message).toContain('lodash');
+  });
+});

package/principles/rules/__tests__/index.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import * as rulesIndex from '../index';
+
+/**
+ * @test REQ-COV-002 Coverage: src/principles/rules/index.ts
+ * @intent Verify all 15 rule re-exports are accessible
+ * @covers AC-COV-002
+ */
+describe('principles/rules/index', () => {
+  const expectedCleanCodeRules = [
+    'longFunctionRule',
+    'largeFileRule',
+    'magicNumbersRule',
+    'godClassRule',
+    'deepNestingRule',
+    'tooManyParamsRule',
+    'missingErrorHandlingRule',
+    'unusedImportsRule',
+    'codeDuplicationRule',
+    'manyExportsRule',
+  ];
+
+  const expectedSolidRules = ['srpRule', 'ocpRule', 'lspRule', 'ispRule', 'dipRule'];
+
+  it('exports all 10 clean-code rules', () => {
+    for (const name of expectedCleanCodeRules) {
+      expect(rulesIndex).toHaveProperty(name);
+      expect(typeof (rulesIndex as Record<string, unknown>)[name]).toBe('object');
+    }
+  });
+
+  it('exports all 5 SOLID rules', () => {
+    for (const name of expectedSolidRules) {
+      expect(rulesIndex).toHaveProperty(name);
+      expect(typeof (rulesIndex as Record<string, unknown>)[name]).toBe('object');
+    }
+  });
+
+  it('each exported rule has an id and check function', () => {
+    const allRules = [...expectedCleanCodeRules, ...expectedSolidRules];
+    for (const name of allRules) {
+      const rule = (rulesIndex as Record<string, { id?: string; check?: unknown }>)[name];
+      expect(rule.id).toBeDefined();
+      expect(typeof rule.id).toBe('string');
+      expect(rule.check).toBeDefined();
+      expect(typeof rule.check).toBe('function');
+    }
+  });
+});

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

@@ -0,0 +1,121 @@
+import { describe, it, expect } from 'vitest';
+import { dipRule } from '../../solid/dip';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('dip.ts - Dependency Inversion Principle Rule', () => {
+  it('should detect direct instantiation in business logic', () => {
+    const mockAdapterWithDirectInstantiation = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'UserService',
+        line: 1,
+        code: `
+class UserService {
+  private repo = new UserRepository();
+  
+  getUser(id: string) {
+    return this.repo.findById(id);
+  }
+}
+`
+      }]
+    };
+    
+    const violations = dipRule.check('test.ts', mockAdapterWithDirectInstantiation as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.dip');
+  });
+
+  it('should pass for dependency injection pattern', () => {
+    const mockAdapterWithDI = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'UserService',
+        line: 1,
+        code: `
+class UserService {
+  constructor(private repo: IRepository) {}
+  
+  getUser(id: string) {
+    return this.repo.findById(id);
+  }
+}
+`
+      }]
+    };
+    
+    const violations = dipRule.check('test.ts', mockAdapterWithDI as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should exclude value objects (Date, Map, Set, etc)', () => {
+    const mockAdapterWithValueObjects = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DateService',
+        line: 1,
+        code: `
+class DateService {
+  formatDate(date: Date) {
+    return new Intl.DateTimeFormat().format(date);
+  }
+}
+`
+      }]
+    };
+    
+    const violations = dipRule.check('test.ts', mockAdapterWithValueObjects as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(dipRule.severity).toBe('warning');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractClasses: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = dipRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should exclude built-in types (Date, Map, Set, etc.)', () => {
+    const mockAdapterWithBuiltins = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'Service',
+        line: 1,
+        code: `class Service { run() { return new Date(); } }`
+      }]
+    };
+    const violations = dipRule.check('test.ts', mockAdapterWithBuiltins as never);
+    expect(violations.length).toBe(0);
+  });
+
+  it('should exclude Factory and Builder patterns', () => {
+    const mockAdapterWithFactory = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'Client',
+        line: 1,
+        code: `class Client { create() { return new UserFactory(); } }`
+      }]
+    };
+    const violations = dipRule.check('test.ts', mockAdapterWithFactory as never);
+    expect(violations.length).toBe(0);
+  });
+});

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

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { ispRule } from '../../solid/isp';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('isp.ts - Interface Segregation Principle Rule', () => {
+  it('should detect interface with too many methods (>10)', () => {
+    const mockAdapterWithFatInterface = {
+      ...mockAdapter,
+      extractInterfaces: () => [{
+        name: 'FatInterface',
+        line: 1,
+        methodCount: 12
+      }]
+    };
+    
+    const violations = ispRule.check('test.ts', mockAdapterWithFatInterface as never);
+    
+    expect(violations.length).toBeGreaterThan(0);
+    expect(violations[0].ruleId).toBe('solid.isp');
+    expect(violations[0].message).toContain('12');
+  });
+
+  it('should pass for focused interface', () => {
+    const mockAdapterWithFocusedInterface = {
+      ...mockAdapter,
+      extractInterfaces: () => [{
+        name: 'ReaderInterface',
+        line: 1,
+        methodCount: 5
+      }]
+    };
+    
+    const violations = ispRule.check('test.ts', mockAdapterWithFocusedInterface as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(ispRule.threshold).toBe(10);
+    expect(ispRule.severity).toBe('info');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractInterfaces: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = ispRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});