@tellet/create 0.9.0 → 0.12.0

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/dist/setup/deps.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Run `npm install` in the project directory with live output.
+ */
+export declare function installDependencies(projectDir: string): Promise<boolean>;

package/dist/setup/deps.js

@@ -0,0 +1,24 @@
+import { spawnSync } from "child_process";
+import * as p from "@clack/prompts";
+/**
+ * Run `npm install` in the project directory with live output.
+ */
+export async function installDependencies(projectDir) {
+    const s = p.spinner();
+    s.start("Installing dependencies...");
+    const result = spawnSync("npm", ["install"], {
+        cwd: projectDir,
+        stdio: "pipe",
+        timeout: 300_000,
+    });
+    if (result.status !== 0) {
+        s.stop("Failed to install dependencies.");
+        const stderr = result.stderr?.toString().trim();
+        if (stderr) {
+            p.log.error(stderr.slice(0, 500));
+        }
+        return false;
+    }
+    s.stop("Dependencies installed!");
+    return true;
+}

package/dist/setup/env.d.ts

@@ -0,0 +1,12 @@
+interface EnvOptions {
+    anthropicKey: string;
+    openaiKey?: string;
+    supabaseUrl: string;
+    supabaseKey: string;
+    serviceRoleKey?: string;
+}
+/**
+ * Write (or overwrite) the .env.local file with Supabase + API credentials.
+ */
+export declare function writeEnvFile(projectDir: string, options: EnvOptions): Promise<void>;
+export {};

package/dist/setup/env.js

@@ -0,0 +1,26 @@
+import fs from "fs-extra";
+import path from "path";
+/** Escape a value for .env files — wrap in quotes if it contains special chars. */
+function envQuote(v) {
+    if (/[\s#"'\\$`!]/.test(v) || v.includes("\n")) {
+        return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+    }
+    return v;
+}
+/**
+ * Write (or overwrite) the .env.local file with Supabase + API credentials.
+ */
+export async function writeEnvFile(projectDir, options) {
+    const lines = [
+        `# Orchestrator (always Anthropic)`,
+        `ANTHROPIC_API_KEY=${envQuote(options.anthropicKey)}`,
+    ];
+    if (options.openaiKey) {
+        lines.push(`OPENAI_API_KEY=${envQuote(options.openaiKey)}`);
+    }
+    lines.push(``, `# Supabase`, `NEXT_PUBLIC_SUPABASE_URL=${envQuote(options.supabaseUrl)}`, `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=${envQuote(options.supabaseKey)}`);
+    if (options.serviceRoleKey) {
+        lines.push(`SUPABASE_SERVICE_ROLE_KEY=${envQuote(options.serviceRoleKey)}`);
+    }
+    await fs.writeFile(path.join(projectDir, ".env.local"), lines.join("\n") + "\n");
+}

package/dist/setup/supabase.d.ts

@@ -0,0 +1,36 @@
+/** Check if the Supabase CLI is installed and accessible. */
+export declare function hasSupabaseCLI(): boolean;
+/** Check if Docker is running (required for `supabase start`). */
+export declare function hasDocker(): boolean;
+export interface SupabaseCredentials {
+    url: string;
+    anonKey: string;
+    serviceRoleKey?: string;
+}
+/**
+ * Initialize Supabase in the project directory.
+ * Creates supabase/config.toml if not already present.
+ */
+export declare function supabaseInit(projectDir: string): boolean;
+/**
+ * Start local Supabase (Docker containers).
+ * Returns credentials on success, null on failure.
+ */
+export declare function supabaseStartLocal(projectDir: string): Promise<SupabaseCredentials | null>;
+/**
+ * Link to a remote Supabase project.
+ * Prompts for project ref, runs `supabase link`.
+ */
+export declare function supabaseLinkRemote(projectDir: string): Promise<boolean>;
+/**
+ * Push migrations to the database.
+ */
+export declare function supabasePushMigrations(projectDir: string): Promise<boolean>;
+/**
+ * Full Supabase setup flow for quickstart tier.
+ * Returns credentials or null if user chose manual setup.
+ */
+export declare function setupSupabase(projectDir: string): Promise<{
+    credentials: SupabaseCredentials | null;
+    method: "local" | "remote" | "manual";
+}>;