afterbefore 0.1.19 → 0.2.1

package/dist/cli.js

@@ -1,1233 +0,0 @@
-#!/usr/bin/env node
-
-// src/cli.ts
-import { Command } from "commander";
-import chalk3 from "chalk";
-
-// src/logger.ts
-import { writeFileSync } from "fs";
-import chalk from "chalk";
-import ora from "ora";
-var BAR_WIDTH = 20;
-var BAR_SPINNER = { interval: 80, frames: [" "] };
-var Logger = class {
-  spinner = null;
-  pipelineTotal = 0;
-  lastStep = 0;
-  lastLabel = "";
-  pipelineActive = false;
-  logBuffer = [];
-  isTTY = !!process.stderr.isTTY;
-  log(level, message) {
-    const ts = (/* @__PURE__ */ new Date()).toISOString();
-    this.logBuffer.push(`${ts} [${level}] ${message}`);
-  }
-  info(message) {
-    this.log("info", message);
-    if (this.pipelineActive) return;
-    if (this.spinner) {
-      this.spinner.clear();
-      console.log(chalk.blue("\u2139"), message);
-      this.spinner.render();
-    } else {
-      console.log(chalk.blue("\u2139"), message);
-    }
-  }
-  success(message) {
-    this.log("ok", message);
-    if (this.pipelineActive) return;
-    if (this.spinner) {
-      this.spinner.clear();
-      console.log(chalk.green("\u2714"), message);
-      this.spinner.render();
-    } else {
-      console.log(chalk.green("\u2714"), message);
-    }
-  }
-  warn(message) {
-    this.log("warn", message);
-    if (this.spinner) {
-      this.spinner.clear();
-      console.log(chalk.yellow("\u26A0"), message);
-      this.spinner.render();
-    } else {
-      console.log(chalk.yellow("\u26A0"), message);
-    }
-  }
-  error(message) {
-    this.log("error", message);
-    if (this.spinner) {
-      this.spinner.clear();
-      console.error(chalk.red("\u2716"), message);
-      this.spinner.render();
-    } else {
-      console.error(chalk.red("\u2716"), message);
-    }
-  }
-  dim(message) {
-    this.log("debug", message);
-    if (this.pipelineActive) return;
-    if (this.spinner) {
-      this.spinner.clear();
-      console.log(chalk.dim(message));
-      this.spinner.render();
-    } else {
-      console.log(chalk.dim(message));
-    }
-  }
-  spin(message) {
-    this.log("info", message);
-    this.clearSpinner();
-    this.spinner = ora(message).start();
-    return this.spinner;
-  }
-  stopSpinner() {
-    this.clearSpinner();
-  }
-  startPipeline(total) {
-    this.pipelineTotal = total;
-    this.lastStep = 0;
-    this.lastLabel = "";
-    this.pipelineActive = true;
-    this.clearSpinner();
-    this.log("info", `Pipeline started (${total} steps)`);
-    const text = this.renderPipeline(0, "Starting...");
-    if (this.isTTY) {
-      this.spinner = ora({
-        text: chalk.dim(text),
-        spinner: BAR_SPINNER
-      }).start();
-    } else {
-      console.error(chalk.dim(text));
-    }
-  }
-  pipeline(step, label) {
-    if (step === this.lastStep && label === this.lastLabel) return;
-    this.lastStep = step;
-    this.lastLabel = label;
-    this.log("step", `${step}/${this.pipelineTotal} ${label}`);
-    const text = chalk.dim(this.renderPipeline(step, label));
-    if (!this.isTTY) {
-      return;
-    }
-    if (!this.spinner) {
-      this.spinner = ora({
-        text,
-        spinner: BAR_SPINNER
-      }).start();
-      return;
-    }
-    this.spinner.text = text;
-    this.spinner.render();
-  }
-  stageComplete(name, detail, durationMs) {
-    const duration = durationMs < 1e3 ? `${Math.round(durationMs)}ms` : `${(durationMs / 1e3).toFixed(1)}s`;
-    const line = `  ${chalk.green("\u2713")} ${name.padEnd(12)} ${chalk.dim(detail.padEnd(50))} ${chalk.dim(duration)}`;
-    this.log("stage", `${name}: ${detail} (${duration})`);
-    if (this.isTTY && this.spinner) {
-      this.spinner.clear();
-      console.log(line);
-      this.spinner.render();
-    } else {
-      console.log(line);
-    }
-  }
-  completePipeline(finished = false) {
-    this.pipelineActive = false;
-    this.log("info", `Pipeline ${finished ? "completed" : "stopped"}`);
-    if (this.spinner) {
-      if (finished) {
-        const bar = "\u2588".repeat(BAR_WIDTH);
-        this.spinner.succeed(` ${bar}`);
-      } else {
-        this.spinner.stop();
-      }
-      this.spinner = null;
-    } else if (finished) {
-      const bar = "\u2588".repeat(BAR_WIDTH);
-      console.error(`${chalk.green("\u2714")} ${bar}`);
-    }
-    this.pipelineTotal = 0;
-    this.lastStep = 0;
-    this.lastLabel = "";
-  }
-  writeLogFile(filePath) {
-    if (this.logBuffer.length === 0) return;
-    writeFileSync(filePath, this.logBuffer.join("\n") + "\n", "utf-8");
-  }
-  renderPipeline(step, label) {
-    const total = this.pipelineTotal || 1;
-    const clampedStep = Math.max(0, Math.min(step, total));
-    const filled = Math.round(clampedStep / total * BAR_WIDTH);
-    const bar = "\u2588".repeat(filled) + "\u2591".repeat(BAR_WIDTH - filled);
-    return `  ${bar} ${clampedStep}/${total} ${label}`;
-  }
-  clearSpinner() {
-    if (this.spinner) {
-      this.spinner.stop();
-      this.spinner = null;
-    }
-  }
-};
-var logger = new Logger();
-
-// src/errors.ts
-var AfterbeforeError = class extends Error {
-  constructor(message, suggestion) {
-    super(message);
-    this.suggestion = suggestion;
-    this.name = "AfterbeforeError";
-  }
-};
-
-// src/cleanup.ts
-var CleanupRegistry = class {
-  cleanups = [];
-  registered = false;
-  register(fn) {
-    this.cleanups.push(fn);
-    this.ensureSignalHandlers();
-  }
-  async runAll() {
-    const fns = [...this.cleanups].reverse();
-    this.cleanups = [];
-    for (const fn of fns) {
-      try {
-        await fn();
-      } catch (err) {
-        logger.warn(
-          `Cleanup failed: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-  }
-  ensureSignalHandlers() {
-    if (this.registered) return;
-    this.registered = true;
-    const handler = async (signal) => {
-      logger.dim(`
-Received ${signal}, cleaning up...`);
-      await this.runAll();
-      process.exit(signal === "SIGINT" ? 130 : 143);
-    };
-    process.on("SIGINT", () => handler("SIGINT"));
-    process.on("SIGTERM", () => handler("SIGTERM"));
-    process.on("exit", () => {
-      if (this.cleanups.length > 0) {
-        for (const fn of [...this.cleanups].reverse()) {
-          try {
-            fn();
-          } catch {
-          }
-        }
-        this.cleanups = [];
-      }
-    });
-  }
-};
-var cleanupRegistry = new CleanupRegistry();
-
-// src/utils/git.ts
-import { execSync } from "child_process";
-function git(args, cwd) {
-  try {
-    return execSync(`git ${args}`, {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    }).trim();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("ENOENT") || message.includes("not found")) {
-      throw new AfterbeforeError(
-        "Git is not installed or not in PATH.",
-        "Install git: https://git-scm.com/downloads"
-      );
-    }
-    throw err;
-  }
-}
-function isGitRepo(cwd) {
-  try {
-    git("rev-parse --is-inside-work-tree", cwd);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function getMergeBase(base, cwd) {
-  try {
-    return git(`merge-base ${base} HEAD`, cwd);
-  } catch {
-    throw new AfterbeforeError(
-      `Could not find merge base for "${base}". The branch or ref may not exist.`,
-      `Run "git branch -a" to see available branches. Did you mean "master" instead of "main"?`
-    );
-  }
-}
-function getDiffNameStatus(base, cwd) {
-  const mergeBase = getMergeBase(base, cwd);
-  return git(`diff --name-status ${mergeBase}`, cwd);
-}
-function getCurrentBranch(cwd) {
-  return git("rev-parse --abbrev-ref HEAD", cwd);
-}
-
-// src/pipeline.ts
-import { resolve as resolve3, basename } from "path";
-import chalk2 from "chalk";
-
-// src/config.ts
-import { resolve } from "path";
-import { existsSync, readFileSync } from "fs";
-import { pathToFileURL } from "url";
-var CONFIG_FILES = [
-  "afterbefore.config.json",
-  "afterbefore.config.js",
-  "afterbefore.config.mjs"
-];
-async function loadConfig(cwd) {
-  for (const name of CONFIG_FILES) {
-    const filePath = resolve(cwd, name);
-    if (!existsSync(filePath)) continue;
-    logger.dim(`  Config: ${name}`);
-    if (name.endsWith(".json")) {
-      const raw = readFileSync(filePath, "utf-8");
-      return JSON.parse(raw);
-    }
-    const mod = await import(pathToFileURL(filePath).href);
-    return mod.default ?? mod;
-  }
-  return null;
-}
-
-// src/utils/fs.ts
-import { mkdir } from "fs/promises";
-async function ensureDir(dir) {
-  await mkdir(dir, { recursive: true });
-}
-
-// src/utils/port.ts
-import { createServer } from "net";
-function findPort() {
-  return new Promise((resolve4, reject) => {
-    const server = createServer();
-    server.listen(0, () => {
-      const addr = server.address();
-      if (!addr || typeof addr === "string") {
-        server.close();
-        reject(new Error("Failed to get port"));
-        return;
-      }
-      const port = addr.port;
-      server.close(() => resolve4(port));
-    });
-    server.on("error", reject);
-  });
-}
-async function findAvailablePort(exclude) {
-  for (let i = 0; i < 5; i++) {
-    const port = await findPort();
-    if (!exclude || !exclude.has(port)) return port;
-  }
-  throw new Error("Failed to find available port after 5 attempts");
-}
-
-// src/stages/diff.ts
-var VALID_STATUSES = /* @__PURE__ */ new Set(["A", "M", "D", "R", "C"]);
-function parseDiffOutput(raw) {
-  if (!raw.trim()) return [];
-  const results = [];
-  for (const line of raw.trim().split("\n")) {
-    const parts = line.split("	");
-    const statusRaw = parts[0].charAt(0);
-    if (!VALID_STATUSES.has(statusRaw)) continue;
-    const status = statusRaw;
-    if (status === "R" || status === "C") {
-      results.push({ status, oldPath: parts[1], path: parts[2] });
-    } else {
-      results.push({ status, path: parts[1] });
-    }
-  }
-  return results;
-}
-function getChangedFiles(base, cwd) {
-  const raw = getDiffNameStatus(base, cwd);
-  return parseDiffOutput(raw);
-}
-
-// src/stages/classify.ts
-var GLOBAL_FILES = /* @__PURE__ */ new Set([
-  "tailwind.config.ts",
-  "tailwind.config.js",
-  "postcss.config.js",
-  "postcss.config.mjs",
-  "postcss.config.cjs"
-]);
-function isGlobalVisualFile(filePath) {
-  const p = filePath.replace(/^src\//, "");
-  return GLOBAL_FILES.has(p) || /globals?\.(css|scss)$/.test(p);
-}
-function classifyFile(filePath) {
-  const p = filePath.replace(/^src\//, "");
-  if (/\.(test|spec)\.[tj]sx?$/.test(p) || /^tests?\//.test(p) || /\/__tests__\//.test(p) || p.includes(".test.") || p.includes(".spec.")) {
-    return "test";
-  }
-  if (/^(tsconfig|next\.config|tailwind\.config|postcss\.config|\.eslint|\.prettier|vitest\.config|jest\.config)/.test(
-    p
-  ) || p === "package.json" || p === "package-lock.json" || p.endsWith(".config.ts") || p.endsWith(".config.js") || p.endsWith(".config.mjs")) {
-    return "config";
-  }
-  if (/\.(css|scss|sass|less)$/.test(p) || p === "tailwind.config.ts") {
-    return "style";
-  }
-  if (/\/layout\.[tj]sx?$/.test(p) || /^app\/layout\.[tj]sx?$/.test(p)) {
-    return "layout";
-  }
-  if (/\/page\.[tj]sx?$/.test(p) || /^app\/page\.[tj]sx?$/.test(p)) {
-    return "page";
-  }
-  if (/^(components|app)\//.test(p) && /\.[tj]sx?$/.test(p)) {
-    return "component";
-  }
-  if (/^(lib|utils|hooks|helpers|services|api)\//.test(p) && /\.[tj]sx?$/.test(p)) {
-    return "utility";
-  }
-  if (/\.[tj]sx?$/.test(p)) {
-    return "component";
-  }
-  return "other";
-}
-function classifyFiles(files) {
-  return files.map((f) => ({
-    ...f,
-    category: classifyFile(f.path)
-  }));
-}
-
-// src/stages/graph.ts
-import { readdirSync, readFileSync as readFileSync3 } from "fs";
-import { join as join2, relative } from "path";
-import { init, parse } from "es-module-lexer";
-
-// src/stages/resolve.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
-import { resolve as resolve2, dirname, join } from "path";
-var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
-function createResolver(projectRoot) {
-  const mappings = loadPathMappings(projectRoot);
-  const existsCache = /* @__PURE__ */ new Map();
-  function cachedExists(p) {
-    const cached = existsCache.get(p);
-    if (cached !== void 0) return cached;
-    const result = existsSync2(p);
-    existsCache.set(p, result);
-    return result;
-  }
-  function tryResolve(candidate) {
-    if (cachedExists(candidate) && !isDirectory(candidate)) return candidate;
-    for (const ext of EXTENSIONS) {
-      const withExt = candidate + ext;
-      if (cachedExists(withExt)) return withExt;
-    }
-    for (const ext of EXTENSIONS) {
-      const indexFile = join(candidate, `index${ext}`);
-      if (cachedExists(indexFile)) return indexFile;
-    }
-    return null;
-  }
-  function isDirectory(p) {
-    try {
-      return statSync(p).isDirectory();
-    } catch {
-      return false;
-    }
-  }
-  return (specifier, fromFile) => {
-    if (specifier.startsWith(".")) {
-      const dir = dirname(fromFile);
-      const candidate = resolve2(dir, specifier);
-      return tryResolve(candidate);
-    }
-    for (const mapping of mappings) {
-      if (!specifier.startsWith(mapping.prefix)) continue;
-      const rest = specifier.slice(mapping.prefix.length);
-      for (const target of mapping.targets) {
-        const candidate = resolve2(projectRoot, target + rest);
-        const result = tryResolve(candidate);
-        if (result) return result;
-      }
-    }
-    return null;
-  };
-}
-function loadPathMappings(projectRoot) {
-  const tsconfigPath = join(projectRoot, "tsconfig.json");
-  if (!existsSync2(tsconfigPath)) {
-    logger.dim("No tsconfig.json found, skipping path alias resolution");
-    return [];
-  }
-  try {
-    const raw = readFileSync2(tsconfigPath, "utf-8");
-    const cleaned = stripJsonComments(raw);
-    const config = JSON.parse(cleaned);
-    const paths = config?.compilerOptions?.paths;
-    if (!paths) return [];
-    const baseUrl = config?.compilerOptions?.baseUrl || ".";
-    const mappings = [];
-    for (const [pattern, targets] of Object.entries(paths)) {
-      const prefix = pattern.replace(/\*$/, "");
-      const resolvedTargets = targets.map(
-        (t) => t.replace(/\*$/, "")
-      );
-      const absoluteTargets = resolvedTargets.map(
-        (t) => join(baseUrl, t)
-      );
-      mappings.push({ prefix, targets: absoluteTargets });
-    }
-    return mappings;
-  } catch (e) {
-    logger.warn(`Failed to parse tsconfig.json: ${e}`);
-    return [];
-  }
-}
-function stripJsonComments(input) {
-  let result = "";
-  let i = 0;
-  const len = input.length;
-  while (i < len) {
-    const ch = input[i];
-    if (ch === '"') {
-      let j = i + 1;
-      while (j < len) {
-        if (input[j] === "\\") {
-          j += 2;
-        } else if (input[j] === '"') {
-          j++;
-          break;
-        } else {
-          j++;
-        }
-      }
-      result += input.slice(i, j);
-      i = j;
-      continue;
-    }
-    if (ch === "/" && input[i + 1] === "/") {
-      i += 2;
-      while (i < len && input[i] !== "\n") i++;
-      continue;
-    }
-    if (ch === "/" && input[i + 1] === "*") {
-      i += 2;
-      while (i < len && !(input[i] === "*" && input[i + 1] === "/")) i++;
-      i += 2;
-      continue;
-    }
-    if (ch === ",") {
-      let j = i + 1;
-      while (j < len && /\s/.test(input[j])) j++;
-      if (input[j] === "}" || input[j] === "]") {
-        i = j;
-        continue;
-      }
-    }
-    result += ch;
-    i++;
-  }
-  return result;
-}
-
-// src/stages/graph.ts
-var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-var SOURCE_DIRS = ["app", "src", "components", "lib"];
-function collectFiles(dir) {
-  const results = [];
-  let entries;
-  try {
-    entries = readdirSync(dir, { withFileTypes: true });
-  } catch {
-    return results;
-  }
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") {
-        continue;
-      }
-      results.push(...collectFiles(fullPath));
-    } else if (entry.isFile()) {
-      const ext = entry.name.slice(entry.name.lastIndexOf("."));
-      if (SOURCE_EXTENSIONS.has(ext)) {
-        results.push(fullPath);
-      }
-    }
-  }
-  return results;
-}
-function parseImports(filePath) {
-  let source;
-  try {
-    source = readFileSync3(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-  try {
-    const cleaned = source.replace(/import\s+type\s+/g, "import ").replace(/export\s+type\s+/g, "export ");
-    const [imports] = parse(cleaned);
-    return imports.map((imp) => imp.n).filter((n) => n !== void 0 && n !== "");
-  } catch {
-    const specifiers = [];
-    const importRegex = /(?:import|from)\s+["']([^"']+)["']/g;
-    let match;
-    while ((match = importRegex.exec(source)) !== null) {
-      specifiers.push(match[1]);
-    }
-    return specifiers;
-  }
-}
-async function buildImportGraph(projectRoot) {
-  await init;
-  const resolve4 = createResolver(projectRoot);
-  const allFiles = [];
-  for (const dir of SOURCE_DIRS) {
-    const fullDir = join2(projectRoot, dir);
-    allFiles.push(...collectFiles(fullDir));
-  }
-  const fileSet = new Set(allFiles);
-  const forward = /* @__PURE__ */ new Map();
-  const reverse = /* @__PURE__ */ new Map();
-  for (const filePath of fileSet) {
-    const relPath = relative(projectRoot, filePath);
-    const specifiers = parseImports(filePath);
-    const deps = /* @__PURE__ */ new Set();
-    for (const spec of specifiers) {
-      const resolved = resolve4(spec, filePath);
-      if (!resolved) continue;
-      const relResolved = relative(projectRoot, resolved);
-      deps.add(relResolved);
-      if (!reverse.has(relResolved)) {
-        reverse.set(relResolved, /* @__PURE__ */ new Set());
-      }
-      reverse.get(relResolved).add(relPath);
-    }
-    forward.set(relPath, deps);
-  }
-  logger.dim(`Import graph: ${fileSet.size} files, ${countEdges(forward)} edges`);
-  return { forward, reverse };
-}
-function countEdges(forward) {
-  let count = 0;
-  for (const deps of forward.values()) {
-    count += deps.size;
-  }
-  return count;
-}
-
-// src/utils/nextjs.ts
-function pagePathToRoute(pagePath) {
-  let p = pagePath.replace(/^src\//, "");
-  const match = p.match(/^app\/(.*)\/page\.[tj]sx?$/);
-  if (!match) {
-    if (/^app\/page\.[tj]sx?$/.test(p)) return "/";
-    return null;
-  }
-  let route = match[1];
-  if (/\[.*\]/.test(route)) {
-    logger.warn(`Skipping dynamic route: /${route} (dynamic segments not supported)`);
-    return null;
-  }
-  route = route.split("/").filter((seg) => !seg.startsWith("(")).join("/");
-  return `/${route}` || "/";
-}
-function isPageFile(filePath) {
-  const p = filePath.replace(/^src\//, "");
-  return /^app\/(.+\/)?page\.[tj]sx?$/.test(p);
-}
-function isLayoutFile(filePath) {
-  const p = filePath.replace(/^src\//, "");
-  return /^app\/(.+\/)?layout\.[tj]sx?$/.test(p);
-}
-function getLayoutDir(filePath) {
-  const p = filePath.replace(/^src\//, "");
-  const match = p.match(/^(app\/.*\/)layout\.[tj]sx?$/);
-  if (!match) return "app/";
-  return match[1];
-}
-
-// src/stages/impact.ts
-var DEFAULT_MAX_DEPTH = 10;
-function findAffectedRoutes(changedFiles, graph, projectRoot, maxRoutes = 0, maxDepth = DEFAULT_MAX_DEPTH) {
-  const routeMap = /* @__PURE__ */ new Map();
-  for (const file of changedFiles) {
-    const visited = /* @__PURE__ */ new Set();
-    const queue = [
-      { path: file, depth: 0, chain: [file] }
-    ];
-    visited.add(file);
-    while (queue.length > 0) {
-      const { path, depth, chain } = queue.shift();
-      if (isPageFile(path)) {
-        const route = pagePathToRoute(path);
-        if (route !== null && !routeMap.has(route)) {
-          routeMap.set(route, {
-            pagePath: path,
-            route,
-            reason: depth === 0 ? "direct" : "transitive",
-            depth,
-            triggerChain: chain
-          });
-        }
-      }
-      if (depth >= maxDepth) continue;
-      const importers = graph.reverse.get(path);
-      if (!importers) continue;
-      for (const importer of importers) {
-        if (visited.has(importer)) continue;
-        visited.add(importer);
-        queue.push({ path: importer, depth: depth + 1, chain: [...chain, importer] });
-      }
-    }
-  }
-  for (const file of changedFiles) {
-    if (!isLayoutFile(file)) continue;
-    const layoutDir = getLayoutDir(file);
-    for (const knownFile of graph.forward.keys()) {
-      if (knownFile.startsWith(layoutDir) && isPageFile(knownFile)) {
-        const route = pagePathToRoute(knownFile);
-        if (route !== null && !routeMap.has(route)) {
-          routeMap.set(route, {
-            pagePath: knownFile,
-            route,
-            reason: "transitive",
-            depth: 1,
-            triggerChain: [file, knownFile]
-          });
-        }
-      }
-    }
-  }
-  const routes = Array.from(routeMap.values()).sort(
-    (a, b) => a.depth - b.depth
-  );
-  if (maxRoutes > 0 && routes.length > maxRoutes) {
-    const skipped = routes.length - maxRoutes;
-    logger.warn(
-      `Limiting to ${maxRoutes} route(s), skipping ${skipped} deeper route(s). Use --max-routes 0 for unlimited.`
-    );
-    const limited = routes.slice(0, maxRoutes);
-    logger.dim(`Found ${limited.length} affected route(s) (of ${routes.length} total)`);
-    return limited;
-  }
-  logger.dim(`Found ${routes.length} affected route(s)`);
-  return routes;
-}
-
-// src/stages/worktree.ts
-import { exec as execCb, execSync as execSync2 } from "child_process";
-import { promisify } from "util";
-import { rm, mkdtemp } from "fs/promises";
-import { join as join4 } from "path";
-import { tmpdir } from "os";
-
-// src/utils/pm.ts
-import { existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-function detectPackageManager(dir) {
-  if (existsSync3(join3(dir, "bun.lockb")) || existsSync3(join3(dir, "bun.lock")))
-    return "bun";
-  if (existsSync3(join3(dir, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync3(join3(dir, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-function pmExec(pm) {
-  switch (pm) {
-    case "bun":
-      return "bunx";
-    case "pnpm":
-      return "pnpm exec";
-    case "yarn":
-      return "yarn";
-    default:
-      return "npx";
-  }
-}
-
-// src/stages/worktree.ts
-var exec = promisify(execCb);
-async function createWorktree(base, cwd) {
-  const worktreeDir = await mkdtemp(join4(tmpdir(), "afterbefore-wt-"));
-  logger.dim(`Creating worktree for ${base} at ${worktreeDir}`);
-  try {
-    await exec(`git worktree add "${worktreeDir}" "${base}"`, { cwd });
-  } catch (err) {
-    throw new AfterbeforeError(
-      `Failed to create worktree for ref "${base}".`,
-      `Make sure the branch/ref "${base}" exists. Run "git branch -a" to see available refs.`
-    );
-  }
-  const pm = detectPackageManager(cwd);
-  logger.dim(`Installing dependencies with ${pm}`);
-  await exec(`${pm} install`, { cwd: worktreeDir });
-  const cleanup = async () => {
-    logger.dim(`Cleaning up worktree at ${worktreeDir}`);
-    try {
-      execSync2(`git worktree remove --force "${worktreeDir}"`, {
-        cwd,
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-    } catch {
-      try {
-        await rm(worktreeDir, { recursive: true, force: true });
-        execSync2("git worktree prune", {
-          cwd,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      } catch {
-        logger.warn(`Failed to clean up worktree at ${worktreeDir}`);
-      }
-    }
-  };
-  cleanupRegistry.register(cleanup);
-  return { path: worktreeDir, ref: base, cleanup };
-}
-
-// src/stages/server.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync4 } from "fs";
-import { join as join5 } from "path";
-function waitForServer(url, timeoutMs) {
-  const start = Date.now();
-  return new Promise((resolve4, reject) => {
-    const poll = async () => {
-      if (Date.now() - start > timeoutMs) {
-        reject(
-          new AfterbeforeError(
-            `Server at ${url} did not respond within ${timeoutMs / 1e3}s.`,
-            `Try running "next dev" manually to check for errors. Also check if port ${url.split(":").pop()} is already in use.`
-          )
-        );
-        return;
-      }
-      try {
-        await fetch(url);
-        resolve4();
-      } catch {
-        setTimeout(poll, 150);
-      }
-    };
-    poll();
-  });
-}
-async function startServer(projectDir, port) {
-  const url = `http://localhost:${port}`;
-  const pm = detectPackageManager(projectDir);
-  const exec2 = pmExec(pm);
-  const [cmd, ...baseArgs] = exec2.split(" ");
-  const lockFile = join5(projectDir, ".next", "dev", "lock");
-  if (existsSync4(lockFile)) {
-    throw new AfterbeforeError(
-      `Another Next.js dev server is running in ${projectDir} (.next/dev/lock exists).`,
-      `Stop the other dev server first, or delete .next/dev/lock if it's stale.`
-    );
-  }
-  logger.info(`Starting Next.js dev server on ${url} (using ${pm})`);
-  const child = spawn(cmd, [...baseArgs, "next", "dev", "-p", String(port)], {
-    cwd: projectDir,
-    stdio: ["pipe", "pipe", "pipe"],
-    detached: true
-  });
-  child.stderr?.on("data", (data) => {
-    const msg = data.toString().trim();
-    if (msg) logger.dim(`[next:${port}] ${msg}`);
-  });
-  await waitForServer(url, 6e4);
-  logger.success(`Server ready at ${url}`);
-  return { port, process: child, url };
-}
-async function stopServer(server) {
-  logger.dim(`Stopping server on port ${server.port}`);
-  const pid = server.process.pid;
-  try {
-    process.kill(-pid, "SIGTERM");
-  } catch {
-  }
-  await new Promise((resolve4) => {
-    const timeout = setTimeout(() => {
-      try {
-        process.kill(-pid, "SIGKILL");
-      } catch {
-      }
-      resolve4();
-    }, 5e3);
-    server.process.on("exit", () => {
-      clearTimeout(timeout);
-      resolve4();
-    });
-  });
-}
-
-// src/stages/capture.ts
-import { join as join6 } from "path";
-import { execSync as execSync3 } from "child_process";
-import { chromium } from "playwright";
-async function launchBrowser() {
-  try {
-    return await chromium.launch();
-  } catch {
-    logger.dim("Chromium not found, installing...");
-    try {
-      execSync3("npx playwright install chromium", {
-        stdio: ["pipe", "pipe", "pipe"]
-      });
-      return await chromium.launch();
-    } catch {
-      throw new AfterbeforeError(
-        "Could not install or launch Playwright Chromium.",
-        'Run "npx playwright install chromium" manually, then try again.'
-      );
-    }
-  }
-}
-async function captureOneRoute(task, beforeCtx, afterCtx, beforeUrl, afterUrl, outputDir, options) {
-  const results = [];
-  const [beforePage, afterPage] = await Promise.all([
-    beforeCtx.newPage(),
-    afterCtx.newPage()
-  ]);
-  try {
-    const beforePath = join6(outputDir, `${task.prefix}-before.png`);
-    const afterPath = join6(outputDir, `${task.prefix}-after.png`);
-    const settle = async (page) => {
-      await page.evaluate("document.fonts.ready");
-      if (options.delay > 0) {
-        await page.waitForTimeout(options.delay);
-      }
-    };
-    const performActions = async (page, actions) => {
-      for (const action of actions) {
-        if (action.click) {
-          await page.locator(action.click).first().click();
-        }
-        if (action.scroll) {
-          await page.locator(action.scroll).first().scrollIntoViewIfNeeded();
-        }
-        if (action.wait && action.wait > 0) {
-          await page.waitForTimeout(action.wait);
-        }
-        await settle(page);
-      }
-    };
-    const screenshot = async (page, path) => {
-      await page.screenshot({ path, fullPage: true });
-    };
-    await Promise.all([
-      beforePage.goto(`${beforeUrl}${task.route}`, { waitUntil: "networkidle" }).then(() => settle(beforePage)).then(() => task.actions ? performActions(beforePage, task.actions) : void 0).then(() => screenshot(beforePage, beforePath)),
-      afterPage.goto(`${afterUrl}${task.route}`, { waitUntil: "networkidle" }).then(() => settle(afterPage)).then(() => task.actions ? performActions(afterPage, task.actions) : void 0).then(() => screenshot(afterPage, afterPath))
-    ]);
-    results.push({ route: task.label, prefix: task.prefix, beforePath, afterPath });
-  } finally {
-    await Promise.all([beforePage.close(), afterPage.close()]);
-  }
-  return results;
-}
-var BATCH_SIZE = 3;
-async function captureRoutes(tasks, beforeUrl, afterUrl, outputDir, options) {
-  const browser = options.browser ?? await launchBrowser();
-  const ownsBrowser = !options.browser;
-  const results = [];
-  try {
-    const contextOpts = {
-      viewport: { width: options.width, height: options.height },
-      deviceScaleFactor: 2
-    };
-    const [beforeCtx, afterCtx] = await Promise.all([
-      browser.newContext(contextOpts),
-      browser.newContext(contextOpts)
-    ]);
-    for (let batchStart = 0; batchStart < tasks.length; batchStart += BATCH_SIZE) {
-      const batch = tasks.slice(batchStart, batchStart + BATCH_SIZE);
-      const batchResults = await Promise.allSettled(
-        batch.map((task, idx) => {
-          options.onProgress?.(batchStart + idx + 1, task.label);
-          return captureOneRoute(task, beforeCtx, afterCtx, beforeUrl, afterUrl, outputDir, options);
-        })
-      );
-      for (const result of batchResults) {
-        if (result.status === "fulfilled") {
-          results.push(...result.value);
-        } else {
-          logger.dim(`Capture failed: ${result.reason}`);
-        }
-      }
-    }
-    await Promise.all([beforeCtx.close(), afterCtx.close()]);
-  } finally {
-    if (ownsBrowser) {
-      await browser.close();
-    }
-  }
-  return results;
-}
-
-// src/pipeline.ts
-function generateSessionName(cwd) {
-  const branch = getCurrentBranch(cwd);
-  const name = branch.replace(/^(feat|fix|perf|chore|refactor|docs|style|test|ci|build)\//, "");
-  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  return `${name}_${date}`;
-}
-function routeToPrefix(route) {
-  if (route === "/") return "_root";
-  return route.replace(/^\//, "").replace(/\//g, "-");
-}
-function expandRoutes(routes, config) {
-  const tasks = [];
-  for (const r of routes) {
-    const scenarios = config?.scenarios?.[r.route] ?? [];
-    tasks.push({
-      route: r.route,
-      label: r.route,
-      prefix: routeToPrefix(r.route)
-    });
-    for (const s of scenarios) {
-      tasks.push({
-        route: r.route,
-        label: `${r.route} [${s.name}]`,
-        prefix: `${routeToPrefix(r.route)}~${s.name}`,
-        actions: s.actions
-      });
-    }
-  }
-  return tasks;
-}
-function applyConfigDefaults(options, config) {
-  if (!config?.defaults) return;
-  const defaults = config.defaults;
-  const cliDefaults = {
-    base: "main",
-    output: ".afterbefore",
-    maxRoutes: 6,
-    width: 1280,
-    height: 720,
-    delay: 0,
-    maxDepth: 10,
-    dryRun: false,
-    verbose: false
-  };
-  const opts = options;
-  for (const [key, value] of Object.entries(defaults)) {
-    if (key === "cwd" || value === void 0) continue;
-    if (key in cliDefaults && opts[key] === cliDefaults[key]) {
-      opts[key] = value;
-    }
-  }
-}
-async function runPipeline(options) {
-  const { base, output, cwd } = options;
-  const sessionName = generateSessionName(cwd);
-  const outputDir = resolve3(cwd, output, sessionName);
-  const startTime = Date.now();
-  try {
-    const version = true ? "0.1.19" : "dev";
-    const mode = options.dryRun ? "Dry run" : "Capturing";
-    console.log(`
-afterbefore v${version} \xB7 ${mode} against ${base}
-`);
-    const config = await loadConfig(cwd);
-    applyConfigDefaults(options, config);
-    logger.startPipeline(options.dryRun ? 3 : 6);
-    const t1 = Date.now();
-    logger.pipeline(1, "Analyzing diff...");
-    const diffFiles = getChangedFiles(base, cwd);
-    logger.stageComplete("Diff", `${diffFiles.length} files changed`, Date.now() - t1);
-    if (diffFiles.length === 0) {
-      logger.completePipeline();
-      logger.success("No changed files detected. Nothing to do.");
-      return;
-    }
-    const t2 = Date.now();
-    const classified = classifyFiles(diffFiles);
-    const impactfulFiles = classified.filter(
-      (f) => f.category !== "test" && f.category !== "other"
-    );
-    if (impactfulFiles.length === 0) {
-      logger.completePipeline();
-      logger.success(
-        "No visually relevant changes detected (only test/other files changed)."
-      );
-      return;
-    }
-    logger.pipeline(2, "Building import graph...");
-    const worktreePromise = options.dryRun ? null : createWorktree(base, cwd);
-    const graph = await buildImportGraph(cwd);
-    const graphEdges = Array.from(graph.forward.values()).reduce((sum, deps) => sum + deps.size, 0);
-    logger.stageComplete("Graph", `${graph.forward.size} modules, ${graphEdges} edges`, Date.now() - t2);
-    const t3 = Date.now();
-    logger.pipeline(3, "Finding affected routes...");
-    const changedPaths = impactfulFiles.map((f) => f.path);
-    let affectedRoutes = findAffectedRoutes(changedPaths, graph, cwd, options.maxRoutes, options.maxDepth);
-    if (affectedRoutes.length === 0) {
-      const hasGlobalChanges = impactfulFiles.some((f) => isGlobalVisualFile(f.path));
-      if (hasGlobalChanges) {
-        const allRoutes = [];
-        for (const file of graph.forward.keys()) {
-          if (!isPageFile(file)) continue;
-          const route = pagePathToRoute(file);
-          if (route === null) continue;
-          allRoutes.push({
-            pagePath: file,
-            route,
-            reason: "transitive",
-            depth: 0,
-            triggerChain: [file]
-          });
-        }
-        allRoutes.sort((a, b) => a.route.localeCompare(b.route));
-        if (options.maxRoutes > 0 && allRoutes.length > options.maxRoutes) {
-          affectedRoutes = allRoutes.slice(0, options.maxRoutes);
-        } else {
-          affectedRoutes = allRoutes;
-        }
-      }
-    }
-    const directCount = affectedRoutes.filter((r) => r.reason === "direct").length;
-    const transitiveCount = affectedRoutes.length - directCount;
-    const impactDetail = directCount > 0 && transitiveCount > 0 ? `${affectedRoutes.length} routes (${directCount} direct, ${transitiveCount} transitive)` : `${affectedRoutes.length} routes`;
-    logger.stageComplete("Impact", impactDetail, Date.now() - t3);
-    if (options.verbose) {
-      console.log("");
-      for (const r of affectedRoutes) {
-        const chain = r.triggerChain.map((f) => basename(f)).join(" \u2192 ");
-        const depthLabel = r.depth === 0 ? "direct" : `depth ${r.depth}`;
-        console.log(chalk2.dim(`  ${r.route.padEnd(24)} ${depthLabel.padEnd(10)} ${chain}`));
-      }
-      console.log("");
-    }
-    if (affectedRoutes.length === 0) {
-      worktreePromise?.then((w) => w.cleanup()).catch(() => {
-      });
-      logger.completePipeline();
-      logger.success(
-        "No affected routes found. Changed files don't impact any pages."
-      );
-      return;
-    }
-    if (options.dryRun) {
-      worktreePromise?.then((w) => w.cleanup()).catch(() => {
-      });
-      logger.completePipeline();
-      console.log(`
-${affectedRoutes.length} route(s) would be captured:
-`);
-      for (const r of affectedRoutes) {
-        const chain = r.triggerChain.map((f) => basename(f)).join(" \u2192 ");
-        const depthLabel = r.depth === 0 ? "direct" : `depth ${r.depth}`;
-        console.log(`  ${r.route.padEnd(24)} ${chalk2.dim(depthLabel.padEnd(10))} ${chalk2.dim(chain)}`);
-      }
-      const elapsed2 = ((Date.now() - startTime) / 1e3).toFixed(1);
-      console.log(chalk2.dim(`
-  Completed in ${elapsed2}s (dry run \u2014 no screenshots captured)
-`));
-      return;
-    }
-    const t4 = Date.now();
-    logger.pipeline(4, "Setting up worktree...");
-    const worktree = await worktreePromise;
-    logger.stageComplete("Worktree", "created + dependencies installed", Date.now() - t4);
-    const t5 = Date.now();
-    logger.pipeline(5, "Starting servers...");
-    await ensureDir(outputDir);
-    const beforePort = await findAvailablePort();
-    const afterPort = await findAvailablePort(/* @__PURE__ */ new Set([beforePort]));
-    const [beforeServer, afterServer, browser] = await Promise.all([
-      startServer(worktree.path, beforePort),
-      startServer(cwd, afterPort),
-      launchBrowser()
-    ]);
-    cleanupRegistry.register(() => stopServer(beforeServer));
-    cleanupRegistry.register(() => stopServer(afterServer));
-    cleanupRegistry.register(() => browser.close());
-    logger.stageComplete("Servers", `ready on :${beforePort} and :${afterPort}`, Date.now() - t5);
-    const t6 = Date.now();
-    logger.pipeline(6, "Capturing screenshots...");
-    const tasks = expandRoutes(affectedRoutes, config);
-    const captures = await captureRoutes(
-      tasks,
-      beforeServer.url,
-      afterServer.url,
-      outputDir,
-      {
-        browser,
-        width: options.width,
-        height: options.height,
-        delay: options.delay,
-        onProgress: (i, label) => logger.pipeline(6, `Capturing ${label} (${i}/${tasks.length})...`)
-      }
-    );
-    logger.stageComplete("Capture", `${captures.length} screenshots from ${tasks.length} routes`, Date.now() - t6);
-    logger.completePipeline(true);
-    console.log(`
-${captures.length} screenshot pair(s) captured:
-`);
-    for (const c of captures) {
-      console.log(`  ${c.route}`);
-      console.log(chalk2.dim(`    before: ${c.beforePath.replace(cwd + "/", "")}`));
-      console.log(chalk2.dim(`    after:  ${c.afterPath.replace(cwd + "/", "")}`));
-    }
-    const elapsed = ((Date.now() - startTime) / 1e3).toFixed(1);
-    logger.success(`Done in ${elapsed}s \u2014 ${captures.length} route(s) captured`);
-  } finally {
-    try {
-      logger.writeLogFile(resolve3(outputDir, "debug.log"));
-    } catch {
-    }
-    await cleanupRegistry.runAll();
-  }
-}
-
-// src/cli.ts
-var program = new Command();
-program.name("afterbefore").description(
-  "Automatic before/after screenshot capture for PRs. Git diff is the config."
-).version("0.1.19").option("--base <ref>", "Base branch or ref to compare against", "main").option("--output <dir>", "Output directory for screenshots", ".afterbefore").option(
-  "--max-routes <count>",
-  "Maximum routes to capture (0 = unlimited)",
-  "6"
-).option("--width <pixels>", "Viewport width", "1280").option("--height <pixels>", "Viewport height", "720").option("--delay <ms>", "Extra wait time (ms) after page load", "0").option("--max-depth <n>", "Max import graph traversal depth", "10").option("--dry-run", "Show affected routes without capturing", false).option("--verbose", "Show detailed import graph traversal", false).action(async (opts) => {
-  const cwd = process.cwd();
-  if (!isGitRepo(cwd)) {
-    logger.error("Not a git repository. Run this from inside a git repo.");
-    process.exit(1);
-  }
-  const options = {
-    base: opts.base,
-    output: opts.output,
-    maxRoutes: parseInt(opts.maxRoutes, 10),
-    width: parseInt(opts.width, 10),
-    height: parseInt(opts.height, 10),
-    delay: parseInt(opts.delay, 10),
-    maxDepth: parseInt(opts.maxDepth, 10),
-    dryRun: opts.dryRun,
-    verbose: opts.verbose,
-    cwd
-  };
-  try {
-    await runPipeline(options);
-  } catch (err) {
-    if (err instanceof AfterbeforeError) {
-      logger.error(err.message);
-      logger.dim(`  Suggestion: ${err.suggestion}`);
-    } else {
-      logger.error(
-        err instanceof Error ? err.message : `Unexpected error: ${String(err)}`
-      );
-      console.error(chalk3.dim("\n  Help us fix this: https://github.com/kairevicius/afterbefore/issues/new"));
-      console.error(chalk3.dim("  Include the debug.log file from your output directory.\n"));
-    }
-    await cleanupRegistry.runAll();
-    process.exit(1);
-  }
-});
-program.parse();
-//# sourceMappingURL=cli.js.map