vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/analysis/line-counter.js

@@ -0,0 +1,513 @@
+/**
+ * Line Counter
+ * 
+ * Accurately counts lines in source files with support for different
+ * file types and exclusion of comments/blank lines.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Line count result class
+ */
+class LineCountResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.totalLines = 0;
+    this.codeLines = 0;
+    this.commentLines = 0;
+    this.blankLines = 0;
+    this.mixedLines = 0; // Lines with both code and comments
+    this.fileType = this.detectFileType();
+    this.encoding = 'utf8';
+    this.lineEnding = this.detectLineEnding();
+    this.errors = [];
+  }
+
+  detectFileType() {
+    const ext = path.extname(this.filePath).toLowerCase();
+    const typeMap = {
+      '.js': 'javascript',
+      '.jsx': 'javascript',
+      '.ts': 'typescript',
+      '.tsx': 'typescript',
+      '.md': 'markdown',
+      '.json': 'json',
+      '.yml': 'yaml',
+      '.yaml': 'yaml',
+      '.html': 'html',
+      '.css': 'css',
+      '.scss': 'scss',
+      '.less': 'less'
+    };
+    
+    return typeMap[ext] || 'text';
+  }
+
+  detectLineEnding() {
+    // This will be detected during file reading
+    return 'unknown';
+  }
+
+  addLine(type, content = '') {
+    this.totalLines++;
+    
+    switch (type) {
+      case 'code':
+        this.codeLines++;
+        break;
+      case 'comment':
+        this.commentLines++;
+        break;
+      case 'blank':
+        this.blankLines++;
+        break;
+      case 'mixed':
+        this.mixedLines++;
+        this.codeLines++;
+        this.commentLines++;
+        break;
+    }
+  }
+
+  getEffectiveLines() {
+    // Return code lines + mixed lines (effective code)
+    return this.codeLines;
+  }
+
+  getCommentRatio() {
+    return this.totalLines > 0 ? (this.commentLines / this.totalLines) : 0;
+  }
+
+  getBlankRatio() {
+    return this.totalLines > 0 ? (this.blankLines / this.totalLines) : 0;
+  }
+}
+
+/**
+ * Line counter class
+ */
+class LineCounter {
+  constructor(options = {}) {
+    this.options = {
+      countComments: true,
+      countBlanks: true,
+      detectMixed: true,
+      encoding: 'utf8',
+      maxFileSize: 10 * 1024 * 1024, // 10MB
+      ...options
+    };
+  }
+
+  /**
+   * Count lines in a single file
+   */
+  countFile(filePath) {
+    const result = new LineCountResult(filePath);
+    
+    try {
+      // Check file size
+      const stats = fs.statSync(filePath);
+      if (stats.size > this.options.maxFileSize) {
+        throw new Error(`File too large: ${stats.size} bytes`);
+      }
+
+      // Read file content
+      const content = fs.readFileSync(filePath, this.options.encoding);
+      
+      // Detect line ending
+      result.lineEnding = this.detectLineEnding(content);
+      
+      // Count lines based on file type
+      this.countLines(content, result);
+      
+    } catch (error) {
+      result.errors.push(error.message);
+    }
+
+    return result;
+  }
+
+  /**
+   * Count lines in multiple files
+   */
+  countFiles(filePaths) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = this.countFile(filePath);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Count lines in content string
+   */
+  countLines(content, result) {
+    const lines = content.split(/\r?\n/);
+    
+    for (const line of lines) {
+      this.analyzeLine(line, result);
+    }
+  }
+
+  /**
+   * Analyze a single line
+   */
+  analyzeLine(line, result) {
+    const trimmed = line.trim();
+    
+    // Empty line
+    if (trimmed === '') {
+      result.addLine('blank');
+      return;
+    }
+
+    // Analyze based on file type
+    switch (result.fileType) {
+      case 'javascript':
+      case 'typescript':
+        this.analyzeJavaScriptLine(line, trimmed, result);
+        break;
+      case 'markdown':
+        this.analyzeMarkdownLine(line, trimmed, result);
+        break;
+      case 'json':
+        this.analyzeJsonLine(line, trimmed, result);
+        break;
+      case 'yaml':
+        this.analyzeYamlLine(line, trimmed, result);
+        break;
+      default:
+        this.analyzeTextLine(line, trimmed, result);
+        break;
+    }
+  }
+
+  /**
+   * Analyze JavaScript/TypeScript line
+   */
+  analyzeJavaScriptLine(line, trimmed, result) {
+    // Single line comment
+    if (trimmed.startsWith('//')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Block comment
+    if (trimmed.startsWith('/*') || trimmed.startsWith('*')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // End of block comment
+    if (trimmed.endsWith('*/')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Check for mixed content (code + inline comment)
+    const commentIndex = line.indexOf('//');
+    if (commentIndex > 0 && !this.isInString(line, commentIndex)) {
+      if (this.options.detectMixed) {
+        result.addLine('mixed');
+      } else {
+        result.addLine('code');
+      }
+      return;
+    }
+
+    // Default to code
+    result.addLine('code');
+  }
+
+  /**
+   * Analyze Markdown line
+   */
+  analyzeMarkdownLine(line, trimmed, result) {
+    // HTML comment
+    if (trimmed.startsWith('<!--') || trimmed.startsWith('-->')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Markdown comment (custom syntax)
+    if (trimmed.startsWith('%%') || trimmed.startsWith('%')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Code block markers
+    if (trimmed.startsWith('```')) {
+      result.addLine('code');
+      return;
+    }
+
+    // Headers, lists, etc. are considered content
+    result.addLine('code');
+  }
+
+  /**
+   * Analyze JSON line
+   */
+  analyzeJsonLine(line, trimmed, result) {
+    // JSON doesn't have comments, but we can consider blank lines
+    if (trimmed === '') {
+      result.addLine('blank');
+    } else {
+      result.addLine('code');
+    }
+  }
+
+  /**
+   * Analyze YAML line
+   */
+  analyzeJsonLine(line, trimmed, result) {
+    // YAML comment
+    if (trimmed.startsWith('#')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Default to code
+    result.addLine('code');
+  }
+
+  /**
+   * Analyze YAML line (corrected method name)
+   */
+  analyzeYamlLine(line, trimmed, result) {
+    // YAML comment
+    if (trimmed.startsWith('#')) {
+      result.addLine('comment');
+      return;
+    }
+
+    // Default to code
+    result.addLine('code');
+  }
+
+  /**
+   * Analyze generic text line
+   */
+  analyzeTextLine(line, trimmed, result) {
+    if (trimmed === '') {
+      result.addLine('blank');
+    } else {
+      result.addLine('code');
+    }
+  }
+
+  /**
+   * Check if position is inside a string literal
+   */
+  isInString(line, position) {
+    let inString = false;
+    let stringChar = null;
+    let escaped = false;
+
+    for (let i = 0; i < position; i++) {
+      const char = line[i];
+      
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+
+      if (char === '\\') {
+        escaped = true;
+        continue;
+      }
+
+      if (!inString && (char === '"' || char === "'" || char === '`')) {
+        inString = true;
+        stringChar = char;
+      } else if (inString && char === stringChar) {
+        inString = false;
+        stringChar = null;
+      }
+    }
+
+    return inString;
+  }
+
+  /**
+   * Detect line ending type
+   */
+  detectLineEnding(content) {
+    if (content.includes('\r\n')) {
+      return 'crlf';
+    } else if (content.includes('\n')) {
+      return 'lf';
+    } else if (content.includes('\r')) {
+      return 'cr';
+    }
+    return 'none';
+  }
+
+  /**
+   * Get summary statistics for multiple results
+   */
+  getSummary(results) {
+    const summary = {
+      totalFiles: results.length,
+      totalLines: 0,
+      totalCodeLines: 0,
+      totalCommentLines: 0,
+      totalBlankLines: 0,
+      totalMixedLines: 0,
+      averageLines: 0,
+      largestFile: null,
+      smallestFile: null,
+      byFileType: {},
+      errors: []
+    };
+
+    for (const result of results) {
+      // Accumulate totals
+      summary.totalLines += result.totalLines;
+      summary.totalCodeLines += result.codeLines;
+      summary.totalCommentLines += result.commentLines;
+      summary.totalBlankLines += result.blankLines;
+      summary.totalMixedLines += result.mixedLines;
+
+      // Track largest and smallest files
+      if (!summary.largestFile || result.totalLines > summary.largestFile.totalLines) {
+        summary.largestFile = result;
+      }
+      if (!summary.smallestFile || result.totalLines < summary.smallestFile.totalLines) {
+        summary.smallestFile = result;
+      }
+
+      // Group by file type
+      if (!summary.byFileType[result.fileType]) {
+        summary.byFileType[result.fileType] = {
+          count: 0,
+          totalLines: 0,
+          averageLines: 0
+        };
+      }
+      const typeStats = summary.byFileType[result.fileType];
+      typeStats.count++;
+      typeStats.totalLines += result.totalLines;
+
+      // Collect errors
+      if (result.errors.length > 0) {
+        summary.errors.push({
+          file: result.filePath,
+          errors: result.errors
+        });
+      }
+    }
+
+    // Calculate averages
+    summary.averageLines = summary.totalFiles > 0 ? 
+      Math.round(summary.totalLines / summary.totalFiles) : 0;
+
+    for (const typeStats of Object.values(summary.byFileType)) {
+      typeStats.averageLines = typeStats.count > 0 ? 
+        Math.round(typeStats.totalLines / typeStats.count) : 0;
+    }
+
+    return summary;
+  }
+
+  /**
+   * Find files exceeding line limit
+   */
+  findExceedingLimit(results, limit = 555) {
+    return results.filter(result => result.totalLines > limit);
+  }
+
+  /**
+   * Find files approaching line limit
+   */
+  findApproachingLimit(results, limit = 555, threshold = 0.9) {
+    const warningThreshold = Math.floor(limit * threshold);
+    return results.filter(result => 
+      result.totalLines > warningThreshold && result.totalLines <= limit
+    );
+  }
+
+  /**
+   * Sort results by line count
+   */
+  sortByLineCount(results, descending = true) {
+    return [...results].sort((a, b) => {
+      return descending ? b.totalLines - a.totalLines : a.totalLines - b.totalLines;
+    });
+  }
+
+  /**
+   * Export results to CSV
+   */
+  exportToCsv(results, filePath) {
+    const headers = [
+      'File Path',
+      'File Type',
+      'Total Lines',
+      'Code Lines',
+      'Comment Lines',
+      'Blank Lines',
+      'Mixed Lines',
+      'Comment Ratio',
+      'Blank Ratio'
+    ];
+
+    const rows = results.map(result => [
+      result.filePath,
+      result.fileType,
+      result.totalLines,
+      result.codeLines,
+      result.commentLines,
+      result.blankLines,
+      result.mixedLines,
+      result.getCommentRatio().toFixed(3),
+      result.getBlankRatio().toFixed(3)
+    ]);
+
+    const csvContent = [headers, ...rows]
+      .map(row => row.map(cell => `"${cell}"`).join(','))
+      .join('\n');
+
+    fs.writeFileSync(filePath, csvContent, 'utf8');
+    return filePath;
+  }
+
+  /**
+   * Export results to JSON
+   */
+  exportToJson(results, filePath) {
+    const exportData = {
+      metadata: {
+        exportedAt: new Date().toISOString(),
+        options: this.options
+      },
+      summary: this.getSummary(results),
+      results: results.map(result => ({
+        filePath: result.filePath,
+        fileType: result.fileType,
+        totalLines: result.totalLines,
+        codeLines: result.codeLines,
+        commentLines: result.commentLines,
+        blankLines: result.blankLines,
+        mixedLines: result.mixedLines,
+        commentRatio: result.getCommentRatio(),
+        blankRatio: result.getBlankRatio(),
+        lineEnding: result.lineEnding,
+        errors: result.errors
+      }))
+    };
+
+    fs.writeFileSync(filePath, JSON.stringify(exportData, null, 2));
+    return filePath;
+  }
+}
+
+module.exports = {
+  LineCounter,
+  LineCountResult
+};