@voyantjs/cli 0.1.0

package/LICENSE

@@ -0,0 +1,109 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 PixelMakers Studio SRL
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly
+display and redistribute the Software for any Permitted Purpose identified
+below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing
+Use means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe
+our patents, the license grant above includes a license under our patents.
+If you make a claim against any party that the Software infringes or
+contributes to the infringement of any patent, then your patent license to
+the Software ends immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives
+of the Software.
+
+If you redistribute any copies, modifications or derivatives of the
+Software, you must include a copy of or a link to these Terms and Conditions
+and not remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A
+PARTICULAR PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO
+THE SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL
+DAMAGES, EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin
+of the Software, you have no right under these Terms and Conditions to use
+our trademarks, trade names, service marks or product names.
+
+---
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software
+under the Apache License, Version 2.0 that is effective on the second
+anniversary of the date we make the Software available. On or after that
+date, you may use the Software under the Apache License, Version 2.0, in
+which case the following will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations
+under the License.

package/README.md

@@ -0,0 +1,59 @@
+# @voyantjs/cli
+
+The `voyant` CLI. Scaffolding, code generation, config loading, database commands, and a TypeScript script runner with native strip-types.
+
+## Install
+
+```bash
+pnpm add -D @voyantjs/cli
+```
+
+Or as a global install:
+
+```bash
+npm install -g @voyantjs/cli
+```
+
+Built-in starters can be referenced by name:
+
+```bash
+voyant new my-app --template dmc
+voyant new my-app --template operator
+```
+
+Built-in starters are downloaded from the matching GitHub Release for the installed CLI version.
+
+You can also point at a custom local template directory:
+
+```bash
+voyant new my-app --template ./templates/custom
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `voyant new <name> [--template <name\|path>] [--force]` | Clone a built-in or custom template into a new directory |
+| `voyant generate module <name> [--dir <path>]` | Scaffold a new module package (schema, validation, service, routes) |
+| `voyant generate link <a.entity> <b.entity>` | Print a `defineLink` snippet |
+| `voyant config <show\|validate\|path> [--path <file>]` | Load + inspect `voyant.config.ts` |
+| `voyant db <generate\|migrate\|studio\|push\|check>` | Drizzle-kit subcommands for the DMC template |
+| `voyant db sync-links [--links <path>] [--out <file>]` | Emit DDL for link pivot tables |
+| `voyant exec <script.ts> [args...]` | Run a TS script with native strip-types + extensionless imports |
+| `voyant --help` | Print usage |
+
+Requires Node 22.6+ for native TypeScript strip-types.
+
+## Exports
+
+| Entry | Description |
+| --- | --- |
+| `.` | CLI `main(argv, ctx)` entry point |
+| `./commands/*` | Individual command handlers |
+| `./lib/strings` | `toKebabCase`, `toCamelCase`, `toPascalCase` |
+| `./lib/args` | Hand-rolled arg parser |
+| `./lib/config-loader` | `voyant.config.*` loader |
+
+## License
+
+FSL-1.1-Apache-2.0

package/bin/voyant.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { main } from "../dist/index.js"
+
+main(process.argv.slice(2))
+  .then((code) => process.exit(code ?? 0))
+  .catch((err) => {
+    process.stderr.write(`${err?.stack ?? String(err)}\n`)
+    process.exit(1)
+  })

package/dist/commands/config.d.ts

@@ -0,0 +1,10 @@
+import type { CommandContext, CommandResult } from "../types.js";
+/**
+ * `voyant config <show|validate|path>`
+ *
+ * Inspects the voyant.config.* manifest discovered by walking parent
+ * directories from the current working directory. Used by other CLI
+ * commands and by users verifying their configuration shape.
+ */
+export declare function configCommand(ctx: CommandContext): Promise<CommandResult>;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/commands/config.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAEhE;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAwC/E"}

package/dist/commands/config.js

@@ -0,0 +1,90 @@
+import { resolveEntry, validateVoyantConfig, } from "@voyantjs/core/config";
+import { parseArgs } from "../lib/args.js";
+import { loadVoyantConfigFile, resolveConfigPath } from "../lib/config-loader.js";
+/**
+ * `voyant config <show|validate|path>`
+ *
+ * Inspects the voyant.config.* manifest discovered by walking parent
+ * directories from the current working directory. Used by other CLI
+ * commands and by users verifying their configuration shape.
+ */
+export async function configCommand(ctx) {
+    const { positionals, flags } = parseArgs(ctx.argv);
+    const sub = positionals[0] ?? "show";
+    const pathFlag = typeof flags.path === "string" ? flags.path : undefined;
+    const resolved = resolveConfigPath({ path: pathFlag, cwd: ctx.cwd });
+    if (!resolved) {
+        ctx.stderr(pathFlag
+            ? `No voyant config found at ${pathFlag}\n`
+            : `No voyant.config.* found in ${ctx.cwd} or any parent directory.\n`);
+        return 1;
+    }
+    if (sub === "path") {
+        ctx.stdout(`${resolved}\n`);
+        return 0;
+    }
+    let loaded;
+    try {
+        loaded = await loadVoyantConfigFile(resolved);
+    }
+    catch (err) {
+        ctx.stderr(`${err instanceof Error ? err.message : String(err)}\n`);
+        return 1;
+    }
+    const result = validateVoyantConfig(loaded.config);
+    if (sub === "validate") {
+        return emitValidation(ctx, loaded.path, result);
+    }
+    if (sub === "show") {
+        return emitShow(ctx, loaded.path, loaded.config, result);
+    }
+    ctx.stderr(`Unknown config subcommand: ${sub}. Expected "show", "validate", or "path".\n`);
+    return 1;
+}
+function emitValidation(ctx, path, result) {
+    if (result.ok) {
+        ctx.stdout(`voyant config ok: ${path}\n`);
+        return 0;
+    }
+    ctx.stderr(`voyant config invalid: ${path}\n`);
+    for (const issue of result.issues) {
+        ctx.stderr(`  - ${issue.path || "(root)"}: ${issue.message}\n`);
+    }
+    return 1;
+}
+function emitShow(ctx, path, config, validation) {
+    ctx.stdout(`voyant config: ${path}\n`);
+    if (!validation.ok) {
+        ctx.stderr(`\nManifest has ${validation.issues.length} issue(s):\n`);
+        for (const issue of validation.issues) {
+            ctx.stderr(`  - ${issue.path || "(root)"}: ${issue.message}\n`);
+        }
+        return 1;
+    }
+    const cfg = config;
+    ctx.stdout(`\nDeployment: ${cfg.deployment ?? "(unset)"}\n`);
+    const modules = cfg.modules ?? [];
+    ctx.stdout(`Modules (${modules.length}):\n`);
+    for (const entry of modules) {
+        const { resolve, options } = resolveEntry(entry);
+        const opts = Object.keys(options).length > 0 ? ` [${Object.keys(options).join(", ")}]` : "";
+        ctx.stdout(`  - ${resolve}${opts}\n`);
+    }
+    const plugins = cfg.plugins ?? [];
+    ctx.stdout(`Plugins (${plugins.length}):\n`);
+    for (const entry of plugins) {
+        const { resolve, options } = resolveEntry(entry);
+        const opts = Object.keys(options).length > 0 ? ` [${Object.keys(options).join(", ")}]` : "";
+        ctx.stdout(`  - ${resolve}${opts}\n`);
+    }
+    if (cfg.admin) {
+        ctx.stdout(`Admin: enabled=${cfg.admin.enabled ?? false} path=${cfg.admin.path ?? "(unset)"}\n`);
+    }
+    if (cfg.featureFlags && Object.keys(cfg.featureFlags).length > 0) {
+        ctx.stdout("Feature flags:\n");
+        for (const [key, value] of Object.entries(cfg.featureFlags)) {
+            ctx.stdout(`  - ${key}: ${value}\n`);
+        }
+    }
+    return 0;
+}

package/dist/commands/db-sync-links.d.ts

@@ -0,0 +1,19 @@
+import type { CommandContext, CommandResult } from "../types.js";
+/**
+ * `voyant db sync-links [--links <path>] [--template <path>] [--out <file>]`
+ *
+ * Loads a template's link definitions and prints the DDL produced by
+ * {@link generateLinkTableSql} — one `CREATE TABLE` + N indexes per link.
+ *
+ * MVP: prints SQL to stdout (or to `--out <file>`). Does not touch the
+ * database. Pair with `psql` / `drizzle-kit push` to apply the DDL.
+ *
+ * The target file must export either a named `links` array or a default-
+ * exported array of {@link LinkDefinition} objects.
+ *
+ * For `.ts` source files, this command spawns a Node subprocess with
+ * `--experimental-strip-types --experimental-transform-types` so that
+ * NodeNext-style `.js` import specifiers resolve to sibling `.ts` files.
+ */
+export declare function dbSyncLinksCommand(ctx: CommandContext): Promise<CommandResult>;
+//# sourceMappingURL=db-sync-links.d.ts.map

package/dist/commands/db-sync-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db-sync-links.d.ts","sourceRoot":"","sources":["../../src/commands/db-sync-links.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAiBhE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA4CpF"}

package/dist/commands/db-sync-links.js

@@ -0,0 +1,250 @@
+import { spawn } from "node:child_process";
+import { existsSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { generateLinkTableSql } from "@voyantjs/core/links";
+import { parseArgs } from "../lib/args.js";
+/**
+ * Candidate locations (relative to a template root) where a `links` array
+ * may live. Probed in declaration order, first hit wins.
+ */
+const DEFAULT_LINKS_PATHS = [
+    "src/links/index.ts",
+    "src/links/index.mts",
+    "src/links/index.mjs",
+    "src/links/index.js",
+    "src/links.ts",
+    "src/links.mts",
+    "src/links.mjs",
+    "src/links.js",
+];
+/**
+ * `voyant db sync-links [--links <path>] [--template <path>] [--out <file>]`
+ *
+ * Loads a template's link definitions and prints the DDL produced by
+ * {@link generateLinkTableSql} — one `CREATE TABLE` + N indexes per link.
+ *
+ * MVP: prints SQL to stdout (or to `--out <file>`). Does not touch the
+ * database. Pair with `psql` / `drizzle-kit push` to apply the DDL.
+ *
+ * The target file must export either a named `links` array or a default-
+ * exported array of {@link LinkDefinition} objects.
+ *
+ * For `.ts` source files, this command spawns a Node subprocess with
+ * `--experimental-strip-types --experimental-transform-types` so that
+ * NodeNext-style `.js` import specifiers resolve to sibling `.ts` files.
+ */
+export async function dbSyncLinksCommand(ctx) {
+    const { flags } = parseArgs(ctx.argv);
+    const linksPath = resolveLinksPath(ctx.cwd, flags);
+    if (!linksPath) {
+        ctx.stderr("Could not find a links file. " +
+            "Pass --links <path> or --template <path>, or run this from a template directory.\n");
+        return 1;
+    }
+    let links;
+    try {
+        links = await loadLinks(linksPath);
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        ctx.stderr(`Failed to load links from ${linksPath}: ${reason}\n`);
+        return 1;
+    }
+    if (links.length === 0) {
+        ctx.stderr(`No link definitions exported from ${linksPath}\n`);
+        return 1;
+    }
+    const sql = renderLinksSql(links, linksPath);
+    const outFlag = flags.out;
+    if (typeof outFlag === "string") {
+        const outPath = isAbsolute(outFlag) ? outFlag : resolve(ctx.cwd, outFlag);
+        try {
+            writeFileSync(outPath, sql);
+        }
+        catch (err) {
+            const reason = err instanceof Error ? err.message : String(err);
+            ctx.stderr(`Failed to write ${outPath}: ${reason}\n`);
+            return 1;
+        }
+        ctx.stdout(`Wrote ${links.length} link table(s) to ${outPath}\n`);
+        return 0;
+    }
+    ctx.stdout(sql);
+    return 0;
+}
+function resolveLinksPath(cwd, flags) {
+    // --links <path> takes priority.
+    if (typeof flags.links === "string") {
+        const abs = isAbsolute(flags.links) ? flags.links : resolve(cwd, flags.links);
+        return existsSync(abs) ? abs : null;
+    }
+    // --template <path> locks us to a single template root.
+    const templateOverride = typeof flags.template === "string" ? flags.template : null;
+    const roots = templateOverride
+        ? [isAbsolute(templateOverride) ? templateOverride : resolve(cwd, templateOverride)]
+        : [join(cwd, "templates/dmc"), cwd];
+    for (const root of roots) {
+        for (const rel of DEFAULT_LINKS_PATHS) {
+            const candidate = join(root, rel);
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+async function loadLinks(absPath) {
+    const isTypeScript = /\.(m|c)?ts$/i.test(absPath);
+    const raw = isTypeScript
+        ? await loadLinksViaSubprocess(absPath)
+        : await loadLinksViaImport(absPath);
+    if (!Array.isArray(raw)) {
+        throw new Error("expected a named export `links` or a default-exported array of LinkDefinition");
+    }
+    // Shape-check each entry so we fail with a useful message.
+    for (const [i, def] of raw.entries()) {
+        if (!def || typeof def !== "object") {
+            throw new Error(`links[${i}] is not an object`);
+        }
+        const d = def;
+        if (!d.tableName || !d.leftColumn || !d.rightColumn || !d.left || !d.right) {
+            throw new Error(`links[${i}] is not a LinkDefinition (missing tableName/leftColumn/rightColumn/left/right)`);
+        }
+    }
+    return raw;
+}
+async function loadLinksViaImport(absPath) {
+    const href = pathToFileURL(absPath).href;
+    const mod = (await import(href));
+    return mod.links ?? mod.default;
+}
+/**
+ * Node loader hook that rewrites NodeNext-style `.js` specifiers to the
+ * matching TypeScript source on disk. This is what TypeScript's
+ * `rewriteRelativeImportExtensions` does at compile time; here we do it
+ * at resolve time so the template's source tree imports as-is.
+ *
+ * Emitted as a data: URL so we can ship it without touching the
+ * filesystem.
+ */
+const LOADER_HOOK_SRC = `
+import { existsSync, statSync } from "node:fs"
+import { fileURLToPath, pathToFileURL } from "node:url"
+function tryResolveTs(specifier, parentDir) {
+  // Rewrite NodeNext-style .js -> .ts / .mjs -> .mts / .cjs -> .cts.
+  if (specifier.endsWith(".js") || specifier.endsWith(".mjs") || specifier.endsWith(".cjs")) {
+    const ext = specifier.endsWith(".mjs") ? ".mjs" : specifier.endsWith(".cjs") ? ".cjs" : ".js"
+    const tsExt = ext === ".mjs" ? ".mts" : ext === ".cjs" ? ".cts" : ".ts"
+    const candidate = parentDir + "/" + specifier.slice(0, -ext.length) + tsExt
+    if (existsSync(candidate)) return candidate
+    return null
+  }
+  // Bundler-style extensionless imports: try .ts / .mts / /index.ts.
+  const base = parentDir + "/" + specifier
+  for (const ext of [".ts", ".mts", ".tsx"]) {
+    if (existsSync(base + ext)) return base + ext
+  }
+  try {
+    if (statSync(base).isDirectory()) {
+      for (const idx of ["/index.ts", "/index.mts", "/index.tsx"]) {
+        if (existsSync(base + idx)) return base + idx
+      }
+    }
+  } catch {}
+  return null
+}
+export async function resolve(specifier, context, nextResolve) {
+  if ((specifier.startsWith("./") || specifier.startsWith("../")) && context.parentURL) {
+    const parentPath = fileURLToPath(context.parentURL)
+    const lastSlash = parentPath.lastIndexOf("/")
+    const parentDir = lastSlash >= 0 ? parentPath.slice(0, lastSlash) : parentPath
+    const found = tryResolveTs(specifier, parentDir)
+    if (found) return nextResolve(pathToFileURL(found).href, context)
+  }
+  return nextResolve(specifier, context)
+}
+`;
+const REGISTER_HOOK_SRC = `import { register } from "node:module";` +
+    `register(${JSON.stringify(`data:text/javascript,${encodeURIComponent(LOADER_HOOK_SRC)}`)},` +
+    ` import.meta.url);`;
+/**
+ * Spawn a Node subprocess that imports the TypeScript file with
+ * transform-types + a resolver hook that rewrites `.js` specifiers to
+ * their `.ts` siblings. Prints the link array as JSON.
+ *
+ * LinkDefinitions are plain data (no functions), so JSON round-tripping
+ * preserves their shape.
+ */
+async function loadLinksViaSubprocess(absPath) {
+    const href = pathToFileURL(absPath).href;
+    // Marker prefix so we can skip over any logs / warnings emitted on
+    // stdout before the JSON payload.
+    const marker = "__VOYANT_LINKS_JSON__:";
+    const script = `import(${JSON.stringify(href)}).then((m)=>{` +
+        `const v=m.links??m.default;` +
+        `process.stdout.write(${JSON.stringify(marker)}+JSON.stringify(v??null));` +
+        `}).catch((e)=>{` +
+        `process.stderr.write(e?.stack??String(e));` +
+        `process.exit(1);` +
+        `});`;
+    const importHookUrl = `data:text/javascript,${encodeURIComponent(REGISTER_HOOK_SRC)}`;
+    const args = [
+        "--experimental-strip-types",
+        "--experimental-transform-types",
+        "--no-warnings",
+        `--import=${importHookUrl}`,
+        "--input-type=module",
+        "-e",
+        script,
+    ];
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn(process.execPath, args, { stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => {
+            stdout += d.toString();
+        });
+        child.stderr.on("data", (d) => {
+            stderr += d.toString();
+        });
+        child.on("error", (err) => rejectPromise(err));
+        child.on("exit", (code) => {
+            if (code !== 0) {
+                rejectPromise(new Error(stderr.trim() || `subprocess exited with code ${code}`));
+                return;
+            }
+            const idx = stdout.indexOf(marker);
+            if (idx < 0) {
+                rejectPromise(new Error("subprocess returned no link payload"));
+                return;
+            }
+            const payload = stdout.slice(idx + marker.length).trim();
+            try {
+                resolvePromise(JSON.parse(payload));
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                rejectPromise(new Error(`could not parse link payload: ${reason}`));
+            }
+        });
+    });
+}
+function renderLinksSql(links, sourcePath) {
+    const lines = [];
+    lines.push("-- Voyant link tables — generated by `voyant db sync-links`");
+    lines.push(`-- Source: ${sourcePath}`);
+    lines.push(`-- ${links.length} link${links.length === 1 ? "" : "s"}`);
+    lines.push("");
+    for (const link of links) {
+        const sql = generateLinkTableSql(link);
+        const leftRef = `${link.left.linkable.module}.${link.left.linkable.entity}`;
+        const rightRef = `${link.right.linkable.module}.${link.right.linkable.entity}`;
+        lines.push(`-- ${leftRef} <-> ${rightRef} (${link.cardinality})`);
+        lines.push(`${sql.createTable};`);
+        for (const idx of sql.indexes) {
+            lines.push(`${idx};`);
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/commands/db.d.ts

@@ -0,0 +1,18 @@
+import type { CommandContext, CommandResult } from "../types.js";
+/**
+ * `voyant db <subcommand>` — proxy drizzle-kit operations to the nearest
+ * template package that owns a `drizzle.config.ts`, plus Voyant-specific
+ * database helpers that don't map 1:1 onto drizzle-kit.
+ *
+ * Drizzle-kit proxies: `generate`, `migrate`, `studio`, `push`, `check`.
+ * Additional arguments are forwarded verbatim.
+ *
+ * Voyant helpers:
+ * - `sync-links` — emit DDL for cross-module link tables from a template's
+ *   `links` array (see {@link dbSyncLinksCommand}).
+ *
+ * Resolution order for drizzle-kit proxies (first hit wins): `--template
+ * <path>`, `templates/dmc`, or the current working directory.
+ */
+export declare function dbCommand(ctx: CommandContext): Promise<CommandResult>;
+//# sourceMappingURL=db.d.ts.map

package/dist/commands/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/commands/db.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGhE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA4C3E"}

package/dist/commands/db.js

@@ -0,0 +1,69 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "../lib/args.js";
+import { dbSyncLinksCommand } from "./db-sync-links.js";
+/**
+ * `voyant db <subcommand>` — proxy drizzle-kit operations to the nearest
+ * template package that owns a `drizzle.config.ts`, plus Voyant-specific
+ * database helpers that don't map 1:1 onto drizzle-kit.
+ *
+ * Drizzle-kit proxies: `generate`, `migrate`, `studio`, `push`, `check`.
+ * Additional arguments are forwarded verbatim.
+ *
+ * Voyant helpers:
+ * - `sync-links` — emit DDL for cross-module link tables from a template's
+ *   `links` array (see {@link dbSyncLinksCommand}).
+ *
+ * Resolution order for drizzle-kit proxies (first hit wins): `--template
+ * <path>`, `templates/dmc`, or the current working directory.
+ */
+export async function dbCommand(ctx) {
+    const { positionals, flags } = parseArgs(ctx.argv);
+    const [sub, ...rest] = positionals;
+    if (!sub) {
+        ctx.stderr("Usage: voyant db <generate|migrate|studio|push|check|sync-links> [...args]\n");
+        return 1;
+    }
+    // Voyant-specific helpers — do not proxy to drizzle-kit.
+    if (sub === "sync-links") {
+        const idx = ctx.argv.indexOf(sub);
+        const subArgs = idx >= 0 ? ctx.argv.slice(idx + 1) : [];
+        return dbSyncLinksCommand({ ...ctx, argv: subArgs });
+    }
+    const known = new Set(["generate", "migrate", "studio", "push", "check"]);
+    if (!known.has(sub)) {
+        ctx.stderr(`Unknown drizzle-kit subcommand: ${sub}\n`);
+        return 1;
+    }
+    const templateDir = resolveTemplateDir(ctx.cwd, flags.template);
+    if (!templateDir) {
+        ctx.stderr("Could not find a template with drizzle.config.ts. " +
+            "Run this command from the repo root, or pass --template <path>.\n");
+        return 1;
+    }
+    const args = ["drizzle-kit", sub, ...rest];
+    ctx.stdout(`> pnpm -C ${templateDir} ${args.join(" ")}\n`);
+    return new Promise((resolve) => {
+        const child = spawn("pnpm", ["-C", templateDir, ...args], {
+            stdio: "inherit",
+            shell: false,
+        });
+        child.on("exit", (code) => resolve(code ?? 0));
+        child.on("error", (err) => {
+            ctx.stderr(`Failed to spawn pnpm: ${err.message}\n`);
+            resolve(1);
+        });
+    });
+}
+function resolveTemplateDir(cwd, override) {
+    if (typeof override === "string") {
+        return existsSync(join(override, "drizzle.config.ts")) ? override : null;
+    }
+    const candidates = [join(cwd, "templates/dmc"), cwd];
+    for (const candidate of candidates) {
+        if (existsSync(join(candidate, "drizzle.config.ts")))
+            return candidate;
+    }
+    return null;
+}

package/dist/commands/exec.d.ts

@@ -0,0 +1,20 @@
+import type { CommandContext, CommandResult } from "../types.js";
+/**
+ * `voyant exec <script> [args...]`
+ *
+ * Run a TypeScript/JavaScript script inside a Node subprocess with
+ * `--experimental-strip-types --experimental-transform-types` + the
+ * voyant loader hook (so bundler-style and `.js`→`.ts` imports work
+ * out of the box).
+ *
+ * The script receives `args` via `process.argv` starting at position 2
+ * (standard Node behavior). Stdout/stderr are inherited, so the
+ * script can log freely and its exit code propagates.
+ *
+ * Use this for:
+ * - one-off migrations or data tasks
+ * - exercising workspace code without bundling
+ * - reproducing test cases that hit real module code paths
+ */
+export declare function execCommand(ctx: CommandContext): Promise<CommandResult>;
+//# sourceMappingURL=exec.d.ts.map

package/dist/commands/exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec.d.ts","sourceRoot":"","sources":["../../src/commands/exec.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAmDhE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CA6C7E"}