@cod3vil/kount-cli 1.0.0 → 1.0.1

package/src/reporters/terminal/Summary.tsx

@@ -1,135 +0,0 @@
-import { Box, Text } from 'ink';
-import path from 'node:path';
-import React from 'react';
-import type { ProjectStats } from '../../plugins/types.js';
-
-interface SummaryProps {
-  stats: ProjectStats;
-}
-
-/**
- * Final summary display after scan completes.
- * Strict color-coding: green for success-like values, no emojis.
- * Follows ux-color-semantics and ux-next-steps guidelines.
- */
-export function Summary({ stats }: SummaryProps): React.ReactElement {
-  const totalLines = stats.pluginResults.get('TotalLines')?.summaryValue ?? 0;
-  const blankLines = stats.pluginResults.get('BlankLines')?.summaryValue ?? 0;
-  const commentLines = stats.pluginResults.get('CommentLines')?.summaryValue ?? 0;
-  const totalBytes = stats.pluginResults.get('FileSize')?.summaryValue ?? 0;
-  const codeLines = totalLines - blankLines - commentLines;
-  const codeRatio = totalLines > 0 ? ((codeLines / totalLines) * 100).toFixed(1) : '0.0';
-
-  // Format bytes
-  const formatSize = (bytes: number): string => {
-    if (bytes < 1024) return `${bytes} B`;
-    if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  };
-
-  // Sort language distribution descending
-  const sortedLangs = [...stats.languageDistribution.entries()]
-    .sort((a, b) => b[1] - a[1]);
-
-  return (
-    <Box flexDirection="column" marginY={1}>
-      {/* Summary Section */}
-      <Box
-        flexDirection="column"
-        borderStyle="single"
-        borderColor="green"
-        paddingX={2}
-        paddingY={1}
-      >
-        <Text color="green" bold>  SCAN RESULTS</Text>
-        <Box marginTop={1} flexDirection="column">
-          <Box>
-            <Box width={20}><Text color="white">Files</Text></Box>
-            <Text color="cyan" bold>{stats.totalFiles.toLocaleString()}</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Total Lines</Text></Box>
-            <Text color="cyan" bold>{totalLines.toLocaleString()}</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Code Lines</Text></Box>
-            <Text color="green" bold>{codeLines.toLocaleString()}</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Comment Lines</Text></Box>
-            <Text color="yellow" bold>{commentLines.toLocaleString()}</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Blank Lines</Text></Box>
-            <Text color="gray" bold>{blankLines.toLocaleString()}</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Code Ratio</Text></Box>
-            <Text color="green" bold>{codeRatio}%</Text>
-          </Box>
-          <Box>
-            <Box width={20}><Text color="white">Total Size</Text></Box>
-            <Text color="cyan" bold>{formatSize(totalBytes)}</Text>
-          </Box>
-        </Box>
-      </Box>
-
-      {/* Language Distribution */}
-      {sortedLangs.length > 0 && (
-        <Box
-          flexDirection="column"
-          borderStyle="single"
-          borderColor="blue"
-          paddingX={2}
-          paddingY={1}
-          marginTop={1}
-        >
-          <Text color="blue" bold>  LANGUAGE DISTRIBUTION</Text>
-          <Box marginTop={1} flexDirection="column">
-            {sortedLangs.map(([lang, count]) => {
-              const pct = ((count / stats.totalFiles) * 100).toFixed(1);
-              return (
-                <Box key={lang}>
-                  <Box width={22}><Text color="white">{lang}</Text></Box>
-                  <Box width={8}><Text color="cyan">{count} files</Text></Box>
-                  <Text color="gray"> ({pct}%)</Text>
-                </Box>
-              );
-            })}
-          </Box>
-        </Box>
-      )}
-
-      {/* Largest Files */}
-      {stats.largestFiles.length > 0 && (
-        <Box
-          flexDirection="column"
-          borderStyle="single"
-          borderColor="magenta"
-          paddingX={2}
-          paddingY={1}
-          marginTop={1}
-        >
-          <Text color="magenta" bold>  TOP {stats.largestFiles.length} LARGEST FILES</Text>
-          <Box marginTop={1} flexDirection="column">
-            {stats.largestFiles.map((file, i) => {
-              const relPath = path.relative(stats.rootDir, file.filePath);
-              return (
-                <Box key={file.filePath}>
-                  <Box width={4}><Text color="gray">{i + 1}.</Text></Box>
-                  <Box width={40}><Text color="white" wrap="truncate-end">{relPath}</Text></Box>
-                  <Text color="yellow">{formatSize(file.size)}</Text>
-                </Box>
-              );
-            })}
-          </Box>
-        </Box>
-      )}
-
-      {/* Footer */}
-      <Box marginTop={1}>
-        <Text color="gray">Scanned at {stats.scannedAt.toLocaleString()}</Text>
-      </Box>
-    </Box>
-  );
-}

package/src/reporters/terminal/Wizard.tsx

@@ -1,125 +0,0 @@
-import { Box, Text, useApp, useInput } from 'ink';
-import React, { useCallback, useState } from 'react';
-
-export interface WizardResult {
-  rootDir: string;
-  outputMode: 'terminal' | 'markdown' | 'html';
-  includeTests: boolean;
-}
-
-interface WizardProps {
-  onComplete: (result: WizardResult) => void;
-}
-
-type Step = 'rootDir' | 'outputMode' | 'includeTests';
-
-const OUTPUT_MODES = ['terminal', 'markdown', 'html'] as const;
-
-/**
- * Minimal interactive step-based wizard when no CLI flags are provided.
- * Follows prompt-group-flow, input-useinput-hook, input-escape-routes guidelines.
- */
-export function Wizard({ onComplete }: WizardProps): React.ReactElement {
-  const { exit } = useApp();
-  const [step, setStep] = useState<Step>('rootDir');
-  const [rootDir, setRootDir] = useState('.');
-  const [rootDirInput, setRootDirInput] = useState('.');
-  const [outputModeIndex, setOutputModeIndex] = useState(0);
-  const [includeTestsIndex, setIncludeTestsIndex] = useState(0);
-
-  const boolOptions = ['Yes', 'No'] as const;
-
-  useInput(useCallback((input: string, key: { return?: boolean; escape?: boolean; upArrow?: boolean; downArrow?: boolean; backspace?: boolean; delete?: boolean }) => {
-    // Escape route
-    if (key.escape) {
-      exit();
-      return;
-    }
-
-    if (step === 'rootDir') {
-      if (key.return) {
-        setRootDir(rootDirInput || '.');
-        setStep('outputMode');
-      } else if (key.backspace || key.delete) {
-        setRootDirInput(prev => prev.slice(0, -1));
-      } else if (input && !key.upArrow && !key.downArrow) {
-        setRootDirInput(prev => prev + input);
-      }
-    } else if (step === 'outputMode') {
-      if (key.upArrow) {
-        setOutputModeIndex(prev => (prev - 1 + OUTPUT_MODES.length) % OUTPUT_MODES.length);
-      } else if (key.downArrow) {
-        setOutputModeIndex(prev => (prev + 1) % OUTPUT_MODES.length);
-      } else if (key.return) {
-        setStep('includeTests');
-      }
-    } else if (step === 'includeTests') {
-      if (key.upArrow || key.downArrow) {
-        setIncludeTestsIndex(prev => (prev + 1) % 2);
-      } else if (key.return) {
-        onComplete({
-          rootDir: rootDir,
-          outputMode: OUTPUT_MODES[outputModeIndex],
-          includeTests: includeTestsIndex === 0,
-        });
-      }
-    }
-  }, [step, rootDirInput, rootDir, outputModeIndex, includeTestsIndex, onComplete, exit]));
-
-  return (
-    <Box flexDirection="column" paddingX={1} paddingY={1}>
-      <Text color="cyan" bold>KOUNT Setup Wizard</Text>
-      <Text color="gray">Press ESC to cancel at any time.</Text>
-      <Box marginTop={1} flexDirection="column">
-
-        {/* Step 1: Root Directory */}
-        <Box flexDirection="column">
-          <Text color={step === 'rootDir' ? 'white' : 'green'} bold>
-            {step === 'rootDir' ? '>' : '✓'} Root directory:
-            {step !== 'rootDir' && <Text color="cyan"> {rootDir}</Text>}
-          </Text>
-          {step === 'rootDir' && (
-            <Box marginLeft={2}>
-              <Text color="cyan">{rootDirInput}</Text>
-              <Text color="gray">█</Text>
-            </Box>
-          )}
-        </Box>
-
-        {/* Step 2: Output Mode */}
-        {(step === 'outputMode' || step === 'includeTests') && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color={step === 'outputMode' ? 'white' : 'green'} bold>
-              {step === 'outputMode' ? '>' : '✓'} Output mode:
-              {step !== 'outputMode' && <Text color="cyan"> {OUTPUT_MODES[outputModeIndex]}</Text>}
-            </Text>
-            {step === 'outputMode' && (
-              <Box marginLeft={2} flexDirection="column">
-                {OUTPUT_MODES.map((mode, i) => (
-                  <Text key={mode} color={i === outputModeIndex ? 'cyan' : 'gray'}>
-                    {i === outputModeIndex ? '> ' : '  '}{mode}
-                  </Text>
-                ))}
-              </Box>
-            )}
-          </Box>
-        )}
-
-        {/* Step 3: Include Tests */}
-        {step === 'includeTests' && (
-          <Box flexDirection="column" marginTop={1}>
-            <Text color="white" bold>{'>'} Include test files?</Text>
-            <Box marginLeft={2} flexDirection="column">
-              {boolOptions.map((opt, i) => (
-                <Text key={opt} color={i === includeTestsIndex ? 'cyan' : 'gray'}>
-                  {i === includeTestsIndex ? '> ' : '  '}{opt}
-                </Text>
-              ))}
-            </Box>
-          </Box>
-        )}
-
-      </Box>
-    </Box>
-  );
-}

package/src/reporters/terminal/index.ts

@@ -1,6 +0,0 @@
-export { Progress } from './Progress.js';
-export { Splash } from './Splash.js';
-export { Summary } from './Summary.js';
-export { Wizard } from './Wizard.js';
-export type { WizardResult } from './Wizard.js';
-

package/src/scanner/ignore-parser.ts

@@ -1,168 +0,0 @@
-import ignore, { Ignore } from 'ignore';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-const DEFAULT_IGNORES = [
-  'node_modules',
-  'dist',
-  'build',
-  '.git',
-  '.next',
-  '.nuxt',
-  'coverage',
-  '.kountcache.json', // Our own cache file
-];
-
-interface IgnoreContext {
-  ig: Ignore;
-  dir: string;
-}
-
-/**
- * Parses ignore files and builds a matcher set for a given directory tree.
- * Respects default ignores automatically.
- */
-export class IgnoreParser {
-  // Store ignore instances keyed by directory path
-  private directoryIgnores = new Map<string, Ignore>();
-  private rootDir: string;
-  private respectGitignore: boolean;
-  
-  // Track binary extensions to filter out automatically
-  private static readonly BINARY_EXTENSIONS = new Set([
-    '.png', '.jpg', '.jpeg', '.gif', '.ico', '.svg', '.webp', '.tiff', '.bmp',
-    '.mp4', '.mkv', '.avi', '.mov', '.wmv', '.webm', '.flv',
-    '.mp3', '.wav', '.ogg', '.flac', '.aac', '.m4a',
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.zip', '.tar', '.gz', '.7z', '.rar', '.bz2', '.xz',
-    '.exe', '.dll', '.so', '.dylib', '.bin', '.dat', '.db', '.sqlite',
-    '.app', '.dmg', '.iso', '.class', '.jar', '.war', '.ear',
-    '.woff', '.woff2', '.ttf', '.eot', '.otf',
-    '.pyc', '.pyo', '.pyd', '.o', '.a', '.lib', '.out',
-    '.wasm'
-  ]);
-
-  constructor(rootDir: string, respectGitignore: boolean = true) {
-    this.rootDir = path.resolve(rootDir);
-    this.respectGitignore = respectGitignore;
-  }
-
-  /**
-   * Initializes the base ignores (defaults + root .kountignore/.gitignore).
-   * Call this before walking.
-   */
-  async init(): Promise<void> {
-    const rootIg = ignore().add(DEFAULT_IGNORES);
-    await this.loadIgnoreFiles(this.rootDir, rootIg);
-    this.directoryIgnores.set(this.rootDir, rootIg);
-  }
-
-  /**
-   * Loads `.gitignore` or `.kountignore` inside a specific directory.
-   */
-  async loadIgnoreForDir(dirPath: string): Promise<void> {
-    if (this.directoryIgnores.has(dirPath)) return;
-
-    // Inherit from parent directory (if any) or fallback to root if not loaded somehow
-    const parentDir = path.dirname(dirPath);
-    const parentIg = this.directoryIgnores.get(parentDir) || this.directoryIgnores.get(this.rootDir);
-    
-    // Create a new instance starting with parent's rules.  Wait, ignore doesn't deep clone easily.
-    // Instead, we just maintain a stack of ig instances during walk, but for class-level,
-    // we can create a fresh ignore and add parent's rules if we tracked them, OR just test
-    // a path against all ignores from root to current dir.
-    // For simplicity and speed: We will test a relative path against an array of ignores.
-    
-    // Actually, ignore is designed to be used by resolving paths relative to where the .gitignore is.
-    // Let's store rules per directory.
-    const ig = ignore();
-    const hasRules = await this.loadIgnoreFiles(dirPath, ig);
-    
-    // If no new rules, we don't strictly need to store it, but let's store undefined or similar
-    // to mark it processed.
-    if (hasRules) {
-        this.directoryIgnores.set(dirPath, ig);
-    }
-  }
-
-  /**
-   * Helper to append rules from files to an Ignore instance.
-   * Returns true if rules were added.
-   */
-  private async loadIgnoreFiles(dirPath: string, ig: Ignore): Promise<boolean> {
-    let hasRules = false;
-
-    // Load .kountignore first (custom rules overrides everything else if needed, though ignore merges them)
-    try {
-      const kountIgnorePath = path.join(dirPath, '.kountignore');
-      const kountRules = await fs.readFile(kountIgnorePath, 'utf8');
-      ig.add(kountRules);
-      hasRules = true;
-    } catch (e) { /* ignores missing file */ }
-
-    // Load .gitignore
-    if (this.respectGitignore) {
-      try {
-        const gitIgnorePath = path.join(dirPath, '.gitignore');
-        const gitRules = await fs.readFile(gitIgnorePath, 'utf8');
-        ig.add(gitRules);
-        hasRules = true;
-      } catch (e) { /* ignores missing file */ }
-    }
-
-    return hasRules;
-  }
-
-  /**
-   * Checks if an absolute path should be ignored.
-   */
-  isIgnored(absolutePath: string, isDirectory: boolean): boolean {
-    // 1. Binary check
-    if (!isDirectory) {
-      const ext = path.extname(absolutePath).toLowerCase();
-      if (IgnoreParser.BINARY_EXTENSIONS.has(ext)) {
-        return true;
-      }
-    }
-
-    // 2. Resolve relative to root to check against ignores
-    const relativeToRoot = path.relative(this.rootDir, absolutePath);
-    
-    // Edge case: if it evaluates to empty string (which means absolutePath == rootDir), don't ignore
-    if (relativeToRoot === '') return false;
-
-    // We need to check the path formatted for `ignore` package (forward slashes)
-    // and if it's a directory, adding a trailing slash helps `ignore` match dir-only rules eagerly.
-    const posixPath = relativeToRoot.split(path.sep).join('/');
-    const testPath = isDirectory ? `${posixPath}/` : posixPath;
-
-    // 3. Test against root ignores first (which contains defaults)
-    const rootIg = this.directoryIgnores.get(this.rootDir);
-    if (rootIg && rootIg.ignores(testPath)) {
-        return true;
-    }
-
-    // 4. Test against nested directory ignores (from root down to the file's dir)
-    // E.g. for src/components/Button.tsx, check src/ and src/components/
-    const parts = relativeToRoot.split(path.sep);
-    let currentPath = this.rootDir;
-
-    for (let i = 0; i < parts.length - 1; i++) { // -1 because we don't need to check in the file's own name as a dir
-      currentPath = path.join(currentPath, parts[i]);
-      const dirIg = this.directoryIgnores.get(currentPath);
-      
-      if (dirIg) {
-          // The ignore package checks paths relative to where the .gitignore file is located.
-          const relToIgnoreFile = path.relative(currentPath, absolutePath);
-          const relPosixPath = relToIgnoreFile.split(path.sep).join('/');
-          const nestedTestPath = isDirectory ? `${relPosixPath}/` : relPosixPath;
-          
-          if (dirIg.ignores(nestedTestPath)) {
-              return true;
-          }
-      }
-    }
-
-    return false;
-  }
-}

package/src/scanner/stream-reader.ts

@@ -1,99 +0,0 @@
-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

@@ -1,79 +0,0 @@
-/**
- * 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] || [];
-}