@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.8

package/src/shared/metrics/code-metrics.ts

@@ -1,520 +0,0 @@
-/**
- * Agentic QE v3 - Code Metrics Analyzer
- * Real code analysis for complexity, maintainability, and quality metrics
- */
-
-import { TypeScriptParser, FunctionInfo, MethodInfo } from '../parsers';
-import { FileReader } from '../io';
-
-// ============================================================================
-// Types and Interfaces
-// ============================================================================
-
-export interface FileMetrics {
-  path: string;
-  linesOfCode: number;
-  linesOfComments: number;
-  blankLines: number;
-  cyclomaticComplexity: number;
-  cognitiveComplexity: number;
-  maintainabilityIndex: number;
-  halsteadMetrics: HalsteadMetrics;
-  functionCount: number;
-  classCount: number;
-  maxNestingDepth: number;
-}
-
-export interface HalsteadMetrics {
-  vocabulary: number;
-  length: number;
-  volume: number;
-  difficulty: number;
-  effort: number;
-}
-
-export interface FunctionMetrics {
-  name: string;
-  startLine: number;
-  endLine: number;
-  cyclomaticComplexity: number;
-  cognitiveComplexity: number;
-  parameterCount: number;
-  linesOfCode: number;
-}
-
-export interface DuplicationResult {
-  percentage: number;
-  duplicates: DuplicateBlock[];
-}
-
-export interface DuplicateBlock {
-  lines: number;
-  occurrences: number;
-  locations: Array<{ file: string; startLine: number; endLine: number }>;
-}
-
-// ============================================================================
-// Code Metrics Analyzer
-// ============================================================================
-
-export class CodeMetricsAnalyzer {
-  private readonly parser: TypeScriptParser;
-  private readonly fileReader: FileReader;
-
-  constructor() {
-    this.parser = new TypeScriptParser();
-    this.fileReader = new FileReader();
-  }
-
-  /**
-   * Analyze a single file for all metrics
-   */
-  async analyzeFile(filePath: string): Promise<FileMetrics | null> {
-    const contentResult = await this.fileReader.readFile(filePath);
-    if (!contentResult.success) {
-      return null;
-    }
-
-    const content = contentResult.value;
-    const lines = content.split('\n');
-
-    // Count different types of lines
-    const { codeLines, commentLines, blankLines } = this.countLines(lines);
-
-    // Parse the file for AST analysis
-    const fileName = filePath.split('/').pop() || filePath;
-    const ext = fileName.split('.').pop() || '';
-
-    let cyclomaticComplexity = 1;
-    let cognitiveComplexity = 0;
-    let maxNestingDepth = 0;
-    let functionCount = 0;
-    let classCount = 0;
-
-    // Only parse TypeScript/JavaScript files
-    if (['ts', 'tsx', 'js', 'jsx'].includes(ext)) {
-      try {
-        const ast = this.parser.parseFile(fileName, content);
-
-        // Extract functions and calculate complexity
-        const functions = this.parser.extractFunctions(ast);
-        functionCount = functions.length;
-
-        for (const func of functions) {
-          const funcMetrics = this.analyzeFunctionComplexity(content, func);
-          cyclomaticComplexity += funcMetrics.cyclomaticComplexity - 1; // -1 to avoid double counting base
-          cognitiveComplexity += funcMetrics.cognitiveComplexity;
-          maxNestingDepth = Math.max(maxNestingDepth, this.calculateNestingDepth(content, func));
-        }
-
-        // Extract classes
-        const classes = this.parser.extractClasses(ast);
-        classCount = classes.length;
-
-        // Add method complexity from classes
-        for (const cls of classes) {
-          for (const method of cls.methods) {
-            const funcMetrics = this.analyzeFunctionComplexity(content, method);
-            cyclomaticComplexity += funcMetrics.cyclomaticComplexity - 1;
-            cognitiveComplexity += funcMetrics.cognitiveComplexity;
-          }
-        }
-      } catch {
-        // If parsing fails, use heuristic analysis
-        cyclomaticComplexity = this.estimateCyclomaticComplexity(content);
-        cognitiveComplexity = this.estimateCognitiveComplexity(content);
-      }
-    } else {
-      // For non-TS/JS files, use heuristic analysis
-      cyclomaticComplexity = this.estimateCyclomaticComplexity(content);
-      cognitiveComplexity = this.estimateCognitiveComplexity(content);
-    }
-
-    // Calculate Halstead metrics
-    const halsteadMetrics = this.calculateHalsteadMetrics(content);
-
-    // Calculate maintainability index
-    const maintainabilityIndex = this.calculateMaintainabilityIndex(
-      halsteadMetrics.volume,
-      cyclomaticComplexity,
-      codeLines
-    );
-
-    return {
-      path: filePath,
-      linesOfCode: codeLines,
-      linesOfComments: commentLines,
-      blankLines,
-      cyclomaticComplexity,
-      cognitiveComplexity,
-      maintainabilityIndex,
-      halsteadMetrics,
-      functionCount,
-      classCount,
-      maxNestingDepth,
-    };
-  }
-
-  /**
-   * Analyze function-level metrics
-   */
-  analyzeFunctionComplexity(
-    content: string,
-    func: FunctionInfo | MethodInfo
-  ): FunctionMetrics {
-    const lines = content.split('\n');
-    const startLine = func.startLine;
-    const endLine = func.endLine;
-    const functionCode = lines.slice(startLine - 1, endLine).join('\n');
-
-    return {
-      name: func.name,
-      startLine,
-      endLine,
-      cyclomaticComplexity: this.calculateCyclomaticComplexity(functionCode),
-      cognitiveComplexity: this.calculateCognitiveComplexity(functionCode),
-      parameterCount: 'parameters' in func ? func.parameters.length : 0,
-      linesOfCode: endLine - startLine + 1,
-    };
-  }
-
-  /**
-   * Detect code duplication across files
-   */
-  async detectDuplication(
-    files: string[],
-    minLines: number = 5
-  ): Promise<DuplicationResult> {
-    const fileContents: Map<string, string[]> = new Map();
-    let totalLines = 0;
-    let duplicatedLines = 0;
-
-    // Read all files
-    for (const file of files) {
-      const result = await this.fileReader.readFile(file);
-      if (result.success) {
-        const lines = result.value.split('\n').map((l) => l.trim());
-        fileContents.set(file, lines);
-        totalLines += lines.length;
-      }
-    }
-
-    // Build line hash map for quick lookup
-    const lineHashes: Map<string, Array<{ file: string; line: number }>> = new Map();
-    const duplicates: DuplicateBlock[] = [];
-
-    for (const [file, lines] of fileContents.entries()) {
-      for (let i = 0; i < lines.length - minLines + 1; i++) {
-        // Create a hash of minLines consecutive lines
-        const block = lines.slice(i, i + minLines).join('\n');
-        if (block.length < 20) continue; // Skip very short blocks
-
-        const hash = this.hashString(block);
-        const existing = lineHashes.get(hash) || [];
-        existing.push({ file, line: i + 1 });
-        lineHashes.set(hash, existing);
-      }
-    }
-
-    // Find actual duplicates (blocks that appear more than once)
-    for (const [, locations] of lineHashes.entries()) {
-      if (locations.length > 1) {
-        duplicatedLines += minLines * (locations.length - 1);
-        duplicates.push({
-          lines: minLines,
-          occurrences: locations.length,
-          locations: locations.map((l) => ({
-            file: l.file,
-            startLine: l.line,
-            endLine: l.line + minLines - 1,
-          })),
-        });
-      }
-    }
-
-    // Limit duplicates to top 20 by occurrences
-    const sortedDuplicates = duplicates
-      .sort((a, b) => b.occurrences - a.occurrences)
-      .slice(0, 20);
-
-    return {
-      percentage: totalLines > 0 ? Math.round((duplicatedLines / totalLines) * 100 * 10) / 10 : 0,
-      duplicates: sortedDuplicates,
-    };
-  }
-
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-
-  private countLines(lines: string[]): {
-    codeLines: number;
-    commentLines: number;
-    blankLines: number;
-  } {
-    let codeLines = 0;
-    let commentLines = 0;
-    let blankLines = 0;
-    let inBlockComment = false;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      if (trimmed === '') {
-        blankLines++;
-        continue;
-      }
-
-      if (inBlockComment) {
-        commentLines++;
-        if (trimmed.includes('*/')) {
-          inBlockComment = false;
-        }
-        continue;
-      }
-
-      if (trimmed.startsWith('//')) {
-        commentLines++;
-      } else if (trimmed.startsWith('/*')) {
-        commentLines++;
-        if (!trimmed.includes('*/')) {
-          inBlockComment = true;
-        }
-      } else {
-        codeLines++;
-        // Also count inline comments
-        if (trimmed.includes('//') || trimmed.includes('/*')) {
-          commentLines++;
-        }
-      }
-    }
-
-    return { codeLines, commentLines, blankLines };
-  }
-
-  private calculateCyclomaticComplexity(code: string): number {
-    // Count decision points
-    const decisionPatterns = [
-      /\bif\s*\(/g,
-      /\belse\s+if\s*\(/g,
-      /\bfor\s*\(/g,
-      /\bwhile\s*\(/g,
-      /\bcase\s+/g,
-      /\bcatch\s*\(/g,
-      /\?\s*[^:]/g, // Ternary operator
-      /&&/g,
-      /\|\|/g,
-      /\?\?/g, // Nullish coalescing
-    ];
-
-    let complexity = 1; // Base complexity
-
-    for (const pattern of decisionPatterns) {
-      const matches = code.match(pattern);
-      if (matches) {
-        complexity += matches.length;
-      }
-    }
-
-    return complexity;
-  }
-
-  private calculateCognitiveComplexity(code: string): number {
-    let complexity = 0;
-    let nestingLevel = 0;
-    const lines = code.split('\n');
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-
-      // Increase nesting
-      if (/\bif\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-        nestingLevel++;
-      }
-      if (/\belse\s+if\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-      }
-      if (/\belse\s*{/.test(trimmed)) {
-        complexity += 1;
-      }
-      if (/\bfor\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-        nestingLevel++;
-      }
-      if (/\bwhile\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-        nestingLevel++;
-      }
-      if (/\bswitch\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-        nestingLevel++;
-      }
-      if (/\bcatch\s*\(/.test(trimmed)) {
-        complexity += 1 + nestingLevel;
-        nestingLevel++;
-      }
-      if (/\?\s*[^:]/.test(trimmed)) {
-        complexity += 1 + nestingLevel; // Ternary
-      }
-      if (/&&|\|\|/.test(trimmed)) {
-        complexity += 1; // Boolean operators
-      }
-
-      // Track nesting via braces (simplified)
-      const openBraces = (trimmed.match(/{/g) || []).length;
-      const closeBraces = (trimmed.match(/}/g) || []).length;
-      nestingLevel = Math.max(0, nestingLevel + openBraces - closeBraces);
-    }
-
-    return complexity;
-  }
-
-  private estimateCyclomaticComplexity(code: string): number {
-    // Fallback heuristic for non-parseable code
-    return this.calculateCyclomaticComplexity(code);
-  }
-
-  private estimateCognitiveComplexity(code: string): number {
-    // Fallback heuristic for non-parseable code
-    return this.calculateCognitiveComplexity(code);
-  }
-
-  private calculateNestingDepth(content: string, func: FunctionInfo | MethodInfo): number {
-    const lines = content.split('\n');
-    const functionCode = lines.slice(func.startLine - 1, func.endLine).join('\n');
-
-    let maxDepth = 0;
-    let currentDepth = 0;
-
-    for (const char of functionCode) {
-      if (char === '{') {
-        currentDepth++;
-        maxDepth = Math.max(maxDepth, currentDepth);
-      } else if (char === '}') {
-        currentDepth = Math.max(0, currentDepth - 1);
-      }
-    }
-
-    return maxDepth;
-  }
-
-  private calculateHalsteadMetrics(code: string): HalsteadMetrics {
-    // Extract operators and operands
-    const operators = new Set<string>();
-    const operands = new Set<string>();
-    let totalOperators = 0;
-    let totalOperands = 0;
-
-    // Common operators
-    const operatorPatterns = [
-      /[+\-*/%]=?/g,
-      /[<>]=?/g,
-      /[!=]=?=?/g,
-      /&&|\|\|/g,
-      /\+\+|--/g,
-      /\./g,
-      /,/g,
-      /:/g,
-      /\?/g,
-      /=>/g,
-    ];
-
-    for (const pattern of operatorPatterns) {
-      const matches = code.match(pattern);
-      if (matches) {
-        for (const match of matches) {
-          operators.add(match);
-          totalOperators++;
-        }
-      }
-    }
-
-    // Extract identifiers as operands
-    const identifierPattern = /\b[a-zA-Z_][a-zA-Z0-9_]*\b/g;
-    const keywords = new Set([
-      'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break',
-      'continue', 'return', 'function', 'class', 'const', 'let', 'var',
-      'new', 'this', 'true', 'false', 'null', 'undefined', 'typeof',
-      'import', 'export', 'default', 'from', 'async', 'await', 'try',
-      'catch', 'finally', 'throw', 'interface', 'type', 'extends',
-    ]);
-
-    const identifiers = code.match(identifierPattern);
-    if (identifiers) {
-      for (const id of identifiers) {
-        if (!keywords.has(id)) {
-          operands.add(id);
-          totalOperands++;
-        }
-      }
-    }
-
-    const n1 = operators.size; // Distinct operators
-    const n2 = operands.size;  // Distinct operands
-    const N1 = totalOperators; // Total operators
-    const N2 = totalOperands;  // Total operands
-
-    const vocabulary = n1 + n2;
-    const length = N1 + N2;
-    const volume = length > 0 && vocabulary > 0 ? length * Math.log2(vocabulary) : 0;
-    const difficulty = n2 > 0 ? (n1 / 2) * (N2 / n2) : 0;
-    const effort = volume * difficulty;
-
-    return {
-      vocabulary,
-      length,
-      volume: Math.round(volume * 100) / 100,
-      difficulty: Math.round(difficulty * 100) / 100,
-      effort: Math.round(effort * 100) / 100,
-    };
-  }
-
-  private calculateMaintainabilityIndex(
-    halsteadVolume: number,
-    cyclomaticComplexity: number,
-    linesOfCode: number
-  ): number {
-    // Standard Maintainability Index formula (Microsoft variant)
-    // MI = 171 - 5.2 * ln(V) - 0.23 * CC - 16.2 * ln(LOC)
-    // Normalized to 0-100 scale
-
-    if (linesOfCode <= 0 || halsteadVolume <= 0) {
-      return 100; // Perfect score for empty/trivial code
-    }
-
-    const lnVolume = Math.log(halsteadVolume);
-    const lnLOC = Math.log(linesOfCode);
-
-    const rawMI = 171 - 5.2 * lnVolume - 0.23 * cyclomaticComplexity - 16.2 * lnLOC;
-
-    // Normalize to 0-100
-    const normalizedMI = Math.max(0, Math.min(100, rawMI * 100 / 171));
-
-    return Math.round(normalizedMI * 100) / 100;
-  }
-
-  private hashString(str: string): string {
-    // Simple hash for duplication detection
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash; // Convert to 32-bit integer
-    }
-    return hash.toString(16);
-  }
-}
-
-// ============================================================================
-// Singleton Instance
-// ============================================================================
-
-let defaultAnalyzer: CodeMetricsAnalyzer | null = null;
-
-export function getCodeMetricsAnalyzer(): CodeMetricsAnalyzer {
-  if (!defaultAnalyzer) {
-    defaultAnalyzer = new CodeMetricsAnalyzer();
-  }
-  return defaultAnalyzer;
-}

package/src/shared/metrics/index.ts

@@ -1,23 +0,0 @@
-/**
- * Agentic QE v3 - Metrics Module
- * Exports for code quality and system metrics analysis
- */
-
-export { CodeMetricsAnalyzer, getCodeMetricsAnalyzer } from './code-metrics';
-export type {
-  FileMetrics,
-  FunctionMetrics,
-  HalsteadMetrics,
-  DuplicationResult,
-  DuplicateBlock,
-} from './code-metrics';
-
-export { SystemMetricsCollector, getSystemMetricsCollector } from './system-metrics';
-export type {
-  SystemMetrics,
-  CpuMetrics,
-  MemoryMetrics,
-  ProcessMetrics,
-  MetricSample,
-  HttpMetrics,
-} from './system-metrics';