tech-debt-score 0.1.5 → 0.1.7

package/src/application/services/AnalysisService.ts

@@ -1,218 +0,0 @@
-/**
- * Application Service: Analysis Service
- * Orchestrates the entire code analysis workflow
- */
-
-import type { IFileReader } from '../ports/IFileReader.js';
-import type { IParser } from '../ports/IParser.js';
-import type { IReporter, AnalysisReport } from '../ports/IReporter.js';
-import type { AnalysisConfig } from '../config/AnalysisConfig.js';
-import type { Rule } from '../../domain/entities/Rule.js';
-import type { Metric } from '../../domain/entities/Metric.js';
-import type { Finding } from '../../domain/entities/Finding.js';
-import type { CategoryScore, Score } from '../../domain/entities/Score.js';
-import { ScoreCalculator } from '../../domain/entities/Score.js';
-
-export class AnalysisService {
-  constructor(
-    private readonly fileReader: IFileReader,
-    private readonly parser: IParser,
-    private readonly rules: Rule[],
-    private readonly reporter: IReporter
-  ) {}
-
-  /**
-   * Run the complete analysis workflow
-   */
-  async analyze(config: AnalysisConfig): Promise<AnalysisReport> {
-    const startTime = Date.now();
-
-    // 1. Scan for files
-    console.log('📁 Scanning files...');
-    const filePaths = await this.fileReader.scan(
-      config.rootPath,
-      config.patterns,
-      config.ignore
-    );
-
-    if (filePaths.length === 0) {
-      console.log('   ❌ No files found matching patterns.');
-      console.log(`      Root: ${config.rootPath}`);
-      console.log(`      Patterns: ${config.patterns.join(', ')}`);
-      console.log('      Check your directory structure and ensure files exist.');
-    } else {
-      console.log(`   Found ${filePaths.length} files`);
-    }
-
-    // 2. Read and parse files
-    console.log('🔍 Parsing files...');
-    const allMetrics: Metric[] = [];
-    const fileContents = new Map<string, string>();
-    
-    let supportedFilesCount = 0;
-    for (const filePath of filePaths) {
-      try {
-        const fileResult = await this.fileReader.read(filePath);
-        fileContents.set(filePath, fileResult.content);
-        
-        if (this.parser.supports(filePath)) {
-          supportedFilesCount++;
-          const parseResult = await this.parser.parse(filePath, fileResult.content);
-          if (parseResult.success) {
-            allMetrics.push(...parseResult.metrics);
-          } else {
-            console.warn(`   ⚠️  Failed to parse ${filePath}: ${parseResult.error}`);
-          }
-        }
-      } catch (err) {
-        console.warn(`   ⚠️  Error reading ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-      }
-    }
-    
-    if (filePaths.length > 0 && supportedFilesCount === 0) {
-      console.log('   ⚠️  None of the found files are supported by the parser (.ts, .js, etc)');
-    }
-    
-    console.log(`   Extracted ${allMetrics.length} metrics from ${supportedFilesCount} files`);
-
-    // 3. Analyze dependencies and duplication
-    console.log('🔗 Analyzing dependencies and duplication...');
-    const additionalMetrics = await this.analyzeAdvancedMetrics(fileContents);
-    allMetrics.push(...additionalMetrics);
-    console.log(`   Added ${additionalMetrics.length} advanced metrics`);
-
-    // 4. Apply rules and collect findings
-    console.log('📊 Applying rules...');
-    const allFindings: Finding[] = [];
-    const rawCategoryScores: CategoryScore[] = [];
-
-    for (const rule of this.rules) {
-      const findings = rule.evaluate(allMetrics);
-      allFindings.push(...findings);
-      
-      const score = rule.calculateScore(findings);
-      rawCategoryScores.push({
-        name: rule.name,
-        score,
-        weight: this.getCategoryWeight(rule.id, config),
-        description: rule.description,
-      });
-    }
-    console.log(`   Generated ${allFindings.length} findings`);
-
-    // Normalize weights to sum to 1.0 (in case not all categories are active)
-    const categoryScores = this.normalizeWeights(rawCategoryScores);
-
-    // 5. Calculate overall score
-    console.log('🎯 Calculating score...');
-    const overallScore = ScoreCalculator.calculateOverall(categoryScores);
-
-    const finalScore: Score = {
-      overall: overallScore,
-      categories: categoryScores,
-      timestamp: new Date(),
-      metadata: {
-        filesAnalyzed: filePaths.length,
-        totalMetrics: allMetrics.length,
-        totalFindings: allFindings.length,
-      },
-    };
-
-    // 6. Prepare report
-    const duration = Date.now() - startTime;
-    const report: AnalysisReport = {
-      score: finalScore,
-      findings: allFindings,
-      metadata: {
-        filesAnalyzed: filePaths.length,
-        duration,
-        timestamp: new Date(),
-      },
-    };
-
-    // 7. Generate output
-    console.log('📋 Generating report...');
-    await this.reporter.generate(report);
-
-    return report;
-  }
-
-  /**
-   * Analyze dependencies and code duplication
-   */
-  private async analyzeAdvancedMetrics(fileContents: Map<string, string>): Promise<Metric[]> {
-    const { DependencyAnalyzer } = await import('./DependencyAnalyzer.js');
-    const { DuplicationDetector } = await import('./DuplicationDetector.js');
-    
-    const depAnalyzer = new DependencyAnalyzer();
-    const dupDetector = new DuplicationDetector();
-    const metrics: Metric[] = [];
-
-    // Analyze all files
-    for (const [filePath, content] of fileContents.entries()) {
-      if (filePath.endsWith('.ts') || filePath.endsWith('.tsx') || 
-          filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
-        depAnalyzer.analyzeDependencies(filePath, content);
-        dupDetector.analyzeFile(filePath, content);
-      }
-    }
-
-    // Detect circular dependencies
-    const circularDeps = depAnalyzer.detectCircularDependencies();
-    metrics.push(...circularDeps);
-
-    // Detect code duplication
-    const duplicates = dupDetector.detectDuplicates();
-    metrics.push(...duplicates);
-
-    return metrics;
-  }
-
-  private getCategoryWeight(ruleId: string, config: AnalysisConfig): number {
-    const weights = config.weights ?? {
-      complexity: 0.30,
-      size: 0.25,
-      typeSafety: 0.20,
-      codeQuality: 0.15,
-      structure: 0.10,
-    };
-
-    switch (ruleId) {
-      case 'complexity':
-        return weights.complexity;
-      case 'size':
-        return weights.size;
-      case 'type-safety':
-        return weights.typeSafety;
-      case 'duplication':
-        return weights.codeQuality;
-      case 'circular-dependency':
-        return weights.structure;
-      default:
-        return 0.05; // Default weight for unknown categories
-    }
-  }
-
-  /**
-   * Normalize weights so they sum to 1.0
-   * This handles cases where not all categories are active
-   */
-  private normalizeWeights(categories: CategoryScore[]): CategoryScore[] {
-    const totalWeight = categories.reduce((sum, cat) => sum + cat.weight, 0);
-    
-    if (totalWeight === 0) {
-      // If all weights are 0, distribute evenly
-      const evenWeight = 1.0 / categories.length;
-      return categories.map(cat => ({
-        ...cat,
-        weight: evenWeight,
-      }));
-    }
-
-    // Normalize proportionally
-    return categories.map(cat => ({
-      ...cat,
-      weight: cat.weight / totalWeight,
-    }));
-  }
-}

package/src/application/services/DependencyAnalyzer.ts

@@ -1,158 +0,0 @@
-/**
- * Application Service: Dependency Analyzer
- * Analyzes import/require statements to detect circular dependencies
- */
-
-import * as ts from 'typescript';
-import { resolve, dirname, join } from 'node:path';
-import type { Metric } from '../../domain/entities/Metric.js';
-import { MetricBuilder } from '../../domain/entities/Metric.js';
-
-interface DependencyNode {
-  filePath: string;
-  imports: string[];
-}
-
-export class DependencyAnalyzer {
-  private dependencyGraph: Map<string, DependencyNode> = new Map();
-
-  /**
-   * Analyze files for import statements and build dependency graph
-   */
-  analyzeDependencies(filePath: string, content: string): void {
-    const sourceFile = ts.createSourceFile(
-      filePath,
-      content,
-      ts.ScriptTarget.Latest,
-      true
-    );
-
-    const imports: string[] = [];
-
-    // Extract import statements
-    const visit = (node: ts.Node): void => {
-      if (ts.isImportDeclaration(node)) {
-        const moduleSpecifier = node.moduleSpecifier;
-        if (ts.isStringLiteral(moduleSpecifier)) {
-          const importPath = this.resolveImportPath(filePath, moduleSpecifier.text);
-          if (importPath) {
-            imports.push(importPath);
-          }
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-
-    visit(sourceFile);
-
-    this.dependencyGraph.set(filePath, {
-      filePath,
-      imports,
-    });
-  }
-
-  /**
-   * Detect circular dependencies using DFS
-   */
-  detectCircularDependencies(): Metric[] {
-    const metrics: Metric[] = [];
-    const visited = new Set<string>();
-    const recursionStack = new Set<string>();
-    const cycles = new Set<string>(); // Track unique cycles
-
-    const dfs = (filePath: string, path: string[]): void => {
-      if (cycles.has(filePath)) return; // Already found this cycle
-      
-      visited.add(filePath);
-      recursionStack.add(filePath);
-
-      const node = this.dependencyGraph.get(filePath);
-      if (!node) {
-        recursionStack.delete(filePath);
-        return;
-      }
-
-      for (const importPath of node.imports) {
-        if (!visited.has(importPath)) {
-          dfs(importPath, [...path, filePath]);
-        } else if (recursionStack.has(importPath)) {
-          // Found a cycle!
-          const cycleStart = path.indexOf(importPath);
-          if (cycleStart !== -1) {
-            const cycle = [...path.slice(cycleStart), importPath];
-            const cycleKey = [...cycle].sort().join('->');
-            
-            if (!cycles.has(cycleKey)) {
-              cycles.add(cycleKey);
-              
-              // Create metric for this cycle
-              metrics.push(
-                new MetricBuilder()
-                  .withName('circular-dependency')
-                  .withValue(cycle.length)
-                  .withFilePath(filePath)
-                  .withContext(cycle.map(p => this.getFileName(p)).join(' → '))
-                  .build()
-              );
-            }
-          }
-        }
-      }
-
-      recursionStack.delete(filePath);
-    };
-
-    // Check all nodes for cycles
-    for (const filePath of this.dependencyGraph.keys()) {
-      if (!visited.has(filePath)) {
-        dfs(filePath, []);
-      }
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Resolve relative import to absolute path
-   */
-  private resolveImportPath(fromFile: string, importSpecifier: string): string | null {
-    // Skip node_modules and external packages
-    if (!importSpecifier.startsWith('.')) {
-      return null;
-    }
-
-    try {
-      const dir = dirname(fromFile);
-      let resolvedPath = resolve(dir, importSpecifier);
-
-      // Try adding extensions if file doesn't exist
-      const extensions = ['.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.js'];
-      for (const ext of extensions) {
-        const pathWithExt = resolvedPath + ext;
-        // We can't check if file exists in this context, so just normalize
-        if (ext.startsWith('/')) {
-          return resolvedPath + ext;
-        }
-      }
-
-      return resolvedPath + '.ts'; // Default to .ts
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Get file name from path for display
-   */
-  private getFileName(filePath: string): string {
-    const parts = filePath.split('/');
-    return parts[parts.length - 1] ?? filePath;
-  }
-
-  /**
-   * Clear the dependency graph (useful for new analysis)
-   */
-  clear(): void {
-    this.dependencyGraph.clear();
-  }
-}

package/src/application/services/DuplicationDetector.ts

@@ -1,207 +0,0 @@
-/**
- * Application Service: Code Duplication Detector
- * Detects duplicate code blocks using token-based similarity
- */
-
-import * as ts from 'typescript';
-import type { Metric } from '../../domain/entities/Metric.js';
-import { MetricBuilder } from '../../domain/entities/Metric.js';
-
-interface CodeBlock {
-  filePath: string;
-  tokens: string;
-  startLine: number;
-  endLine: number;
-  functionName?: string | undefined;
-}
-
-export class DuplicationDetector {
-  private codeBlocks: CodeBlock[] = [];
-  private readonly MIN_BLOCK_SIZE = 50; // Minimum token count
-
-  /**
-   * Analyze file for code blocks
-   */
-  analyzeFile(filePath: string, content: string): void {
-    const sourceFile = ts.createSourceFile(
-      filePath,
-      content,
-      ts.ScriptTarget.Latest,
-      true
-    );
-
-    // Extract function bodies as code blocks
-    const visit = (node: ts.Node): void => {
-      if (this.isFunctionNode(node)) {
-        const block = this.extractCodeBlock(sourceFile, filePath, node);
-        if (block && block.tokens.length >= this.MIN_BLOCK_SIZE) {
-          this.codeBlocks.push(block);
-        }
-      }
-      ts.forEachChild(node, visit);
-    };
-
-    visit(sourceFile);
-  }
-
-  /**
-   * Detect duplicates across all analyzed files
-   */
-  detectDuplicates(): Metric[] {
-    const metrics: Metric[] = [];
-    const seen = new Set<number>();
-
-    for (let i = 0; i < this.codeBlocks.length; i++) {
-      if (seen.has(i)) continue;
-
-      const block1 = this.codeBlocks[i];
-      if (!block1) continue;
-
-      let duplicateCount = 0;
-
-      for (let j = i + 1; j < this.codeBlocks.length; j++) {
-        if (seen.has(j)) continue;
-
-        const block2 = this.codeBlocks[j];
-        if (!block2) continue;
-
-        const similarity = this.calculateSimilarity(block1.tokens, block2.tokens);
-
-        if (similarity >= 0.85) { // 85% similarity threshold
-          duplicateCount++;
-          seen.add(j);
-        }
-      }
-
-      if (duplicateCount > 0) {
-        metrics.push(
-          new MetricBuilder()
-            .withName('code-duplication')
-            .withValue(duplicateCount)
-            .withFilePath(block1.filePath)
-            .withContext(block1.functionName || 'code block')
-            .withLocation({
-              startLine: block1.startLine,
-              endLine: block1.endLine,
-              startColumn: 0,
-              endColumn: 0,
-            })
-            .build()
-        );
-      }
-    }
-
-    return metrics;
-  }
-
-  /**
-   * Extract code block from function node
-   */
-  private extractCodeBlock(
-    sourceFile: ts.SourceFile,
-    filePath: string,
-    node: ts.Node
-  ): CodeBlock | null {
-    const start = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const end = sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-
-    // Tokenize the code (simple whitespace normalization)
-    const text = node.getText(sourceFile);
-    const tokens = this.tokenize(text);
-
-    return {
-      filePath,
-      tokens,
-      startLine: start.line + 1,
-      endLine: end.line + 1,
-      functionName: this.getFunctionName(node),
-    };
-  }
-
-  /**
-   * Simple tokenization (normalize whitespace)
-   */
-  private tokenize(code: string): string {
-    return code
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
-      .replace(/\/\/.*/g, '') // Remove line comments
-      .trim();
-  }
-
-  /**
-   * Calculate similarity between two token strings
-   */
-  private calculateSimilarity(tokens1: string, tokens2: string): number {
-    if (tokens1 === tokens2) return 1.0;
-
-    // Use Levenshtein distance for similarity
-    const len1 = tokens1.length;
-    const len2 = tokens2.length;
-    const maxLen = Math.max(len1, len2);
-
-    if (maxLen === 0) return 1.0;
-
-    const distance = this.levenshteinDistance(tokens1, tokens2);
-    return 1 - distance / maxLen;
-  }
-
-  /**
-   * Calculate Levenshtein distance
-   */
-  private levenshteinDistance(str1: string, str2: string): number {
-    const len1 = str1.length;
-    const len2 = str2.length;
-    const matrix: number[][] = [];
-
-    for (let i = 0; i <= len1; i++) {
-      matrix[i] = [i];
-    }
-
-    for (let j = 0; j <= len2; j++) {
-      matrix[0]![j] = j;
-    }
-
-    for (let i = 1; i <= len1; i++) {
-      for (let j = 1; j <= len2; j++) {
-        const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-        matrix[i]![j] = Math.min(
-          matrix[i - 1]![j]! + 1, // deletion
-          matrix[i]![j - 1]! + 1, // insertion
-          matrix[i - 1]![j - 1]! + cost // substitution
-        );
-      }
-    }
-
-    return matrix[len1]![len2]!;
-  }
-
-  /**
-   * Check if node is a function
-   */
-  private isFunctionNode(node: ts.Node): boolean {
-    return ts.isFunctionDeclaration(node) ||
-           ts.isMethodDeclaration(node) ||
-           ts.isArrowFunction(node) ||
-           ts.isFunctionExpression(node);
-  }
-
-  /**
-   * Get function name for context
-   */
-  private getFunctionName(node: ts.Node): string | undefined {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      return node.name.getText();
-    } else if (ts.isMethodDeclaration(node) && node.name) {
-      return node.name.getText();
-    }
-    return undefined;
-  }
-
-  /**
-   * Clear stored blocks
-   */
-  clear(): void {
-    this.codeBlocks = [];
-  }
-}

package/src/cli/commands/analyze.ts

@@ -1,77 +0,0 @@
-import { resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-import { AnalysisService } from '../../application/services/AnalysisService.js';
-import { FileSystemReader } from '../../adapters/input/FileSystemReader.js';
-import { TypeScriptParser } from '../../adapters/input/TypeScriptParser.js';
-import { TerminalReporter } from '../../adapters/output/TerminalReporter.js';
-import { JsonExporter } from '../../adapters/output/JsonExporter.js';
-import type { IReporter, AnalysisReport } from '../../application/ports/IReporter.js';
-
-import { ComplexityRule } from '../../domain/rules/ComplexityRule.js';
-import { SizeRule } from '../../domain/rules/SizeRule.js';
-import { TypeSafetyRule } from '../../domain/rules/TypeSafetyRule.js';
-import { DuplicationRule } from '../../domain/rules/DuplicationRule.js';
-import { CircularDependencyRule } from '../../domain/rules/CircularDependencyRule.js';
-import { DEFAULT_CONFIG } from '../../application/config/AnalysisConfig.js';
-import type { AnalysisConfig } from '../../application/config/AnalysisConfig.js';
-
-// Helper to broadcast to multiple reporters
-class CompositeReporter implements IReporter {
-  constructor(private reporters: IReporter[]) {}
-  
-  async generate(report: AnalysisReport): Promise<void> {
-    await Promise.all(this.reporters.map(r => r.generate(report)));
-  }
-}
-
-export async function analyzeCommand(rootPath: string, jsonOutputPath?: string): Promise<void> {
-  console.log('🚀 Starting technical debt analysis...\n');
-
-  // Wiring: Create all adapters and services (dependency injection)
-  const fileReader = new FileSystemReader();
-  const parser = new TypeScriptParser();
-  
-  // Use both terminal and JSON reporters
-  const reporter = new CompositeReporter([
-    new TerminalReporter(),
-    new JsonExporter(jsonOutputPath)
-  ]);
-  
-  const rules = [
-    // ... rules
-
-    new ComplexityRule(),
-    new SizeRule(),
-    new TypeSafetyRule(),
-    new DuplicationRule(),
-    new CircularDependencyRule(),
-  ];
-
-  const analysisService = new AnalysisService(
-    fileReader,
-    parser,
-    rules,
-    reporter
-  );
-  
-  // Build configuration
-  // Use broad patterns by default and rely on ignore list for exclusions.
-  // This makes the tool structure-agnostic (works for src/, lib/, or root files).
-  const defaultPatterns = ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'];
-
-  const config: AnalysisConfig = {
-    rootPath,
-    ...DEFAULT_CONFIG,
-    patterns: defaultPatterns,
-  };
-
-  // Log scan start for transparency
-  if (config.patterns.length > 0) {
-    console.log(`📂 Scanning for patterns: ${config.patterns.join(', ')}`);
-  }
-
-  // Execute analysis
-  await analysisService.analyze(config);
-  
-  console.log('✅ Analysis complete!\n');
-}