@blzsky/variant 0.2.0 → 0.3.0-canary.0

package/dist/chunk-IFFZ46YS.js

@@ -0,0 +1,575 @@
+import {
+  loadPackageGraph
+} from "./chunk-3E5LBU3O.js";
+import {
+  aliasesInScope,
+  exportsCandidates,
+  matchPathAlias,
+  readPathAliases
+} from "./chunk-X3VVGTEV.js";
+import {
+  updateSymbolGraph
+} from "./chunk-NFFXYYM6.js";
+
+// src/core/graph/workspace-audit.ts
+import { readFile } from "fs/promises";
+import path3 from "path";
+
+// src/core/graph/workspace-check.ts
+import { builtinModules } from "module";
+import path2 from "path";
+
+// src/core/graph/import-graph.ts
+import path from "path";
+var TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".jsx"]);
+var JS_TO_TS = {
+  ".js": [".ts", ".tsx"],
+  ".mjs": [".mts"],
+  ".cjs": [".cts"],
+  ".jsx": [".tsx"]
+};
+function buildImportGraph(symbolGraph, options = {}) {
+  const files = new Set(Object.keys(symbolGraph.files));
+  const packageDirs = options.packageDirs ?? {};
+  const allAliases = options.pathAliases ?? [];
+  const packageExports = options.packageExports ?? {};
+  const imports = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  const externals = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Map();
+  const edges = /* @__PURE__ */ new Map();
+  const computed = /* @__PURE__ */ new Set();
+  const unresolvedTargets = /* @__PURE__ */ new Map();
+  const patternTargets = /* @__PURE__ */ new Map();
+  const sortedFiles = [...files].sort();
+  for (const file of sortedFiles) {
+    imports.set(file, /* @__PURE__ */ new Set());
+    dependents.set(file, /* @__PURE__ */ new Set());
+    externals.set(file, /* @__PURE__ */ new Set());
+    unresolved.set(file, /* @__PURE__ */ new Set());
+    edges.set(file, /* @__PURE__ */ new Map());
+  }
+  const addEdge = (from, to, imp) => {
+    imports.get(from)?.add(to);
+    const perFile = edges.get(from);
+    if (perFile === void 0) return;
+    let edge = perFile.get(to);
+    if (edge === void 0) {
+      edge = { names: /* @__PURE__ */ new Set(), typeOnly: true, dynamic: false };
+      perFile.set(to, edge);
+    }
+    for (const name of imp.names) edge.names.add(name);
+    if (imp.kind === "dynamic" || imp.kind === "pattern") edge.dynamic = true;
+    edge.typeOnly = edge.typeOnly && imp.typeOnly;
+  };
+  const addUnresolved = (from, spec, bases) => {
+    unresolved.get(from)?.add(spec);
+    for (const base of bases) {
+      for (const key of unresolvedKeys(base))
+        addTo(unresolvedTargets, key, from);
+    }
+  };
+  for (const file of sortedFiles) {
+    const index = symbolGraph.files[file];
+    if (index === void 0) continue;
+    const pathAliases = aliasesInScope(file, allAliases);
+    for (const imp of index.imports) {
+      const spec = imp.module;
+      if (imp.kind === "pattern") {
+        const bases = patternBases(file, spec, packageDirs, pathAliases);
+        if (bases === void 0) {
+          computed.add(file);
+          continue;
+        }
+        for (const base of bases) addTo(patternTargets, base, file);
+        for (const target of sortedFiles) {
+          if (target !== file && bases.some((b) => target.startsWith(b))) {
+            addEdge(file, target, imp);
+          }
+        }
+        continue;
+      }
+      if (isRelativeSpecifier(spec)) {
+        const resolved = resolveRelativeImport(file, spec, files);
+        if (resolved !== void 0) {
+          addEdge(file, resolved, imp);
+          continue;
+        }
+        addUnresolved(file, spec, [
+          path.posix.join(path.posix.dirname(file), spec)
+        ]);
+        continue;
+      }
+      if (spec.startsWith("node:")) {
+        externals.get(file)?.add(spec);
+        continue;
+      }
+      const pkg = matchWorkspacePackage(spec, packageDirs);
+      if (pkg !== void 0) {
+        const resolved = resolvePackageImport(
+          pkg.dir,
+          pkg.subpath,
+          files,
+          packageExports[pkg.name]
+        );
+        if (resolved !== void 0) {
+          addEdge(file, resolved, imp);
+          continue;
+        }
+        addUnresolved(
+          file,
+          spec,
+          pkg.subpath === "" ? [pkg.dir] : [
+            path.posix.join(pkg.dir, pkg.subpath),
+            path.posix.join(pkg.dir, "src", pkg.subpath)
+          ]
+        );
+        continue;
+      }
+      const aliased = resolveAliasImport(spec, pathAliases, files);
+      if (aliased !== void 0) {
+        addEdge(file, aliased, imp);
+        continue;
+      }
+      const aliasBases = matchPathAlias(spec, pathAliases);
+      if (aliasBases.length > 0) {
+        addUnresolved(file, spec, aliasBases);
+        continue;
+      }
+      if (spec.startsWith("#")) {
+        addUnresolved(file, spec, []);
+        continue;
+      }
+      externals.get(file)?.add(spec);
+    }
+  }
+  for (const [file, targets] of imports) {
+    for (const target of targets) {
+      dependents.get(target)?.add(file);
+    }
+  }
+  return {
+    imports,
+    dependents,
+    externals,
+    unresolved,
+    edges,
+    computed,
+    unresolvedTargets,
+    patternTargets
+  };
+}
+function importersOfUnindexed(graph, file) {
+  const target = toPosix(file);
+  const stem = stripSourceExtension(target);
+  const keys = [target, stem];
+  if (path.posix.basename(stem) === "index") {
+    keys.push(path.posix.dirname(stem));
+  }
+  const importers = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    for (const importer of graph.unresolvedTargets.get(key) ?? []) {
+      importers.add(importer);
+    }
+  }
+  for (const [prefix, loaders] of graph.patternTargets) {
+    if (!target.startsWith(prefix)) continue;
+    for (const loader of loaders) importers.add(loader);
+  }
+  return importers;
+}
+function unresolvedKeys(base) {
+  const ext = path.posix.extname(base);
+  return JS_EXTENSIONS.has(ext) ? [base, base.slice(0, -ext.length)] : [base];
+}
+function stripSourceExtension(file) {
+  const declaration = /\.d\.[cm]?ts$/.exec(file);
+  if (declaration !== null) return file.slice(0, declaration.index);
+  const ext = path.posix.extname(file);
+  return ext === "" ? file : file.slice(0, -ext.length);
+}
+function addTo(map, key, value) {
+  let set = map.get(key);
+  if (set === void 0) {
+    set = /* @__PURE__ */ new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+function computeAffectedFiles(changed, graph) {
+  const affected = /* @__PURE__ */ new Set();
+  for (const file of changed) affected.add(toPosix(file));
+  let frontier = new Set(affected);
+  while (frontier.size > 0) {
+    const next = /* @__PURE__ */ new Set();
+    for (const file of frontier) {
+      for (const dependent of graph.dependents.get(file) ?? []) {
+        if (!affected.has(dependent)) {
+          affected.add(dependent);
+          next.add(dependent);
+        }
+      }
+    }
+    frontier = next;
+  }
+  return affected;
+}
+function resolveRelativeImport(fromFile, spec, files) {
+  const base = path.posix.normalize(
+    path.posix.join(path.posix.dirname(fromFile), spec)
+  );
+  if (base === ".." || base.startsWith("../")) return void 0;
+  return firstExisting(candidatePaths(base === "." ? "index" : base), files);
+}
+function isRelativeSpecifier(spec) {
+  return spec === "." || spec === ".." || spec.startsWith("./") || spec.startsWith("../");
+}
+function patternBases(fromFile, prefix, packageDirs, aliases) {
+  if (prefix === "") return void 0;
+  if (prefix.startsWith(".")) {
+    const base = path.posix.join(path.posix.dirname(fromFile), prefix);
+    return [base === "." || base === "./" ? "" : base];
+  }
+  if (prefix.startsWith("node:")) return [];
+  const bases = [];
+  for (const [name, dir] of Object.entries(packageDirs)) {
+    if (prefix.startsWith(`${name}/`) || name.startsWith(prefix)) {
+      bases.push(`${toPosix(dir)}/`);
+    }
+  }
+  for (const alias of aliases) {
+    for (const target of alias.targets) {
+      const targetStem = alias.wildcard ? target.slice(0, target.indexOf("*")) : target;
+      if (alias.wildcard && prefix.startsWith(alias.prefix)) {
+        bases.push(targetStem + prefix.slice(alias.prefix.length));
+      } else if (alias.prefix.startsWith(prefix)) {
+        bases.push(targetStem);
+      }
+    }
+  }
+  if (bases.length > 0) return bases;
+  const segments = prefix.split("/");
+  const nameLength = prefix.startsWith("@") ? 2 : 1;
+  return segments.length > nameLength ? [] : void 0;
+}
+function resolvePackageImport(pkgDir, subpath, files, exportsField) {
+  const fromExports = exportsCandidates(exportsField, subpath);
+  const candidates = fromExports.flatMap(
+    (base) => candidatePaths(path.posix.join(pkgDir, base))
+  );
+  if (subpath === "") {
+    candidates.push(
+      ...candidatePaths(`${pkgDir}/src/index`),
+      ...candidatePaths(`${pkgDir}/index`)
+    );
+  } else {
+    candidates.push(
+      ...candidatePaths(path.posix.join(pkgDir, subpath)),
+      ...candidatePaths(path.posix.join(pkgDir, "src", subpath))
+    );
+  }
+  return firstExisting(candidates, files);
+}
+function resolveAliasImport(spec, aliases, files) {
+  for (const base of matchPathAlias(spec, aliases)) {
+    const resolved = firstExisting(candidatePaths(base), files);
+    if (resolved !== void 0) return resolved;
+  }
+  return void 0;
+}
+function matchWorkspacePackage(spec, packageDirs) {
+  const segments = spec.split("/");
+  const nameLength = spec.startsWith("@") ? 2 : 1;
+  if (segments.length < nameLength) return void 0;
+  const name = segments.slice(0, nameLength).join("/");
+  const dir = packageDirs[name];
+  if (dir === void 0) return void 0;
+  return {
+    name,
+    dir: toPosix(dir),
+    subpath: segments.slice(nameLength).join("/")
+  };
+}
+function candidatePaths(base) {
+  const ext = path.posix.extname(base);
+  if (TS_EXTENSIONS.includes(ext)) {
+    return [base];
+  }
+  const tsExts = JS_TO_TS[ext];
+  if (tsExts !== void 0) {
+    const stem = base.slice(0, -ext.length);
+    return [...tsExts.map((e) => stem + e), base];
+  }
+  const extensions = [...TS_EXTENSIONS, ...JS_EXTENSIONS];
+  return [
+    ...extensions.map((e) => base + e),
+    ...extensions.map((e) => `${base}/index${e}`)
+  ];
+}
+function firstExisting(candidates, files) {
+  for (const c of candidates) {
+    if (files.has(c)) return c;
+  }
+  return void 0;
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// src/core/graph/workspace-check.ts
+var BUILTINS = new Set(builtinModules);
+function checkWorkspace(input) {
+  const { symbolGraph, packages } = input;
+  const rootDeclared = input.rootDeclared ?? /* @__PURE__ */ new Set();
+  const byName = new Map(packages.map((p) => [p.name, p]));
+  const files = new Set(Object.keys(symbolGraph.files));
+  const grouped = /* @__PURE__ */ new Map();
+  const addViolation = (kind, pkg, target, file) => {
+    const key = `${kind}|${pkg}|${target}`;
+    let violation = grouped.get(key);
+    if (violation === void 0) {
+      violation = { kind, package: pkg, target, files: [] };
+      grouped.set(key, violation);
+    }
+    if (!violation.files.includes(file)) violation.files.push(file);
+  };
+  for (const file of [...files].sort()) {
+    const owner = fileToPackage(file, packages);
+    if (owner === void 0) continue;
+    const aliases = aliasesInScope(file, input.pathAliases ?? []);
+    const nested = nestedManifests(file, owner.dir, input.manifests);
+    const declares = (name) => owner.declared.has(name) || nested.some((manifest) => name in allDependencies(manifest));
+    const isSelf = (name) => name === owner.name || nested.some((manifest) => manifest.name === name);
+    for (const imp of symbolGraph.files[file]?.imports ?? []) {
+      if (imp.kind === "pattern") continue;
+      const spec = imp.module;
+      if (isRelativeSpecifier(spec)) {
+        const target = resolveRelativeImport(file, spec, files);
+        if (target === void 0) continue;
+        const targetOwner = fileToPackage(target, packages);
+        if (targetOwner !== void 0 && targetOwner.name !== owner.name) {
+          addViolation(
+            "cross-package-relative-import",
+            owner.name,
+            targetOwner.name,
+            file
+          );
+        }
+        continue;
+      }
+      if (matchPathAlias(spec, aliases).length > 0) {
+        const target = resolveAliasImport(spec, aliases, files);
+        const targetOwner = target === void 0 ? void 0 : fileToPackage(target, packages);
+        if (targetOwner !== void 0 && targetOwner.name !== owner.name && !owner.declared.has(targetOwner.name)) {
+          addViolation(
+            "undeclared-workspace-dep",
+            owner.name,
+            targetOwner.name,
+            file
+          );
+        }
+        continue;
+      }
+      if (spec.startsWith("#")) continue;
+      const name = packageNameOf(stripNodePrefix(spec));
+      if (name === void 0 || BUILTINS.has(name)) continue;
+      if (spec.startsWith("node:") || isSelf(name)) continue;
+      if (byName.has(name)) {
+        if (!declares(name)) {
+          addViolation("undeclared-workspace-dep", owner.name, name, file);
+        }
+        continue;
+      }
+      if (declares(name) || rootDeclared.has(name)) continue;
+      const types = typesPackageOf(name);
+      if (imp.typeOnly && (declares(types) || rootDeclared.has(types))) {
+        continue;
+      }
+      addViolation("undeclared-external-dep", owner.name, name, file);
+    }
+  }
+  const violations = [...grouped.values()].map((v) => ({ ...v, files: [...v.files].sort() })).sort(
+    (a, b) => a.package.localeCompare(b.package) || a.target.localeCompare(b.target) || a.kind.localeCompare(b.kind)
+  );
+  return { packagesChecked: packages.length, violations };
+}
+function fileToPackage(file, packages) {
+  let best;
+  let bestLength = -1;
+  for (const pkg of packages) {
+    const prefix = pkg.dir === "" ? "" : `${pkg.dir}/`;
+    if (file.startsWith(prefix) && prefix.length > bestLength) {
+      best = pkg;
+      bestLength = prefix.length;
+    }
+  }
+  return best;
+}
+function nestedManifests(file, ownerDir, manifests) {
+  if (manifests === void 0) return [];
+  const found = [];
+  let dir = path2.posix.dirname(file);
+  while (dir !== ownerDir && dir !== "." && dir !== "/" && dir !== "") {
+    const manifest = manifests.get(dir);
+    if (manifest !== void 0) found.push(manifest);
+    dir = path2.posix.dirname(dir);
+  }
+  return found;
+}
+function typesPackageOf(name) {
+  return `@types/${name.startsWith("@") ? name.slice(1).replace("/", "__") : name}`;
+}
+function packageNameOf(spec) {
+  const segments = spec.split("/");
+  const nameLength = spec.startsWith("@") ? 2 : 1;
+  if (segments.length < nameLength) return void 0;
+  const name = segments.slice(0, nameLength).join("/");
+  return name === "" ? void 0 : name;
+}
+function stripNodePrefix(spec) {
+  return spec.startsWith("node:") ? spec.slice(5) : spec;
+}
+var LOCAL_PROTOCOL = /^(?:workspace|link|file|portal):/;
+var MAX_NOTE_NAMES = 3;
+function workspaceBlindSpots(input) {
+  const { packageNames, manifests } = input;
+  const root = manifests.get("") ?? {};
+  const rootDeclared = new Set(Object.keys(allDependencies(root)));
+  const notes = [];
+  const missingLocal = /* @__PURE__ */ new Set();
+  for (const [dir, manifest] of manifests) {
+    const member = dir === "" || manifest.name !== void 0 && packageNames.has(manifest.name);
+    if (!member) continue;
+    for (const [name, range] of Object.entries(allDependencies(manifest))) {
+      if (LOCAL_PROTOCOL.test(range) && !packageNames.has(name)) {
+        missingLocal.add(name);
+      }
+    }
+  }
+  if (missingLocal.size > 0) {
+    const one = missingLocal.size === 1;
+    notes.push(
+      `${missingLocal.size} ${one ? "dependency" : "dependencies"} declared with a local protocol ${one ? "is not a workspace package" : "are not workspace packages"} variant found (${listNames(missingLocal)}); imports of ${one ? "it" : "them"} count as external, so a change to ${one ? "it" : "them"} reaches no importer`
+    );
+  }
+  const undeclared = /* @__PURE__ */ new Set();
+  for (const [file, specs] of input.externals) {
+    const nearest = nearestManifest(file, manifests) ?? root;
+    const declared = allDependencies(nearest);
+    for (const spec of specs) {
+      if (spec.includes(":")) continue;
+      const name = packageNameOf(spec);
+      if (name === void 0 || BUILTINS.has(name)) continue;
+      if (name === nearest.name || packageNames.has(name)) continue;
+      if (name in declared || rootDeclared.has(name)) continue;
+      if (!missingLocal.has(name)) undeclared.add(name);
+    }
+  }
+  if (undeclared.size > 0) {
+    const one = undeclared.size === 1;
+    notes.push(
+      `${undeclared.size} bare import ${one ? "name is" : "names are"} neither workspace packages nor declared dependencies (${listNames(undeclared)}); if one is a workspace package variant did not find, or a tsconfig alias it did not read, a change behind it reaches no test`
+    );
+  }
+  const undiscovered = /* @__PURE__ */ new Map();
+  for (const [dir, manifest] of manifests) {
+    if (manifest.name !== void 0 && missingLocal.has(manifest.name)) {
+      undiscovered.set(manifest.name, dir);
+    }
+  }
+  return { notes, undiscovered };
+}
+function nearestManifest(file, manifests) {
+  let dir = path2.posix.dirname(file);
+  while (true) {
+    const manifest = manifests.get(dir === "." ? "" : dir);
+    if (manifest !== void 0) return manifest;
+    if (dir === "." || dir === "/" || dir === "") return void 0;
+    dir = path2.posix.dirname(dir);
+  }
+}
+function allDependencies(manifest) {
+  return {
+    ...manifest.dependencies ?? {},
+    ...manifest.devDependencies ?? {},
+    ...manifest.peerDependencies ?? {},
+    ...manifest.optionalDependencies ?? {}
+  };
+}
+function listNames(names) {
+  const sorted = [...names].sort();
+  return sorted.length > MAX_NOTE_NAMES ? `${sorted.slice(0, MAX_NOTE_NAMES).join(", ")}, \u2026 ${sorted.length - MAX_NOTE_NAMES} more` : sorted.join(", ");
+}
+
+// src/core/graph/workspace-audit.ts
+function declaredNames(manifest) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(manifest.dependencies ?? {}),
+    ...Object.keys(manifest.devDependencies ?? {}),
+    ...Object.keys(manifest.peerDependencies ?? {})
+  ]);
+}
+async function readRootDeclared(cwd) {
+  try {
+    const manifest = JSON.parse(
+      await readFile(path3.join(cwd, "package.json"), "utf8")
+    );
+    return declaredNames(manifest);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function readManifests(cwd) {
+  const fg = (await import("fast-glob")).default;
+  const found = await fg("**/package.json", {
+    cwd,
+    onlyFiles: true,
+    ignore: ["**/node_modules/**", ".git/**", ".variant/**"]
+  });
+  const entries = await Promise.all(
+    found.map(async (rel) => {
+      try {
+        const manifest = JSON.parse(
+          await readFile(path3.join(cwd, rel), "utf8")
+        );
+        const dir = path3.posix.dirname(rel.replace(/\\/g, "/"));
+        return [dir === "." ? "" : dir, manifest];
+      } catch {
+        return void 0;
+      }
+    })
+  );
+  return new Map(entries.filter((entry) => entry !== void 0));
+}
+async function auditWorkspace(cwd) {
+  const packageGraph = await loadPackageGraph(cwd).catch(() => null);
+  if (packageGraph === null || packageGraph.packages.length === 0) return null;
+  const packages = packageGraph.packages.map((pkg) => ({
+    name: pkg.manifest.name,
+    dir: path3.relative(cwd, pkg.dir).replace(/\\/g, "/"),
+    declared: declaredNames(pkg.manifest)
+  }));
+  const [{ graph: symbolGraph }, rootDeclared, pathAliases, manifests] = await Promise.all([
+    updateSymbolGraph(cwd),
+    readRootDeclared(cwd),
+    readPathAliases(cwd),
+    readManifests(cwd)
+  ]);
+  return checkWorkspace({
+    symbolGraph,
+    packages,
+    rootDeclared,
+    pathAliases,
+    manifests
+  });
+}
+
+export {
+  buildImportGraph,
+  importersOfUnindexed,
+  computeAffectedFiles,
+  workspaceBlindSpots,
+  readManifests,
+  auditWorkspace
+};

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
+};