@llbbl/uncov 0.1.1

package/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/README.md

@@ -0,0 +1,240 @@
+# uncov
+
+[![CI](https://github.com/llbbl/uncov/actions/workflows/ci.yml/badge.svg)](https://github.com/llbbl/uncov/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/llbbl/uncov/branch/main/graph/badge.svg)](https://codecov.io/gh/llbbl/uncov)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+A zero-dependency CLI tool that reports files with low test coverage from Vitest/Istanbul JSON output.
+
+## Features
+
+- **Zero dependencies** - Single binary, instant startup
+- **Zero config** - Just run `uncov` in any project with coverage output
+- **Cross-platform** - Binaries for macOS (arm64, x64), Linux (x64), Windows (x64)
+- **CI-friendly** - JSON output, exit codes for automation
+- **Optional setup** - Bootstrap coverage scripts with `uncov init`
+
+## Installation
+
+### Quick Install (Recommended)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/llbbl/uncov/main/install.sh | bash
+```
+
+This automatically detects your platform, downloads the latest binary, verifies the checksum, and installs to your PATH.
+
+### npm / pnpm / bun
+
+```bash
+# npm
+npm install -g uncov
+
+# pnpm
+pnpm add -g uncov
+
+# bun
+bun add -g uncov
+```
+
+### Download Binary
+
+Download the latest release for your platform from [GitHub Releases](https://github.com/llbbl/uncov/releases).
+
+```bash
+# macOS (Apple Silicon)
+curl -fsSL https://github.com/llbbl/uncov/releases/latest/download/uncov-darwin-arm64 -o uncov
+chmod +x uncov
+sudo mv uncov /usr/local/bin/
+
+# macOS (Intel)
+curl -fsSL https://github.com/llbbl/uncov/releases/latest/download/uncov-darwin-x64 -o uncov
+chmod +x uncov
+sudo mv uncov /usr/local/bin/
+
+# Linux
+curl -fsSL https://github.com/llbbl/uncov/releases/latest/download/uncov-linux-x64 -o uncov
+chmod +x uncov
+sudo mv uncov /usr/local/bin/
+```
+
+### Build from Source
+
+```bash
+git clone https://github.com/llbbl/uncov.git
+cd uncov
+bun install
+bun run build:local
+```
+
+## Quick Start
+
+1. Run your tests with coverage:
+   ```bash
+   pnpm test:coverage
+   # or
+   vitest run --coverage
+   ```
+
+2. Report low coverage files:
+   ```bash
+   uncov
+   ```
+
+Output:
+```
+Files at or below 10% line coverage: 3
+
+   0.00%  LH    0/LF  120   src/renderer.ts
+   5.26%  LH    2/LF   38   src/bootstrap.ts
+  10.00%  LH   10/LF  100   src/engine.ts
+```
+
+## Commands
+
+### `uncov` (default)
+
+Report files below coverage threshold.
+
+```bash
+uncov                     # Files at or below 10% coverage (default)
+uncov --threshold 50      # Files at or below 50% coverage
+uncov --threshold 0       # Only 0% coverage files
+uncov --fail              # Exit 1 if any files below threshold
+uncov --json              # JSON output for scripting
+uncov --verbose           # Show debug information
+uncov --no-color          # Disable colorized output
+```
+
+### `uncov init`
+
+Bootstrap coverage configuration in your project.
+
+```bash
+uncov init                # Interactive setup
+uncov init --force        # Overwrite existing config
+uncov init --dry-run      # Preview changes without modifying files
+```
+
+This command:
+1. Detects your package manager (pnpm, bun, npm, yarn)
+2. Adds scripts to `package.json`:
+   - `test:coverage` - Run tests with coverage
+   - `coverage:low` - Run uncov
+3. Creates `vitest.config.ts` with coverage settings
+4. Adds `coverage/` to `.gitignore`
+
+### `uncov check`
+
+Verify coverage setup is correct.
+
+```bash
+uncov check               # Verify setup
+uncov check --verbose     # Show detailed check information
+```
+
+Checks:
+- Vitest config exists
+- Coverage config is present
+- `coverage-summary.json` exists
+- Required scripts are configured
+
+## Configuration
+
+### uncov.config.json
+
+```json
+{
+  "threshold": 10,
+  "exclude": ["**/*.test.ts", "**/index.ts"],
+  "failOnLow": false,
+  "coveragePath": "coverage/coverage-summary.json"
+}
+```
+
+### package.json
+
+```json
+{
+  "uncov": {
+    "threshold": 20,
+    "failOnLow": true
+  }
+}
+```
+
+### Configuration Priority
+
+1. CLI flags (highest)
+2. `uncov.config.json`
+3. `package.json` uncov field
+4. Defaults (lowest)
+
+## Exit Codes
+
+| Code | Meaning |
+|------|---------|
+| 0 | Success (or low coverage files found but `--fail` not set) |
+| 1 | Low coverage files found and `--fail` set |
+| 2 | Missing coverage-summary.json or config error |
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/llbbl/uncov.git
+cd uncov
+bun install
+```
+
+### Commands
+
+Using [Just](https://github.com/casey/just) (recommended):
+
+```bash
+just              # Show available commands
+just install      # Install dependencies
+just dev          # Run CLI locally
+just dev --help   # Run CLI with args
+just test         # Run tests
+just lint         # Lint with Biome
+just lint-fix     # Fix lint issues
+just build        # Build local binary
+just build-all    # Build all platform binaries
+just check        # Run lint + tests
+just clean        # Remove build artifacts
+```
+
+Or using bun directly:
+
+```bash
+bun run dev           # Run CLI locally
+bun test              # Run tests
+bun run lint          # Lint with Biome
+bun run lint:fix      # Fix lint issues
+bun run build:local   # Build local binary
+bun run build         # Build all platform binaries
+```
+
+### Project Structure
+
+```
+uncov/
+├── src/
+│   ├── cli.ts              # Entry point, arg parsing
+│   ├── commands/           # Command implementations
+│   ├── lib/                # Core logic
+│   └── utils/              # Helpers
+├── test/                   # Tests
+├── scripts/
+│   └── build.ts            # Cross-platform build
+└── docs/
+    └── spec.md             # Full specification
+```
+
+See [docs/spec.md](docs/spec.md) for the full specification.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,900 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/cli.ts
+import { parseArgs } from "util";
+// package.json
+var package_default = {
+  name: "@llbbl/uncov",
+  version: "0.1.1",
+  description: "Report files with low test coverage from Vitest/Istanbul output",
+  type: "module",
+  main: "./dist/cli.js",
+  bin: {
+    uncov: "./dist/cli.js"
+  },
+  files: ["dist"],
+  scripts: {
+    dev: "bun run src/cli.ts",
+    test: "bun test",
+    lint: "biome check .",
+    "lint:fix": "biome check --write .",
+    build: "bun run scripts/build.ts",
+    "build:local": "bun build --compile --outfile=uncov src/cli.ts",
+    "build:npm": "bun build src/cli.ts --outdir=dist --target=node",
+    "test:coverage": "vitest run --coverage",
+    "coverage:low": "uncov"
+  },
+  devDependencies: {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "^1.2.4"
+  },
+  keywords: ["coverage", "vitest", "testing", "cli"],
+  license: "MIT"
+};
+
+// src/lib/constants.ts
+var DEFAULT_COVERAGE_PATH = "coverage/coverage-summary.json";
+var VITEST_CONFIG_FILES = [
+  { file: "vitest.config.ts", type: "ts" },
+  { file: "vitest.config.js", type: "js" },
+  { file: "vitest.config.mts", type: "mts" },
+  { file: "vitest.config.mjs", type: "mjs" },
+  { file: "vite.config.ts", type: "ts" },
+  { file: "vite.config.js", type: "js" },
+  { file: "vite.config.mts", type: "mts" },
+  { file: "vite.config.mjs", type: "mjs" }
+];
+
+// src/utils/fs.ts
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, relative, resolve } from "node:path";
+function validatePath(targetPath, baseDir = process.cwd()) {
+  const resolved = resolve(baseDir, targetPath);
+  const relativePath = relative(baseDir, resolved);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    throw new Error(`Path "${targetPath}" is outside allowed directory`);
+  }
+  return resolved;
+}
+function fileExists(path) {
+  return existsSync(path);
+}
+function readJson(path, options) {
+  const resolvedPath = options?.baseDir ? validatePath(path, options.baseDir) : path;
+  let content;
+  try {
+    content = readFileSync(resolvedPath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to read file "${path}": ${message}`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid JSON";
+    throw new Error(`Failed to parse JSON in "${path}": ${message}`);
+  }
+}
+function writeJson(path, data, options) {
+  const resolvedPath = options?.baseDir ? validatePath(path, options.baseDir) : path;
+  ensureDir(dirname(resolvedPath));
+  const content = `${JSON.stringify(data, null, 2)}
+`;
+  try {
+    writeFileSync(resolvedPath, content, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to write JSON to "${path}": ${message}`);
+  }
+}
+function readText(path, options) {
+  const resolvedPath = options?.baseDir ? validatePath(path, options.baseDir) : path;
+  try {
+    return readFileSync(resolvedPath, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to read file "${path}": ${message}`);
+  }
+}
+function writeText(path, content, options) {
+  const resolvedPath = options?.baseDir ? validatePath(path, options.baseDir) : path;
+  ensureDir(dirname(resolvedPath));
+  try {
+    writeFileSync(resolvedPath, content, "utf-8");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to write to "${path}": ${message}`);
+  }
+}
+function ensureDir(path) {
+  if (!path || path === "." || path === "/") {
+    return;
+  }
+  try {
+    if (!existsSync(path)) {
+      mkdirSync(path, { recursive: true });
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to create directory "${path}": ${message}`);
+  }
+}
+function appendLine(path, line, options) {
+  const resolvedPath = options?.baseDir ? validatePath(path, options.baseDir) : path;
+  ensureDir(dirname(resolvedPath));
+  try {
+    if (existsSync(resolvedPath)) {
+      const content = readFileSync(resolvedPath, "utf-8");
+      const needsNewlineBefore = content.length > 0 && !content.endsWith(`
+`);
+      const lineToAppend = needsNewlineBefore ? `
+${line}
+` : `${line}
+`;
+      appendFileSync(resolvedPath, lineToAppend, "utf-8");
+    } else {
+      writeFileSync(resolvedPath, `${line}
+`, "utf-8");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to append to "${path}": ${message}`);
+  }
+}
+function resolvePath(relativePath, cwd) {
+  const base = cwd ?? process.cwd();
+  return resolve(base, relativePath);
+}
+
+// src/lib/detect.ts
+var LOCKFILE_MAP = [
+  { file: "pnpm-lock.yaml", manager: "pnpm" },
+  { file: "bun.lockb", manager: "bun" },
+  { file: "package-lock.json", manager: "npm" },
+  { file: "yarn.lock", manager: "yarn" }
+];
+function detectPackageManager(cwd) {
+  for (const { file, manager } of LOCKFILE_MAP) {
+    const lockfilePath = resolvePath(file, cwd);
+    if (fileExists(lockfilePath)) {
+      return manager;
+    }
+  }
+  return "npm";
+}
+function detectVitestConfig(cwd) {
+  for (const { file, type } of VITEST_CONFIG_FILES) {
+    const configPath = resolvePath(file, cwd);
+    if (fileExists(configPath)) {
+      return { path: configPath, type };
+    }
+  }
+  return null;
+}
+function detectGitignore(cwd) {
+  const gitignorePath = resolvePath(".gitignore", cwd);
+  if (!fileExists(gitignorePath)) {
+    return { exists: false, hasCoverage: false };
+  }
+  try {
+    const content = readText(gitignorePath);
+    const lines = content.split(`
+`).map((line) => line.trim());
+    const hasCoverage = lines.some((line) => {
+      if (line.startsWith("#") || line === "") {
+        return false;
+      }
+      return /^[/*]*coverage[/*]*$/.test(line) || line.startsWith("coverage") || line.endsWith("/coverage") || line.endsWith("/coverage/");
+    });
+    return { exists: true, hasCoverage };
+  } catch {
+    return { exists: true, hasCoverage: false };
+  }
+}
+
+// src/lib/package-json.ts
+function readPackageJson(path) {
+  const resolvedPath = path ?? resolvePath("package.json");
+  if (!fileExists(resolvedPath)) {
+    throw new Error(`package.json not found at: ${resolvedPath}`);
+  }
+  return readJson(resolvedPath);
+}
+function writePackageJson(pkg, path) {
+  const resolvedPath = path ?? resolvePath("package.json");
+  writeJson(resolvedPath, pkg);
+}
+function addScripts(scripts, path) {
+  const resolvedPath = path ?? resolvePath("package.json");
+  const pkg = readPackageJson(resolvedPath);
+  const added = [];
+  const skipped = [];
+  if (!pkg.scripts) {
+    pkg.scripts = {};
+  }
+  for (const [name, command] of Object.entries(scripts)) {
+    if (pkg.scripts[name] !== undefined) {
+      skipped.push(name);
+    } else {
+      pkg.scripts[name] = command;
+      added.push(name);
+    }
+  }
+  if (added.length > 0) {
+    writePackageJson(pkg, resolvedPath);
+  }
+  return { added, skipped };
+}
+function hasScript(name, path) {
+  const resolvedPath = path ?? resolvePath("package.json");
+  if (!fileExists(resolvedPath)) {
+    return false;
+  }
+  try {
+    const pkg = readPackageJson(resolvedPath);
+    return pkg.scripts?.[name] !== undefined;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/vitest-config.ts
+function hasVitestConfig(cwd) {
+  for (const { file } of VITEST_CONFIG_FILES) {
+    const configPath = resolvePath(file, cwd);
+    if (fileExists(configPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasCoverageConfig(configPath) {
+  if (!fileExists(configPath)) {
+    return false;
+  }
+  try {
+    const content = readText(configPath);
+    const hasCoverageBlock = /coverage\s*:\s*\{/.test(content);
+    if (hasCoverageBlock) {
+      return true;
+    }
+    const hasCoverageProperty = /coverage\s*:\s*[a-zA-Z]/.test(content);
+    return hasCoverageProperty;
+  } catch {
+    return false;
+  }
+}
+function createVitestConfig() {
+  return `import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json-summary'],
+      reportsDirectory: './coverage',
+    },
+  },
+});
+`;
+}
+
+// src/utils/colors.ts
+function isColorSupported(noColor = false) {
+  if (noColor) {
+    return false;
+  }
+  if (process.env.NO_COLOR !== undefined) {
+    return false;
+  }
+  return Boolean(process.stdout.isTTY);
+}
+function makeColor(code, enabled) {
+  if (!enabled) {
+    return (s) => s;
+  }
+  return (s) => `\x1B[${code}m${s}\x1B[0m`;
+}
+function createColors(noColor = false) {
+  const enabled = isColorSupported(noColor);
+  return {
+    red: makeColor("31", enabled),
+    green: makeColor("32", enabled),
+    yellow: makeColor("33", enabled),
+    cyan: makeColor("36", enabled),
+    bold: makeColor("1", enabled),
+    dim: makeColor("2", enabled)
+  };
+}
+
+// src/utils/logger.ts
+function createLogger(verbose) {
+  return {
+    verbose: (msg) => {
+      if (verbose) {
+        console.error(`[verbose] ${msg}`);
+      }
+    },
+    info: (msg) => console.log(msg),
+    error: (msg) => console.error(msg)
+  };
+}
+
+// src/commands/check.ts
+async function checkCommand(options = {}) {
+  const colors = createColors(options.noColor);
+  const log = createLogger(options.verbose ?? false);
+  const cwd = process.cwd();
+  const checks = [];
+  log.verbose(`Working directory: ${cwd}`);
+  log.verbose("Checking for vitest config...");
+  const vitestConfig = detectVitestConfig(cwd);
+  if (vitestConfig) {
+    log.verbose(`Found vitest config: ${vitestConfig.path}`);
+    checks.push({
+      name: "vitest-config",
+      passed: true,
+      message: `Vitest config found: ${vitestConfig.path}`
+    });
+    log.verbose("Checking for coverage config in vitest config...");
+    const hasCoverage = hasCoverageConfig(vitestConfig.path);
+    if (hasCoverage) {
+      log.verbose("Coverage config detected");
+      checks.push({
+        name: "coverage-config",
+        passed: true,
+        message: "Coverage config detected"
+      });
+    } else {
+      log.verbose("Coverage config not found");
+      checks.push({
+        name: "coverage-config",
+        passed: false,
+        message: "Coverage config not found in vitest config",
+        hint: "Add coverage configuration to your vitest.config.ts"
+      });
+    }
+  } else {
+    log.verbose("No vitest config found");
+    checks.push({
+      name: "vitest-config",
+      passed: false,
+      message: "Vitest config not found",
+      hint: "Run 'uncov init' to create a vitest.config.ts"
+    });
+    checks.push({
+      name: "coverage-config",
+      passed: false,
+      message: "Coverage config not checked (no vitest config)",
+      hint: "Create a vitest config first"
+    });
+  }
+  const coveragePath = resolvePath(DEFAULT_COVERAGE_PATH, cwd);
+  log.verbose(`Checking for coverage summary at: ${coveragePath}`);
+  if (fileExists(coveragePath)) {
+    log.verbose("Coverage summary found");
+    checks.push({
+      name: "coverage-summary",
+      passed: true,
+      message: `Coverage summary exists: ${DEFAULT_COVERAGE_PATH}`
+    });
+  } else {
+    log.verbose("Coverage summary not found");
+    checks.push({
+      name: "coverage-summary",
+      passed: false,
+      message: `Coverage summary not found: ${DEFAULT_COVERAGE_PATH}`,
+      hint: "Run 'pnpm test:coverage' to generate coverage data"
+    });
+  }
+  log.verbose("Checking for test:coverage script in package.json...");
+  const hasTestCoverage = hasScript("test:coverage");
+  if (hasTestCoverage) {
+    log.verbose("test:coverage script found");
+    checks.push({
+      name: "scripts",
+      passed: true,
+      message: "Scripts configured: test:coverage"
+    });
+  } else {
+    log.verbose("test:coverage script not found");
+    checks.push({
+      name: "scripts",
+      passed: false,
+      message: "Script not found: test:coverage",
+      hint: "Run 'uncov init' to add required scripts"
+    });
+  }
+  const failedChecks = checks.filter((c) => !c.passed);
+  const passedChecks = checks.filter((c) => c.passed);
+  for (const check of passedChecks) {
+    console.log(`${colors.green("[ok]")} ${check.message}`);
+  }
+  for (const check of failedChecks) {
+    console.log(`${colors.red("[fail]")} ${check.message}`);
+    if (check.hint) {
+      console.log(`  ${colors.dim(check.hint)}`);
+    }
+  }
+  console.log("");
+  if (failedChecks.length === 0) {
+    console.log(colors.green("All checks passed!"));
+    return 0;
+  }
+  console.log(colors.red(`${failedChecks.length} check${failedChecks.length === 1 ? "" : "s"} failed`));
+  return 1;
+}
+
+// src/commands/init.ts
+var SCRIPTS_TO_ADD = {
+  "test:coverage": "vitest run --coverage",
+  "coverage:low": "uncov"
+};
+async function initCommand(options) {
+  const colors = createColors(options.noColor);
+  const log = createLogger(options.verbose ?? false);
+  const dryRun = options.dryRun ?? false;
+  const cwd = process.cwd();
+  if (dryRun) {
+    console.log(colors.cyan("Dry run - no files will be modified"));
+    console.log("");
+  }
+  log.verbose(`Working directory: ${cwd}`);
+  const packageJsonPath = resolvePath("package.json", cwd);
+  log.verbose(`Checking for package.json at: ${packageJsonPath}`);
+  if (!fileExists(packageJsonPath)) {
+    console.error(colors.red("Error: No package.json found in current directory."));
+    console.error("Run 'npm init' or 'pnpm init' first to create a package.json.");
+    return 2;
+  }
+  try {
+    readPackageJson(packageJsonPath);
+    log.verbose("package.json is valid JSON");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(colors.red(`Error: Failed to read package.json: ${message}`));
+    return 2;
+  }
+  log.verbose("Detecting package manager from lockfiles...");
+  const packageManager = detectPackageManager(cwd);
+  if (dryRun) {
+    console.log(`Would detect package manager: ${colors.bold(packageManager)}`);
+  } else {
+    console.log(`${colors.green("[ok]")} Detected package manager: ${packageManager}`);
+  }
+  log.verbose("Checking package.json scripts...");
+  if (dryRun) {
+    for (const script of Object.keys(SCRIPTS_TO_ADD)) {
+      console.log(`Would add script: ${colors.bold(script)}`);
+    }
+  } else {
+    const scriptsResult = addScripts(SCRIPTS_TO_ADD, packageJsonPath);
+    for (const script of scriptsResult.added) {
+      console.log(`${colors.green("[ok]")} Added script: ${script}`);
+    }
+    for (const script of scriptsResult.skipped) {
+      console.log(`${colors.yellow("[skip]")} Script already exists: ${script}`);
+    }
+  }
+  log.verbose("Checking for existing vitest config...");
+  const existingConfig = detectVitestConfig(cwd);
+  const vitestConfigPath = resolvePath("vitest.config.ts", cwd);
+  if (dryRun) {
+    if (existingConfig && !options.force) {
+      console.log(`Would skip vitest config (already exists: ${existingConfig.path})`);
+    } else if (existingConfig && options.force) {
+      console.log(`Would overwrite: ${colors.bold("vitest.config.ts")}`);
+    } else if (!hasVitestConfig(cwd)) {
+      console.log(`Would create: ${colors.bold("vitest.config.ts")}`);
+    }
+  } else {
+    if (existingConfig && !options.force) {
+      console.log(`${colors.yellow("[skip]")} Vitest config already exists: ${existingConfig.path}`);
+      console.log("       Use --force to overwrite");
+    } else {
+      if (existingConfig && options.force) {
+        const configContent = createVitestConfig();
+        writeText(vitestConfigPath, configContent);
+        console.log(`${colors.green("[ok]")} Overwrote vitest.config.ts with coverage settings`);
+      } else if (!hasVitestConfig(cwd)) {
+        const configContent = createVitestConfig();
+        writeText(vitestConfigPath, configContent);
+        console.log(`${colors.green("[ok]")} Created vitest.config.ts with coverage settings`);
+      }
+    }
+  }
+  log.verbose("Checking .gitignore...");
+  const gitignoreResult = detectGitignore(cwd);
+  const gitignorePath = resolvePath(".gitignore", cwd);
+  if (dryRun) {
+    if (gitignoreResult.hasCoverage) {
+      console.log("Would skip .gitignore (coverage/ already present)");
+    } else if (gitignoreResult.exists) {
+      console.log(`Would append to .gitignore: ${colors.bold("coverage/")}`);
+    } else {
+      console.log(`Would create .gitignore with: ${colors.bold("coverage/")}`);
+    }
+  } else {
+    if (gitignoreResult.hasCoverage) {
+      console.log(`${colors.yellow("[skip]")} coverage/ already in .gitignore`);
+    } else {
+      appendLine(gitignorePath, "coverage/");
+      if (gitignoreResult.exists) {
+        console.log(`${colors.green("[ok]")} Added coverage/ to .gitignore`);
+      } else {
+        console.log(`${colors.green("[ok]")} Created .gitignore with coverage/`);
+      }
+    }
+  }
+  console.log("");
+  if (dryRun) {
+    console.log(colors.cyan("Run without --dry-run to apply these changes."));
+  } else {
+    console.log(`Run '${packageManager} test:coverage' to generate coverage, then 'uncov' to see low coverage files.`);
+  }
+  return 0;
+}
+
+// src/lib/config.ts
+var DEFAULT_CONFIG = {
+  threshold: 10,
+  exclude: [],
+  failOnLow: false,
+  coveragePath: "coverage/coverage-summary.json"
+};
+var CONFIG_FILE_NAME = "uncov.config.json";
+function findConfigFile(cwd) {
+  const configPath = resolvePath(CONFIG_FILE_NAME, cwd);
+  return fileExists(configPath) ? configPath : null;
+}
+function readPackageJsonConfig(cwd) {
+  const packagePath = resolvePath("package.json", cwd);
+  if (!fileExists(packagePath)) {
+    return null;
+  }
+  try {
+    const pkg = readJson(packagePath);
+    const uncovConfig = pkg.uncov;
+    if (typeof uncovConfig === "object" && uncovConfig !== null) {
+      return validatePartialConfig(uncovConfig);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function validatePartialConfig(obj) {
+  const result = {};
+  if (typeof obj.threshold === "number" && obj.threshold >= 0 && obj.threshold <= 100) {
+    result.threshold = obj.threshold;
+  }
+  if (Array.isArray(obj.exclude) && obj.exclude.every((e) => typeof e === "string")) {
+    result.exclude = obj.exclude;
+  }
+  if (typeof obj.failOnLow === "boolean") {
+    result.failOnLow = obj.failOnLow;
+  }
+  if (typeof obj.coveragePath === "string") {
+    result.coveragePath = obj.coveragePath;
+  }
+  return result;
+}
+function mergeConfigs(...configs) {
+  const result = { ...DEFAULT_CONFIG };
+  for (const config of configs) {
+    if (config.threshold !== undefined) {
+      result.threshold = config.threshold;
+    }
+    if (config.exclude !== undefined) {
+      result.exclude = config.exclude;
+    }
+    if (config.failOnLow !== undefined) {
+      result.failOnLow = config.failOnLow;
+    }
+    if (config.coveragePath !== undefined) {
+      result.coveragePath = config.coveragePath;
+    }
+  }
+  return result;
+}
+function loadConfig(cliOverrides, cwd) {
+  const configs = [];
+  const pkgConfig = readPackageJsonConfig(cwd);
+  if (pkgConfig) {
+    configs.push(pkgConfig);
+  }
+  const configFilePath = findConfigFile(cwd);
+  if (configFilePath) {
+    try {
+      const fileConfig = readJson(configFilePath);
+      configs.push(validatePartialConfig(fileConfig));
+    } catch {}
+  }
+  if (cliOverrides) {
+    configs.push(cliOverrides);
+  }
+  return mergeConfigs(...configs);
+}
+
+// src/lib/coverage.ts
+function isValidCoverageMetric(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const metric = obj;
+  return typeof metric.total === "number" && typeof metric.covered === "number" && typeof metric.pct === "number";
+}
+function isValidFileCoverage(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const coverage = obj;
+  return isValidCoverageMetric(coverage.lines);
+}
+function validateCoverageSummary(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Coverage summary must be an object");
+  }
+  const summary = data;
+  if (!isValidFileCoverage(summary.total)) {
+    throw new Error('Coverage summary missing valid "total" field');
+  }
+  for (const [key, value] of Object.entries(summary)) {
+    if (key !== "total" && !isValidFileCoverage(value)) {
+      throw new Error(`Invalid coverage data for file: ${key}`);
+    }
+  }
+  return summary;
+}
+function parseCoverageSummary(coveragePath) {
+  const data = readJson(coveragePath);
+  return validateCoverageSummary(data);
+}
+function filterBelowThreshold(summary, threshold) {
+  const result = [];
+  for (const [path, coverage] of Object.entries(summary)) {
+    if (path === "total")
+      continue;
+    const linesPct = coverage.lines.pct;
+    if (linesPct <= threshold) {
+      result.push({
+        path,
+        linesPct,
+        linesCovered: coverage.lines.covered,
+        linesTotal: coverage.lines.total
+      });
+    }
+  }
+  return result;
+}
+function sortByPercentage(files) {
+  return [...files].sort((a, b) => a.linesPct - b.linesPct);
+}
+
+// src/utils/format.ts
+function formatPercent(pct) {
+  return `${pct.toFixed(2).padStart(6)}%`;
+}
+function formatLines(covered, total) {
+  const coveredStr = covered.toString().padStart(4);
+  const totalStr = total.toString().padStart(4);
+  return `LH ${coveredStr}/LF ${totalStr}`;
+}
+function formatFileLine(file, colors) {
+  const pct = formatPercent(file.linesPct);
+  const lines = formatLines(file.linesCovered, file.linesTotal);
+  const line = `${pct}  ${lines}   ${file.path}`;
+  if (!colors) {
+    return line;
+  }
+  if (file.linesPct === 0) {
+    return colors.red(line);
+  }
+  return colors.yellow(line);
+}
+function formatReport(files, threshold, colors) {
+  if (files.length === 0) {
+    const msg = `No files at or below ${threshold}% line coverage.`;
+    return colors ? colors.green(msg) : msg;
+  }
+  const header = `Files at or below ${threshold}% line coverage: ${files.length}
+`;
+  const fileLines = files.map((f) => `  ${formatFileLine(f, colors)}`).join(`
+`);
+  return `${header}
+${fileLines}`;
+}
+function formatReportJson(files, threshold) {
+  return JSON.stringify({
+    threshold,
+    count: files.length,
+    files: files.map((f) => ({
+      path: f.path,
+      linesPct: f.linesPct,
+      linesCovered: f.linesCovered,
+      linesTotal: f.linesTotal
+    }))
+  }, null, 2);
+}
+
+// src/commands/report.ts
+async function reportCommand(options) {
+  const colors = createColors(options.noColor);
+  const log = createLogger(options.verbose ?? false);
+  log.verbose("Loading configuration...");
+  const config = loadConfig({
+    threshold: options.threshold,
+    failOnLow: options.fail,
+    coveragePath: options.coveragePath
+  });
+  log.verbose(`Config loaded: threshold=${config.threshold}, failOnLow=${config.failOnLow}`);
+  const coveragePath = resolvePath(config.coveragePath);
+  log.verbose(`Coverage path: ${coveragePath}`);
+  if (!fileExists(coveragePath)) {
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Coverage file not found",
+        path: coveragePath
+      }, null, 2));
+    } else {
+      console.error(colors.red(`Error: Coverage file not found: ${coveragePath}`));
+      console.error("Run your test coverage command first (e.g., 'pnpm test:coverage')");
+    }
+    return 2;
+  }
+  let summary;
+  try {
+    log.verbose("Parsing coverage summary...");
+    summary = parseCoverageSummary(coveragePath);
+    log.verbose(`Parsed ${Object.keys(summary).length - 1} files from coverage summary`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (options.json) {
+      console.log(JSON.stringify({
+        error: "Failed to parse coverage file",
+        details: message
+      }, null, 2));
+    } else {
+      console.error(colors.red(`Error: Failed to parse coverage file: ${message}`));
+    }
+    return 2;
+  }
+  log.verbose(`Filtering files at or below ${config.threshold}% threshold...`);
+  const filesBelow = filterBelowThreshold(summary, config.threshold);
+  log.verbose(`Found ${filesBelow.length} files below threshold`);
+  log.verbose("Sorting files by coverage percentage...");
+  const sortedFiles = sortByPercentage(filesBelow);
+  if (options.json) {
+    console.log(formatReportJson(sortedFiles, config.threshold));
+  } else {
+    console.log(formatReport(sortedFiles, config.threshold, colors));
+  }
+  if (sortedFiles.length > 0 && config.failOnLow) {
+    return 1;
+  }
+  return 0;
+}
+
+// src/lib/constants.ts
+var DEFAULT_COVERAGE_PATH2 = "coverage/coverage-summary.json";
+
+// src/cli.ts
+var VERSION = package_default.version;
+var HELP = `
+uncov - Report files with low test coverage
+
+Usage: uncov [command] [options]
+
+Commands:
+  (default)  Report files below coverage threshold
+  init       Bootstrap coverage configuration
+  check      Verify coverage setup
+
+Options:
+  --threshold <n>  Coverage threshold percentage (default: 10)
+  --fail           Exit 1 if files below threshold
+  --json           Output as JSON
+  --no-color       Disable colorized output
+  --verbose, -V    Show debug information
+  --dry-run        Show what would happen without making changes (init only)
+  --help, -h       Show this help
+  --version, -v    Show version
+`.trim();
+function parseCliArgs(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      help: { type: "boolean", short: "h", default: false },
+      version: { type: "boolean", short: "v", default: false },
+      threshold: { type: "string", short: "t", default: "10" },
+      fail: { type: "boolean", short: "f", default: false },
+      json: { type: "boolean", short: "j", default: false },
+      "coverage-path": {
+        type: "string",
+        short: "c",
+        default: DEFAULT_COVERAGE_PATH2
+      },
+      force: { type: "boolean", default: false },
+      "no-color": { type: "boolean", default: false },
+      verbose: { type: "boolean", short: "V", default: false },
+      "dry-run": { type: "boolean", default: false }
+    },
+    allowPositionals: true
+  });
+  const command = positionals[0];
+  let parsedCommand = "report";
+  if (command === "init") {
+    parsedCommand = "init";
+  } else if (command === "check") {
+    parsedCommand = "check";
+  } else if (command && command !== "report") {
+    console.error(`Unknown command: ${command}`);
+    console.error("Run 'uncov --help' for usage information.");
+    process.exit(2);
+  }
+  const thresholdRaw = values.threshold ?? "10";
+  const threshold = Number.parseInt(thresholdRaw, 10);
+  if (Number.isNaN(threshold)) {
+    console.error(`Error: Invalid threshold value "${thresholdRaw}". Must be a number.`);
+    process.exit(2);
+  }
+  if (threshold < 0 || threshold > 100) {
+    console.error(`Error: Threshold must be between 0 and 100, got ${threshold}.`);
+    process.exit(2);
+  }
+  return {
+    command: parsedCommand,
+    help: values.help ?? false,
+    version: values.version ?? false,
+    threshold,
+    fail: values.fail ?? false,
+    json: values.json ?? false,
+    coveragePath: values["coverage-path"] ?? DEFAULT_COVERAGE_PATH2,
+    force: values.force ?? false,
+    noColor: values["no-color"] ?? false,
+    verbose: values.verbose ?? false,
+    dryRun: values["dry-run"] ?? false
+  };
+}
+async function main() {
+  const args = parseCliArgs(process.argv.slice(2));
+  if (args.version) {
+    console.log(VERSION);
+    process.exit(0);
+  }
+  if (args.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  let exitCode = 0;
+  switch (args.command) {
+    case "report":
+      exitCode = await reportCommand({
+        threshold: args.threshold,
+        fail: args.fail,
+        json: args.json,
+        coveragePath: args.coveragePath,
+        noColor: args.noColor,
+        verbose: args.verbose
+      });
+      break;
+    case "init":
+      exitCode = await initCommand({
+        force: args.force,
+        noColor: args.noColor,
+        verbose: args.verbose,
+        dryRun: args.dryRun
+      });
+      break;
+    case "check":
+      exitCode = await checkCommand({
+        noColor: args.noColor,
+        verbose: args.verbose
+      });
+      break;
+  }
+  process.exit(exitCode);
+}
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(2);
+});

package/package.json

@@ -0,0 +1,28 @@
+{
+	"name": "@llbbl/uncov",
+	"version": "0.1.1",
+	"description": "Report files with low test coverage from Vitest/Istanbul output",
+	"type": "module",
+	"main": "./dist/cli.js",
+	"bin": {
+		"uncov": "./dist/cli.js"
+	},
+	"files": ["dist"],
+	"scripts": {
+		"dev": "bun run src/cli.ts",
+		"test": "bun test",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"build": "bun run scripts/build.ts",
+		"build:local": "bun build --compile --outfile=uncov src/cli.ts",
+		"build:npm": "bun build src/cli.ts --outdir=dist --target=node",
+		"test:coverage": "vitest run --coverage",
+		"coverage:low": "uncov"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.4",
+		"@types/bun": "^1.2.4"
+	},
+	"keywords": ["coverage", "vitest", "testing", "cli"],
+	"license": "MIT"
+}