@boyingliu01/xp-gate 0.8.8 → 0.8.10

package/principles/adapters/objectivec.ts

@@ -0,0 +1,82 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+/**
+ * Objective-C Adapter
+ * Supports .m (Objective-C) and .mm (Objective-C++) files
+ */
+export class ObjectiveCAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.m') || ext.endsWith('.mm')) {
+      return 'objectivec';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return {
+      content: this.fileContent,
+      language: 'objectivec',
+      filePath: this.filePath
+    };
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const methodRegex = /[-+]\s*\([^)]+\)\s*(\w+)\s*(?::[^;{]+)?/g;
+    let match;
+
+    while ((match = methodRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push({
+        name: match[1],
+        type: 'method',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    const cFunctionRegex = /^(?:static\s+)?(?:inline\s+)?(?:\w+\s+)+(\w+)\s*\([^)]*\)\s*\{/gm;
+    while ((match = cFunctionRegex.exec(this.fileContent)) !== null) {
+      if (this.fileContent.substring(match.index).startsWith('-') ||
+          this.fileContent.substring(match.index).startsWith('+')) {
+        continue;
+      }
+      functionMatches.push({
+        name: match[1],
+        type: 'function',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const implRegex = /@implementation\s+(\w+)/g;
+    let match;
+
+    while ((match = implRegex.exec(this.fileContent)) !== null) {
+      classMatches.push({
+        name: match[1],
+        type: 'implementation',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    const interfaceRegex = /@interface\s+(\w+)/g;
+    while ((match = interfaceRegex.exec(this.fileContent)) !== null) {
+      classMatches.push({
+        name: match[1],
+        type: 'interface',
+        line: this.getLineNumber(match.index),
+        code: this.extractCodeBlock(match.index)
+      });
+    }
+
+    return classMatches;
+  }
+}

package/principles/adapters/python.ts

@@ -0,0 +1,83 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class PythonAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.py')) {
+      return 'python';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return {
+      content: this.fileContent,
+      language: 'python',
+      filePath: this.filePath
+    };
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /(async\s+)?def\s+(\w+)\s*\([^)]*\)\s*:/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push({
+        name: match[2],
+        type: match[1] ? 'async_function' : 'function',
+        line: this.getLineNumber(match.index),
+        code: this.getCodeBlock(match.index)
+      });
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /class\s+(\w+)(\s*\([^)]*\))?\s*:/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push({
+        name: match[1],
+        type: 'class',
+        line: this.getLineNumber(match.index),
+        code: this.getCodeBlock(match.index)
+      });
+    }
+
+    return classMatches;
+  }
+
+  private getCodeBlock(startPos: number): string {
+    const lines = this.fileContent.split('\n');
+    const startLine = this.getLineNumber(startPos) - 1;
+    
+    const codeLines = [];
+    let indentLevel = -1;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      if (i === startLine) {
+        indentLevel = line.search(/\S/);
+        codeLines.push(line);
+      } else {
+        const currentIndent = line.search(/\S/);
+        
+        if (line.trim() === '' || currentIndent > indentLevel) {
+          codeLines.push(line);
+        } else if (currentIndent >= 0 && currentIndent <= indentLevel) {
+          break;
+        }
+      }
+      
+      if (codeLines.length > 50) break;
+    }
+    
+    return codeLines.join('\n');
+  }
+}

package/principles/adapters/swift.ts

@@ -0,0 +1,40 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class SwiftAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.swift')) {
+      return 'swift';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return this.createParseResult('swift');
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /func\s+(\w+)\s*\([^)]*\)/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push(this.createCodeMatch(match[1], 'function', match.index));
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /class\s+(\w+)/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push(this.createCodeMatch(match[1], 'class', match.index));
+    }
+
+    return classMatches;
+  }
+}

package/principles/adapters/typescript.ts

@@ -0,0 +1,66 @@
+import { BaseAdapter } from './base';
+import { Adapter } from '../types';
+
+export class TypeScriptAdapter extends BaseAdapter implements Adapter {
+  detectLanguage(): string {
+    const ext = this.filePath.toLowerCase();
+    if (ext.endsWith('.ts') || ext.endsWith('.tsx')) {
+      return 'typescript';
+    }
+    return super.detectLanguage();
+  }
+
+  parseAST(): unknown {
+    return this.createParseResult('typescript');
+  }
+
+  extractFunctions(): unknown[] {
+    const functionMatches = [];
+    const fnRegex = /(export\s+)?(async\s+)?function\s+(\w+)\s*\([^)]*\)\s*[:\w\s]*{/g;
+    let match;
+
+    while ((match = fnRegex.exec(this.fileContent)) !== null) {
+      functionMatches.push(this.createCodeMatch(match[3], 'function', match.index));
+    }
+
+    return functionMatches;
+  }
+
+  extractClasses(): unknown[] {
+    const classMatches = [];
+    const classRegex = /(export\s+)?class\s+(\w+)\s*(extends\s+[\w.]+)?\s*{/g;
+    let match;
+
+    while ((match = classRegex.exec(this.fileContent)) !== null) {
+      classMatches.push(this.createCodeMatch(match[2], 'class', match.index));
+    }
+
+    return classMatches;
+  }
+
+  extractExports(): unknown[] {
+    const exportMatches = [];
+    const exportRegex = /^(export\s+(default\s+)?(async\s+)?(function|const|class|let|var|type|interface|enum)\s+\w+)/gm;
+    let match;
+
+    while ((match = exportRegex.exec(this.fileContent)) !== null) {
+      exportMatches.push({
+        name: match[0],
+        type: 'export',
+        line: this.getLineNumber(match.index)
+      });
+    }
+
+    const reExportRegex = /^export\s*{/gm;
+    let reMatch;
+    while ((reMatch = reExportRegex.exec(this.fileContent)) !== null) {
+      exportMatches.push({
+        name: reMatch[0],
+        type: 're-export',
+        line: this.getLineNumber(reMatch.index)
+      });
+    }
+
+    return exportMatches;
+  }
+}

package/principles/analyzer.ts

@@ -0,0 +1,190 @@
+import { Rule, Violation, Adapter } from './types';
+import { TypeScriptAdapter } from './adapters/typescript';
+import { PythonAdapter } from './adapters/python';
+import { GoAdapter } from './adapters/go';
+import { JavaAdapter } from './adapters/java';
+import { KotlinAdapter } from './adapters/kotlin';
+import { DartAdapter } from './adapters/dart';
+import { SwiftAdapter } from './adapters/swift';
+import { ObjectiveCAdapter } from './adapters/objectivec';
+import { CppAdapter } from './adapters/cpp';
+import { extname } from 'path';
+
+export type { Violation } from './types';
+export interface AnalysisOptions {
+  enabledRules?: string[];
+}
+
+export interface FileResult {
+  violations: Violation[];
+  ruleIds: string[];
+}
+
+export interface RuleResult {
+  violationCount: number;
+  filesChecked: number;
+}
+
+export interface AnalysisSummary {
+  totalViolations: number;
+  errorCount: number;
+  warningCount: number;
+  infoCount: number;
+  filesChecked: number;
+  rulesRun: number;
+}
+
+export interface AnalysisResult {
+  violations: Violation[];
+  summary: AnalysisSummary;
+  fileResults: Record<string, FileResult>;
+  ruleResults: Record<string, RuleResult>;
+  executionTimeMs: number;
+  errors: string[];
+}
+
+export type AdapterFactory = (filePath: string) => Adapter | null;
+
+export function getAdapterForFile(filePath: string): Adapter | null {
+  const ext = extname(filePath).toLowerCase();
+  
+  const adapterMap: Record<string, new (filePath: string) => Adapter> = {
+    '.ts': TypeScriptAdapter,
+    '.tsx': TypeScriptAdapter,
+    '.js': TypeScriptAdapter,
+    '.jsx': TypeScriptAdapter,
+    '.py': PythonAdapter,
+    '.go': GoAdapter,
+    '.java': JavaAdapter,
+    '.kt': KotlinAdapter,
+    '.kts': KotlinAdapter,
+    '.dart': DartAdapter,
+    '.swift': SwiftAdapter,
+    '.m': ObjectiveCAdapter,
+    '.mm': ObjectiveCAdapter,
+    '.cpp': CppAdapter,
+    '.cxx': CppAdapter,
+    '.cc': CppAdapter,
+    '.c': CppAdapter,
+    '.hpp': CppAdapter,
+    '.h': CppAdapter,
+  };
+  
+  const AdapterClass = adapterMap[ext];
+  if (!AdapterClass) {
+    return null;
+  }
+  
+  return new AdapterClass(filePath);
+}
+
+function resolveAdapter(
+  file: string,
+  adapterOrFactory: Adapter | AdapterFactory,
+): Adapter | null {
+  if (typeof adapterOrFactory === 'function') {
+    return adapterOrFactory(file);
+  }
+  return adapterOrFactory;
+}
+
+function computeSummary(
+  violations: Violation[],
+  fileResults: Record<string, FileResult>,
+  rulesToRun: Rule[],
+): AnalysisSummary {
+  let errorCount = 0;
+  let warningCount = 0;
+  let infoCount = 0;
+  for (const v of violations) {
+    if (v.severity === 'error') errorCount++;
+    else if (v.severity === 'warning') warningCount++;
+    else infoCount++;
+  }
+  return {
+    totalViolations: violations.length,
+    errorCount,
+    warningCount,
+    infoCount,
+    filesChecked: Object.keys(fileResults).length,
+    rulesRun: rulesToRun.length,
+  };
+}
+
+function runRuleOnFile(ctx: RunRuleContext): void {
+  const { file, rule, adapter, violations, fileResult, ruleResult, errors } = ctx;
+  ruleResult.filesChecked++;
+  try {
+    const ruleViolations = rule.check(file, adapter);
+    if (ruleViolations.length > 0) {
+      violations.push(...ruleViolations);
+      fileResult.violations.push(...ruleViolations);
+      fileResult.ruleIds.push(rule.id);
+      ruleResult.violationCount += ruleViolations.length;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    errors.push(`Rule ${rule.id} failed on ${file}: ${msg}`);
+  }
+}
+
+interface RunRuleContext {
+  file: string;
+  rule: Rule;
+  adapter: Adapter;
+  violations: Violation[];
+  fileResult: FileResult;
+  ruleResult: RuleResult;
+  errors: string[];
+}
+
+export async function analyze(
+  files: string[],
+  rules: Rule[],
+  adapterOrFactory: Adapter | AdapterFactory,
+  options?: AnalysisOptions
+): Promise<AnalysisResult> {
+  const startTime = Date.now();
+  const errors: string[] = [];
+  const violations: Violation[] = [];
+  const fileResults: Record<string, FileResult> = {};
+  const ruleResults: Record<string, RuleResult> = {};
+
+  const enabledRules = options?.enabledRules ?? rules.map(r => r.id);
+  const rulesToRun = rules.filter(r => enabledRules.includes(r.id));
+
+  for (const rule of rulesToRun) {
+    ruleResults[rule.id] = { violationCount: 0, filesChecked: 0 };
+  }
+
+  for (const file of files) {
+    const adapter = resolveAdapter(file, adapterOrFactory);
+    if (!adapter || adapter.detectLanguage() === 'unknown') continue;
+
+    const fileResult: FileResult = { violations: [], ruleIds: [] };
+    fileResults[file] = fileResult;
+
+    for (const rule of rulesToRun) {
+      runRuleOnFile({
+        file,
+        rule,
+        adapter,
+        violations,
+        fileResult,
+        ruleResult: ruleResults[rule.id],
+        errors,
+      });
+    }
+  }
+
+  const summary = computeSummary(violations, fileResults, rulesToRun);
+
+  return {
+    violations,
+    summary,
+    fileResults,
+    ruleResults,
+    executionTimeMs: Date.now() - startTime,
+    errors,
+  };
+}