create-cronus-stack 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,12 @@
+# create-cronus-stack
+
+CLI generator for the Cronus Stack Builder.
+
+```sh
+bun create cronus-stack@latest my-app --yes --web next --ui cronus
+```
+
+The generator always writes `stack.json` and `KICKOFF.md`. The default stack
+creates a runnable Next.js + Cronus UI app. Non-default framework/backend choices
+are captured honestly in those artifacts and in the generated README so the next
+developer or agent knows what remains to implement.

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { type StackFlagValues } from "@cronus-ui/stack";
+export declare function stackFlagHelpLines(): string;
+interface ParsedCli {
+    name: string;
+    yes: boolean;
+    help: boolean;
+    version: boolean;
+    values: StackFlagValues;
+}
+export declare function parseCli(args: string[]): ParsedCli;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+import { existsSync, 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 { CLI_FLAGS, catalog, flagValue, resolveStackFlags, sanitizeProjectName, } from "@cronus-ui/stack";
+import { assertWritableTarget, initGit, runInstall, scaffoldStack } from "./scaffold.js";
+import { c, log, packageManagerFromConfig } from "./utils.js";
+import { CREATE_STACK_VERSION } from "./version.js";
+const STACK_FLAG_OPTIONS = Object.fromEntries(CLI_FLAGS.map(({ flag }) => [flag, { type: "string" }]));
+export function stackFlagHelpLines() {
+    return CLI_FLAGS.map(({ catId, flag, kind }) => {
+        const category = catalog.find((candidate) => candidate.id === catId);
+        const values = category?.options.map((option) => flagValue(option.id)).join("|") ?? "value";
+        const suffix = kind === "multi" ? " — comma-separated list or none" : "";
+        return `  --${flag} <${values}>${suffix}`;
+    }).join("\n");
+}
+const HELP = `${c.bold("create-cronus-stack")} — scaffold from the Cronus Stack Builder.
+
+${c.bold("Usage")}
+  create-cronus-stack [project-name] [options]
+  bun create cronus-stack@latest [project-name] [options]
+
+${c.bold("Stack flags")}
+${stackFlagHelpLines()}
+  --vibe
+  --git / --no-git
+  --install / --no-install
+  -y, --yes                  Accept defaults
+  -h, --help                 Show this help
+  -v, --version              Show the version
+
+${c.bold("Examples")}
+  bun create cronus-stack@latest my-app --yes --no-install
+  bun create cronus-stack@latest admin --web next --ui cronus --ai claude-code,cursor
+`;
+export function parseCli(args) {
+    const { values, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            ...STACK_FLAG_OPTIONS,
+            vibe: { type: "boolean", default: false },
+            git: { type: "boolean", default: false },
+            "no-git": { type: "boolean", default: false },
+            install: { type: "boolean", default: false },
+            "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 },
+        },
+    });
+    return {
+        name: sanitizeProjectName(positionals[0] ?? "my-cronus-app"),
+        yes: values.yes === true,
+        help: values.help === true,
+        version: values.version === true,
+        values: values,
+    };
+}
+async function main() {
+    const parsed = parseCli(process.argv.slice(2));
+    if (parsed.help) {
+        process.stdout.write(`${HELP}\n`);
+        return;
+    }
+    if (parsed.version) {
+        process.stdout.write(`${CREATE_STACK_VERSION}\n`);
+        return;
+    }
+    log.intro();
+    if (!parsed.yes && process.stdin.isTTY) {
+        log.warn("Using Stack Builder defaults. Pass flags or -y to skip this notice.");
+    }
+    const config = resolveStackFlags(parsed.values, { catalog });
+    const targetDir = join(process.cwd(), parsed.name);
+    assertWritableTarget(targetDir);
+    log.step(`Scaffolding into ${c.cyan(parsed.name)}…`);
+    const result = scaffoldStack({ targetDir, projectName: parsed.name, config, catalog });
+    log.ok(`Created ${result.fileCount} files.`);
+    for (const note of result.unsupported)
+        log.warn(note);
+    if (config.git === true) {
+        try {
+            log.step("Initializing git repository…");
+            initGit(targetDir);
+            log.ok("Git initialized.");
+        }
+        catch (err) {
+            log.warn(`Git init failed (${err.message}).`);
+        }
+    }
+    const pm = packageManagerFromConfig(config);
+    if (config.install === true) {
+        try {
+            log.step(`Installing dependencies with ${c.cyan(pm)}…`);
+            runInstall(pm, targetDir);
+            log.ok("Dependencies installed.");
+        }
+        catch (err) {
+            log.warn(`Install failed (${err.message}). Install manually later.`);
+        }
+    }
+    log.outro(parsed.name, pm, config.install === true);
+}
+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,17 @@
+import type { Catalog, StackConfig } from "@cronus-ui/stack";
+import { type PackageManager } from "./utils.js";
+export interface ScaffoldStackOptions {
+    targetDir: string;
+    projectName: string;
+    config: StackConfig;
+    catalog?: Catalog;
+}
+export interface ScaffoldStackResult {
+    fileCount: number;
+    unsupported: string[];
+}
+export declare function assertWritableTarget(targetDir: string): void;
+export declare function scaffoldStack(options: ScaffoldStackOptions): ScaffoldStackResult;
+export declare function initGit(cwd: string): void;
+export declare function runInstall(pm: PackageManager, cwd: string): void;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/scaffold.js

@@ -0,0 +1,481 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { writeAiKit, writeDesignDocuments } from "@cronus-ui/ai-kit";
+import { catalog as defaultCatalog, generateKickoff, generateStackJson, sanitizeProjectName, } from "@cronus-ui/stack";
+import { packageManagerFromConfig, runCommand } from "./utils.js";
+import { CREATE_STACK_VERSION } from "./version.js";
+function single(config, key) {
+    const value = config[key];
+    return typeof value === "string" ? value : undefined;
+}
+function multi(config, key) {
+    const value = config[key];
+    return Array.isArray(value) ? value : [];
+}
+function add(deps, name, range) {
+    deps[name] = range;
+}
+const CRONUS_UI_VERSION_RANGE = `^${CREATE_STACK_VERSION}`;
+const CRONUS_UI_REGISTRY = `https://raw.githubusercontent.com/pedrogbraz/cronus-ui/v${CREATE_STACK_VERSION}/registry`;
+function write(targetDir, rel, content) {
+    const path = join(targetDir, rel);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+}
+function appDir(config) {
+    return single(config, "structure") === "structure-root" ? "app" : "src/app";
+}
+function aliasTarget(config) {
+    if (single(config, "importAlias") !== "import-alias")
+        return undefined;
+    return appDir(config).startsWith("src/") ? "./src/*" : "./*";
+}
+function cronusUiPaths(config) {
+    const prefix = appDir(config).startsWith("src/") ? "src/" : "";
+    return {
+        ui: `${prefix}components/ui`,
+        lib: `${prefix}lib`,
+        blocks: `${prefix}components/blocks`,
+    };
+}
+function usesCronusUi(config) {
+    return single(config, "ui") === "ui-cronus";
+}
+function packageJson(projectName, config) {
+    const isNext = single(config, "web") === "web-next";
+    const isCronusUi = usesCronusUi(config);
+    const deps = {};
+    const devDeps = {
+        typescript: "^6.0.3",
+    };
+    if (isNext) {
+        add(deps, "next", "16.2.10");
+        add(deps, "react", "^19.2.0");
+        add(deps, "react-dom", "^19.2.0");
+        add(devDeps, "@types/node", "^22.10.0");
+        add(devDeps, "@types/react", "^19.0.0");
+        add(devDeps, "@types/react-dom", "^19.0.0");
+    }
+    if (isCronusUi) {
+        add(deps, "@cronus-ui/theme", CRONUS_UI_VERSION_RANGE);
+        add(deps, "@cronus-ui/tokens", CRONUS_UI_VERSION_RANGE);
+        add(deps, "@cronus-ui/ui", CRONUS_UI_VERSION_RANGE);
+        add(devDeps, "@tailwindcss/postcss", "^4.3.0");
+        add(devDeps, "tailwindcss", "^4.3.0");
+    }
+    if (multi(config, "addons").includes("addon-biome")) {
+        add(devDeps, "@biomejs/biome", "^2.0.6");
+    }
+    if (single(config, "commitStyle") === "commit-conventional") {
+        add(devDeps, "@commitlint/cli", "^20.2.0");
+        add(devDeps, "@commitlint/config-conventional", "^20.2.0");
+    }
+    const scripts = isNext
+        ? {
+            dev: "next dev",
+            build: "next build",
+            start: "next start",
+            typecheck: "tsc --noEmit",
+        }
+        : {
+            dev: 'echo "Open KICKOFF.md and wire the selected framework scaffold."',
+            build: "tsc --noEmit",
+            typecheck: "tsc --noEmit",
+        };
+    if (multi(config, "addons").includes("addon-biome")) {
+        scripts.lint = "biome check .";
+        scripts.format = "biome format --write .";
+    }
+    if (single(config, "database") !== "db-none") {
+        scripts["db:push"] = 'echo "Configure the selected database/ORM before syncing schema."';
+    }
+    return `${JSON.stringify({
+        name: projectName,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts,
+        dependencies: deps,
+        devDependencies: devDeps,
+    }, null, 2)}\n`;
+}
+function tsconfig(config) {
+    const alias = aliasTarget(config);
+    const strict = single(config, "tsStrict") === "ts-strict";
+    const compilerOptions = {
+        target: "ES2022",
+        lib: ["dom", "dom.iterable", "ES2022"],
+        allowJs: true,
+        skipLibCheck: true,
+        strict,
+        noEmit: true,
+        esModuleInterop: true,
+        module: "esnext",
+        moduleResolution: "bundler",
+        resolveJsonModule: true,
+        isolatedModules: true,
+        jsx: "preserve",
+        incremental: true,
+    };
+    if (strict) {
+        compilerOptions.noUncheckedIndexedAccess = true;
+        compilerOptions.noImplicitOverride = true;
+    }
+    if (alias)
+        compilerOptions.paths = { "@/*": [alias] };
+    if (single(config, "web") === "web-next")
+        compilerOptions.plugins = [{ name: "next" }];
+    return `${JSON.stringify({
+        compilerOptions,
+        include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+        exclude: ["node_modules"],
+    }, null, 2)}\n`;
+}
+function globalsCss(config) {
+    const app = appDir(config);
+    const sourceNodeModules = app.startsWith("src/")
+        ? "../../node_modules/@cronus-ui/ui/dist/**/*.js"
+        : "../node_modules/@cronus-ui/ui/dist/**/*.js";
+    const sourceApp = app.startsWith("src/") ? "../**/*.{ts,tsx}" : "./**/*.{ts,tsx}";
+    return `@import "tailwindcss";
+@import "@cronus-ui/tokens/styles.css";
+
+@source "${sourceNodeModules}";
+@source "${sourceApp}";
+`;
+}
+function neutralGlobalsCss() {
+    return `:root {
+  color-scheme: light dark;
+  font-family:
+    Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  background: #0f172a;
+  color: #f8fafc;
+}
+
+a {
+  color: inherit;
+}
+`;
+}
+function layoutTsx(projectName) {
+    return `import { CronusThemeScript, CronusUIProvider } from "@cronus-ui/theme";
+import type { Metadata } from "next";
+import type { ReactNode } from "react";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "${projectName}",
+  description: "A Next.js app built with Cronus UI.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en" suppressHydrationWarning>
+      <head>
+        <CronusThemeScript storageKey="theme" defaultThemeName="aurora" defaultModeName="dark" />
+      </head>
+      <body>
+        <CronusUIProvider
+          asRoot
+          storageKey="theme"
+          defaultThemeName="aurora"
+          defaultModeName="dark"
+        >
+          {children}
+        </CronusUIProvider>
+      </body>
+    </html>
+  );
+}
+`;
+}
+function neutralLayoutTsx(projectName) {
+    return `import type { Metadata } from "next";
+import type { ReactNode } from "react";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "${projectName}",
+  description: "A Next.js app generated by create-cronus-stack.",
+};
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
+}
+function pageTsx() {
+    return `import { Badge } from "@cronus-ui/ui/badge";
+import { Button } from "@cronus-ui/ui/button";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@cronus-ui/ui/card";
+
+const metrics = [
+  { label: "Revenue", value: "R$ 48.2k" },
+  { label: "Active users", value: "2,318" },
+  { label: "NPS", value: "72" },
+];
+
+export default function Page() {
+  return (
+    <main className="mx-auto flex min-h-screen w-full max-w-5xl flex-col gap-8 px-6 py-12">
+      <header className="flex flex-col gap-4">
+        <Badge variant="primary" className="w-fit">
+          Built with Cronus UI
+        </Badge>
+        <div className="flex flex-col gap-3">
+          <h1 className="text-4xl font-semibold tracking-tight text-fg">Your stack is ready</h1>
+          <p className="max-w-prose text-fg-secondary">
+            This app was scaffolded from the Cronus Stack Builder. Read KICKOFF.md before changing
+            frameworks, databases, auth, payments, or design-system rules.
+          </p>
+        </div>
+        <div className="flex flex-wrap gap-3">
+          <Button variant="primary">Start building</Button>
+          <Button variant="outline">Read KICKOFF.md</Button>
+        </div>
+      </header>
+
+      <section className="grid gap-4 sm:grid-cols-3">
+        {metrics.map((metric) => (
+          <Card key={metric.label}>
+            <CardHeader>
+              <CardDescription>{metric.label}</CardDescription>
+              <CardTitle>{metric.value}</CardTitle>
+            </CardHeader>
+            <CardContent className="text-sm text-fg-secondary">
+              Replace this with your real product data.
+            </CardContent>
+          </Card>
+        ))}
+      </section>
+    </main>
+  );
+}
+`;
+}
+function neutralPageTsx(config) {
+    const uiStep = single(config, "ui") === "ui-none"
+        ? "No UI library was selected; add product UI intentionally when the design direction is clear."
+        : "Install and configure the selected UI library from stack.json.";
+    return `const nextSteps = [
+  "Read KICKOFF.md before installing framework, UI, database, auth, or payment adapters.",
+  "${uiStep}",
+  "Replace this neutral starter with product-specific routes and components.",
+];
+
+export default function Page() {
+  return (
+    <main style={{ margin: "0 auto", maxWidth: "64rem", padding: "4rem 1.5rem" }}>
+      <p style={{ color: "#38bdf8", fontSize: "0.875rem", fontWeight: 700 }}>
+        Generated by create-cronus-stack
+      </p>
+      <h1 style={{ fontSize: "3rem", letterSpacing: "-0.04em", margin: "1rem 0" }}>
+        Your neutral stack starter is ready
+      </h1>
+      <p style={{ color: "#cbd5e1", fontSize: "1.125rem", lineHeight: 1.7, maxWidth: "42rem" }}>
+        This project records your selected stack in KICKOFF.md and stack.json. The default Cronus UI
+        stack is runnable immediately; non-Cronus UI choices are intentionally left as explicit
+        follow-up so the scaffold does not install or import the wrong design system.
+      </p>
+      <ul style={{ color: "#e2e8f0", lineHeight: 1.8, marginTop: "2rem", paddingLeft: "1.25rem" }}>
+        {nextSteps.map((step) => (
+          <li key={step}>{step}</li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+`;
+}
+function basicIndex(projectName) {
+    return `console.log("${projectName}: read KICKOFF.md and wire the selected framework scaffold.");
+`;
+}
+function readme(projectName, config, unsupported) {
+    const pm = packageManagerFromConfig(config);
+    const dev = pm === "npm" ? "npm run dev" : `${pm} dev`;
+    const install = pm === "yarn" ? "yarn" : `${pm} install`;
+    return `# ${projectName}
+
+Generated by \`create-cronus-stack\`.
+
+Read \`KICKOFF.md\` first. It is the source of truth for stack choices,
+conventions, AI capabilities, guardrails, and Definition of Done.
+
+## Run
+
+\`\`\`sh
+${install}
+${dev}
+\`\`\`
+
+## Generated artifacts
+
+- \`stack.json\` — machine-readable resolved stack.
+- \`KICKOFF.md\` — handoff prompt for the coding agent.
+- App starter files for the supported scaffold path.
+
+${unsupported.length ? `## Manual follow-up\n\n${unsupported.map((item) => `- ${item}`).join("\n")}\n` : ""}
+`;
+}
+function envExample(config) {
+    const lines = [];
+    if (single(config, "database") !== "db-none")
+        lines.push("DATABASE_URL=");
+    if (single(config, "auth") !== "auth-none")
+        lines.push("AUTH_SECRET=");
+    if (single(config, "payments") !== "pay-none") {
+        lines.push("PAYMENTS_SECRET_KEY=");
+        lines.push("PAYMENTS_WEBHOOK_SECRET=");
+    }
+    return lines.length ? `${lines.join("\n")}\n` : undefined;
+}
+function assistantIds(config) {
+    const picked = new Set();
+    for (const id of multi(config, "assistants")) {
+        if (id === "ai-claude-code")
+            picked.add("claude");
+        if (id === "ai-cursor")
+            picked.add("cursor");
+        if (id === "ai-copilot")
+            picked.add("copilot");
+        if (id === "ai-windsurf")
+            picked.add("windsurf");
+    }
+    return [...picked];
+}
+function unsupportedNotes(config) {
+    const notes = [];
+    if (single(config, "web") !== "web-next") {
+        notes.push("The selected web framework is captured in KICKOFF.md; this generator currently writes a runnable app only for Next.js.");
+    }
+    const ui = single(config, "ui");
+    if (ui && ui !== "ui-cronus" && ui !== "ui-none") {
+        notes.push("The selected UI library is captured in KICKOFF.md; this generator writes a neutral Next.js starter unless Cronus UI is selected, so install and wire the chosen UI library manually.");
+    }
+    if (single(config, "backend") !== "backend-none" &&
+        single(config, "backend") !== "backend-fullstack-next") {
+        notes.push("Add the selected dedicated backend service described in KICKOFF.md.");
+    }
+    if (single(config, "database") !== "db-none") {
+        notes.push("Wire the selected database/ORM/provider before running db:push.");
+    }
+    if (single(config, "auth") !== "auth-none") {
+        notes.push("Implement the selected auth provider and protect mutating routes.");
+    }
+    if (single(config, "payments") !== "pay-none") {
+        notes.push("Implement payment webhooks server-side; never trust client-side amounts.");
+    }
+    const assistantIds = multi(config, "assistants");
+    if (assistantIds.includes("ai-cline")) {
+        notes.push("Add Cline workspace configuration manually; AI Kit does not emit Cline files yet.");
+    }
+    const mcpIds = multi(config, "mcp");
+    const unsupportedMcp = mcpIds.filter((id) => id !== "mcp-cronus-ui");
+    if (unsupportedMcp.length > 0) {
+        notes.push("Configure the selected non-Cronus MCP servers manually; the generated AI Kit template only ships the cronus-ui MCP entry today.");
+    }
+    if (mcpIds.includes("mcp-cronus-ui") && !usesCronusUi(config)) {
+        notes.push("The cronus-ui MCP server is not generated for stacks that do not use Cronus UI.");
+    }
+    if (multi(config, "skills").length > 0) {
+        notes.push("Install the selected agent skill packs in your agent environment; KICKOFF.md records the choices but the scaffold does not install external skills.");
+    }
+    const unsupportedAddons = multi(config, "addons").filter((id) => id !== "addon-biome");
+    if (unsupportedAddons.length > 0) {
+        notes.push("Wire the selected addons manually unless noted otherwise; this generator currently scaffolds Biome config and records the rest in KICKOFF.md.");
+    }
+    return notes;
+}
+export function assertWritableTarget(targetDir) {
+    if (existsSync(targetDir) && readdirSync(targetDir).length > 0) {
+        throw new Error(`Directory "${targetDir}" already exists and is not empty.`);
+    }
+}
+export function scaffoldStack(options) {
+    const { targetDir, config, catalog = defaultCatalog } = options;
+    const projectName = sanitizeProjectName(options.projectName);
+    const unsupported = unsupportedNotes(config);
+    let fileCount = 0;
+    const emit = (rel, content) => {
+        if (content === undefined)
+            return;
+        write(targetDir, rel, content);
+        fileCount += 1;
+    };
+    mkdirSync(targetDir, { recursive: true });
+    emit("package.json", packageJson(projectName, config));
+    emit("README.md", readme(projectName, config, unsupported));
+    emit("KICKOFF.md", generateKickoff(config, projectName, catalog));
+    emit("stack.json", `${generateStackJson(config, projectName)}\n`);
+    emit(".gitignore", "node_modules\n.next\ndist\n.env*\n!.env.example\n.DS_Store\n");
+    emit("tsconfig.json", tsconfig(config));
+    emit(".env.example", envExample(config));
+    if (single(config, "commitStyle") === "commit-conventional") {
+        emit("commitlint.config.cjs", 'module.exports = { extends: ["@commitlint/config-conventional"] };\n');
+    }
+    if (multi(config, "addons").includes("addon-biome")) {
+        emit("biome.json", `${JSON.stringify({ $schema: "https://biomejs.dev/schemas/2.0.6/schema.json", formatter: { enabled: true }, linter: { enabled: true } }, null, 2)}\n`);
+    }
+    if (single(config, "web") === "web-next") {
+        const isCronusUi = usesCronusUi(config);
+        emit("next.config.mjs", "/** @type {import('next').NextConfig} */\nconst nextConfig = {};\n\nexport default nextConfig;\n");
+        const app = appDir(config);
+        if (isCronusUi) {
+            emit("postcss.config.mjs", 'export default { plugins: { "@tailwindcss/postcss": {} } };\n');
+            emit(`${app}/globals.css`, globalsCss(config));
+            emit(`${app}/layout.tsx`, layoutTsx(projectName));
+            emit(`${app}/page.tsx`, pageTsx());
+            emit("cronus-ui.json", `${JSON.stringify({
+                aliases: { ui: "@/components/ui", lib: "@/lib", blocks: "@/components/blocks" },
+                paths: cronusUiPaths(config),
+                registry: CRONUS_UI_REGISTRY,
+                theme: { name: "aurora", mode: "dark" },
+            }, null, 2)}\n`);
+        }
+        else {
+            emit(`${app}/globals.css`, neutralGlobalsCss());
+            emit(`${app}/layout.tsx`, neutralLayoutTsx(projectName));
+            emit(`${app}/page.tsx`, neutralPageTsx(config));
+        }
+    }
+    else {
+        emit("src/index.ts", basicIndex(projectName));
+    }
+    const assistants = assistantIds(config);
+    const isCronusUi = usesCronusUi(config);
+    const cronusUiMcp = isCronusUi && multi(config, "mcp").includes("mcp-cronus-ui");
+    if (assistants.length > 0 || cronusUiMcp) {
+        const { written } = writeAiKit({
+            targetDir,
+            name: projectName,
+            assistants,
+            preset: "standard",
+            includeCronusUi: isCronusUi,
+            cronusUiMcp,
+        });
+        fileCount += written.length;
+    }
+    else if (isCronusUi) {
+        const { written } = writeDesignDocuments(targetDir);
+        fileCount += written.length;
+    }
+    return { fileCount, unsupported };
+}
+export function initGit(cwd) {
+    runCommand("git", ["init"], cwd);
+}
+export function runInstall(pm, cwd) {
+    runCommand(pm, ["install"], cwd);
+}
+//# sourceMappingURL=scaffold.js.map

package/dist/utils.d.ts

@@ -0,0 +1,23 @@
+import type { StackConfig } from "@cronus-ui/stack";
+export declare const PACKAGE_MANAGERS: readonly ["bun", "npm", "pnpm", "yarn"];
+export type PackageManager = (typeof PACKAGE_MANAGERS)[number];
+export declare const c: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    red: (s: string) => string;
+    cyan: (s: string) => string;
+    magenta: (s: string) => string;
+};
+export declare const log: {
+    intro(): void;
+    step(msg: string): void;
+    ok(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+    outro(name: string, pm: PackageManager, installed: boolean): void;
+};
+export declare function packageManagerFromConfig(config: StackConfig): PackageManager;
+export declare function runCommand(command: string, args: string[], cwd: string): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,70 @@
+import { spawnSync } from "node:child_process";
+export const PACKAGE_MANAGERS = ["bun", "npm", "pnpm", "yarn"];
+const useColor = Boolean(process.stdout.isTTY) && !process.env.NO_COLOR;
+const wrap = (open, close) => (s) => useColor ? `\x1b[${open}m${s}\x1b[${close}m` : s;
+export const c = {
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    red: wrap(31, 39),
+    cyan: wrap(36, 39),
+    magenta: wrap(35, 39),
+};
+export const log = {
+    intro() {
+        process.stdout.write(`\n${c.magenta(c.bold("create-cronus-stack"))}\n\n`);
+    },
+    step(msg) {
+        process.stdout.write(`${c.cyan("›")} ${msg}\n`);
+    },
+    ok(msg) {
+        process.stdout.write(`${c.green("✓")} ${msg}\n`);
+    },
+    warn(msg) {
+        process.stdout.write(`${c.yellow("!")} ${msg}\n`);
+    },
+    error(msg) {
+        process.stderr.write(`${c.red("✗")} ${msg}\n`);
+    },
+    outro(name, pm, installed) {
+        const install = pm === "yarn" ? "yarn" : `${pm} install`;
+        const dev = pm === "npm" ? "npm run dev" : `${pm} dev`;
+        const lines = [
+            "",
+            `${c.green(c.bold("Done!"))} Your Cronus stack is ready in ${c.cyan(name)}.`,
+            "",
+            "Next steps:",
+            `  ${c.dim("$")} cd ${name}`,
+            ...(installed ? [] : [`  ${c.dim("$")} ${install}`]),
+            `  ${c.dim("$")} ${dev}`,
+            "",
+            `Read ${c.cyan("KICKOFF.md")} before changing the generated stack.`,
+            "",
+        ];
+        process.stdout.write(`${lines.join("\n")}\n`);
+    },
+};
+export function packageManagerFromConfig(config) {
+    switch (config.packageManager) {
+        case "pm-npm":
+            return "npm";
+        case "pm-pnpm":
+            return "pnpm";
+        default:
+            return "bun";
+    }
+}
+export function runCommand(command, args, cwd) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+    });
+    if (result.error)
+        throw result.error;
+    if (typeof result.status === "number" && result.status !== 0) {
+        throw new Error(`${command} ${args.join(" ")} exited with code ${result.status}`);
+    }
+}
+//# sourceMappingURL=utils.js.map

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const CREATE_STACK_VERSION = "0.6.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -0,0 +1,2 @@
+export const CREATE_STACK_VERSION = "0.6.0";
+//# sourceMappingURL=version.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "create-cronus-stack",
+  "version": "0.6.0",
+  "description": "Scaffold a Cronus stack from the Cronus Stack Builder contract: app files, stack.json, KICKOFF.md, and optional AI Kit.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Cronus",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pedrogbraz/cronus-ui.git",
+    "directory": "packages/create-cronus-stack"
+  },
+  "homepage": "https://aicronus.com",
+  "bugs": {
+    "url": "https://github.com/pedrogbraz/cronus-ui/issues"
+  },
+  "keywords": [
+    "cronus",
+    "create-cronus-stack",
+    "stack",
+    "scaffold",
+    "next",
+    "cronus-ui",
+    "ai"
+  ],
+  "bin": {
+    "create-cronus-stack": "./dist/index.js",
+    "cronus-stack": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --config vitest.config.ts",
+    "prepublishOnly": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@cronus-ui/ai-kit": "0.6.0",
+    "@cronus-ui/stack": "0.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.9"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}