@blzsky/variant 0.2.1 → 0.3.0-canary.1

package/dist/chunk-C3NZIFW6.js

@@ -0,0 +1,174 @@
+// src/core/errors.ts
+var VariantError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "VariantError";
+  }
+  code;
+  hint;
+  /** Lines of evidence printed between the message and the hint. */
+  details;
+  /**
+   * Why the task that produced this failure was running. Attached by the
+   * runner so the failure and its reason travel together; absent on errors
+   * belonging to no task (config, CLI usage) and on successful runs.
+   *
+   * This says nothing about why the task FAILED — see `RunReason`.
+   */
+  provenance;
+};
+var ConfigError = class extends VariantError {
+  constructor(message, options) {
+    super("CONFIG_ERROR", message, options);
+    this.hint = "Run `variant doctor` to diagnose configuration issues.";
+  }
+};
+var CycleError = class extends VariantError {
+  constructor(cycle) {
+    super("CYCLE_ERROR", `Circular dependency detected: ${cycle.join(" -> ")}`);
+    this.cycle = cycle;
+    this.hint = "Remove or reorder `dependsOn` entries to break the cycle.";
+  }
+  cycle;
+};
+var TaskExecutionError = class extends VariantError {
+  constructor(task, exitCode, message, options) {
+    super(
+      "TASK_EXECUTION_ERROR",
+      message ?? `Task "${task}" failed with exit code ${exitCode}`,
+      options
+    );
+    this.task = task;
+    this.exitCode = exitCode;
+    this.hint = `Check the output above, fix the failing command in task "${task}", then re-run.`;
+  }
+  task;
+  exitCode;
+};
+var CacheError = class extends VariantError {
+  constructor(message, options) {
+    super("CACHE_ERROR", message, options);
+    this.hint = "Delete `.variant/cache/` and retry.";
+  }
+};
+var GraphError = class extends VariantError {
+  constructor(message, options) {
+    super("GRAPH_ERROR", message, options);
+    this.hint = "Delete `.variant/graph/` and retry.";
+  }
+};
+var GitRefError = class extends VariantError {
+  constructor(message) {
+    super("GIT_REF_ERROR", message);
+    this.hint = "Check the ref with `git rev-parse --verify <ref>`. In CI, check out with `fetch-depth: 0` and pass a remote-tracking ref such as `origin/main`.";
+  }
+};
+var NoBaseCommitError = class extends VariantError {
+  constructor() {
+    super(
+      "NO_BASE_COMMIT",
+      "This push has no previous commit to compare against"
+    );
+    this.hint = "The first push of a branch, or a force-push whose old head is gone. Pass --base to compare against a commit of your choice.";
+  }
+};
+var ImpactReportError = class extends VariantError {
+  constructor(message) {
+    super("IMPACT_REPORT_ERROR", `Could not read the test report: ${message}`);
+    this.hint = "Pass a Vitest `--reporter=json --outputFile=<path>` or Jest `--json --outputFile=<path>` report.";
+  }
+};
+var NoTestFilesError = class extends VariantError {
+  constructor() {
+    super(
+      "NO_TEST_FILES",
+      "No test files found, so there is nothing to predict"
+    );
+    this.hint = "variant finds TypeScript tests named `*.test.ts` or `*.spec.ts` (also `.tsx`, `.mts`, `.cts`) or placed under `__tests__/`. JavaScript files are not indexed.";
+  }
+};
+var NoChangeBaseError = class extends VariantError {
+  constructor(message) {
+    super("NO_CHANGE_BASE", message);
+    this.hint = "Pass --base <ref> to say what to compare against, for example `--base HEAD~1` or `--base origin/main`.";
+  }
+};
+var DID_NOT_LOAD = " (did not load)";
+function baselineMessage(failingTests) {
+  const files = failingTests.filter((test) => test.name.endsWith(DID_NOT_LOAD));
+  const tests = failingTests.length - files.length;
+  const parts = [
+    ...files.length > 0 ? [
+      `${files.length} test file${files.length === 1 ? "" : "s"} did not load`
+    ] : [],
+    ...tests > 0 ? [`${tests} test${tests === 1 ? " fails" : "s fail"}`] : []
+  ];
+  return parts.length === 0 ? "The tests fail before any mutation, so no result could be trusted" : `${parts.join(" and ")} before any mutation, so no result could be trusted`;
+}
+var BaselineFailedError = class extends VariantError {
+  constructor(failingTests, output) {
+    super("BASELINE_FAILED", baselineMessage(failingTests));
+    this.failingTests = failingTests;
+    this.output = output;
+    this.details = failingTests.slice(0, 10).map(
+      (test) => test.message === "" ? test.name : `${test.name}: ${test.message}`
+    );
+    this.hint = "Make the tests pass first. If `vitest run` already passes outside variant, the copy variant runs them in is the cause: a path outside this directory (such as a tsconfig `extends`), git used by a test, or an absolute path.";
+  }
+  failingTests;
+  output;
+};
+var CheckBackendError = class extends VariantError {
+  constructor(message, output) {
+    super("CHECK_BACKEND", message);
+    this.output = output;
+    const lines = output.split(/\r?\n/).filter((line) => line.trim() !== "");
+    this.details = lines.slice(-12);
+    this.hint = lines.length > 0 ? "Above is the engine's last output. If the tests pass with `vitest run`, please report this with it." : "If the tests pass with `vitest run`, please report this.";
+  }
+  output;
+};
+var CheckWorkspaceRootError = class extends VariantError {
+  constructor() {
+    super(
+      "CHECK_WORKSPACE_ROOT",
+      "`variant check` runs from a package directory, not a workspace root"
+    );
+    this.hint = "cd into the package whose code changed and run `variant check` there.";
+  }
+};
+var CheckRunnerError = class extends VariantError {
+  constructor(found) {
+    super(
+      "CHECK_RUNNER",
+      found.kind === "jest" ? `This package tests with Jest (${found.evidence}); \`variant check\` runs Vitest only` : "No Vitest here: no `vitest` dependency, script or config in this package"
+    );
+    this.hint = found.kind === "jest" ? "Jest support is not built yet. The pull request report (`variant pr report`) and `variant impact` do work with Jest; docs/check.md says what `check` supports." : "Run it from the package that runs Vitest, or pass --vitest-config <file>.";
+  }
+};
+var CliUsageError = class extends VariantError {
+  constructor(message) {
+    super("CLI_USAGE", message);
+    this.hint = "Run `variant --help` for usage information.";
+  }
+};
+
+export {
+  VariantError,
+  ConfigError,
+  CycleError,
+  TaskExecutionError,
+  CacheError,
+  GraphError,
+  GitRefError,
+  NoBaseCommitError,
+  ImpactReportError,
+  NoTestFilesError,
+  NoChangeBaseError,
+  BaselineFailedError,
+  CheckBackendError,
+  CheckWorkspaceRootError,
+  CheckRunnerError,
+  CliUsageError
+};

package/dist/{chunk-ZH2PQUNL.js → chunk-EFCMBBBT.js}

@@ -1,3 +1,10 @@
+import {
+  buildGraph
+} from "./chunk-H55GYSQ6.js";
+import {
+  changedFilesToPackages,
+  getChangedFiles
+} from "./chunk-MKUYZIXF.js";
 import {
   detectProject,
   genericAdapter,
@@ -5,31 +12,24 @@ import {
   nextPlugin,
   viteAdapter
 } from "./chunk-V5CTGXMM.js";
-import {
-  loadConfig
-} from "./chunk-26DHEXGS.js";
-import {
-  getColors
-} from "./chunk-YYGCSKIQ.js";
-import {
-  changedFilesToPackages,
-  getChangedFiles
-} from "./chunk-7OPTWU6E.js";
 import {
   computeAffectedPackages,
   loadPackageGraph,
   tasksFromPackageGraph
 } from "./chunk-3E5LBU3O.js";
 import {
-  errorLines
+  errorLines,
+  lines
 } from "./chunk-6J4XDG44.js";
+import {
+  loadConfig
+} from "./chunk-NOC53Z5Q.js";
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
 import {
   getPrinter
 } from "./chunk-EISTWXDW.js";
-import {
-  ConfigError,
-  CycleError
-} from "./chunk-VYWPQKMS.js";
 
 // src/adapters/frameworks/plugin.ts
 var wrapFrameworkAsPlugin = (a) => ({
@@ -133,100 +133,6 @@ function insertSorted(arr, item, priorityOf) {
   arr.splice(lo, 0, item);
 }
 
-// src/core/graph/dag.ts
-var TaskGraph = class {
-  tasks = /* @__PURE__ */ new Set();
-  deps = /* @__PURE__ */ new Map();
-  // task -> set of tasks it depends on
-  levelCache = /* @__PURE__ */ new Map();
-  addTask(name) {
-    if (!this.tasks.has(name)) {
-      this.tasks.add(name);
-      this.deps.set(name, /* @__PURE__ */ new Set());
-      this.levelCache.clear();
-    }
-  }
-  addDependency(task, dependsOn) {
-    this.addTask(task);
-    this.addTask(dependsOn);
-    const taskDeps = this.deps.get(task);
-    taskDeps?.add(dependsOn);
-    this.levelCache.clear();
-  }
-  getDependencies(task) {
-    return this.deps.get(task) ?? /* @__PURE__ */ new Set();
-  }
-  toLevels(target) {
-    const cached = this.levelCache.get(target);
-    if (cached !== void 0) {
-      return cached.map((level) => [...level]);
-    }
-    if (!this.tasks.has(target)) {
-      throw new ConfigError(`Task "${target}" not found in graph`);
-    }
-    const subgraph = /* @__PURE__ */ new Set();
-    const stack = [target];
-    while (stack.length) {
-      const node = stack.pop();
-      if (node === void 0) continue;
-      if (subgraph.has(node)) continue;
-      subgraph.add(node);
-      for (const dep of this.deps.get(node) ?? []) {
-        stack.push(dep);
-      }
-    }
-    const inDegree = /* @__PURE__ */ new Map();
-    for (const node of subgraph) inDegree.set(node, 0);
-    for (const node of subgraph) {
-      for (const dep of this.deps.get(node) ?? []) {
-        if (subgraph.has(dep)) {
-          inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
-        }
-      }
-    }
-    const levels = [];
-    let queue = [...subgraph].filter((n) => inDegree.get(n) === 0);
-    let processed = 0;
-    while (queue.length) {
-      levels.push([...queue].sort());
-      processed += queue.length;
-      const next = [];
-      for (const node of queue) {
-        for (const dep of this.deps.get(node) ?? []) {
-          if (subgraph.has(dep)) {
-            const newDeg = (inDegree.get(dep) ?? 0) - 1;
-            inDegree.set(dep, newDeg);
-            if (newDeg === 0) next.push(dep);
-          }
-        }
-      }
-      queue = next;
-    }
-    if (processed < subgraph.size) {
-      const remaining = [...subgraph].filter((n) => (inDegree.get(n) ?? 0) > 0);
-      throw new CycleError(remaining);
-    }
-    const result = levels.reverse();
-    this.levelCache.set(
-      target,
-      result.map((level) => [...level])
-    );
-    return result;
-  }
-};
-
-// src/core/graph/planner.ts
-function buildGraph(config) {
-  const graph = new TaskGraph();
-  for (const [name, task] of Object.entries(config.tasks)) {
-    graph.addTask(name);
-    task.dependsOn?.forEach((dep) => {
-      graph.addDependency(name, dep);
-    });
-  }
-  return graph;
-}
-
 // src/core/plugins/registry.ts
 var swallowErrors = () => {
 };
@@ -460,9 +366,65 @@ function toRunOptions(ctx, overrides = {}) {
   };
 }
 
+// src/cli/render/insight.ts
+function statusLabel(result) {
+  const colors = getColors();
+  if (result.skipped) return colors.dim("SKIP");
+  return result.cacheHit ? colors.green("HIT") : colors.red("MISS");
+}
+function renderInsights(summary, printer = getPrinter()) {
+  const colors = getColors();
+  const results = summary.lastRunResults;
+  if (results.length === 0) {
+    const entries = Object.entries(summary.cachedStats);
+    if (entries.length === 0) {
+      lines(printer, "No cached task data yet. Run a task first.");
+      return;
+    }
+    lines(printer, "", "Cached task history:");
+    for (const [task, entry] of entries) {
+      const duration = entry.lastDurationMs !== void 0 ? `${entry.lastDurationMs}ms` : "unknown";
+      const ran = new Date(entry.lastRun).toLocaleString();
+      lines(
+        printer,
+        `  ${task.padEnd(20)} last run: ${ran}  duration: ${duration}`
+      );
+    }
+    return;
+  }
+  const nameWidth = Math.max(...results.map((r) => r.task.length), 4);
+  const header = `${"TASK".padEnd(nameWidth)} ${"DURATION".padEnd(10)} STATUS`;
+  lines(printer, "", colors.bold(header), "-".repeat(header.length));
+  for (const result of results) {
+    const duration = result.skipped || result.cacheHit ? "-" : `${result.durationMs}ms`;
+    lines(
+      printer,
+      `${result.task.padEnd(nameWidth)} ${duration.padEnd(10)} ${statusLabel(result)}`
+    );
+  }
+  const percent = (summary.cacheHitRate * 100).toFixed(0);
+  lines(
+    printer,
+    "",
+    colors.dim(
+      `Total: ${summary.totalDurationMs}ms  Cache hit rate: ${percent}%`
+    )
+  );
+}
+function renderEnv(pm, runtime, framework, printer = getPrinter()) {
+  lines(
+    printer,
+    `Package Manager : ${pm}`,
+    `Runtime         : ${runtime.primary} (fallback: ${runtime.fallback})`,
+    `Framework       : ${framework ?? "none detected"}`
+  );
+}
+
 export {
   runScheduled,
   recordCacheMiss,
   createContext,
-  toRunOptions
+  toRunOptions,
+  renderInsights,
+  renderEnv
 };

package/dist/chunk-H55GYSQ6.js

@@ -0,0 +1,102 @@
+import {
+  ConfigError,
+  CycleError
+} from "./chunk-C3NZIFW6.js";
+
+// src/core/graph/dag.ts
+var TaskGraph = class {
+  tasks = /* @__PURE__ */ new Set();
+  deps = /* @__PURE__ */ new Map();
+  // task -> set of tasks it depends on
+  levelCache = /* @__PURE__ */ new Map();
+  addTask(name) {
+    if (!this.tasks.has(name)) {
+      this.tasks.add(name);
+      this.deps.set(name, /* @__PURE__ */ new Set());
+      this.levelCache.clear();
+    }
+  }
+  addDependency(task, dependsOn) {
+    this.addTask(task);
+    this.addTask(dependsOn);
+    const taskDeps = this.deps.get(task);
+    taskDeps?.add(dependsOn);
+    this.levelCache.clear();
+  }
+  getDependencies(task) {
+    return this.deps.get(task) ?? /* @__PURE__ */ new Set();
+  }
+  toLevels(target) {
+    const cached = this.levelCache.get(target);
+    if (cached !== void 0) {
+      return cached.map((level) => [...level]);
+    }
+    if (!this.tasks.has(target)) {
+      throw new ConfigError(`Task "${target}" not found in graph`);
+    }
+    const subgraph = /* @__PURE__ */ new Set();
+    const stack = [target];
+    while (stack.length) {
+      const node = stack.pop();
+      if (node === void 0) continue;
+      if (subgraph.has(node)) continue;
+      subgraph.add(node);
+      for (const dep of this.deps.get(node) ?? []) {
+        stack.push(dep);
+      }
+    }
+    const inDegree = /* @__PURE__ */ new Map();
+    for (const node of subgraph) inDegree.set(node, 0);
+    for (const node of subgraph) {
+      for (const dep of this.deps.get(node) ?? []) {
+        if (subgraph.has(dep)) {
+          inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+        }
+      }
+    }
+    const levels = [];
+    let queue = [...subgraph].filter((n) => inDegree.get(n) === 0);
+    let processed = 0;
+    while (queue.length) {
+      levels.push([...queue].sort());
+      processed += queue.length;
+      const next = [];
+      for (const node of queue) {
+        for (const dep of this.deps.get(node) ?? []) {
+          if (subgraph.has(dep)) {
+            const newDeg = (inDegree.get(dep) ?? 0) - 1;
+            inDegree.set(dep, newDeg);
+            if (newDeg === 0) next.push(dep);
+          }
+        }
+      }
+      queue = next;
+    }
+    if (processed < subgraph.size) {
+      const remaining = [...subgraph].filter((n) => (inDegree.get(n) ?? 0) > 0);
+      throw new CycleError(remaining);
+    }
+    const result = levels.reverse();
+    this.levelCache.set(
+      target,
+      result.map((level) => [...level])
+    );
+    return result;
+  }
+};
+
+// src/core/graph/planner.ts
+function buildGraph(config) {
+  const graph = new TaskGraph();
+  for (const [name, task] of Object.entries(config.tasks)) {
+    graph.addTask(name);
+    task.dependsOn?.forEach((dep) => {
+      graph.addDependency(name, dep);
+    });
+  }
+  return graph;
+}
+
+export {
+  buildGraph
+};

package/dist/chunk-HL65IPEQ.js

@@ -0,0 +1,167 @@
+import {
+  appendReconciliation,
+  defaultHistoryDir,
+  readImpactPredictions
+} from "./chunk-34VGKPEM.js";
+import {
+  ImpactReportError
+} from "./chunk-C3NZIFW6.js";
+
+// src/core/impact/verify.ts
+import { realpathSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+function realpathOrSelf(target) {
+  try {
+    return realpathSync.native(target);
+  } catch {
+    return target;
+  }
+}
+function escapes(relative) {
+  return relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative);
+}
+function toRelativePosix(cwd, testPath, realpath) {
+  let relative = testPath;
+  if (path.isAbsolute(testPath)) {
+    relative = path.relative(cwd, testPath);
+    if (escapes(relative)) {
+      relative = path.relative(realpath(cwd), realpath(testPath));
+    }
+  }
+  return relative.replace(/\\/g, "/");
+}
+function parseTestRun(cwd, raw, realpath = realpathOrSelf) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new ImpactReportError("it is not valid JSON");
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new ImpactReportError("it is not a JSON object");
+  }
+  const results = parsed.testResults;
+  if (!Array.isArray(results)) {
+    throw new ImpactReportError("it has no `testResults` array");
+  }
+  const ran = /* @__PURE__ */ new Set();
+  const failed = /* @__PURE__ */ new Set();
+  for (const entry of results) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const { name, status } = entry;
+    if (typeof name !== "string") continue;
+    const file = toRelativePosix(cwd, name, realpath);
+    ran.add(file);
+    if (status === "failed") failed.add(file);
+  }
+  return { ran: [...ran].sort(), failed: [...failed].sort() };
+}
+function testRunFrom(cwd, results, realpath = realpathOrSelf) {
+  const ran = /* @__PURE__ */ new Set();
+  const failed = /* @__PURE__ */ new Set();
+  for (const result of results) {
+    const file = toRelativePosix(cwd, result.file, realpath);
+    ran.add(file);
+    if (result.failed) failed.add(file);
+  }
+  return { ran: [...ran].sort(), failed: [...failed].sort() };
+}
+function reconcile(prediction, failedTests) {
+  const selected = new Set(prediction.affectedTests);
+  const caught = [];
+  const falseSkips = [];
+  for (const test of failedTests) {
+    if (prediction.selectAll || selected.has(test)) caught.push(test);
+    else falseSkips.push(test);
+  }
+  return {
+    caught,
+    falseSkips,
+    falseSkipRate: failedTests.length === 0 ? 0 : falseSkips.length / failedTests.length
+  };
+}
+function selectPrediction(predictions, headSha) {
+  if (headSha !== void 0) {
+    for (let i = predictions.length - 1; i >= 0; i--) {
+      const candidate = predictions[i];
+      if (candidate?.headSha === headSha) {
+        return { prediction: candidate, matchedBy: "head-sha" };
+      }
+    }
+    return null;
+  }
+  const latest = predictions[predictions.length - 1];
+  return latest === void 0 ? null : { prediction: latest, matchedBy: "most-recent" };
+}
+async function readReport(cwd, reportPath) {
+  try {
+    return await readFile(path.resolve(cwd, reportPath), "utf8");
+  } catch (error) {
+    const code = error instanceof Error && "code" in error ? String(error.code) : "";
+    throw new ImpactReportError(
+      code === "ENOENT" ? `no file at ${reportPath}` : `${reportPath} could not be read${code === "" ? "" : ` (${code})`}`
+    );
+  }
+}
+async function verifyImpact(cwd, reportPaths, options = {}) {
+  const paths = typeof reportPaths === "string" ? [reportPaths] : reportPaths;
+  return verifyRun(
+    cwd,
+    async () => {
+      const reports = await Promise.all(
+        paths.map((reportPath) => readReport(cwd, reportPath))
+      );
+      return reports.map((raw) => parseTestRun(cwd, raw));
+    },
+    options
+  );
+}
+async function verifyRun(cwd, runs, options = {}) {
+  const historyDir = defaultHistoryDir(cwd);
+  const predictions = options.predictions ?? await readImpactPredictions(historyDir);
+  const match = selectPrediction(predictions, options.headSha);
+  if (match === null) return null;
+  const resolved = typeof runs === "function" ? await runs() : Array.isArray(runs) ? runs : [runs];
+  const failedTests = [
+    ...new Set(resolved.flatMap((run) => run.failed))
+  ].sort();
+  const ran = new Set(resolved.flatMap((run) => run.ran));
+  const selected = new Set(match.prediction.affectedTests);
+  const predictedRan = match.prediction.selectAll ? ran.size : [...ran].filter((test) => selected.has(test)).length;
+  const { caught, falseSkips, falseSkipRate } = reconcile(
+    match.prediction,
+    failedTests
+  );
+  const historyLogged = options.log === false ? true : await appendReconciliation(historyDir, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    headSha: match.prediction.headSha,
+    baseRef: match.prediction.baseRef,
+    predictedTests: match.prediction.affectedTests.length,
+    totalTests: match.prediction.totalTests,
+    failedTests: failedTests.length,
+    caught: caught.length,
+    falseSkips: falseSkips.length,
+    confidence: match.prediction.confidence,
+    selectAll: match.prediction.selectAll,
+    ranTests: ran.size,
+    predictedRan
+  });
+  return {
+    prediction: match.prediction,
+    matchedBy: match.matchedBy,
+    failedTests,
+    caught,
+    falseSkips,
+    falseSkipRate,
+    ranTests: ran.size,
+    predictedRan,
+    historyLogged
+  };
+}
+
+export {
+  testRunFrom,
+  verifyImpact,
+  verifyRun
+};

package/dist/chunk-IHXJ72XA.js

@@ -0,0 +1,31 @@
+// 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(lines) {
+  return lines > 0 ? `${ESC}[${lines}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));
+}
+
+export {
+  HIDE_CURSOR,
+  SHOW_CURSOR,
+  CLEAR_LINE,
+  SYNC_START,
+  SYNC_END,
+  cursorUp,
+  fitWidth
+};