@andy2639/jest-context 1.0.0

package/dist/bin/console-context.cjs

@@ -0,0 +1,685 @@
+#!/usr/bin/env node
+"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 __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
+));
+
+// src/commands/console-context.ts
+var import_node_path2 = __toESM(require("path"));
+
+// 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 isWindows() {
+  return process.platform === "win32";
+}
+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}`);
+}
+
+// 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" });
+}
+
+// src/commands/console-context.ts
+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_path2.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"
+  });
+}
+
+// src/bin/console-context.ts
+runConsoleContext().catch((error) => {
+  console.error(`\u274C ${error.message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=console-context.cjs.map