@tellet/create 0.10.0 → 0.12.0

package/dist/mcp/tools.js

@@ -0,0 +1,264 @@
+import { z } from "zod";
+import fs from "fs-extra";
+import path from "path";
+import { spawn } from "child_process";
+import { loadConfig, saveConfig, nameToId, generateAgentFile, updateAgentRegistry, } from "../commands/shared.js";
+const VALID_ROLES = [
+    "customer_support",
+    "sales",
+    "marketing",
+    "operations",
+    "analytics",
+    "development",
+];
+export function registerTools(server) {
+    // ─── project_status ───────────────────────────────────
+    server.registerTool("project_status", {
+        title: "Project Status",
+        description: "Show tellet project status: company info, agents, channels, LLM config, and environment health.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const envPath = path.resolve(process.cwd(), ".env.local");
+        const envExists = await fs.pathExists(envPath);
+        const nodeModules = await fs.pathExists(path.resolve(process.cwd(), "node_modules"));
+        const enabledChannels = Object.entries(config.channels)
+            .filter(([, v]) => v.enabled)
+            .map(([k]) => k);
+        const text = [
+            `Company: ${config.company.name}`,
+            `Industry: ${config.company.industry}`,
+            `Mode: ${config.mode}`,
+            `Provider: ${config.llm.provider} (${config.llm.defaultModel})`,
+            `Agents: ${config.agents.length} (${config.agents.map((a) => a.name).join(", ")})`,
+            `Channels: ${enabledChannels.join(", ") || "none"}`,
+            `Storage: ${config.storage}`,
+            `.env.local: ${envExists ? "found" : "MISSING"}`,
+            `node_modules: ${nodeModules ? "installed" : "NOT INSTALLED"}`,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+    // ─── agent_list ───────────────────────────────────────
+    server.registerTool("agent_list", {
+        title: "List Agents",
+        description: "List all agents in the tellet project with their roles, models, channels, and tools.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        if (config.agents.length === 0) {
+            return { content: [{ type: "text", text: "No agents configured." }] };
+        }
+        const lines = config.agents.map((a) => [
+            `- ${a.name} (${a.id})`,
+            `  Role: ${a.role}`,
+            `  Model: ${a.model}`,
+            `  Channels: ${a.channels.join(", ")}`,
+            `  Tools: ${a.tools.length > 0 ? a.tools.join(", ") : "none"}`,
+        ].join("\n"));
+        return { content: [{ type: "text", text: lines.join("\n\n") }] };
+    });
+    // ─── agent_add ────────────────────────────────────────
+    server.registerTool("agent_add", {
+        title: "Add Agent",
+        description: "Add a new AI agent to the tellet project. Updates tellet.json, creates the agent file, and updates the registry.",
+        inputSchema: z.object({
+            name: z.string().describe("Agent display name (e.g. Luna, Atlas)"),
+            role: z
+                .enum(VALID_ROLES)
+                .describe("Agent role"),
+            description: z
+                .string()
+                .describe("What this agent does (used in system prompt)"),
+        }),
+    }, async ({ name, role, description }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const id = nameToId(name);
+        if (!id) {
+            return {
+                content: [{ type: "text", text: "Error: Name must contain at least one letter or number." }],
+                isError: true,
+            };
+        }
+        if (config.agents.some((a) => a.id === id)) {
+            return {
+                content: [{ type: "text", text: `Error: Agent "${id}" already exists.` }],
+                isError: true,
+            };
+        }
+        const model = config.llm.defaultModel;
+        const systemPrompt = `You are ${name}, the ${role.replace(/_/g, " ")} agent for ${config.company.name}. ${description}`;
+        config.agents.push({
+            id,
+            name,
+            role,
+            model,
+            channels: ["web_chat"],
+            tools: role === "customer_support" ? ["search_knowledge"] : [],
+        });
+        await saveConfig(config);
+        const agentsDir = path.resolve(process.cwd(), "agents");
+        await fs.mkdirp(agentsDir);
+        await fs.writeFile(path.join(agentsDir, `${id}.ts`), generateAgentFile({ id, name, role, model, systemPrompt }));
+        await updateAgentRegistry(config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Added agent "${name}" (${role})\nID: ${id}\nFile: agents/${id}.ts\nTotal agents: ${config.agents.length}`,
+                },
+            ],
+        };
+    });
+    // ─── agent_remove ─────────────────────────────────────
+    server.registerTool("agent_remove", {
+        title: "Remove Agent",
+        description: "Remove an agent from the tellet project by ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Agent ID to remove"),
+        }),
+    }, async ({ id }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const agent = config.agents.find((a) => a.id === id);
+        if (!agent) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Agent "${id}" not found. Available: ${config.agents.map((a) => a.id).join(", ")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        config.agents = config.agents.filter((a) => a.id !== id);
+        await saveConfig(config);
+        const agentPath = path.resolve(process.cwd(), "agents", `${id}.ts`);
+        if (await fs.pathExists(agentPath)) {
+            await fs.remove(agentPath);
+        }
+        await updateAgentRegistry(config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed agent "${agent.name}" (${id})\nRemaining agents: ${config.agents.length}`,
+                },
+            ],
+        };
+    });
+    // ─── config_read ──────────────────────────────────────
+    server.registerTool("config_read", {
+        title: "Read Config",
+        description: "Read the full tellet.json configuration file.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const configPath = path.resolve(process.cwd(), "tellet.json");
+        if (!(await fs.pathExists(configPath))) {
+            return configError();
+        }
+        const raw = await fs.readFile(configPath, "utf-8");
+        return { content: [{ type: "text", text: raw }] };
+    });
+    // ─── dev_start ────────────────────────────────────────
+    server.registerTool("dev_start", {
+        title: "Start Dev Server",
+        description: "Start the Next.js development server (next dev). Launches in the background — success means the process was spawned, not that the server is healthy.",
+        inputSchema: z.object({
+            port: z
+                .number()
+                .int()
+                .min(1024)
+                .max(65535)
+                .optional()
+                .describe("Port number (default: 3000)"),
+        }),
+    }, async ({ port }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const nodeModules = await fs.pathExists(path.resolve(process.cwd(), "node_modules"));
+        if (!nodeModules) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: node_modules not found. Run npm install first.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const args = ["next", "dev"];
+        if (port)
+            args.push("--port", String(port));
+        const child = spawn("npx", args, {
+            cwd: process.cwd(),
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        const actualPort = port || 3000;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Dev server spawned for ${config.company.name} on http://localhost:${actualPort}\nPID: ${child.pid}\nNote: Check the port is not already in use.`,
+                },
+            ],
+        };
+    });
+    // ─── deploy_info ──────────────────────────────────────
+    server.registerTool("deploy_info", {
+        title: "Deploy Info",
+        description: "Show deployment options and commands based on the project structure.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const cwd = process.cwd();
+        const hasInfra = await fs.pathExists(path.join(cwd, "infra"));
+        const hasDocker = await fs.pathExists(path.join(cwd, "docker-compose.yml"));
+        const hasRailway = await fs.pathExists(path.join(cwd, "railway.toml"));
+        const options = [];
+        options.push("## Vercel (recommended for Quick Start)", "```", "npx vercel", "```", "");
+        if (hasRailway || hasDocker) {
+            options.push("## Railway", "```", "railway login", "railway init", "railway add --plugin postgresql", "railway up", "```", "");
+        }
+        if (hasDocker) {
+            options.push("## Docker", "```", "docker build -t tellet .", "docker compose up -d", "```", "Works with Render, Fly.io, DigitalOcean, or any Docker host.", "");
+        }
+        if (hasInfra) {
+            options.push("## AWS CDK", "```", "cd infra && npm install", "npx cdk bootstrap  # first time only", "npx cdk deploy", "```", "");
+        }
+        return { content: [{ type: "text", text: options.join("\n") }] };
+    });
+}
+// ─── Helpers ──────────────────────────────────────────
+async function tryLoadConfig() {
+    try {
+        return await loadConfig();
+    }
+    catch {
+        return null;
+    }
+}
+function configError() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: "No tellet.json found in current directory. Make sure the MCP server is running from inside a tellet project.",
+            },
+        ],
+        isError: true,
+    };
+}

package/dist/scaffold-flow.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;

package/dist/scaffold-flow.js

@@ -0,0 +1,402 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { generateAgents } from "./ai/generate.js";
+import { scaffoldProject } from "./scaffold/project.js";
+import { setupSupabase } from "./setup/supabase.js";
+import { installDependencies } from "./setup/deps.js";
+export 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 = "";
+    let useAutomatedSupabase = false;
+    if (tier === "quickstart") {
+        useAutomatedSupabase = true;
+    }
+    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...");
+    const slug = company.name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+    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: supabaseUrl || "PLACEHOLDER",
+                supabaseKey: supabaseKey || "PLACEHOLDER",
+            },
+        });
+        s.stop("Project created!");
+        // Post-scaffold automation
+        // Step 9: Supabase setup (quickstart only)
+        if (tier === "quickstart" && useAutomatedSupabase) {
+            const result = await setupSupabase(projectDir);
+            if (result.method === "local" && result.credentials) {
+                supabaseUrl = result.credentials.url;
+                supabaseKey = result.credentials.anonKey;
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                    serviceRoleKey: result.credentials.serviceRoleKey,
+                });
+                p.log.success(chalk.green("Supabase configured automatically!") +
+                    chalk.dim(` → ${supabaseUrl}`));
+            }
+            else if (result.method === "remote") {
+                p.log.info(chalk.dim("Project linked. Get your URL and key from Settings → API."));
+                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;
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                });
+            }
+            else {
+                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;
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                });
+            }
+        }
+        // Step 10: Install dependencies
+        const installConfirm = await p.confirm({
+            message: "Install dependencies now? (npm install)",
+            initialValue: true,
+        });
+        if (!p.isCancel(installConfirm) && installConfirm) {
+            await installDependencies(projectDir);
+        }
+        // Final output
+        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>')}`,
+            ]
+            : [];
+        const didInstall = !p.isCancel(installConfirm) && installConfirm === true;
+        const devCmd = didInstall ? "tellet dev" : "npm install && tellet dev";
+        if (tier === "quickstart") {
+            p.note([
+                `cd ${slug}`,
+                `${devCmd}        ${chalk.dim("→ http://localhost:3000")}`,
+                ``,
+                `${chalk.bold("CLI commands:")}`,
+                `tellet status     ${chalk.dim("project info")}`,
+                `tellet agent list ${chalk.dim("list agents")}`,
+                `tellet deploy     ${chalk.dim("deploy guide")}`,
+                ``,
+                `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("tellet 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:")}`,
+                `tellet deploy`,
+                ``,
+                `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:")}`,
+                `tellet deploy`,
+                ``,
+                `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("tellet 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);
+    }
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@tellet/create",
-  "version": "0.10.0",
-  "description": "AI agents that run your business — email, delegate, schedule, embed. One command.",
+  "version": "0.12.0",
+  "description": "AI agents that run your business — create, manage, and deploy. One CLI.",
   "type": "module",
   "bin": {
-    "create": "dist/index.js"
+    "create": "dist/index.js",
+    "tellet": "dist/index.js"
   },
   "files": [
     "dist",
@@ -41,6 +42,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.80.0",
     "@clack/prompts": "^1.1.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "chalk": "^5.6.2",
     "fs-extra": "^11.3.4",
     "openai": "^6.32.0"