@andy2639/jest-context 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1112 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CONSOLE_LOG_TYPES: () => CONSOLE_LOG_TYPES,
+  JEST_PATTERNS: () => JEST_PATTERNS,
+  VALID_EXPORT_FORMATS: () => VALID_EXPORT_FORMATS,
+  VALID_MODES: () => VALID_MODES,
+  VALID_TEST_EXTENSIONS: () => VALID_TEST_EXTENSIONS,
+  buildJestArgsForMode: () => buildJestArgsForMode,
+  buildTimestampedPath: () => buildTimestampedPath,
+  createProgressBar: () => createProgressBar,
+  createSpinner: () => createSpinner,
+  detectPackageManager: () => detectPackageManager,
+  displayBanner: () => displayBanner,
+  displayHelp: () => displayHelp,
+  execCommand: () => execCommand,
+  exitWithError: () => exitWithError,
+  exportToFile: () => exportToFile,
+  extractConsoleType: () => extractConsoleType,
+  extractFailures: () => extractFailures,
+  filterTestFiles: () => filterTestFiles,
+  formatAsMarkdown: () => formatAsMarkdown,
+  getDisplayTimestamp: () => getDisplayTimestamp,
+  getFilenameTimestamp: () => getFilenameTimestamp,
+  getJestCommand: () => getJestCommand,
+  getPlatform: () => getPlatform,
+  getStagedFiles: () => getStagedFiles,
+  handleExportOrDisplay: () => handleExportOrDisplay,
+  hasGit: () => hasGit,
+  isCodeSnippetLine: () => isCodeSnippetLine,
+  isConsoleTypeLine: () => isConsoleTypeLine,
+  isLinux: () => isLinux,
+  isMac: () => isMac,
+  isStackTraceLine: () => isStackTraceLine,
+  isWindows: () => isWindows,
+  logInfo: () => logInfo,
+  logSuccess: () => logSuccess,
+  logWarning: () => logWarning,
+  parseExportCliArgs: () => parseExportCliArgs,
+  resolveCommand: () => resolveCommand,
+  runConsoleContext: () => runConsoleContext,
+  runCoverageContext: () => runCoverageContext,
+  runJest: () => runJest,
+  runTestContext: () => runTestContext,
+  shouldShowUI: () => shouldShowUI,
+  stripAnsi: () => stripAnsi,
+  validateCliArgs: () => validateCliArgs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/constants.ts
+var VALID_MODES = ["--all", "--related", "--tests"];
+var VALID_EXPORT_FORMATS = ["txt", "md"];
+var VALID_TEST_EXTENSIONS = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
+var CONSOLE_LOG_TYPES = {
+  ERROR: "console.error",
+  WARN: "console.warn",
+  LOG: "console.log",
+  DEBUG: "console.debug"
+};
+var JEST_PATTERNS = {
+  FAIL_LINE: /^FAIL\s+/,
+  PASS_LINE: /^PASS\s+/,
+  TEST_FILE: /^(PASS|FAIL)\s+(.+\.(test|spec)\.tsx?)/,
+  COVERAGE_LINE: /^(.+?)\s+\|\s+([\d.]+)\s+\|\s+([\d.]+)\s+\|\s+([\d.]+)\s+\|\s+([\d.]+)(?:\s+\|\s+(.+))?$/,
+  BULLET_POINT: /^●\s+/,
+  CODE_LINE: /^>?\s*\d*\s*\|/,
+  STACK_TRACE: /^\s+at\s+/
+};
+
+// src/core/platform.ts
+function getPlatform() {
+  return process.platform;
+}
+function isWindows() {
+  return process.platform === "win32";
+}
+function isMac() {
+  return process.platform === "darwin";
+}
+function isLinux() {
+  return process.platform === "linux";
+}
+function resolveCommand(cmd) {
+  if (!isWindows()) return cmd;
+  const windowsCommands = {
+    git: "git.exe",
+    node: "node.exe",
+    npm: "npm.cmd",
+    npx: "npx.cmd",
+    yarn: "yarn.cmd",
+    pnpm: "pnpm.cmd"
+  };
+  return windowsCommands[cmd] ?? cmd;
+}
+
+// src/core/package-manager.ts
+function detectPackageManager() {
+  if (process.env.npm_execpath?.includes("yarn")) return "yarn";
+  if (process.env.npm_execpath?.includes("pnpm")) return "pnpm";
+  return "npm";
+}
+function getJestCommand(packageManager = null) {
+  const pm = packageManager ?? detectPackageManager();
+  switch (pm) {
+    case "yarn":
+      return ["yarn", "jest"];
+    case "pnpm":
+      return ["pnpm", "jest"];
+    default:
+      return ["npx", "jest"];
+  }
+}
+
+// src/core/exec.ts
+var import_node_child_process = require("child_process");
+async function execCommand(cmd, args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const resolvedCmd = resolveCommand(cmd);
+    const child = (0, import_node_child_process.spawn)(resolvedCmd, args, {
+      shell: options.shell ?? process.platform === "win32"
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr?.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      const result = {
+        stdout,
+        stderr,
+        output: `${stdout}
+${stderr}`,
+        code
+      };
+      if (code !== 0 && !options.ignoreErrors) {
+        reject(new Error(`Command failed with code ${code}: ${cmd} ${args.join(" ")}`));
+        return;
+      }
+      resolve(result);
+    });
+    child.on("error", (error) => {
+      reject(new Error(`Failed to execute command: ${error.message}`));
+    });
+  });
+}
+
+// src/core/git.ts
+var cachedGitAvailability = null;
+var cachedStagedFiles = null;
+var cachedStagedFilesAt = 0;
+var STAGED_FILES_CACHE_TTL_MS = 1e3;
+async function hasGit() {
+  if (cachedGitAvailability !== null) {
+    return cachedGitAvailability;
+  }
+  try {
+    const result = await execCommand("git", ["--version"], { ignoreErrors: true });
+    cachedGitAvailability = result.code === 0;
+    return cachedGitAvailability;
+  } catch {
+    cachedGitAvailability = false;
+    return false;
+  }
+}
+async function getStagedFiles() {
+  const now = Date.now();
+  if (cachedStagedFiles && now - cachedStagedFilesAt <= STAGED_FILES_CACHE_TTL_MS) {
+    return cachedStagedFiles;
+  }
+  const gitAvailable = await hasGit();
+  if (!gitAvailable) {
+    throw new Error("Git is not installed or not available in PATH");
+  }
+  const result = await execCommand("git", ["diff", "--name-only", "--cached"], {
+    ignoreErrors: true
+  });
+  const files = result.stdout.split("\n").map((f) => f.trim()).filter(Boolean);
+  cachedStagedFiles = files;
+  cachedStagedFilesAt = now;
+  return files;
+}
+function filterTestFiles(files) {
+  return files.filter((file) => VALID_TEST_EXTENSIONS.test(file));
+}
+
+// src/core/jest.ts
+var import_node_child_process2 = require("child_process");
+async function runJest(args = [], options = {}) {
+  const {
+    verbose = false,
+    coverage = false,
+    packageManager = null,
+    ignoreErrors = true,
+    disableVerbose = false
+  } = options;
+  const jestCmd = getJestCommand(packageManager);
+  const jestArgs = [...jestCmd.slice(1)];
+  if (verbose && !disableVerbose) {
+    jestArgs.push("--verbose");
+  }
+  if (coverage) {
+    jestArgs.push("--coverage");
+    if (options.coverageReporters) {
+      for (const reporter of options.coverageReporters) {
+        jestArgs.push(`--coverageReporters=${reporter}`);
+      }
+    }
+  }
+  if (isWindows()) {
+    jestArgs.push("--no-watchman");
+  }
+  jestArgs.push(...args);
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process2.spawn)(jestCmd[0], jestArgs, {
+      shell: isWindows()
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (d) => {
+      stdout += d.toString();
+    });
+    child.stderr.on("data", (d) => {
+      stderr += d.toString();
+    });
+    child.on("close", (code) => {
+      const result = {
+        stdout,
+        stderr,
+        output: `${stdout}
+${stderr}`,
+        code
+      };
+      if (code !== 0 && !ignoreErrors) {
+        reject(new Error(`Jest failed with code ${code}`));
+        return;
+      }
+      resolve(result);
+    });
+    child.on("error", reject);
+  });
+}
+async function buildJestArgsForMode(mode) {
+  if (mode === "all") {
+    return [];
+  }
+  const staged = await getStagedFiles();
+  if (staged.length === 0) {
+    throw new Error(`No staged files found for mode: ${mode}`);
+  }
+  if (mode === "tests") {
+    const testFiles = filterTestFiles(staged);
+    if (testFiles.length === 0) {
+      throw new Error("No test files found in staged files");
+    }
+    return testFiles;
+  }
+  return ["--findRelatedTests", ...staged];
+}
+
+// src/core/parsing.ts
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function isCodeSnippetLine(line) {
+  return JEST_PATTERNS.CODE_LINE.test(stripAnsi(line).trim());
+}
+function isStackTraceLine(line) {
+  return JEST_PATTERNS.STACK_TRACE.test(stripAnsi(line));
+}
+function isConsoleTypeLine(line) {
+  const clean = stripAnsi(line).trim();
+  return Object.values(CONSOLE_LOG_TYPES).includes(clean);
+}
+function extractConsoleType(line) {
+  const clean = stripAnsi(line).trim();
+  return Object.values(CONSOLE_LOG_TYPES).find((type) => type === clean) ?? null;
+}
+
+// src/core/export.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"));
+function getDisplayTimestamp(locale = "en-US") {
+  return (/* @__PURE__ */ new Date()).toLocaleString(locale, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+}
+function getFilenameTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (value) => String(value).padStart(2, "0");
+  return [now.getFullYear(), pad(now.getMonth() + 1), pad(now.getDate())].join("-") + "_" + [pad(now.getHours()), pad(now.getMinutes()), pad(now.getSeconds())].join("-");
+}
+function buildTimestampedPath(prefix, extension, dir = process.cwd()) {
+  const timestamp = getFilenameTimestamp();
+  const filename = `${prefix}-${timestamp}.${extension}`;
+  return import_node_path.default.resolve(dir, filename);
+}
+function formatAsMarkdown(content, title, timestamp = null) {
+  const lines = [`# ${title}`, ""];
+  if (timestamp) {
+    lines.push(`Generated: ${timestamp}`, "");
+  }
+  lines.push("```text", content.trimEnd(), "```", "");
+  return lines.join("\n");
+}
+function exportToFile(content, options) {
+  const { prefix, format, title, dir = process.cwd() } = options;
+  const filePath = buildTimestampedPath(prefix, format, dir);
+  let finalContent = content;
+  if (format === "md" && title) {
+    finalContent = formatAsMarkdown(content, title, getDisplayTimestamp());
+  }
+  (0, import_node_fs.writeFileSync)(filePath, finalContent, "utf-8");
+  return filePath;
+}
+function parseExportCliArgs(args) {
+  let exportFormat = null;
+  const exportArgs = [];
+  for (const arg of args) {
+    if (arg === "--export") {
+      exportFormat = "txt";
+      exportArgs.push(arg);
+      continue;
+    }
+    if (!arg.startsWith("--export=")) {
+      continue;
+    }
+    const value = arg.slice("--export=".length).trim().toLowerCase();
+    if (!value || !VALID_EXPORT_FORMATS.includes(value)) {
+      throw new Error(`Invalid value for --export: ${value || "(empty)"}. Valid values: txt, md`);
+    }
+    exportFormat = value;
+    exportArgs.push(arg);
+  }
+  return { exportFormat, exportArgs };
+}
+function handleExportOrDisplay(content, config) {
+  const { exportFormat, prefix, title } = config;
+  if (!exportFormat) {
+    console.log(content);
+    return null;
+  }
+  const outputPath = exportToFile(content, {
+    prefix,
+    format: exportFormat,
+    title
+  });
+  console.log(`Output exported to: ${outputPath}`);
+  return outputPath;
+}
+
+// src/core/cli.ts
+function validateCliArgs(args, schema) {
+  const parsed = {};
+  const unknownArgs = [];
+  for (const [key, config] of Object.entries(schema)) {
+    if (config.default !== void 0) {
+      parsed[key] = config.default;
+    }
+  }
+  for (const arg of args) {
+    let matched = false;
+    for (const [key, config] of Object.entries(schema)) {
+      if (config.values?.includes(arg)) {
+        if (config.exclusive && parsed[key] !== void 0 && parsed[key] !== config.default) {
+          throw new Error(`Multiple values provided for ${key}: ${parsed[key]} and ${arg}`);
+        }
+        parsed[key] = arg;
+        matched = true;
+        break;
+      }
+      if (config.prefix && arg.startsWith(config.prefix)) {
+        const value = arg.slice(config.prefix.length).trim().toLowerCase();
+        if (!value) {
+          parsed[key] = "true";
+          matched = true;
+          break;
+        }
+        if (config.allowedValues && !config.allowedValues.includes(value)) {
+          throw new Error(
+            `Invalid value for ${config.prefix}: ${value}. Valid values: ${config.allowedValues.join(", ")}`
+          );
+        }
+        parsed[key] = value;
+        matched = true;
+        break;
+      }
+    }
+    if (!matched && arg.startsWith("--")) {
+      unknownArgs.push(arg);
+    }
+  }
+  return { parsed, unknownArgs };
+}
+function displayHelp(title, content) {
+  console.log(`
+${title}
+`);
+  if (content.description) {
+    console.log(`${content.description}
+`);
+  }
+  if (content.usage?.length) {
+    console.log("Usage:");
+    content.usage.forEach((line) => console.log(`  ${line}`));
+    console.log("");
+  }
+  if (content.options?.length) {
+    console.log("Options:");
+    content.options.forEach((line) => console.log(`  ${line}`));
+    console.log("");
+  }
+  if (content.examples?.length) {
+    console.log("Examples:");
+    content.examples.forEach((line) => console.log(`  ${line}`));
+    console.log("");
+  }
+  process.exit(0);
+}
+function exitWithError(message, code = 1) {
+  console.error(`\u274C ${message}`);
+  process.exit(code);
+}
+function logWarning(message) {
+  console.warn(`\u26A0\uFE0F  ${message}`);
+}
+function logInfo(message) {
+  console.log(`\u2139\uFE0F  ${message}`);
+}
+function logSuccess(message) {
+  console.log(`\u2705 ${message}`);
+}
+
+// src/core/ui.ts
+function shouldShowUI(exportMode, noBanner = false) {
+  return !exportMode && !noBanner && Boolean(process.stdout.isTTY);
+}
+function displayBanner(config) {
+  const { text, subtitle, info = {}, colors = ["cyan"], font = "block" } = config;
+  const bannerText = [text, subtitle].filter(Boolean).join(" ").trim();
+  const cfonts = require("cfonts");
+  const boxenModule = require("boxen");
+  const boxen = typeof boxenModule === "function" ? boxenModule : boxenModule.default;
+  const renderedBanner = cfonts.render(bannerText, {
+    font,
+    colors,
+    align: "left",
+    background: "transparent",
+    letterSpacing: 1,
+    lineHeight: 1,
+    space: false,
+    maxLength: "0",
+    env: "node"
+  });
+  const infoLine = Object.entries(info).map(([key, value]) => `${key}: ${value}`).join(" | ");
+  const contentLines = [renderedBanner.string.trimEnd()];
+  if (infoLine) {
+    contentLines.push("", ` ${infoLine}`);
+  }
+  contentLines.push(` Date: ${getDisplayTimestamp()}`);
+  const boxed = boxen(contentLines.join("\n"), {
+    padding: {
+      top: 0,
+      right: 1,
+      bottom: 0,
+      left: 1
+    },
+    margin: {
+      top: 0,
+      right: 0,
+      bottom: 1,
+      left: 0
+    },
+    borderStyle: "round",
+    borderColor: colors[0] ?? "cyan"
+  });
+  console.log(boxed);
+}
+function createSpinner(text, color = "cyan") {
+  const ora = require("ora");
+  return ora({ text, color, spinner: "dots" });
+}
+function createProgressBar(total = 100, task = "Progress") {
+  const cliProgress = require("cli-progress");
+  const bar = new cliProgress.SingleBar(
+    {
+      format: "{task} [{bar}] {percentage}% | {status}",
+      barCompleteChar: "\u2588",
+      barIncompleteChar: "\u2591",
+      hideCursor: true,
+      barsize: 24
+    },
+    cliProgress.Presets.shades_classic
+  );
+  bar.start(total, 0, {
+    task,
+    status: "Starting..."
+  });
+  return {
+    update: (value, payload) => bar.update(value, payload),
+    stop: () => bar.stop()
+  };
+}
+
+// src/commands/test-context.ts
+function extractFailures(raw) {
+  const lines = raw.split("\n");
+  const temp = [];
+  let current = null;
+  for (const line of lines) {
+    if (JEST_PATTERNS.FAIL_LINE.test(line)) {
+      if (current) {
+        temp.push(current);
+      }
+      current = {
+        file: line.replace("FAIL ", "").trim(),
+        tests: []
+      };
+      continue;
+    }
+    if (JEST_PATTERNS.BULLET_POINT.test(line.trim())) {
+      current?.tests.push(line.trim().slice(1).trim());
+    }
+  }
+  if (current) {
+    temp.push(current);
+  }
+  const merged = {};
+  for (const item of temp) {
+    if (!merged[item.file]) {
+      merged[item.file] = {
+        file: item.file,
+        tests: []
+      };
+    }
+    merged[item.file].tests.push(...item.tests);
+  }
+  for (const value of Object.values(merged)) {
+    value.tests = Array.from(new Set(value.tests));
+  }
+  return Object.values(merged);
+}
+async function runTestContext(argv = process.argv.slice(2)) {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    displayHelp("Test Context Script", {
+      description: "Run Jest and print failures in LLM-friendly format.",
+      usage: [
+        "test-context -- --all",
+        "test-context -- --related",
+        "test-context -- --tests"
+      ],
+      options: [
+        "--all               Run all tests (default)",
+        "--related           Run tests related to staged files",
+        "--tests             Run only staged test files",
+        "--export            Export output as txt",
+        "--export=txt|md     Export output in selected format",
+        "--no-banner         Disable fancy terminal UI",
+        "-h, --help          Show this help"
+      ],
+      examples: ["test-context -- --related --export=md"]
+    });
+  }
+  const noBanner = argv.includes("--no-banner");
+  const args = argv.filter((arg) => arg !== "--no-banner");
+  let exportFormat;
+  let exportArgs;
+  let parsed;
+  let unknownArgs;
+  try {
+    ({ exportFormat, exportArgs } = parseExportCliArgs(args));
+    ({ parsed, unknownArgs } = validateCliArgs(args, {
+      mode: {
+        values: [...VALID_MODES],
+        default: "--all",
+        exclusive: true
+      }
+    }));
+  } catch (error) {
+    exitWithError(error.message);
+  }
+  const exportArgSet = new Set(exportArgs);
+  const filteredUnknownArgs = unknownArgs.filter((arg) => !exportArgSet.has(arg));
+  if (filteredUnknownArgs.length > 0) {
+    logWarning(`Unknown arguments ignored: ${filteredUnknownArgs.join(", ")}`);
+  }
+  const modeArg = parsed.mode ?? "--all";
+  const mode = modeArg === "--related" ? "related" : modeArg === "--tests" ? "tests" : "all";
+  const showUI = shouldShowUI(exportFormat, noBanner);
+  if (showUI) {
+    displayBanner({
+      text: "TEST",
+      subtitle: "CONTEXT",
+      info: {
+        Mode: mode
+      },
+      colors: ["cyan", "blue"]
+    });
+  }
+  let jestArgs = [];
+  try {
+    jestArgs = await buildJestArgsForMode(mode);
+  } catch (error) {
+    exitWithError(error.message);
+  }
+  const spinner = showUI ? createSpinner("Running Jest tests...") : null;
+  spinner?.start();
+  const result = await runJest(jestArgs, {
+    verbose: true,
+    ignoreErrors: true
+  });
+  const output = stripAnsi(result.output);
+  const hadFailures = output.includes("FAIL") || output.includes("\u25CF");
+  if (spinner) {
+    if (hadFailures) {
+      spinner.warn("Tests completed with failures");
+    } else {
+      spinner.succeed("All tests passed!");
+    }
+  }
+  if (!hadFailures) {
+    const passMessage = "All tests passed!";
+    handleExportOrDisplay(passMessage, {
+      exportFormat,
+      prefix: "export-test-context",
+      title: "Test Context"
+    });
+    return;
+  }
+  const failures = extractFailures(output);
+  const lines = ["=== LLM TEST CONTEXT BEGIN ===", ""];
+  if (failures.length === 0) {
+    lines.push("No test failures could be parsed from Jest output.");
+    lines.push("This may happen if Jest failed before running tests.", "");
+  }
+  for (const fail of failures) {
+    lines.push(`File: ${fail.file}`);
+    lines.push("Failures:");
+    for (const test of fail.tests) {
+      lines.push(`- ${test}`);
+    }
+    lines.push("");
+  }
+  lines.push("=== LLM TEST CONTEXT END ===");
+  handleExportOrDisplay(lines.join("\n"), {
+    exportFormat,
+    prefix: "export-test-context",
+    title: "Test Context"
+  });
+}
+
+// src/commands/coverage-context.ts
+var import_node_path2 = __toESM(require("path"));
+function parseCoverage(text) {
+  const lines = text.split("\n");
+  const rows = [];
+  let currentFolder = null;
+  for (const line of lines) {
+    const match = line.match(JEST_PATTERNS.COVERAGE_LINE);
+    if (!match) continue;
+    const [, rawFile, stmts, branch, funcs, linesPct, uncovered] = match;
+    const normalized = rawFile.trim();
+    if (normalized === "All files") continue;
+    const isFile = /\.(ts|tsx)$/.test(normalized);
+    if (!isFile) {
+      currentFolder = normalized;
+      continue;
+    }
+    if (/index\.(ts|tsx)$/.test(normalized)) continue;
+    if (!currentFolder) currentFolder = import_node_path2.default.dirname(normalized);
+    rows.push({
+      folder: currentFolder,
+      file: import_node_path2.default.basename(normalized),
+      stmts: Number(stmts),
+      branch: Number(branch),
+      funcs: Number(funcs),
+      lines: Number(linesPct),
+      uncovered: uncovered?.trim()
+    });
+  }
+  return rows;
+}
+function filterIncomplete(rows, threshold = 100) {
+  return rows.filter(
+    (r) => !(r.stmts >= threshold && r.branch >= threshold && r.funcs >= threshold && r.lines >= threshold)
+  );
+}
+function groupByFolder(rows) {
+  const grouped = {};
+  for (const row of rows) {
+    const { folder, file, ...rest } = row;
+    if (!grouped[folder]) grouped[folder] = [];
+    grouped[folder].push({ file, coverage: rest });
+  }
+  return grouped;
+}
+function formatCoverageOutput(grouped) {
+  let output = "";
+  for (const folder of Object.keys(grouped)) {
+    output += `\u{1F4C1} Folder: ${folder}
+`;
+    for (const item of grouped[folder]) {
+      const { file, coverage } = item;
+      output += ` \u{1F4C4} File: ${file}
+`;
+      output += `- Coverage:
+`;
+      output += `  - Stmts:  ${coverage.stmts}
+`;
+      output += `  - Branch: ${coverage.branch}
+`;
+      output += `  - Funcs:  ${coverage.funcs}
+`;
+      output += `  - Lines:  ${coverage.lines}
+`;
+      output += `  - Uncovered: ${coverage.uncovered || "N/A"}
+
+`;
+    }
+    output += "\n";
+  }
+  return output.trim();
+}
+async function runCoverageContext(argv = process.argv.slice(2)) {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    displayHelp("Coverage Context Script", {
+      description: "Run Jest coverage and print files below threshold.",
+      usage: ["coverage-context", "coverage-context --threshold=90"],
+      options: [
+        "--threshold=0..100  Minimum percentage for stmts/branch/funcs/lines (default: 100)",
+        "--export            Export output as txt",
+        "--export=txt|md     Export output in selected format",
+        "--no-banner         Disable fancy terminal UI",
+        "-h, --help          Show this help"
+      ],
+      examples: ["coverage-context --threshold=90 --export=md"]
+    });
+  }
+  const noBanner = argv.includes("--no-banner");
+  const args = argv.filter((arg) => arg !== "--no-banner");
+  const { exportFormat, exportArgs } = parseExportCliArgs(args);
+  const { parsed, unknownArgs } = validateCliArgs(args, {
+    threshold: {
+      prefix: "--threshold=",
+      allowedValues: Array.from({ length: 101 }, (_, i) => String(i))
+    }
+  });
+  const exportArgSet = new Set(exportArgs);
+  const filteredUnknownArgs = unknownArgs.filter((arg) => !exportArgSet.has(arg));
+  if (filteredUnknownArgs.length > 0) {
+    logWarning(`Unknown arguments ignored: ${filteredUnknownArgs.join(", ")}`);
+  }
+  const threshold = parsed.threshold ? Number(parsed.threshold) : 100;
+  const showUI = shouldShowUI(exportFormat, noBanner);
+  if (showUI) {
+    displayBanner({
+      text: "COVERAGE",
+      info: {
+        Threshold: `>=${threshold}%`
+      },
+      colors: ["magenta", "blue"]
+    });
+  }
+  const bar = showUI ? createProgressBar(100, "Running coverage") : null;
+  bar?.update(10, { status: "Running Jest..." });
+  const result = await runJest([], {
+    coverage: true,
+    coverageReporters: ["text", "text-summary"],
+    ignoreErrors: true
+  });
+  bar?.update(70, { status: "Parsing output..." });
+  const rows = parseCoverage(result.output);
+  if (rows.length === 0) {
+    bar?.update(100, { status: "Done" });
+    bar?.stop();
+    handleExportOrDisplay("No coverage rows parsed from Jest output.", {
+      exportFormat,
+      prefix: "export-coverage-context",
+      title: "Coverage Context"
+    });
+    return;
+  }
+  const incomplete = filterIncomplete(rows, threshold);
+  const grouped = groupByFolder(incomplete);
+  bar?.update(100, { status: "Done" });
+  bar?.stop();
+  if (Object.keys(grouped).length === 0) {
+    handleExportOrDisplay(`All files meet threshold >= ${threshold}%`, {
+      exportFormat,
+      prefix: "export-coverage-context",
+      title: "Coverage Context"
+    });
+    return;
+  }
+  const formatted = formatCoverageOutput(grouped);
+  handleExportOrDisplay(formatted, {
+    exportFormat,
+    prefix: "export-coverage-context",
+    title: "Coverage Context"
+  });
+}
+
+// src/commands/console-context.ts
+var import_node_path3 = __toESM(require("path"));
+function parseConsoleWarnings(rawOutput) {
+  const lines = rawOutput.split("\n");
+  const warnings = [];
+  const state = {
+    currentTestFile: null,
+    currentWarning: null,
+    pendingWarnings: []
+  };
+  const flushCurrentWarning = () => {
+    if (!state.currentWarning) return;
+    if (state.currentWarning.testFile === "unknown" && state.currentTestFile) {
+      state.currentWarning.testFile = state.currentTestFile;
+    }
+    warnings.push(state.currentWarning);
+    state.pendingWarnings.push(state.currentWarning);
+    state.currentWarning = null;
+  };
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (JEST_PATTERNS.TEST_FILE.test(trimmed)) {
+      const match = trimmed.match(JEST_PATTERNS.TEST_FILE);
+      if (match) {
+        state.currentTestFile = import_node_path3.default.basename(match[2]);
+        for (const warning of state.pendingWarnings) {
+          if (warning.testFile === "unknown") warning.testFile = state.currentTestFile;
+        }
+      }
+      flushCurrentWarning();
+      continue;
+    }
+    if (trimmed === "\u25CF Console") {
+      continue;
+    }
+    if (isConsoleTypeLine(line)) {
+      flushCurrentWarning();
+      state.currentWarning = {
+        type: extractConsoleType(line) ?? "console.warn",
+        testFile: state.currentTestFile ?? "unknown",
+        messages: []
+      };
+      continue;
+    }
+    if (!state.currentWarning) continue;
+    if (isCodeSnippetLine(line)) continue;
+    if (isStackTraceLine(line)) continue;
+    const cleanMessage = stripAnsi(line).trim();
+    if (cleanMessage.length > 0) {
+      state.currentWarning.messages.push(cleanMessage);
+    }
+  }
+  flushCurrentWarning();
+  return warnings;
+}
+function filterWarningsByType(warnings, filter) {
+  if (filter === "errors") {
+    return warnings.filter((w) => w.type === CONSOLE_LOG_TYPES.ERROR);
+  }
+  if (filter === "warns") {
+    return warnings.filter((w) => w.type === CONSOLE_LOG_TYPES.WARN);
+  }
+  return warnings;
+}
+function groupByTestFile(warnings) {
+  const grouped = {};
+  for (const warning of warnings) {
+    const file = warning.testFile;
+    if (!grouped[file]) grouped[file] = [];
+    grouped[file].push(warning);
+  }
+  return grouped;
+}
+function sortFilesByWarningCount(grouped) {
+  const entries = Object.entries(grouped);
+  entries.sort((a, b) => b[1].length - a[1].length);
+  return entries;
+}
+function formatWarningsOutput(grouped, timestamp, stats) {
+  const lines = [];
+  lines.push("=== CONSOLE WARNINGS CONTEXT BEGIN ===", "", `\u{1F4C5} Run Date: ${timestamp}`, "");
+  const sortedEntries = sortFilesByWarningCount(grouped);
+  const totalFiles = sortedEntries.length;
+  if (totalFiles === 0) {
+    lines.push("\u2705 No console warnings found!");
+  } else {
+    lines.push(
+      `\u26A0\uFE0F  Found ${stats.total} warning(s) in ${totalFiles} test file(s)`,
+      "",
+      "\u{1F4CA} Summary by Type:",
+      `   - console.error: ${stats.byType[CONSOLE_LOG_TYPES.ERROR] ?? 0} occurrence(s)`,
+      `   - console.warn:  ${stats.byType[CONSOLE_LOG_TYPES.WARN] ?? 0} occurrence(s)`,
+      "",
+      "=".repeat(60),
+      ""
+    );
+    for (const [file, warnings] of sortedEntries) {
+      lines.push(`\u{1F4C4} File: ${file}`, `   Total Warnings: ${warnings.length}`, "");
+      warnings.forEach((warning, idx) => {
+        lines.push(`   ${idx + 1}. ${warning.type}`, "");
+        if (warning.messages.length > 0) {
+          lines.push("   \u{1F4DD} Message:");
+          warning.messages.forEach((msg) => lines.push(`      ${msg}`));
+          lines.push("");
+        }
+        if (idx < warnings.length - 1) {
+          lines.push("   " + "-".repeat(50), "");
+        }
+      });
+      lines.push("=".repeat(60), "");
+    }
+  }
+  lines.push("=== CONSOLE WARNINGS CONTEXT END ===");
+  return `${lines.join("\n")}
+`;
+}
+function calculateStatistics(warnings) {
+  const stats = {
+    total: warnings.length,
+    byType: {
+      [CONSOLE_LOG_TYPES.ERROR]: 0,
+      [CONSOLE_LOG_TYPES.WARN]: 0
+    }
+  };
+  for (const warning of warnings) {
+    if (warning.type === CONSOLE_LOG_TYPES.ERROR) {
+      stats.byType[CONSOLE_LOG_TYPES.ERROR]++;
+    } else if (warning.type === CONSOLE_LOG_TYPES.WARN) {
+      stats.byType[CONSOLE_LOG_TYPES.WARN]++;
+    }
+  }
+  return stats;
+}
+async function runConsoleContext(argv = process.argv.slice(2)) {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    displayHelp("Console Context Script", {
+      description: "Capture and format console warnings/errors from Jest output.",
+      usage: [
+        "console-context -- --all",
+        "console-context -- --related",
+        "console-context -- --tests"
+      ],
+      options: [
+        "--all              Run all tests (default)",
+        "--related          Run tests related to staged files",
+        "--tests            Run only staged test files",
+        "--only-errors      Show only console.error warnings",
+        "--only-warns       Show only console.warn warnings",
+        "--export           Export output as txt",
+        "--export=txt|md    Export output in selected format",
+        "--no-banner        Disable fancy terminal UI",
+        "-h, --help         Show this help"
+      ],
+      examples: [
+        "console-context -- --related --only-errors",
+        "console-context -- --all --export=md"
+      ]
+    });
+  }
+  const noBanner = argv.includes("--no-banner");
+  const args = argv.filter((arg) => arg !== "--no-banner");
+  const { exportFormat, exportArgs } = parseExportCliArgs(args);
+  const { parsed, unknownArgs } = validateCliArgs(args, {
+    mode: {
+      values: [...VALID_MODES],
+      default: "--all",
+      exclusive: true
+    },
+    filter: {
+      values: ["--only-errors", "--only-warns"],
+      exclusive: true
+    }
+  });
+  const exportArgSet = new Set(exportArgs);
+  const filteredUnknownArgs = unknownArgs.filter((arg) => !exportArgSet.has(arg));
+  if (filteredUnknownArgs.length > 0) {
+    logWarning(`Unknown arguments ignored: ${filteredUnknownArgs.join(", ")}`);
+  }
+  const mode = parsed.mode ?? "--all";
+  const filter = parsed.filter === "--only-errors" ? "errors" : parsed.filter === "--only-warns" ? "warns" : null;
+  const showUI = shouldShowUI(exportFormat, noBanner);
+  if (showUI) {
+    displayBanner({
+      text: "CONSOLE",
+      subtitle: "WARNINGS",
+      info: {
+        Mode: mode,
+        Filter: filter ?? "none"
+      },
+      colors: ["yellow", "red"]
+    });
+  }
+  const modeKey = mode.replace("--", "");
+  let jestArgs = [];
+  try {
+    jestArgs = await buildJestArgsForMode(modeKey);
+  } catch (error) {
+    exitWithError(error.message);
+  }
+  const spinner = showUI ? createSpinner("Capturing console warnings...", "yellow") : null;
+  spinner?.start();
+  const result = await runJest(jestArgs, {
+    disableVerbose: true,
+    ignoreErrors: true
+  });
+  let warnings = parseConsoleWarnings(result.output);
+  warnings = filterWarningsByType(warnings, filter);
+  if (spinner) {
+    if (warnings.length > 0) {
+      spinner.warn(`Found ${warnings.length} warning(s)`);
+    } else {
+      spinner.succeed("No console warnings found");
+    }
+  }
+  const grouped = groupByTestFile(warnings);
+  const stats = calculateStatistics(warnings);
+  const timestamp = getDisplayTimestamp();
+  const formatted = formatWarningsOutput(grouped, timestamp, stats);
+  handleExportOrDisplay(formatted, {
+    exportFormat,
+    prefix: "export-console-context",
+    title: "Console Warnings Context"
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONSOLE_LOG_TYPES,
+  JEST_PATTERNS,
+  VALID_EXPORT_FORMATS,
+  VALID_MODES,
+  VALID_TEST_EXTENSIONS,
+  buildJestArgsForMode,
+  buildTimestampedPath,
+  createProgressBar,
+  createSpinner,
+  detectPackageManager,
+  displayBanner,
+  displayHelp,
+  execCommand,
+  exitWithError,
+  exportToFile,
+  extractConsoleType,
+  extractFailures,
+  filterTestFiles,
+  formatAsMarkdown,
+  getDisplayTimestamp,
+  getFilenameTimestamp,
+  getJestCommand,
+  getPlatform,
+  getStagedFiles,
+  handleExportOrDisplay,
+  hasGit,
+  isCodeSnippetLine,
+  isConsoleTypeLine,
+  isLinux,
+  isMac,
+  isStackTraceLine,
+  isWindows,
+  logInfo,
+  logSuccess,
+  logWarning,
+  parseExportCliArgs,
+  resolveCommand,
+  runConsoleContext,
+  runCoverageContext,
+  runJest,
+  runTestContext,
+  shouldShowUI,
+  stripAnsi,
+  validateCliArgs
+});
+//# sourceMappingURL=index.cjs.map