@cod3vil/kount-cli 1.0.0 → 1.0.1

package/src/index.tsx

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-
-import React, { useState, useEffect, useCallback } from 'react';
-import { render, Box, Text, useApp } from 'ink';
-import { createCli } from './cli/parser.js';
-import { resolveConfig } from './cli/config-resolver.js';
-import type { KountConfig } from './cli/config-resolver.js';
-import { Aggregator } from './core/aggregator.js';
-import type { ProjectStats } from './plugins/types.js';
-import { Splash } from './reporters/terminal/Splash.js';
-import { Progress } from './reporters/terminal/Progress.js';
-import { Summary } from './reporters/terminal/Summary.js';
-import { Wizard } from './reporters/terminal/Wizard.js';
-import type { WizardResult } from './reporters/terminal/Wizard.js';
-import { writeMarkdownReport } from './reporters/markdown.js';
-import { serveHtmlDashboard } from './reporters/html.js';
-
-// ---------------------------------------------------------------------------
-// Non-interactive execution (markdown / html modes, or terminal with flags)
-// ---------------------------------------------------------------------------
-
-async function runHeadless(config: KountConfig): Promise<void> {
-    const aggregator = new Aggregator(config.rootDir, {
-        respectGitignore: config.respectGitignore,
-        cacheEnabled: config.cache.enabled,
-        clearCache: config.cache.clearFirst,
-    });
-
-    const stats = await aggregator.run();
-
-    if (config.outputMode === 'markdown') {
-        const outputPath = await writeMarkdownReport(stats, config.outputPath, config.force);
-        process.stdout.write(`Markdown report written to ${outputPath}\n`);
-    } else if (config.outputMode === 'html') {
-        const { url } = await serveHtmlDashboard(stats);
-        process.stdout.write(`Dashboard running at ${url}\nPress Ctrl+C to stop.\n`);
-    }
-}
-
-// ---------------------------------------------------------------------------
-// Ink Terminal UI App
-// ---------------------------------------------------------------------------
-
-type AppPhase = 'splash' | 'wizard' | 'scanning' | 'done';
-
-interface AppProps {
-    config: KountConfig;
-    needsWizard: boolean;
-}
-
-function App({ config: initialConfig, needsWizard }: AppProps): React.ReactElement {
-    const { exit } = useApp();
-    const [phase, setPhase] = useState<AppPhase>(needsWizard ? 'splash' : 'scanning');
-    const [config, setConfig] = useState<KountConfig>(initialConfig);
-    const [progress, setProgress] = useState({ current: 0, total: 0, file: '' });
-    const [stats, setStats] = useState<ProjectStats | null>(null);
-    const [error, setError] = useState<string | null>(null);
-
-    // Show splash briefly, then move to wizard
-    useEffect(() => {
-        if (phase === 'splash') {
-            const timer = setTimeout(() => setPhase('wizard'), 1500);
-            return () => clearTimeout(timer);
-        }
-        return undefined;
-    }, [phase]);
-
-    // Run the scan when entering the scanning phase
-    useEffect(() => {
-        if (phase !== 'scanning') return;
-
-        const aggregator = new Aggregator(config.rootDir, {
-            respectGitignore: config.respectGitignore,
-            cacheEnabled: config.cache.enabled,
-            clearCache: config.cache.clearFirst,
-        });
-
-        aggregator
-            .run((current, total, filePath) => {
-                setProgress({ current, total, file: filePath });
-            })
-            .then((result) => {
-                setStats(result);
-                setPhase('done');
-            })
-            .catch((err: unknown) => {
-                setError(err instanceof Error ? err.message : String(err));
-                setPhase('done');
-            });
-    }, [phase, config]);
-
-    const handleWizardComplete = useCallback((result: WizardResult) => {
-        setConfig((prev) => ({
-            ...prev,
-            rootDir: result.rootDir,
-            outputMode: result.outputMode,
-            includeTests: result.includeTests,
-        }));
-        setPhase('scanning');
-    }, []);
-
-    // Auto-exit after done phase is displayed
-    useEffect(() => {
-        if (phase === 'done' && stats) {
-            // Give the user a moment to see the results
-            const timer = setTimeout(() => exit(), 500);
-            return () => clearTimeout(timer);
-        }
-        return undefined;
-    }, [phase, stats, exit]);
-
-    return (
-        <Box flexDirection= "column" >
-        { phase === 'splash' && <Splash />
-}
-{ phase === 'wizard' && <Wizard onComplete={ handleWizardComplete } /> }
-{
-    phase === 'scanning' && (
-        <Box flexDirection="column" >
-            <Progress
-            current={ progress.current }
-    total = { progress.total }
-    currentFile = { progress.file }
-        />
-        </Box>
-      )
-}
-{
-    phase === 'done' && error && (
-        <Box marginY={ 1 }>
-            <Text color="red" bold > Error: { error } </Text>
-                </Box>
-      )
-}
-{ phase === 'done' && stats && <Summary stats={ stats } /> }
-</Box>
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Main
-// ---------------------------------------------------------------------------
-
-async function main(): Promise<void> {
-    const cliFlags = createCli(process.argv);
-    const config = await resolveConfig(cliFlags);
-
-    if (config.outputMode === 'terminal') {
-        // Determine if we need the wizard (no explicit flags were passed)
-        const hasExplicitFlags = cliFlags.rootDir !== undefined || cliFlags.outputMode !== undefined;
-
-        render(
-            React.createElement(App, {
-                config,
-                needsWizard: !hasExplicitFlags,
-            })
-        );
-    } else {
-        // Markdown or HTML — run headless
-        await runHeadless(config);
-    }
-}
-
-main().catch((err: unknown) => {
-    process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}\n`);
-    process.exit(1);
-});

package/src/plugins/built-in/blank-lines.ts

@@ -1,26 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Counts blank (empty or whitespace-only) lines across all scanned files.
- */
-export class BlankLinesPlugin implements AnalyzerPlugin {
-  readonly name = 'BlankLines';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const perFile = new Map<string, number>();
-    let summaryValue = 0;
-
-    for (const file of files) {
-      let blankCount = 0;
-      for (const line of file.lines) {
-        if (line.trim() === '') {
-          blankCount++;
-        }
-      }
-      perFile.set(file.filePath, blankCount);
-      summaryValue += blankCount;
-    }
-
-    return { pluginName: this.name, summaryValue, perFile };
-  }
-}

package/src/plugins/built-in/comment-lines.ts

@@ -1,90 +0,0 @@
-import { getCommentSyntax } from '../../utils/language-map.js';
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Counts comment lines across all scanned files.
- * Handles single-line comments (//, #, --, ;) and block comments (/* *​/, <!-- -->).
- */
-export class CommentLinesPlugin implements AnalyzerPlugin {
-  readonly name = 'CommentLines';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const perFile = new Map<string, number>();
-    let summaryValue = 0;
-
-    for (const file of files) {
-      const commentCount = this.countComments(file);
-      perFile.set(file.filePath, commentCount);
-      summaryValue += commentCount;
-    }
-
-    return { pluginName: this.name, summaryValue, perFile };
-  }
-
-  private countComments(file: AnalyzedFileData): number {
-    const syntaxes = getCommentSyntax(file.extension);
-    if (syntaxes.length === 0) return 0;
-
-    // Separate single-line and block comment markers
-    const singleLineMarkers: string[] = [];
-    const blockMarkers: Array<{ open: string; close: string }> = [];
-
-    for (const syntax of syntaxes) {
-      if (syntax.includes(' ')) {
-        // Block comment syntax like '/* */' or '<!-- -->'
-        const parts = syntax.split(' ');
-        if (parts.length === 2) {
-          blockMarkers.push({ open: parts[0], close: parts[1] });
-        }
-      } else {
-        // Single-line comment syntax like '//' or '#'
-        singleLineMarkers.push(syntax);
-      }
-    }
-
-    let commentCount = 0;
-    let inBlockComment = false;
-    let currentBlockClose = '';
-
-    for (const line of file.lines) {
-      const trimmed = line.trim();
-
-      if (inBlockComment) {
-        commentCount++;
-        if (trimmed.includes(currentBlockClose)) {
-          inBlockComment = false;
-          currentBlockClose = '';
-        }
-        continue;
-      }
-
-      // Check for block comment opening
-      let isBlockStart = false;
-      for (const block of blockMarkers) {
-        if (trimmed.includes(block.open)) {
-          commentCount++;
-          isBlockStart = true;
-          // Check if block closes on the same line
-          const afterOpen = trimmed.substring(trimmed.indexOf(block.open) + block.open.length);
-          if (!afterOpen.includes(block.close)) {
-            inBlockComment = true;
-            currentBlockClose = block.close;
-          }
-          break;
-        }
-      }
-
-      if (isBlockStart) continue;
-
-      // Check for single-line comments
-      for (const marker of singleLineMarkers) {
-        if (trimmed.startsWith(marker)) {
-          commentCount++;
-          break;
-        }
-      }
-    }
-
-    return commentCount;
-  }
-}

package/src/plugins/built-in/file-size.ts

@@ -1,20 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Computes total file size (bytes) across all scanned files.
- */
-export class FileSizePlugin implements AnalyzerPlugin {
-  readonly name = 'FileSize';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const perFile = new Map<string, number>();
-    let summaryValue = 0;
-
-    for (const file of files) {
-      perFile.set(file.filePath, file.size);
-      summaryValue += file.size;
-    }
-
-    return { pluginName: this.name, summaryValue, perFile };
-  }
-}

package/src/plugins/built-in/language-distribution.ts

@@ -1,95 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Known extension-to-language name mappings.
- */
-const EXTENSION_TO_LANGUAGE: Record<string, string> = {
-  '.js': 'JavaScript',
-  '.jsx': 'JavaScript (JSX)',
-  '.ts': 'TypeScript',
-  '.tsx': 'TypeScript (TSX)',
-  '.py': 'Python',
-  '.rb': 'Ruby',
-  '.java': 'Java',
-  '.c': 'C',
-  '.cpp': 'C++',
-  '.cs': 'C#',
-  '.go': 'Go',
-  '.rs': 'Rust',
-  '.swift': 'Swift',
-  '.kt': 'Kotlin',
-  '.dart': 'Dart',
-  '.scala': 'Scala',
-  '.php': 'PHP',
-  '.html': 'HTML',
-  '.htm': 'HTML',
-  '.css': 'CSS',
-  '.scss': 'SCSS',
-  '.less': 'LESS',
-  '.xml': 'XML',
-  '.svg': 'SVG',
-  '.json': 'JSON',
-  '.jsonc': 'JSONC',
-  '.yaml': 'YAML',
-  '.yml': 'YAML',
-  '.md': 'Markdown',
-  '.sh': 'Shell',
-  '.bash': 'Shell',
-  '.zsh': 'Shell',
-  '.sql': 'SQL',
-  '.lua': 'Lua',
-  '.r': 'R',
-  '.m': 'Objective-C',
-  '.mm': 'Objective-C++',
-  '.pl': 'Perl',
-  '.pm': 'Perl',
-  '.hs': 'Haskell',
-  '.lisp': 'Lisp',
-  '.clj': 'Clojure',
-  '.scm': 'Scheme',
-  '.vue': 'Vue',
-  '.toml': 'TOML',
-  '.ini': 'INI',
-  '.cfg': 'Config',
-  '.ps1': 'PowerShell',
-  '.ada': 'Ada',
-  '.vhdl': 'VHDL',
-};
-
-/**
- * Computes language distribution across all scanned files.
- * The perFile map stores a value of 1 for each file (used for counting),
- * while summaryValue is the number of distinct languages found.
- */
-export class LanguageDistributionPlugin implements AnalyzerPlugin {
-  readonly name = 'LanguageDistribution';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const langCounts = new Map<string, number>();
-    const perFile = new Map<string, number>();
-
-    for (const file of files) {
-      const ext = file.extension.toLowerCase();
-      const language = EXTENSION_TO_LANGUAGE[ext] || 'Other';
-      langCounts.set(language, (langCounts.get(language) || 0) + 1);
-      perFile.set(file.filePath, 1);
-    }
-
-    // summaryValue = number of distinct languages
-    return { pluginName: this.name, summaryValue: langCounts.size, perFile };
-  }
-
-  /**
-   * Helper to retrieve the full language distribution map.
-   * Called by the aggregator after analyze().
-   */
-  getDistribution(files: AnalyzedFileData[]): Map<string, number> {
-    const langCounts = new Map<string, number>();
-    for (const file of files) {
-      const ext = file.extension.toLowerCase();
-      const language = EXTENSION_TO_LANGUAGE[ext] || 'Other';
-      langCounts.set(language, (langCounts.get(language) || 0) + 1);
-    }
-    return langCounts;
-  }
-}

package/src/plugins/built-in/largest-files.ts

@@ -1,41 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-const DEFAULT_TOP_N = 10;
-
-/**
- * Identifies the largest files by byte size.
- * summaryValue = the size of the single largest file.
- * perFile = the size of each file (same as FileSize, but sorted/limited).
- */
-export class LargestFilesPlugin implements AnalyzerPlugin {
-  readonly name = 'LargestFiles';
-  private topN: number;
-
-  constructor(topN: number = DEFAULT_TOP_N) {
-    this.topN = topN;
-  }
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const sorted = [...files].sort((a, b) => b.size - a.size);
-    const top = sorted.slice(0, this.topN);
-
-    const perFile = new Map<string, number>();
-    for (const file of top) {
-      perFile.set(file.filePath, file.size);
-    }
-
-    const summaryValue = top.length > 0 ? top[0].size : 0;
-
-    return { pluginName: this.name, summaryValue, perFile };
-  }
-
-  /**
-   * Helper to get the ranked list, consumed by reporters.
-   */
-  getTopFiles(files: AnalyzedFileData[]): Array<{ filePath: string; size: number }> {
-    return [...files]
-      .sort((a, b) => b.size - a.size)
-      .slice(0, this.topN)
-      .map(f => ({ filePath: f.filePath, size: f.size }));
-  }
-}

package/src/plugins/built-in/total-files.ts

@@ -1,18 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Counts total number of files scanned.
- */
-export class TotalFilesPlugin implements AnalyzerPlugin {
-  readonly name = 'TotalFiles';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const perFile = new Map<string, number>();
-
-    for (const file of files) {
-      perFile.set(file.filePath, 1);
-    }
-
-    return { pluginName: this.name, summaryValue: files.length, perFile };
-  }
-}

package/src/plugins/built-in/total-lines.ts

@@ -1,21 +0,0 @@
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult } from '../types.js';
-
-/**
- * Counts total lines across all scanned files.
- */
-export class TotalLinesPlugin implements AnalyzerPlugin {
-  readonly name = 'TotalLines';
-
-  analyze(files: AnalyzedFileData[]): PluginResult {
-    const perFile = new Map<string, number>();
-    let summaryValue = 0;
-
-    for (const file of files) {
-      const lineCount = file.lines.length;
-      perFile.set(file.filePath, lineCount);
-      summaryValue += lineCount;
-    }
-
-    return { pluginName: this.name, summaryValue, perFile };
-  }
-}

package/src/plugins/index.ts

@@ -1,10 +0,0 @@
-export { BlankLinesPlugin } from './built-in/blank-lines.js';
-export { CommentLinesPlugin } from './built-in/comment-lines.js';
-export { FileSizePlugin } from './built-in/file-size.js';
-export { LanguageDistributionPlugin } from './built-in/language-distribution.js';
-export { LargestFilesPlugin } from './built-in/largest-files.js';
-export { TotalFilesPlugin } from './built-in/total-files.js';
-export { TotalLinesPlugin } from './built-in/total-lines.js';
-
-export type { AnalyzedFileData, AnalyzerPlugin, PluginResult, ProjectStats } from './types.js';
-

package/src/plugins/types.ts

@@ -1,58 +0,0 @@
-
-/**
- * Represents the result of a single plugin's analysis on the entire project.
- */
-export interface PluginResult {
-  /** The name of the plugin that produced this result. */
-  pluginName: string;
-  /** Summary-level metric value (e.g. total lines across all files). */
-  summaryValue: number;
-  /** Per-file breakdown of the metric, keyed by file path. */
-  perFile: Map<string, number>;
-}
-
-/**
- * The contract every analyzer plugin must implement.
- * Plugins receive the full list of scanned files and their line data,
- * then return aggregated results.
- */
-export interface AnalyzerPlugin {
-  /** Unique name of this plugin (e.g. 'TotalLines'). */
-  name: string;
-  /** Analyze scanned files and return aggregated results. */
-  analyze(files: AnalyzedFileData[]): PluginResult;
-}
-
-/**
- * Enriched file data created by the aggregator after streaming each file.
- * Contains raw line data so plugins don't need to re-read files.
- */
-export interface AnalyzedFileData {
-  /** Absolute path to the scanned file. */
-  filePath: string;
-  /** File size in bytes (from stat). */
-  size: number;
-  /** File extension including the dot, e.g. '.ts'. */
-  extension: string;
-  /** All lines of the file as strings. */
-  lines: string[];
-}
-
-/**
- * The final aggregated stats payload produced by the Orchestrator.
- * Consumed by reporters to render output.
- */
-export interface ProjectStats {
-  /** Root directory that was scanned. */
-  rootDir: string;
-  /** Total number of files scanned. */
-  totalFiles: number;
-  /** Results from each plugin, keyed by plugin name. */
-  pluginResults: Map<string, PluginResult>;
-  /** Language distribution: language name -> file count. */
-  languageDistribution: Map<string, number>;
-  /** Top N largest files by size. */
-  largestFiles: Array<{ filePath: string; size: number }>;
-  /** Timestamp of when the scan completed. */
-  scannedAt: Date;
-}