@boyingliu01/xp-gate 0.8.9 → 0.8.10

package/principles/reporter.ts

@@ -0,0 +1,188 @@
+import { AnalysisResult, Violation } from './analyzer';
+
+export function formatSARIF(result: AnalysisResult): string {
+  const ruleDescriptors = Object.keys(result.ruleResults).map(ruleId => ({
+    id: ruleId,
+    shortDescription: {
+      text: getRuleDescription(ruleId)
+    },
+    defaultConfiguration: {
+      level: getRuleLevel(ruleId)
+    }
+  }));
+  
+  const sarifResults = result.violations.map(v => ({
+    ruleId: v.ruleId,
+    level: v.severity === 'error' ? 'error' : v.severity === 'warning' ? 'warning' : 'note',
+    message: {
+      text: v.message
+    },
+    locations: [
+      {
+        physicalLocation: {
+          artifactLocation: {
+            uri: v.file
+          },
+          region: {
+            startLine: v.line,
+            startColumn: v.column || 1
+          }
+        }
+      }
+    ]
+  }));
+  
+  const sarif = {
+    $schema: 'https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json',
+    version: '2.1.0',
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: 'Principles Checker',
+            version: '1.0.0',
+            informationUri: 'https://github.com/boyingliu01/xp-gate',
+            rules: ruleDescriptors
+          }
+        },
+        results: sarifResults,
+        properties: {
+          filesChecked: result.summary.filesChecked,
+          rulesRun: result.summary.rulesRun,
+          executionTimeMs: result.executionTimeMs
+        }
+      }
+    ]
+  };
+  
+  return JSON.stringify(sarif, null, 2);
+}
+
+function getRuleDescription(ruleId: string): string {
+  const descriptions: Record<string, string> = {
+    'clean-code.long-function': 'Function exceeds maximum line threshold',
+    'clean-code.large-file': 'File exceeds maximum line threshold',
+    'clean-code.god-class': 'Class has too many methods',
+    'clean-code.deep-nesting': 'Nested depth exceeds threshold',
+    'clean-code.too-many-params': 'Function has too many parameters',
+    'clean-code.magic-numbers': 'Magic number found without named constant',
+    'clean-code.missing-error-handling': 'Missing error handling for I/O operations',
+    'clean-code.unused-imports': 'Unused import detected',
+    'clean-code.code-duplication': 'Code duplication detected',
+    'solid.srp': 'Single Responsibility Principle violation',
+    'solid.ocp': 'Open/Closed Principle violation',
+    'solid.lsp': 'Liskov Substitution Principle violation',
+    'solid.isp': 'Interface Segregation Principle violation',
+    'solid.dip': 'Dependency Inversion Principle violation'
+  };
+  
+  return descriptions[ruleId] || ruleId;
+}
+
+function getRuleLevel(ruleId: string): string {
+  const errorRules = ['clean-code.missing-error-handling', 'solid.srp', 'solid.dip'];
+  const warningRules = [
+    'clean-code.long-function', 'clean-code.large-file', 'clean-code.god-class',
+    'clean-code.deep-nesting', 'clean-code.code-duplication'
+  ];
+  
+  if (errorRules.includes(ruleId)) return 'error';
+  if (warningRules.includes(ruleId)) return 'warning';
+  return 'note';
+}
+
+function formatEmptyResult(result: AnalysisResult, lines: string[]): string {
+  lines.push('✓ No violations found');
+  lines.push('');
+  lines.push(`Files checked: ${result.summary.filesChecked}`);
+  lines.push(`Rules run: ${result.summary.rulesRun}`);
+  lines.push(`Execution time: ${result.executionTimeMs}ms`);
+  return lines.join('\n');
+}
+
+function formatViolationLines(violation: Violation): string[] {
+  const severityIcon = violation.severity === 'error' ? '✗' : 
+                       violation.severity === 'warning' ? '⚠' : 'ℹ';
+  const severityLabel = violation.severity.toUpperCase();
+  return [
+    `  ${severityIcon} [${severityLabel}] ${violation.ruleId}`,
+    `     line ${violation.line}${violation.column ? `, col ${violation.column}` : ''}: ${violation.message}`
+  ];
+}
+
+function formatFileViolations(lines: string[], filesMap: Record<string, Violation[]>): void {
+  for (const [file, violations] of Object.entries(filesMap)) {
+    lines.push(`\n📁 ${file}`);
+    lines.push('─'.repeat(40));
+    for (const v of violations) {
+      lines.push(...formatViolationLines(v));
+    }
+  }
+}
+
+function formatErrors(lines: string[], result: AnalysisResult): void {
+  if (result.errors.length === 0) return;
+  lines.push('');
+  lines.push('⚠ Analysis errors:');
+  for (const err of result.errors) {
+    lines.push(`  - ${err}`);
+  }
+}
+
+export function formatConsole(result: AnalysisResult): string {
+  const lines: string[] = [];
+  
+  if (result.violations.length === 0) {
+    return formatEmptyResult(result, lines);
+  }
+  
+  const filesMap: Record<string, Violation[]> = {};
+  for (const v of result.violations) {
+    if (!filesMap[v.file]) {
+      filesMap[v.file] = [];
+    }
+    filesMap[v.file].push(v);
+  }
+  
+  formatFileViolations(lines, filesMap);
+  
+  lines.push('');
+  lines.push('─'.repeat(40));
+  lines.push(formatSummary(result));
+  lines.push(`Execution time: ${result.executionTimeMs}ms`);
+  
+  formatErrors(lines, result);
+  
+  return lines.join('\n');
+}
+
+export function formatJSON(result: AnalysisResult): string {
+  const output = {
+    violations: result.violations,
+    summary: result.summary,
+    fileResults: result.fileResults,
+    ruleResults: result.ruleResults,
+    executionTimeMs: result.executionTimeMs,
+    errors: result.errors
+  };
+  
+  return JSON.stringify(output, null, 2);
+}
+
+export function formatSummary(result: AnalysisResult): string {
+  const status = result.violations.length === 0 ? 'PASS' : 'FAIL';
+  const statusIcon = result.violations.length === 0 ? '✓' : '✗';
+  
+  const lines: string[] = [];
+  lines.push(`${statusIcon} ${status}`);
+  lines.push('');
+  lines.push(`${result.summary.totalViolations} violations total`);
+  lines.push(`  ${result.summary.errorCount} errors`);
+  lines.push(`  ${result.summary.warningCount} warnings`);
+  lines.push(`  ${result.summary.infoCount} info`);
+  lines.push('');
+  lines.push(`${result.summary.filesChecked} files checked`);
+  lines.push(`${result.summary.rulesRun} rules run`);
+  
+  return lines.join('\n');
+}

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

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import { codeDuplicationRule } from '../../clean-code/code-duplication';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('code-duplication.ts - Code Duplication Rule', () => {
+  it('should detect high duplication percentage above threshold', () => {
+    const mockAdapterWithDuplication = {
+      ...mockAdapter,
+      duplicationPercentage: 25
+    };
+    
+    const violations = codeDuplicationRule.check('test.ts', mockAdapterWithDuplication as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.code-duplication');
+    expect(violations[0].message).toContain('25%');
+  });
+
+  it('should pass for low duplication percentage below threshold', () => {
+    const mockAdapterWithLowDuplication = {
+      ...mockAdapter,
+      duplicationPercentage: 10
+    };
+    
+    const violations = codeDuplicationRule.check('test.ts', mockAdapterWithLowDuplication as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should pass for duplication exactly at threshold (15%)', () => {
+    const mockAdapterAtThreshold = {
+      ...mockAdapter,
+      duplicationPercentage: 15
+    };
+    
+    const violations = codeDuplicationRule.check('test.ts', mockAdapterAtThreshold as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold and severity from config', () => {
+    expect(codeDuplicationRule.threshold).toBe(15);
+    expect(codeDuplicationRule.severity).toBe('warning');
+  });
+
+  it('should return empty array when adapter.duplicationPercentage is undefined', () => {
+    const violations = codeDuplicationRule.check('test.ts', mockAdapter as never);
+    
+    expect(violations).toEqual([]);
+  });
+
+  it('should return empty array when adapter throws', () => {
+    const mockAdapterThrowing = {
+      ...mockAdapter,
+      duplicationPercentage: () => { throw new Error('jscpd error'); }
+    };
+    
+    const violations = codeDuplicationRule.check('test.ts', mockAdapterThrowing as never);
+    
+    expect(violations).toEqual([]);
+  });
+
+  it('should handle multiple files with duplication', () => {
+    const mockAdapterWithDuplication = {
+      ...mockAdapter,
+      duplicationPercentage: 30,
+      duplicatedBlocks: [
+        { lines: 10, tokens: 50, files: ['test.ts', 'other.ts'] }
+      ]
+    };
+    
+    const violations = codeDuplicationRule.check('test.ts', mockAdapterWithDuplication as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].message).toContain('30%');
+  });
+});

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

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { deepNestingRule } from '../../clean-code/deep-nesting';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('deep-nesting.ts - Deep Nesting Rule', () => {
+  it('should detect function with nesting deeper than 4 levels', () => {
+    const mockAdapterWithDeepNesting = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'deeplyNested',
+        startLine: 1,
+        code: `
+function deeplyNested() {
+  if (a) {
+    if (b) {
+      if (c) {
+        if (d) {
+          if (e) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+}
+`,
+        nestingDepth: 5
+      }]
+    };
+    
+    const violations = deepNestingRule.check('test.ts', mockAdapterWithDeepNesting as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.deep-nesting');
+  });
+
+  it('should pass for function with acceptable nesting', () => {
+    const mockAdapterWithNormalNesting = {
+      ...mockAdapter,
+      extractFunctions: () => [{
+        name: 'normalNesting',
+        startLine: 1,
+        nestingDepth: 3
+      }]
+    };
+    
+    const violations = deepNestingRule.check('test.ts', mockAdapterWithNormalNesting as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(deepNestingRule.threshold).toBe(4);
+    expect(deepNestingRule.severity).toBe('warning');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractFunctions: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = deepNestingRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});

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

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { godClassRule } from '../../clean-code/god-class';
+
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: () => 0
+};
+
+describe('god-class.ts - God Class Rule', () => {
+  it('should detect class with more than 15 methods', () => {
+    const mockAdapterWithGodClass = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'GodClass',
+        line: 1,
+        code: `
+class GodClass {
+  method1() {}
+  method2() {}
+  method3() {}
+  method4() {}
+  method5() {}
+  method6() {}
+  method7() {}
+  method8() {}
+  method9() {}
+  method10() {}
+  method11() {}
+  method12() {}
+  method13() {}
+  method14() {}
+  method15() {}
+  method16() {}
+}
+`
+      }]
+    };
+    
+    const violations = godClassRule.check('test.ts', mockAdapterWithGodClass as never);
+    
+    expect(violations.length).toBe(1);
+    expect(violations[0].ruleId).toBe('clean-code.god-class');
+    expect(violations[0].message).toContain('GodClass');
+    expect(violations[0].message).toContain('16');
+  });
+
+  it('should pass for class with fewer than threshold methods', () => {
+    const mockAdapterWithSmallClass = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'SmallClass',
+        line: 1,
+        code: `
+class SmallClass {
+  method1() {}
+  method2() {}
+  method3() {}
+}
+`
+      }]
+    };
+    
+    const violations = godClassRule.check('test.ts', mockAdapterWithSmallClass as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should exclude getters and setters from count', () => {
+    const mockAdapterWithGetters = {
+      ...mockAdapter,
+      extractClasses: () => [{
+        name: 'DataClass',
+        line: 1,
+        code: `
+class DataClass {
+  get name() { return this._name; }
+  set name(value) { this._name = value; }
+  get age() { return this._age; }
+  set age(value) { this._age = value; }
+  method1() {}
+  method2() {}
+  method3() {}
+}
+`
+      }]
+    };
+    
+    const violations = godClassRule.check('test.ts', mockAdapterWithGetters as never);
+    
+    expect(violations.length).toBe(0);
+  });
+
+  it('should use threshold from config', () => {
+    expect(godClassRule.threshold).toBe(15);
+    expect(godClassRule.severity).toBe('warning');
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractClasses: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = godClassRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations.length).toBe(0);
+  });
+});

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

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { largeFileRule } from '../../clean-code/large-file';
+
+// Mock adapter for testing
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: (_fileName: string) => 10 // Default to small file
+};
+
+describe('largeFileRule', () => {
+  it('should return an empty array when file has fewer than 500 lines', () => {
+    const shortFileAdapter = {
+      ...mockAdapter,
+      countLines: () => 499
+    } as never;
+
+    const violations = largeFileRule.check('test-short.ts', shortFileAdapter);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('should detect files exceeding 650 lines', () => {
+    const largeFileAdapter: never = {
+      ...mockAdapter,
+      countLines: () => 651
+    };
+
+    const violations = largeFileRule.check('test-large.ts', largeFileAdapter);
+    expect(violations).toHaveLength(1);
+    expect(violations[0]).toEqual({
+      file: 'test-large.ts',
+      line: 1,
+      ruleId: 'clean-code.large-file',
+      message: 'File is too large: 651 lines (maximum: 650)',
+      severity: 'warning'
+    });
+  });
+
+  it('should handle exactly threshold lines as not violating', () => {
+    const thresholdFileAdapter: never = {
+      ...mockAdapter,
+      countLines: () => 650
+    };
+
+    const violations = largeFileRule.check('test-threshold.ts', thresholdFileAdapter);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('should use the correct rule identifier', () => {
+    expect(largeFileRule.id).toEqual('clean-code.large-file');
+  });
+
+  it('should have the correct severity', () => {
+    expect(largeFileRule.severity).toEqual('warning');
+  });
+
+  it('should use the correct threshold', () => {
+    expect(largeFileRule.threshold).toEqual(650);
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows: never = {
+      ...mockAdapter,
+      countLines: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = largeFileRule.check('test.ts', mockAdapterThatThrows);
+    
+    expect(violations).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { longFunctionRule } from '../../clean-code/long-function';
+
+// Mock adapter for testing
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: (content: string) => content.split('\n').length
+};
+
+describe('longFunctionRule', () => {
+  it('should return an empty array when no long function is detected', () => {
+    const mockShortAdapter = {
+      ...mockAdapter,
+      extractFunctions: () => [
+        { name: 'shortFunction', startLine: 1, endLine: 40, length: 40 }
+      ]
+    };
+
+    const violations = longFunctionRule.check('test.ts', mockShortAdapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('should detect long functions exceeding 50 lines', () => {
+    const mockLongAdapter = {
+      ...mockAdapter,
+      extractFunctions: () => [
+        { name: 'veryLongFunction', startLine: 1, endLine: 55, length: 55 }
+      ]
+    };
+
+    const violations = longFunctionRule.check('test.ts', mockLongAdapter as never);
+    expect(violations).toHaveLength(1);
+    expect(violations[0]).toEqual({
+      file: 'test.ts',
+      line: 1,
+      ruleId: 'clean-code.long-function',
+      message: 'Function "veryLongFunction" is too long: 55 lines (maximum: 50)',
+      severity: 'warning'
+    });
+  });
+
+  it('should handle multiple functions in a file', () => {
+    const mockMultiAdapter = {
+      ...mockAdapter,
+      extractFunctions: () => [
+        { name: 'shortFunction', startLine: 1, endLine: 4, length: 4 },
+        { name: 'alsoLongFunction', startLine: 6, endLine: 62, length: 57 }
+      ]
+    };
+
+    const violations = longFunctionRule.check('test.ts', mockMultiAdapter as never);
+    expect(violations).toHaveLength(1);
+    expect(violations[0].ruleId).toEqual('clean-code.long-function');
+    expect(violations[0].message).toContain('alsoLongFunction');
+    expect(violations[0].message).toContain('57 lines');
+  });
+
+  it('should use the correct rule identifier', () => {
+    expect(longFunctionRule.id).toEqual('clean-code.long-function');
+  });
+
+  it('should have the correct severity', () => {
+    expect(longFunctionRule.severity).toEqual('warning');
+  });
+
+  it('should use the correct threshold', () => {
+    expect(longFunctionRule.threshold).toEqual(50);
+  });
+
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractFunctions: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = longFunctionRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import { magicNumbersRule } from '../../clean-code/magic-numbers';
+
+// Mock adapter for testing
+const mockAdapter = {
+  detectLanguage: () => 'typescript',
+  parseAST: () => undefined,
+  extractFunctions: () => [],
+  extractClasses: () => [],
+  countLines: (_fileName: string) => 10
+};
+
+describe('magicNumbersRule', () => {
+  it('should return an empty array for code with only excluded safe values', () => {
+    const mockSafeAdapter = {
+      ...mockAdapter,
+      parseAST: () => undefined,
+      extract: () => []
+    };
+
+    const violations = magicNumbersRule.check('test-safe.ts', mockSafeAdapter as never);
+    expect(violations).toHaveLength(0);
+  });
+
+  it('should detect non-safe magic numbers', () => {
+    const mockUnsafeAdapter = {
+      ...mockAdapter,
+      parseAST: () => undefined,
+      extract: () => [
+        { value: 0.0875, line: 1 },
+        { value: 42, line: 2 },
+        { value: 99, line: 3 },
+        { value: 73, line: 4 }
+      ]
+    };
+
+    const violations = magicNumbersRule.check('test-unsafe.ts', mockUnsafeAdapter as never);
+    expect(violations).toHaveLength(4);
+    
+    expect(violations[0].message).toContain('0.0875');
+    expect(violations[1].message).toContain('42');
+    expect(violations[2].message).toContain('99');
+    expect(violations[3].message).toContain('73');
+    expect(violations[0].severity).toEqual('info');
+  });
+
+  it('should have the correct rule identifier', () => {
+    expect(magicNumbersRule.id).toEqual('clean-code.magic-numbers');
+  });
+
+  it('should have the correct severity', () => {
+    expect(magicNumbersRule.severity).toEqual('info');
+  });
+
+  it('should use the correct exclusion values', () => {
+    expect(magicNumbersRule.threshold).toEqual(10);
+  });
+});
+  it('should return empty violations when adapter throws error', () => {
+    const mockAdapterThatThrows = {
+      ...mockAdapter,
+      extractFunctions: () => { throw new Error('Adapter failed'); }
+    };
+    
+    const violations = magicNumbersRule.check('test.ts', mockAdapterThatThrows as never);
+    
+    expect(violations).toHaveLength(0);
+  });