@redaksjon/brennpunkt 0.0.1

package/dist/analyzer.js

@@ -0,0 +1,115 @@
+function parseLcov(content) {
+  const files = [];
+  let current = null;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("SF:")) {
+      current = {
+        file: trimmed.slice(3),
+        linesFound: 0,
+        linesHit: 0,
+        functionsFound: 0,
+        functionsHit: 0,
+        branchesFound: 0,
+        branchesHit: 0
+      };
+    } else if (current) {
+      if (trimmed.startsWith("LF:")) {
+        current.linesFound = parseInt(trimmed.slice(3), 10);
+      } else if (trimmed.startsWith("LH:")) {
+        current.linesHit = parseInt(trimmed.slice(3), 10);
+      } else if (trimmed.startsWith("FNF:")) {
+        current.functionsFound = parseInt(trimmed.slice(4), 10);
+      } else if (trimmed.startsWith("FNH:")) {
+        current.functionsHit = parseInt(trimmed.slice(4), 10);
+      } else if (trimmed.startsWith("BRF:")) {
+        current.branchesFound = parseInt(trimmed.slice(4), 10);
+      } else if (trimmed.startsWith("BRH:")) {
+        current.branchesHit = parseInt(trimmed.slice(4), 10);
+      } else if (trimmed === "end_of_record") {
+        files.push(current);
+        current = null;
+      }
+    }
+  }
+  return files;
+}
+
+function calculateOverallCoverage(files) {
+  const totals = files.reduce((acc, f) => ({
+    linesFound: acc.linesFound + f.linesFound,
+    linesHit: acc.linesHit + f.linesHit,
+    functionsFound: acc.functionsFound + f.functionsFound,
+    functionsHit: acc.functionsHit + f.functionsHit,
+    branchesFound: acc.branchesFound + f.branchesFound,
+    branchesHit: acc.branchesHit + f.branchesHit
+  }), {
+    linesFound: 0,
+    linesHit: 0,
+    functionsFound: 0,
+    functionsHit: 0,
+    branchesFound: 0,
+    branchesHit: 0
+  });
+  return {
+    lines: {
+      found: totals.linesFound,
+      hit: totals.linesHit,
+      coverage: totals.linesFound > 0 ? Math.round(totals.linesHit / totals.linesFound * 1e4) / 100 : 100
+    },
+    functions: {
+      found: totals.functionsFound,
+      hit: totals.functionsHit,
+      coverage: totals.functionsFound > 0 ? Math.round(totals.functionsHit / totals.functionsFound * 1e4) / 100 : 100
+    },
+    branches: {
+      found: totals.branchesFound,
+      hit: totals.branchesHit,
+      coverage: totals.branchesFound > 0 ? Math.round(totals.branchesHit / totals.branchesFound * 1e4) / 100 : 100
+    },
+    fileCount: files.length
+  };
+}
+function analyzeFile(file, weights) {
+  const lineCoverage = file.linesFound > 0 ? file.linesHit / file.linesFound * 100 : 100;
+  const functionCoverage = file.functionsFound > 0 ? file.functionsHit / file.functionsFound * 100 : 100;
+  const branchCoverage = file.branchesFound > 0 ? file.branchesHit / file.branchesFound * 100 : 100;
+  const lineGap = 100 - lineCoverage;
+  const functionGap = 100 - functionCoverage;
+  const branchGap = 100 - branchCoverage;
+  const sizeFactor = Math.log10(Math.max(file.linesFound, 1) + 1);
+  const priorityScore = (branchGap * weights.branches + functionGap * weights.functions + lineGap * weights.lines) * sizeFactor;
+  return {
+    file: file.file,
+    lines: {
+      found: file.linesFound,
+      hit: file.linesHit,
+      coverage: Math.round(lineCoverage * 100) / 100
+    },
+    functions: {
+      found: file.functionsFound,
+      hit: file.functionsHit,
+      coverage: Math.round(functionCoverage * 100) / 100
+    },
+    branches: {
+      found: file.branchesFound,
+      hit: file.branchesHit,
+      coverage: Math.round(branchCoverage * 100) / 100
+    },
+    priorityScore: Math.round(priorityScore * 100) / 100,
+    uncoveredLines: file.linesFound - file.linesHit,
+    uncoveredBranches: file.branchesFound - file.branchesHit
+  };
+}
+function analyzeCoverage(files, weights, minLines, top) {
+  const overall = calculateOverallCoverage(files);
+  const analyzed = files.filter((f) => f.linesFound >= minLines).map((f) => analyzeFile(f, weights)).sort((a, b) => b.priorityScore - a.priorityScore);
+  const results = top ? analyzed.slice(0, top) : analyzed;
+  return {
+    overall,
+    files: results
+  };
+}
+
+export { analyzeCoverage as a, analyzeFile as b, calculateOverallCoverage as c, parseLcov as p };
+//# sourceMappingURL=analyzer.js.map

package/dist/analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.js","sources":["../src/parser.ts","../src/analyzer.ts"],"sourcesContent":["/**\n * LCOV file parser\n */\n\nimport type { LcovFileData } from './types';\n\n/**\n * Parse an LCOV format file content into structured file coverage data.\n * \n * LCOV format documentation:\n * - SF:<source file path> - Start of file record\n * - LF:<lines found> - Total number of instrumented lines\n * - LH:<lines hit> - Number of lines with execution count > 0\n * - FNF:<functions found> - Total number of functions\n * - FNH:<functions hit> - Number of functions executed\n * - BRF:<branches found> - Total number of branches\n * - BRH:<branches hit> - Number of branches taken\n * - end_of_record - End of file record\n * \n * @param content - Raw LCOV file content\n * @returns Array of parsed file coverage data\n */\nexport function parseLcov(content: string): LcovFileData[] {\n    const files: LcovFileData[] = [];\n    let current: LcovFileData | null = null;\n\n    for (const line of content.split('\\n')) {\n        const trimmed = line.trim();\n        \n        if (trimmed.startsWith('SF:')) {\n            current = {\n                file: trimmed.slice(3),\n                linesFound: 0,\n                linesHit: 0,\n                functionsFound: 0,\n                functionsHit: 0,\n                branchesFound: 0,\n                branchesHit: 0,\n            };\n        } else if (current) {\n            if (trimmed.startsWith('LF:')) {\n                current.linesFound = parseInt(trimmed.slice(3), 10);\n            } else if (trimmed.startsWith('LH:')) {\n                current.linesHit = parseInt(trimmed.slice(3), 10);\n            } else if (trimmed.startsWith('FNF:')) {\n                current.functionsFound = parseInt(trimmed.slice(4), 10);\n            } else if (trimmed.startsWith('FNH:')) {\n                current.functionsHit = parseInt(trimmed.slice(4), 10);\n            } else if (trimmed.startsWith('BRF:')) {\n                current.branchesFound = parseInt(trimmed.slice(4), 10);\n            } else if (trimmed.startsWith('BRH:')) {\n                current.branchesHit = parseInt(trimmed.slice(4), 10);\n            } else if (trimmed === 'end_of_record') {\n                files.push(current);\n                current = null;\n            }\n        }\n    }\n\n    return files;\n}\n","/**\n * Coverage analysis and priority scoring\n */\n\nimport type { \n    LcovFileData, \n    PriorityWeights, \n    OverallCoverage, \n    AnalyzedFile,\n    AnalysisResult \n} from './types';\n\n/**\n * Calculate overall coverage statistics from all files.\n * This aggregates totals before any filtering is applied.\n * \n * @param files - Array of parsed LCOV file data\n * @returns Overall coverage summary\n */\nexport function calculateOverallCoverage(files: LcovFileData[]): OverallCoverage {\n    const totals = files.reduce((acc, f) => ({\n        linesFound: acc.linesFound + f.linesFound,\n        linesHit: acc.linesHit + f.linesHit,\n        functionsFound: acc.functionsFound + f.functionsFound,\n        functionsHit: acc.functionsHit + f.functionsHit,\n        branchesFound: acc.branchesFound + f.branchesFound,\n        branchesHit: acc.branchesHit + f.branchesHit,\n    }), {\n        linesFound: 0,\n        linesHit: 0,\n        functionsFound: 0,\n        functionsHit: 0,\n        branchesFound: 0,\n        branchesHit: 0,\n    });\n\n    return {\n        lines: {\n            found: totals.linesFound,\n            hit: totals.linesHit,\n            coverage: totals.linesFound > 0 \n                ? Math.round((totals.linesHit / totals.linesFound) * 10000) / 100 \n                : 100,\n        },\n        functions: {\n            found: totals.functionsFound,\n            hit: totals.functionsHit,\n            coverage: totals.functionsFound > 0 \n                ? Math.round((totals.functionsHit / totals.functionsFound) * 10000) / 100 \n                : 100,\n        },\n        branches: {\n            found: totals.branchesFound,\n            hit: totals.branchesHit,\n            coverage: totals.branchesFound > 0 \n                ? Math.round((totals.branchesHit / totals.branchesFound) * 10000) / 100 \n                : 100,\n        },\n        fileCount: files.length,\n    };\n}\n\n/**\n * Calculate coverage percentages and priority score for a single file.\n * \n * Priority scoring logic:\n * - Higher score = higher priority for testing\n * - Based on coverage gaps (100 - coverage%) for each metric\n * - Weighted by the provided weights (default: branches 0.5, functions 0.3, lines 0.2)\n * - Scaled by file size (log10) so larger files with low coverage rank higher\n * \n * @param file - Parsed LCOV data for a single file\n * @param weights - Weights for each coverage type\n * @returns Analyzed file with coverage percentages and priority score\n */\nexport function analyzeFile(file: LcovFileData, weights: PriorityWeights): AnalyzedFile {\n    const lineCoverage = file.linesFound > 0 \n        ? (file.linesHit / file.linesFound) * 100 \n        : 100;\n    \n    const functionCoverage = file.functionsFound > 0 \n        ? (file.functionsHit / file.functionsFound) * 100 \n        : 100;\n    \n    const branchCoverage = file.branchesFound > 0 \n        ? (file.branchesHit / file.branchesFound) * 100 \n        : 100;\n\n    // Priority score: lower coverage = higher priority (inverted)\n    // Weighted combination of coverage gaps\n    const lineGap = 100 - lineCoverage;\n    const functionGap = 100 - functionCoverage;\n    const branchGap = 100 - branchCoverage;\n\n    // Factor in file size - bigger files with low coverage = more important\n    const sizeFactor = Math.log10(Math.max(file.linesFound, 1) + 1);\n\n    const priorityScore = (\n        (branchGap * weights.branches) +\n        (functionGap * weights.functions) +\n        (lineGap * weights.lines)\n    ) * sizeFactor;\n\n    return {\n        file: file.file,\n        lines: {\n            found: file.linesFound,\n            hit: file.linesHit,\n            coverage: Math.round(lineCoverage * 100) / 100,\n        },\n        functions: {\n            found: file.functionsFound,\n            hit: file.functionsHit,\n            coverage: Math.round(functionCoverage * 100) / 100,\n        },\n        branches: {\n            found: file.branchesFound,\n            hit: file.branchesHit,\n            coverage: Math.round(branchCoverage * 100) / 100,\n        },\n        priorityScore: Math.round(priorityScore * 100) / 100,\n        uncoveredLines: file.linesFound - file.linesHit,\n        uncoveredBranches: file.branchesFound - file.branchesHit,\n    };\n}\n\n/**\n * Perform complete coverage analysis on LCOV data.\n * \n * @param files - Array of parsed LCOV file data\n * @param weights - Priority weights for scoring\n * @param minLines - Minimum lines threshold for including a file\n * @param top - Optional limit on number of results\n * @returns Complete analysis result with overall and per-file data\n */\nexport function analyzeCoverage(\n    files: LcovFileData[],\n    weights: PriorityWeights,\n    minLines: number,\n    top: number | null\n): AnalysisResult {\n    // Calculate overall coverage from ALL files (before filtering)\n    const overall = calculateOverallCoverage(files);\n    \n    // Filter and analyze\n    const analyzed = files\n        .filter(f => f.linesFound >= minLines)\n        .map(f => analyzeFile(f, weights))\n        .sort((a, b) => b.priorityScore - a.priorityScore);\n\n    // Apply top limit if specified\n    const results = top ? analyzed.slice(0, top) : analyzed;\n\n    return {\n        overall,\n        files: results,\n    };\n}\n"],"names":[],"mappings":"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"}

package/dist/main.js

@@ -0,0 +1,376 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { Command } from 'commander';
+import { z } from 'zod';
+import { p as parseLcov, a as analyzeCoverage } from './analyzer.js';
+
+function supportsColor() {
+  if (process.env.NO_COLOR !== void 0) {
+    return false;
+  }
+  if (process.env.FORCE_COLOR !== void 0) {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return false;
+  }
+  if (process.env.TERM === "dumb") {
+    return false;
+  }
+  return true;
+}
+function color(code, text, useColors) {
+  if (!useColors) return text;
+  return `${code}${text}\x1B[0m`;
+}
+function colorPct(pct, useColors) {
+  const text = `${pct.toFixed(2)}%`;
+  if (pct >= 90) return color("\x1B[32m", text, useColors);
+  if (pct >= 80) return color("\x1B[33m", text, useColors);
+  return color("\x1B[31m", text, useColors);
+}
+function getColorCode(coverage, useColors) {
+  if (!useColors) return "";
+  if (coverage < 50) return "\x1B[31m";
+  if (coverage < 80) return "\x1B[33m";
+  return "\x1B[32m";
+}
+function formatTable(result, options, forceColors) {
+  const { overall, files: analyzed } = result;
+  const lines = [];
+  const divider = "─".repeat(120);
+  const useColors = supportsColor();
+  const reset = useColors ? "\x1B[0m" : "";
+  lines.push("");
+  lines.push("📊 Coverage Priority Report");
+  lines.push("");
+  lines.push("┌─────────────────────────────────────────────────────────────────┐");
+  lines.push("│                      OVERALL COVERAGE                           │");
+  lines.push("├─────────────────┬─────────────────┬─────────────────────────────┤");
+  lines.push(`│  Lines: ${colorPct(overall.lines.coverage, useColors).padEnd(24)}│  Functions: ${colorPct(overall.functions.coverage, useColors).padEnd(20)}│  Branches: ${colorPct(overall.branches.coverage, useColors).padEnd(22)}│`);
+  lines.push(`│  (${overall.lines.hit}/${overall.lines.found})`.padEnd(18) + `│  (${overall.functions.hit}/${overall.functions.found})`.padEnd(18) + `│  (${overall.branches.hit}/${overall.branches.found})`.padEnd(30) + "│");
+  lines.push("└─────────────────┴─────────────────┴─────────────────────────────┘");
+  lines.push(`
+Files: ${overall.fileCount} | Weights: B=${options.weights.branches}, F=${options.weights.functions}, L=${options.weights.lines} | Min lines: ${options.minLines}
+`);
+  lines.push(divider);
+  lines.push(
+    "Priority".padEnd(10) + "File".padEnd(45) + "Lines".padEnd(12) + "Funcs".padEnd(12) + "Branch".padEnd(12) + "Uncov Lines".padEnd(12) + "Score"
+  );
+  lines.push(divider);
+  analyzed.forEach((item, index) => {
+    const priority = index + 1;
+    const fileName = item.file.length > 43 ? "..." + item.file.slice(-40) : item.file;
+    const colorLine = getColorCode(item.lines.coverage, useColors);
+    const colorFunc = getColorCode(item.functions.coverage, useColors);
+    const colorBranch = getColorCode(item.branches.coverage, useColors);
+    lines.push(
+      `#${priority}`.padEnd(10) + fileName.padEnd(45) + `${colorLine}${item.lines.coverage.toFixed(1)}%${reset}`.padEnd(21) + `${colorFunc}${item.functions.coverage.toFixed(1)}%${reset}`.padEnd(21) + `${colorBranch}${item.branches.coverage.toFixed(1)}%${reset}`.padEnd(21) + `${item.uncoveredLines}`.padEnd(12) + item.priorityScore.toFixed(1)
+    );
+  });
+  lines.push(divider);
+  lines.push(`
+Total files analyzed: ${analyzed.length}`);
+  const totalUncoveredLines = analyzed.reduce((sum, f) => sum + f.uncoveredLines, 0);
+  const totalUncoveredBranches = analyzed.reduce((sum, f) => sum + f.uncoveredBranches, 0);
+  lines.push(`Total uncovered lines: ${totalUncoveredLines}`);
+  lines.push(`Total uncovered branches: ${totalUncoveredBranches}`);
+  lines.push("");
+  lines.push("🎯 Recommended Focus (Top 3):");
+  lines.push("");
+  analyzed.slice(0, 3).forEach((item, i) => {
+    const reasons = [];
+    if (item.branches.coverage < 70) reasons.push(`${item.branches.found - item.branches.hit} untested branches`);
+    if (item.functions.coverage < 80) reasons.push(`${item.functions.found - item.functions.hit} untested functions`);
+    if (item.lines.coverage < 70) reasons.push(`${item.uncoveredLines} uncovered lines`);
+    lines.push(`  ${i + 1}. ${item.file}`);
+    lines.push(`     ${reasons.join(", ") || "General coverage improvement"}`);
+    lines.push("");
+  });
+  return lines.join("\n");
+}
+function formatJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+const VERSION = "0.0.1";
+const PROGRAM_NAME = "brennpunkt";
+const CONFIG_FILE_NAME = "brennpunkt.yaml";
+const COVERAGE_SEARCH_PATHS = [
+  "coverage/lcov.info",
+  // Jest, Vitest, c8 (most common)
+  ".coverage/lcov.info",
+  // Some configurations
+  "coverage/lcov/lcov.info",
+  // Karma
+  "lcov.info",
+  // Project root
+  ".nyc_output/lcov.info",
+  // NYC legacy
+  "test-results/lcov.info"
+  // Some CI configurations
+];
+const ConfigSchema = z.object({
+  coveragePath: z.string().optional(),
+  weights: z.string().optional(),
+  minLines: z.number().optional(),
+  json: z.boolean().optional(),
+  top: z.number().optional()
+});
+const DEFAULTS = {
+  coveragePath: "coverage/lcov.info",
+  weights: "0.5,0.3,0.2",
+  minLines: 10,
+  json: false,
+  top: void 0
+};
+function parseWeights(weightsStr) {
+  const parts = weightsStr.split(",").map(Number);
+  if (parts.length !== 3 || parts.some(isNaN)) {
+    throw new Error("Weights must be three comma-separated numbers (branches,functions,lines)");
+  }
+  return {
+    branches: parts[0],
+    functions: parts[1],
+    lines: parts[2]
+  };
+}
+function resolveCoveragePath(inputPath) {
+  if (inputPath.startsWith("/")) {
+    return inputPath;
+  }
+  return resolve(process.cwd(), inputPath);
+}
+function discoverCoverageFile() {
+  const cwd = process.cwd();
+  const searched = [];
+  for (const searchPath of COVERAGE_SEARCH_PATHS) {
+    const fullPath = resolve(cwd, searchPath);
+    searched.push(fullPath);
+    if (existsSync(fullPath)) {
+      return { found: fullPath, searched };
+    }
+  }
+  return null;
+}
+function parseSimpleYaml(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, colonIndex).trim();
+    let value = trimmed.slice(colonIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (value === "true") {
+      result[key] = true;
+    } else if (value === "false") {
+      result[key] = false;
+    } else if (!isNaN(Number(value)) && value !== "") {
+      result[key] = Number(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function readConfigFile(configPath) {
+  const paths = configPath ? [configPath] : [
+    resolve(process.cwd(), CONFIG_FILE_NAME),
+    resolve(process.cwd(), ".brennpunkt", "config.yaml")
+  ];
+  for (const filePath of paths) {
+    if (existsSync(filePath)) {
+      try {
+        const content = readFileSync(filePath, "utf-8");
+        const parsed = parseSimpleYaml(content);
+        return ConfigSchema.partial().parse(parsed);
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+function generateConfigFile(outputPath) {
+  const filePath = outputPath || resolve(process.cwd(), CONFIG_FILE_NAME);
+  const configContent = `# Brennpunkt Configuration
+# https://github.com/redaksjon/brennpunkt
+
+# Path to lcov.info coverage file
+# coveragePath: coverage/lcov.info
+
+# Priority weights for branches, functions, lines (must sum to 1.0)
+# Higher branch weight means untested branches are prioritized more heavily
+# weights: "0.5,0.3,0.2"
+
+# Minimum number of lines for a file to be included in analysis
+# Helps filter out tiny utility files
+# minLines: 10
+
+# Output format (true for JSON, false for table)
+# json: false
+
+# Limit results to top N files (comment out or remove for all files)
+# top: 20
+`;
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, configContent, "utf-8");
+  process.stdout.write(`Configuration file created: ${filePath}
+`);
+}
+function checkConfig(cliArgs) {
+  const fileConfig = readConfigFile(cliArgs.config);
+  process.stdout.write("\n");
+  process.stdout.write("================================================================================\n");
+  process.stdout.write("BRENNPUNKT CONFIGURATION\n");
+  process.stdout.write("================================================================================\n\n");
+  const configPath = cliArgs.config || resolve(process.cwd(), CONFIG_FILE_NAME);
+  const configExists = existsSync(configPath);
+  process.stdout.write(`Config file: ${configPath}
+`);
+  process.stdout.write(`Status: ${configExists ? "Found" : "Not found (using defaults)"}
+
+`);
+  process.stdout.write("RESOLVED CONFIGURATION:\n");
+  process.stdout.write("--------------------------------------------------------------------------------\n");
+  const mergedConfig = { ...DEFAULTS, ...fileConfig };
+  const formatValue = (key, value, isFromFile) => {
+    const source = isFromFile ? "[config file]" : "[default]    ";
+    process.stdout.write(`  ${source} ${key.padEnd(15)}: ${JSON.stringify(value)}
+`);
+  };
+  for (const key of Object.keys(DEFAULTS)) {
+    const fileValue = fileConfig[key];
+    const isFromFile = fileValue !== void 0;
+    formatValue(key, mergedConfig[key], isFromFile);
+  }
+  process.stdout.write("\n================================================================================\n");
+}
+function runAnalysis(config, explicitPath) {
+  let resolvedPath;
+  if (explicitPath && config.coveragePath) {
+    resolvedPath = resolveCoveragePath(config.coveragePath);
+    if (!existsSync(resolvedPath)) {
+      process.stderr.write(`Error: Could not find coverage file at ${resolvedPath}
+`);
+      process.stderr.write("Run tests with coverage first: npm test -- --coverage\n");
+      process.exit(1);
+    }
+  } else {
+    const discovered = discoverCoverageFile();
+    if (!discovered) {
+      process.stderr.write("Error: Could not find coverage file\n");
+      process.stderr.write("\nSearched locations:\n");
+      for (const searchPath of COVERAGE_SEARCH_PATHS) {
+        process.stderr.write(`  - ${searchPath}
+`);
+      }
+      process.stderr.write("\nRun tests with coverage first: npm test -- --coverage\n");
+      process.stderr.write("Or specify path explicitly: brennpunkt <path-to-lcov.info>\n");
+      process.exit(1);
+    }
+    resolvedPath = discovered.found;
+    const relativePath = resolvedPath.replace(process.cwd() + "/", "");
+    process.stderr.write(`Using coverage file: ${relativePath}
+
+`);
+  }
+  let weights;
+  try {
+    weights = parseWeights(config.weights || DEFAULTS.weights);
+  } catch (err) {
+    process.stderr.write(`Error: ${err.message}
+`);
+    process.exit(1);
+  }
+  const options = {
+    weights,
+    minLines: config.minLines ?? DEFAULTS.minLines,
+    json: config.json ?? DEFAULTS.json,
+    top: config.top ?? null
+  };
+  let lcovContent;
+  try {
+    lcovContent = readFileSync(resolvedPath, "utf-8");
+  } catch (err) {
+    process.stderr.write(`Error: Could not read ${resolvedPath}
+`);
+    process.stderr.write(`${err.message}
+`);
+    process.exit(1);
+  }
+  const files = parseLcov(lcovContent);
+  if (files.length === 0) {
+    process.stderr.write("Warning: No coverage data found in the file\n");
+    process.exit(0);
+  }
+  const result = analyzeCoverage(files, options.weights, options.minLines, options.top);
+  if (options.json) {
+    process.stdout.write(formatJson(result) + "\n");
+  } else {
+    process.stdout.write(formatTable(result, options) + "\n");
+  }
+}
+function main() {
+  const program = new Command();
+  program.name(PROGRAM_NAME).description("Coverage priority analyzer - identify where to focus testing efforts").version(VERSION).argument("[coverage-path]", "Path to lcov.info file", DEFAULTS.coveragePath).option("-w, --weights <weights>", "Custom weights for branches,functions,lines", DEFAULTS.weights).option("-m, --min-lines <number>", "Exclude files with fewer than N lines", String(DEFAULTS.minLines)).option("-j, --json", "Output as JSON", DEFAULTS.json).option("-t, --top <number>", "Show only top N priority files").option("-c, --config <path>", "Path to configuration file", CONFIG_FILE_NAME).option("--init-config", "Generate a default brennpunkt.yaml configuration file").option("--check-config", "Display resolved configuration and exit");
+  program.parse();
+  const cliArgs = program.opts();
+  const coveragePath = program.args[0] || cliArgs.coveragePath;
+  if (process.argv.includes("--init-config")) {
+    generateConfigFile(cliArgs.config);
+    return;
+  }
+  if (process.argv.includes("--check-config")) {
+    checkConfig(cliArgs);
+    return;
+  }
+  const fileConfig = readConfigFile(cliArgs.config);
+  const explicitPath = Boolean(coveragePath || fileConfig.coveragePath);
+  let parsedMinLines;
+  let parsedTop;
+  if (cliArgs.minLines) {
+    parsedMinLines = parseInt(cliArgs.minLines, 10);
+    if (isNaN(parsedMinLines) || parsedMinLines < 0) {
+      process.stderr.write(`Error: --min-lines must be a non-negative number
+`);
+      process.exit(1);
+    }
+  }
+  if (cliArgs.top) {
+    parsedTop = parseInt(cliArgs.top, 10);
+    if (isNaN(parsedTop) || parsedTop <= 0) {
+      process.stderr.write(`Error: --top must be a positive number
+`);
+      process.exit(1);
+    }
+  }
+  const config = {
+    ...DEFAULTS,
+    ...fileConfig,
+    ...coveragePath && { coveragePath },
+    ...cliArgs.weights && { weights: cliArgs.weights },
+    ...parsedMinLines !== void 0 && { minLines: parsedMinLines },
+    ...cliArgs.json !== void 0 && { json: cliArgs.json },
+    ...parsedTop !== void 0 && { top: parsedTop }
+  };
+  runAnalysis(config, explicitPath);
+}
+const isTestEnvironment = process.env.NODE_ENV === "test" || process.env.VITEST === "true" || process.argv.some((arg) => arg.includes("vitest"));
+if (!isTestEnvironment) {
+  main();
+}
+
+export { ConfigSchema, discoverCoverageFile };
+//# sourceMappingURL=main.js.map