@blzsky/variant 0.2.0

package/dist/chunk-4LLK2S4R.js

@@ -0,0 +1,630 @@
+import {
+  computeInsights,
+  evictStaleEntries,
+  readCache,
+  writeCache,
+  writeCacheSync
+} from "./chunk-LXKLCLL6.js";
+import {
+  renderInsights
+} from "./chunk-ISRF5F3Q.js";
+import {
+  recordCacheMiss,
+  runScheduled
+} from "./chunk-SWPVR2DF.js";
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
+import {
+  mapLimit
+} from "./chunk-GDSZFIHM.js";
+import {
+  TaskExecutionError,
+  VariantError
+} from "./chunk-RVXUCJYA.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+
+// src/core/execution/runner.ts
+import { createHash as createHash2 } from "crypto";
+import os from "os";
+
+// src/core/cache/hashing.ts
+import { createHash } from "crypto";
+import { readFile } from "fs/promises";
+import path from "path";
+import fg from "fast-glob";
+function assertSafePattern(pattern) {
+  if (path.isAbsolute(pattern)) {
+    throw new Error(
+      `Unsafe glob pattern "${pattern}": patterns must be relative and must not traverse outside the project root.`
+    );
+  }
+  const segments = pattern.replace(/\\/g, "/").split("/");
+  if (segments.some((seg) => seg === "..")) {
+    throw new Error(
+      `Unsafe glob pattern "${pattern}": patterns must be relative and must not traverse outside the project root.`
+    );
+  }
+}
+async function hashTaskInputs(cwd, patterns, options = {}) {
+  for (const p of patterns) assertSafePattern(p);
+  const files = (await fg(patterns, {
+    cwd,
+    onlyFiles: true,
+    ignore: ["node_modules/**", ".git/**", ".variant/**"]
+  })).sort();
+  const inScope = filterToScopes(cwd, files, options.packageScopes);
+  const limit = Math.max(1, options.parallel ?? 32);
+  const digests = new Array(inScope.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const i = next++;
+      if (i >= inScope.length) return;
+      const relPath = inScope[i];
+      if (relPath === void 0) return;
+      digests[i] = sha256(await readFile(path.join(cwd, relPath)));
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, inScope.length || 1) }, worker)
+  );
+  const hash = createHash("sha256");
+  for (let i = 0; i < inScope.length; i++) {
+    const relPath = inScope[i];
+    const digest = digests[i];
+    if (relPath === void 0 || digest === void 0) continue;
+    hash.update(relPath);
+    hash.update(digest);
+  }
+  return hash.digest("hex");
+}
+function filterToScopes(cwd, files, packageScopes) {
+  if (!packageScopes?.length) return files;
+  const prefixes = packageScopes.map((dir) => path.resolve(dir) + path.sep);
+  return files.filter((file) => {
+    const absolute = path.resolve(cwd, file);
+    return prefixes.some((prefix) => absolute.startsWith(prefix));
+  });
+}
+function sha256(content) {
+  return createHash("sha256").update(content).digest("hex");
+}
+
+// src/core/provenance/attach.ts
+function attachProvenance(err, taskId, provenance) {
+  const failure = err instanceof VariantError ? err : new TaskExecutionError(
+    taskId,
+    1,
+    `Task "${taskId}" failed: ${String(err)}`,
+    { cause: err }
+  );
+  const entry = provenance?.get(taskId);
+  if (entry !== void 0) failure.provenance = entry;
+  return failure;
+}
+
+// src/core/execution/executor.ts
+var executeTask = async (name, cfg, pm, cwd, onOutput) => {
+  const { execa, ExecaError } = await import("execa");
+  const { default: stringArgv } = await import("string-argv");
+  const command = cfg.command ?? `${pm} run ${name}`;
+  const [cmd, ...args] = stringArgv(command);
+  if (!cmd) {
+    throw new TaskExecutionError(name, 1, `Empty command for task "${name}"`);
+  }
+  try {
+    if (onOutput === void 0) {
+      await execa(cmd, args, { cwd, stdio: "inherit" });
+    } else {
+      const subprocess = execa(cmd, args, { cwd, all: true, buffer: false });
+      for await (const line of subprocess.iterable({ from: "all" })) {
+        onOutput(line);
+      }
+    }
+  } catch (err) {
+    if (err instanceof ExecaError) {
+      const exitCode = typeof err.exitCode === "number" ? err.exitCode : 1;
+      const signal = typeof err.signal === "string" ? err.signal : null;
+      const message = signal ? `Task "${name}" killed by ${signal}` : `Task "${name}" failed with exit code ${exitCode}`;
+      throw new TaskExecutionError(name, exitCode, message, { cause: err });
+    }
+    throw new TaskExecutionError(
+      name,
+      1,
+      `Task "${name}" failed: ${String(err)}`,
+      { cause: err }
+    );
+  }
+};
+
+// src/core/execution/runner.ts
+var sha2562 = (s) => createHash2("sha256").update(s).digest("hex");
+function defaultConcurrency() {
+  return Math.max(1, os.cpus().length - 1);
+}
+async function runOneTask(taskName, options, cache, executor) {
+  if (options.taskFilter && !options.taskFilter(taskName)) {
+    return { task: taskName, durationMs: 0, cacheHit: false, skipped: true };
+  }
+  const taskCfg = options.tasks[taskName] ?? {};
+  const patterns = taskCfg.inputs ?? [];
+  const isStrict = options.config.strategy === "strict";
+  const plugins = options.plugins;
+  const { onTaskOutput } = options;
+  const onOutput = onTaskOutput !== void 0 ? (line) => onTaskOutput(taskName, line) : void 0;
+  if (plugins) {
+    const skip = await plugins.runOnBeforeExecute(taskName);
+    if (skip) {
+      const result2 = {
+        task: taskName,
+        durationMs: 0,
+        cacheHit: true
+      };
+      options.onTaskEvent?.({ task: taskName, status: "cached" });
+      await plugins.runOnAfterExecute(taskName, result2);
+      return result2;
+    }
+  }
+  if (!isStrict && patterns.length > 0) {
+    const baseHash = await hashTaskInputs(
+      options.cwd,
+      patterns,
+      options.packageScopes !== void 0 ? { packageScopes: options.packageScopes } : {}
+    );
+    const extra = plugins ? await plugins.runOnHash(taskName, patterns) : [];
+    const hash = extra.length === 0 ? baseHash : sha2562(`${baseHash}\0${extra.join("\0")}`);
+    const cached = cache.tasks[taskName];
+    if (cached !== void 0 && cached.hash === hash) {
+      const result3 = {
+        task: taskName,
+        durationMs: 0,
+        cacheHit: true
+      };
+      options.onTaskEvent?.({ task: taskName, status: "cached" });
+      if (plugins) await plugins.runOnAfterExecute(taskName, result3);
+      return result3;
+    }
+    recordCacheMiss(options.provenance, taskName, cached?.hash ?? null, hash);
+    options.onTaskEvent?.({ task: taskName, status: "running" });
+    const start2 = Date.now();
+    try {
+      await executor(taskName, taskCfg, options.pm, options.cwd, onOutput);
+    } catch (err) {
+      options.onTaskEvent?.({ task: taskName, status: "failed" });
+      throw attachProvenance(err, taskName, options.provenance);
+    }
+    const durationMs2 = Date.now() - start2;
+    const entry = { hash, lastRun: Date.now(), lastDurationMs: durationMs2 };
+    cache.tasks[taskName] = entry;
+    const result2 = {
+      task: taskName,
+      durationMs: durationMs2,
+      cacheHit: false
+    };
+    options.onTaskEvent?.({ task: taskName, status: "done", durationMs: durationMs2 });
+    if (plugins) await plugins.runOnAfterExecute(taskName, result2);
+    return result2;
+  }
+  options.onTaskEvent?.({ task: taskName, status: "running" });
+  const start = Date.now();
+  try {
+    await executor(taskName, taskCfg, options.pm, options.cwd, onOutput);
+  } catch (err) {
+    options.onTaskEvent?.({ task: taskName, status: "failed" });
+    throw attachProvenance(err, taskName, options.provenance);
+  }
+  const durationMs = Date.now() - start;
+  cache.tasks[taskName] = {
+    lastRun: Date.now(),
+    lastDurationMs: durationMs
+  };
+  const result = {
+    task: taskName,
+    durationMs,
+    cacheHit: false
+  };
+  options.onTaskEvent?.({ task: taskName, status: "done", durationMs });
+  if (plugins) await plugins.runOnAfterExecute(taskName, result);
+  return result;
+}
+async function runTasksWithDeps(target, graph, options, executor = executeTask) {
+  const levels = graph.toLevels(target);
+  const rawCache = await readCache(options.cacheDir);
+  const ttlDays = options.config.cache.ttlDays;
+  const cache = ttlDays !== void 0 ? evictStaleEntries(rawCache, ttlDays) : rawCache;
+  const results = [];
+  const concurrency = options.concurrency ?? defaultConcurrency();
+  const flushCache = () => writeCacheSync(options.cacheDir, cache);
+  process.on("exit", flushCache);
+  try {
+    if (options.useScheduler) {
+      const byTask = /* @__PURE__ */ new Map();
+      await runScheduled(
+        target,
+        graph,
+        async (taskName) => {
+          byTask.set(
+            taskName,
+            await runOneTask(taskName, options, cache, executor)
+          );
+        },
+        {
+          concurrency,
+          ...options.priorityOf !== void 0 ? { priorityOf: options.priorityOf } : {}
+        }
+      );
+      for (const name of levels.flat()) {
+        const r = byTask.get(name);
+        if (r !== void 0) results.push(r);
+      }
+    } else {
+      for (const level of levels) {
+        const levelResults = await mapLimit(
+          level,
+          concurrency,
+          async (taskName) => runOneTask(taskName, options, cache, executor)
+        );
+        results.push(...levelResults);
+      }
+    }
+  } finally {
+    try {
+      await writeCache(options.cacheDir, cache);
+    } catch {
+    }
+    process.off("exit", flushCache);
+  }
+  return results;
+}
+
+// src/cli/visuals/ansi.ts
+var ESC = "\x1B";
+var HIDE_CURSOR = `${ESC}[?25l`;
+var SHOW_CURSOR = `${ESC}[?25h`;
+var CLEAR_LINE = `${ESC}[2K`;
+var SYNC_START = `${ESC}[?2026h`;
+var SYNC_END = `${ESC}[?2026l`;
+function cursorUp(lines2) {
+  return lines2 > 0 ? `${ESC}[${lines2}A` : "";
+}
+var STYLE_PATTERN = new RegExp(`${ESC}\\[[0-9;]*m`, "g");
+function stripStyles(text) {
+  return text.replace(STYLE_PATTERN, "");
+}
+function visibleLength(line) {
+  return stripStyles(line).length;
+}
+function fitWidth(line, columns) {
+  if (visibleLength(line) <= columns) return line;
+  return stripStyles(line).slice(0, Math.max(0, columns - 1));
+}
+
+// src/cli/visuals/progress.ts
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var TICK_MS = 80;
+var BAR_WIDTH = 30;
+function humanReadableBytes(bytes) {
+  const units = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB"];
+  if (bytes < 1) return [bytes, "B"];
+  const exponent = Math.min(
+    Math.floor(Math.log2(bytes) / 10),
+    units.length - 1
+  );
+  return [bytes / 1024 ** exponent, units[exponent] ?? "B"];
+}
+function formatBytes(bytes) {
+  const [value, unit] = humanReadableBytes(bytes);
+  const rounded = value >= 100 ? value.toFixed(0) : value.toFixed(1);
+  return `${rounded} ${unit}`;
+}
+var DIRECTION_LABELS = {
+  download: { active: "Downloading", done: "Downloaded" },
+  upload: { active: "Uploading", done: "Uploaded" }
+};
+var BlockRenderer = class {
+  constructor(stream) {
+    this.stream = stream;
+  }
+  stream;
+  renderedLineCount = 0;
+  /**
+   * Emit one frame as a single write, wrapped in a synchronized update so
+   * the terminal paints it atomically. Permanent lines overwrite the top of
+   * the previous block and scroll away; the live block is redrawn below.
+   */
+  frame(permanentLines, liveLines) {
+    const columns = this.stream.columns ?? 80;
+    let out = SYNC_START + cursorUp(this.renderedLineCount);
+    for (const line of permanentLines) {
+      out += `${CLEAR_LINE}${fitWidth(line, columns)}
+`;
+    }
+    for (const line of liveLines) {
+      out += `${CLEAR_LINE}${fitWidth(line, columns)}
+`;
+    }
+    const leftover = this.renderedLineCount - permanentLines.length - liveLines.length;
+    if (leftover > 0) {
+      out += `${CLEAR_LINE}
+`.repeat(leftover) + cursorUp(leftover);
+    }
+    this.stream.write(out + SYNC_END);
+    this.renderedLineCount = liveLines.length;
+  }
+  repaint(lines2) {
+    this.frame([], lines2);
+  }
+  clear() {
+    this.frame([], []);
+  }
+};
+function detectSingleMode() {
+  const session = process.env["JPY_SESSION_NAME"];
+  return session !== void 0 && session !== "";
+}
+function testProgressSuppressed() {
+  const flag = process.env["VARIANT_TEST_NO_CLI_PROGRESS"];
+  return flag !== void 0 && flag !== "";
+}
+var ProgressReporter = class _ProgressReporter {
+  printer;
+  renderer;
+  singleMode;
+  /** Pinned header lines (pre-rendered), in insertion order. */
+  tasks = /* @__PURE__ */ new Map();
+  requests = /* @__PURE__ */ new Map();
+  /** Permanent lines queued for the next frame (flushed in one write). */
+  pendingLogs = [];
+  message;
+  nextId = 0;
+  maxNameLength = 0;
+  frame = 0;
+  timer;
+  finished = false;
+  constructor(printer, message, options) {
+    this.printer = printer;
+    this.message = message;
+    this.singleMode = options.singleMode ?? detectSingleMode();
+    if (printer.progressEnabled) {
+      this.renderer = new BlockRenderer(printer.progressStream);
+      printer.progressStream.write(HIDE_CURSOR);
+      this.timer = setInterval(() => this.tick(), TICK_MS);
+      this.timer.unref();
+      this.repaint();
+    }
+  }
+  /** Build a reporter with a root spinner, e.g. for a resolve/prepare step. */
+  static spinner(printer, message, options = {}) {
+    return new _ProgressReporter(printer, message, options);
+  }
+  /** Update the root spinner's message (e.g. the item currently in flight). */
+  setMessage(message) {
+    this.message = message;
+    this.repaint();
+  }
+  /** Finish and clear the whole block, restoring the cursor. */
+  finish() {
+    if (this.finished) return;
+    if (this.timer !== void 0) clearInterval(this.timer);
+    if (this.renderer !== void 0) {
+      this.renderer.frame(this.pendingLogs.splice(0), []);
+      this.printer.progressStream.write(SHOW_CURSOR);
+    }
+    this.finished = true;
+  }
+  /**
+   * Pin a fully custom, pre-rendered header line above the item bars.
+   * Returns an ID to pass to {@link finishTask} / {@link completeTask}.
+   */
+  pinLine(line) {
+    const id = ++this.nextId;
+    if (this.singleMode) return id;
+    this.tasks.set(id, line);
+    if (this.renderer === void 0) {
+      this.logLine(line);
+      return id;
+    }
+    this.repaint();
+    return id;
+  }
+  /**
+   * Start a labeled header (e.g. "Building foo") pinned above the item bars.
+   * Returns an ID to pass to {@link finishTask}.
+   */
+  startTask(verb, subject) {
+    const colors = getColors();
+    return this.pinLine(`   ${colors.bold(colors.cyan(verb))} ${subject}`);
+  }
+  /** Complete a task started with {@link startTask}, leaving a done line. */
+  finishTask(verb, subject, id) {
+    const colors = getColors();
+    this.completeTask(
+      id,
+      `      ${colors.bold(colors.green(verb))} ${subject}`
+    );
+  }
+  /**
+   * Complete a task started with {@link startTask} with a fully custom line
+   * (e.g. a red failure line): removes the header and logs the line.
+   */
+  completeTask(id, line) {
+    if (this.singleMode) return;
+    this.tasks.delete(id);
+    this.logLine(line);
+  }
+  /**
+   * Print a permanent line above the live block (indicatif's `println`) — or
+   * as a plain stderr line when bars are hidden.
+   */
+  log(line) {
+    this.logLine(line);
+  }
+  /**
+   * Start tracking a download/upload with an optional known size. Returns an
+   * ID to pass to {@link requestProgress} / {@link requestComplete}.
+   */
+  requestStart(direction, name, size) {
+    const id = ++this.nextId;
+    if (this.singleMode) return id;
+    this.requests.set(id, { direction, name, size, transferred: 0 });
+    this.maxNameLength = Math.max(this.maxNameLength, name.length);
+    this.repaint();
+    return id;
+  }
+  /** Record `bytes` more transferred for a request. */
+  requestProgress(id, bytes) {
+    const request = this.requests.get(id);
+    if (request === void 0) return;
+    request.transferred += bytes;
+    this.repaint();
+  }
+  /** Complete and clear a request bar. */
+  requestComplete(id) {
+    const request = this.requests.get(id);
+    if (request === void 0) return;
+    this.requests.delete(id);
+    if (this.renderer === void 0) {
+      const colors = getColors();
+      const label = DIRECTION_LABELS[request.direction].done;
+      const detail = request.size !== void 0 ? ` (${formatBytes(request.size)})` : "";
+      this.logLine(
+        `${colors.bold(colors.green(label))} ${request.name}${colors.dim(detail)}`
+      );
+      return;
+    }
+    this.repaint();
+  }
+  /**
+   * Print a permanent line above the live block — or as a plain stderr line
+   * when bars are hidden, so output degrades gracefully in pipes and CI.
+   * Visible-mode lines are queued and flushed inside the next frame's single
+   * write, so the terminal never paints an intermediate state.
+   */
+  logLine(line) {
+    if (this.renderer === void 0) {
+      if (!testProgressSuppressed()) this.printer.stderr(`${line}
+`);
+      return;
+    }
+    this.pendingLogs.push(line);
+    this.repaint();
+  }
+  tick() {
+    this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+    this.repaint();
+  }
+  repaint() {
+    if (this.renderer === void 0 || this.finished) return;
+    this.renderer.frame(this.pendingLogs.splice(0), this.composeLines());
+  }
+  composeLines() {
+    const colors = getColors();
+    const lines2 = [...this.tasks.values()];
+    const requests = [...this.requests.values()].sort(
+      (a, b) => (a.size ?? 0) - (b.size ?? 0)
+    );
+    for (const request of requests) {
+      lines2.push(this.composeRequestLine(request, colors));
+    }
+    const spinnerFrame = SPINNER_FRAMES[this.frame] ?? "\u280B";
+    lines2.push(`${spinnerFrame} ${colors.dim(this.message)}`);
+    return lines2;
+  }
+  composeRequestLine(request, colors) {
+    const name = colors.dim(request.name.padEnd(this.maxNameLength));
+    if (request.size === void 0) {
+      return `${name} ${colors.dim("....")}`;
+    }
+    const ratio = request.size === 0 ? 1 : Math.min(request.transferred / request.size, 1);
+    const filled = Math.round(ratio * BAR_WIDTH);
+    const bar = colors.green("\u2588".repeat(filled)) + colors.dim("\u2591".repeat(BAR_WIDTH - filled));
+    const transferred = formatBytes(request.transferred).padStart(9);
+    return `${name} ${bar} ${transferred}/${formatBytes(request.size)}`;
+  }
+};
+
+// src/cli/visuals/task-events.ts
+function createTaskEventProgress(message, printer = getPrinter()) {
+  const reporter = ProgressReporter.spinner(printer, message);
+  const running = /* @__PURE__ */ new Map();
+  const completeWith = (task, line) => {
+    const id = running.get(task);
+    running.delete(task);
+    if (id !== void 0) reporter.completeTask(id, line);
+    else reporter.log(line);
+  };
+  const onTaskEvent = ({ task, status, durationMs }) => {
+    const colors = getColors();
+    switch (status) {
+      case "running":
+        running.set(
+          task,
+          reporter.pinLine(`  ${colors.bold(colors.cyan("\u2192"))} ${task}`)
+        );
+        break;
+      case "cached":
+        reporter.log(colors.dim(`  \xB7 ${task} [cached]`));
+        break;
+      case "done": {
+        const duration = durationMs !== void 0 ? colors.dim(` (${durationMs}ms)`) : "";
+        completeWith(task, `${colors.green(`  \u2713 ${task}`)}${duration}`);
+        break;
+      }
+      case "failed":
+        completeWith(task, colors.red(`  \u2717 ${task}`));
+        break;
+    }
+  };
+  const onTaskOutput = printer.progressEnabled ? (task, line) => {
+    const colors = getColors();
+    reporter.log(`${colors.dim(`  ${task} \u2502`)} ${line}`);
+  } : void 0;
+  return {
+    onTaskEvent,
+    onTaskOutput,
+    finish: () => {
+      reporter.finish();
+    }
+  };
+}
+
+// src/cli/execute.ts
+async function executeTarget(target, ctx, runOptions, message) {
+  const progress = createTaskEventProgress(message);
+  runOptions.onTaskEvent = progress.onTaskEvent;
+  if (progress.onTaskOutput !== void 0) {
+    runOptions.onTaskOutput = progress.onTaskOutput;
+  }
+  try {
+    return await runTasksWithDeps(target, ctx.graph, runOptions);
+  } finally {
+    progress.finish();
+  }
+}
+async function reportRunInsights(ctx, results) {
+  const cache = await readCache(ctx.cacheDir);
+  renderInsights(computeInsights(results, cache));
+}
+
+// src/cli/render/plan.ts
+function renderDryRunPlan(target, levels, printer = getPrinter()) {
+  lines(
+    printer,
+    `[dry-run] Task plan for "${target}" (${levels.flat().length} task(s)):`
+  );
+  for (const [index, level] of levels.entries()) {
+    lines(printer, `  Level ${index + 1}: ${level.join(", ")}`);
+  }
+}
+
+export {
+  executeTarget,
+  reportRunInsights,
+  renderDryRunPlan
+};

package/dist/chunk-6J4XDG44.js

@@ -0,0 +1,14 @@
+// src/cli/render/writer.ts
+function lines(printer, ...text) {
+  for (const t of text) printer.stdout(`${t}
+`);
+}
+function errorLines(printer, ...text) {
+  for (const t of text) printer.stderr(`${t}
+`);
+}
+
+export {
+  lines,
+  errorLines
+};

package/dist/chunk-CXNXZLDG.js

@@ -0,0 +1,13 @@
+// src/cli/render/labels.ts
+var LABEL_WIDTH = "non-impacting".length;
+function classificationLabel(classification) {
+  return classification.padEnd(LABEL_WIDTH);
+}
+function plural(count, noun) {
+  return `${count.toLocaleString("en-US")} ${noun}${count === 1 ? "" : "s"}`;
+}
+
+export {
+  classificationLabel,
+  plural
+};

package/dist/chunk-DRMASVYN.js

@@ -0,0 +1,25 @@
+// src/core/semantic/verdict.ts
+function deriveVerdict(classifications, options = {}) {
+  if (options.forceBuild === true) return "build-required";
+  let verdict = "safe-to-skip";
+  for (const classification of classifications) {
+    if (classification === "breaking") return "build-required";
+    if (classification === "internal" || classification === "unanalyzed") {
+      verdict = "build-recommended";
+    }
+  }
+  return verdict;
+}
+var VERDICT_TEXT = {
+  "safe-to-skip": "safe to skip build",
+  "build-recommended": "build recommended",
+  "build-required": "build required"
+};
+function verdictText(verdict) {
+  return VERDICT_TEXT[verdict];
+}
+
+export {
+  deriveVerdict,
+  verdictText
+};