create-cronus-app 0.6.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cronus
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,173 @@
+# create-cronus-app
+
+Scaffold a production-ready **Next.js + Cronus UI** app in one command.
+
+```sh
+npx create-cronus-app my-app --template saas
+```
+
+That is the gold path: a composed multi-page SaaS product — split login/signup,
+sidebar-shell dashboard, analytics, team, billing, and settings — built from
+validated registry blocks (the generator's golden rule: pages only import and
+stack installed blocks).
+
+You get Next.js 16 (App Router) + React 19 + Tailwind v4 with
+[`@cronus-ui/ui`](https://www.npmjs.com/package/@cronus-ui/ui), `@cronus-ui/tokens`,
+and `@cronus-ui/theme` already wired — themeable, accessible components and an
+anti-flash theme script.
+
+The CLI default remains `--template default` (a single-page starter). Pass
+`--template saas` when you want the full product.
+
+## Usage
+
+```sh
+create-cronus-app [project-name] [options]
+```
+
+If you omit the project name, you are prompted (default: `my-cronus-app`).
+Interactive runs also prompt for template, theme, mode, and the AI Kit.
+
+### Options
+
+| Flag | Description |
+| --- | --- |
+| `--template <name>` | Starter template. CLI default: `default`. Bundled: `default`, `dashboard`, `marketing`. Composed: `store`, `landing`, `saas`, plus `landing-*` flavors (studio, ops, secure, care, shop, docs, premium, agents, coverage, broadcast, agency, glass). |
+| `--theme <aurora\|neutral\|midnight\|sunset\|emerald>` | Theme preset to bake in (default: `aurora`). |
+| `--mode <dark\|light>` | Default color mode (default: `dark`). |
+| `--ai` / `--no-ai` | Include or skip the AI Kit (skills, rules & doctrine). |
+| `--assistants <claude,cursor,copilot,windsurf,gemini\|all\|none>` | Assistants to configure (default: all). Codex CLI and Zed read the root `AGENTS.md` natively. |
+| `--preset <standard\|fintech\|saas\|oss\|agency\|none>` | Engineering doctrine to ship (default: `standard`). |
+| `--skills <ui-add,theme,compose,code-review,ship-pr,evidence-check\|all\|none>` | Claude Code skills to include (default: all). |
+| `--pm <bun\|npm\|pnpm\|yarn>` | Package manager to install with (auto-detected otherwise). |
+| `--no-install` | Skip installing dependencies. |
+| `-y`, `--yes` | Accept defaults; skip interactive prompts. |
+| `-h`, `--help` | Show help. |
+| `-v`, `--version` | Show the version. |
+
+There are no other flags.
+
+### Templates
+
+`default`, `dashboard`, and `marketing` copy a bundled directory.
+
+`store`, `landing`, `saas`, the `landing-*` flavors, and the Pro pack
+(`mail`, `chat`, `finance`) have **no** bundled template dir. They scaffold
+the `default` base, then compose pages + chrome from validated registry
+blocks (the same engine as `npx cronus-ui compose <template>`). OSS keeps
+saas/store/landing; the Pro pack is additive.
+
+| Template | What you get |
+| --- | --- |
+| `default` | Single-page starter — metrics, table & cards. The CLI default (`--yes` without `--template` lands here). |
+| `dashboard` | Bundled multi-page app — sidebar shell, KPIs, chart, data table, settings. |
+| `marketing` | Bundled landing site — hero, features, pricing, testimonials, FAQ, waitlist. |
+| `store` | Composed storefront — 9 navigable pages, real nav, from validated blocks. |
+| `landing` | Composed marketing page — hero, features, pricing, testimonials, FAQ, CTA. |
+| `saas` | Composed SaaS product — split auth + sidebar-shell dashboard, analytics, team, billing, settings. **Recommended for a full product.** |
+| `landing-studio` | Dark AI studio — atmosphere hero, marquee, bento, stats, pricing. Midnight dark. |
+| `landing-ops` | Workflow product — split hero, logos, features, integrations. |
+| `landing-secure` | Infra/security — compact hero, metrics, usage pricing, split FAQ. Midnight dark. |
+| `landing-care` | Healthcare conversion — waitlist hero, bento, proof. Emerald light. |
+| `landing-shop` | Storefront — compact hero + editorial product showcase. Sunset light. |
+| `landing-docs` | Developer tool — compact hero, logos, features, integrations. |
+| `landing-premium` | Full SaaS marketing — split hero, toggle pricing, FAQ. Aurora light. |
+| `landing-agents` | Automation — split hero, marquee, bento, stats. Emerald light. |
+| `landing-coverage` | Services — hero, stats, testimonial grid, FAQ. Sunset light. |
+| `landing-broadcast` | Studio/show — atmosphere hero, marquee, features, pricing. |
+| `landing-agency` | Agency — split hero, about, services, stats. Midnight dark. |
+| `landing-glass` | Glass dark — atmosphere hero, bento, split FAQ, split CTA. |
+| `mail` | **Pro.** Inbox — notification panel, activity feed, compose, preferences. Midnight dark. |
+| `chat` | **Pro.** Assistant — chat thread, prompt box, replies, settings. Aurora dark. |
+| `finance` | **Pro.** Money — payouts, invoices, billing, analytics. Emerald light. |
+
+### AI Kit
+
+`--ai` writes the kit; `--no-ai` skips it. If you pass neither, an interactive
+run prompts (default **yes**). `--yes` accepts that default, so
+`npx create-cronus-app my-app -y` **does** include the kit — pass `--no-ai` to
+skip it. `--assistants`, `--preset`, and `--skills` only take effect when the
+kit is written.
+
+### Examples
+
+```sh
+# Gold path — composed SaaS product.
+npx create-cronus-app my-app --template saas
+
+# Same, non-interactive, skip the AI Kit, install with pnpm.
+npx create-cronus-app my-app --template saas --no-ai --pm pnpm --yes
+
+# Bundled dashboard starter.
+npx create-cronus-app my-app --template dashboard
+
+# Theme + mode (any template).
+npx create-cronus-app my-app --template saas --theme aurora --mode dark
+
+# AI Kit for a subset of assistants.
+npx create-cronus-app my-app --template saas --ai --assistants claude,cursor --preset fintech
+
+# Files only; install later yourself.
+npx create-cronus-app my-app --template saas --no-install
+```
+
+## What you get
+
+A `--template saas` app (after compose) looks like:
+
+```
+my-app/
+├─ app/
+│  ├─ globals.css           # Tailwind v4 + Cronus tokens + the @source opt-in
+│  ├─ layout.tsx            # <CronusUIProvider> + anti-flash <CronusThemeScript>
+│  ├─ (bare)/login          # split-variant sign-in
+│  ├─ (bare)/signup
+│  └─ (shell)/              # dashboard (/), analytics, team, billing, settings
+├─ components/blocks/       # installed registry blocks; pages only stack them
+├─ cronus-ui.json            # so `npx cronus-ui add` / add-page / compose work here
+├─ next.config.mjs
+├─ postcss.config.mjs
+├─ tsconfig.json
+└─ package.json
+```
+
+`default` is the single-page starter (`app/page.tsx` only). `store` and
+`landing` compose the same way as `saas`, with their own routes and chrome.
+
+After scaffolding:
+
+```sh
+cd my-app
+npm install   # if you used --no-install
+npm run dev
+```
+
+Open [http://localhost:3000](http://localhost:3000).
+
+## How to grow
+
+Composed apps (`saas` / `store` / `landing`) grow with `add-page`, not by
+hand-wiring routes. Switch theme or preview upgrades at any time:
+
+```sh
+npx cronus-ui add-page --route /pricing --blocks pricing,cta --nav Pricing
+npx cronus-ui theme set aurora --mode dark
+npx cronus-ui upgrade --all --dry-run
+```
+
+Every app still has a `cronus-ui.json`, so individual components work too:
+
+```sh
+npx cronus-ui add dialog table tabs
+```
+
+Started from `default`, `dashboard`, or `marketing` and want a multi-page
+product? Compose one onto the project:
+
+```sh
+npx cronus-ui compose saas
+```
+
+## License
+
+MIT

package/dist/compose.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Post-scaffold composition adapter.
+ *
+ * `store`/`landing` have no bundled template dir: create-cronus-app copies the
+ * `default` base, then this module calls `cronus-ui`'s `composeApp()` library
+ * entry to generate the pages + chrome from validated registry blocks.
+ *
+ * The import is dynamic so the rest of the CLI (and its tests) never pay for
+ * loading `cronus-ui/compose` — only composed templates reach here.
+ *
+ * Registry resolution (F1 honest cut — the chicken-and-egg):
+ *   A freshly scaffolded app's `cronus-ui.json` pins the registry to the release
+ *   remote (`v<version>/registry`), which only ships the `meta.json` sidecar
+ *   compose needs from v0.4.0+. `composeApp` hard-requires that sidecar. So:
+ *     1. `CRONUS_UI_REGISTRY` (env) wins — the dev/CI escape hatch that points at
+ *        the local workspace `registry/` dir (which has meta.json today).
+ *     2. Otherwise `composeApp` uses the project's own config registry (the
+ *        release remote — correct once v0.4.0+ publishes meta.json).
+ *   When the registry lacks meta.json, compose fails gracefully and the caller
+ *   keeps the valid `default` scaffold with a clear "run compose later" hint.
+ */
+/** What create-cronus-app needs from the composer (a subset of `ComposeAppResult`). */
+export interface ComposeTemplateOptions {
+    /** The scaffolded project root (contains cronus-ui.json). */
+    targetDir: string;
+    /** The composed template name (`store` / `landing`). */
+    template: string;
+    /** Brand string baked into chrome/hero copy (the project name). */
+    brand: string;
+    /** Skip the composer's own `pm add` (the final create-cronus-app install covers it). */
+    skipInstall?: boolean;
+    /**
+     * Registry override. Defaults to `process.env.CRONUS_UI_REGISTRY` so dev/CI can
+     * point at the local workspace registry; falls through to the project config
+     * when unset.
+     */
+    registry?: string;
+}
+/** Structured outcome so the caller can log a page count or a graceful skip. */
+export type ComposeTemplateResult = {
+    ok: true;
+    pageCount: number;
+    blockCount: number;
+    files: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Compose a bundled app template into the freshly scaffolded project. Never
+ * throws: a compose failure (e.g. the pinned registry has no meta.json yet)
+ * returns `{ ok: false, reason }` so scaffolding still succeeds with the valid
+ * `default` base.
+ */
+export declare function composeTemplate(options: ComposeTemplateOptions): Promise<ComposeTemplateResult>;
+//# sourceMappingURL=compose.d.ts.map

package/dist/compose.js

@@ -0,0 +1,92 @@
+/**
+ * Post-scaffold composition adapter.
+ *
+ * `store`/`landing` have no bundled template dir: create-cronus-app copies the
+ * `default` base, then this module calls `cronus-ui`'s `composeApp()` library
+ * entry to generate the pages + chrome from validated registry blocks.
+ *
+ * The import is dynamic so the rest of the CLI (and its tests) never pay for
+ * loading `cronus-ui/compose` — only composed templates reach here.
+ *
+ * Registry resolution (F1 honest cut — the chicken-and-egg):
+ *   A freshly scaffolded app's `cronus-ui.json` pins the registry to the release
+ *   remote (`v<version>/registry`), which only ships the `meta.json` sidecar
+ *   compose needs from v0.4.0+. `composeApp` hard-requires that sidecar. So:
+ *     1. `CRONUS_UI_REGISTRY` (env) wins — the dev/CI escape hatch that points at
+ *        the local workspace `registry/` dir (which has meta.json today).
+ *     2. Otherwise `composeApp` uses the project's own config registry (the
+ *        release remote — correct once v0.4.0+ publishes meta.json).
+ *   When the registry lacks meta.json, compose fails gracefully and the caller
+ *   keeps the valid `default` scaffold with a clear "run compose later" hint.
+ */
+import { existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * True when `file` is a generated page that owns the root URL "/".
+ *
+ * The renderer emits the home page as `app/(<chromeGroup>)/page.tsx` (route "/"
+ * inside a path-transparent route group), never a bare `app/page.tsx`. So a
+ * generated `app/(<group>)/page.tsx` is the compose-authored home page.
+ */
+function isGeneratedRootPage(file) {
+    return /^app\/\([^/]+\)\/page\.tsx$/.test(file);
+}
+/**
+ * Remove the base template's `app/page.tsx` when compose generated its own home
+ * page. `create-cronus-app store|landing` scaffolds the `default` base (which
+ * ships `app/page.tsx`, the single-page dashboard starter) and THEN composes
+ * `app/(<group>)/page.tsx` for the manifest's "/" route. In the Next.js App
+ * Router a route group like `(site)` is path-transparent, so `app/page.tsx` and
+ * `app/(site)/page.tsx` both own "/". Left together, `next build` either errors
+ * ("two parallel pages resolve to /") or — on the Turbopack builder the template
+ * uses — silently serves the leftover base starter and drops the composed store
+ * home. Deleting the now-superseded base page leaves exactly one "/" page.
+ *
+ * The base `app/layout.tsx` (the required <html>/<body> root layout) is KEPT:
+ * Next allows a root `app/layout.tsx` plus nested route-group layouts
+ * (`app/(site)/layout.tsx`) to coexist, so only the PAGE collides.
+ */
+function removeSupersededBasePage(targetDir, generatedFiles) {
+    // Only delete the base page when compose actually authored a "/" page to
+    // replace it — never orphan the app of a home route.
+    if (!generatedFiles.some(isGeneratedRootPage))
+        return;
+    const basePage = join(targetDir, "app", "page.tsx");
+    if (existsSync(basePage))
+        rmSync(basePage);
+}
+/**
+ * Compose a bundled app template into the freshly scaffolded project. Never
+ * throws: a compose failure (e.g. the pinned registry has no meta.json yet)
+ * returns `{ ok: false, reason }` so scaffolding still succeeds with the valid
+ * `default` base.
+ */
+export async function composeTemplate(options) {
+    const registry = options.registry ?? process.env.CRONUS_UI_REGISTRY;
+    try {
+        // Dynamic import: only composed templates load the compose library, and a
+        // missing/unbuilt `cronus-ui/compose` degrades to a graceful skip rather than
+        // crashing the scaffolder.
+        const { composeApp } = await import("cronus-ui/compose");
+        const result = await composeApp({
+            targetDir: options.targetDir,
+            template: options.template,
+            choices: { brand: options.brand },
+            skipInstall: options.skipInstall ?? true,
+            ...(registry !== undefined ? { registry } : {}),
+        });
+        // Compose owns the "/" route via app/(<group>)/page.tsx; drop the base
+        // template's colliding app/page.tsx so exactly one page resolves to "/".
+        removeSupersededBasePage(options.targetDir, result.generatedFiles);
+        return {
+            ok: true,
+            pageCount: result.generatedFiles.filter((f) => f.endsWith("page.tsx")).length,
+            blockCount: result.installedBlocks.length,
+            files: result.generatedFiles,
+        };
+    }
+    catch (err) {
+        return { ok: false, reason: err.message };
+    }
+}
+//# sourceMappingURL=compose.js.map

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { type Assistant, type DoctrinePreset, type Skill } from "@cronus-ui/ai-kit";
+import { type ModeName, type PackageManager, type TemplateName, type Theme } from "./utils.js";
+export declare const HELP: string;
+interface ParsedCli {
+    /** Project name from positional arg, or undefined to prompt. */
+    name?: string;
+    pm?: PackageManager;
+    install: boolean;
+    /** Template from `--template`, or undefined to prompt. */
+    template?: TemplateName;
+    /** Theme from `--theme`, or undefined to prompt. */
+    theme?: Theme;
+    /** Mode from `--mode`, or undefined to prompt. */
+    mode?: ModeName;
+    /** `--yes`: accept defaults, skip prompts (also implied when not a TTY). */
+    yes: boolean;
+    /** AI Kit: true (`--ai`) / false (`--no-ai`) / undefined (decide later). */
+    ai?: boolean;
+    /** Assistants to configure (defaults to all). */
+    assistants?: readonly Assistant[];
+    /** Doctrine preset (defaults to "standard"). */
+    preset?: DoctrinePreset;
+    /** Claude Code skills to include (defaults to all). */
+    skills?: readonly Skill[];
+}
+/**
+ * Parse argv into options. Throws a friendly Error on bad input (unknown flag,
+ * invalid `--pm`) so the caller can print and exit non-zero.
+ */
+export declare function parseCli(argv: string[]): ParsedCli;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { argv } from "node:process";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { ASSISTANTS, DEFAULT_PRESET, DOCTRINE_PRESETS, parseList, SKILLS, writeAiKit, writeDesignDocuments, } from "@cronus-ui/ai-kit";
+import { composeTemplate } from "./compose.js";
+import { runInstall, scaffold } from "./scaffold.js";
+import { c, DEFAULT_MODE, DEFAULT_TEMPLATE, DEFAULT_THEME, dirNameFromProjectName, isComposedTemplate, isValidProjectName, log, MODES, PACKAGE_MANAGERS, promptConfirm, promptSelect, TEMPLATE_APPEARANCE, TEMPLATE_HINTS, TEMPLATES, THEME_HINTS, THEMES, } from "./utils.js";
+import { CREATE_VERSION } from "./version.js";
+export const HELP = `${c.bold("create-cronus-app")} — scaffold a Next.js + Cronus UI app.
+
+${c.bold("Usage")}
+  create-cronus-app [project-name] [options]
+
+${c.bold("Options")}
+  --template <name>          Starter template (default: ${DEFAULT_TEMPLATE}).
+                             Bundled: default, dashboard, marketing.
+                             Composed: store, landing, saas, landing-* flavors, and Pro pack (mail, chat, finance).
+  --theme <${THEMES.join("|")}>
+                             Theme preset to bake in (default: ${DEFAULT_THEME})
+  --mode <${MODES.join("|")}>            Default color mode (default: ${DEFAULT_MODE})
+  --ai / --no-ai             Include (or skip) the AI Kit: skills, rules & doctrine.
+                             DESIGN.md still ships with --no-ai.
+  --assistants <${ASSISTANTS.join(",")}|all|none>
+                             Which assistants to configure (default: all).
+                             Codex CLI and Zed read the root AGENTS.md natively.
+  --preset <${DOCTRINE_PRESETS.join("|")}>
+                             Which engineering doctrine to ship (default: standard)
+  --skills <name,...|all|none>
+                             Which Claude Code skills to include (default: all)
+  --pm <bun|npm|pnpm|yarn>   Package manager to install with (auto-detected otherwise)
+  --no-install               Skip installing dependencies
+  -y, --yes                  Accept defaults; skip interactive prompts
+  -h, --help                 Show this help
+  -v, --version              Show the version
+
+${c.bold("Examples")}
+  npx create-cronus-app my-app --template saas
+  npx create-cronus-app my-app --template landing-studio
+  npx create-cronus-app my-app --template mail
+  npx create-cronus-app my-app --template dashboard
+  npx create-cronus-app my-app --theme sunset --mode light
+  npx create-cronus-app my-app --ai --assistants claude,cursor --preset fintech
+  npx create-cronus-app my-app --no-ai --pm pnpm --yes
+`;
+/**
+ * Parse argv into options. Throws a friendly Error on bad input (unknown flag,
+ * invalid `--pm`) so the caller can print and exit non-zero.
+ */
+export function parseCli(argv) {
+    // `node:util` parseArgs has no built-in `--no-foo` negation, so we declare an
+    // explicit `no-install` flag rather than rely on a `--no-install` convention.
+    const { values, positionals } = parseArgs({
+        args: argv,
+        allowPositionals: true,
+        options: {
+            template: { type: "string" },
+            theme: { type: "string" },
+            mode: { type: "string" },
+            ai: { type: "boolean", default: false },
+            "no-ai": { type: "boolean", default: false },
+            assistants: { type: "string" },
+            preset: { type: "string" },
+            skills: { type: "string" },
+            pm: { type: "string" },
+            "no-install": { type: "boolean", default: false },
+            yes: { type: "boolean", short: "y", default: false },
+            help: { type: "boolean", short: "h", default: false },
+            version: { type: "boolean", short: "v", default: false },
+        },
+    });
+    if (values.help)
+        return { install: true, yes: false, name: "--help" };
+    if (values.version)
+        return { install: true, yes: false, name: "--version" };
+    const pm = values.pm;
+    if (pm !== undefined && !PACKAGE_MANAGERS.includes(pm)) {
+        throw new Error(`Unknown --pm "${pm}". Use one of: ${PACKAGE_MANAGERS.join(", ")}.`);
+    }
+    const template = values.template;
+    if (template !== undefined && !TEMPLATES.includes(template)) {
+        throw new Error(`Unknown --template "${template}". Use one of: ${TEMPLATES.join(", ")}.`);
+    }
+    const theme = values.theme;
+    if (theme !== undefined && !THEMES.includes(theme)) {
+        throw new Error(`Unknown --theme "${theme}". Use one of: ${THEMES.join(", ")}.`);
+    }
+    const mode = values.mode;
+    if (mode !== undefined && !MODES.includes(mode)) {
+        throw new Error(`Unknown --mode "${mode}". Use one of: ${MODES.join(", ")}.`);
+    }
+    const preset = values.preset;
+    if (preset !== undefined && !DOCTRINE_PRESETS.includes(preset)) {
+        throw new Error(`Unknown --preset "${preset}". Use one of: ${DOCTRINE_PRESETS.join(", ")}.`);
+    }
+    // `parseList` validates each token and expands "all"/empty to the full set.
+    const assistants = parseList(values.assistants, ASSISTANTS, "assistant");
+    const skills = parseList(values.skills, SKILLS, "skill");
+    return {
+        name: positionals[0],
+        pm: pm,
+        install: !values["no-install"],
+        template: template,
+        theme: theme,
+        mode: mode,
+        yes: values.yes,
+        ai: values["no-ai"] ? false : values.ai ? true : undefined,
+        assistants,
+        preset: preset ?? DEFAULT_PRESET,
+        skills,
+    };
+}
+/** Prompt for a project name on the TTY; falls back to the default when piped. */
+async function promptName(defaultName) {
+    if (!process.stdin.isTTY)
+        return defaultName;
+    const { createInterface } = await import("node:readline/promises");
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question(`${c.bold("Project name")} ${c.dim(`(${defaultName})`)} `)).trim();
+        return answer || defaultName;
+    }
+    finally {
+        rl.close();
+    }
+}
+/** Detect a package manager from the npm user-agent (set when run via npx/pnpm dlx). */
+function detectPackageManager() {
+    const ua = process.env.npm_config_user_agent ?? "";
+    if (ua.startsWith("bun"))
+        return "bun";
+    if (ua.startsWith("pnpm"))
+        return "pnpm";
+    if (ua.startsWith("yarn"))
+        return "yarn";
+    return "npm";
+}
+async function main() {
+    const parsed = parseCli(process.argv.slice(2));
+    if (parsed.name === "--help") {
+        process.stdout.write(`${HELP}\n`);
+        return;
+    }
+    if (parsed.name === "--version") {
+        process.stdout.write(`${CREATE_VERSION}\n`);
+        return;
+    }
+    log.intro();
+    const name = parsed.name ?? (await promptName("my-cronus-app"));
+    if (!isValidProjectName(name)) {
+        log.error(`"${name}" is not a valid package name. Use lowercase letters, digits, "-", "_", "." ` +
+            `(optionally scoped, e.g. @scope/name).`);
+        process.exitCode = 1;
+        return;
+    }
+    const dirName = dirNameFromProjectName(name);
+    const targetDir = join(process.cwd(), dirName);
+    if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+        log.error(`Directory "${dirName}" already exists and is not empty.`);
+        process.exitCode = 1;
+        return;
+    }
+    // Template + theme + mode: an explicit flag wins; otherwise prompt on a TTY
+    // (unless --yes), and fall back to the ship defaults when piped/CI.
+    const template = parsed.template ??
+        (parsed.yes
+            ? DEFAULT_TEMPLATE
+            : await promptSelect("Template", TEMPLATES, DEFAULT_TEMPLATE, TEMPLATE_HINTS));
+    const appearance = TEMPLATE_APPEARANCE[template];
+    const theme = parsed.theme ??
+        (parsed.yes
+            ? (appearance?.theme ?? DEFAULT_THEME)
+            : await promptSelect("Theme", THEMES, appearance?.theme ?? DEFAULT_THEME, THEME_HINTS));
+    const mode = parsed.mode ??
+        (parsed.yes
+            ? (appearance?.mode ?? DEFAULT_MODE)
+            : await promptSelect("Default mode", MODES, appearance?.mode ?? DEFAULT_MODE));
+    log.step(`Scaffolding into ${c.cyan(dirName)}…`);
+    const { fileCount } = scaffold({ targetDir, name, theme, mode, template });
+    log.ok(`Created ${fileCount} files (${c.cyan(template)} template, ${c.cyan(theme)} theme, ${mode} mode).`);
+    // Cronus Compose: store/landing scaffold the `default` base above, then generate
+    // their pages + chrome from validated registry blocks. The blocks pull npm deps
+    // (e.g. lucide-react) that the base package.json lacks, so let compose record +
+    // install them via `pm add` when installing is enabled; a following `--no-install`
+    // scaffold records nothing (matching `cronus-ui add --no-install`).
+    if (isComposedTemplate(template)) {
+        log.step(`Composing the ${c.cyan(template)} app from validated blocks…`);
+        const composed = await composeTemplate({
+            targetDir,
+            template,
+            brand: name,
+            skipInstall: !parsed.install,
+        });
+        if (composed.ok) {
+            log.ok(`Composed ${composed.pageCount} page(s) from ${composed.blockCount} validated block(s).`);
+        }
+        else {
+            log.warn(`Skipped composition (${composed.reason}). The ${c.cyan("default")} app was scaffolded; ` +
+                `run ${c.cyan(`npx cronus-ui compose ${template}`)} once the registry ships meta.json.`);
+        }
+    }
+    // AI Kit: skills, rules & doctrine for Claude Code / Cursor / Copilot.
+    const wantAi = parsed.ai ??
+        (parsed.yes
+            ? true
+            : await promptConfirm("Add the AI Kit (skills, rules & doctrine for AI assistants)?", true));
+    if (wantAi) {
+        const assistants = parsed.assistants ?? ASSISTANTS;
+        const preset = parsed.preset ?? DEFAULT_PRESET;
+        const skills = parsed.skills ?? SKILLS;
+        const { written } = writeAiKit({
+            targetDir,
+            name,
+            assistants,
+            preset,
+            skills,
+            theme,
+        });
+        log.ok(`AI Kit added — ${written.length} files for ${assistants.join(", ")} (${preset} doctrine).`);
+    }
+    else {
+        const { written } = writeDesignDocuments(targetDir, { theme });
+        if (written.length > 0) {
+            log.ok("DESIGN.md added (visual taste).");
+        }
+    }
+    const pm = parsed.pm ?? detectPackageManager();
+    if (parsed.install) {
+        log.step(`Installing dependencies with ${c.cyan(pm)}…`);
+        try {
+            runInstall(pm, targetDir);
+            log.ok("Dependencies installed.");
+        }
+        catch (err) {
+            log.warn(`Install failed (${err.message}). Install manually later.`);
+        }
+    }
+    log.outro(dirName, pm, parsed.install, template);
+}
+/** True when this module is the process entry point (not imported by a test). */
+function isEntrypoint() {
+    const entry = argv[1];
+    if (!entry)
+        return false;
+    return existsSync(entry) && fileURLToPath(import.meta.url) === realpathSync(entry);
+}
+if (isEntrypoint()) {
+    main().catch((err) => {
+        log.error(err.message);
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/scaffold.d.ts

@@ -0,0 +1,31 @@
+import { type ModeName, type PackageManager, type TemplateName, type Theme } from "./utils.js";
+/**
+ * Replace template tokens. `__APP_NAME__` is the package name; `__THEME__` /
+ * `__MODE__` are the chosen theme preset + color mode (baked into layout.tsx and
+ * cronus-ui.json). Theme/mode default to the ship defaults so existing callers
+ * (and tests) that pass only a name keep working.
+ */
+export declare function applyTokens(content: string, name: string, theme?: Theme, mode?: ModeName): string;
+export interface ScaffoldOptions {
+    /** Absolute path of the directory to create. */
+    targetDir: string;
+    /** Package name written into package.json / README (may be scoped). */
+    name: string;
+    /** Theme preset baked into the app. @default "aurora" */
+    theme?: Theme;
+    /** Default color mode baked into the app. @default "dark" */
+    mode?: ModeName;
+    /** Starter template to copy. @default "default" */
+    template?: TemplateName;
+}
+export interface ScaffoldResult {
+    fileCount: number;
+}
+/**
+ * Recursively copy the chosen template into `targetDir`, replacing tokens in
+ * text files and restoring stripped dotfile names. Returns the file count.
+ */
+export declare function scaffold(options: ScaffoldOptions): ScaffoldResult;
+/** Run the package manager's install in `cwd`. Throws if it exits non-zero. */
+export declare function runInstall(pm: PackageManager, cwd: string): void;
+//# sourceMappingURL=scaffold.d.ts.map