@tellet/create 0.8.0

package/README.md

@@ -0,0 +1,195 @@
+# @tellet/create
+
+> The open-source platform for running an Agentic Company.
+
+```bash
+npx @tellet/create
+```
+
+tellet is a management platform for AI-powered companies. One command generates your AI agent team, website, dashboard, Knowledge Base, and Orchestrator — ready to deploy anywhere.
+
+## What you get
+
+- **AI Agent Team** — 3-5 agents auto-generated for your business (CS, marketing, sales, ops)
+- **Orchestrator** — Manage your entire company through conversation
+- **Knowledge Base** — pgvector-powered, agents reference it for accurate answers
+- **Dashboard** — Stats, agent chat, conversations, onboarding
+- **Tool Marketplace** — Stripe, Email, GitHub, Slack, Notion via MCP
+- **Embeddable Widget** — One script tag to add AI chat to any website
+- **3-Tier Deployment** — Free (Vercel) / Cloud (Railway) / Enterprise (AWS)
+
+## How it works
+
+```
+npx @tellet/create
+
+? New or Connect?          → New business or add AI to existing
+? Deployment?              → Quick Start / Cloud / Enterprise
+? AI Provider?             → Anthropic / OpenAI
+? Company name?            → Sunny Coffee
+? Describe your business   → We sell specialty coffee...
+
+  Generating your AI team and website...
+
+  Your team:
+  Barista (customer_support)
+  Roaster (marketing)
+  Grinder (sales)
+
+  Your website:
+  "Coffee worth waking up for"
+
+  ✓ Project created!
+```
+
+## Quick start
+
+```bash
+# Quick Start (Vercel + Supabase, free)
+npx @tellet/create
+cd your-company
+npm install && npm run dev
+
+# Cloud (Docker + Railway, $5/mo)
+npx @tellet/create  # choose "Cloud"
+cd your-company
+docker compose up         # local dev
+railway up                # deploy
+
+# Enterprise (AWS CDK, $5-15/mo)
+npx @tellet/create  # choose "Enterprise"
+cd your-company/infra
+npm install && npx cdk deploy
+```
+
+## Architecture
+
+```
+┌─ tellet Platform ─────────────────────────┐
+│  Owner ↔ Orchestrator                      │
+│              ↕                             │
+│  Agent Team (CS · Marketing · Sales · Ops) │
+│              ↕                             │
+│  MCP Bridge Layer                          │
+│  (KB, Stripe, DB, Email, Custom API...)    │
+└────────────────────────────────────────────┘
+```
+
+## Project structure
+
+```
+your-company/
+├── agents/                # AI agent definitions (auto-generated)
+├── app/
+│   ├── (site)/            # Public website with chat widget
+│   ├── (dashboard)/       # Management dashboard + Orchestrator
+│   └── api/
+│       ├── chat/          # Streaming chat API (tool use)
+│       ├── orchestrator/  # Orchestrator API (tool use loop)
+│       └── cron/          # Scheduled agent tasks
+├── components/
+│   ├── chat/              # ChatWidget, Markdown
+│   ├── dashboard/         # Sidebar, Stats, AgentChat, Orchestrator
+│   └── sections/          # Landing page sections
+├── lib/
+│   ├── engine/            # Agent runtime with tool use agentic loop
+│   ├── providers/         # LLM providers (Anthropic, OpenAI)
+│   ├── mcp/               # MCP client, Knowledge Base, tool registry
+│   ├── orchestrator/      # Orchestrator tools + executor
+│   └── scheduler.ts       # Cron/heartbeat agent scheduler
+├── public/widget.js       # Embeddable chat widget
+├── tellet.json            # Configuration (single source of truth)
+├── Dockerfile             # Docker deployment (Cloud/Enterprise)
+├── docker-compose.yml     # Local dev with PostgreSQL + pgvector
+├── railway.toml           # Railway auto-deploy
+└── infra/                 # AWS CDK (Enterprise only)
+```
+
+## Orchestrator
+
+The Orchestrator is your AI company manager. Talk to it from the dashboard:
+
+- "Show my stats" — conversations, messages, costs
+- "Update the website tagline" — modifies site content
+- "Add Stripe to my agents" — installs tools from marketplace
+- "Schedule marketing to post daily at 9am" — sets up cron tasks
+- "Add our refund policy to the Knowledge Base" — agents reference it
+
+## Tool Marketplace
+
+Connect tools via the Orchestrator or `tellet.json`:
+
+| Tool | Package | Use case |
+|------|---------|----------|
+| Stripe | `@stripe/mcp` | Payments, invoices, subscriptions |
+| Email | `resend-mcp` | Send emails, campaigns |
+| GitHub | `@modelcontextprotocol/server-github` | Issues, PRs, repos |
+| Slack | `@anthropic-ai/mcp-server-slack` | Messages, channels |
+| Notion | `@anthropic-ai/mcp-server-notion` | Docs, databases |
+
+19,000+ MCP servers available via the [MCP Registry](https://registry.modelcontextprotocol.io/).
+
+## Deployment options
+
+| Tier | Provider | Cost | Best for |
+|------|----------|------|----------|
+| Quick Start | Vercel + Supabase | $0 | Prototyping, new business |
+| Cloud | Railway / Render / Fly.io | $5-20/mo | Production, startups |
+| Enterprise | AWS CDK (Lambda + RDS) | $5-15/mo | Scale, existing AWS |
+
+## Connect mode
+
+Already have a business? Use Connect mode:
+
+```bash
+npx @tellet/create  # choose "Connect"
+```
+
+- Skips site generation, keeps dashboard + API
+- Embeddable widget for your existing site:
+
+```html
+<script src="https://your-tellet.com/widget.js"
+        data-agent="support"
+        data-api="https://your-tellet.com"></script>
+```
+
+## Configuration
+
+All configuration lives in `tellet.json`:
+
+```json
+{
+  "company": { "name": "Sunny Coffee", "industry": "Food & Beverage" },
+  "mode": "new",
+  "llm": { "provider": "anthropic", "defaultModel": "claude-sonnet-4-6" },
+  "agents": [
+    { "id": "barista", "role": "customer_support", "tools": ["search_knowledge"] },
+    { "id": "roaster", "role": "marketing", "tools": ["email"] }
+  ],
+  "tools": {
+    "search_knowledge": { "type": "builtin" },
+    "email": { "type": "mcp", "package": "resend-mcp" }
+  },
+  "site": { "tagline": "Coffee worth waking up for", "..." : "..." }
+}
+```
+
+## Tech stack
+
+- [Next.js 16](https://nextjs.org/) — App framework
+- [PostgreSQL + pgvector](https://github.com/pgvector/pgvector) — Database + vector search
+- [MCP](https://modelcontextprotocol.io/) — Tool integration protocol
+- [Anthropic Claude](https://anthropic.com/) / [OpenAI](https://openai.com/) — AI models
+- [Tailwind CSS 4](https://tailwindcss.com/) — Styling
+- [Framer Motion](https://www.framer.com/motion/) — Animations
+
+## License
+
+MIT
+
+## Links
+
+- [tellet.com](https://tellet.com) — Website
+- [GitHub](https://github.com/agentic-company/create-tellet) — Source code
+- [npm](https://www.npmjs.com/package/@tellet/create) — Package

package/dist/ai/generate.d.ts

@@ -0,0 +1,33 @@
+export type Provider = "anthropic" | "openai";
+interface GeneratedAgent {
+    id: string;
+    name: string;
+    role: string;
+    description: string;
+    systemPrompt: string;
+    model: string;
+}
+interface SiteFeature {
+    title: string;
+    description: string;
+    icon: string;
+}
+interface SiteFAQ {
+    question: string;
+    answer: string;
+}
+interface SiteContent {
+    tagline: string;
+    subtitle: string;
+    features: SiteFeature[];
+    faq: SiteFAQ[];
+    cta: string;
+}
+export interface GenerateResult {
+    industry: string;
+    summary: string;
+    agents: GeneratedAgent[];
+    site: SiteContent;
+}
+export declare function generateAgents(companyName: string, businessDescription: string, provider?: Provider): Promise<GenerateResult>;
+export {};

package/dist/ai/generate.js

@@ -0,0 +1,108 @@
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+function buildSystemPrompt(provider) {
+    const modelExamples = provider === "anthropic"
+        ? 'use "claude-haiku-4-5" for high-volume simple tasks (CS), "claude-sonnet-4-6" for creative/complex tasks (marketing, sales)'
+        : 'use "gpt-4.1-mini" for high-volume simple tasks (CS), "gpt-4.1" for creative/complex tasks (marketing, sales)';
+    return `You are an AI company architect. Given a business description, generate a team of AI agents AND website content tailored for that specific business.
+
+Rules for AGENTS:
+1. Generate 3-5 agents appropriate for the business
+2. Always include a customer_support agent
+3. Each agent needs a unique, memorable name related to the business theme
+4. Each system_prompt must be detailed (200+ words) and specific to THIS business — include the company name, products, customer demographics, tone of voice
+5. Assign appropriate models: ${modelExamples}
+6. The id should be lowercase, no spaces
+
+Rules for SITE CONTENT:
+1. tagline: a punchy one-liner (max 8 words) that captures the business value
+2. subtitle: 1-2 sentences expanding on the tagline, mentioning who the business serves
+3. features: 4-6 business features/benefits (NOT technical features). Each needs a title (3-5 words), description (1 sentence), and icon (one of: sparkles, shield, zap, heart, globe, chart, clock, users, star, target)
+4. faq: 4-5 frequently asked questions a customer would ask, with concise answers
+5. cta: a short call-to-action phrase (e.g. "Start your journey today")
+
+Output ONLY valid JSON matching this schema:
+{
+  "industry": "string",
+  "summary": "string — one-line business summary",
+  "agents": [
+    {
+      "id": "string",
+      "name": "string",
+      "role": "string — one of: customer_support, marketing, sales, operations, development, analytics",
+      "description": "string — one sentence",
+      "systemPrompt": "string — detailed system prompt",
+      "model": "string"
+    }
+  ],
+  "site": {
+    "tagline": "string",
+    "subtitle": "string",
+    "features": [
+      { "title": "string", "description": "string", "icon": "string" }
+    ],
+    "faq": [
+      { "question": "string", "answer": "string" }
+    ],
+    "cta": "string"
+  }
+}`;
+}
+async function generateWithAnthropic(companyName, businessDescription) {
+    const client = new Anthropic();
+    const message = await client.messages.create({
+        model: "claude-sonnet-4-6",
+        max_tokens: 8192,
+        system: buildSystemPrompt("anthropic"),
+        messages: [
+            {
+                role: "user",
+                content: `Company: ${companyName}\n\nBusiness Description: ${businessDescription}`,
+            },
+        ],
+    });
+    return message.content[0].type === "text" ? message.content[0].text : "";
+}
+async function generateWithOpenAI(companyName, businessDescription) {
+    const client = new OpenAI();
+    const response = await client.chat.completions.create({
+        model: "gpt-4.1",
+        max_tokens: 8192,
+        messages: [
+            { role: "system", content: buildSystemPrompt("openai") },
+            {
+                role: "user",
+                content: `Company: ${companyName}\n\nBusiness Description: ${businessDescription}`,
+            },
+        ],
+    });
+    return response.choices[0]?.message?.content || "";
+}
+export async function generateAgents(companyName, businessDescription, provider = "anthropic") {
+    const text = provider === "openai"
+        ? await generateWithOpenAI(companyName, businessDescription)
+        : await generateWithAnthropic(companyName, businessDescription);
+    // Extract JSON from response (handle markdown code blocks)
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/) || [null, text];
+    const jsonStr = (jsonMatch[1] || text).trim();
+    try {
+        const result = JSON.parse(jsonStr);
+        if (!result.agents || result.agents.length === 0) {
+            throw new Error("No agents generated");
+        }
+        // Ensure site content exists with defaults
+        if (!result.site) {
+            result.site = {
+                tagline: `${companyName} — Powered by AI`,
+                subtitle: result.summary || businessDescription,
+                features: [],
+                faq: [],
+                cta: "Get started today",
+            };
+        }
+        return result;
+    }
+    catch {
+        throw new Error("Failed to parse AI response. Please try again.");
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,337 @@
+#!/usr/bin/env node
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { generateAgents } from "./ai/generate.js";
+import { scaffoldProject } from "./scaffold/project.js";
+async function main() {
+    console.clear();
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("— Build Your AI Company")}`));
+    console.log();
+    p.intro(chalk.bgHex("#8b5cf6").white(" @tellet/create "));
+    // Step 0: New or Connect
+    const modeChoice = await p.select({
+        message: "What would you like to do?",
+        options: [
+            {
+                value: "new",
+                label: "New",
+                hint: "Build a new AI company from scratch",
+            },
+            {
+                value: "connect",
+                label: "Connect",
+                hint: "Add AI agents to your existing business",
+            },
+        ],
+    });
+    if (p.isCancel(modeChoice)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    const mode = modeChoice;
+    // Step 1: Company info
+    const company = await p.group({
+        name: () => p.text({
+            message: "What's your company name?",
+            placeholder: "Sunny Coffee",
+            validate: (v) => (!v ? "Company name is required" : undefined),
+        }),
+        description: () => p.text({
+            message: "Describe your business (what you do, who your customers are, what help you need):",
+            placeholder: "We sell specialty coffee subscriptions. Customers are coffee enthusiasts aged 25-45...",
+            validate: (v) => !v || v.length < 20
+                ? "Please provide at least a few sentences"
+                : undefined,
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        },
+    });
+    // Step 2: Deployment tier
+    const tierChoice = await p.select({
+        message: "Deployment mode:",
+        options: [
+            {
+                value: "quickstart",
+                label: "Quick Start",
+                hint: "Vercel + Supabase — free, instant deploy",
+            },
+            {
+                value: "cloud",
+                label: "Cloud",
+                hint: "Railway / Render / Fly.io — Docker, $5-20/mo",
+            },
+            {
+                value: "enterprise",
+                label: "Enterprise",
+                hint: "AWS CDK — auto-provision Lambda + RDS + CloudFront",
+            },
+        ],
+    });
+    if (p.isCancel(tierChoice)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    const tier = tierChoice;
+    // Step 3: Choose AI provider
+    const providerChoice = await p.select({
+        message: "Choose your AI provider:",
+        options: [
+            {
+                value: "anthropic",
+                label: "Anthropic (Claude)",
+                hint: "recommended — also powers the Orchestrator",
+            },
+            {
+                value: "openai",
+                label: "OpenAI (GPT)",
+                hint: "uses gpt-4.1 for generation",
+            },
+        ],
+    });
+    if (p.isCancel(providerChoice)) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    const provider = providerChoice;
+    // Step 4: Get API key
+    const envKey = provider === "anthropic"
+        ? process.env.ANTHROPIC_API_KEY
+        : process.env.OPENAI_API_KEY;
+    const envName = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
+    const keyPrefix = provider === "anthropic" ? "sk-ant-" : "sk-";
+    const keyPlaceholder = provider === "anthropic" ? "sk-ant-..." : "sk-...";
+    let apiKey = envKey || "";
+    if (!apiKey) {
+        const keyInput = await p.text({
+            message: `Your ${provider === "anthropic" ? "Anthropic" : "OpenAI"} API key:`,
+            placeholder: keyPlaceholder,
+            validate: (v) => !v || !v.startsWith(keyPrefix)
+                ? `Please enter a valid key (starts with ${keyPrefix})`
+                : undefined,
+        });
+        if (p.isCancel(keyInput)) {
+            p.cancel("Setup cancelled.");
+            process.exit(0);
+        }
+        apiKey = keyInput;
+        process.env[envName] = apiKey;
+    }
+    else {
+        p.log.info(chalk.dim(`Using ${envName} from environment.`));
+    }
+    // Orchestrator always needs Anthropic
+    let anthropicKey = "";
+    if (provider === "anthropic") {
+        anthropicKey = apiKey;
+    }
+    else {
+        const existingKey = process.env.ANTHROPIC_API_KEY || "";
+        if (existingKey) {
+            anthropicKey = existingKey;
+            p.log.info(chalk.dim("Using ANTHROPIC_API_KEY for Orchestrator."));
+        }
+        else {
+            p.log.info(chalk.dim("The Orchestrator requires an Anthropic API key (Claude tool use)."));
+            const orchKeyInput = await p.text({
+                message: "Anthropic API key for Orchestrator:",
+                placeholder: "sk-ant-...",
+                validate: (v) => !v || !v.startsWith("sk-ant-")
+                    ? "Please enter a valid Anthropic key (starts with sk-ant-)"
+                    : undefined,
+            });
+            if (p.isCancel(orchKeyInput)) {
+                p.cancel("Setup cancelled.");
+                process.exit(0);
+            }
+            anthropicKey = orchKeyInput;
+        }
+    }
+    // Step 5: Generate agents + site content
+    const s = p.spinner();
+    s.start("Generating your AI team and website...");
+    let agents;
+    try {
+        agents = await generateAgents(company.name, company.description, provider);
+        s.stop("Your AI team is ready!");
+    }
+    catch (err) {
+        s.stop("Failed to generate agents.");
+        p.log.error(err instanceof Error ? err.message : "Check your API key");
+        p.cancel("Setup failed.");
+        process.exit(1);
+    }
+    // Step 6: Show agents + site preview
+    p.log.info(chalk.bold("Meet your team:"));
+    console.log();
+    for (const agent of agents.agents) {
+        console.log(`  ${chalk.hex("#8b5cf6").bold(agent.name)} ${chalk.dim(`(${agent.role})`)}`);
+        console.log(`  ${chalk.dim(agent.description)}`);
+        console.log();
+    }
+    if (agents.site && mode === "new") {
+        p.log.info(chalk.bold("Your website:"));
+        console.log(`  ${chalk.hex("#f59e0b")(agents.site.tagline)}`);
+        console.log(`  ${chalk.dim(agents.site.subtitle)}`);
+        console.log();
+    }
+    const confirm = await p.confirm({
+        message: "Looks good?",
+        initialValue: true,
+    });
+    if (p.isCancel(confirm) || !confirm) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    // Step 7a: Connect mode — website URL for KB
+    let websiteUrl = "";
+    if (mode === "connect") {
+        const urlInput = await p.text({
+            message: "Your existing website URL (for Knowledge Base crawling):",
+            placeholder: "https://my-business.com",
+        });
+        if (!p.isCancel(urlInput) && urlInput) {
+            websiteUrl = urlInput;
+        }
+    }
+    // Step 7b: Infrastructure setup (tier-dependent)
+    let supabaseUrl = "";
+    let supabaseKey = "";
+    if (tier === "quickstart") {
+        p.log.info(`${chalk.bold("Supabase setup")} ${chalk.dim("(free tier works fine)")}\n` +
+            `  ${chalk.dim("1.")} Create a project at ${chalk.cyan("https://supabase.com/dashboard/new")}\n` +
+            `  ${chalk.dim("2.")} Go to Settings → API to find your URL and keys`);
+        const supabase = await p.group({
+            url: () => p.text({
+                message: "Your Supabase project URL:",
+                placeholder: "https://xxx.supabase.co",
+                validate: (v) => !v || !v.includes("supabase")
+                    ? "Please enter a valid Supabase URL"
+                    : undefined,
+            }),
+            key: () => p.text({
+                message: "Your Supabase publishable key (anon/public):",
+                placeholder: "sb_publishable_...",
+                validate: (v) => (!v ? "Key is required" : undefined),
+            }),
+        }, {
+            onCancel: () => {
+                p.cancel("Setup cancelled.");
+                process.exit(0);
+            },
+        });
+        supabaseUrl = supabase.url;
+        supabaseKey = supabase.key;
+    }
+    else if (tier === "cloud") {
+        p.log.info(chalk.dim("Cloud mode: PostgreSQL runs in Docker. No Supabase needed."));
+    }
+    else {
+        p.log.info(`${chalk.bold("AWS Enterprise setup")}\n` +
+            `  ${chalk.dim("Requires:")} AWS CLI configured + CDK bootstrapped\n` +
+            `  ${chalk.dim("Cost:")} ~$5-15/mo (Lambda + RDS free tier)`);
+    }
+    // Step 8: Scaffold project
+    s.start("Creating your project...");
+    try {
+        const projectDir = await scaffoldProject({
+            company: {
+                name: company.name,
+                description: company.description,
+                industry: agents.industry,
+            },
+            agents: agents.agents,
+            site: agents.site,
+            provider,
+            tier,
+            mode,
+            websiteUrl,
+            infra: {
+                anthropicKey,
+                openaiKey: provider === "openai" ? apiKey : undefined,
+                supabaseUrl,
+                supabaseKey,
+            },
+        });
+        s.stop("Project created!");
+        const slug = company.name
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-|-$/g, "");
+        const widgetSnippet = mode === "connect"
+            ? [
+                ``,
+                `${chalk.bold("Embed in your existing site:")}`,
+                `${chalk.cyan('<script src="https://YOUR_URL/widget.js"')}`,
+                `${chalk.cyan('  data-agent="' + agents.agents[0].id + '"')}`,
+                `${chalk.cyan('  data-api="https://YOUR_URL"></script>')}`,
+            ]
+            : [];
+        if (tier === "quickstart") {
+            p.note([
+                `cd ${slug}`,
+                `npm install`,
+                `npm run dev        ${chalk.dim("→ http://localhost:3000")}`,
+                ``,
+                `Dashboard:    ${chalk.dim("/dashboard")}`,
+                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
+                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
+                ...widgetSnippet,
+            ].join("\n"), mode === "connect" ? "Your AI agents are ready" : "Your AI company is ready");
+            p.outro(`Deploy: ${chalk.cyan("vercel deploy")}`);
+        }
+        else if (tier === "cloud") {
+            p.note([
+                `cd ${slug}`,
+                ``,
+                `${chalk.bold("Local development:")}`,
+                `docker compose up     ${chalk.dim("→ http://localhost:3000")}`,
+                ``,
+                `${chalk.bold("Deploy to Railway:")}`,
+                `railway login`,
+                `railway init`,
+                `railway add --plugin postgresql`,
+                `railway up`,
+                ``,
+                `Dashboard:    ${chalk.dim("/dashboard")}`,
+                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
+                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
+            ].join("\n"), "Your AI company is ready");
+            p.outro(`Or deploy to ${chalk.cyan("Render")}, ${chalk.cyan("Fly.io")}, or any Docker host`);
+        }
+        else {
+            p.note([
+                `cd ${slug}`,
+                ``,
+                `${chalk.bold("Local development:")}`,
+                `docker compose up     ${chalk.dim("→ http://localhost:3000")}`,
+                ``,
+                `${chalk.bold("Deploy to AWS:")}`,
+                `cd infra`,
+                `npm install`,
+                `npx cdk bootstrap     ${chalk.dim("(first time only)")}`,
+                `npx cdk deploy        ${chalk.dim("→ CloudFront URL in output")}`,
+                ``,
+                `${chalk.bold("Update API keys:")}`,
+                `aws secretsmanager put-secret-value \\`,
+                `  --secret-id ${slug}/api-keys \\`,
+                `  --secret-string '{"ANTHROPIC_API_KEY":"sk-ant-..."}'`,
+                ``,
+                `Dashboard:    ${chalk.dim("/dashboard")}`,
+                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
+                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
+                `Est. cost:    ${chalk.dim("$5-15/mo")}`,
+            ].join("\n"), "Your AI company is ready (AWS)");
+            p.outro(`Run ${chalk.cyan("cd infra && npx cdk deploy")} to provision AWS infrastructure`);
+        }
+    }
+    catch (err) {
+        s.stop("Failed to create project.");
+        p.log.error(err instanceof Error ? err.message : String(err));
+        process.exit(1);
+    }
+}
+main().catch(console.error);