cronus-ui 0.6.0

package/dist/commands/add.js

@@ -0,0 +1,114 @@
+import { CLI_VERSION, hasConfig, readConfig, writeConfig, } from "../config.js";
+import { Registry, registrySourceVersion } from "../registry.js";
+import { closestName, collectDependencies, detectPackageManager, log, runInstall, writeItemFiles, } from "../utils.js";
+export async function add(names, options) {
+    const { cwd } = options;
+    if (!hasConfig(cwd)) {
+        log.err("No cronus-ui.json found. Run `cronus-ui init` first.");
+        process.exitCode = 1;
+        return;
+    }
+    if (names.length === 0) {
+        log.err("Specify at least one component, e.g. `cronus-ui add button card`.");
+        process.exitCode = 1;
+        return;
+    }
+    const config = await readConfig(cwd);
+    const registry = new Registry(options.registry ?? config.registry);
+    // Validate requested names against the registry index up front so a typo gets
+    // a "did you mean" hint instead of an opaque 404 from resolve(). If the index
+    // itself cannot be read we fall through and let resolve() report the failure.
+    try {
+        const available = (await registry.index()).map((i) => i.name);
+        const known = new Set(available);
+        const unknown = names.filter((name) => !known.has(name));
+        if (unknown.length > 0) {
+            for (const name of unknown) {
+                const suggestion = closestName(name, available);
+                log.err(suggestion
+                    ? `Unknown item "${name}". Did you mean "${suggestion}"?`
+                    : `Unknown item "${name}".`);
+            }
+            log.step("Run `cronus-ui list` to see all available items.");
+            process.exitCode = 1;
+            return;
+        }
+    }
+    catch {
+        // Index unavailable (e.g. offline local registry) — defer to resolve() below.
+    }
+    let items;
+    try {
+        items = await registry.resolve(names);
+    }
+    catch (err) {
+        log.err(`Failed to resolve from registry: ${err.message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const requested = new Set(names);
+    // Transitive registry items pulled in to satisfy a requested item's
+    // registryDependencies. Blocks import the @cronus-ui/ui package rather than
+    // copied source, so they never pull in components — only ui/lib items do.
+    const pulledIn = items.filter((i) => !requested.has(i.name) && (i.type === "registry:ui" || i.type === "registry:lib"));
+    const blockCount = items.filter((i) => requested.has(i.name) && i.type === "registry:block").length;
+    const componentCount = names.length - blockCount;
+    const summary = [
+        componentCount > 0 ? `${componentCount} component(s)` : null,
+        blockCount > 0 ? `${blockCount} block(s)` : null,
+    ]
+        .filter(Boolean)
+        .join(" and ");
+    log.title(`Adding ${summary}`);
+    if (pulledIn.length > 0) {
+        log.step(`Pulling in dependencies: ${pulledIn.map((i) => i.name).join(", ")}`);
+    }
+    // The registry release these files come from — recorded in the install
+    // manifest so `upgrade` can later fetch the exact merge base. Sources without
+    // a version segment (e.g. a local dir) are pinned to the running CLI version.
+    const sourceUsed = options.registry ?? config.registry;
+    const installedVersion = registrySourceVersion(sourceUsed) ?? CLI_VERSION;
+    const installed = { ...config.installed };
+    let manifestChanged = false;
+    const allWritten = [];
+    const allSkipped = [];
+    for (const item of items) {
+        const { written, skipped } = await writeItemFiles(item, config, cwd, {
+            overwrite: options.overwrite ?? false,
+        });
+        allWritten.push(...written);
+        allSkipped.push(...skipped);
+        // Only record an item whose files were ALL written this run. A partially
+        // skipped item keeps older (possibly edited) files on disk — pinning it to
+        // today's release would corrupt the 3-way merge base for `upgrade`.
+        if (written.length === item.files.length && written.length > 0) {
+            installed[item.name] = { version: installedVersion, files: written };
+            manifestChanged = true;
+        }
+    }
+    for (const path of allWritten)
+        log.ok(`Added ${path}`);
+    for (const path of allSkipped)
+        log.warn(`Skipped ${path} (exists — use --overwrite)`);
+    if (manifestChanged) {
+        await writeConfig(cwd, { ...config, installed });
+    }
+    const deps = collectDependencies(items);
+    if (deps.length > 0 && !options.skipInstall) {
+        const pm = detectPackageManager(cwd);
+        log.step(`Installing ${deps.length} dependencies with ${pm}…`);
+        try {
+            await runInstall(pm, deps, cwd);
+            log.ok("Installed dependencies");
+        }
+        catch (err) {
+            log.warn(`Install failed: ${err.message}`);
+            log.step(`Install manually: ${pm} add ${deps.join(" ")}`);
+        }
+    }
+    else if (deps.length > 0) {
+        log.step(`Dependencies to install: ${deps.join(" ")}`);
+    }
+    log.title(`Done — ${allWritten.length} file(s) written.`);
+}
+//# sourceMappingURL=add.js.map

package/dist/commands/ai.d.ts

@@ -0,0 +1,14 @@
+interface AiOptions {
+    cwd: string;
+    assistants?: string;
+    preset?: string;
+    skills?: string;
+}
+/**
+ * Scaffold the Cronus UI AI Kit (AGENTS.md doctrine + Claude Code / Cursor /
+ * Copilot config) into the project. Writes are idempotent: existing files are
+ * left untouched, so re-running only fills in what is missing.
+ */
+export declare function aiAdd(options: AiOptions): Promise<void>;
+export {};
+//# sourceMappingURL=ai.d.ts.map

package/dist/commands/ai.js

@@ -0,0 +1,69 @@
+import { readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { ASSISTANTS, DOCTRINE_PRESETS, parseList, SKILLS, writeAiKit, } from "@cronus-ui/ai-kit";
+import { hasConfig, readConfig } from "../config.js";
+import { log } from "../utils.js";
+/** Read the project name from `<cwd>/package.json`, falling back to the dir name. */
+async function projectName(cwd) {
+    try {
+        const raw = await readFile(join(cwd, "package.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.name === "string" && parsed.name.trim() !== "")
+            return parsed.name;
+    }
+    catch {
+        // No/invalid package.json — fall back to the directory basename below.
+    }
+    return basename(cwd);
+}
+/**
+ * Scaffold the Cronus UI AI Kit (AGENTS.md doctrine + Claude Code / Cursor /
+ * Copilot config) into the project. Writes are idempotent: existing files are
+ * left untouched, so re-running only fills in what is missing.
+ */
+export async function aiAdd(options) {
+    const { cwd } = options;
+    let assistants;
+    let skills;
+    try {
+        assistants = parseList(options.assistants, ASSISTANTS, "assistant");
+        skills = parseList(options.skills, SKILLS, "skill");
+    }
+    catch (err) {
+        log.err(err.message);
+        process.exitCode = 1;
+        return;
+    }
+    const preset = options.preset ? options.preset : "standard";
+    if (!DOCTRINE_PRESETS.includes(preset)) {
+        log.err(`Unknown preset "${options.preset}". Use one of: ${DOCTRINE_PRESETS.join(", ")}.`);
+        process.exitCode = 1;
+        return;
+    }
+    const name = await projectName(cwd);
+    const theme = hasConfig(cwd) ? (await readConfig(cwd)).theme?.name : undefined;
+    log.title(`Adding the Cronus UI AI Kit to ${name}`);
+    log.step(`Assistants: ${assistants.join(", ")} · doctrine: ${preset}`);
+    const { written, skipped } = writeAiKit({
+        targetDir: cwd,
+        name,
+        assistants,
+        preset,
+        skills,
+        theme,
+    });
+    for (const path of written)
+        log.ok(`Wrote ${path}`);
+    if (skipped.length > 0) {
+        log.step(`Skipped ${skipped.length} existing file(s) (idempotent — never clobbered):`);
+        for (const path of skipped)
+            log.step(`  ${path}`);
+    }
+    if (written.length === 0) {
+        log.title("Nothing to do — the AI Kit is already in place.");
+    }
+    else {
+        log.title(`Done — ${written.length} file(s) written.`);
+    }
+}
+//# sourceMappingURL=ai.js.map

package/dist/commands/compose.d.ts

@@ -0,0 +1,82 @@
+import { type AppManifest } from "../compose/manifest.js";
+import { type ComposeChoiceInput, type ComposeMeta } from "../compose/plan.js";
+import { Registry, type RegistryItem } from "../registry.js";
+export { listTemplates, loadManifestFile, loadTemplate } from "../compose/templates.js";
+/** Read the chrome block sources named by the manifest's chrome map from the registry. */
+export declare function readChromeSources(manifest: AppManifest, registry: Registry): Promise<Record<string, string>>;
+/** The compose meta subset, loaded from the registry's `meta.json`. */
+export declare function readComposeMeta(registry: Registry): Promise<ComposeMeta | null>;
+/**
+ * The project's package name (from package.json), used as the default brand and
+ * as `__APP_NAME__`. Falls back to the directory basename when unreadable, so the
+ * composer never fails on a bare project. Derives the trailing segment of a scoped
+ * name ("@acme/shop" → "shop").
+ */
+export declare function readProjectName(cwd: string): Promise<string>;
+/** Options accepted by the composeApp library entry + the CLI command. */
+export interface ComposeAppOptions {
+    /** Project root (must contain cronus-ui.json). */
+    targetDir: string;
+    /** Bundled template name (mutually exclusive with `manifestPath`). */
+    template?: string;
+    /** Explicit manifest file path (mutually exclusive with `template`). */
+    manifestPath?: string;
+    /** Plan-shaping choices (brand/seed/pages/variants). */
+    choices?: ComposeChoiceInput;
+    /** Overwrite existing files instead of skipping (default false). */
+    overwrite?: boolean;
+    /** Skip the npm install step (default false). */
+    skipInstall?: boolean;
+    /** Override the registry source (else use the project config's). */
+    registry?: string;
+}
+/** Result of a successful compose (for programmatic callers / tests). */
+export interface ComposeAppResult {
+    /** The template/manifest name (the `composed{}` key). */
+    templateName: string;
+    /** The resolved project/brand name. */
+    appName: string;
+    installedBlocks: string[];
+    generatedFiles: string[];
+    skippedFiles: string[];
+}
+/**
+ * Compose an app template into an existing Cronus UI project: resolve + install the
+ * blocks, customize the chrome copies (nav data + brand), write the generated
+ * pages/layouts/wrappers, snapshot the emitted bytes, and record `installed{}` +
+ * `composed{}`. Reuses the exact `add` install core — this is one more caller, not
+ * a new write path. Throws {@link ComposePlanError} / {@link ManifestError} on
+ * invalid input.
+ */
+export declare function composeApp(options: ComposeAppOptions): Promise<ComposeAppResult>;
+/** CLI-facing options (flags parsed by commander in index.ts). */
+export interface ComposeCommandOptions {
+    cwd: string;
+    registry?: string;
+    manifest?: string;
+    pages?: string;
+    variant?: string[];
+    brand?: string;
+    seed?: string;
+    overwrite?: boolean;
+    skipInstall?: boolean;
+    dryRun?: boolean;
+    yes?: boolean;
+}
+/**
+ * Parse `--variant login=split --variant footer=mega` into a `{ slug: variant }`
+ * record. Each pair MUST be `slug=variant` with a non-empty slug and variant;
+ * a malformed pair (no `=`, empty side) throws so a typo like `--variant login`
+ * fails loud instead of being silently dropped. A repeated slug keeps the last
+ * value (last flag wins).
+ */
+export declare function parseVariants(pairs: string[] | undefined): Record<string, string>;
+/**
+ * The `cronus-ui compose` command. Resolves a template (bundled or `--manifest`),
+ * plans + validates it (aggregating errors), and either prints a deterministic
+ * dry-run preview or applies it via {@link composeApp}. TTY-prompts for a template
+ * when none is given (unless `--yes`).
+ */
+export declare function compose(templateArg: string | undefined, options: ComposeCommandOptions): Promise<void>;
+export type { RegistryItem };
+//# sourceMappingURL=compose.d.ts.map

package/dist/commands/compose.js

@@ -0,0 +1,403 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { writeDesignDocuments } from "@cronus-ui/ai-kit";
+import { manifestFingerprint } from "../compose/manifest.js";
+import { buildComposePlan, ComposePlanError, } from "../compose/plan.js";
+import { renderPreview } from "../compose/preview.js";
+import { baseSnapshotDir } from "../compose/reload.js";
+import { renderPlan } from "../compose/render.js";
+import { defaultComposeTemplate, listTemplates, loadManifestFile, loadTemplate, } from "../compose/templates.js";
+import { CLI_VERSION, hasConfig, readConfig, writeConfig, } from "../config.js";
+import { Registry, registrySourceVersion } from "../registry.js";
+import { collectDependencies, detectPackageManager, log, resolveSafeDest, runInstall, writeFileEnsured, writeItemFiles, } from "../utils.js";
+export { listTemplates, loadManifestFile, loadTemplate } from "../compose/templates.js";
+/** Read the chrome block sources named by the manifest's chrome map from the registry. */
+export async function readChromeSources(manifest, registry) {
+    const slugs = new Set();
+    for (const group of Object.values(manifest.manifest.chrome)) {
+        if (group.navbar !== undefined)
+            slugs.add(group.navbar);
+        if (group.footer !== undefined)
+            slugs.add(group.footer);
+        if (group.block !== undefined)
+            slugs.add(group.block);
+    }
+    const sources = {};
+    for (const slug of slugs) {
+        try {
+            const item = await registry.item(slug);
+            const content = item.files[0]?.content;
+            if (content !== undefined)
+                sources[slug] = content;
+        }
+        catch {
+            // Left absent → plan validation reports "shipped source unavailable".
+        }
+    }
+    return sources;
+}
+/** The compose meta subset, loaded from the registry's `meta.json`. */
+export async function readComposeMeta(registry) {
+    const meta = await registry.meta();
+    if (meta === null || meta.blocks === undefined)
+        return null;
+    return meta;
+}
+/**
+ * The project's package name (from package.json), used as the default brand and
+ * as `__APP_NAME__`. Falls back to the directory basename when unreadable, so the
+ * composer never fails on a bare project. Derives the trailing segment of a scoped
+ * name ("@acme/shop" → "shop").
+ */
+export async function readProjectName(cwd) {
+    const fallback = cwd.split(/[/\\]/).filter(Boolean).pop() ?? "app";
+    try {
+        const pkg = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+        if (typeof pkg.name === "string" && pkg.name.length > 0) {
+            const slash = pkg.name.lastIndexOf("/");
+            return slash === -1 ? pkg.name : pkg.name.slice(slash + 1);
+        }
+    }
+    catch {
+        // No/invalid package.json — fall back to the dir name.
+    }
+    return fallback;
+}
+/**
+ * Compose an app template into an existing Cronus UI project: resolve + install the
+ * blocks, customize the chrome copies (nav data + brand), write the generated
+ * pages/layouts/wrappers, snapshot the emitted bytes, and record `installed{}` +
+ * `composed{}`. Reuses the exact `add` install core — this is one more caller, not
+ * a new write path. Throws {@link ComposePlanError} / {@link ManifestError} on
+ * invalid input.
+ */
+export async function composeApp(options) {
+    const { targetDir } = options;
+    if (!hasConfig(targetDir)) {
+        throw new Error("No cronus-ui.json found. Run `cronus-ui init` first.");
+    }
+    const config = await readConfig(targetDir);
+    const sourceUsed = options.registry ?? config.registry;
+    const registry = new Registry(sourceUsed);
+    const manifest = options.manifestPath !== undefined
+        ? await loadManifestFile(options.manifestPath)
+        : await loadTemplate(requireTemplate(options.template));
+    const meta = await readComposeMeta(registry);
+    if (meta === null) {
+        throw new Error("This registry does not ship a meta.json sidecar — compose needs it (upgrade the CLI/registry to v0.4.0+).");
+    }
+    const index = await registry.index();
+    const chromeSources = await readChromeSources(manifest, registry);
+    const choices = {
+        ...options.choices,
+        appName: options.choices?.appName ?? (await readProjectName(targetDir)),
+    };
+    const plan = buildComposePlan(manifest, choices, index, meta, chromeSources);
+    // --- Resolve + install the blocks (unchanged install core) ----------------
+    const items = await registry.resolve(plan.blockSlugs);
+    const installedVersion = registrySourceVersion(sourceUsed) ?? CLI_VERSION;
+    const installed = { ...config.installed };
+    const overwrite = options.overwrite ?? false;
+    const installedBlocks = [];
+    // Files the install loop actually wrote this run (fresh install or --overwrite).
+    // Used to gate the chrome rewrite: only customize a chrome copy we just laid
+    // down pristine — never a pre-existing one that the user may have hand-edited.
+    const writtenThisRun = new Set();
+    for (const item of items) {
+        const { written } = await writeItemFiles(item, config, targetDir, { overwrite });
+        for (const path of written)
+            writtenThisRun.add(path);
+        if (written.length === item.files.length && written.length > 0) {
+            installed[item.name] = { version: installedVersion, files: written };
+            if (item.type === "registry:block")
+                installedBlocks.push(item.name);
+        }
+    }
+    const generatedFiles = [];
+    const skippedFiles = [];
+    // --- Customize the installed chrome copies in place -----------------------
+    // The chrome block was just (re)installed pristine by the loop above. Honor
+    // the same collision-safety guarantee as the generated pages: if the install
+    // loop SKIPPED it (already existed, no --overwrite), the on-disk copy is the
+    // previously-customized bytes the user may have edited — do NOT clobber it.
+    // Only rewrite a chrome copy we actually wrote this run.
+    const { files: generated, chromeRewrites } = renderPlan(plan, config);
+    for (const rewrite of chromeRewrites) {
+        if (!writtenThisRun.has(rewrite.file)) {
+            skippedFiles.push(rewrite.file);
+            continue;
+        }
+        const dest = resolveSafeDest(targetDir, ".", rewrite.file);
+        await writeFileEnsured(dest, rewrite.content);
+        generatedFiles.push(rewrite.file);
+    }
+    // --- Write the generated pages/layouts/wrappers (safe writes) -------------
+    for (const file of generated) {
+        const dest = resolveSafeDest(targetDir, ".", file.path);
+        if (existsSync(dest) && !overwrite) {
+            skippedFiles.push(file.path);
+            continue;
+        }
+        await writeFileEnsured(dest, file.content);
+        generatedFiles.push(file.path);
+        // Base snapshot: the exact bytes emitted, for the F4 3-way page upgrade.
+        // Keyed by template name (the composed{} key), not package.json name — a
+        // project can compose several templates.
+        const snapDest = resolveSafeDest(targetDir, baseSnapshotDir(plan.templateName), file.path);
+        await writeFileEnsured(snapDest, file.content);
+    }
+    // --- Record composed{} + installed{} --------------------------------------
+    // Keyed by TEMPLATE name (not project name): a project can compose several
+    // templates, and re-composing the same one updates its record in place.
+    //
+    // `files` must describe the app's COMPLETE generated surface, independent of
+    // what this particular run happened to write. On a benign re-compose (no
+    // --overwrite) every page + chrome copy already exists and goes to
+    // skippedFiles, so `generatedFiles` is empty; a straight assignment would
+    // clobber the record to `files: []` and orphan every composed page from its
+    // .cronus-ui/base/ snapshot (the F4 3-way upgrade merge base). Union with the
+    // prior record so a no-op re-run never empties the tracked file set.
+    const composed = { ...config.composed };
+    const priorFiles = config.composed?.[plan.templateName]?.files ?? [];
+    composed[plan.templateName] = {
+        version: installedVersion,
+        planVersion: plan.planVersion,
+        choices: plan.choices,
+        files: [...new Set([...priorFiles, ...generatedFiles])].sort(),
+        // Compose provenance: lets add-page verify a bundled reload is the SAME
+        // manifest this app was composed from (guards the bundled-name collision).
+        manifestHash: manifestFingerprint(manifest),
+    };
+    const nextConfig = { ...config, installed, composed };
+    await writeConfig(targetDir, nextConfig);
+    writeDesignDocuments(targetDir, { theme: nextConfig.theme?.name });
+    // --- Install npm deps (best-effort, like add) -----------------------------
+    const deps = collectDependencies(items);
+    if (deps.length > 0 && !(options.skipInstall ?? false)) {
+        const pm = detectPackageManager(targetDir);
+        try {
+            await runInstall(pm, deps, targetDir);
+        }
+        catch {
+            // Non-fatal: caller/log surfaces the manual command.
+        }
+    }
+    return {
+        templateName: plan.templateName,
+        appName: plan.appName,
+        installedBlocks,
+        generatedFiles,
+        skippedFiles,
+    };
+}
+function requireTemplate(template) {
+    if (template === undefined || template.length === 0) {
+        throw new Error("No template given. Pass a template name, e.g. `cronus-ui compose store`.");
+    }
+    return template;
+}
+/**
+ * Parse `--variant login=split --variant footer=mega` into a `{ slug: variant }`
+ * record. Each pair MUST be `slug=variant` with a non-empty slug and variant;
+ * a malformed pair (no `=`, empty side) throws so a typo like `--variant login`
+ * fails loud instead of being silently dropped. A repeated slug keeps the last
+ * value (last flag wins).
+ */
+export function parseVariants(pairs) {
+    const out = {};
+    for (const pair of pairs ?? []) {
+        const eq = pair.indexOf("=");
+        const slug = eq > 0 ? pair.slice(0, eq) : "";
+        const variant = eq > 0 ? pair.slice(eq + 1) : "";
+        if (slug.length === 0 || variant.length === 0) {
+            throw new Error(`Invalid --variant "${pair}" (expected "slug=variant", e.g. login=split).`);
+        }
+        out[slug] = variant;
+    }
+    return out;
+}
+/** Parse a comma-separated `--pages /,/products,login` into normalized routes. */
+function parsePages(spec) {
+    if (spec === undefined)
+        return undefined;
+    return spec
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0)
+        .map((s) => (s.startsWith("/") ? s : `/${s}`));
+}
+/**
+ * The `cronus-ui compose` command. Resolves a template (bundled or `--manifest`),
+ * plans + validates it (aggregating errors), and either prints a deterministic
+ * dry-run preview or applies it via {@link composeApp}. TTY-prompts for a template
+ * when none is given (unless `--yes`).
+ */
+export async function compose(templateArg, options) {
+    const { cwd } = options;
+    if (!hasConfig(cwd)) {
+        log.err("No cronus-ui.json found. Run `cronus-ui init` first.");
+        process.exitCode = 1;
+        return;
+    }
+    const seed = options.seed !== undefined ? Number.parseInt(options.seed, 10) : undefined;
+    if (options.seed !== undefined && (seed === undefined || Number.isNaN(seed))) {
+        log.err(`Invalid --seed "${options.seed}" (expected an integer).`);
+        process.exitCode = 1;
+        return;
+    }
+    // Parse `--variant slug=variant` up front so a malformed pair fails loud before
+    // any registry work (parseVariants throws on a bad shape).
+    let variants;
+    try {
+        variants = parseVariants(options.variant);
+    }
+    catch (err) {
+        log.err(err.message);
+        process.exitCode = 1;
+        return;
+    }
+    // Resolve which template/manifest to use.
+    let template = templateArg;
+    const usingManifestFile = options.manifest !== undefined;
+    if (!usingManifestFile && template === undefined) {
+        const available = await listTemplates();
+        if (available.length === 0) {
+            log.err("No app templates are bundled with this CLI.");
+            process.exitCode = 1;
+            return;
+        }
+        template = await promptTemplate(available, options.yes ?? false);
+    }
+    const config = await readConfig(cwd);
+    const sourceUsed = options.registry ?? config.registry;
+    const registry = new Registry(sourceUsed);
+    // Load + validate the manifest.
+    let manifest;
+    try {
+        manifest = usingManifestFile
+            ? await loadManifestFile(options.manifest)
+            : await loadTemplate(template);
+    }
+    catch (err) {
+        reportError(err);
+        process.exitCode = 1;
+        return;
+    }
+    const meta = await readComposeMeta(registry);
+    if (meta === null) {
+        log.err("This registry does not ship a meta.json sidecar — compose needs it (upgrade to v0.4.0+).");
+        process.exitCode = 1;
+        return;
+    }
+    const index = await registry.index();
+    const chromeSources = await readChromeSources(manifest, registry);
+    const parsedPages = parsePages(options.pages);
+    const choices = {
+        appName: await readProjectName(cwd),
+        ...(options.brand !== undefined ? { brand: options.brand } : {}),
+        ...(seed !== undefined ? { seed } : {}),
+        ...(parsedPages !== undefined ? { pages: parsedPages } : {}),
+        variants,
+    };
+    // Plan + validate (aggregate ALL errors).
+    let plan;
+    try {
+        plan = buildComposePlan(manifest, choices, index, meta, chromeSources);
+    }
+    catch (err) {
+        reportError(err);
+        process.exitCode = 1;
+        return;
+    }
+    // --- Dry-run: preview + per-file plan, write nothing ----------------------
+    if (options.dryRun === true) {
+        log.title(`Compose plan (dry-run) — ${plan.title}`);
+        console.log(renderPreview(plan));
+        console.log("");
+        const { files } = renderPlan(plan, config);
+        for (const file of files)
+            log.step(`Would write ${file.path}`);
+        for (const slug of plan.chromeSlugs) {
+            log.step(`Would customize ${config.paths.blocks}/${slug}.tsx (nav links + brand)`);
+        }
+        log.title(`Plan: ${plan.blockSlugs.length} block(s), ${plan.pages.length} page(s), ${plan.chromes.length} chrome group(s). Nothing written (dry-run).`);
+        return;
+    }
+    // --- Apply -----------------------------------------------------------------
+    log.title(`Composing ${plan.title}`);
+    let result;
+    try {
+        result = await composeApp({
+            targetDir: cwd,
+            ...(usingManifestFile ? { manifestPath: options.manifest } : { template }),
+            choices,
+            overwrite: options.overwrite ?? false,
+            skipInstall: options.skipInstall ?? false,
+            registry: options.registry,
+        });
+    }
+    catch (err) {
+        reportError(err);
+        process.exitCode = 1;
+        return;
+    }
+    for (const path of result.generatedFiles)
+        log.ok(`Generated ${path}`);
+    for (const path of result.skippedFiles)
+        log.warn(`Skipped ${path} (exists — use --overwrite)`);
+    if (result.installedBlocks.length > 0) {
+        log.step(`Installed ${result.installedBlocks.length} block(s): ${result.installedBlocks.join(", ")}`);
+    }
+    log.title(`Done — ${result.templateName}: ${result.installedBlocks.length} block(s) + ${result.generatedFiles.length} generated file(s).`);
+    log.title("Next steps");
+    log.step("npx cronus-ui add-page --route /pricing --blocks pricing,cta --nav Pricing");
+    log.step("npx cronus-ui theme set aurora --mode dark");
+    log.step("npx cronus-ui upgrade --all --dry-run");
+}
+/** Print a plan/manifest error's aggregated list, or a plain message. */
+function reportError(err) {
+    if (err instanceof ComposePlanError) {
+        log.err("Compose plan is invalid:");
+        for (const e of err.errors)
+            log.step(e);
+        return;
+    }
+    // ManifestError carries an `errors` array too (duck-typed to avoid a cyclic import cost).
+    const maybe = err;
+    if (Array.isArray(maybe.errors)) {
+        log.err("App manifest is invalid:");
+        for (const e of maybe.errors)
+            log.step(e);
+        return;
+    }
+    log.err(err.message);
+}
+/** TTY-prompt for a template name; `--yes`/non-TTY picks SaaS (not lexical first). */
+async function promptTemplate(available, yes) {
+    const fallback = defaultComposeTemplate(available);
+    if (yes || !process.stdin.isTTY)
+        return fallback;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log("Pick an app template:");
+        available.forEach((name, i) => {
+            console.log(`  ${i + 1} ${name}`);
+        });
+        const answer = (await rl.question(`(1-${available.length} or name, default ${fallback}) `)).trim();
+        if (answer.length === 0)
+            return fallback;
+        const asNum = Number.parseInt(answer, 10);
+        if (Number.isInteger(asNum)) {
+            const picked = available[asNum - 1];
+            if (picked !== undefined)
+                return picked;
+        }
+        return available.includes(answer) ? answer : fallback;
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=compose.js.map