@blzsky/variant 0.2.0

package/dist/chunk-SWPVR2DF.js

@@ -0,0 +1,468 @@
+import {
+  detectProject,
+  genericAdapter,
+  nextAdapter,
+  nextPlugin,
+  viteAdapter
+} from "./chunk-V5CTGXMM.js";
+import {
+  loadConfig
+} from "./chunk-RGD422OM.js";
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
+import {
+  changedFilesToPackages,
+  getChangedFiles
+} from "./chunk-MZZOE7L4.js";
+import {
+  computeAffectedPackages,
+  loadPackageGraph,
+  tasksFromPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  ConfigError,
+  CycleError
+} from "./chunk-RVXUCJYA.js";
+import {
+  errorLines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+
+// src/adapters/frameworks/plugin.ts
+var wrapFrameworkAsPlugin = (a) => ({
+  name: `framework:${a.name}`,
+  hooks: {
+    onDetect: async (ctx) => {
+      if (!await Promise.resolve(a.detect(ctx.cwd))) return;
+      ctx.framework = ctx.framework ?? a.name;
+      if (!ctx.tasks["dev"]?.command) {
+        ctx.tasks["dev"] = { ...ctx.tasks["dev"], command: a.devCommand() };
+      }
+      if (!ctx.tasks["build"]?.command) {
+        ctx.tasks["build"] = {
+          ...ctx.tasks["build"],
+          command: a.buildCommand()
+        };
+      }
+    }
+  }
+});
+
+// src/core/execution/scheduler.ts
+async function runScheduled(target, graph, runner, options) {
+  const levels = graph.toLevels(target);
+  const allTasks = levels.flat();
+  const remainingDeps = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const t of allTasks) {
+    remainingDeps.set(t, 0);
+    dependents.set(t, /* @__PURE__ */ new Set());
+  }
+  for (const t of allTasks) {
+    for (const dep of graph.getDependencies(t)) {
+      if (remainingDeps.has(dep)) {
+        remainingDeps.set(t, (remainingDeps.get(t) ?? 0) + 1);
+        dependents.get(dep)?.add(t);
+      }
+    }
+  }
+  const priorityOf = options.priorityOf ?? (() => 0);
+  const ready = [];
+  for (const [t, n] of remainingDeps) {
+    if (n === 0) ready.push(t);
+  }
+  ready.sort((a, b) => priorityOf(a) - priorityOf(b));
+  let inFlight = 0;
+  let firstError = null;
+  return new Promise((resolve, reject) => {
+    const tryDrain = () => {
+      if (firstError !== null && inFlight === 0) {
+        reject(firstError);
+        return;
+      }
+      while (firstError === null && inFlight < options.concurrency && ready.length > 0) {
+        const next = ready.shift();
+        if (next === void 0) continue;
+        inFlight++;
+        runner(next).then(() => {
+          for (const dep of dependents.get(next) ?? []) {
+            const left = (remainingDeps.get(dep) ?? 0) - 1;
+            remainingDeps.set(dep, left);
+            if (left === 0) {
+              insertSorted(ready, dep, priorityOf);
+            }
+          }
+        }).catch((err) => {
+          if (firstError === null) firstError = err;
+        }).finally(() => {
+          inFlight--;
+          if (ready.length === 0 && inFlight === 0 && [...remainingDeps.values()].every((n) => n <= 0)) {
+            firstError === null ? resolve() : reject(firstError);
+            return;
+          }
+          tryDrain();
+        });
+      }
+    };
+    tryDrain();
+  });
+}
+function priorityFromConfig(config, tasks) {
+  const policy = config.scheduler?.policy;
+  if (policy === "light-first") {
+    return (task) => tasks[task]?.cpuHeavy ? 1 : 0;
+  }
+  if (policy === "pack-heavy") {
+    return (task) => tasks[task]?.cpuHeavy ? 0 : 1;
+  }
+  return void 0;
+}
+function insertSorted(arr, item, priorityOf) {
+  const p = priorityOf(item);
+  let lo = 0;
+  let hi = arr.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const midTask = arr[mid];
+    if (midTask === void 0 || priorityOf(midTask) <= p) lo = mid + 1;
+    else hi = mid;
+  }
+  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 = () => {
+};
+var PluginRegistry = class {
+  plugins = [];
+  onError;
+  constructor(onError = swallowErrors) {
+    this.onError = onError;
+  }
+  register(plugin) {
+    this.plugins.push(plugin);
+  }
+  list() {
+    return this.plugins;
+  }
+  async runOnDetect(ctx) {
+    for (const p of this.plugins) {
+      const hook = p.hooks?.onDetect;
+      if (!hook) continue;
+      try {
+        await hook(ctx);
+      } catch (err) {
+        this.onError(err, p.name, "onDetect");
+      }
+    }
+  }
+  /**
+   * Extra hash inputs from every plugin, deduped and sorted so the cache key
+   * does not depend on plugin registration order.
+   */
+  async runOnHash(task, files) {
+    const acc = /* @__PURE__ */ new Set();
+    for (const p of this.plugins) {
+      const hook = p.hooks?.onHash;
+      if (!hook) continue;
+      try {
+        const out = await hook(task, Array.from(files));
+        if (Array.isArray(out)) for (const v of out) acc.add(v);
+      } catch (err) {
+        this.onError(err, p.name, "onHash", task);
+      }
+    }
+    return [...acc].sort();
+  }
+  /**
+   * True when the task should be skipped. One plugin vetoing is enough — a
+   * plugin that knows the work is unnecessary is not outvoted by plugins
+   * that merely have no opinion.
+   */
+  async runOnBeforeExecute(task) {
+    let skip = false;
+    for (const p of this.plugins) {
+      const hook = p.hooks?.onBeforeExecute;
+      if (!hook) continue;
+      try {
+        const out = await hook(task);
+        if (out === false) skip = true;
+      } catch (err) {
+        this.onError(err, p.name, "onBeforeExecute", task);
+      }
+    }
+    return skip;
+  }
+  async runOnAfterExecute(task, result) {
+    for (const p of this.plugins) {
+      const hook = p.hooks?.onAfterExecute;
+      if (!hook) continue;
+      try {
+        await hook(task, result);
+      } catch (err) {
+        this.onError(err, p.name, "onAfterExecute", task);
+      }
+    }
+  }
+};
+
+// src/core/provenance/capture.ts
+function packageOfTask(taskId) {
+  const separator = taskId.lastIndexOf(":");
+  return separator === -1 ? void 0 : taskId.slice(0, separator);
+}
+function isAlwaysRun(strategy, task) {
+  return strategy === "strict" || (task.inputs?.length ?? 0) === 0;
+}
+function isDirty(taskId, affected) {
+  if (affected === void 0) return true;
+  const owner = packageOfTask(taskId);
+  return owner === void 0 || affected.has(owner);
+}
+function reverseAdjacency(tasks, graph) {
+  const dependents = /* @__PURE__ */ new Map();
+  for (const taskId of Object.keys(tasks)) {
+    for (const upstream of graph.getDependencies(taskId)) {
+      const existing = dependents.get(upstream);
+      if (existing === void 0) dependents.set(upstream, [taskId]);
+      else existing.push(taskId);
+    }
+  }
+  return dependents;
+}
+function seedReason(taskId, input) {
+  const task = input.tasks[taskId] ?? {};
+  if (isAlwaysRun(input.strategy, task)) return { kind: "always" };
+  return { kind: "affected-by", changedFiles: [...input.changedFiles ?? []] };
+}
+function buildProvenance(input) {
+  const dependents = reverseAdjacency(input.tasks, input.graph);
+  const provenance = /* @__PURE__ */ new Map();
+  for (const taskId of Object.keys(input.tasks)) {
+    provenance.set(taskId, {
+      taskId,
+      reason: seedReason(taskId, input),
+      // Sorted so a reason block never reorders between identical runs.
+      dirtyDependents: (dependents.get(taskId) ?? []).filter((dependent) => isDirty(dependent, input.affectedPackages)).sort(),
+      upstreamTasks: [...input.graph.getDependencies(taskId)].sort()
+    });
+  }
+  return provenance;
+}
+function recordCacheMiss(provenance, taskId, expectedHash, actualHash) {
+  const existing = provenance?.get(taskId);
+  if (existing === void 0) return;
+  existing.reason = { kind: "cache-miss", expectedHash, actualHash };
+}
+
+// src/cli/render/plugin-errors.ts
+var reportPluginError = (err, pluginName, hook, task) => {
+  const colors = getColors();
+  const where = task ? `${pluginName}.${hook} (${task})` : `${pluginName}.${hook}`;
+  const detail = err instanceof Error ? err.message : String(err);
+  errorLines(
+    getPrinter(),
+    `${colors.yellow("[variant plugin]")} ${where} threw: ${detail}`
+  );
+};
+
+// src/cli/context.ts
+var EMPTY_PACKAGE_GRAPH = {
+  packages: [],
+  edges: /* @__PURE__ */ new Map()
+};
+async function createContext(cwd = process.cwd(), options = {}) {
+  const [rawConfig, { pm, runtime, framework }] = await Promise.all([
+    loadConfig(cwd),
+    detectProject(cwd)
+  ]);
+  const workspaceEnabled = rawConfig.workspace?.enabled === true;
+  const scopeEnabled = options.scope !== false && rawConfig.git?.enabled !== false;
+  const packageGraphPromise = workspaceEnabled ? loadPackageGraph(cwd) : scopeEnabled ? loadPackageGraph(cwd).catch(() => EMPTY_PACKAGE_GRAPH) : void 0;
+  const changedFilesPromise = scopeEnabled ? getChangedFiles(
+    rawConfig.git?.baseRef === void 0 ? { cwd } : { cwd, baseRef: rawConfig.git.baseRef }
+  ) : void 0;
+  const [pkgGraph, gitFiles] = await Promise.all([
+    packageGraphPromise,
+    changedFilesPromise
+  ]);
+  let config = rawConfig;
+  if (workspaceEnabled && pkgGraph !== void 0) {
+    config = {
+      ...config,
+      tasks: tasksFromPackageGraph(
+        pkgGraph,
+        config.tasks,
+        config.workspace?.scripts,
+        pm.name
+      )
+    };
+  }
+  let packageScopes;
+  let affectedPackages;
+  let changedFiles;
+  if (gitFiles != null) {
+    changedFiles = gitFiles;
+    const graph2 = pkgGraph ?? EMPTY_PACKAGE_GRAPH;
+    const changed = changedFilesToPackages(gitFiles, graph2, cwd);
+    if (changed.size > 0) {
+      const affected = computeAffectedPackages(changed, graph2);
+      packageScopes = graph2.packages.filter((p) => affected.has(p.name)).map((p) => p.dir);
+      affectedPackages = affected;
+    }
+  }
+  const cacheDir = config.cache.directory;
+  const plugins = new PluginRegistry(reportPluginError);
+  plugins.register(wrapFrameworkAsPlugin(nextAdapter));
+  plugins.register(wrapFrameworkAsPlugin(viteAdapter));
+  plugins.register(wrapFrameworkAsPlugin(genericAdapter));
+  plugins.register(nextPlugin);
+  await plugins.runOnDetect({
+    cwd,
+    pm: pm.name,
+    framework: framework?.name ?? null,
+    tasks: config.tasks
+  });
+  const graph = buildGraph(config);
+  const provenance = buildProvenance({
+    tasks: config.tasks,
+    graph,
+    strategy: config.strategy,
+    ...changedFiles !== void 0 ? { changedFiles } : {},
+    ...affectedPackages !== void 0 ? { affectedPackages } : {}
+  });
+  return {
+    cwd,
+    config,
+    pm: pm.name,
+    runtime: { primary: runtime.name, fallback: "node" },
+    framework: framework?.name ?? null,
+    graph,
+    cacheDir,
+    plugins,
+    provenance,
+    ...packageScopes !== void 0 ? { packageScopes } : {},
+    ...affectedPackages !== void 0 ? { affectedPackages } : {}
+  };
+}
+function toRunOptions(ctx, overrides = {}) {
+  const schedulerEnabled = ctx.config.scheduler?.policy !== void 0;
+  const derivedPriorityOf = schedulerEnabled ? priorityFromConfig(ctx.config, ctx.config.tasks) : void 0;
+  return {
+    cwd: ctx.cwd,
+    cacheDir: ctx.cacheDir,
+    pm: ctx.pm,
+    config: ctx.config,
+    tasks: ctx.config.tasks,
+    plugins: ctx.plugins,
+    provenance: ctx.provenance,
+    ...ctx.packageScopes !== void 0 ? { packageScopes: ctx.packageScopes } : {},
+    ...schedulerEnabled ? { useScheduler: true } : {},
+    ...derivedPriorityOf !== void 0 ? { priorityOf: derivedPriorityOf } : {},
+    ...overrides.concurrency !== void 0 ? { concurrency: overrides.concurrency } : {}
+  };
+}
+
+export {
+  runScheduled,
+  recordCacheMiss,
+  createContext,
+  toRunOptions
+};

package/dist/chunk-V22IPJ7A.js

@@ -0,0 +1,64 @@
+// src/cli/visuals/printer.ts
+var Printer = class _Printer {
+  mode;
+  out;
+  err;
+  constructor(mode, streams = {}) {
+    this.mode = mode;
+    this.out = streams.stdout ?? process.stdout;
+    this.err = streams.stderr ?? process.stderr;
+  }
+  static fromFlags(flags = {}, streams) {
+    const quiet = flags.quiet ?? 0;
+    const verbose = flags.verbose ?? 0;
+    if (quiet === 1) return new _Printer("quiet", streams);
+    if (quiet > 1) return new _Printer("silent", streams);
+    if (verbose > 0) return new _Printer("verbose", streams);
+    if (flags.noProgress) return new _Printer("no-progress", streams);
+    return new _Printer("default", streams);
+  }
+  get stdoutEnabled() {
+    return this.mode !== "silent" && this.mode !== "quiet";
+  }
+  get stderrEnabled() {
+    return this.mode !== "silent" && this.mode !== "quiet";
+  }
+  /**
+   * Whether animated progress may draw: only in default mode on a TTY.
+   * Verbose hides bars so they don't interleave with debug logs, and
+   * `VARIANT_TEST_NO_CLI_PROGRESS` suppresses them because concurrent bar
+   * output is non-deterministic and breaks snapshot tests.
+   */
+  get progressEnabled() {
+    if (this.mode !== "default" || this.err.isTTY !== true) return false;
+    const testFlag = process.env["VARIANT_TEST_NO_CLI_PROGRESS"];
+    return testFlag === void 0 || testFlag === "";
+  }
+  /** The raw stderr sink, for renderers that manage their own ANSI drawing. */
+  get progressStream() {
+    return this.err;
+  }
+  stdout(text) {
+    if (this.stdoutEnabled) this.out.write(text);
+  }
+  stderr(text) {
+    if (this.stderrEnabled) this.err.write(text);
+  }
+  /** Write a debug line, shown only in verbose mode. */
+  debug(text) {
+    if (this.mode === "verbose") this.err.write(text);
+  }
+};
+var globalPrinter = new Printer("default");
+function setGlobalPrinter(printer) {
+  globalPrinter = printer;
+}
+function getPrinter() {
+  return globalPrinter;
+}
+
+export {
+  Printer,
+  setGlobalPrinter,
+  getPrinter
+};