ts-analyzer 1.0.0

package/src/code-complexity.ts

@@ -0,0 +1,431 @@
+// src/code-complexity.ts
+import fs from 'fs/promises';
+import path from 'path';
+import * as espree from 'espree';
+import * as estraverse from 'estraverse';
+import * as ts from 'typescript';
+import { Node as EstreeNode } from 'estree';
+
+// Define our own simplified Node interface
+interface CustomNode {
+  type: string;
+  body?: any;
+  loc?: { start: { line: number }, end: { line: number } };
+  params?: any[];
+  id?: { name: string };
+  operator?: string;
+}
+
+interface SimplifiedProgram {
+  type: string;
+  body: any[];
+}
+
+interface FunctionData {
+  type: string;
+  name: string;
+  complexity: number;
+  nestingDepth: number;
+  paramCount: number;
+  lineCount: number;
+}
+
+export interface FileComplexityMetrics {
+  avgComplexity: string;
+  maxComplexity: number;
+  avgNestingDepth: string;
+  maxNestingDepth: number;
+  avgFunctionSize: string;
+  avgParams: string;
+  functionCount: number;
+  complexityScore: number;
+  complexityRating: string;
+}
+
+export interface CodeComplexityMetrics {
+  analyzedFiles: number;
+  avgComplexity: string;
+  maxComplexity: number;
+  avgNestingDepth: string;
+  maxNestingDepth: number;
+  avgFunctionSize: string;
+  totalFunctions: number;
+  complexFiles: number;
+  overallComplexity: string;
+}
+
+// Calculate cyclomatic complexity
+function calculateCyclomaticComplexity(ast: any): number {
+  let complexity = 1; // Start with 1 (one path through the function)
+
+  estraverse.traverse(ast, {
+    enter(node: any) {
+      // Count conditional statements and operators that create new paths
+      switch (node.type) {
+        case 'IfStatement':
+        case 'ConditionalExpression':
+        case 'SwitchCase':
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'ForOfStatement':
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+          complexity++;
+          break;
+        case 'LogicalExpression':
+          if (node.operator === '&&' || node.operator === '||') {
+            complexity++;
+          }
+          break;
+      }
+    }
+  });
+
+  return complexity;
+}
+
+// Calculate nesting depth
+function calculateNestingDepth(ast: any): number {
+  let maxDepth = 0;
+  let currentDepth = 0;
+
+  estraverse.traverse(ast, {
+    enter(node: any) {
+      // Count nesting for blocks and control structures
+      switch (node.type) {
+        case 'BlockStatement':
+        case 'IfStatement':
+        case 'SwitchStatement':
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'ForOfStatement':
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+        case 'TryStatement':
+          currentDepth++;
+          maxDepth = Math.max(maxDepth, currentDepth);
+          break;
+      }
+    },
+    leave(node: any) {
+      // Decrement depth when leaving a block
+      switch (node.type) {
+        case 'BlockStatement':
+        case 'IfStatement':
+        case 'SwitchStatement':
+        case 'ForStatement':
+        case 'ForInStatement':
+        case 'ForOfStatement':
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+        case 'TryStatement':
+          currentDepth--;
+          break;
+      }
+    }
+  });
+
+  return maxDepth;
+}
+
+// Find function declarations and calculate their metrics
+function analyzeFunctions(ast: any): FunctionData[] {
+  const functions: FunctionData[] = [];
+
+  estraverse.traverse(ast, {
+    enter(node: any) {
+      if (node.type === 'FunctionDeclaration' ||
+          node.type === 'FunctionExpression' ||
+          node.type === 'ArrowFunctionExpression') {
+
+        // Skip functions without a body
+        if (!node.body) return;
+
+        // Get the function's source code
+        let functionAst = node;
+        if (node.type === 'ArrowFunctionExpression' && node.body.type !== 'BlockStatement') {
+          functionAst = {
+            type: 'ArrowFunctionExpression',
+            body: {
+              type: 'BlockStatement',
+              body: [{ type: 'ReturnStatement', argument: node.body }]
+            }
+          };
+        }
+
+        // Calculate complexity
+        const complexity = calculateCyclomaticComplexity(functionAst);
+
+        // Calculate nesting
+        const nestingDepth = calculateNestingDepth(functionAst);
+
+        // Count function parameters
+        const paramCount = node.params ? node.params.length : 0;
+
+        // Estimate function size (lines)
+        let lineCount = 0;
+        if (node.loc) {
+          lineCount = node.loc.end.line - node.loc.start.line + 1;
+        }
+
+        functions.push({
+          type: node.type,
+          name: node.id ? node.id.name : 'anonymous',
+          complexity,
+          nestingDepth,
+          paramCount,
+          lineCount
+        });
+      }
+    }
+  });
+
+  return functions;
+}
+
+// Parse a TypeScript file using the TypeScript compiler
+function parseTypeScriptFile(content: string): SimplifiedProgram {
+  try {
+    // Create a source file
+    const sourceFile = ts.createSourceFile(
+        'temp.ts',
+        content,
+        ts.ScriptTarget.Latest,
+        true
+    );
+
+    // Create a simplified program AST structure
+    const simplifiedAst: SimplifiedProgram = {
+      type: 'Program',
+      body: []
+    };
+
+    // Function to visit TypeScript nodes and extract function information
+    function visit(node: ts.Node) {
+      if (ts.isFunctionDeclaration(node) ||
+          ts.isMethodDeclaration(node) ||
+          ts.isArrowFunction(node) ||
+          ts.isFunctionExpression(node)) {
+
+        const startLine = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
+        const endLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line + 1;
+
+        const functionNode = {
+          type: ts.isFunctionDeclaration(node) ? 'FunctionDeclaration' :
+              ts.isArrowFunction(node) ? 'ArrowFunctionExpression' : 'FunctionExpression',
+          id: ts.isFunctionDeclaration(node) && node.name ? { name: node.name.text } : undefined,
+          params: node.parameters ? node.parameters.map(() => ({})) : [],
+          body: { type: 'BlockStatement', body: [] as any[] },
+          loc: {
+            start: { line: startLine },
+            end: { line: endLine }
+          }
+        };
+
+        simplifiedAst.body.push(functionNode);
+      }
+
+      ts.forEachChild(node, visit);
+    }
+
+    visit(sourceFile);
+
+    return simplifiedAst;
+  } catch (error) {
+    console.error('Error parsing TypeScript file:', error);
+    return { type: 'Program', body: [] };
+  }
+}
+
+export async function analyzeFileComplexity(filePath: string): Promise<FileComplexityMetrics> {
+  try {
+    const content = await fs.readFile(filePath, 'utf8');
+    const extension = path.extname(filePath);
+
+    // Choose the appropriate parser based on file extension
+    let ast: any;
+
+    if (extension === '.ts' || extension === '.tsx') {
+      // Use TypeScript parser for .ts and .tsx files
+      ast = parseTypeScriptFile(content);
+    } else {
+      // Use espree for JavaScript files
+      try {
+        const parserOptions = {
+          ecmaVersion: 2022,
+          sourceType: 'module',
+          ecmaFeatures: {
+            jsx: extension === '.jsx'
+          }
+        };
+
+        ast = espree.parse(content, parserOptions as any);
+      } catch (parseError) {
+        console.error(`Parsing error in ${filePath}: ${(parseError as Error).message}`);
+        return {
+          avgComplexity: '0',
+          maxComplexity: 0,
+          avgNestingDepth: '0',
+          maxNestingDepth: 0,
+          avgFunctionSize: '0',
+          avgParams: '0',
+          functionCount: 0,
+          complexityScore: 0,
+          complexityRating: 'N/A'
+        };
+      }
+    }
+
+    // Analyze the functions in the file
+    const functions = analyzeFunctions(ast);
+
+    if (functions.length === 0) {
+      return {
+        avgComplexity: '0',
+        maxComplexity: 0,
+        avgNestingDepth: '0',
+        maxNestingDepth: 0,
+        avgFunctionSize: '0',
+        avgParams: '0',
+        functionCount: 0,
+        complexityScore: 0,
+        complexityRating: 'N/A'
+      };
+    }
+
+    // Calculate average and maximum values
+    const totalComplexity = functions.reduce((sum, fn) => sum + fn.complexity, 0);
+    const maxComplexity = Math.max(...functions.map(fn => fn.complexity));
+
+    const totalNestingDepth = functions.reduce((sum, fn) => sum + fn.nestingDepth, 0);
+    const maxNestingDepth = Math.max(...functions.map(fn => fn.nestingDepth));
+
+    const totalLineCount = functions.reduce((sum, fn) => sum + fn.lineCount, 0);
+    const totalParams = functions.reduce((sum, fn) => sum + fn.paramCount, 0);
+
+    const avgComplexity = totalComplexity / functions.length;
+    const avgNestingDepth = totalNestingDepth / functions.length;
+    const avgFunctionSize = totalLineCount / functions.length;
+    const avgParams = totalParams / functions.length;
+
+    // Calculate a complexity score (0-100, higher means more complex)
+    const complexityWeight = 0.4;
+    const nestingWeight = 0.3;
+    const sizeWeight = 0.2;
+    const paramsWeight = 0.1;
+
+    // Normalized scores (0-100)
+    const complexityScore = Math.min((avgComplexity / 10) * 100, 100);
+    const nestingScore = Math.min((avgNestingDepth / 5) * 100, 100);
+    const sizeScore = Math.min((avgFunctionSize / 30) * 100, 100);
+    const paramsScore = Math.min((avgParams / 6) * 100, 100);
+
+    const totalScore = (complexityScore * complexityWeight) +
+        (nestingScore * nestingWeight) +
+        (sizeScore * sizeWeight) +
+        (paramsScore * paramsWeight);
+
+    // Define complexity rating
+    let complexityRating: string;
+    if (totalScore < 30) complexityRating = 'Low';
+    else if (totalScore < 60) complexityRating = 'Medium';
+    else complexityRating = 'High';
+
+    return {
+      avgComplexity: avgComplexity.toFixed(1),
+      maxComplexity,
+      avgNestingDepth: avgNestingDepth.toFixed(1),
+      maxNestingDepth,
+      avgFunctionSize: avgFunctionSize.toFixed(1),
+      avgParams: avgParams.toFixed(1),
+      functionCount: functions.length,
+      complexityScore: Math.round(totalScore),
+      complexityRating
+    };
+  } catch (error) {
+    console.error(`Error analyzing file complexity for ${filePath}:`, error);
+    return {
+      avgComplexity: '0',
+      maxComplexity: 0,
+      avgNestingDepth: '0',
+      maxNestingDepth: 0,
+      avgFunctionSize: '0',
+      avgParams: '0',
+      functionCount: 0,
+      complexityScore: 0,
+      complexityRating: 'N/A'
+    };
+  }
+}
+
+export async function calculateProjectComplexity(projectPath: string, fileList: string[]): Promise<CodeComplexityMetrics> {
+  const jsExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+  const jsFiles = fileList.filter(file => jsExtensions.includes(path.extname(file)));
+
+  if (jsFiles.length === 0) {
+    return {
+      analyzedFiles: 0,
+      avgComplexity: '0.0',
+      maxComplexity: 0,
+      avgNestingDepth: '0.0',
+      maxNestingDepth: 0,
+      avgFunctionSize: '0.0',
+      totalFunctions: 0,
+      complexFiles: 0,
+      overallComplexity: 'N/A'
+    };
+  }
+
+  let totalComplexity = 0;
+  let totalNestingDepth = 0;
+  let totalFunctionSize = 0;
+  let maxComplexityGlobal = 0;
+  let maxNestingDepthGlobal = 0;
+  let totalFunctions = 0;
+  let complexFiles = 0;
+
+  for (const file of jsFiles) {
+    const filePath = path.join(projectPath, file);
+    const metrics = await analyzeFileComplexity(filePath);
+
+    totalComplexity += parseFloat(metrics.avgComplexity) * metrics.functionCount;
+    totalNestingDepth += parseFloat(metrics.avgNestingDepth) * metrics.functionCount;
+    totalFunctionSize += parseFloat(metrics.avgFunctionSize) * metrics.functionCount;
+    maxComplexityGlobal = Math.max(maxComplexityGlobal, metrics.maxComplexity);
+    maxNestingDepthGlobal = Math.max(maxNestingDepthGlobal, metrics.maxNestingDepth);
+    totalFunctions += metrics.functionCount;
+
+    if (metrics.complexityRating === 'High') {
+      complexFiles++;
+    }
+  }
+
+  // Calculate project averages
+  const avgComplexity = totalFunctions > 0 ? (totalComplexity / totalFunctions).toFixed(1) : '0.0';
+  const avgNestingDepth = totalFunctions > 0 ? (totalNestingDepth / totalFunctions).toFixed(1) : '0.0';
+  const avgFunctionSize = totalFunctions > 0 ? (totalFunctionSize / totalFunctions).toFixed(1) : '0.0';
+
+  // Determine overall complexity
+  let overallComplexity: string;
+  const complexFilesPercentage = (complexFiles / jsFiles.length) * 100;
+
+  if (parseFloat(avgComplexity) < 4 && complexFilesPercentage < 10) {
+    overallComplexity = 'Low';
+  } else if (parseFloat(avgComplexity) < 8 && complexFilesPercentage < 25) {
+    overallComplexity = 'Medium';
+  } else {
+    overallComplexity = 'High';
+  }
+
+  return {
+    analyzedFiles: jsFiles.length,
+    avgComplexity,
+    maxComplexity: maxComplexityGlobal,
+    avgNestingDepth,
+    maxNestingDepth: maxNestingDepthGlobal,
+    avgFunctionSize,
+    totalFunctions,
+    complexFiles,
+    overallComplexity
+  };
+}

package/src/index.ts

@@ -0,0 +1,180 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import { calculateProjectTypeSafety, TypeScriptSafetyMetrics } from './typescript-safety.js';
+import { calculateProjectComplexity, CodeComplexityMetrics } from './code-complexity.js';
+
+export const REACT_EXTENSIONS = [
+    '.js', '.jsx', '.ts', '.tsx',
+    '.css', '.scss', '.sass',
+    '.html', '.json'
+];
+
+export const DEFAULT_IGNORE = [
+    'node_modules',
+    'build',
+    'dist',
+    '.git',
+    'coverage',
+    '.next',
+    'out'
+];
+
+export interface LineCount {
+    total: number;
+    nonEmpty: number;
+    code: number;
+    comments: number;
+    empty: number;
+}
+
+export interface FileTypeData {
+    files: number;
+    totalLines: number;
+    codeLines: number;
+    commentLines: number;
+    emptyLines: number;
+}
+
+export interface FileTypeFormatted {
+    'Extension': string;
+    'Files': string;
+    'Total Lines': string;
+    'Code Lines': string;
+    'Comment Lines': string;
+    'Empty Lines': string;
+    '% of Codebase': string;
+}
+
+export interface ProjectOptions {
+    excludePatterns?: string[];
+    additionalExtensions?: string[];
+    analyzeSafety?: boolean;
+    analyzeComplexity?: boolean;
+}
+
+export interface ProjectStats {
+    files: number;
+    totalLines: number;
+    codeLines: number;
+    commentLines: number;
+    emptyLines: number;
+    fileTypes: Record<string, FileTypeData>;
+    formattedFileTypes?: FileTypeFormatted[];
+    typescriptSafety: TypeScriptSafetyMetrics | null;
+    codeComplexity: CodeComplexityMetrics | null;
+    formatNumber: (num: number) => string;
+}
+
+export async function countLines(filePath: string): Promise<LineCount> {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        const lines: string[] = content.split('\n');
+        const nonEmptyLines = lines.filter(line => line.trim().length > 0);
+        const nonCommentLines = nonEmptyLines.filter(line => {
+            const trimmed = line.trim();
+            return !trimmed.startsWith('//') && !trimmed.startsWith('/*') && !trimmed.startsWith('*');
+        });
+
+        return {
+            total: lines.length,
+            nonEmpty: nonEmptyLines.length,
+            code: nonCommentLines.length,
+            comments: nonEmptyLines.length - nonCommentLines.length,
+            empty: lines.length - nonEmptyLines.length
+        };
+    } catch (error) {
+        console.error(`Error reading file ${filePath}:`, error);
+        return { total: 0, nonEmpty: 0, code: 0, comments: 0, empty: 0 };
+    }
+}
+
+export async function analyzeProject(projectPath = '.', options: ProjectOptions = {}): Promise<ProjectStats> {
+    const stats: ProjectStats = {
+        files: 0,
+        totalLines: 0,
+        codeLines: 0,
+        commentLines: 0,
+        emptyLines: 0,
+        fileTypes: {},
+        typescriptSafety: null,
+        codeComplexity: null,
+        formatNumber: (num: number) => num.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ',')
+    };
+
+    const extensions = [...REACT_EXTENSIONS, ...(options.additionalExtensions || [])];
+    const ignorePatterns = [...DEFAULT_IGNORE, ...(options.excludePatterns || [])];
+
+    const allFilePaths: string[] = [];
+
+    async function traverse(currentPath: string): Promise<void> {
+        const files = await fs.readdir(currentPath);
+
+        for (const file of files) {
+            const fullPath = path.join(currentPath, file);
+            const stat = await fs.stat(fullPath);
+
+            if (stat.isDirectory()) {
+                if (!ignorePatterns.includes(file)) {
+                    await traverse(fullPath);
+                }
+                continue;
+            }
+
+            const ext = path.extname(file);
+            if (!extensions.includes(ext)) continue;
+
+            stats.files++;
+            const relativePath = path.relative(projectPath, fullPath);
+            allFilePaths.push(relativePath);
+
+            if (!stats.fileTypes[ext]) {
+                stats.fileTypes[ext] = {
+                    files: 0,
+                    totalLines: 0,
+                    codeLines: 0,
+                    commentLines: 0,
+                    emptyLines: 0
+                };
+            }
+
+            const { total, code, comments, empty } = await countLines(fullPath);
+
+            stats.totalLines += total;
+            stats.codeLines += code;
+            stats.commentLines += comments;
+            stats.emptyLines += empty;
+
+            stats.fileTypes[ext].files++;
+            stats.fileTypes[ext].totalLines += total;
+            stats.fileTypes[ext].codeLines += code;
+            stats.fileTypes[ext].commentLines += comments;
+            stats.fileTypes[ext].emptyLines += empty;
+        }
+    }
+
+    await traverse(projectPath);
+
+    stats.formattedFileTypes = Object.entries(stats.fileTypes)
+        .sort(([, a], [, b]) => b.files - a.files)
+        .map(([ext, data]) => ({
+            'Extension': ext,
+            'Files': stats.formatNumber(data.files),
+            'Total Lines': stats.formatNumber(data.totalLines),
+            'Code Lines': stats.formatNumber(data.codeLines),
+            'Comment Lines': stats.formatNumber(data.commentLines),
+            'Empty Lines': stats.formatNumber(data.emptyLines),
+            '% of Codebase': `${((data.codeLines / stats.codeLines) * 100).toFixed(1)}%`
+        }));
+
+    // Now analyze TypeScript safety and code complexity if requested
+    if (options.analyzeSafety !== false) {
+        stats.typescriptSafety = await calculateProjectTypeSafety(projectPath, allFilePaths);
+    }
+
+    if (options.analyzeComplexity !== false) {
+        stats.codeComplexity = await calculateProjectComplexity(projectPath, allFilePaths);
+    }
+
+    return stats;
+}

package/src/table-formatter.ts

@@ -0,0 +1,94 @@
+// src/table-formatter.ts
+/**
+ * Simple table formatter that handles ANSI color codes correctly
+ */
+export function formatTable(data: Array<Record<string, any>>, options?: { title?: string }): void {
+    if (!data || data.length === 0) {
+        console.log('No data to display');
+        return;
+    }
+
+    // Print the title if provided
+    if (options?.title) {
+        console.log(`\n${options.title}`);
+    }
+
+    // Extract all unique keys from the data
+    const allKeys = new Set<string>();
+    data.forEach(item => {
+        Object.keys(item).forEach(key => allKeys.add(key));
+    });
+    const headers = Array.from(allKeys);
+
+    // Function to get visible string length (excluding ANSI color codes)
+    const getVisibleLength = (str: string): number => {
+        // Remove ANSI color codes for width calculation
+        return str.replace(/\x1B\[\d+m/g, '').length;
+    };
+
+    // Calculate the width of each column
+    const colWidths: Record<string, number> = {};
+    headers.forEach(header => {
+        // Start with the header width
+        colWidths[header] = header.length;
+
+        // Check each row for this column's value and update width if needed
+        data.forEach(row => {
+            const value = row[header] !== undefined ? String(row[header]) : '';
+            colWidths[header] = Math.max(colWidths[header], getVisibleLength(value));
+        });
+    });
+
+    // Function to pad a string to desired visible length, accounting for ANSI codes
+    const padString = (str: string, length: number, padChar = ' '): string => {
+        const visibleLength = getVisibleLength(str);
+        const paddingNeeded = Math.max(0, length - visibleLength);
+        return str + padChar.repeat(paddingNeeded);
+    };
+
+    // Create the header row
+    let headerRow = '│ ';
+    headers.forEach((header, index) => {
+        const isLast = index === headers.length - 1;
+        headerRow += padString(header, colWidths[header]) + (isLast ? ' │' : ' │ ');
+    });
+
+    // Create a separator row
+    let separator = '├─';
+    headers.forEach((header, index) => {
+        const isLast = index === headers.length - 1;
+        separator += '─'.repeat(colWidths[header]) + (isLast ? '─┤' : '─┼─');
+    });
+
+    // Create the top border
+    let topBorder = '┌─';
+    headers.forEach((header, index) => {
+        const isLast = index === headers.length - 1;
+        topBorder += '─'.repeat(colWidths[header]) + (isLast ? '─┐' : '─┬─');
+    });
+
+    // Create the bottom border
+    let bottomBorder = '└─';
+    headers.forEach((header, index) => {
+        const isLast = index === headers.length - 1;
+        bottomBorder += '─'.repeat(colWidths[header]) + (isLast ? '─┘' : '─┴─');
+    });
+
+    // Print the table
+    console.log(topBorder);
+    console.log(headerRow);
+    console.log(separator);
+
+    // Print each data row
+    data.forEach(row => {
+        let dataRow = '│ ';
+        headers.forEach((header, index) => {
+            const isLast = index === headers.length - 1;
+            const value = row[header] !== undefined ? String(row[header]) : '';
+            dataRow += padString(value, colWidths[header]) + (isLast ? ' │' : ' │ ');
+        });
+        console.log(dataRow);
+    });
+
+    console.log(bottomBorder);
+}