@metaobjectsdev/cli 0.5.0 → 0.6.0-rc.1

package/src/lib/args.ts

@@ -9,6 +9,7 @@ export interface InitFlags {
   quiet: boolean;
   printOnly: boolean;
   refreshDocs: boolean;
+  d1: boolean;
 }
 
 export function parseInitArgs(argv: string[]): InitFlags {
@@ -19,6 +20,7 @@ export function parseInitArgs(argv: string[]): InitFlags {
       quiet: { type: "boolean", default: false },
       "print-only": { type: "boolean", default: false },
       "refresh-docs": { type: "boolean", default: false },
+      d1: { type: "boolean", default: false },
     },
     strict: true,
     allowPositionals: false,
@@ -28,6 +30,7 @@ export function parseInitArgs(argv: string[]): InitFlags {
     quiet: !!values.quiet,
     printOnly: !!values["print-only"],
     refreshDocs: !!values["refresh-docs"],
+    d1: !!values.d1,
   };
 }
 
@@ -77,11 +80,61 @@ export function parseExportArgs(argv: string[]): ExportFlags {
   };
 }
 
+// ---------------------------------------------------------------------------
+// verify flags
+// ---------------------------------------------------------------------------
+
+export interface VerifyFlags {
+  /** Directory (relative to cwd) holding provider-resolved template text. */
+  prompts: string | undefined;
+}
+
+export function parseVerifyArgs(argv: string[]): VerifyFlags {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      prompts: { type: "string" },
+    },
+    strict: true,
+    allowPositionals: false,
+  });
+  return {
+    prompts: values.prompts,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// prompt-snapshot flags
+// ---------------------------------------------------------------------------
+
+export interface PromptSnapshotFlags {
+  /** Compare against committed snapshots and fail on drift; never write. */
+  check: boolean;
+  /** Directory (relative to cwd) holding provider-resolved template text. */
+  prompts: string | undefined;
+}
+
+export function parsePromptSnapshotArgs(argv: string[]): PromptSnapshotFlags {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      check: { type: "boolean", default: false },
+      prompts: { type: "string" },
+    },
+    strict: true,
+    allowPositionals: false,
+  });
+  return {
+    check: !!values.check,
+    prompts: values.prompts,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // migrate flags
 // ---------------------------------------------------------------------------
 
-const DIALECTS = ["sqlite", "postgres"] as const;
+const DIALECTS = ["sqlite", "postgres", "d1"] as const;
 type Dialect = (typeof DIALECTS)[number];
 
 const ALLOW_TOKENS = [
@@ -105,6 +158,11 @@ export interface MigrateFlags {
   allow: AllowToken[];
   onAmbiguous: OnAmbiguous | undefined;
   dryRun: boolean;
+  // D1-specific:
+  d1Binding: string | undefined;
+  remote: boolean;
+  apply: boolean;
+  yes: boolean;
 }
 
 export function parseMigrateArgs(argv: string[]): MigrateFlags {
@@ -118,6 +176,10 @@ export function parseMigrateArgs(argv: string[]): MigrateFlags {
       "allow": { type: "string" },
       "on-ambiguous": { type: "string" },
       "dry-run": { type: "boolean", default: false },
+      "d1": { type: "string" },
+      "remote": { type: "boolean", default: false },
+      "apply": { type: "boolean", default: false },
+      "yes": { type: "boolean", default: false },
     },
     strict: true,
     allowPositionals: false,
@@ -153,5 +215,9 @@ export function parseMigrateArgs(argv: string[]): MigrateFlags {
     allow: allowTokens as AllowToken[],
     onAmbiguous: onAmb as OnAmbiguous | undefined,
     dryRun: !!values["dry-run"],
+    d1Binding: values.d1 as string | undefined,
+    remote: !!values.remote,
+    apply: !!values.apply,
+    yes: !!values.yes,
   };
 }

package/src/lib/config.ts

@@ -2,15 +2,18 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { ConfigSchema, type Config, DEFAULT_METAOBJECTS_DIR } from "@metaobjectsdev/sdk";
 import type { GenFlags, MigrateFlags } from "./args.js";
+import type { Dialect } from "./kysely.js";
 
 // ---------------------------------------------------------------------------
 // Built-in defaults
 // ---------------------------------------------------------------------------
 
+export const MIGRATE_DEFAULT_OUT_DIR = "./.metaobjects/migrations";
+
 const MIGRATE_DEFAULTS = {
-  outDir: "./.metaobjects/migrations",
+  outDir: MIGRATE_DEFAULT_OUT_DIR,
   databaseUrl: undefined as string | undefined,
-  dialect: undefined as "sqlite" | "postgres" | undefined,
+  dialect: undefined as Dialect | undefined,
   onAmbiguous: "abort" as const,
   allow: [] as string[],
 };
@@ -24,14 +27,23 @@ export interface ResolvedGenConfig {
   entities: string[];
 }
 
+export interface ResolvedD1Config {
+  binding: string | undefined;
+  remote: boolean;
+  autoApply: boolean;
+  wranglerConfigPath: string | undefined;
+}
+
 export interface ResolvedMigrateConfig {
   outDir: string;
   databaseUrl: string | undefined;
-  dialect: "sqlite" | "postgres" | undefined;
+  dialect: Dialect | undefined;
   onAmbiguous: "abort" | "rename" | "drop-add";
   allow: string[];
   slug: string | undefined;
   dryRun: boolean;
+  yes: boolean;
+  d1: ResolvedD1Config;
 }
 
 // ---------------------------------------------------------------------------
@@ -61,6 +73,7 @@ export async function resolveMigrateConfig(
 ): Promise<ResolvedMigrateConfig> {
   const config = await tryLoadConfig(metaRoot);
   const cfgBlock = config?.migrate ?? {};
+  const d1Block = cfgBlock.d1 ?? {};
 
   const envUrl = process.env.DATABASE_URL;
 
@@ -74,5 +87,12 @@ export async function resolveMigrateConfig(
       : (cfgBlock.allow ?? MIGRATE_DEFAULTS.allow),
     slug: flags.slug,
     dryRun: flags.dryRun,
+    yes: flags.yes,
+    d1: {
+      binding: flags.d1Binding ?? d1Block.binding,
+      remote: flags.remote || (d1Block.remote ?? false),
+      autoApply: flags.apply || (d1Block.autoApply ?? false),
+      wranglerConfigPath: d1Block.wranglerConfigPath,
+    },
   };
 }

package/src/lib/file-provider.ts

@@ -0,0 +1,33 @@
+// The filesystem template provider for `meta verify` (FR-004 Plan #3, T6).
+//
+// Maps a 2-layer logical reference (`group/source`) onto a file under a base
+// directory, trying a small set of conventional extensions. This is the CLI's
+// concrete provider; the render engine itself stays provider-agnostic (it only
+// knows the `Provider` interface), so production hosts can swap in an RDB/NoSQL
+// provider without touching the engine.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Provider } from "@metaobjectsdev/render";
+
+const EXTENSIONS = [".mustache", ".txt", ""] as const;
+
+export class FileProvider implements Provider {
+  constructor(private readonly baseDir: string) {}
+
+  resolve(ref: string): string | undefined {
+    // `group/source` → <baseDir>/group/source<ext>; node:path.join normalizes
+    // the embedded "/" separators for the host OS.
+    for (const ext of EXTENSIONS) {
+      const path = join(this.baseDir, ref) + ext;
+      if (existsSync(path)) {
+        try {
+          return readFileSync(path, "utf8");
+        } catch {
+          // unreadable — fall through and try the next candidate
+        }
+      }
+    }
+    return undefined;
+  }
+}

package/src/lib/kysely.ts

@@ -1,6 +1,6 @@
 import { Kysely } from "kysely";
 
-export type Dialect = "sqlite" | "postgres";
+export type Dialect = "sqlite" | "postgres" | "d1";
 
 export interface KyselyHandle {
   db: Kysely<Record<string, unknown>>;
@@ -56,6 +56,12 @@ export async function buildKyselyFromUrl(
   const dialect = dialectOverride ?? inferDialect(url);
   const displayUrl = redactUrl(url);
 
+  if (dialect === "d1") {
+    throw new Error(
+      `dialect 'd1' does not use a URL connection; use meta migrate --d1 <binding>`,
+    );
+  }
+
   if (dialect === "sqlite") {
     type LibsqlDialectCtor = new (opts: { url: string }) => ConstructorParameters<typeof Kysely<Record<string, unknown>>>[0]["dialect"];
     let LibsqlDialect: LibsqlDialectCtor;

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

@@ -19,13 +19,11 @@ const _thisFile = fileURLToPath(import.meta.url);
 const _isCompiled = _thisFile.includes("/dist/");
 const _cliDir = resolve(_thisFile, _isCompiled ? "../../../.." : "../../..");
 const _require = createRequire(import.meta.url);
-// Each aliased specifier maps to a compiled-output path and a TS-source path,
-// relative to _cliDir. When running from compiled output we resolve into the
-// package's dist/; when running TS source directly (bun test, `meta` run from
-// the workspace) we resolve into src/ so the CLI never depends on a stale,
-// unrebuilt dist/.
+// Fallback layout for each codegen specifier (relative to _cliDir), used only
+// when standard module resolution can't locate it. Compiled output lives in
+// dist/; un-compiled runs (bun test, `meta` from the workspace) use src/ so the
+// CLI never depends on a stale, unrebuilt dist/.
 //
-// The three workspace deps resolve through the CLI's own node_modules.
 // @metaobjectsdev/cli is this package itself, so it resolves directly from
 // _cliDir rather than through node_modules (which would be a non-existent
 // self-referential symlink).
@@ -38,6 +36,10 @@ const CLI_PKG_PATHS: Record<string, { dist: string; src: string }> = {
     dist: "node_modules/@metaobjectsdev/codegen-ts/dist/generators/index.js",
     src: "node_modules/@metaobjectsdev/codegen-ts/src/generators/index.ts",
   },
+  "@metaobjectsdev/codegen-ts-react": {
+    dist: "node_modules/@metaobjectsdev/codegen-ts-react/dist/index.js",
+    src: "node_modules/@metaobjectsdev/codegen-ts-react/src/index.ts",
+  },
   "@metaobjectsdev/codegen-ts-tanstack": {
     dist: "node_modules/@metaobjectsdev/codegen-ts-tanstack/dist/index.js",
     src: "node_modules/@metaobjectsdev/codegen-ts-tanstack/src/index.ts",
@@ -48,12 +50,33 @@ const CLI_PKG_PATHS: Record<string, { dist: string; src: string }> = {
   },
 };
 
+// Resolve a codegen specifier to an absolute path for jiti's alias map, so a
+// user's metaobjects.config.ts can import @metaobjectsdev/codegen-ts* without
+// declaring it directly — the CLI's own copy is used.
+//
+// Standard module resolution is tried first: it follows whatever node_modules
+// layout exists — npm (flat), pnpm (deps as siblings in the virtual store,
+// NOT nested under the CLI dir), or bun — and honors the package's export
+// conditions. The CLI_PKG_PATHS fallback only kicks in when a specifier isn't
+// require-resolvable from the CLI module.
 function resolveCliPkg(specifier: string): string {
   const paths = CLI_PKG_PATHS[specifier];
-  if (paths !== undefined) {
+  // The cli self-reference always points at this package's own entry, never a
+  // (possibly absent) self-referential node_modules symlink.
+  if (specifier === "@metaobjectsdev/cli" && paths !== undefined) {
     return resolve(_cliDir, _isCompiled ? paths.dist : paths.src);
   }
-  return _require.resolve(specifier);
+  try {
+    return _require.resolve(specifier);
+  } catch {
+    if (paths !== undefined) {
+      const candidate = resolve(_cliDir, _isCompiled ? paths.dist : paths.src);
+      if (existsSync(candidate)) return candidate;
+    }
+    throw new Error(
+      `metaobjects: could not resolve ${specifier} from the CLI — try reinstalling @metaobjectsdev/cli.`,
+    );
+  }
 }
 
 export async function loadMetaobjectsConfig(projectRoot: string): Promise<MetaobjectsGenConfig> {
@@ -72,6 +95,7 @@ export async function loadMetaobjectsConfig(projectRoot: string): Promise<Metaob
     alias: {
       "@metaobjectsdev/codegen-ts": resolveCliPkg("@metaobjectsdev/codegen-ts"),
       "@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"),
       "@metaobjectsdev/cli": resolveCliPkg("@metaobjectsdev/cli"),
     },

package/src/lib/output.ts

@@ -3,6 +3,8 @@
 // TTY-gated glyphs: unicode (✓ ↺ ✗ = ⚠) when stdout is a TTY, plain words
 // (NEW MERGED CONFLICT UNCHANGED REFUSED) otherwise. Per SP5 §5.1.
 
+import type { Dialect } from "./kysely.js";
+
 export interface FormatOptions {
   isTTY: boolean;
 }
@@ -22,7 +24,7 @@ export interface GenFileEntry {
 export interface GenResultShape {
   files: GenFileEntry[];
   outDir: string;
-  dialect: "sqlite" | "postgres";
+  dialect: Dialect;
   dryRun: boolean;
   warnings: string[];
 }
@@ -103,7 +105,7 @@ export interface AmbiguousEntry {
 }
 
 export interface MigrateResultShape {
-  dialect: "sqlite" | "postgres";
+  dialect: Dialect;
   displayUrl: string;
   changeCounts: Record<string, number>;
   blocked: BlockedEntry[];

package/src/lib/payload-field-tree.ts

@@ -0,0 +1,47 @@
+// Derive a plain payload field tree from a loaded `object.value` view-object,
+// for `meta verify` (FR-004 Plan #3, T6). This is the metadata-side bridge to
+// the zero-core-dependency render engine: render's `verify` takes a PLAIN
+// PayloadField[] (no metadata import), and this function produces it by walking
+// the view-object exactly as payload-codegen.ts does — scalars become leaves,
+// `field.object` with an `@objectRef` becomes a nested tree.
+
+import {
+  type MetaData,
+  TYPE_OBJECT,
+  TYPE_FIELD,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_ATTR_OBJECT_REF,
+} from "@metaobjectsdev/metadata";
+import type { PayloadField } from "@metaobjectsdev/render";
+
+function findObject(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && c.name === name);
+}
+
+/**
+ * Walk an `object.value` view-object into a render `PayloadField[]`. Object-ref
+ * fields recurse into their referenced view-object; a `seen` set guards against
+ * a (pathological) reference cycle.
+ */
+export function derivePayloadFieldTree(
+  root: MetaData,
+  voName: string,
+  seen: ReadonlySet<string> = new Set(),
+): PayloadField[] {
+  if (seen.has(voName)) return [];
+  const vo = findObject(root, voName);
+  if (!vo) return [];
+  const nextSeen = new Set(seen).add(voName);
+  const fields: PayloadField[] = [];
+  for (const f of vo.children().filter((c) => c.type === TYPE_FIELD)) {
+    if (f.subType === FIELD_SUBTYPE_OBJECT) {
+      const ref = f.ownAttr(FIELD_ATTR_OBJECT_REF);
+      if (typeof ref === "string") {
+        fields.push({ name: f.name, fields: derivePayloadFieldTree(root, ref, nextSeen) });
+        continue;
+      }
+    }
+    fields.push({ name: f.name });
+  }
+  return fields;
+}

package/src/lib/projection-migrations.ts

@@ -13,13 +13,14 @@ import {
   type ViewMigrationInput,
   type ViewMigrationsResult,
 } from "@metaobjectsdev/migrate-ts";
+import type { Dialect } from "./kysely.js";
 
 /** view-name → set of source-table names the view's SELECT depends on. */
 export type ProjectionViewDependencies = ReadonlyMap<string, ReadonlySet<string>>;
 
 export interface ProjectionMigrationsOpts {
   readonly metadata: MetaData;
-  readonly dialect: "postgres" | "sqlite";
+  readonly dialect: Dialect;
   readonly allowBreaking?: boolean;
   /** Column naming strategy forwarded to extractViewSpec. Defaults to "snake_case". */
   readonly columnNamingStrategy?: "snake_case" | "literal" | "kebab-case";
@@ -53,6 +54,8 @@ export function computeProjectionMigrations(
   if (!(opts.metadata instanceof MetaRoot)) {
     throw new Error("computeProjectionMigrations: opts.metadata must be a loaded MetaRoot.");
   }
+  // D1 is SQLite at the SQL level; normalize before passing to downstream emitters.
+  const dialect: "postgres" | "sqlite" = opts.dialect === "d1" ? "sqlite" : opts.dialect;
   const root = opts.metadata;
   const columnNamingStrategy = opts.columnNamingStrategy ?? "snake_case";
 
@@ -84,7 +87,7 @@ export function computeProjectionMigrations(
     }
 
     const createSql = emitViewDdl(spec, {
-      dialect: opts.dialect,
+      dialect,
       baseTableName,
       joinTables,
     });
@@ -111,7 +114,7 @@ export function computeProjectionMigrations(
   }
 
   return computeViewMigrations({
-    dialect: opts.dialect,
+    dialect,
     allowBreaking: opts.allowBreaking ?? false,
     views,
   });

package/src/lib/snapshot.ts

@@ -0,0 +1,50 @@
+// Path + diff helpers for `meta prompt-snapshot`. Pure (no I/O, no metadata) so
+// they unit-test trivially; the command does the filesystem work.
+
+import { join } from "node:path";
+
+export interface SnapshotPaths {
+  /** The per-template snapshot directory: <cwd>/.metaobjects/snapshots/<name>. */
+  dir: string;
+  /** The committed fixture payload (author-owned input). */
+  payloadPath: string;
+  /** The golden rendered output (tool-managed, byte-exact). */
+  snapPath: string;
+}
+
+export function snapshotPaths(cwd: string, templateName: string): SnapshotPaths {
+  const dir = join(cwd, ".metaobjects", "snapshots", templateName);
+  return {
+    dir,
+    payloadPath: join(dir, "payload.json"),
+    snapPath: join(dir, "output.snap"),
+  };
+}
+
+// A compact line diff: trim the common leading/trailing lines, then show the
+// differing middle as `- <expected>` followed by `+ <actual>`. Enough to make
+// drift reviewable in CI output without pulling in a diff dependency.
+export function unifiedDiff(expected: string, actual: string): string {
+  const e = expected.split("\n");
+  const a = actual.split("\n");
+
+  let pre = 0;
+  while (pre < e.length && pre < a.length && e[pre] === a[pre]) pre++;
+
+  let suf = 0;
+  while (
+    suf < e.length - pre &&
+    suf < a.length - pre &&
+    e[e.length - 1 - suf] === a[a.length - 1 - suf]
+  ) {
+    suf++;
+  }
+
+  const eMid = e.slice(pre, e.length - suf);
+  const aMid = a.slice(pre, a.length - suf);
+
+  const out: string[] = [`@@ line ${pre + 1} @@`];
+  for (const line of eMid) out.push(`- ${line}`);
+  for (const line of aMid) out.push(`+ ${line}`);
+  return out.join("\n");
+}

package/src/lib/wrangler.ts

@@ -0,0 +1,45 @@
+import { execFile as execFileCb } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCb);
+
+export interface WranglerExecuteOptions {
+  binding: string;
+  remote: boolean;
+  command: string;
+  configPath: string | undefined;
+}
+
+export function buildWranglerExecuteArgs(opts: WranglerExecuteOptions): string[] {
+  const args: string[] = [
+    "d1", "execute", opts.binding,
+    opts.remote ? "--remote" : "--local",
+    "--json",
+    "--command", opts.command,
+  ];
+  if (opts.configPath !== undefined) {
+    args.push("--config", opts.configPath);
+  }
+  return args;
+}
+
+/**
+ * Run wrangler with the given args; return stdout. Stderr is included in the
+ * error message when wrangler exits non-zero. `cwd` is the directory wrangler
+ * runs in (defaults to process.cwd() — caller should pass the project root).
+ */
+export type WranglerRunner = (args: string[], cwd: string) => Promise<{ stdout: string; stderr: string }>;
+
+export const defaultWranglerRunner: WranglerRunner = async (args, cwd) => {
+  try {
+    const { stdout, stderr } = await execFile("wrangler", args, { cwd, maxBuffer: 16 * 1024 * 1024 });
+    return { stdout, stderr };
+  } catch (err) {
+    const e = err as NodeJS.ErrnoException & { stderr?: string; stdout?: string };
+    if (e.code === "ENOENT") {
+      throw new Error(`wrangler not found on PATH; install it: 'npm i -D wrangler'`);
+    }
+    const stderr = e.stderr ?? "";
+    throw new Error(`wrangler ${args.join(" ")} failed: ${stderr || e.message}`);
+  }
+};