tech-debt-score 0.1.5 → 0.1.6

package/src/adapters/input/TypeScriptParser.ts

@@ -1,367 +0,0 @@
-/**
- * Input Adapter: TypeScript/JavaScript Parser
- * Implements IParser using TypeScript Compiler API for AST-based analysis
- */
-
-import * as ts from 'typescript';
-import type { IParser, ParseResult } from '../../application/ports/IParser.js';
-import type { Metric } from '../../domain/entities/Metric.js';
-import { MetricBuilder } from '../../domain/entities/Metric.js';
-import type { SourceLocation } from '../../shared/types.js';
-
-/**
- * Helper class to extract metrics from AST nodes
- */
-class MetricExtractor {
-  private metrics: Metric[] = [];
-  
-  constructor(
-    private sourceFile: ts.SourceFile,
-    private filePath: string
-  ) {}
-
-  /**
-   * Node types that contribute to cyclomatic complexity
-   */
-  private static readonly COMPLEXITY_KINDS = new Set<ts.SyntaxKind>([
-    ts.SyntaxKind.IfStatement,
-    ts.SyntaxKind.ForStatement,
-    ts.SyntaxKind.ForInStatement,
-    ts.SyntaxKind.ForOfStatement,
-    ts.SyntaxKind.WhileStatement,
-    ts.SyntaxKind.DoStatement,
-    ts.SyntaxKind.CaseClause,
-    ts.SyntaxKind.ConditionalExpression,
-    ts.SyntaxKind.CatchClause,
-  ]);
-
-  /**
-   * Node types that contribute to nesting depth
-   */
-  private static readonly NESTING_KINDS = new Set<ts.SyntaxKind>([
-    ts.SyntaxKind.Block,
-    ts.SyntaxKind.IfStatement,
-    ts.SyntaxKind.ForStatement,
-    ts.SyntaxKind.ForInStatement,
-    ts.SyntaxKind.ForOfStatement,
-    ts.SyntaxKind.WhileStatement,
-    ts.SyntaxKind.DoStatement,
-    ts.SyntaxKind.SwitchStatement,
-    ts.SyntaxKind.TryStatement,
-  ]);
-
-  /**
-   * Extract all metrics from the source file
-   */
-  extract(): Metric[] {
-    this.metrics = [];
-    
-    // File-level metrics
-    this.extractFileMetrics();
-    
-    // Function-level metrics
-    this.visit(this.sourceFile);
-    
-    return this.metrics;
-  }
-
-  /**
-   * Extract file-level metrics
-   */
-  private extractFileMetrics(): void {
-    const lines = this.sourceFile.getLineStarts();
-    const lineCount = lines.length;
-    
-    // File length metric
-    this.metrics.push(
-      new MetricBuilder()
-        .withName('file-length')
-        .withValue(lineCount)
-        .withFilePath(this.filePath)
-        .build()
-    );
-
-    // Count TODO/FIXME comments
-    const text = this.sourceFile.getFullText();
-    const todoCount = (text.match(/\/\/\s*TODO/gi) || []).length + 
-                     (text.match(/\/\*[\s\S]*?TODO[\s\S]*?\*\//gi) || []).length;
-    const fixmeCount = (text.match(/\/\/\s*FIXME/gi) || []).length + 
-                      (text.match(/\/\*[\s\S]*?FIXME[\s\S]*?\*\//gi) || []).length;
-    
-    if (todoCount > 0) {
-      this.metrics.push(
-        new MetricBuilder()
-          .withName('todo-comments')
-          .withValue(todoCount)
-          .withFilePath(this.filePath)
-          .build()
-      );
-    }
-    
-    if (fixmeCount > 0) {
-      this.metrics.push(
-        new MetricBuilder()
-          .withName('fixme-comments')
-          .withValue(fixmeCount)
-          .withFilePath(this.filePath)
-          .build()
-      );
-    }
-  }
-
-  /**
-   * Visit AST nodes recursively
-   */
-  private visit(node: ts.Node): void {
-    // Check if this is a function node
-    if (this.isFunctionNode(node)) {
-      this.extractFunctionMetrics(node as ts.FunctionLikeDeclaration);
-    }
-
-    // Recurse to children
-    ts.forEachChild(node, (child) => this.visit(child));
-  }
-
-  /**
-   * Check if node is a function-like declaration
-   */
-  private isFunctionNode(node: ts.Node): boolean {
-    return ts.isFunctionDeclaration(node) ||
-           ts.isMethodDeclaration(node) ||
-           ts.isArrowFunction(node) ||
-           ts.isFunctionExpression(node) ||
-           ts.isConstructorDeclaration(node);
-  }
-
-  /**
-   * Extract metrics from a function node
-   */
-  private extractFunctionMetrics(node: ts.FunctionLikeDeclaration): void {
-    const functionName = this.getFunctionName(node);
-    const location = this.getLocation(node);
-    
-    // Function length
-    const startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
-    const endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
-    const functionLength = endLine - startLine + 1;
-    
-    this.metrics.push(
-      new MetricBuilder()
-        .withName('function-length')
-        .withValue(functionLength)
-        .withFilePath(this.filePath)
-        .withContext(functionName)
-        .withLocation(location)
-        .build()
-    );
-
-    // Parameter count
-    const paramCount = node.parameters.length;
-    if (paramCount > 0) {
-      this.metrics.push(
-        new MetricBuilder()
-          .withName('parameter-count')
-          .withValue(paramCount)
-          .withFilePath(this.filePath)
-          .withContext(functionName)
-          .withLocation(location)
-          .build()
-      );
-    }
-
-    // Cyclomatic complexity
-    const complexity = this.calculateComplexity(node);
-    this.metrics.push(
-      new MetricBuilder()
-        .withName('cyclomatic-complexity')
-        .withValue(complexity)
-        .withFilePath(this.filePath)
-        .withContext(functionName)
-        .withLocation(location)
-        .build()
-    );
-
-    // Nesting depth
-    const maxDepth = this.calculateNestingDepth(node);
-    if (maxDepth > 0) {
-      this.metrics.push(
-        new MetricBuilder()
-          .withName('nesting-depth')
-          .withValue(maxDepth)
-          .withFilePath(this.filePath)
-          .withContext(functionName)
-          .withLocation(location)
-          .build()
-      );
-    }
-
-    // Count 'any' usage in function signature
-    const anyCount = this.countAnyUsage(node);
-    if (anyCount > 0) {
-      this.metrics.push(
-        new MetricBuilder()
-          .withName('any-usage')
-          .withValue(anyCount)
-          .withFilePath(this.filePath)
-          .withContext(functionName)
-          .withLocation(location)
-          .build()
-      );
-    }
-  }
-
-  /**
-   * Calculate cyclomatic complexity
-   * Formula: Number of decision points + 1
-   */
-  private calculateComplexity(node: ts.Node): number {
-    let complexity = 1; // Base complexity
-
-    const countDecisionPoints = (n: ts.Node): void => {
-      if (MetricExtractor.COMPLEXITY_KINDS.has(n.kind)) {
-        complexity++;
-      } else if (ts.isBinaryExpression(n)) {
-        // Logical operators && and ||
-        const op = n.operatorToken.kind;
-        if (op === ts.SyntaxKind.AmpersandAmpersandToken ||
-            op === ts.SyntaxKind.BarBarToken) {
-          complexity++;
-        }
-      }
-
-      ts.forEachChild(n, countDecisionPoints);
-    };
-
-    countDecisionPoints(node);
-    return complexity;
-  }
-
-  /**
-   * Calculate maximum nesting depth
-   */
-  private calculateNestingDepth(node: ts.Node): number {
-    let maxDepth = 0;
-
-    const traverse = (n: ts.Node, depth: number): void => {
-      let currentDepth = depth;
-
-      // Increment depth for nesting constructs using the static registry
-      if (MetricExtractor.NESTING_KINDS.has(n.kind)) {
-        currentDepth++;
-        maxDepth = Math.max(maxDepth, currentDepth);
-      }
-
-      ts.forEachChild(n, (child) => traverse(child, currentDepth));
-    };
-
-    traverse(node, 0);
-    return maxDepth;
-  }
-
-  /**
-   * Count 'any' type usage in function signature
-   */
-  private countAnyUsage(node: ts.FunctionLikeDeclaration): number {
-    let count = 0;
-
-    // Check parameters
-    for (const param of node.parameters) {
-      if (param.type && this.isAnyType(param.type)) {
-        count++;
-      }
-    }
-
-    // Check return type
-    if (node.type && this.isAnyType(node.type)) {
-      count++;
-    }
-
-    return count;
-  }
-
-  /**
-   * Check if a type node represents 'any'
-   */
-  private isAnyType(typeNode: ts.TypeNode): boolean {
-    return typeNode.kind === ts.SyntaxKind.AnyKeyword;
-  }
-
-  /**
-   * Get function name for context
-   */
-  private getFunctionName(node: ts.FunctionLikeDeclaration): string {
-    if (ts.isFunctionDeclaration(node) && node.name) {
-      return node.name.getText();
-    } else if (ts.isMethodDeclaration(node) && node.name) {
-      return node.name.getText();
-    } else if (ts.isConstructorDeclaration(node)) {
-      return 'constructor';
-    }
-    return 'anonymous function';
-  }
-
-  /**
-   * Get source location from node
-   */
-  private getLocation(node: ts.Node): SourceLocation {
-    const start = this.sourceFile.getLineAndCharacterOfPosition(node.getStart());
-    const end = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd());
-    
-    return {
-      startLine: start.line + 1,
-      endLine: end.line + 1,
-      startColumn: start.character,
-      endColumn: end.character,
-    };
-  }
-}
-
-/**
- * TypeScript Parser using native TypeScript Compiler API
- */
-export class TypeScriptParser implements IParser {
-  supports(filePath: string): boolean {
-    return filePath.endsWith('.ts') || 
-           filePath.endsWith('.tsx') || 
-           filePath.endsWith('.js') || 
-           filePath.endsWith('.jsx');
-  }
-
-  async parse(filePath: string, content: string): Promise<ParseResult> {
-    try {
-      // Create source file from content
-      const sourceFile = ts.createSourceFile(
-        filePath,
-        content,
-        ts.ScriptTarget.Latest,
-        true, // setParentNodes
-        this.getScriptKind(filePath)
-      );
-
-      // Extract metrics using AST traversal
-      const extractor = new MetricExtractor(sourceFile, filePath);
-      const metrics = extractor.extract();
-
-      return {
-        metrics,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        metrics: [],
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown parsing error',
-      };
-    }
-  }
-
-  /**
-   * Determine script kind from file extension
-   */
-  private getScriptKind(filePath: string): ts.ScriptKind {
-    if (filePath.endsWith('.tsx')) return ts.ScriptKind.TSX;
-    if (filePath.endsWith('.jsx')) return ts.ScriptKind.JSX;
-    if (filePath.endsWith('.ts')) return ts.ScriptKind.TS;
-    return ts.ScriptKind.JS;
-  }
-}

package/src/adapters/output/JsonExporter.ts

@@ -1,48 +0,0 @@
-/**
- * Output Adapter: JSON Exporter
- * Implements IReporter for JSON file output
- */
-
-import { writeFile } from 'node:fs/promises';
-import type { IReporter, AnalysisReport } from '../../application/ports/IReporter.js';
-
-export class JsonExporter implements IReporter {
-  constructor(private readonly outputPath: string = './tech-debt-report.json') {}
-
-  async generate(report: AnalysisReport): Promise<void> {
-    const jsonReport = {
-      version: '1.0.0',
-      generatedAt: report.metadata.timestamp.toISOString(),
-      score: {
-        overall: report.score.overall,
-        categories: report.score.categories.map(cat => ({
-          name: cat.name,
-          score: cat.score,
-          weight: cat.weight,
-          description: cat.description,
-        })),
-      },
-      findings: report.findings.map(finding => ({
-        ruleId: finding.ruleId,
-        severity: finding.severity,
-        message: finding.message,
-        filePath: finding.filePath,
-        location: finding.location ? {
-          startLine: finding.location.startLine,
-          endLine: finding.location.endLine,
-          startColumn: finding.location.startColumn,
-          endColumn: finding.location.endColumn,
-        } : undefined,
-        suggestion: finding.suggestion,
-      })),
-      metadata: {
-        filesAnalyzed: report.metadata.filesAnalyzed,
-        durationMs: report.metadata.duration,
-        timestamp: report.metadata.timestamp.toISOString(),
-      },
-    };
-
-    await writeFile(this.outputPath, JSON.stringify(jsonReport, null, 2), 'utf-8');
-    console.log(`💾 JSON report saved to: ${this.outputPath}`);
-  }
-}

package/src/adapters/output/TerminalReporter.ts

@@ -1,94 +0,0 @@
-/**
- * Output Adapter: Terminal Reporter
- * Implements IReporter for console output
- */
-
-import type { IReporter, AnalysisReport } from '../../application/ports/IReporter.js';
-
-export class TerminalReporter implements IReporter {
-  async generate(report: AnalysisReport): Promise<void> {
-    console.log('\n');
-    console.log('═'.repeat(60));
-    console.log('  TECHNICAL DEBT SCORE REPORT');
-    console.log('═'.repeat(60));
-    console.log('\n');
-
-    // Overall Score
-    const scoreColor = this.getScoreColor(report.score.overall);
-    console.log(`📊 Overall Score: ${scoreColor}${report.score.overall.toFixed(1)}/100${this.reset()}`);
-    console.log(this.getScoreLabel(report.score.overall));
-    console.log('\n');
-
-    // Category Breakdown
-    console.log('📈 Category Breakdown:');
-    console.log('─'.repeat(60));
-    for (const category of report.score.categories) {
-      const bar = this.createBar(category.score);
-      const weight = (category.weight * 100).toFixed(0);
-      console.log(`  ${category.name.padEnd(20)} ${bar} ${category.score.toFixed(1)} (${weight}%)`);
-    }
-    console.log('\n');
-
-    // Summary Statistics
-    console.log('📋 Analysis Summary:');
-    console.log('─'.repeat(60));
-    console.log(`  Files Analyzed:    ${report.metadata.filesAnalyzed}`);
-    console.log(`  Total Findings:    ${report.findings.length}`);
-    console.log(`  Duration:          ${(report.metadata.duration / 1000).toFixed(2)}s`);
-    console.log(`  Timestamp:         ${report.metadata.timestamp.toISOString()}`);
-    console.log('\n');
-
-    // Top Issues
-    if (report.findings.length > 0) {
-      console.log('⚠️  Top Issues:');
-      console.log('─'.repeat(60));
-      const topFindings = report.findings
-        .sort((a, b) => {
-          const severityOrder = { high: 0, medium: 1, low: 2 };
-          return severityOrder[a.severity] - severityOrder[b.severity];
-        })
-        .slice(0, 10);
-
-      for (const finding of topFindings) {
-        const icon = finding.severity === 'high' ? '🔴' : finding.severity === 'medium' ? '🟡' : '🟢';
-        console.log(`  ${icon} ${finding.message}`);
-        console.log(`     ${finding.filePath}${finding.location ? `:${finding.location.startLine}` : ''}`);
-      }
-      console.log('\n');
-    } else if (report.metadata.filesAnalyzed > 0) {
-      console.log('✨ No issues found! Your codebase looks clean.');
-      console.log('\n');
-    } else {
-      console.log('❓ No files were analyzed. Check your configuration or directory.');
-      console.log('\n');
-    }
-
-    console.log('═'.repeat(60));
-    console.log('\n');
-  }
-
-  private createBar(score: number, length = 20): string {
-    const filled = Math.round((score / 100) * length);
-    const empty = length - filled;
-    return `[${'█'.repeat(filled)}${'░'.repeat(empty)}]`;
-  }
-
-  private getScoreColor(score: number): string {
-    // ANSI color codes (placeholder - could use chalk library)
-    if (score >= 80) return '\x1b[32m'; // Green
-    if (score >= 60) return '\x1b[33m'; // Yellow
-    return '\x1b[31m'; // Red
-  }
-
-  private reset(): string {
-    return '\x1b[0m';
-  }
-
-  private getScoreLabel(score: number): string {
-    if (score >= 90) return '   ✨ Excellent - Very low technical debt';
-    if (score >= 80) return '   ✅ Good - Manageable technical debt';
-    if (score >= 60) return '   ⚠️  Fair - Moderate technical debt';
-    if (score >= 40) return '   ❗ Poor - High technical debt';
-    return '   🚨 Critical - Very high technical debt';
-  }
-}

package/src/application/config/AnalysisConfig.ts

@@ -1,58 +0,0 @@
-/**
- * Application Configuration
- * Configuration for running code analysis
- */
-
-export interface AnalysisConfig {
-  /**
-   * Root directory to analyze
-   */
-  rootPath: string;
-
-  /**
-   * File patterns to include (glob patterns)
-   * Default: ['src/**\/*.ts', 'src/**\/*.js']
-   */
-  patterns: string[];
-
-  /**
-   * Patterns to ignore
-   * Default: ['node_modules', 'dist', 'build', 'coverage', '.git']
-   */
-  ignore: string[];
-
-  /**
-   * Category weights for score calculation
-   * Should sum to 1.0
-   */
-  weights?: {
-    complexity: number;
-    size: number;
-    typeSafety: number;
-    codeQuality: number;
-    structure: number;
-  };
-}
-
-/**
- * Default configuration values
- */
-export const DEFAULT_CONFIG: Omit<AnalysisConfig, 'rootPath'> = {
-  patterns: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-  ignore: [
-    '**/node_modules/**',
-    '**/dist/**',
-    '**/build/**',
-    '**/coverage/**',
-    '**/.git/**',
-    '**/.next/**',
-    '**/out/**',
-  ],
-  weights: {
-    complexity: 0.30,
-    size: 0.25,
-    typeSafety: 0.20,
-    codeQuality: 0.15,
-    structure: 0.10,
-  },
-};

package/src/application/ports/IFileReader.ts

@@ -1,36 +0,0 @@
-/**
- * Application Port: File Reader Interface
- * Input adapter interface for reading files from the filesystem
- */
-
-import type { FileMetadata } from '../../shared/types.js';
-
-export interface FileReadResult {
-  content: string;
-  metadata: FileMetadata;
-}
-
-export interface IFileReader {
-  /**
-   * Scan a directory and return matching file paths
-   * 
-   * @param rootPath - Root directory to scan
-   * @param patterns - Glob patterns to match (e.g., ['src/**\/*.ts'])
-   * @param ignore - Patterns to ignore (e.g., ['node_modules', 'dist'])
-   */
-  scan(rootPath: string, patterns: string[], ignore: string[]): Promise<string[]>;
-
-  /**
-   * Read a single file and return its content
-   * 
-   * @param filePath - Absolute path to the file
-   */
-  read(filePath: string): Promise<FileReadResult>;
-
-  /**
-   * Read multiple files in batch
-   * 
-   * @param filePaths - Array of absolute file paths
-   */
-  readBatch(filePaths: string[]): Promise<FileReadResult[]>;
-}

package/src/application/ports/IParser.ts

@@ -1,40 +0,0 @@
-/**
- * Application Port: Parser Interface
- * Input adapter interface for parsing source code into AST and extracting metrics
- */
-
-import type { Metric } from '../../domain/entities/Metric.js';
-
-export interface ParseResult {
-  /**
-   * Array of metrics extracted from the source code
-   */
-  metrics: Metric[];
-
-  /**
-   * Indicates if parsing was successful
-   */
-  success: boolean;
-
-  /**
-   * Error message if parsing failed
-   */
-  error?: string;
-}
-
-export interface IParser {
-  /**
-   * Parse source code and extract metrics
-   * 
-   * @param filePath - Path to the file being parsed
-   * @param content - Source code content
-   */
-  parse(filePath: string, content: string): Promise<ParseResult>;
-
-  /**
-   * Check if this parser supports a given file
-   * 
-   * @param filePath - Path to check
-   */
-  supports(filePath: string): boolean;
-}

package/src/application/ports/IReporter.ts

@@ -1,26 +0,0 @@
-/**
- * Application Port: Reporter Interface
- * Output adapter interface for reporting analysis results
- */
-
-import type { Score } from '../../domain/entities/Score.js';
-import type { Finding } from '../../domain/entities/Finding.js';
-
-export interface AnalysisReport {
-  score: Score;
-  findings: Finding[];
-  metadata: {
-    filesAnalyzed: number;
-    duration: number;
-    timestamp: Date;
-  };
-}
-
-export interface IReporter {
-  /**
-   * Generate and output a report
-   * 
-   * @param report - The analysis report data
-   */
-  generate(report: AnalysisReport): Promise<void>;
-}