@cod3vil/kount-cli 1.0.0 → 1.0.3

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@cod3vil/kount-cli",
   "packageManager": "bun@1.3.5",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Project Intelligence for Codebases — analyze your code with precision.",
   "module": "src/index.tsx",
   "type": "module",
   "bin": {
-    "kount": "./bin/kount.js"
+    "kount": "dist/kount.js"
   },
   "files": [
-    "src",
-    "bin",
+    "dist",
     "README.md"
   ],
   "publishConfig": {
@@ -21,7 +20,7 @@
     "start": "bun run src/index.tsx",
     "test": "vitest run",
     "test:watch": "vitest",
-    "build": "bun build ./src/index.tsx --compile --external react-devtools-core --outfile dist/kount",
+    "build": "rm -rf dist && bun build ./src/index.tsx --outfile dist/kount.js --target node",
     "prepublishOnly": "bun run build",
     "release": "np"
   },
@@ -50,6 +49,7 @@
     "@types/node": "^25.3.2",
     "@types/react": "^19.2.14",
     "np": "^11.0.2",
+    "react-devtools-core": "^7.0.1",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {

package/bin/kount.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env bun
-import './src/index.tsx';

package/src/cli/config-resolver.ts

@@ -1,175 +0,0 @@
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-
-/**
- * Resolved configuration used throughout the application.
- */
-export interface KountConfig {
-  rootDir: string;
-  outputMode: 'terminal' | 'markdown' | 'html';
-  includeTests: boolean;
-  respectGitignore: boolean;
-  cache: {
-    enabled: boolean;
-    clearFirst: boolean;
-  };
-  force: boolean;
-  outputPath?: string;
-}
-
-/**
- * Shape of the .kountrc.json / .kountrc.yaml config file.
- */
-interface ConfigFile {
-  rootDir?: string;
-  outputMode?: string;
-  includeTests?: boolean;
-  respectGitignore?: boolean;
-  cache?: {
-    enabled?: boolean;
-    clearFirst?: boolean;
-  };
-}
-
-/**
- * CLI flags that can override the config file.
- */
-export interface CliFlags {
-  rootDir?: string;
-  outputMode?: string;
-  includeTests?: boolean;
-  respectGitignore?: boolean;
-  cache?: boolean;
-  clearCache?: boolean;
-  force?: boolean;
-  output?: string;
-}
-
-const DEFAULTS: KountConfig = {
-  rootDir: '.',
-  outputMode: 'terminal',
-  includeTests: false,
-  respectGitignore: true,
-  cache: {
-    enabled: true,
-    clearFirst: false,
-  },
-  force: false,
-};
-
-/**
- * Attempts to load a config file from the given directory.
- * Checks for .kountrc.json first, then .kountrc.yaml.
- */
-async function loadConfigFile(dir: string): Promise<ConfigFile> {
-  const jsonPath = path.join(dir, '.kountrc.json');
-
-  try {
-    const raw = await fsp.readFile(jsonPath, 'utf8');
-    return JSON.parse(raw) as ConfigFile;
-  } catch {
-    // JSON not found or invalid — try YAML
-  }
-
-  // YAML support: we'll parse manually for the simple flat structure
-  // rather than adding a heavy dependency. This handles basic key: value pairs.
-  const yamlPath = path.join(dir, '.kountrc.yaml');
-  try {
-    const raw = await fsp.readFile(yamlPath, 'utf8');
-    return parseSimpleYaml(raw);
-  } catch {
-    // No config file found — use defaults
-  }
-
-  return {};
-}
-
-/**
- * Minimal YAML parser for flat config files.
- * Handles: string, boolean, and nested single-level objects.
- */
-function parseSimpleYaml(raw: string): ConfigFile {
-  const result: Record<string, unknown> = {};
-  let currentObject: Record<string, unknown> | null = null;
-  let currentKey = '';
-
-  for (const line of raw.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed === '' || trimmed.startsWith('#')) continue;
-
-    const indent = line.length - line.trimStart().length;
-
-    if (indent > 0 && currentObject !== null) {
-      // Nested key
-      const match = trimmed.match(/^(\w+)\s*:\s*(.+)$/);
-      if (match) {
-        currentObject[match[1]] = parseYamlValue(match[2]);
-      }
-    } else {
-      // Top-level key
-      const match = trimmed.match(/^(\w+)\s*:\s*(.*)$/);
-      if (match) {
-        const key = match[1];
-        const value = match[2].trim();
-
-        if (value === '') {
-          // Start of nested object
-          currentKey = key;
-          currentObject = {};
-          result[key] = currentObject;
-        } else {
-          currentObject = null;
-          result[key] = parseYamlValue(value);
-        }
-      }
-    }
-  }
-
-  return result as unknown as ConfigFile;
-}
-
-function parseYamlValue(val: string): string | boolean | number {
-  if (val === 'true') return true;
-  if (val === 'false') return false;
-  const num = Number(val);
-  if (!isNaN(num) && val !== '') return num;
-  // Strip quotes
-  if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-    return val.slice(1, -1);
-  }
-  return val;
-}
-
-/**
- * Resolves the final configuration from:
- *   CLI flags > Config file > Defaults
- *
- * @param cliFlags Parsed CLI arguments.
- * @param cwd Current working directory (for finding config files).
- */
-export async function resolveConfig(cliFlags: CliFlags, cwd: string = process.cwd()): Promise<KountConfig> {
-  const fileConfig = await loadConfigFile(cwd);
-
-  const outputMode = validateOutputMode(
-    cliFlags.outputMode ?? fileConfig.outputMode ?? DEFAULTS.outputMode
-  );
-
-  return {
-    rootDir: path.resolve(cwd, cliFlags.rootDir ?? fileConfig.rootDir ?? DEFAULTS.rootDir),
-    outputMode,
-    includeTests: cliFlags.includeTests ?? fileConfig.includeTests ?? DEFAULTS.includeTests,
-    respectGitignore: cliFlags.respectGitignore ?? fileConfig.respectGitignore ?? DEFAULTS.respectGitignore,
-    cache: {
-      enabled: cliFlags.cache ?? fileConfig.cache?.enabled ?? DEFAULTS.cache.enabled,
-      clearFirst: cliFlags.clearCache ?? fileConfig.cache?.clearFirst ?? DEFAULTS.cache.clearFirst,
-    },
-    force: cliFlags.force ?? DEFAULTS.force,
-    outputPath: cliFlags.output,
-  };
-}
-
-function validateOutputMode(mode: string): 'terminal' | 'markdown' | 'html' {
-  const valid = ['terminal', 'markdown', 'html'];
-  if (valid.includes(mode)) return mode as 'terminal' | 'markdown' | 'html';
-  return 'terminal';
-}

package/src/cli/parser.ts

@@ -1,52 +0,0 @@
-import { Command } from 'commander';
-import type { CliFlags } from './config-resolver.js';
-
-/**
- * Creates and configures the Commander CLI program.
- * Returns parsed CLI flags for the config resolver.
- *
- * Follows tuicfg-sensible-defaults, tuicfg-flags-over-args,
- * and tuicfg-help-system guidelines from terminal-ui skill.
- */
-export function createCli(argv: string[]): CliFlags {
-  const program = new Command();
-
-  program
-    .name('kount')
-    .description('Project Intelligence for Codebases — analyze your code with precision.')
-    .version('1.0.0')
-    .option('-d, --root-dir <path>', 'Root directory to scan (default: current directory)')
-    .option(
-      '-o, --output-mode <mode>',
-      'Output mode: terminal, markdown, or html (default: terminal)'
-    )
-    .option('-t, --include-tests', 'Include test files in the analysis')
-    .option('--no-gitignore', 'Ignore .gitignore rules')
-    .option('--no-cache', 'Disable caching')
-    .option('--clear-cache', 'Clear the cache before scanning')
-    .option('-f, --force', 'Force overwrite output files (for markdown mode)')
-    .option('--output <path>', 'Output file path (for markdown mode)')
-    .parse(argv);
-
-  const opts = program.opts<{
-    rootDir?: string;
-    outputMode?: string;
-    includeTests?: boolean;
-    gitignore?: boolean;
-    cache?: boolean;
-    clearCache?: boolean;
-    force?: boolean;
-    output?: string;
-  }>();
-
-  return {
-    rootDir: opts.rootDir,
-    outputMode: opts.outputMode,
-    includeTests: opts.includeTests,
-    respectGitignore: opts.gitignore, // Commander converts --no-gitignore to gitignore: false
-    cache: opts.cache, // Commander converts --no-cache to cache: false
-    clearCache: opts.clearCache,
-    force: opts.force,
-    output: opts.output,
-  };
-}

package/src/core/aggregator.ts

@@ -1,204 +0,0 @@
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import {
-    BlankLinesPlugin,
-    CommentLinesPlugin,
-    FileSizePlugin,
-    LanguageDistributionPlugin,
-    LargestFilesPlugin,
-    TotalFilesPlugin,
-    TotalLinesPlugin,
-} from '../plugins/index.js';
-import type { AnalyzedFileData, AnalyzerPlugin, PluginResult, ProjectStats } from '../plugins/types.js';
-import type { ScannedFile } from '../scanner/stream-reader.js';
-import { Scanner } from '../scanner/stream-reader.js';
-import { CacheManager } from './cache.js';
-
-/**
- * Default set of built-in v1 plugins.
- */
-function getDefaultPlugins(): AnalyzerPlugin[] {
-  return [
-    new TotalLinesPlugin(),
-    new BlankLinesPlugin(),
-    new CommentLinesPlugin(),
-    new FileSizePlugin(),
-    new TotalFilesPlugin(),
-    new LanguageDistributionPlugin(),
-    new LargestFilesPlugin(),
-  ];
-}
-
-export interface AggregatorOptions {
-  respectGitignore?: boolean;
-  plugins?: AnalyzerPlugin[];
-  cacheEnabled?: boolean;
-  clearCache?: boolean;
-}
-
-/**
- * Orchestrator: connects the Scanner to the Plugin pipeline.
- * Streams each file, builds AnalyzedFileData, then runs all plugins.
- * Integrates the CacheManager to skip unchanged files.
- */
-export class Aggregator {
-  private scanner: Scanner;
-  private plugins: AnalyzerPlugin[];
-  private rootDir: string;
-  private cache: CacheManager;
-  private clearCacheFirst: boolean;
-
-  constructor(rootDir: string, options?: AggregatorOptions) {
-    this.rootDir = path.resolve(rootDir);
-    this.scanner = new Scanner(this.rootDir, options?.respectGitignore ?? true);
-    this.plugins = options?.plugins ?? getDefaultPlugins();
-    this.cache = new CacheManager(this.rootDir, options?.cacheEnabled ?? true);
-    this.clearCacheFirst = options?.clearCache ?? false;
-  }
-
-  /**
-   * Runs the full pipeline: discover → cache check → stream → analyze → aggregate → save cache.
-   * Returns a ProjectStats payload ready for reporters.
-   *
-   * @param onProgress Optional callback fired per file for progress tracking.
-   */
-  async run(onProgress?: (current: number, total: number, filePath: string) => void): Promise<ProjectStats> {
-    // 0. Cache setup
-    if (this.clearCacheFirst) {
-      await this.cache.clear();
-    }
-    await this.cache.load();
-
-    // 1. Discover files
-    const scannedFiles = await this.scanner.discover(this.rootDir);
-
-    // 2. Stream each file (or use cache) and build enriched data
-    const analyzedFiles: AnalyzedFileData[] = [];
-    let current = 0;
-
-    for (const scannedFile of scannedFiles) {
-      const fileData = await this.processFile(scannedFile);
-      analyzedFiles.push(fileData);
-      current++;
-
-      if (onProgress) {
-        onProgress(current, scannedFiles.length, scannedFile.filePath);
-      }
-    }
-
-    // 3. Run each plugin against the full analyzed data
-    const pluginResults = new Map<string, PluginResult>();
-    for (const plugin of this.plugins) {
-      const result = plugin.analyze(analyzedFiles);
-      pluginResults.set(plugin.name, result);
-    }
-
-    // 4. Update cache with fresh per-file metrics from plugins
-    for (const file of analyzedFiles) {
-      const metrics: Record<string, number> = {};
-      for (const [pluginName, result] of pluginResults) {
-        const value = result.perFile.get(file.filePath);
-        if (value !== undefined) {
-          metrics[pluginName] = value;
-        }
-      }
-
-      try {
-        const stat = await fsp.stat(file.filePath);
-        this.cache.set(file.filePath, stat.mtimeMs, stat.size, metrics);
-      } catch {
-        // File may have been deleted between discover and cache save — skip
-      }
-    }
-
-    // 5. Save cache to disk
-    await this.cache.save();
-
-    // 6. Compute language distribution
-    const langPlugin = this.plugins.find(
-      (p): p is LanguageDistributionPlugin => p.name === 'LanguageDistribution'
-    ) as LanguageDistributionPlugin | undefined;
-    const languageDistribution = langPlugin
-      ? langPlugin.getDistribution(analyzedFiles)
-      : new Map<string, number>();
-
-    // 7. Compute largest files
-    const largestPlugin = this.plugins.find(
-      (p): p is LargestFilesPlugin => p.name === 'LargestFiles'
-    ) as LargestFilesPlugin | undefined;
-    const largestFiles = largestPlugin
-      ? largestPlugin.getTopFiles(analyzedFiles)
-      : [];
-
-    return {
-      rootDir: this.rootDir,
-      totalFiles: scannedFiles.length,
-      pluginResults,
-      languageDistribution,
-      largestFiles,
-      scannedAt: new Date(),
-    };
-  }
-
-  /**
-   * Processes a single file: checks cache first, streams if cache miss.
-   */
-  private async processFile(scannedFile: ScannedFile): Promise<AnalyzedFileData> {
-    // Check cache (we need the current stat to compare)
-    try {
-      const stat = await fsp.stat(scannedFile.filePath);
-      const cached = this.cache.lookup(scannedFile.filePath, stat.mtimeMs, stat.size);
-
-      if (cached !== null) {
-        // Cache hit — we still need AnalyzedFileData for the plugins.
-        // Since plugins need `lines`, we need to re-stream on cache miss.
-        // For cache hits, we can't avoid re-reading if plugins need full line data.
-        // However the cache stores per-file metrics directly, so for a future
-        // optimization we could bypass plugins entirely. For now, we still stream
-        // but the cache mechanism is in place for the next optimization pass.
-      }
-    } catch {
-      // stat failed — proceed with streaming
-    }
-
-    return this.streamAndParse(scannedFile);
-  }
-
-  /**
-   * Streams a single file and collects its lines.
-   * Uses the Scanner's streaming API to avoid loading the entire file at once.
-   */
-  private async streamAndParse(scannedFile: ScannedFile): Promise<AnalyzedFileData> {
-    const lines: string[] = [];
-    let remainder = '';
-
-    await this.scanner.streamFile(scannedFile.filePath, (chunk, isLast) => {
-      if (chunk.length === 0 && isLast) {
-        // Flush any remaining partial line
-        if (remainder.length > 0) {
-          lines.push(remainder);
-          remainder = '';
-        }
-        return;
-      }
-
-      const text = remainder + chunk.toString('utf8');
-      const parts = text.split('\n');
-
-      // All complete lines (everything except the last element which may be partial)
-      for (let i = 0; i < parts.length - 1; i++) {
-        lines.push(parts[i]);
-      }
-
-      // Keep the last part as remainder (may be partial line)
-      remainder = parts[parts.length - 1];
-    });
-
-    return {
-      filePath: scannedFile.filePath,
-      size: scannedFile.size,
-      extension: path.extname(scannedFile.filePath),
-      lines,
-    };
-  }
-}

package/src/core/cache.ts

@@ -1,130 +0,0 @@
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-
-/**
- * Per-file cached entry storing metrics and invalidation keys.
- */
-export interface CacheEntry {
-  /** Last modified time in ms (from stat.mtimeMs). */
-  mtimeMs: number;
-  /** File size in bytes (from stat.size). */
-  size: number;
-  /** Cached plugin results keyed by plugin name. */
-  metrics: Record<string, number>;
-}
-
-/**
- * Shape of the .kountcache.json file on disk.
- */
-interface CacheFile {
-  version: number;
-  entries: Record<string, CacheEntry>;
-}
-
-const CACHE_VERSION = 1;
-const CACHE_FILENAME = '.kountcache.json';
-
-/**
- * Manages the .kountcache.json file for incremental scanning.
- * Uses mtime + size to determine if a file needs re-scanning.
- */
-export class CacheManager {
-  private cachePath: string;
-  private entries: Map<string, CacheEntry> = new Map();
-  private enabled: boolean;
-  private dirty = false;
-
-  constructor(rootDir: string, enabled: boolean = true) {
-    this.cachePath = path.join(path.resolve(rootDir), CACHE_FILENAME);
-    this.enabled = enabled;
-  }
-
-  /**
-   * Loads the cache from disk. If it doesn't exist or is corrupt, starts fresh.
-   */
-  async load(): Promise<void> {
-    if (!this.enabled) return;
-
-    try {
-      const raw = await fsp.readFile(this.cachePath, 'utf8');
-      const parsed: CacheFile = JSON.parse(raw);
-
-      if (parsed.version !== CACHE_VERSION) {
-        // Version mismatch — discard and start fresh
-        this.entries = new Map();
-        return;
-      }
-
-      this.entries = new Map(Object.entries(parsed.entries));
-    } catch {
-      // File doesn't exist or is corrupt — start with empty cache
-      this.entries = new Map();
-    }
-  }
-
-  /**
-   * Checks whether a file's cached entry is still valid by comparing
-   * mtime and size from the current stat against the stored values.
-   *
-   * @returns The cached metrics if valid, or null if the file needs re-scanning.
-   */
-  lookup(filePath: string, currentMtimeMs: number, currentSize: number): Record<string, number> | null {
-    if (!this.enabled) return null;
-
-    const entry = this.entries.get(filePath);
-    if (!entry) return null;
-
-    if (entry.mtimeMs === currentMtimeMs && entry.size === currentSize) {
-      return entry.metrics;
-    }
-
-    // Invalidated — mtime or size changed
-    return null;
-  }
-
-  /**
-   * Stores or updates a file's cache entry after scanning.
-   */
-  set(filePath: string, mtimeMs: number, size: number, metrics: Record<string, number>): void {
-    if (!this.enabled) return;
-
-    this.entries.set(filePath, { mtimeMs, size, metrics });
-    this.dirty = true;
-  }
-
-  /**
-   * Persists the cache to disk if any entries were updated.
-   */
-  async save(): Promise<void> {
-    if (!this.enabled || !this.dirty) return;
-
-    const cacheFile: CacheFile = {
-      version: CACHE_VERSION,
-      entries: Object.fromEntries(this.entries),
-    };
-
-    await fsp.writeFile(this.cachePath, JSON.stringify(cacheFile, null, 2), 'utf8');
-    this.dirty = false;
-  }
-
-  /**
-   * Removes the cache file from disk.
-   */
-  async clear(): Promise<void> {
-    this.entries = new Map();
-    this.dirty = false;
-
-    try {
-      await fsp.unlink(this.cachePath);
-    } catch {
-      // File didn't exist — that's fine
-    }
-  }
-
-  /**
-   * Returns the number of cached entries (for diagnostics).
-   */
-  get size(): number {
-    return this.entries.size;
-  }
-}