@blzsky/variant 0.2.0

package/dist/chunk-V5CTGXMM.js

@@ -0,0 +1,256 @@
+// src/adapters/frameworks/generic.ts
+var genericAdapter = {
+  name: "generic",
+  detect(_cwd) {
+    return true;
+  },
+  devCommand() {
+    return "dev";
+  },
+  buildCommand() {
+    return "build";
+  }
+};
+
+// src/adapters/frameworks/next.ts
+import { readdir, readFile, stat } from "fs/promises";
+import path from "path";
+var nextAdapter = {
+  name: "next",
+  async detect(cwd) {
+    const pkgPath = path.join(cwd, "package.json");
+    try {
+      const json = JSON.parse(await readFile(pkgPath, "utf8"));
+      const deps = json["dependencies"];
+      const devDeps = json["devDependencies"];
+      const peerDeps = json["peerDependencies"];
+      return Boolean(deps?.["next"] || devDeps?.["next"] || peerDeps?.["next"]);
+    } catch {
+      return false;
+    }
+  },
+  devCommand: () => "next dev",
+  buildCommand: () => "next build"
+};
+var nextPlugin = {
+  name: "next",
+  hooks: {
+    async onDetect(ctx) {
+      const apps = await findNextApps(ctx.cwd);
+      for (const app of apps) {
+        const taskName = `${app}:build`;
+        if (!ctx.tasks[taskName]) {
+          ctx.tasks[taskName] = {
+            command: `${ctx.pm} --filter ${app} run build`,
+            inputs: [`apps/${app}/**/*.{ts,tsx,js,jsx,json,css}`]
+          };
+        }
+      }
+    }
+  }
+};
+async function findNextApps(cwd) {
+  const appsDir = path.join(cwd, "apps");
+  try {
+    const dirs = await readdir(appsDir, { withFileTypes: true });
+    const out = [];
+    for (const d of dirs) {
+      if (!d.isDirectory()) continue;
+      const cfg = path.join(appsDir, d.name, "next.config.js");
+      const cfgMjs = path.join(appsDir, d.name, "next.config.mjs");
+      if (await fileExists(cfg) || await fileExists(cfgMjs)) {
+        out.push(d.name);
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+async function fileExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/frameworks/vite.ts
+import { existsSync, readFileSync } from "fs";
+import path2 from "path";
+var viteAdapter = {
+  name: "vite",
+  detect(cwd) {
+    const pkgPath = path2.join(cwd, "package.json");
+    if (!existsSync(pkgPath)) return false;
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+      const deps = {
+        ...pkg["dependencies"],
+        ...pkg["devDependencies"]
+      };
+      return "vite" in deps;
+    } catch {
+      return false;
+    }
+  },
+  devCommand() {
+    return "vite";
+  },
+  buildCommand() {
+    return "vite build";
+  }
+};
+
+// src/core/detection/framework.ts
+var FRAMEWORK_ADAPTERS = [nextAdapter, viteAdapter];
+async function detectFramework(cwd) {
+  for (const adapter of FRAMEWORK_ADAPTERS) {
+    if (await Promise.resolve(adapter.detect(cwd))) return adapter;
+  }
+  return null;
+}
+
+// src/core/detection/packageManager.ts
+import { existsSync as existsSync2 } from "fs";
+import path3 from "path";
+
+// src/adapters/pm/npm.ts
+var npmAdapter = {
+  name: "npm",
+  async runScript(scriptName, cwd) {
+    const { execa } = await import("execa");
+    await execa("npm", ["run", scriptName], { cwd, stdio: "inherit" });
+  },
+  async install(cwd) {
+    const { execa } = await import("execa");
+    await execa("npm", ["install"], { cwd, stdio: "inherit" });
+  }
+};
+
+// src/adapters/pm/pnpm.ts
+var pnpmAdapter = {
+  name: "pnpm",
+  async runScript(scriptName, cwd) {
+    const { execa } = await import("execa");
+    await execa("pnpm", ["run", scriptName], { cwd, stdio: "inherit" });
+  },
+  async install(cwd) {
+    const { execa } = await import("execa");
+    await execa("pnpm", ["install"], { cwd, stdio: "inherit" });
+  }
+};
+
+// src/adapters/pm/yarn.ts
+var yarnAdapter = {
+  name: "yarn",
+  async runScript(scriptName, cwd) {
+    const { execa } = await import("execa");
+    await execa("yarn", ["run", scriptName], { cwd, stdio: "inherit" });
+  },
+  async install(cwd) {
+    const { execa } = await import("execa");
+    await execa("yarn", ["install"], { cwd, stdio: "inherit" });
+  }
+};
+
+// src/core/detection/packageManager.ts
+function detectPackageManager(cwd) {
+  if (existsSync2(path3.join(cwd, "pnpm-lock.yaml"))) return pnpmAdapter;
+  if (existsSync2(path3.join(cwd, "pnpm-workspace.yaml"))) return pnpmAdapter;
+  if (existsSync2(path3.join(cwd, "yarn.lock"))) return yarnAdapter;
+  if (existsSync2(path3.join(cwd, "package-lock.json"))) return npmAdapter;
+  return npmAdapter;
+}
+
+// src/adapters/runtimes/probe.ts
+import { execSync } from "child_process";
+function createVersionProbe(binary, parse = (output) => output.trim()) {
+  let cached;
+  return () => {
+    if (cached === void 0) {
+      try {
+        cached = {
+          version: parse(
+            execSync(`${binary} --version`, { stdio: "pipe" }).toString()
+          )
+        };
+      } catch {
+        cached = { version: null };
+      }
+    }
+    return cached.version;
+  };
+}
+
+// src/adapters/runtimes/bun.ts
+var probe = createVersionProbe("bun");
+var bunAdapter = {
+  name: "bun",
+  available() {
+    return probe() !== null;
+  },
+  version() {
+    return probe();
+  }
+};
+
+// src/adapters/runtimes/deno.ts
+var probe2 = createVersionProbe(
+  "deno",
+  (output) => output.trim().split("\n")[0]?.trim() ?? null
+);
+var denoAdapter = {
+  name: "deno",
+  available() {
+    return probe2() !== null;
+  },
+  version() {
+    return probe2();
+  }
+};
+
+// src/adapters/runtimes/node.ts
+var nodeAdapter = {
+  name: "node",
+  // Both answers are already in this process. Spawning `node --version` to
+  // ask the running Node its own version cost ~8 ms for a value held in
+  // memory, and a PATH lookup could even have found a different Node than
+  // the one executing this code.
+  available() {
+    return typeof process.versions.node === "string";
+  },
+  version() {
+    return process.version;
+  }
+};
+
+// src/core/detection/runtime.ts
+function detectRuntime() {
+  const g = globalThis;
+  if (typeof g["Bun"] !== "undefined") {
+    return bunAdapter;
+  }
+  if (typeof g["Deno"] !== "undefined") {
+    return denoAdapter;
+  }
+  return nodeAdapter;
+}
+
+// src/core/detection/project.ts
+async function detectProject(cwd) {
+  return {
+    pm: detectPackageManager(cwd),
+    runtime: detectRuntime(),
+    framework: await detectFramework(cwd)
+  };
+}
+
+export {
+  genericAdapter,
+  nextAdapter,
+  nextPlugin,
+  viteAdapter,
+  detectProject
+};

package/dist/chunk-VTJ67TT5.js

@@ -0,0 +1,238 @@
+import {
+  GraphError
+} from "./chunk-RVXUCJYA.js";
+import {
+  collectExportedSurface
+} from "./chunk-O4LZKXNZ.js";
+
+// src/core/semantic/symbol-graph.ts
+import { createHash } from "crypto";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+var SYMBOL_GRAPH_VERSION = 1;
+var GRAPH_FILENAME = "symbols.json";
+var DEFAULT_INCLUDE = ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"];
+var DEFAULT_IGNORE = [
+  "node_modules/**",
+  ".git/**",
+  ".variant/**",
+  "dist/**",
+  "**/*.d.ts"
+];
+function defaultGraphDir(cwd) {
+  return path.join(cwd, ".variant", "graph");
+}
+async function buildSymbolGraph(cwd, options = {}) {
+  const fg = (await import("fast-glob")).default;
+  const include = options.include ?? DEFAULT_INCLUDE;
+  for (const p of include) assertSafePattern(p);
+  const files = (await fg(include, {
+    cwd,
+    onlyFiles: true,
+    ignore: [...DEFAULT_IGNORE, ...options.ignore ?? []]
+  })).map(toPosix).sort();
+  const previous = options.previous?.version === SYMBOL_GRAPH_VERSION ? options.previous : null;
+  const stats = {
+    scanned: files.length,
+    parsed: 0,
+    reused: 0,
+    removed: 0
+  };
+  const contents = new Array(files.length);
+  const limit = Math.max(1, options.parallel ?? 32);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const i = next++;
+      if (i >= files.length) return;
+      const relPath = files[i];
+      if (relPath === void 0) return;
+      contents[i] = await readFile(path.join(cwd, relPath), "utf8");
+    }
+  };
+  await Promise.all(
+    Array.from({ length: Math.min(limit, files.length || 1) }, worker)
+  );
+  let tsm;
+  let project;
+  const out = {};
+  for (let i = 0; i < files.length; i++) {
+    const relPath = files[i];
+    const content = contents[i];
+    if (relPath === void 0 || content === void 0) continue;
+    const contentHash = sha256(content);
+    const prev = previous?.files[relPath];
+    if (prev !== void 0 && prev.contentHash === contentHash) {
+      out[relPath] = prev;
+      stats.reused++;
+      continue;
+    }
+    if (tsm === void 0 || project === void 0) {
+      tsm = await import("ts-morph");
+      project = new tsm.Project({ useInMemoryFileSystem: true });
+    }
+    const sourceFile = project.createSourceFile(relPath, content, {
+      overwrite: true
+    });
+    out[relPath] = indexSourceFile(sourceFile, contentHash, tsm);
+    stats.parsed++;
+  }
+  if (previous !== null) {
+    for (const key of Object.keys(previous.files)) {
+      if (!(key in out)) stats.removed++;
+    }
+  }
+  return {
+    graph: {
+      version: SYMBOL_GRAPH_VERSION,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: out
+    },
+    stats
+  };
+}
+async function updateSymbolGraph(cwd, options = {}) {
+  const graphDir = options.graphDir ?? defaultGraphDir(cwd);
+  const previous = options.previous ?? await loadSymbolGraph(graphDir);
+  const result = await buildSymbolGraph(cwd, { ...options, previous });
+  await saveSymbolGraph(graphDir, result.graph);
+  return result;
+}
+async function loadSymbolGraph(graphDir) {
+  const filePath = path.join(graphDir, GRAPH_FILENAME);
+  let raw;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw new GraphError(
+      `Failed to read symbol graph at "${filePath}": ${String(err)}`,
+      { cause: err }
+    );
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== SYMBOL_GRAPH_VERSION) return null;
+    if (typeof parsed.files !== "object" || parsed.files === null) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function saveSymbolGraph(graphDir, graph) {
+  try {
+    await mkdir(graphDir, { recursive: true });
+    await writeFile(
+      path.join(graphDir, GRAPH_FILENAME),
+      JSON.stringify(graph, null, 2)
+    );
+  } catch (err) {
+    throw new GraphError(
+      `Failed to write symbol graph to "${graphDir}": ${String(err)}`,
+      { cause: err }
+    );
+  }
+}
+function findSymbol(graph, name) {
+  const hits = [];
+  for (const [file, index] of Object.entries(graph.files)) {
+    for (const symbol of index.symbols) {
+      if (symbol.name === name) hits.push({ file, symbol });
+    }
+  }
+  return hits;
+}
+function getFileIndex(graph, file) {
+  return graph.files[toPosix(file)];
+}
+function indexSourceFile(file, contentHash, tsm) {
+  const surface = collectExportedSurface(file, tsm);
+  const { imports, notes: importNotes } = collectImports(file, tsm);
+  const symbols = [...surface.symbols.entries()].map(([name, s]) => ({
+    name,
+    kind: s.kind,
+    signatureHash: sha256(s.signature),
+    bodyHash: s.body === "" ? "" : sha256(s.body),
+    typeSpace: s.typeSpace
+  })).sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    contentHash,
+    symbols,
+    imports,
+    notes: [.../* @__PURE__ */ new Set([...surface.notes, ...importNotes])]
+  };
+}
+function collectImports(file, tsm) {
+  const imports = [];
+  const notes = [];
+  for (const imp of file.getImportDeclarations()) {
+    const names = [];
+    if (imp.getDefaultImport() !== void 0) names.push("default");
+    if (imp.getNamespaceImport() !== void 0) names.push("*");
+    for (const named of imp.getNamedImports()) names.push(named.getName());
+    imports.push({
+      module: imp.getModuleSpecifierValue(),
+      kind: "static",
+      typeOnly: imp.isTypeOnly(),
+      names
+    });
+  }
+  for (const exp of file.getExportDeclarations()) {
+    const module = exp.getModuleSpecifierValue();
+    if (module === void 0) continue;
+    const named = exp.getNamedExports().map((s) => s.getName());
+    imports.push({
+      module,
+      kind: "reexport",
+      typeOnly: exp.isTypeOnly(),
+      names: named.length > 0 ? named : ["*"]
+    });
+  }
+  for (const call of file.getDescendantsOfKind(tsm.SyntaxKind.CallExpression)) {
+    if (call.getExpression().getKind() !== tsm.SyntaxKind.ImportKeyword) {
+      continue;
+    }
+    const arg = call.getArguments()[0];
+    if (arg !== void 0 && tsm.Node.isStringLiteral(arg)) {
+      imports.push({
+        module: arg.getLiteralValue(),
+        kind: "dynamic",
+        typeOnly: false,
+        names: []
+      });
+    } else {
+      notes.push("dynamic import() with a non-literal specifier");
+    }
+  }
+  return { imports, notes };
+}
+function sha256(text) {
+  return createHash("sha256").update(text).digest("hex");
+}
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+function assertSafePattern(pattern) {
+  if (path.isAbsolute(pattern)) {
+    throw new GraphError(
+      `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 GraphError(
+      `Unsafe glob pattern "${pattern}": patterns must be relative and must not traverse outside the project root.`
+    );
+  }
+}
+
+export {
+  SYMBOL_GRAPH_VERSION,
+  defaultGraphDir,
+  buildSymbolGraph,
+  updateSymbolGraph,
+  loadSymbolGraph,
+  saveSymbolGraph,
+  findSymbol,
+  getFileIndex
+};