@metaobjectsdev/cli 0.23.2 → 0.24.0

package/src/commands/prompt-snapshot.ts

@@ -14,8 +14,8 @@ import { parsePromptSnapshotArgs } from "../lib/args.js";
 import { log } from "../lib/log.js";
 import { FileProvider } from "../lib/file-provider.js";
 import { snapshotPaths, unifiedDiff } from "../lib/snapshot.js";
-import { loadMetaobjectsConfig } from "../lib/load-metaobjects-config.js";
-import { loadMemory } from "@metaobjectsdev/sdk";
+import { loadMemoryOptionsFrom, loadMetaobjectsConfig, resolveGenConfigDir } from "../lib/load-metaobjects-config.js";
+import { loadMemory, resolveCollection } from "@metaobjectsdev/sdk";
 import { TYPE_TEMPLATE, TEMPLATE_ATTR_TEXT_REF, TEMPLATE_ATTR_FORMAT } from "@metaobjectsdev/metadata";
 import { render, ESCAPERS, type RenderFormat } from "@metaobjectsdev/render";
 
@@ -30,34 +30,59 @@ export async function promptSnapshotCommand(args: string[], cwd: string): Promis
     return 2;
   }
 
-  // Best-effort load of metaobjects.config.ts to pick up consumer-supplied
-  // providers. prompt-snapshot doesn't require codegen config; if it's absent
+  // Where the metadata lives is `resolveCollection`'s decision, not this
+  // command's — `--check` is a drift GATE, so a project declaring `sources`
+  // elsewhere would otherwise gate against a stale `metaobjects/` (or report
+  // "no metaobjects/ found" for metadata it can see perfectly well). Discovery
+  // and load stay separate failure modes, the `meta gen` pattern: a broad catch
+  // around both reports a genuine ParseError as "no metadata found".
+  // `resolveCollection` raises ERR_COLLECTION_NOT_FOUND with its own message,
+  // replacing the hand-rolled ENOENT sniff that used to live here.
+  let collection;
+  try {
+    collection = await resolveCollection(cwd);
+  } catch (err) {
+    log.error((err as Error).message);
+    return 2;
+  }
+
+  // Everything project-relative below hangs off the DECLARING directory, not
+  // ambient cwd: `.metaobjects/snapshots/` is that config's own state, and the
+  // prompt text belongs to the same project as the metadata that references it.
+  // Identical to cwd for a run from the project root, which is the only
+  // invocation that worked before metadata sources were resolvable at all.
+  const projectRoot = collection.configDir;
+
+  // Best-effort load of metaobjects.config.ts to pick up consumer-supplied providers
+  // and shipped `libraries`. prompt-snapshot doesn't require codegen config; if it's absent
   // or invalid, fall back to defaults — the loader still works for any
   // metadata that only uses core+forge subtypes.
-  let configProviders: NonNullable<Awaited<ReturnType<typeof loadMetaobjectsConfig>>["providers"]> | undefined;
+  let configLoadOptions: ReturnType<typeof loadMemoryOptionsFrom> = {};
   try {
-    const forgeConfig = await loadMetaobjectsConfig(cwd);
-    configProviders = forgeConfig.providers;
+    // `metaobjects.config.ts` gets its own nearest-ancestor walk, not `projectRoot`:
+    // it answers a different question from `.metaobjects/config.json` (design §4.6)
+    // and in a Maven- or pip-rooted monorepo the two legitimately sit in different
+    // directories, so reading it from the collection's would silently drop this
+    // package's providers (#326). Same path whenever the two files sit together.
+    configLoadOptions = loadMemoryOptionsFrom(
+      await loadMetaobjectsConfig(resolveGenConfigDir(cwd, projectRoot)),
+    );
   } catch {
-    configProviders = undefined;
+    configLoadOptions = {};
   }
 
   let root;
   try {
-    root = await loadMemory(cwd, {
-      ...(configProviders !== undefined ? { providers: configProviders } : {}),
+    root = await loadMemory(collection.configDir, {
+      files: collection.files,
+      ...configLoadOptions,
     });
   } catch (err) {
-    const msg = (err as Error).message;
-    if (msg.includes("ENOENT") || msg.includes("no such") || msg.includes("cannot read")) {
-      log.error(`no metaobjects/ found in ${cwd}; run 'meta init' to scaffold`);
-      return 2;
-    }
-    log.error(`failed to load metadata: ${msg}`);
+    log.error(`failed to load metadata: ${(err as Error).message}`);
     return 1;
   }
 
-  const promptsDir = join(cwd, flags.prompts ?? DEFAULT_PROMPTS_DIR);
+  const promptsDir = join(projectRoot, flags.prompts ?? DEFAULT_PROMPTS_DIR);
   const provider = new FileProvider(promptsDir);
 
   // ADR-0039: effective children — resolve rather than rely on root being unextended.
@@ -79,7 +104,7 @@ export async function promptSnapshotCommand(args: string[], cwd: string): Promis
     // Absent/typeless required attrs are a loader-schema concern, not ours.
     if (typeof textRef !== "string") continue;
 
-    const { dir, payloadPath, snapPath } = snapshotPaths(cwd, tmpl.name);
+    const { dir, payloadPath, snapPath } = snapshotPaths(projectRoot, tmpl.name);
     if (!existsSync(payloadPath)) {
       log.info(`[${tmpl.name}] skipped — no payload at ${payloadPath}`);
       skipped++;

package/src/commands/upgrade.ts

@@ -0,0 +1,156 @@
+// server/typescript/packages/cli/src/commands/upgrade.ts
+//
+// `meta upgrade` — rewrite retired vocabulary in this project's metadata.
+//
+// DELIBERATELY NOT `meta migrate`. That command owns DATABASE SCHEMA (ADR-0015) and an
+// adopter reading `migrate` expects DDL. Overloading it with a metadata rewrite would make
+// the most destructive command in the toolchain ambiguous about what it touches.
+//
+// IT DOES NOT LOAD THE METADATA, and cannot. Once vocabulary is deregistered, metadata
+// carrying it fails the load — which is exactly the state this command exists to repair. So
+// it resolves the file SET through `resolveCollection` (the single authority on where
+// metadata lives) and hands each file's RAW TEXT to the rewriter. See
+// `metadata/src/vocabulary-rewrite.ts` for why that is the only workable shape.
+//
+// DRY-RUN BY DEFAULT, per this repo's convention for anything that edits committed files.
+// `--apply` writes. Refusals exit NON-ZERO even when every mechanical change succeeded, so
+// CI cannot mistake a partial upgrade for a finished one.
+
+import { readFile, writeFile } from "node:fs/promises";
+import { extname, relative } from "node:path";
+import { resolveCollection } from "@metaobjectsdev/sdk";
+import { rewriteDocument } from "@metaobjectsdev/metadata";
+import { log } from "../lib/log.js";
+
+/** Authoring formats the rewriter cannot edit — see `vocabulary-rewrite.ts` for why. */
+const UNREWRITABLE_EXTENSIONS = new Set([".yaml", ".yml"]);
+
+interface UpgradeFlags {
+  apply: boolean;
+  maxVersion?: string;
+  projectRoot?: string;
+}
+
+function parseArgs(argv: string[]): UpgradeFlags {
+  const flags: UpgradeFlags = { apply: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i] as string;
+    if (a === "--apply") flags.apply = true;
+    else if (a === "--to") {
+      const v = argv[++i];
+      if (v === undefined) throw new Error("--to needs a version");
+      flags.maxVersion = v;
+    } else if (a.startsWith("--to=")) flags.maxVersion = a.slice("--to=".length);
+    else if (a === "--help" || a === "-h") throw new Error("__help__");
+    else if (!a.startsWith("-")) flags.projectRoot = a;
+    else throw new Error(`unknown option: ${a}`);
+  }
+  return flags;
+}
+
+export async function upgradeCommand(args: string[], cwd: string): Promise<number> {
+  let flags: UpgradeFlags;
+  try {
+    flags = parseArgs(args);
+  } catch (err) {
+    if ((err as Error).message === "__help__") {
+      log.info(
+        "meta upgrade [<project>] [--to <version>] [--apply]\n\n" +
+          "  Rewrites retired metadata vocabulary. Previews by default; --apply writes.\n" +
+          "  Retirements needing a human decision are REFUSED and listed with their guide.",
+      );
+      return 0;
+    }
+    log.error((err as Error).message);
+    return 2;
+  }
+
+  const projectRoot = flags.projectRoot ?? cwd;
+
+  let files: readonly string[];
+  try {
+    files = (await resolveCollection(projectRoot)).files;
+  } catch (err) {
+    log.error((err as Error).message);
+    return 1;
+  }
+
+  let totalChanges = 0;
+  let totalRefusals = 0;
+  let filesChanged = 0;
+  const skipped: string[] = [];
+
+  for (const file of files) {
+    const rel = relative(projectRoot, file);
+
+    // A file we cannot rewrite is NAMED, never passed over. Silently skipping it is the
+    // failure this command exists to prevent: the adopter runs the documented migration,
+    // reads "no retired vocabulary found", and ships metadata that does not load.
+    if (UNREWRITABLE_EXTENSIONS.has(extname(file).toLowerCase())) {
+      skipped.push(rel);
+      continue;
+    }
+
+    const before = await readFile(file, "utf8");
+    const r = rewriteDocument(before, {
+      ...(flags.maxVersion !== undefined ? { maxVersion: flags.maxVersion } : {}),
+    });
+    if (r.changes.length === 0 && r.refusals.length === 0) continue;
+
+    log.info(`\n${rel}`);
+    for (const c of r.changes) log.info(`  ${c.line}: @${c.from} → ${c.to}`);
+    for (const f of r.refusals) {
+      log.warn(
+        `  ${f.line}: ${f.subject}${f.value !== undefined ? `: ${f.value}` : ""} — needs a decision. ` +
+          `Retired in ${f.since}. ${f.migration !== undefined ? `See ${f.migration}` : f.why}`,
+      );
+    }
+
+    totalChanges += r.changes.length;
+    totalRefusals += r.refusals.length;
+    if (r.changes.length > 0) {
+      filesChanged++;
+      if (flags.apply) await writeFile(file, r.text, "utf8");
+    }
+  }
+
+  log.info("");
+  if (skipped.length > 0) {
+    log.warn(
+      `${skipped.length} YAML file(s) cannot be rewritten automatically and were NOT ` +
+        `checked — migrate them by hand:\n  ${skipped.join("\n  ")}`,
+    );
+  }
+
+  if (totalChanges === 0 && totalRefusals === 0) {
+    log.info(
+      skipped.length > 0
+        ? "meta upgrade — no retired vocabulary found in the JSON metadata."
+        : "meta upgrade — no retired vocabulary found.",
+    );
+  } else if (totalChanges === 0) {
+    // Refusals only. Reporting "rewrote 0 declarations", or advertising `--apply`, both
+    // promise an action guaranteed to change nothing and bury the fact that the remaining
+    // work is entirely human.
+    log.info("meta upgrade — nothing here can be rewritten automatically.");
+  } else if (flags.apply) {
+    log.info(`meta upgrade — rewrote ${totalChanges} declaration(s) across ${filesChanged} file(s).`);
+  } else {
+    log.info(
+      `meta upgrade — ${totalChanges} declaration(s) in ${filesChanged} file(s) can be rewritten. ` +
+        `Re-run with --apply to write.`,
+    );
+  }
+
+  // Non-zero while ANY refusal stands, applied or not. A partial upgrade that exited 0 would
+  // let CI record the migration as done while metadata still fails to load. A file we could
+  // not read at all counts the same way, for the same reason.
+  if (totalRefusals > 0) {
+    log.error(
+      `${totalRefusals} declaration(s) need a human decision and were left untouched — ` +
+        `see the guides listed above.`,
+    );
+    return 1;
+  }
+  return skipped.length > 0 ? 1 : 0;
+}