@cargo-ai/cdk 1.0.6 → 1.0.8

package/build/src/cli/commands/from.js

@@ -0,0 +1,285 @@
+// `cdk init <dir> --from <source>` — scaffold from a GitHub repo instead of a
+// bundled template. The source names a repo or a folder inside one
+// (`owner/repo`, `owner/repo/folder`, `owner/repo/folder@ref`, or a
+// github.com URL). The repo is fetched with a shallow `git clone`, so private
+// sources work through the user's existing git auth.
+//
+// The manifest is OPTIONAL — any repo/folder scaffolds without it. A repo of
+// composable folders (e.g. cargo-cookbooks) can ship a `cargo.scaffold.json`
+// at its root to declare cross-folder dependencies:
+//
+//   {
+//     "shared": ["package.json", "tsconfig.json"],
+//     "folders": { "signal-based-tam": { "requires": ["base-gtm"] } }
+//   }
+//
+// When the requested folder is declared there, the scaffold keeps the repo's
+// folder layout and also copies its `requires` folders (transitively) plus the
+// `shared` root files — so cross-folder imports like
+// `../base-gtm/models/accounts` keep resolving. Any other source copies the
+// folder's contents flat into the target directory.
+import { execFile } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { copyDirectory } from "./templates.js";
+const execFileAsync = promisify(execFile);
+const SEGMENT_PATTERN = /^[\w][\w.-]*$/;
+/** Reject absolute paths, `..`, `.`, and empty segments in repo-relative paths. */
+export function assertSafeRepoRelativePath(repoRelativePath, label) {
+    if (repoRelativePath === "") {
+        return;
+    }
+    if (isAbsolute(repoRelativePath)) {
+        throw new Error(`Invalid ${label}: absolute paths are not allowed.`);
+    }
+    const segments = repoRelativePath.split(/[/\\]/);
+    for (const segment of segments) {
+        if (segment === "" || segment === "." || segment === "..") {
+            throw new Error(`Invalid ${label}: "${repoRelativePath}" contains an unsafe path segment.`);
+        }
+    }
+}
+/** Join `relativePath` under `baseDir` and ensure the result cannot escape it. */
+export function resolveWithin(baseDir, relativePath) {
+    const resolvedBase = resolve(baseDir);
+    const resolved = resolve(resolvedBase, relativePath);
+    const rel = relative(resolvedBase, resolved);
+    if (rel === "" || rel === ".") {
+        return resolvedBase;
+    }
+    if (rel.startsWith("..") || isAbsolute(rel)) {
+        throw new Error(`Path "${relativePath}" escapes "${baseDir}".`);
+    }
+    return resolved;
+}
+function assertSafeSubPath(subPath) {
+    try {
+        assertSafeRepoRelativePath(subPath, "source folder");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateManifestPaths(manifest) {
+    for (const file of manifest.shared) {
+        assertSafeRepoRelativePath(file, `${MANIFEST_FILENAME} shared entry`);
+    }
+    for (const [folder, entry] of Object.entries(manifest.folders)) {
+        assertSafeRepoRelativePath(folder, `${MANIFEST_FILENAME} folder key`);
+        for (const required of entry.requires) {
+            assertSafeRepoRelativePath(required, `${MANIFEST_FILENAME} requires entry for "${folder}"`);
+        }
+    }
+}
+/**
+ * Parse a `--from` source. Accepts `owner/repo[/sub/path][@ref]`, the same
+ * with a `github.com` / `git@github.com:` prefix, and GitHub tree URLs
+ * (`github.com/owner/repo/tree/<ref>/<sub/path>`). Returns `undefined` when
+ * the source doesn't name a GitHub repo.
+ */
+export function parseFromRef(raw) {
+    const trimmed = raw.trim();
+    const isGitHubUrl = /^https?:\/\/(www\.)?github\.com\//.test(trimmed) ||
+        /^git@github\.com:/.test(trimmed);
+    const stripped = trimmed
+        .replace(/^git@github\.com:/, "")
+        .replace(/^https?:\/\/(www\.)?github\.com\//, "")
+        .replace(/\/+$/, "");
+    if (stripped.includes("://") || stripped.startsWith("git@")) {
+        return undefined;
+    }
+    const atIndex = stripped.lastIndexOf("@");
+    const path = atIndex === -1 ? stripped : stripped.slice(0, atIndex);
+    const refSuffix = atIndex === -1 ? "" : stripped.slice(atIndex + 1);
+    if (atIndex !== -1 && refSuffix === "")
+        return undefined;
+    const segments = path.split("/").filter((segment) => segment !== "");
+    const [owner, repoRaw] = segments;
+    if (owner === undefined || repoRaw === undefined)
+        return undefined;
+    const repo = repoRaw.replace(/\.git$/, "");
+    if (SEGMENT_PATTERN.test(owner) === false ||
+        SEGMENT_PATTERN.test(repo) === false) {
+        return undefined;
+    }
+    // A tree URL pins its ref in the path: owner/repo/tree/<ref>/<sub/path>.
+    // Only apply for full GitHub URLs — otherwise "tree" may be a real folder
+    // (e.g. owner/repo/tree/my-feature).
+    if (isGitHubUrl && segments[2] === "tree") {
+        const treeRef = segments[3];
+        if (treeRef === undefined || refSuffix !== "")
+            return undefined;
+        const subPath = segments.slice(4).join("/");
+        if (assertSafeSubPath(subPath) === false)
+            return undefined;
+        return {
+            owner,
+            repo,
+            subPath,
+            gitRef: treeRef,
+        };
+    }
+    const subPath = segments.slice(2).join("/");
+    if (assertSafeSubPath(subPath) === false)
+        return undefined;
+    return {
+        owner,
+        repo,
+        subPath,
+        gitRef: refSuffix,
+    };
+}
+const manifestSchema = z.object({
+    shared: z.array(z.string()).default([]),
+    folders: z
+        .record(z.string(), z.object({ requires: z.array(z.string()).default([]) }))
+        .default({}),
+});
+export const MANIFEST_FILENAME = "cargo.scaffold.json";
+// Read the manifest file's raw contents; undefined when it doesn't exist
+// (ENOENT), rethrowing any other read error.
+async function readManifestFile(manifestPath) {
+    try {
+        return await fs.readFile(manifestPath, "utf-8");
+    }
+    catch (error) {
+        if (error !== null &&
+            typeof error === "object" &&
+            "code" in error &&
+            error.code === "ENOENT") {
+            return undefined;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read ${MANIFEST_FILENAME} in the source repo: ${message}`);
+    }
+}
+// Parse the manifest text, turning a JSON syntax error into a clear message.
+function parseManifestJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid ${MANIFEST_FILENAME} in the source repo: ${message}`);
+    }
+}
+/** Read and validate `cargo.scaffold.json` at the repo root, if present. */
+export async function readManifest(repoDir) {
+    const manifestPath = join(repoDir, MANIFEST_FILENAME);
+    const raw = await readManifestFile(manifestPath);
+    if (raw === undefined)
+        return undefined;
+    const json = parseManifestJson(raw);
+    const parsed = manifestSchema.safeParse(json);
+    if (parsed.success === false) {
+        throw new Error(`Invalid ${MANIFEST_FILENAME} in the source repo: ${z.prettifyError(parsed.error)}`);
+    }
+    validateManifestPaths(parsed.data);
+    return parsed.data;
+}
+/**
+ * Decide what to copy. A manifest-declared folder keeps the repo layout and
+ * brings its transitive `requires` plus the shared root files; anything else
+ * is a flat copy of the requested folder (or the whole repo).
+ */
+export function planCopies(manifest, subPath) {
+    const declared = manifest === undefined ? undefined : manifest.folders[subPath];
+    if (manifest === undefined || declared === undefined || subPath === "") {
+        return { folders: [subPath], files: [], flatten: true };
+    }
+    const folders = [];
+    const queue = [subPath];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (current === undefined || folders.includes(current))
+            continue;
+        folders.push(current);
+        const entry = manifest.folders[current];
+        if (entry !== undefined)
+            queue.push(...entry.requires);
+    }
+    return { folders, files: manifest.shared, flatten: false };
+}
+/**
+ * Shallow-clone the repo into a temp dir. Returns the dir and its cleanup.
+ * `remoteUrl` overrides the GitHub URL (tests clone from a local repo).
+ */
+export async function cloneGitHubRepo(ref, remoteUrl) {
+    const dir = await fs.mkdtemp(join(tmpdir(), "cargo-cdk-from-"));
+    const url = remoteUrl === undefined
+        ? `https://github.com/${ref.owner}/${ref.repo}.git`
+        : remoteUrl;
+    const branchArgs = ref.gitRef === "" ? [] : ["--branch", ref.gitRef];
+    try {
+        await execFileAsync("git", [
+            "clone",
+            "--depth",
+            "1",
+            "--quiet",
+            ...branchArgs,
+            url,
+            dir,
+        ]);
+    }
+    catch (error) {
+        await fs.rm(dir, { recursive: true, force: true });
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not clone ${url}${ref.gitRef === "" ? "" : ` (ref ${ref.gitRef})`}. Is git installed and the repo accessible?\n${message}`);
+    }
+    // Drop the git metadata so a whole-repo copy never carries it over.
+    await fs.rm(join(dir, ".git"), { recursive: true, force: true });
+    return {
+        dir,
+        cleanup: () => fs.rm(dir, { recursive: true, force: true }),
+    };
+}
+/**
+ * Fetch the source and copy the planned folders/files into `targetDir`,
+ * substituting `__APP_NAME__`. Returns the copied repo-relative paths.
+ */
+export async function scaffoldFromGitHub(payload) {
+    const { ref, targetDir, appName, remoteUrl } = payload;
+    const rename = [{ from: "__APP_NAME__", to: appName }];
+    const { dir, cleanup } = await cloneGitHubRepo(ref, remoteUrl);
+    try {
+        if (ref.subPath !== "") {
+            assertSafeRepoRelativePath(ref.subPath, "source folder");
+            const subPathSrc = resolveWithin(dir, ref.subPath);
+            const stat = await fs.stat(subPathSrc).catch(() => undefined);
+            if (stat === undefined || stat.isDirectory() === false) {
+                throw new Error(`"${ref.subPath}" is not a folder in ${ref.owner}/${ref.repo}.`);
+            }
+        }
+        const manifest = await readManifest(dir);
+        const plan = planCopies(manifest, ref.subPath);
+        for (const folder of plan.folders) {
+            const src = resolveWithin(dir, folder);
+            const dest = plan.flatten ? targetDir : resolveWithin(targetDir, folder);
+            const stat = await fs.stat(src).catch(() => undefined);
+            if (stat === undefined || stat.isDirectory() === false) {
+                throw new Error(`Manifest folder "${folder}" is missing from ${ref.owner}/${ref.repo}.`);
+            }
+            await copyDirectory(src, dest, rename);
+        }
+        for (const file of plan.files) {
+            const src = resolveWithin(dir, file);
+            const stat = await fs.stat(src).catch(() => undefined);
+            if (stat === undefined || stat.isFile() === false) {
+                throw new Error(`Manifest shared file "${file}" is missing from ${ref.owner}/${ref.repo}.`);
+            }
+            const raw = await fs.readFile(src, "utf-8");
+            const replaced = rename.reduce((current, { from, to }) => current.split(from).join(to), raw);
+            const dest = resolveWithin(targetDir, file);
+            await fs.mkdir(dirname(dest), { recursive: true });
+            await fs.writeFile(dest, replaced, "utf-8");
+        }
+        return [...plan.folders, ...plan.files].filter((path) => path !== "");
+    }
+    finally {
+        await cleanup();
+    }
+}

package/build/src/cli/commands/init.d.ts

@@ -1,3 +1,3 @@
-import type { Command } from "commander";
+import { type Command } from "commander";
 export declare function registerInitCommand(parent: Command): void;
 //# sourceMappingURL=init.d.ts.map

package/build/src/cli/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAezC,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAyEzD"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,WAAW,CAAC;AAmBjD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAqGzD"}

package/build/src/cli/commands/init.js

@@ -1,11 +1,16 @@
 import { existsSync, readdirSync } from "node:fs";
 import { basename, dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { Option } from "commander";
 import { ExitCodes, failWith, info, success } from "../io.js";
+import { parseFromRef, scaffoldFromGitHub } from "./from.js";
 import { copyDirectory, listTemplates } from "./templates.js";
-// `cdk init <directory> [--template <slug>]` — scaffold a starter CDK project by
-// copying one of `@cargo-ai/cdk`'s bundled templates (see `--list-templates`),
-// substituting `__APP_NAME__`.
+// `cdk init <directory> [--template <slug>] [--from <source>]` — scaffold a
+// starter CDK project by copying one of `@cargo-ai/cdk`'s bundled templates
+// (see `--list-templates`) or fetching a GitHub source — e.g. a cookbook:
+// `cdk init my-tam --from getcargohq/cargo-cookbooks/signal-based-tam` — substituting
+// `__APP_NAME__`. Cookbook sources pull their required sibling folders via the
+// repo's `cargo.scaffold.json` (see `./from.ts`).
 const TEMPLATE_DESCRIPTIONS = {
     blank: "Minimal starter — one connector + model + a workflow-backed tool. Good starting point.",
     full: "The full example — every resource type wired into a GTM growth workspace: connectors, models, plays, agents, an MCP server, context, tools, a worker, and a hosted app.",
@@ -14,7 +19,10 @@ export function registerInitCommand(parent) {
     parent
         .command("init <directory>")
         .description("Scaffold a starter Cargo CDK project locally from a template (ready to plan/deploy).")
-        .option("--template <slug>", "Template slug (default: blank)", "blank")
+        .addOption(new Option("--template <slug>", "Template slug (default: blank)")
+        .default("blank")
+        .conflicts("from"))
+        .option("--from <source>", "GitHub source to scaffold from instead of a template — owner/repo[/folder][@ref] or a github.com URL. Cookbook folders also pull their required siblings (repo's cargo.scaffold.json).")
         .option("--name <name>", "Project name written into package.json")
         .option("--list-templates", "Print available templates and exit")
         .option("--force", "Write into a non-empty directory")
@@ -23,16 +31,12 @@ export function registerInitCommand(parent) {
         if (opts.listTemplates === true) {
             const slugs = await listTemplates(templatesRoot);
             for (const slug of slugs) {
-                const desc = TEMPLATE_DESCRIPTIONS[slug] ?? "";
+                const described = TEMPLATE_DESCRIPTIONS[slug];
+                const desc = described === undefined ? "" : described;
                 info(`${slug}${desc.length > 0 ? ` — ${desc}` : ""}`);
             }
             return;
         }
-        const templateDir = join(templatesRoot, opts.template);
-        if (!existsSync(templateDir)) {
-            const slugs = await listTemplates(templatesRoot);
-            failWith(`Unknown template "${opts.template}". Available: ${slugs.join(", ")}`, { code: ExitCodes.GenericError });
-        }
         const targetDir = resolve(process.cwd(), directory);
         if (existsSync(targetDir) &&
             readdirSync(targetDir).length > 0 &&
@@ -40,10 +44,26 @@ export function registerInitCommand(parent) {
             failWith(`Directory ${directory} is not empty. Pass --force to scaffold into it anyway.`, { code: ExitCodes.GenericError });
         }
         const appName = opts.name !== undefined ? opts.name : basename(targetDir);
-        await copyDirectory(templateDir, targetDir, [
-            { from: "__APP_NAME__", to: appName },
-        ]);
-        success(`Scaffolded ${directory} from the "${opts.template}" template`);
+        if (opts.from !== undefined) {
+            const ref = parseFromRef(opts.from);
+            if (ref === undefined) {
+                failWith(`Could not parse --from "${opts.from}". Expected owner/repo[/folder][@ref] or a github.com URL.`, { code: ExitCodes.GenericError });
+            }
+            const copied = await scaffoldFromGitHub({ ref, targetDir, appName });
+            const detail = copied.length > 0 ? ` (${copied.join(", ")})` : "";
+            success(`Scaffolded ${directory} from ${ref.owner}/${ref.repo}${ref.subPath === "" ? "" : `/${ref.subPath}`}${detail}`);
+        }
+        else {
+            const templateDir = join(templatesRoot, opts.template);
+            if (existsSync(templateDir) === false) {
+                const slugs = await listTemplates(templatesRoot);
+                failWith(`Unknown template "${opts.template}". Available: ${slugs.join(", ")}`, { code: ExitCodes.GenericError });
+            }
+            await copyDirectory(templateDir, targetDir, [
+                { from: "__APP_NAME__", to: appName },
+            ]);
+            success(`Scaffolded ${directory} from the "${opts.template}" template`);
+        }
         info(``);
         info([
             `Next steps:`,
@@ -62,15 +82,19 @@ export function registerInitCommand(parent) {
 // unrelated `templates/` dir along the way). Works both from the monorepo build
 // output and an installed `node_modules/@cargo-ai/cdk`.
 function findTemplatesRoot() {
-    let cursor = dirname(fileURLToPath(import.meta.url));
-    for (let i = 0; i < 8; i += 1) {
+    const start = dirname(fileURLToPath(import.meta.url));
+    for (const cursor of ancestorDirs(start, 8)) {
         const candidate = join(cursor, "templates");
         if (existsSync(join(candidate, "blank")))
             return candidate;
-        const parent = dirname(cursor);
-        if (parent === cursor)
-            break;
-        cursor = parent;
     }
     throw new Error("Could not locate the @cargo-ai/cdk templates directory. Reinstall @cargo-ai/cdk if this persists.");
 }
+// The directory chain from `start` walking up to `max` levels, stopping at the
+// filesystem root — so a marker file/dir can be located independent of build depth.
+function ancestorDirs(start, max) {
+    const parent = dirname(start);
+    if (max <= 1 || parent === start)
+        return [start];
+    return [start, ...ancestorDirs(parent, max - 1)];
+}

package/build/src/cli/commands/inputTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inputTypes.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/inputTypes.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAE+D,CAAC;AAEjG;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQ3D;AAkMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU5E"}
+{"version":3,"file":"inputTypes.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/inputTypes.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAE+D,CAAC;AAEjG;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQ3D;AAmTD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU5E"}

package/build/src/cli/commands/inputTypes.js

@@ -83,10 +83,20 @@ function printSchema(schema, topLevel, encRef) {
         // Connectors model "pick an auth method, then its fields" as an object with
         // a discriminant property plus `allOf: [{ if, then, else }]`. Expand that to
         // a discriminated union (e.g. HubSpot → `{ method: "privateApp"; … } | { …
-        // "oauth"; … }`); otherwise fall back to rendering the head.
+        // "oauth"; … }`).
         const conditional = printConditionalObject(schema, topLevel, encRef);
         if (conditional !== undefined)
             return conditional;
+        // General case: expand the `allOf` into the distinct object shapes it allows
+        // (see `flattenAllOf`) and render them as a union — e.g. Slack postMessage →
+        // `{ channelId; … format: "markdown"; body } | { … format: "blockKit";
+        // blocks }`. This keeps the base props AND the variant members instead of
+        // dropping either.
+        const shapes = flattenAllOf(schema);
+        if (shapes.length > 0) {
+            return uniqueUnion(shapes.map((s) => printObjectShape(s, topLevel, encRef)));
+        }
+        // Last resort: render the head (never abort codegen on an odd schema).
         return printSchema(schema.allOf[0], topLevel, encRef);
     }
     if (typeof schema.type !== "string")
@@ -120,10 +130,14 @@ function printConditionalObject(schema, topLevel, encRef) {
     if (props === undefined || schema.allOf === undefined)
         return undefined;
     const block = schema.allOf.find((a) => a.if !== undefined);
-    if (block === undefined || block.if?.properties === undefined)
+    if (block === undefined)
+        return undefined;
+    const blockIf = block.if;
+    if (blockIf === undefined || blockIf.properties === undefined) {
         return undefined;
+    }
     // The discriminant: the single property the `if` tests, and its `const` value.
-    const ifEntries = Object.entries(block.if.properties);
+    const ifEntries = Object.entries(blockIf.properties);
     if (ifEntries.length !== 1)
         return undefined;
     const [discKey, discCond] = ifEntries[0];
@@ -143,11 +157,11 @@ function printConditionalObject(schema, topLevel, encRef) {
             ...props,
             [discKey]: { const: value },
         };
-        if (extra?.properties !== undefined) {
+        if (extra !== undefined && extra.properties !== undefined) {
             Object.assign(branchProps, extra.properties);
         }
         const required = new Set(baseRequired);
-        if (Array.isArray(extra?.required)) {
+        if (extra !== undefined && Array.isArray(extra.required)) {
             for (const r of extra.required)
                 required.add(r);
         }
@@ -162,7 +176,7 @@ function discriminantValues(schema) {
         return [schema.const];
     if (Array.isArray(schema.enum))
         return schema.enum;
-    const variants = schema.oneOf ?? schema.anyOf;
+    const variants = schema.oneOf !== undefined ? schema.oneOf : schema.anyOf;
     if (Array.isArray(variants)) {
         const consts = variants.map((v) => v.const).filter((v) => v !== undefined);
         if (consts.length > 0)
@@ -170,6 +184,63 @@ function discriminantValues(schema) {
     }
     return [];
 }
+function flattenAllOf(schema) {
+    const { allOf = [] } = schema;
+    const base = objectShapeOf(schema);
+    const seed = base === undefined ? emptyShape() : base;
+    return allOf.map(shapesOf).reduce(crossMerge, [seed]);
+}
+// The object shape(s) a single allOf member contributes: one for a plain object,
+// several for an `anyOf`/`oneOf`, or a nested `allOf`'s result. Empty when the
+// member (or any `anyOf`/`oneOf` variant) isn't object-shaped.
+function shapesOf(member) {
+    const { allOf, anyOf, oneOf } = member;
+    if (allOf !== undefined && allOf.length > 0) {
+        return flattenAllOf(member);
+    }
+    const variants = anyOf !== undefined ? anyOf : oneOf;
+    if (variants !== undefined && variants.length > 0) {
+        const shapes = variants
+            .map(objectShapeOf)
+            .filter((shape) => shape !== undefined);
+        // A non-object variant drops out above; if any did, the union is incomplete
+        // so give up on the whole member rather than emit a narrower type.
+        return shapes.length === variants.length ? shapes : [];
+    }
+    const shape = objectShapeOf(member);
+    return shape === undefined ? [] : [shape];
+}
+// Every current shape merged with every option: {a} × [{b}, {c}] → [{ab}, {ac}].
+function crossMerge(shapes, options) {
+    return shapes.flatMap((shape) => options.map((option) => mergeShapes(shape, option)));
+}
+// Read a schema as an object shape (its properties + required), or undefined
+// when it isn't object-shaped.
+function objectShapeOf(schema) {
+    const { properties, type, required } = schema;
+    if (properties === undefined && type !== "object")
+        return undefined;
+    return {
+        properties: { ...properties },
+        required: new Set(Array.isArray(required) ? required : []),
+    };
+}
+function mergeShapes(a, b) {
+    return {
+        properties: { ...a.properties, ...b.properties },
+        required: new Set([...a.required, ...b.required]),
+    };
+}
+function emptyShape() {
+    return { properties: {}, required: new Set() };
+}
+function printObjectShape(shape, topLevel, encRef) {
+    return printObject({
+        type: "object",
+        properties: shape.properties,
+        required: [...shape.required],
+    }, topLevel, encRef);
+}
 function printArray(schema, encRef) {
     if (schema.items === undefined)
         return "unknown[]";

package/build/src/cli/commands/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2FzC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CA8D7E"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiHzC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CAgE7E"}