@blzsky/variant 0.2.0

package/dist/chunk-O4LZKXNZ.js

@@ -0,0 +1,301 @@
+// src/core/semantic/surface.ts
+function collectExportedSurface(file, tsm) {
+  const symbols = /* @__PURE__ */ new Map();
+  const notes = [];
+  for (const decl of file.getExportDeclarations()) {
+    const moduleSpec = decl.getModuleSpecifierValue();
+    const declTypeOnly = decl.isTypeOnly();
+    const named = decl.getNamedExports();
+    if (moduleSpec === void 0) {
+      for (const spec of named) {
+        const source = findImportSource(file, spec.getName());
+        if (source === void 0) continue;
+        const typeOnly = declTypeOnly || spec.isTypeOnly() || source.typeOnly;
+        symbols.set(spec.getAliasNode()?.getText() ?? spec.getName(), {
+          signature: reexportSignature(spec.getName(), source.module, typeOnly),
+          body: "",
+          typeSpace: typeOnly,
+          kind: "reexport"
+        });
+      }
+      continue;
+    }
+    if (named.length > 0) {
+      for (const spec of named) {
+        const typeOnly = declTypeOnly || spec.isTypeOnly();
+        symbols.set(spec.getAliasNode()?.getText() ?? spec.getName(), {
+          signature: reexportSignature(spec.getName(), moduleSpec, typeOnly),
+          body: "",
+          typeSpace: typeOnly,
+          kind: "reexport"
+        });
+      }
+      continue;
+    }
+    const namespaceExport = decl.getNamespaceExport();
+    if (namespaceExport !== void 0) {
+      symbols.set(namespaceExport.getName(), {
+        signature: reexportSignature("*", moduleSpec, declTypeOnly),
+        body: "",
+        typeSpace: declTypeOnly,
+        kind: "reexport"
+      });
+      continue;
+    }
+    symbols.set(`* from ${moduleSpec}`, {
+      signature: reexportSignature("*", moduleSpec, declTypeOnly),
+      body: "",
+      typeSpace: declTypeOnly,
+      kind: "reexport"
+    });
+    notes.push(`export * from "${moduleSpec}" hides which names are exported`);
+  }
+  for (const [name, decls] of file.getExportedDeclarations()) {
+    if (symbols.has(name) || decls.length === 0) continue;
+    if (decls.some((d) => tsm.Node.isModuleDeclaration(d))) {
+      notes.push(`"${name}" uses namespace/declaration merging`);
+    } else if (new Set(decls.map((d) => d.getKind())).size > 1) {
+      notes.push(`"${name}" merges declarations of different kinds`);
+    }
+    const surfaces = decls.map((d) => declarationSurface(d, tsm));
+    const first = surfaces[0];
+    symbols.set(name, {
+      signature: surfaces.map((s) => s.signature).join(" & "),
+      body: surfaces.map((s) => s.body).filter((b) => b !== "").join(" "),
+      typeSpace: surfaces.every((s) => s.typeSpace),
+      kind: first === void 0 ? "unknown" : first.kind
+    });
+  }
+  if (hasDynamicImport(file, tsm)) {
+    notes.push("dynamic import() prevents full static resolution");
+  }
+  return { symbols, notes };
+}
+function reexportSignature(name, module, typeOnly) {
+  return `reexport ${name} from ${module}${typeOnly ? " (type-only)" : ""}`;
+}
+function findImportSource(file, localName) {
+  for (const imp of file.getImportDeclarations()) {
+    const module = imp.getModuleSpecifierValue();
+    const typeOnly = imp.isTypeOnly();
+    if (imp.getDefaultImport()?.getText() === localName) {
+      return { module, typeOnly };
+    }
+    if (imp.getNamespaceImport()?.getText() === localName) {
+      return { module, typeOnly };
+    }
+    for (const named of imp.getNamedImports()) {
+      const local = named.getAliasNode()?.getText() ?? named.getName();
+      if (local === localName) {
+        return { module, typeOnly: typeOnly || named.isTypeOnly() };
+      }
+    }
+  }
+  return void 0;
+}
+function declarationSurface(decl, tsm) {
+  if (tsm.Node.isFunctionDeclaration(decl)) {
+    return {
+      signature: functionSignature(decl, tsm),
+      body: significantText(
+        `${decl.getBody()?.getText() ?? ""} ${parameterDefaults(decl)}`,
+        tsm
+      ),
+      typeSpace: false,
+      kind: "function"
+    };
+  }
+  if (tsm.Node.isVariableDeclaration(decl)) {
+    const init = decl.getInitializer();
+    if (init !== void 0 && (tsm.Node.isArrowFunction(init) || tsm.Node.isFunctionExpression(init))) {
+      return {
+        signature: normalize(decl.getTypeNode()?.getText() ?? "") || functionSignature(init, tsm),
+        body: significantText(
+          `${init.getBody().getText()} ${parameterDefaults(init)}`,
+          tsm
+        ),
+        typeSpace: false,
+        kind: "function"
+      };
+    }
+    const typeText = decl.getTypeNode()?.getText() ?? inferTypeText(
+      () => decl.getType().getBaseTypeOfLiteralType().getText(void 0, tsm.TypeFormatFlags.NoTruncation)
+    );
+    return {
+      signature: normalize(typeText),
+      body: significantText(init?.getText() ?? "", tsm),
+      typeSpace: false,
+      kind: "variable"
+    };
+  }
+  if (tsm.Node.isClassDeclaration(decl)) {
+    return classSurface(decl, tsm);
+  }
+  if (tsm.Node.isInterfaceDeclaration(decl)) {
+    return {
+      signature: significantText(decl.getText(), tsm),
+      body: "",
+      typeSpace: true,
+      kind: "interface"
+    };
+  }
+  if (tsm.Node.isTypeAliasDeclaration(decl)) {
+    return {
+      signature: significantText(decl.getText(), tsm),
+      body: "",
+      typeSpace: true,
+      kind: "type"
+    };
+  }
+  if (tsm.Node.isEnumDeclaration(decl)) {
+    return {
+      signature: significantText(decl.getText(), tsm),
+      body: "",
+      typeSpace: false,
+      kind: "enum"
+    };
+  }
+  if (tsm.Node.isModuleDeclaration(decl)) {
+    return {
+      signature: significantText(decl.getText(), tsm),
+      body: "",
+      typeSpace: false,
+      kind: "namespace"
+    };
+  }
+  return {
+    signature: significantText(decl.getText(), tsm),
+    body: "",
+    typeSpace: false,
+    kind: "unknown"
+  };
+}
+function functionSignature(fn, tsm) {
+  const typeParams = fn.getTypeParameters().map((t) => t.getText()).join(", ");
+  const params = fn.getParameters().map((p) => parameterSignature(p, tsm)).join(", ");
+  const returnType = fn.getReturnTypeNode()?.getText() ?? inferTypeText(
+    () => fn.getReturnType().getText(void 0, tsm.TypeFormatFlags.NoTruncation)
+  );
+  return normalize(`<${typeParams}>(${params}) => ${returnType}`);
+}
+function parameterSignature(p, tsm) {
+  const rest = p.isRestParameter() ? "..." : "";
+  const optional = p.hasQuestionToken() || p.hasInitializer() ? "?" : "";
+  const type = p.getTypeNode()?.getText() ?? inferTypeText(
+    () => p.getType().getText(void 0, tsm.TypeFormatFlags.NoTruncation)
+  );
+  return `${rest}${type}${optional}`;
+}
+function parameterDefaults(fn) {
+  return fn.getParameters().map((p) => p.getInitializer()?.getText() ?? "").filter((t) => t !== "").join(" ");
+}
+function classSurface(cls, tsm) {
+  const signatureParts = [];
+  const bodyParts = [];
+  const typeParams = cls.getTypeParameters().map((t) => t.getText()).join(", ");
+  const heritage = cls.getHeritageClauses().map((h) => h.getText()).join(" ");
+  const decorators = cls.getDecorators().map((d) => d.getText()).join(" ");
+  signatureParts.push(`class<${typeParams}> ${heritage} ${decorators}`);
+  for (const member of cls.getMembers()) {
+    if (tsm.Node.isConstructorDeclaration(member)) {
+      const params = member.getParameters().map((p) => {
+        const modifiers = p.getModifiers().map((m) => m.getText()).join(" ");
+        return `${modifiers} ${parameterSignature(p, tsm)}`.trim();
+      }).join(", ");
+      signatureParts.push(`constructor(${params})`);
+      bodyParts.push(member.getBody()?.getText() ?? "");
+      bodyParts.push(parameterDefaults(member));
+      continue;
+    }
+    if (isPrivateMember(member, tsm)) {
+      bodyParts.push(member.getText());
+      continue;
+    }
+    if (tsm.Node.isMethodDeclaration(member)) {
+      const staticMod = member.isStatic() ? "static " : "";
+      const optional = member.hasQuestionToken() ? "?" : "";
+      signatureParts.push(
+        `${staticMod}${member.getName()}${optional}${functionSignature(member, tsm)}`
+      );
+      bodyParts.push(member.getBody()?.getText() ?? "");
+      bodyParts.push(parameterDefaults(member));
+      continue;
+    }
+    if (tsm.Node.isPropertyDeclaration(member)) {
+      const staticMod = member.isStatic() ? "static " : "";
+      const readonlyMod = member.isReadonly() ? "readonly " : "";
+      const optional = member.hasQuestionToken() ? "?" : "";
+      const type = member.getTypeNode()?.getText() ?? inferTypeText(
+        () => member.getType().getBaseTypeOfLiteralType().getText(void 0, tsm.TypeFormatFlags.NoTruncation)
+      );
+      signatureParts.push(
+        `${staticMod}${readonlyMod}${member.getName()}${optional}: ${type}`
+      );
+      bodyParts.push(member.getInitializer()?.getText() ?? "");
+      continue;
+    }
+    if (tsm.Node.isGetAccessorDeclaration(member)) {
+      const type = member.getReturnTypeNode()?.getText() ?? inferTypeText(
+        () => member.getReturnType().getText(void 0, tsm.TypeFormatFlags.NoTruncation)
+      );
+      signatureParts.push(`get ${member.getName()}: ${type}`);
+      bodyParts.push(member.getBody()?.getText() ?? "");
+      continue;
+    }
+    if (tsm.Node.isSetAccessorDeclaration(member)) {
+      const param = member.getParameters()[0];
+      signatureParts.push(
+        `set ${member.getName()}(${param === void 0 ? "" : parameterSignature(param, tsm)})`
+      );
+      bodyParts.push(member.getBody()?.getText() ?? "");
+      continue;
+    }
+    bodyParts.push(member.getText());
+  }
+  return {
+    signature: normalize(signatureParts.join(" | ")),
+    body: significantText(bodyParts.filter((b) => b !== "").join(" "), tsm),
+    typeSpace: false,
+    kind: "class"
+  };
+}
+function isPrivateMember(member, tsm) {
+  const name = tsm.Node.hasName(member) ? member.getName() : "";
+  if (name.startsWith("#")) return true;
+  return tsm.Node.isScoped(member) && member.getScope() === tsm.Scope.Private;
+}
+function hasDynamicImport(file, tsm) {
+  return file.getDescendantsOfKind(tsm.SyntaxKind.CallExpression).some((c) => c.getExpression().getKind() === tsm.SyntaxKind.ImportKeyword);
+}
+function inferTypeText(get) {
+  try {
+    return get();
+  } catch {
+    return "<unresolved>";
+  }
+}
+function significantText(src, tsm) {
+  if (src.trim() === "") return "";
+  const scanner = tsm.ts.createScanner(
+    tsm.ts.ScriptTarget.Latest,
+    /* skipTrivia */
+    true,
+    tsm.ts.LanguageVariant.Standard,
+    src
+  );
+  const parts = [];
+  let kind = scanner.scan();
+  while (kind !== tsm.ts.SyntaxKind.EndOfFileToken) {
+    parts.push(scanner.getTokenText());
+    kind = scanner.scan();
+  }
+  return parts.join(" ");
+}
+function normalize(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+export {
+  collectExportedSurface,
+  significantText
+};

package/dist/chunk-RGD422OM.js

@@ -0,0 +1,108 @@
+import {
+  ConfigError
+} from "./chunk-RVXUCJYA.js";
+
+// src/core/config/loader.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import path from "path";
+
+// src/core/config/schema.ts
+import * as z from "zod";
+var defaultCache = {
+  mode: "content",
+  directory: ".variant/cache"
+};
+var taskConfigSchema = z.object({
+  inputs: z.array(z.string()).optional(),
+  dependsOn: z.array(z.string()).optional(),
+  command: z.string().optional(),
+  /** Phase 4: scheduler hint. */
+  cpuHeavy: z.boolean().optional()
+});
+var variantConfigSchema = z.object({
+  strategy: z.enum(["adaptive", "strict"]).default("adaptive"),
+  cache: z.object({
+    mode: z.literal("content").default(defaultCache.mode),
+    directory: z.string().default(defaultCache.directory),
+    /** Evict local cache entries older than this many days. */
+    ttlDays: z.number().optional()
+  }).default(defaultCache),
+  tasks: z.record(z.string(), taskConfigSchema).default({}),
+  workspace: z.object({
+    enabled: z.boolean().default(false),
+    scripts: z.array(z.string()).default(["build", "test", "lint"])
+  }).optional(),
+  git: z.object({
+    baseRef: z.string().default("HEAD~1"),
+    enabled: z.boolean().default(true)
+  }).optional(),
+  semanticDiff: z.object({
+    enabled: z.boolean().default(false)
+  }).optional(),
+  scheduler: z.object({
+    policy: z.enum(["auto", "light-first", "pack-heavy", "critical-path"]).default("auto")
+  }).optional()
+}).superRefine((val, ctx) => {
+  const taskNames = new Set(Object.keys(val.tasks));
+  for (const [name, cfg] of Object.entries(val.tasks)) {
+    for (const dep of cfg.dependsOn ?? []) {
+      if (!taskNames.has(dep)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["tasks", name, "dependsOn"],
+          message: `references unknown task "${dep}" \u2014 add it to config.tasks or remove the reference`
+        });
+      }
+    }
+  }
+});
+
+// src/core/config/loader.ts
+function defineConfig(config) {
+  return config;
+}
+var CANDIDATES = [
+  "variant.config.ts",
+  "variant.config.mjs",
+  "variant.config.js",
+  "variant.config.json"
+];
+function findVariantConfigPath(cwd) {
+  return CANDIDATES.map((f) => path.join(cwd, f)).find(existsSync);
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = findVariantConfigPath(cwd);
+  let raw = {};
+  if (configPath) {
+    if (path.extname(configPath) === ".json") {
+      try {
+        const text = await readFile(configPath, "utf8");
+        raw = JSON.parse(text);
+      } catch (err) {
+        const hint = err instanceof Error ? err.message : String(err);
+        throw new ConfigError(
+          `Invalid JSON config (${path.basename(configPath)}): ${hint}`
+        );
+      }
+    } else {
+      const { createJiti } = await import("jiti");
+      const jiti = createJiti(import.meta.url);
+      const mod = await jiti.import(configPath);
+      raw = mod.default ?? mod;
+    }
+  }
+  const result = variantConfigSchema.safeParse(raw);
+  if (!result.success) {
+    const messages = result.error.issues.map((e) => ` ${e.path.map(String).join(".")}: ${e.message}`).join("\n");
+    throw new ConfigError(`Invalid variant config:
+${messages}`);
+  }
+  return result.data;
+}
+
+export {
+  defineConfig,
+  findVariantConfigPath,
+  loadConfig
+};

package/dist/chunk-RVXUCJYA.js

@@ -0,0 +1,81 @@
+// src/core/errors.ts
+var VariantError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "VariantError";
+  }
+  code;
+  hint;
+  /**
+   * 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 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 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,
+  ImpactReportError,
+  CliUsageError
+};