@cod3vil/kount-cli 1.0.0

package/src/scanner/stream-reader.ts

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { IgnoreParser } from './ignore-parser.js';
+
+export interface ScannedFile {
+  filePath: string;
+  size: number;
+}
+
+export type FileChunkCallback = (chunk: Buffer, isLast: boolean) => void;
+
+/**
+ * Recursively walks directories and streams files chunk-by-chunk.
+ * Respects .gitignore and built-in binary exclusions via IgnoreParser.
+ */
+export class Scanner {
+  private parser: IgnoreParser;
+
+  constructor(rootDir: string, respectGitignore: boolean = true) {
+    this.parser = new IgnoreParser(rootDir, respectGitignore);
+  }
+
+  /**
+   * Discovers all files in the directory tree matching rules.
+   */
+  async discover(dirPath: string): Promise<ScannedFile[]> {
+    await this.parser.init();
+    return this.walk(path.resolve(dirPath));
+  }
+
+  private async walk(currentDir: string): Promise<ScannedFile[]> {
+    const filesList: ScannedFile[] = [];
+
+    // Provide ignore rules for this specific directory level
+    await this.parser.loadIgnoreForDir(currentDir);
+
+    try {
+      const entries = await fsp.readdir(currentDir, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentDir, entry.name);
+
+        // Check ignore rules immediately to avoid stat calls on ignored paths
+        if (this.parser.isIgnored(fullPath, entry.isDirectory())) {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          const subFiles = await this.walk(fullPath);
+          filesList.push(...subFiles);
+        } else if (entry.isFile()) {
+           try {
+             // We need the size, though we could get it via stats here or let the caller do it.
+             // We'll calculate it so plugins can use it.
+             const stats = await fsp.stat(fullPath);
+             filesList.push({ filePath: fullPath, size: stats.size });
+           } catch (e) {
+             // Handle gracefully: e.g. broken symlink or permission denied
+             // Could hook a logger here later.
+           }
+        }
+      }
+    } catch (e) {
+        // e.g. Permission denied on directory
+    }
+
+    return filesList;
+  }
+
+  /**
+   * Streams a file in chunks without reading the whole file into memory.
+   */
+  streamFile(filePath: string, onChunk: FileChunkCallback): Promise<void> {
+    return new Promise((resolve, reject) => {
+      // High water mark set to a reasonable chunk size (e.g. 64KB) to keep memory low
+      const stream = fs.createReadStream(filePath, { highWaterMark: 64 * 1024 });
+
+      stream.on('data', (chunk: Buffer | string) => {
+        // Enforce Buffer
+        const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        // We pass false for `isLast` because we don't know yet.
+        // We will signal `isLast` on 'end' if needed, but typically passing the chunk is enough.
+        // For line counting plugins relying on chunks, we might need a signal to flush remaining lines.
+        onChunk(bufferChunk, false);
+      });
+
+      stream.on('error', (err) => {
+        reject(err);
+      });
+
+      stream.on('end', () => {
+        // Send a final empty chunk with isLast = true so plugins can flush state.
+        onChunk(Buffer.alloc(0), true);
+        resolve();
+      });
+    });
+  }
+}

package/src/utils/language-map.ts

@@ -0,0 +1,79 @@
+/**
+ * Maps file extensions to their corresponding comment syntaxes.
+ * This is used by the comment-lines plugin to accurately count comments.
+ */
+export const LANGUAGE_COMMENT_MAP: Record<string, string[]> = {
+  // C-style (JS, TS, Java, C, C++, C#, Go, Swift, Rust, Kotlin, Dart, Scala, Objective-C)
+  '.js': ['//', '/* */'],
+  '.ts': ['//', '/* */'],
+  '.jsx': ['//', '/* */'],
+  '.tsx': ['//', '/* */'],
+  '.java': ['//', '/* */'],
+  '.c': ['//', '/* */'],
+  '.cpp': ['//', '/* */'],
+  '.cs': ['//', '/* */'],
+  '.go': ['//', '/* */'],
+  '.swift': ['//', '/* */'],
+  '.rs': ['//', '/* */'],
+  '.kt': ['//', '/* */'],
+  '.dart': ['//', '/* */'],
+  '.scala': ['//', '/* */'],
+  '.m': ['//', '/* */'],
+  '.mm': ['//', '/* */'],
+  '.css': ['/* */'],
+  '.scss': ['//', '/* */'],
+  '.less': ['//', '/* */'],
+
+  // Hash-style (Python, Ruby, Shell, YAML, Perl, PHP (also uses //), R, PowerShell, Makefile)
+  '.py': ['#'],
+  '.rb': ['#'],
+  '.sh': ['#'],
+  '.bash': ['#'],
+  '.zsh': ['#'],
+  '.yaml': ['#'],
+  '.yml': ['#'],
+  '.pl': ['#'],
+  '.pm': ['#'],
+  '.r': ['#'],
+  '.ps1': ['#'],
+  'makefile': ['#'], // Note: Makefile might not have an extension, handle separately if needed
+
+  // HTML/XML-style (HTML, XML, SVG, Markdown, Vue)
+  '.html': ['<!-- -->'],
+  '.htm': ['<!-- -->'],
+  '.xml': ['<!-- -->'],
+  '.svg': ['<!-- -->'],
+  '.md': ['<!-- -->'],
+  '.vue': ['<!-- -->', '//', '/* */'], // Vue can have JS/TS inside <script> and CSS inside <style>
+
+  // Dash-style (SQL, Lua, Haskell, Ada, VHDL)
+  '.sql': ['--'],
+  '.lua': ['--'],
+  '.hs': ['--'],
+  '.ada': ['--'],
+  '.vhdl': ['--'],
+
+  // Lisp-style (Lisp, Clojure, Scheme)
+  '.lisp': [';'],
+  '.clj': [';'],
+  '.scm': [';'],
+
+  // PHP
+  '.php': ['//', '#', '/* */'],
+
+  // JSON (Standard JSON has no comments, but JSONC allowing comments is common in tools)
+  '.jsonc': ['//', '/* */'],
+};
+
+/**
+ * Returns the expected comment syntax array for a given file extension.
+ * If the extension is not mapped, returns an empty array.
+ * 
+ * @param extension The file extension including the dot (e.g., '.ts')
+ * @returns Array of comment syntaxes (e.g., ['//', '/* *\/']) or empty array if not found.
+ */
+export function getCommentSyntax(extension: string): string[] {
+  // Ensure the extension starts with a dot if it's not a known full filename like Makefile
+  const normalizedExt = extension.toLowerCase();
+  return LANGUAGE_COMMENT_MAP[normalizedExt] || [];
+}