@tellet/create 0.10.0 → 0.12.0

package/README.md

@@ -1,6 +1,6 @@
 # Tell it. Let it.
 
-> AI agents that run your business — email, delegate, schedule, embed.
+> AI agents that run your business — create, manage, and deploy. One CLI.
 
 ```bash
 npx @tellet/create
@@ -12,6 +12,56 @@ Or start instantly at [tellet.com](https://tellet.com) — no setup required.
 
 tellet generates an AI agent team for your business. Agents don't just chat — they send emails, delegate tasks to each other, run scheduled automations, and serve customers through an embeddable widget.
 
+## CLI commands
+
+After creating a project, manage it with the `tellet` CLI:
+
+```bash
+# Install globally (optional — or use npx @tellet/create <command>)
+npm i -g @tellet/create
+
+# Inside your tellet project:
+tellet dev              # Start dev server
+tellet build            # Build for production
+tellet status           # Show project info
+tellet agent list       # List all agents
+tellet agent add        # Add a new agent interactively
+tellet agent remove     # Remove an agent
+tellet deploy           # Guided deployment (Vercel, Railway, Docker, AWS)
+tellet mcp              # Start MCP server (for Claude Code / Cursor)
+tellet help             # Show all commands
+```
+
+## MCP Server (Claude Code / Cursor / Codex)
+
+Use tellet from Claude Code, Cursor, or any MCP-compatible AI tool:
+
+```json
+{
+  "mcpServers": {
+    "tellet": {
+      "command": "npx",
+      "args": ["@tellet/create", "mcp"],
+      "cwd": "/path/to/your-tellet-project"
+    }
+  }
+}
+```
+
+Available MCP tools:
+
+| Tool | Description |
+|------|-------------|
+| `project_status` | Company info, agents, channels, environment health |
+| `agent_list` | List all agents with details |
+| `agent_add` | Add a new agent (name, role, description) |
+| `agent_remove` | Remove an agent by ID |
+| `config_read` | Read full tellet.json |
+| `dev_start` | Start Next.js dev server |
+| `deploy_info` | Show deployment options |
+
+Then just ask your AI: *"Add a marketing agent called Nova"* or *"Show me the project status"*.
+
 ## What agents can do
 
 - **Email customers** — Send follow-ups, confirmations, and outreach via Resend

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function run(args: string[]): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import chalk from "chalk";
+const COMMANDS = {
+    dev: { description: "Start development server", module: "./commands/dev.js" },
+    build: { description: "Build for production", module: "./commands/build.js" },
+    status: { description: "Show project status", module: "./commands/status.js" },
+    agent: { description: "Manage agents (list, add, remove)", module: "./commands/agent.js" },
+    deploy: { description: "Deploy your project", module: "./commands/deploy.js" },
+    mcp: { description: "Start MCP server (for Claude Code / Cursor)", module: "./commands/mcp.js" },
+};
+function printBanner() {
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("CLI")}`));
+    console.log();
+}
+function printHelp() {
+    printBanner();
+    console.log(chalk.bold("  Usage:"));
+    console.log(`    ${chalk.cyan("tellet")} ${chalk.dim("<command>")}`);
+    console.log(`    ${chalk.cyan("npx @tellet/create")} ${chalk.dim("<command>")}`);
+    console.log();
+    console.log(chalk.bold("  Commands:"));
+    const padLen = Math.max(...Object.keys(COMMANDS).map((k) => k.length)) + 2;
+    for (const [name, cmd] of Object.entries(COMMANDS)) {
+        console.log(`    ${chalk.cyan(name.padEnd(padLen))} ${chalk.dim(cmd.description)}`);
+    }
+    console.log();
+    console.log(`    ${chalk.cyan("(no command)".padEnd(padLen))} ${chalk.dim("Create a new tellet project")}`);
+    console.log();
+    console.log(chalk.dim("  Run tellet <command> --help for command-specific help."));
+    console.log();
+}
+export async function run(args) {
+    const command = args[0];
+    // No command or help → check if we should scaffold or show help
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        // If no command and no tellet.json in CWD, run scaffold
+        if (!command) {
+            const { main: scaffold } = await import("./scaffold-flow.js");
+            return scaffold();
+        }
+        printHelp();
+        return;
+    }
+    const cmd = COMMANDS[command];
+    if (!cmd) {
+        console.error(chalk.red(`  Unknown command: ${command}`));
+        console.log(chalk.dim(`  Run ${chalk.cyan("tellet help")} to see available commands.`));
+        process.exit(1);
+    }
+    const subArgs = args.slice(1);
+    const mod = await import(cmd.module);
+    await mod.default(subArgs);
+}

package/dist/commands/agent.d.ts

@@ -0,0 +1 @@
+export default function agent(args: string[]): Promise<void>;

package/dist/commands/agent.js

@@ -0,0 +1,156 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import { loadConfigOrExit, saveConfig, nameToId, generateAgentFile, updateAgentRegistry, } from "./shared.js";
+const VALID_ROLES = [
+    "customer_support",
+    "sales",
+    "marketing",
+    "operations",
+    "analytics",
+    "development",
+];
+export default async function agent(args) {
+    const sub = args[0];
+    switch (sub) {
+        case "list":
+        case "ls":
+            return agentList();
+        case "add":
+            return agentAdd();
+        case "remove":
+        case "rm":
+            return agentRemove(args.slice(1));
+        default:
+            console.log();
+            console.log(chalk.bold("  Usage:"));
+            console.log(`    tellet agent list     ${chalk.dim("List all agents")}`);
+            console.log(`    tellet agent add      ${chalk.dim("Add a new agent")}`);
+            console.log(`    tellet agent remove   ${chalk.dim("Remove an agent")}`);
+            console.log();
+    }
+}
+async function agentList() {
+    const config = await loadConfigOrExit();
+    console.log();
+    console.log(chalk.bold(`  Agents (${config.agents.length})`));
+    console.log();
+    for (const agent of config.agents) {
+        const channels = agent.channels.join(", ");
+        const tools = agent.tools.length > 0 ? agent.tools.join(", ") : chalk.dim("none");
+        console.log(`  ${chalk.hex("#8b5cf6").bold(agent.name)}`);
+        console.log(`    ID:       ${chalk.dim(agent.id)}`);
+        console.log(`    Role:     ${chalk.dim(agent.role)}`);
+        console.log(`    Model:    ${chalk.dim(agent.model)}`);
+        console.log(`    Channels: ${chalk.dim(channels)}`);
+        console.log(`    Tools:    ${tools}`);
+        console.log();
+    }
+}
+async function agentAdd() {
+    const config = await loadConfigOrExit();
+    console.log();
+    p.intro(chalk.bgHex("#8b5cf6").white(" Add Agent "));
+    const info = await p.group({
+        name: () => p.text({
+            message: "Agent name:",
+            placeholder: "Luna",
+            validate: (v) => {
+                if (!v)
+                    return "Name is required";
+                const id = nameToId(v);
+                if (!id)
+                    return "Name must contain at least one letter or number";
+                return undefined;
+            },
+        }),
+        role: () => p.select({
+            message: "Role:",
+            options: VALID_ROLES.map((r) => ({ value: r, label: r.replace(/_/g, " ") })),
+        }),
+        description: () => p.text({
+            message: "What does this agent do?",
+            placeholder: "Handles billing inquiries and payment processing",
+            validate: (v) => (!v ? "Description is required" : undefined),
+        }),
+    }, {
+        onCancel: () => {
+            p.cancel("Cancelled.");
+            process.exit(0);
+        },
+    });
+    const name = info.name;
+    const role = info.role;
+    const description = info.description;
+    const id = nameToId(name);
+    if (config.agents.some((a) => a.id === id)) {
+        p.log.error(`Agent with ID "${id}" already exists.`);
+        process.exit(1);
+    }
+    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);
+    p.log.success(`Added ${chalk.bold(name)} (${role})`);
+    p.outro(chalk.dim(`Agent file: agents/${id}.ts`));
+}
+async function agentRemove(args) {
+    const config = await loadConfigOrExit();
+    const force = args.includes("--yes") || args.includes("-y");
+    const idArg = args.find((a) => !a.startsWith("-"));
+    if (config.agents.length === 0) {
+        p.log.error("No agents to remove.");
+        return;
+    }
+    let targetId = idArg;
+    if (!targetId) {
+        console.log();
+        const choice = await p.select({
+            message: "Which agent to remove?",
+            options: config.agents.map((a) => ({
+                value: a.id,
+                label: `${a.name} (${a.role})`,
+            })),
+        });
+        if (p.isCancel(choice)) {
+            p.cancel("Cancelled.");
+            return;
+        }
+        targetId = choice;
+    }
+    const agent = config.agents.find((a) => a.id === targetId);
+    if (!agent) {
+        p.log.error(`Agent "${targetId}" not found.`);
+        process.exit(1);
+    }
+    if (!force) {
+        const confirm = await p.confirm({
+            message: `Remove ${agent.name} (${agent.role})?`,
+            initialValue: false,
+        });
+        if (p.isCancel(confirm) || !confirm) {
+            p.cancel("Cancelled.");
+            return;
+        }
+    }
+    config.agents = config.agents.filter((a) => a.id !== targetId);
+    await saveConfig(config);
+    const agentPath = path.resolve(process.cwd(), "agents", `${targetId}.ts`);
+    if (await fs.pathExists(agentPath)) {
+        await fs.remove(agentPath);
+    }
+    await updateAgentRegistry(config);
+    p.log.success(`Removed ${chalk.bold(agent.name)}`);
+}

package/dist/commands/build.d.ts

@@ -0,0 +1 @@
+export default function build(_args: string[]): Promise<void>;

package/dist/commands/build.js

@@ -0,0 +1,14 @@
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import { loadConfigOrExit } from "./shared.js";
+export default async function build(_args) {
+    const config = await loadConfigOrExit();
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("build")} — ${config.company.name}`));
+    console.log();
+    const result = spawnSync("npx", ["next", "build"], {
+        cwd: process.cwd(),
+        stdio: "inherit",
+    });
+    process.exit(result.status ?? 1);
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1 @@
+export default function deploy(_args: string[]): Promise<void>;

package/dist/commands/deploy.js

@@ -0,0 +1,117 @@
+import { spawnSync } from "child_process";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import { loadConfigOrExit } from "./shared.js";
+export default async function deploy(_args) {
+    const config = await loadConfigOrExit();
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("deploy")} — ${config.company.name}`));
+    console.log();
+    // Detect tier from project structure
+    const fs = await import("fs-extra");
+    const path = await import("path");
+    const cwd = process.cwd();
+    const hasInfra = await fs.default.pathExists(path.default.join(cwd, "infra"));
+    const hasDockerCompose = await fs.default.pathExists(path.default.join(cwd, "docker-compose.yml"));
+    const hasRailwayToml = await fs.default.pathExists(path.default.join(cwd, "railway.toml"));
+    const targets = [];
+    targets.push({
+        value: "vercel",
+        label: "Vercel",
+        hint: "Recommended for Quick Start — free, instant",
+    });
+    if (hasRailwayToml || hasDockerCompose) {
+        targets.push({
+            value: "railway",
+            label: "Railway",
+            hint: "Docker-based, $5-20/mo",
+        });
+    }
+    if (hasDockerCompose) {
+        targets.push({
+            value: "docker",
+            label: "Docker (manual)",
+            hint: "Any Docker host — Render, Fly.io, etc.",
+        });
+    }
+    if (hasInfra) {
+        targets.push({
+            value: "aws",
+            label: "AWS CDK",
+            hint: "Lambda + RDS + CloudFront",
+        });
+    }
+    const choice = await p.select({
+        message: "Deploy target:",
+        options: targets,
+    });
+    if (p.isCancel(choice)) {
+        p.cancel("Cancelled.");
+        return;
+    }
+    const target = choice;
+    switch (target) {
+        case "vercel":
+            return deployVercel();
+        case "railway":
+            return deployRailway();
+        case "docker":
+            return deployDocker();
+        case "aws":
+            return deployAws(cwd);
+    }
+}
+function deployVercel() {
+    console.log(chalk.dim("  Launching Vercel deploy..."));
+    console.log();
+    const result = spawnSync("npx", ["vercel"], {
+        cwd: process.cwd(),
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        console.log();
+        console.log(chalk.dim("  If Vercel CLI is not installed:"));
+        console.log(chalk.cyan("    npm i -g vercel && vercel"));
+    }
+}
+function deployRailway() {
+    console.log();
+    console.log(chalk.bold("  Railway deployment:"));
+    console.log();
+    console.log(`  ${chalk.dim("1.")} ${chalk.cyan("railway login")}`);
+    console.log(`  ${chalk.dim("2.")} ${chalk.cyan("railway init")}`);
+    console.log(`  ${chalk.dim("3.")} ${chalk.cyan("railway add --plugin postgresql")}`);
+    console.log(`  ${chalk.dim("4.")} ${chalk.cyan("railway up")}`);
+    console.log();
+    console.log(chalk.dim("  Set environment variables in Railway dashboard after deploy."));
+    console.log();
+}
+function deployDocker() {
+    console.log();
+    console.log(chalk.bold("  Docker deployment:"));
+    console.log();
+    console.log(`  ${chalk.dim("Build:")}  ${chalk.cyan("docker build -t tellet .")}`);
+    console.log(`  ${chalk.dim("Run:")}    ${chalk.cyan("docker compose up -d")}`);
+    console.log();
+    console.log(chalk.dim("  Works with Render, Fly.io, DigitalOcean, or any Docker host."));
+    console.log();
+    console.log(chalk.bold("  Fly.io:"));
+    console.log(`  ${chalk.cyan("  fly launch && fly deploy")}`);
+    console.log();
+    console.log(chalk.bold("  Render:"));
+    console.log(chalk.dim("  Connect your GitHub repo at render.com → New Web Service → Docker"));
+    console.log();
+}
+function deployAws(cwd) {
+    console.log();
+    console.log(chalk.bold("  AWS CDK deployment:"));
+    console.log();
+    console.log(`  ${chalk.cyan("cd infra")}`);
+    console.log(`  ${chalk.cyan("npm install")}`);
+    console.log(`  ${chalk.cyan("npx cdk bootstrap")}   ${chalk.dim("(first time only)")}`);
+    console.log(`  ${chalk.cyan("npx cdk deploy")}`);
+    console.log();
+    console.log(chalk.dim("  CloudFront URL will be in the output."));
+    console.log(chalk.dim("  API keys are stored in AWS Secrets Manager."));
+    console.log();
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1 @@
+export default function dev(_args: string[]): Promise<void>;

package/dist/commands/dev.js

@@ -0,0 +1,15 @@
+import { spawnSync } from "child_process";
+import chalk from "chalk";
+import { loadConfigOrExit } from "./shared.js";
+export default async function dev(_args) {
+    const config = await loadConfigOrExit();
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("dev")} — ${config.company.name}`));
+    console.log(chalk.dim(`  ${config.agents.length} agents · ${config.llm.provider} · ${config.storage}`));
+    console.log();
+    const result = spawnSync("npx", ["next", "dev"], {
+        cwd: process.cwd(),
+        stdio: "inherit",
+    });
+    process.exit(result.status ?? 1);
+}

package/dist/commands/mcp.d.ts

@@ -0,0 +1 @@
+export default function mcp(_args: string[]): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,4 @@
+import { startMcpServer } from "../mcp/server.js";
+export default async function mcp(_args) {
+    await startMcpServer();
+}

package/dist/commands/shared.d.ts

@@ -0,0 +1,69 @@
+export interface TelletConfig {
+    version: string;
+    company: {
+        name: string;
+        description: string;
+        industry: string;
+    };
+    engine: string;
+    llm: {
+        provider: string;
+        defaultModel: string;
+        fallback: string | null;
+    };
+    agents: {
+        id: string;
+        name: string;
+        role: string;
+        model: string;
+        channels: string[];
+        tools: string[];
+    }[];
+    tools: Record<string, {
+        type: string;
+        description: string;
+    }>;
+    channels: Record<string, {
+        enabled: boolean;
+    }>;
+    mode: string;
+    storage: string;
+    integrations: string[];
+    websiteUrl?: string;
+    site?: Record<string, unknown>;
+}
+/**
+ * Load tellet.json from CWD. Throws if not found.
+ */
+export declare function loadConfig(): Promise<TelletConfig>;
+/**
+ * Load tellet.json from CWD with pretty error + exit (for CLI commands only).
+ */
+export declare function loadConfigOrExit(): Promise<TelletConfig>;
+/**
+ * Save tellet.json back to CWD.
+ */
+export declare function saveConfig(config: TelletConfig): Promise<void>;
+/**
+ * Normalize a display name to a safe identifier.
+ * Returns empty string if input has no alphanumeric characters.
+ */
+export declare function nameToId(name: string): string;
+/**
+ * Generate an agent .ts file with properly escaped values.
+ */
+export declare function generateAgentFile(agent: {
+    id: string;
+    name: string;
+    role: string;
+    model: string;
+    systemPrompt: string;
+}): string;
+/**
+ * Rewrite agents/index.ts registry to match config.
+ */
+export declare function updateAgentRegistry(config: {
+    agents: {
+        id: string;
+    }[];
+}): Promise<void>;

package/dist/commands/shared.js

@@ -0,0 +1,73 @@
+import fs from "fs-extra";
+import path from "path";
+import chalk from "chalk";
+/**
+ * Load tellet.json from CWD. Throws if not found.
+ */
+export async function loadConfig() {
+    const configPath = path.resolve(process.cwd(), "tellet.json");
+    if (!(await fs.pathExists(configPath))) {
+        throw new Error("No tellet.json found in current directory.");
+    }
+    return fs.readJSON(configPath);
+}
+/**
+ * Load tellet.json from CWD with pretty error + exit (for CLI commands only).
+ */
+export async function loadConfigOrExit() {
+    try {
+        return await loadConfig();
+    }
+    catch {
+        console.error(chalk.red("  No tellet.json found in current directory.\n") +
+            chalk.dim("  Run this command from inside a tellet project, or create one:\n") +
+            chalk.cyan("  npx @tellet/create"));
+        process.exit(1);
+    }
+}
+/**
+ * Save tellet.json back to CWD.
+ */
+export async function saveConfig(config) {
+    const configPath = path.resolve(process.cwd(), "tellet.json");
+    await fs.writeJSON(configPath, config, { spaces: 2 });
+}
+/**
+ * Normalize a display name to a safe identifier.
+ * Returns empty string if input has no alphanumeric characters.
+ */
+export function nameToId(name) {
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_|_$/g, "");
+}
+/**
+ * Generate an agent .ts file with properly escaped values.
+ */
+export function generateAgentFile(agent) {
+    return `import { defineAgent } from "@/lib/engine";
+
+export default defineAgent({
+  id: ${JSON.stringify(agent.id)},
+  name: ${JSON.stringify(agent.name)},
+  role: ${JSON.stringify(agent.role)},
+  model: ${JSON.stringify(agent.model)},
+  systemPrompt: ${JSON.stringify(agent.systemPrompt)},
+  channels: ["web_chat"],
+  tools: [],
+});
+`;
+}
+/**
+ * Rewrite agents/index.ts registry to match config.
+ */
+export async function updateAgentRegistry(config) {
+    const agentsDir = path.resolve(process.cwd(), "agents");
+    const indexPath = path.join(agentsDir, "index.ts");
+    const imports = config.agents
+        .map((a) => `import ${a.id} from "./${a.id}.js";`)
+        .join("\n");
+    const exports = config.agents.map((a) => `  ${a.id}`).join(",\n");
+    await fs.writeFile(indexPath, `${imports}\n\nexport const agents = {\n${exports},\n};\n`);
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export default function status(_args: string[]): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import fs from "fs-extra";
+import path from "path";
+import { loadConfigOrExit } from "./shared.js";
+export default async function status(_args) {
+    const config = await loadConfigOrExit();
+    console.log();
+    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("status")}`));
+    console.log();
+    // Company
+    console.log(chalk.bold("  Company"));
+    console.log(`    Name:     ${chalk.white(config.company.name)}`);
+    console.log(`    Industry: ${chalk.dim(config.company.industry)}`);
+    console.log(`    Mode:     ${chalk.dim(config.mode)}`);
+    console.log();
+    // LLM
+    console.log(chalk.bold("  LLM"));
+    console.log(`    Provider: ${chalk.white(config.llm.provider)}`);
+    console.log(`    Model:    ${chalk.dim(config.llm.defaultModel)}`);
+    console.log();
+    // Agents
+    console.log(chalk.bold(`  Agents (${config.agents.length})`));
+    for (const agent of config.agents) {
+        const tools = agent.tools.length > 0 ? chalk.dim(` [${agent.tools.join(", ")}]`) : "";
+        console.log(`    ${chalk.hex("#8b5cf6")(agent.name)} ${chalk.dim(`(${agent.role})`)}${tools}`);
+    }
+    console.log();
+    // Channels
+    const enabledChannels = Object.entries(config.channels)
+        .filter(([, v]) => v.enabled)
+        .map(([k]) => k);
+    const disabledChannels = Object.entries(config.channels)
+        .filter(([, v]) => !v.enabled)
+        .map(([k]) => k);
+    console.log(chalk.bold("  Channels"));
+    if (enabledChannels.length > 0) {
+        console.log(`    Enabled:  ${chalk.green(enabledChannels.join(", "))}`);
+    }
+    if (disabledChannels.length > 0) {
+        console.log(`    Disabled: ${chalk.dim(disabledChannels.join(", "))}`);
+    }
+    console.log();
+    // Environment check
+    console.log(chalk.bold("  Environment"));
+    const envPath = path.resolve(process.cwd(), ".env.local");
+    const envExists = await fs.pathExists(envPath);
+    console.log(`    .env.local: ${envExists ? chalk.green("found") : chalk.red("missing")}`);
+    const nodeModules = await fs.pathExists(path.resolve(process.cwd(), "node_modules"));
+    console.log(`    node_modules: ${nodeModules ? chalk.green("installed") : chalk.yellow("not installed — run npm install")}`);
+    const hasPackageLock = await fs.pathExists(path.resolve(process.cwd(), "package-lock.json"));
+    console.log(`    lock file: ${hasPackageLock ? chalk.green("found") : chalk.dim("none")}`);
+    console.log();
+}