@blzsky/variant 0.2.0

package/dist/chunk-GDSZFIHM.js

@@ -0,0 +1,29 @@
+// src/core/execution/concurrency.ts
+async function mapLimit(items, limit, fn, stopOnError = true) {
+  const results = new Array(items.length);
+  let next = 0;
+  let firstError = null;
+  let stopped = false;
+  const worker = async () => {
+    while (true) {
+      if (stopped) return;
+      const i = next++;
+      if (i >= items.length) return;
+      try {
+        results[i] = await fn(items[i], i);
+      } catch (err) {
+        if (firstError === null) firstError = err;
+        if (stopOnError) stopped = true;
+        return;
+      }
+    }
+  };
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workerCount }, worker));
+  if (firstError !== null) throw firstError;
+  return results;
+}
+
+export {
+  mapLimit
+};

package/dist/chunk-ISRF5F3Q.js

@@ -0,0 +1,68 @@
+import {
+  getColors
+} from "./chunk-YYGCSKIQ.js";
+import {
+  lines
+} from "./chunk-6J4XDG44.js";
+import {
+  getPrinter
+} from "./chunk-V22IPJ7A.js";
+
+// 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 {
+  renderInsights,
+  renderEnv
+};

package/dist/chunk-KSHWC2XN.js

@@ -0,0 +1,78 @@
+// src/core/graph/tsconfig-paths.ts
+import { access } from "fs/promises";
+import path from "path";
+var MAX_WILDCARDS = 1;
+function toPathAliases(cwd, paths, baseUrl) {
+  if (paths === void 0) return [];
+  const base = baseUrl ?? cwd;
+  const aliases = [];
+  for (const [pattern, rawTargets] of Object.entries(paths)) {
+    const stars = pattern.split("*").length - 1;
+    if (stars > MAX_WILDCARDS) continue;
+    const wildcard = stars === 1;
+    const [prefix = "", suffix = ""] = wildcard ? pattern.split("*") : [pattern, ""];
+    const targets = [];
+    for (const target of rawTargets) {
+      if (target.split("*").length - 1 > MAX_WILDCARDS) continue;
+      const absolute = path.resolve(base, target);
+      const relative = path.relative(cwd, absolute).replace(/\\/g, "/");
+      if (relative === "" || relative.startsWith("../")) continue;
+      targets.push(relative);
+    }
+    if (targets.length > 0) {
+      aliases.push({ prefix, suffix, wildcard, targets });
+    }
+  }
+  aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+  return aliases;
+}
+function matchPathAlias(spec, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (!alias.wildcard) {
+      if (spec === alias.prefix) bases.push(...alias.targets);
+      continue;
+    }
+    if (spec.length < alias.prefix.length + alias.suffix.length || !spec.startsWith(alias.prefix) || !spec.endsWith(alias.suffix)) {
+      continue;
+    }
+    const captured = spec.slice(
+      alias.prefix.length,
+      spec.length - alias.suffix.length
+    );
+    for (const target of alias.targets) {
+      bases.push(target.replace("*", captured));
+    }
+  }
+  return bases;
+}
+async function readPathAliases(cwd, tsconfigName = "tsconfig.json") {
+  const configPath = path.join(cwd, tsconfigName);
+  try {
+    await access(configPath);
+  } catch {
+    return [];
+  }
+  const { ts } = await import("ts-morph");
+  const read = ts.readConfigFile(configPath, (file) => ts.sys.readFile(file));
+  if (read.error !== void 0 || read.config === void 0) return [];
+  const parsed = ts.parseJsonConfigFileContent(
+    read.config,
+    {
+      ...ts.sys,
+      // Enumerating every file in the workspace is pure waste: only
+      // `compilerOptions` is wanted, and a large repo makes this the most
+      // expensive call in the command.
+      readDirectory: () => [],
+      useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames
+    },
+    cwd
+  );
+  return toPathAliases(cwd, parsed.options.paths, parsed.options.baseUrl);
+}
+
+export {
+  toPathAliases,
+  matchPathAlias,
+  readPathAliases
+};

package/dist/chunk-LJDDS4RR.js

@@ -0,0 +1,91 @@
+import {
+  collectExportedSurface,
+  significantText
+} from "./chunk-O4LZKXNZ.js";
+
+// src/core/semantic/differ.ts
+function createClassifier() {
+  let host;
+  let nextId = 0;
+  return async (input) => {
+    host ??= (async () => {
+      const tsm2 = await import("ts-morph");
+      return {
+        tsm: tsm2,
+        project: new tsm2.Project({ useInMemoryFileSystem: true })
+      };
+    })();
+    const { tsm, project } = await host;
+    const id = nextId++;
+    const beforeFile = project.createSourceFile(
+      `__before_${id}.ts`,
+      input.before,
+      { overwrite: true }
+    );
+    const afterFile = project.createSourceFile(
+      `__after_${id}.ts`,
+      input.after,
+      { overwrite: true }
+    );
+    try {
+      return compareSurfaces(input, beforeFile, afterFile, tsm);
+    } finally {
+      project.removeSourceFile(beforeFile);
+      project.removeSourceFile(afterFile);
+    }
+  };
+}
+var defaultClassifier;
+async function classifyChange(input) {
+  defaultClassifier ??= createClassifier();
+  return defaultClassifier(input);
+}
+function compareSurfaces(input, beforeFile, afterFile, tsm) {
+  const beforeApi = collectExportedSurface(beforeFile, tsm);
+  const afterApi = collectExportedSurface(afterFile, tsm);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, after] of afterApi.symbols) {
+    const before = beforeApi.symbols.get(name);
+    if (before === void 0) {
+      added.push(name);
+    } else if (before.signature !== after.signature) {
+      changed.push({
+        name,
+        kind: before.typeSpace && after.typeSpace ? "type" : "signature"
+      });
+    } else if (before.body !== after.body) {
+      changed.push({ name, kind: "body" });
+    }
+  }
+  for (const name of beforeApi.symbols.keys()) {
+    if (!afterApi.symbols.has(name)) removed.push(name);
+  }
+  const surfaceChanged = added.length > 0 || removed.length > 0 || changed.some((c) => c.kind !== "body");
+  let classification;
+  if (surfaceChanged) {
+    classification = "breaking";
+  } else if (changed.length > 0 || significantText(input.before, tsm) !== significantText(input.after, tsm)) {
+    classification = "internal";
+  } else {
+    classification = "non-impacting";
+  }
+  const confidenceNotes = [.../* @__PURE__ */ new Set([...beforeApi.notes, ...afterApi.notes])];
+  const confidence = Math.max(
+    0.3,
+    Math.round((1 - confidenceNotes.length * 0.15) * 100) / 100
+  );
+  return {
+    filePath: input.filePath,
+    classification,
+    exportedSymbols: { added, removed, changed },
+    confidence,
+    confidenceNotes
+  };
+}
+
+export {
+  createClassifier,
+  classifyChange
+};

package/dist/chunk-LXKLCLL6.js

@@ -0,0 +1,91 @@
+import {
+  CacheError
+} from "./chunk-RVXUCJYA.js";
+
+// src/core/cache/store.ts
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
+import path from "path";
+var CACHE_FILENAME = "cache.json";
+async function readCache(cacheDir) {
+  const filePath = path.join(cacheDir, CACHE_FILENAME);
+  try {
+    const raw = await readFile(filePath, "utf8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT") return { tasks: {} };
+    throw new CacheError(
+      `Failed to read cache at "${filePath}": ${String(err)}`,
+      { cause: err }
+    );
+  }
+}
+async function writeCache(cacheDir, cache) {
+  const filePath = path.join(cacheDir, CACHE_FILENAME);
+  const tempPath = temporaryPathFor(filePath);
+  try {
+    await mkdir(cacheDir, { recursive: true });
+    await writeFile(tempPath, JSON.stringify(cache));
+    await rename(tempPath, filePath);
+  } catch (err) {
+    await unlink(tempPath).catch(() => {
+    });
+    throw new CacheError(
+      `Failed to write cache to "${cacheDir}": ${String(err)}`,
+      { cause: err }
+    );
+  }
+}
+function writeCacheSync(cacheDir, cache) {
+  const filePath = path.join(cacheDir, CACHE_FILENAME);
+  const tempPath = temporaryPathFor(filePath);
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(tempPath, JSON.stringify(cache));
+    renameSync(tempPath, filePath);
+  } catch (err) {
+    try {
+      unlinkSync(tempPath);
+    } catch {
+    }
+    throw new CacheError(
+      `Failed to write cache to "${cacheDir}": ${String(err)}`,
+      { cause: err }
+    );
+  }
+}
+var temporaryCounter = 0;
+function temporaryPathFor(filePath) {
+  return `${filePath}.${process.pid}.${temporaryCounter++}.tmp`;
+}
+function evictStaleEntries(cache, ttlDays) {
+  const cutoff = Date.now() - ttlDays * 24 * 60 * 60 * 1e3;
+  const tasks = {};
+  for (const [name, entry] of Object.entries(cache.tasks)) {
+    if (entry.lastRun >= cutoff) {
+      tasks[name] = entry;
+    }
+  }
+  return { tasks };
+}
+
+// src/core/insight/analyzer.ts
+function computeInsights(results, cache) {
+  const totalDurationMs = results.reduce((sum, r) => sum + r.durationMs, 0);
+  const hits = results.filter((r) => r.cacheHit).length;
+  const cacheHitRate = results.length === 0 ? 0 : hits / results.length;
+  return {
+    lastRunResults: results,
+    cachedStats: cache.tasks,
+    totalDurationMs,
+    cacheHitRate
+  };
+}
+
+export {
+  readCache,
+  writeCache,
+  writeCacheSync,
+  evictStaleEntries,
+  computeInsights
+};

package/dist/chunk-MZZOE7L4.js

@@ -0,0 +1,26 @@
+import {
+  packageForFile
+} from "./chunk-3E5LBU3O.js";
+import {
+  listChangedFiles
+} from "./chunk-XUBWCTJZ.js";
+
+// src/core/cache/git-diff.ts
+import path from "path";
+async function getChangedFiles(options) {
+  const { cwd, baseRef = "HEAD~1" } = options;
+  return listChangedFiles(cwd, baseRef);
+}
+function changedFilesToPackages(files, graph, cwd) {
+  const out = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const owner = packageForFile(path.resolve(cwd, file), graph);
+    if (owner !== null) out.add(owner.name);
+  }
+  return out;
+}
+
+export {
+  getChangedFiles,
+  changedFilesToPackages
+};

package/dist/chunk-NSNZOH5P.js

@@ -0,0 +1,31 @@
+import {
+  classifyChange
+} from "./chunk-LJDDS4RR.js";
+import {
+  readFileAtRef
+} from "./chunk-XUBWCTJZ.js";
+
+// src/core/semantic/file-change.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var DEFAULT_DIFF_BASE_REF = "HEAD~1";
+function toWorkspaceRelative(cwd, filePath) {
+  return path.relative(cwd, path.resolve(cwd, filePath)).replace(/\\/g, "/");
+}
+async function classifyFileAgainstRef(cwd, relPath, baseRef) {
+  const [before, after] = await Promise.all([
+    readFileAtRef(cwd, baseRef, relPath),
+    readFile(path.resolve(cwd, relPath), "utf8").catch(() => null)
+  ]);
+  return classifyChange({
+    filePath: relPath,
+    before: before ?? "",
+    after: after ?? ""
+  });
+}
+
+export {
+  DEFAULT_DIFF_BASE_REF,
+  toWorkspaceRelative,
+  classifyFileAgainstRef
+};