@tellet/create 0.9.0 → 0.12.0

package/README.md

@@ -1,188 +1,204 @@
 # Tell it. Let it.
 
-> The open-source platform for running an Agentic Company.
+> AI agents that run your business — create, manage, and deploy. One CLI.
 
 ```bash
-npx create-tellet
+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.
+Or start instantly at [tellet.com](https://tellet.com) — no setup required.
 
-## 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)
+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.
 
-## How it works
+## 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
 ```
-npx create-tellet
 
-? 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...
+## MCP Server (Claude Code / Cursor / Codex)
 
-  Generating your AI team and website...
+Use tellet from Claude Code, Cursor, or any MCP-compatible AI tool:
 
-  Your team:
-  Barista (customer_support)
-  Roaster (marketing)
-  Grinder (sales)
+```json
+{
+  "mcpServers": {
+    "tellet": {
+      "command": "npx",
+      "args": ["@tellet/create", "mcp"],
+      "cwd": "/path/to/your-tellet-project"
+    }
+  }
+}
+```
 
-  Your website:
-  "Coffee worth waking up for"
+Available MCP tools:
 
-  ✓ Project created!
-```
+| 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 |
 
-## Quick start
+Then just ask your AI: *"Add a marketing agent called Nova"* or *"Show me the project status"*.
 
-```bash
-# Quick Start (Vercel + Supabase, free)
-npx create-tellet
-cd your-company
-npm install && npm run dev
+## What agents can do
 
-# Cloud (Docker + Railway, $5/mo)
-npx create-tellet  # choose "Cloud"
-cd your-company
-docker compose up         # local dev
-railway up                # deploy
+- **Email customers** — Send follow-ups, confirmations, and outreach via Resend
+- **Delegate to each other** — Support agent routes billing questions to sales automatically
+- **Run on schedule** — Daily reports, weekly summaries, automated follow-ups via cron
+- **Search knowledge** — Reference your product info, policies, and FAQ for accurate answers
+- **Serve customers anywhere** — Embeddable widget for any website, one script tag
 
-# Enterprise (AWS CDK, $5-15/mo)
-npx create-tellet  # choose "Enterprise"
-cd your-company/infra
-npm install && npx cdk deploy
-```
+## Two ways to start
 
-## Architecture
+### Hosted (tellet.com) — recommended
 
-```
-┌─ tellet Platform ─────────────────────────┐
-│  Owner ↔ Orchestrator                      │
-│              ↕                             │
-│  Agent Team (CS · Marketing · Sales · Ops) │
-│              ↕                             │
-│  MCP Bridge Layer                          │
-│  (KB, Stripe, DB, Email, Custom API...)    │
-└────────────────────────────────────────────┘
-```
+1. Sign up at [tellet.com](https://tellet.com)
+2. Describe your business in one sentence
+3. AI generates your agent team with email, delegation, and scheduling
+4. Embed the widget on your site, agents go to work
 
-## Project structure
+### Self-hosted (CLI)
 
+```bash
+npx @tellet/create
+cd your-company
+npm install && npm run dev
 ```
-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)
+
+## How it works
+
 ```
+You: "I run a coffee shop called Sunny Coffee"
 
-## Orchestrator
+  Generating your AI team...
 
-The Orchestrator is your AI company manager. Talk to it from the dashboard:
+  Your team:
+  Barista (customer_support) — emails, knowledge, delegation
+  Roaster (marketing)       — emails, knowledge, delegation
+  Grinder (sales)           — emails, knowledge, delegation
 
-- "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
+  Orchestrator tools:
+  ✓ schedule_task        — cron-based agent automation
+  ✓ list_scheduled_tasks — view all schedules
+  ✓ cancel_scheduled_task
 
-## Tool Marketplace
+  ✓ Your AI company is live!
+```
 
-Connect tools via the Orchestrator or `tellet.json`:
+## Architecture
 
-| 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 |
+```
+┌─ tellet Platform ──────────────────────────────────┐
+│                                                     │
+│  Owner ↔ Orchestrator (schedule, manage, configure) │
+│              ↕                                     │
+│  Agent Team (CS · Marketing · Sales · Ops)         │
+│     ↕ delegate_to_agent ↕                          │
+│  Actions: email · search · schedule                │
+│              ↕                                     │
+│  Channels: dashboard · widget · cron               │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
 
-19,000+ MCP servers available via the [MCP Registry](https://registry.modelcontextprotocol.io/).
+## Agent capabilities by role
 
-## Deployment options
+| Role | search_knowledge | send_email | delegate_to_agent |
+|------|:---:|:---:|:---:|
+| customer_support | Y | Y | Y |
+| sales | Y | Y | Y |
+| marketing | Y | Y | Y |
+| operations | Y | Y | Y |
+| analytics | Y | - | Y |
 
-| 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 |
+## Orchestrator commands
 
-## Connect mode
+The Orchestrator manages your AI company through conversation:
 
-Already have a business? Use Connect mode:
+- "Schedule marketing to send a weekly summary every Monday 9am"
+- "Show all scheduled tasks"
+- "Add our refund policy to the Knowledge Base"
+- "Update the support agent's system prompt"
+- "Show my stats"
 
-```bash
-npx create-tellet  # choose "Connect"
-```
+## Embeddable widget
 
-- Skips site generation, keeps dashboard + API
-- Embeddable widget for your existing site:
+Add AI chat to any website:
 
 ```html
-<script src="https://your-tellet.com/widget.js"
-        data-agent="support"
-        data-api="https://your-tellet.com"></script>
+<script src="https://tellet.com/widget.js"></script>
+<script>
+  Tellet.init({ companyId: "your-company-id" });
+</script>
 ```
 
-## Configuration
+Features: dark/light theme, streaming responses, session persistence, mobile responsive.
 
-All configuration lives in `tellet.json`:
+## Project structure (self-hosted)
 
-```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", "..." : "..." }
-}
+```
+your-company/
+├─�� app/
+│   ├── (site)/             # Public website with chat widget
+│   ├── (dashboard)/        # Management dashboard + Orchestrator
+│   └── api/
+│       ├── chat/           # Agent chat (SSE, tool use loop)
+│       ├── orchestrator/   # Orchestrator (scheduling, management)
+│       ├── cron/           # Scheduled task execution
+│       └── widget/         # Public widget API (CORS, no auth)
+├── lib/
+│   ├── engine/             # Agent runtime with agentic loop
+│   ├── actions/            # Role-based tools (email, delegate, search)
+│   ├── scheduling/         # Cron parser + task executor
+│   ├── orchestrator/       # Orchestrator tools + executor
+│   ├── providers/          # LLM providers (Anthropic, OpenAI)
+│   └── mcp/                # Knowledge base, tool registry
+├── public/widget.js        # Embeddable chat widget
+├── supabase/migrations/    # Database schema
+└── vercel.json             # Cron configuration
 ```
 
 ## 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
+- [Supabase](https://supabase.com/) — Auth, database, pgvector, RLS
 - [Anthropic Claude](https://anthropic.com/) / [OpenAI](https://openai.com/) — AI models
+- [Resend](https://resend.com/) — Email delivery
+- [Vercel Cron](https://vercel.com/docs/cron-jobs) — Scheduled task execution
 - [Tailwind CSS 4](https://tailwindcss.com/) — Styling
-- [Framer Motion](https://www.framer.com/motion/) — Animations
+
+## Environment variables
+
+| Variable | Required | Description |
+|----------|:---:|-------------|
+| `NEXT_PUBLIC_SUPABASE_URL` | Y | Supabase project URL |
+| `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY` | Y | Supabase publishable key |
+| `SUPABASE_SERVICE_ROLE_KEY` | Y | Supabase service role key |
+| `ANTHROPIC_API_KEY` | Y | Claude API key |
+| `RESEND_API_KEY` | - | Resend API key (for email) |
+| `CRON_SECRET` | - | Secret for cron endpoint auth |
 
 ## License
 
@@ -190,6 +206,6 @@ MIT
 
 ## Links
 
-- [tellet.com](https://tellet.com) — Website
+- [tellet.com](https://tellet.com) — Hosted platform (free)
 - [GitHub](https://github.com/agentic-company/tellet) — Source code
-- [npm](https://www.npmjs.com/package/create-tellet) — Package
+- [npm](https://www.npmjs.com/package/@tellet/create) — CLI package

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>;