create-bk-agent 0.16.0 → 0.17.0

package/README.md

@@ -1,54 +1,118 @@
 # create-bk-agent
 
-Scaffold a new [BackendKit agent](https://github.com/BackendKit-labs/backendkit-agent-framework) project in seconds.
+Scaffold a new [BackendKit agent](https://github.com/BackendKit-labs/backendkit-agent-framework) project in seconds — or add capabilities to an existing one.
 
-## Usage
+## Create a project
 
 ```bash
 npx create-bk-agent my-project
 ```
 
+The CLI asks three questions and generates a production-ready project:
+
 ```
-✨  create-bk-agent  v0.14.0
+✨  create-bk-agent  v0.17.0
 
-? Project name:  my-project
-? Template:      coding — Coding assistant (files, git, code execution)
-? LLM provider:  Anthropic (Claude)
+? Project name:          my-project
+? Architecture:          Multi-agent (orchestrator + specialists)
+? Skill packs:           Node.js / TypeScript
+? How will it be used?   MCP Server (HTTP)
 
-Creating coding agent in ./my-project...
+Creating Multi-agent — MCP Server (HTTP) agent in ./my-project...
 Installing dependencies...
 
-✅  Done!
+✅  Done! Your agent is ready.
+
    cd my-project
-   cp .env.example .env
-   npm run dev
+   cp .env.example .env      # add your API key
+   npm run server            # starts HTTP MCP on port 3001
 ```
 
-## Templates
+## Architectures
+
+| Architecture | What it gives you | Best for |
+|---|---|---|
+| `multi-agent` | Orchestrator + specialists with delegation | Domain agents (DevOps, finance, data, etc.) |
+| `single` | One agent with a tool registry | Simple task automation |
+| `coding` | 10 pre-built agents + all coding tools | Coding assistants, ready out of the box |
+| `autonomous` | Trigger system (cron / webhook / event) | Scheduled or event-driven daemons |
+| `minimal` | Bare engine, no entry point | Library embedding |
 
-### `coding` — complete, ready to run
-10 specialized agents (backend, frontend, QA, security, architecture…) and all
-coding tools (read/write files, run commands, git, search) are already configured.
-Add your API key, describe your project in `AGENT.md`, and it works out of the box.
-**Choose this when you want a coding assistant, not when you want to build one.**
+## Deploy modes
 
-### `domain-agent` — blank multi-agent architecture
-Orchestrator + specialists pattern with no pre-built agents or tools. You define
-the agents and tools for your specific domain (Docker, AWS, databases, APIs, etc.).
-The framework handles orchestration, delegation, and parallel execution.
-**Choose this when you are building a new type of agent from scratch.**
+Available for `multi-agent` and `single` architectures:
 
-| Template | What it gives you | You provide |
-|----------|------------------|-------------|
-| `coding` | 10 agents + all coding tools | API key + `AGENT.md` |
-| `domain-agent` | Orchestration skeleton | Agents + tools for your domain |
-| `autonomous` | Trigger system (cron / webhook / event) | Agent logic |
-| `mcp-server` | MCP server boilerplate | Tools to expose |
-| `minimal` | Bare engine | Everything |
+| Mode | Entry point | Use case |
+|---|---|---|
+| `repl` | `src/index.ts` — readline loop | Local terminal tool |
+| `mcp-http` | `src/server.ts` — HTTP MCP server | Connect to Claude Desktop, Cursor, etc. |
+| `mcp-stdio` | `src/server.ts` — stdio MCP server | Subprocess / pipe-based MCP |
+| `hybrid` | Both `index.ts` + `server.ts` | REPL for dev, server for production |
+| `library` | Only `src/engine.ts` exported | Import the engine in your own app |
 
 ## Providers
 
-Supports Anthropic (Claude), OpenAI, DeepSeek / OpenAI-compatible endpoints, and Ollama (local).
+Anthropic (Claude), OpenAI, DeepSeek / any OpenAI-compatible endpoint, and Ollama (local).
+
+---
+
+## Add capabilities to an existing project
+
+Once a project is created, use `add` to extend it without editing code manually:
+
+```bash
+npx create-bk-agent add <module> [options]
+```
+
+### `add server` — expose the agent as an HTTP MCP server
+
+```bash
+npx create-bk-agent add server
+npx create-bk-agent add server --port 4000 --name my-agent
+```
+
+- Generates `src/server.ts` wired to the existing engine
+- Adds `@backendkit-labs/mcp-server` to `dependencies`
+- Adds `"server"` script to `package.json`
+
+### `add specialist <name>` — add a specialist agent (multi-agent projects)
+
+```bash
+npx create-bk-agent add specialist data-analyst
+npx create-bk-agent add specialist git-expert
+```
+
+- Creates `src/agents/<name>.ts` with an `AgentProfile` stub
+- Patches `src/engine.ts`: adds the import and `agents.register()`
+
+### `add tools <domain>` — add a tool file for a new domain
+
+```bash
+npx create-bk-agent add tools github
+npx create-bk-agent add tools my-database
+```
+
+- Creates `src/tools/<domain>-tools.ts` with two stub tools (action + query)
+- Patches `src/engine.ts`: adds the import and `tools.register()`
+
+### `add mcp-client <url>` — connect to a remote MCP server
+
+```bash
+npx create-bk-agent add mcp-client http://localhost:3001/mcp
+npx create-bk-agent add mcp-client http://billing-agent/mcp --name billing
+```
+
+- Patches `src/engine.ts`: adds the entry to `mcpServers: [...]` inside `AgentEngine`
+- Creates the `mcpServers` array if it doesn't exist yet
+
+All `add` commands are **idempotent** — running the same command twice won't duplicate entries.
+
+---
+
+## Requirements
+
+- Node.js >= 20
+- An API key for your chosen provider (Anthropic, OpenAI, DeepSeek, or Ollama)
 
 ## License
 

package/dist/src/add/detector.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectProject = detectProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function detectProject(cwd) {
+    const pkgFile = path.join(cwd, 'package.json');
+    if (!fs.existsSync(pkgFile))
+        return null;
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(pkgFile, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const deps = {
+        ...(pkg.dependencies ?? {}),
+        ...(pkg.devDependencies ?? {}),
+    };
+    if (!deps['@backendkit-labs/agent-core'])
+        return null;
+    const engineFile = path.join(cwd, 'src', 'engine.ts');
+    let architecture = 'unknown';
+    let engineFnName = 'createEngine';
+    if (fs.existsSync(engineFile)) {
+        const content = fs.readFileSync(engineFile, 'utf-8');
+        if (content.includes('ORCHESTRATOR_PROFILE') || content.includes("id: 'orchestrator'")) {
+            architecture = 'multi-agent';
+        }
+        else if (content.includes('export function create')) {
+            architecture = 'single';
+        }
+        const match = content.match(/export function (\w+)\s*\(/);
+        if (match)
+            engineFnName = match[1];
+    }
+    return {
+        cwd,
+        architecture,
+        engineFile,
+        indexFile: path.join(cwd, 'src', 'index.ts'),
+        serverFile: path.join(cwd, 'src', 'server.ts'),
+        pkgFile,
+        engineFnName,
+    };
+}

package/dist/src/add/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAdd = runAdd;
+const detector_1 = require("./detector");
+const server_1 = require("./modules/server");
+const specialist_1 = require("./modules/specialist");
+const tools_1 = require("./modules/tools");
+const mcp_client_1 = require("./modules/mcp-client");
+const HELP = `
+Usage: npx create-bk-agent add <module> [options]
+
+Modules:
+  server                Add an HTTP MCP server (src/server.ts)
+    --port <n>            Port to listen on  (default: 3001)
+    --name <s>            MCP server name    (default: project directory name)
+
+  specialist <name>     Add a new specialist agent to a multi-agent project
+                        (creates src/agents/<name>.ts and patches engine.ts)
+
+  tools <domain>        Add a tool file for a new domain
+                        (creates src/tools/<domain>-tools.ts and patches engine.ts)
+
+  mcp-client <url>      Add a remote MCP server to the engine
+    --name <s>            Name for the mcpServers entry (default: last URL segment)
+
+Examples:
+  npx create-bk-agent add server --port 4000
+  npx create-bk-agent add specialist data-analyst
+  npx create-bk-agent add tools github
+  npx create-bk-agent add mcp-client http://localhost:3001/mcp --name billing
+`;
+function runAdd(args, cwd) {
+    const [module, ...rest] = args;
+    if (!module || module === '--help' || module === '-h') {
+        console.log(HELP);
+        process.exit(0);
+    }
+    const info = (0, detector_1.detectProject)(cwd);
+    if (!info) {
+        console.error('\n✗  No bk-agent project detected in the current directory.\n' +
+            '   Make sure you are inside a project created with npx create-bk-agent.\n');
+        process.exit(1);
+    }
+    switch (module) {
+        case 'server':
+            (0, server_1.addServer)(info, rest);
+            break;
+        case 'specialist':
+            if (info.architecture !== 'multi-agent') {
+                console.error(`\n⚠  "add specialist" is designed for multi-agent projects.\n` +
+                    `   Detected architecture: ${info.architecture}.\n` +
+                    `   Proceeding anyway — verify engine.ts manually.\n`);
+            }
+            (0, specialist_1.addSpecialist)(info, rest);
+            break;
+        case 'tools':
+            (0, tools_1.addTools)(info, rest);
+            break;
+        case 'mcp-client':
+            (0, mcp_client_1.addMcpClient)(info, rest);
+            break;
+        default:
+            console.error(`\n✗  Unknown module: "${module}"\n`);
+            console.log(HELP);
+            process.exit(1);
+    }
+}

package/dist/src/add/modules/mcp-client.js

@@ -0,0 +1,65 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addMcpClient = addMcpClient;
+const fs = __importStar(require("fs"));
+const patcher_1 = require("../patcher");
+function addMcpClient(info, args) {
+    const url = args[0];
+    if (!url) {
+        console.error('\n✗  Usage: add mcp-client <url> [--name <name>]\n');
+        process.exit(1);
+    }
+    let name = url.split('/').filter(Boolean).pop() ?? 'remote-agent';
+    for (let i = 1; i < args.length; i++) {
+        if (args[i] === '--name' && args[i + 1]) {
+            name = args[++i];
+            break;
+        }
+    }
+    if (!fs.existsSync(info.engineFile)) {
+        console.error('\n✗  src/engine.ts not found.\n');
+        process.exit(1);
+    }
+    const ok = (0, patcher_1.addMcpServerEntry)(info.engineFile, name, url);
+    if (ok) {
+        console.log(`\n✓  Patched src/engine.ts  (mcpServers: { name: '${name}', url: '${url}' })`);
+        console.log(`\nNext steps:\n   npm run dev\n`);
+    }
+    else {
+        console.error('\n✗  Could not locate AgentEngine constructor to inject mcpServers.\n');
+        process.exit(1);
+    }
+}

package/dist/src/add/modules/server.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addServer = addServer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const patcher_1 = require("../patcher");
+function parseArgs(args, defaultName) {
+    let port = 3001;
+    let name = defaultName;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--port' && args[i + 1])
+            port = parseInt(args[++i]);
+        if (args[i] === '--name' && args[i + 1])
+            name = args[++i];
+    }
+    return { port, name };
+}
+function generateServerTs(info, opts) {
+    return `import 'dotenv/config';
+import { AgentMCPServer } from '@backendkit-labs/mcp-server';
+import { CallbackTransport } from '@backendkit-labs/agent-core';
+import { z } from 'zod';
+import { ${info.engineFnName} } from './engine';
+
+const server = new AgentMCPServer({
+    name:    '${opts.name}',
+    version: '1.0.0',
+    port:    parseInt(process.env.MCP_PORT ?? '${opts.port}'),
+
+    tools: [
+        {
+            name:        'agent_request',
+            description: 'TODO: describe what requests this agent handles',
+            schema: {
+                request: z.string().describe('Natural-language request for the agent'),
+            },
+            buildPrompt: ({ request }: { request: string }) => request,
+        },
+    ],
+
+    engineFactory: (transport: CallbackTransport) => ${info.engineFnName}(transport),
+});
+
+await server.start();
+`;
+}
+function addServer(info, args) {
+    const opts = parseArgs(args, path.basename(info.cwd));
+    if (fs.existsSync(info.serverFile)) {
+        console.error(`\n✗  src/server.ts already exists. Remove it first to regenerate.\n`);
+        process.exit(1);
+    }
+    fs.writeFileSync(info.serverFile, generateServerTs(info, opts));
+    console.log(`\n✓  Created src/server.ts  (HTTP MCP on port ${opts.port})`);
+    const added = (0, patcher_1.addPackageDependency)(info.pkgFile, '@backendkit-labs/mcp-server', '^0.16.0');
+    (0, patcher_1.addPackageDependency)(info.pkgFile, 'zod', '^3.25.0');
+    (0, patcher_1.addPackageScript)(info.pkgFile, 'server', 'ts-node src/server.ts');
+    if (added) {
+        console.log(`✓  package.json  (@backendkit-labs/mcp-server added)`);
+    }
+    console.log(`✓  package.json  (script "server" added)`);
+    console.log(`
+Next steps:
+   npm install
+   npm run server        # starts HTTP MCP on port ${opts.port}
+`);
+}

package/dist/src/add/modules/specialist.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSpecialist = addSpecialist;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const patcher_1 = require("../patcher");
+function toConstName(name) {
+    return name.replace(/-/g, '_').toUpperCase() + '_PROFILE';
+}
+function toDisplayName(name) {
+    return name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+function generateSpecialistTs(name) {
+    const constName = toConstName(name);
+    return `import type { AgentProfile } from '@backendkit-labs/agent-core';
+
+// TODO: Rename this file and export to match your domain
+export const ${constName}: AgentProfile = {
+    id: '${name}',
+    name: '${toDisplayName(name)}',
+    icon: '🔧',
+    description: 'TODO: describe what this specialist does',
+    delegatesTo: [],
+    allowedTools: [
+        // TODO: list the tool names this agent can use
+    ],
+    systemPrompt: \`You are a specialist in TODO: <your domain area>.
+
+Use the available tools to complete the task delegated to you.
+Be precise and report results clearly.\`,
+};
+`;
+}
+function addSpecialist(info, args) {
+    const name = args[0];
+    if (!name) {
+        console.error('\n✗  Usage: add specialist <name>\n');
+        process.exit(1);
+    }
+    const agentFile = path.join(info.cwd, 'src', 'agents', `${name}.ts`);
+    if (fs.existsSync(agentFile)) {
+        console.error(`\n✗  src/agents/${name}.ts already exists.\n`);
+        process.exit(1);
+    }
+    fs.writeFileSync(agentFile, generateSpecialistTs(name));
+    console.log(`\n✓  Created src/agents/${name}.ts`);
+    if (fs.existsSync(info.engineFile)) {
+        const constName = toConstName(name);
+        (0, patcher_1.addImportLine)(info.engineFile, `import { ${constName} } from './agents/${name}';`);
+        // Primary: insert after TODO comment; fallback: after last .register( call
+        const inserted = (0, patcher_1.insertAfterPattern)(info.engineFile, /\/\/ TODO: register more specialists/, `    agents.register(${constName});`) ||
+            (0, patcher_1.insertAfterPattern)(info.engineFile, /agents\.register\(/, `    agents.register(${constName});`);
+        if (inserted) {
+            console.log(`✓  Patched src/engine.ts  (agents.register(${constName}))`);
+        }
+        else {
+            console.log(`⚠  Could not auto-patch engine.ts — add manually: agents.register(${constName})`);
+        }
+        const orchestratorFile = path.join(info.cwd, 'src', 'agents', 'orchestrator.ts');
+        if (fs.existsSync(orchestratorFile)) {
+            console.log(`\n  Reminder: add '${name}' to orchestrator.ts delegatesTo[] and update the systemPrompt.`);
+        }
+    }
+    console.log(`\nNext steps:\n   Implement src/agents/${name}.ts\n   npm run dev\n`);
+}

package/dist/src/add/modules/tools.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTools = addTools;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const patcher_1 = require("../patcher");
+function toCamelCase(name) {
+    return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function generateToolsTs(domain) {
+    const fn = toCamelCase(domain);
+    return `import { defineTool, z } from '@backendkit-labs/agent-core';
+
+// TODO: replace with real ${domain} SDK/API calls
+
+export const ${fn}Action = defineTool({
+    name: '${domain}_action',
+    description: 'TODO: describe what this tool does',
+    input: z.object({
+        target: z.string().describe('Target to act on'),
+        // TODO: add more parameters
+    }),
+    execute: async ({ target }) => {
+        // TODO: implement
+        return \`${domain} action on: \${target}\`;
+    },
+});
+
+export const ${fn}Query = defineTool({
+    name: '${domain}_query',
+    description: 'TODO: describe what this query returns',
+    input: z.object({
+        filter: z.string().optional().describe('Optional filter'),
+    }),
+    execute: async ({ filter }) => {
+        // TODO: implement
+        return JSON.stringify({ results: [], filter });
+    },
+});
+`;
+}
+function addTools(info, args) {
+    const domain = args[0];
+    if (!domain) {
+        console.error('\n✗  Usage: add tools <domain>\n');
+        process.exit(1);
+    }
+    const toolsFile = path.join(info.cwd, 'src', 'tools', `${domain}-tools.ts`);
+    if (fs.existsSync(toolsFile)) {
+        console.error(`\n✗  src/tools/${domain}-tools.ts already exists.\n`);
+        process.exit(1);
+    }
+    fs.mkdirSync(path.dirname(toolsFile), { recursive: true });
+    fs.writeFileSync(toolsFile, generateToolsTs(domain));
+    console.log(`\n✓  Created src/tools/${domain}-tools.ts`);
+    if (fs.existsSync(info.engineFile)) {
+        const fn = toCamelCase(domain);
+        (0, patcher_1.addImportLine)(info.engineFile, `import { ${fn}Action, ${fn}Query } from './tools/${domain}-tools';`);
+        const inserted = (0, patcher_1.insertAfterPattern)(info.engineFile, /\/\/ TODO: register more tools/, `    tools.register(${fn}Action).register(${fn}Query);`) ||
+            (0, patcher_1.insertAfterPattern)(info.engineFile, /tools\.register\(/, `    tools.register(${fn}Action).register(${fn}Query);`);
+        if (inserted) {
+            console.log(`✓  Patched src/engine.ts  (tools.register(${fn}Action, ${fn}Query))`);
+        }
+        else {
+            console.log(`⚠  Could not auto-patch engine.ts — add manually: tools.register(${fn}Action).register(${fn}Query)`);
+        }
+    }
+    console.log(`\nNext steps:\n   Implement src/tools/${domain}-tools.ts\n   npm run dev\n`);
+}