@metaobjectsdev/cli 0.9.0-rc.1 → 0.10.0

package/src/lib/codegen-drift.ts

@@ -0,0 +1,173 @@
+// `meta verify --codegen` — the codegen-drift gate (ADR-0021 D2).
+//
+// Regenerates the configured codegen into a throwaway temp directory and DIFFs
+// the freshly-generated file tree against the committed output (the config's
+// outDir / per-target outDirs). Any difference — a file present in one tree but
+// not the other, or differing content — is drift: either "metadata changed but
+// `meta gen` wasn't re-run" or "a generated file was hand-edited". Reuses the
+// exact same `runGen` pipeline `meta gen` uses, so the comparison is faithful.
+//
+// Faithfulness note: generated content can embed import paths computed RELATIVE
+// to a target's outDir (and between targets). To keep the regen byte-identical
+// to the committed output, each outDir is remapped into the temp tree at the
+// SAME path it has relative to the project root — preserving the inter-target
+// layout. `importBase` (a stable string, not a path) is untouched.
+
+import {
+  mkdtempSync,
+  rmSync,
+  existsSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, relative, resolve, isAbsolute } from "node:path";
+import { runGen } from "@metaobjectsdev/codegen-ts";
+import type { MetaobjectsGenConfig } from "@metaobjectsdev/codegen-ts";
+import type { MetaData } from "@metaobjectsdev/metadata";
+
+/** Per-target config as carried on MetaobjectsGenConfig (TargetConfig isn't
+ *  re-exported from the package index, so derive it from the config type). */
+type TargetConfig = NonNullable<MetaobjectsGenConfig["targets"]>[string];
+
+export interface CodegenDriftResult {
+  /** True when the committed output matches a fresh regen exactly. */
+  clean: boolean;
+  /** Project-relative paths that differ (changed / missing / extra), sorted. */
+  driftedFiles: string[];
+  /** Human-readable, one-line-per-file drift summary. */
+  lines: string[];
+  /** Set when the gate could not run (e.g. no outDir to compare against). */
+  error?: string;
+}
+
+/** Collect the committed outDirs declared by the config (default + per-target). */
+function committedOutDirs(config: MetaobjectsGenConfig): string[] {
+  const dirs = new Set<string>();
+  if (typeof config.outDir === "string" && config.outDir.length > 0) {
+    dirs.add(resolve(config.outDir));
+  }
+  for (const t of Object.values(config.targets ?? {})) {
+    if (t.outDir && t.outDir.length > 0) dirs.add(resolve(t.outDir));
+  }
+  return [...dirs];
+}
+
+/** Recursively list files under `dir` as paths relative to `dir` (POSIX-ish). */
+function listFiles(dir: string): string[] {
+  if (!existsSync(dir)) return [];
+  const out: string[] = [];
+  const walk = (d: string): void => {
+    for (const entry of readdirSync(d)) {
+      const full = join(d, entry);
+      if (statSync(full).isDirectory()) walk(full);
+      else out.push(relative(dir, full));
+    }
+  };
+  walk(dir);
+  return out;
+}
+
+/**
+ * Run codegen into a temp tree and diff it against the committed output.
+ *
+ * @param config   the loaded metaobjects config (provides outDir/targets).
+ * @param metadata the loaded MetaRoot (same object `meta gen` would use).
+ * @param projectRoot absolute project root (committed outDirs are keyed off it).
+ */
+export async function computeCodegenDrift(
+  config: MetaobjectsGenConfig,
+  metadata: MetaData,
+  projectRoot: string,
+): Promise<CodegenDriftResult> {
+  const root = isAbsolute(projectRoot) ? projectRoot : resolve(projectRoot);
+
+  const committedDirs = committedOutDirs(config);
+  if (committedDirs.length === 0) {
+    return {
+      clean: false,
+      driftedFiles: [],
+      lines: [],
+      error:
+        "verify --codegen: no outDir configured — cannot locate the committed " +
+        "generated output to diff against. Set 'outDir' (and/or per-target " +
+        "outDir) in metaobjects.config.ts.",
+    };
+  }
+
+  // Build a temp tree that mirrors each outDir at its project-relative path, so
+  // relative import paths in generated content come out identical.
+  const tempRoot = mkdtempSync(join(tmpdir(), "meta-verify-codegen-"));
+  try {
+    const tempFor = (committed: string): string => {
+      const rel = relative(root, committed);
+      // If a committed outDir lives outside the project root, fall back to a
+      // flattened, collision-safe slot under the temp root. (Relative-import
+      // fidelity for out-of-tree targets isn't guaranteed, but the diff is
+      // still meaningful per-file.)
+      const safeRel = rel.startsWith("..") || isAbsolute(rel)
+        ? committed.replace(/[^A-Za-z0-9]+/g, "_")
+        : rel;
+      return join(tempRoot, safeRel);
+    };
+
+    // Remap the config so runGen writes into the temp mirror instead of the
+    // committed output. Default outDir + each named target's outDir are rewritten.
+    const remappedTargets: Record<string, TargetConfig> = {};
+    for (const [name, t] of Object.entries(config.targets ?? {})) {
+      remappedTargets[name] = { ...t, outDir: tempFor(resolve(t.outDir)) };
+    }
+    const tempConfig: MetaobjectsGenConfig = {
+      ...config,
+      outDir: tempFor(resolve(config.outDir)),
+      ...(config.targets !== undefined ? { targets: remappedTargets } : {}),
+    };
+
+    // Generate fresh into the temp tree. "overwrite" + "fresh" + a temp
+    // gen-state dir guarantees every file is written (no merge/skip), so the
+    // temp tree is the canonical "what gen would produce right now".
+    await runGen({
+      config: tempConfig,
+      metadata,
+      projectRoot: tempRoot,
+      genStateDir: join(tempRoot, ".gen-state"),
+      mergeStrategy: "overwrite",
+      baseline: "fresh",
+    });
+
+    // Diff each committed outDir against its temp mirror.
+    const driftedFiles = new Set<string>();
+    const lines: string[] = [];
+    for (const committed of committedDirs) {
+      const fresh = tempFor(committed);
+      const committedFiles = new Set(listFiles(committed));
+      const freshFiles = new Set(listFiles(fresh));
+      const all = new Set([...committedFiles, ...freshFiles]);
+      for (const rel of [...all].sort()) {
+        const relKey = relative(root, join(committed, rel));
+        const inCommitted = committedFiles.has(rel);
+        const inFresh = freshFiles.has(rel);
+        if (inCommitted && !inFresh) {
+          driftedFiles.add(relKey);
+          lines.push(`- ${relKey} (committed but regen would not emit it)`);
+        } else if (!inCommitted && inFresh) {
+          driftedFiles.add(relKey);
+          lines.push(`+ ${relKey} (regen would emit it; not committed — run 'meta gen')`);
+        } else {
+          const a = readFileSync(join(committed, rel), "utf8");
+          const b = readFileSync(join(fresh, rel), "utf8");
+          if (a !== b) {
+            driftedFiles.add(relKey);
+            lines.push(`~ ${relKey} (committed content differs from a fresh regen)`);
+          }
+        }
+      }
+    }
+
+    const sorted = [...driftedFiles].sort();
+    return { clean: sorted.length === 0, driftedFiles: sorted, lines };
+  } finally {
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+}

package/src/lib/detect-stack.ts

@@ -0,0 +1,41 @@
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import {
+  detectStack, makeStack,
+  type ServerLang, type ClientFramework, type Stack, type ProjectProbe,
+  SERVER_LANGS, CLIENT_FRAMEWORKS,
+} from "@metaobjectsdev/sdk/agent-context";
+
+function depNames(cwd: string): Set<string> {
+  const out = new Set<string>();
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, Record<string, string>>;
+      for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
+        for (const name of Object.keys(pkg[key] ?? {})) out.add(name);
+      }
+    } catch { /* unreadable manifest — treat as no deps */ }
+  }
+  return out;
+}
+
+function probe(cwd: string): ProjectProbe {
+  const deps = depNames(cwd);
+  const names = existsSync(cwd) ? readdirSync(cwd) : [];
+  return {
+    hasDep: (name) => deps.has(name),
+    hasFileMatching: (re) => names.some((n) => re.test(n)),
+  };
+}
+
+/** Resolve the stack: explicit --server/--client overrides take precedence; otherwise detect. */
+export function resolveStack(cwd: string, overrides: { servers: string[]; clients: string[] }): Stack {
+  const validServers = SERVER_LANGS as readonly string[];
+  const validClients = CLIENT_FRAMEWORKS as readonly string[];
+  const oServers = overrides.servers.filter((s): s is ServerLang => validServers.includes(s));
+  const oClients = overrides.clients.filter((c): c is ClientFramework => validClients.includes(c));
+  if (oServers.length > 0 || oClients.length > 0) return makeStack(oServers, oClients);
+  const detected = detectStack(probe(cwd));
+  return makeStack(detected.servers, detected.clients);
+}

package/src/lib/load-metaobjects-config.ts

@@ -32,6 +32,13 @@ const CLI_PKG_PATHS: Record<string, { dist: string; src: string }> = {
     dist: "node_modules/@metaobjectsdev/codegen-ts/dist/index.js",
     src: "node_modules/@metaobjectsdev/codegen-ts/src/index.ts",
   },
+  // Consumer configs that ship custom MetaDataTypeProviders import the type
+  // primitives (TypeId, MetaField, TYPE_* …) from here. Aliased to the CLI's
+  // own copy so the user's project needn't declare it as a direct dependency.
+  "@metaobjectsdev/metadata": {
+    dist: "node_modules/@metaobjectsdev/metadata/dist/index.js",
+    src: "node_modules/@metaobjectsdev/metadata/src/index.ts",
+  },
   "@metaobjectsdev/codegen-ts/generators": {
     dist: "node_modules/@metaobjectsdev/codegen-ts/dist/generators/index.js",
     src: "node_modules/@metaobjectsdev/codegen-ts/src/generators/index.ts",
@@ -94,6 +101,7 @@ export async function loadMetaobjectsConfig(projectRoot: string): Promise<Metaob
     interopDefault: true,
     alias: {
       "@metaobjectsdev/codegen-ts": resolveCliPkg("@metaobjectsdev/codegen-ts"),
+      "@metaobjectsdev/metadata": resolveCliPkg("@metaobjectsdev/metadata"),
       "@metaobjectsdev/codegen-ts/generators": resolveCliPkg("@metaobjectsdev/codegen-ts/generators"),
       "@metaobjectsdev/codegen-ts-react": resolveCliPkg("@metaobjectsdev/codegen-ts-react"),
       "@metaobjectsdev/codegen-ts-tanstack": resolveCliPkg("@metaobjectsdev/codegen-ts-tanstack"),

package/src/lib/version.ts

@@ -0,0 +1,27 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * The installed `@metaobjectsdev/cli` version, read from its own package.json so it
+ * never goes stale. Walks up from this module to the cli package root; returns
+ * "0.0.0" if not found.
+ */
+export function cliVersion(): string {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 6; i++) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate)) {
+      try {
+        const pkg = JSON.parse(readFileSync(candidate, "utf8")) as { name?: string; version?: string };
+        if (pkg.name === "@metaobjectsdev/cli" && pkg.version) return pkg.version;
+      } catch {
+        // not our manifest / unreadable — keep walking up
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return "0.0.0";
+}