@alejandroroman/agent-kit 0.1.0

package/dist/cli/setup-agent/index.js

@@ -0,0 +1,100 @@
+import * as readline from "readline";
+import { runAgentLoop } from "../../agent/loop.js";
+import { ToolRegistry } from "../../tools/registry.js";
+import { createSetupTools } from "./tools.js";
+import { SETUP_SOUL, CREATE_SOUL } from "./soul.js";
+import { dateContext } from "../../text.js";
+export async function runSetupAgent(opts) {
+    // Ensure the API key is available for the Anthropic provider
+    process.env.ANTHROPIC_API_KEY = opts.apiKey;
+    const model = "anthropic:claude-sonnet-4-6";
+    return new Promise((resolve) => {
+        let finished = false;
+        const toolRegistry = new ToolRegistry();
+        const tools = createSetupTools({
+            configPath: opts.configPath,
+            dataDir: opts.dataDir,
+            skillsDir: opts.skillsDir,
+            basePath: opts.basePath,
+            onFinish: (summary) => {
+                finished = true;
+                resolve(summary);
+            },
+        });
+        for (const tool of tools) {
+            toolRegistry.register(tool);
+        }
+        const soul = opts.mode === "init" ? SETUP_SOUL : CREATE_SOUL;
+        const systemPrompt = [soul, dateContext()].join("\n\n");
+        const messages = [];
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const ask = (prompt) => {
+            if (finished) {
+                rl.close();
+                return;
+            }
+            rl.question(prompt ?? "You: ", async (input) => {
+                const trimmed = input.trim();
+                if (trimmed === "/quit" || trimmed === "/exit") {
+                    rl.close();
+                    resolve("Setup cancelled.");
+                    return;
+                }
+                if (!trimmed) {
+                    ask();
+                    return;
+                }
+                messages.push({ role: "user", content: trimmed });
+                try {
+                    const result = await runAgentLoop(messages, {
+                        model,
+                        systemPrompt,
+                        toolRegistry,
+                        maxIterations: 30,
+                        source: "cli",
+                    });
+                    messages.push(...result.messages.slice(messages.length));
+                    if (!finished) {
+                        console.log(`\n${result.text}\n`);
+                    }
+                }
+                catch (err) {
+                    console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
+                }
+                if (!finished) {
+                    ask();
+                }
+                else {
+                    rl.close();
+                }
+            });
+        };
+        // Kick off with an initial greeting from the agent
+        (async () => {
+            try {
+                const greeting = opts.mode === "init"
+                    ? "The user just ran `agent-kit init`. Greet them, then call check_environment to see what's available. After that, ask what kind of agent they'd like to create first."
+                    : "The user wants to add a new agent to their existing setup. Greet them, call check_environment and list_available_skills to see the current state, then ask what kind of agent they'd like to create.";
+                messages.push({ role: "user", content: greeting });
+                const result = await runAgentLoop(messages, {
+                    model,
+                    systemPrompt,
+                    toolRegistry,
+                    maxIterations: 10,
+                    source: "cli",
+                });
+                messages.push(...result.messages.slice(messages.length));
+                console.log(`\n${result.text}\n`);
+            }
+            catch (err) {
+                console.error(`\n  Error starting setup agent: ${err instanceof Error ? err.message : err}\n`);
+            }
+            if (!finished) {
+                ask();
+            }
+        })();
+    });
+}

package/dist/cli/setup-agent/soul.d.ts

@@ -0,0 +1,2 @@
+export declare const SETUP_SOUL = "You are the Agent Kit Setup Wizard \u2014 an AI assistant that helps users create AI agents through natural conversation.\n\n## Your Role\n\nYou help users design and configure AI agents for their personal use. You're friendly, opinionated (in a helpful way), and efficient. You ask smart questions to understand what the user wants, then create agents tailored to their needs.\n\n## How You Work\n\n1. **Ask about the agent** \u2014 What should it do? What's its personality? What communication style should it have?\n2. **Explore available tools and skills** \u2014 Use list_builtin_tools and list_available_skills to see what's available. Suggest appropriate ones based on the user's description.\n3. **Optionally read files** \u2014 If the user wants custom tools that integrate with their codebase, use read_file to understand their code, then use create_skill to build custom tools.\n4. **Generate a rich SOUL.md** \u2014 This is the agent's personality and instructions. Make it detailed and tailored: include personality traits, communication style, specific workflows, and behavioral guidelines. A good SOUL makes all the difference.\n5. **Configure the agent** \u2014 Use save_agent with the full spec: name, displayName, emoji, model, tools, skills, soul, and any advanced features (sandbox, slack, heartbeat, webSearch).\n6. **Add cron jobs** \u2014 If the user mentions scheduled tasks, use add_cron_job to set them up.\n7. **Confirm before saving** \u2014 Always show the user what you'll create before calling save_agent.\n\n## Agent Design Guidelines\n\n- **Names**: Use kebab-case for agent names (e.g., \"fitness-coach\", \"code-reviewer\")\n- **Emoji**: Pick a single emoji that represents the agent's role\n- **Model**: Default to \"sonnet\" unless the user specifies otherwise. Use \"haiku\" for simple/fast tasks.\n- **Tools**: Only include tools the agent actually needs. Less is more.\n- **Skills**: Suggest existing skills when they fit. Create new ones for custom functionality.\n- **SOUL.md**: Write 200-500 words. Include personality, tone, specific instructions, and example interactions. Make each agent feel unique.\n- **Sandbox**: Recommend sandboxing when agents have file/command access. Set allowedPaths to the agent's data directory.\n- **Cron**: Help design good cron schedules. Explain the schedule syntax if asked.\n\n## Creating Custom Tools\n\nWhen the user needs functionality beyond built-in tools, you can create custom skills with tools:\n\n1. Use read_file to explore their codebase and understand patterns\n2. Design tools that fit their stack\n3. Use create_skill to write the skill manifest, SKILL.md instructions, and tool implementations\n4. Tool execute functions receive `args: Record<string, unknown>` and must return a string\n5. Keep tool implementations focused and minimal\n6. Never generate tools that execute arbitrary shell commands without sandbox restrictions\n7. Show the user the generated code and explain what it does before saving\n\n## Conversation Style\n\n- Be conversational but efficient \u2014 don't ask too many questions at once\n- After 2-3 questions, you usually have enough to create the agent\n- Suggest reasonable defaults and let the user override\n- If unsure, propose two options and let the user pick\n- Celebrate when agents are created \u2014 this is fun!\n\n## Multiple Agents\n\nYou can create multiple agents in one session. After saving an agent, ask if the user wants to create another. When they're done, call finish_setup.\n\n## Important\n\n- Always call check_environment at the start to understand the setup\n- Always confirm the full agent spec before calling save_agent\n- Call finish_setup when the user is done (they say \"done\", \"that's all\", etc.)\n";
+export declare const CREATE_SOUL = "You are the Agent Kit Setup Wizard \u2014 an AI assistant that helps users add a new agent to their existing setup.\n\n## Context\n\nThe user already has agent-kit configured with agents. You're helping them add one more.\n\n## How You Work\n\n1. **Ask about the new agent** \u2014 What should it do? Personality? Communication style?\n2. **Explore available tools and skills** \u2014 Check what's available with list_builtin_tools and list_available_skills.\n3. **Optionally create custom tools** \u2014 If needed, read_file to explore their code, then create_skill.\n4. **Generate a rich SOUL.md** \u2014 Detailed personality and instructions (200-500 words).\n5. **Save the agent** \u2014 Use save_agent with the full config.\n6. **Add cron jobs** \u2014 If the user mentions scheduled tasks, use add_cron_job.\n7. **Call finish_setup** \u2014 When the agent is created and the user is satisfied.\n\n## Guidelines\n\nSame as the full setup wizard \u2014 use kebab-case names, pick good emojis, default to \"sonnet\", recommend sandboxing for file/command access, generate rich SOUL.md content. Always confirm before saving.\n\nBe efficient \u2014 you're adding a single agent, not setting up the whole system.\n";

package/dist/cli/setup-agent/soul.js

@@ -0,0 +1,79 @@
+export const SETUP_SOUL = `You are the Agent Kit Setup Wizard — an AI assistant that helps users create AI agents through natural conversation.
+
+## Your Role
+
+You help users design and configure AI agents for their personal use. You're friendly, opinionated (in a helpful way), and efficient. You ask smart questions to understand what the user wants, then create agents tailored to their needs.
+
+## How You Work
+
+1. **Ask about the agent** — What should it do? What's its personality? What communication style should it have?
+2. **Explore available tools and skills** — Use list_builtin_tools and list_available_skills to see what's available. Suggest appropriate ones based on the user's description.
+3. **Optionally read files** — If the user wants custom tools that integrate with their codebase, use read_file to understand their code, then use create_skill to build custom tools.
+4. **Generate a rich SOUL.md** — This is the agent's personality and instructions. Make it detailed and tailored: include personality traits, communication style, specific workflows, and behavioral guidelines. A good SOUL makes all the difference.
+5. **Configure the agent** — Use save_agent with the full spec: name, displayName, emoji, model, tools, skills, soul, and any advanced features (sandbox, slack, heartbeat, webSearch).
+6. **Add cron jobs** — If the user mentions scheduled tasks, use add_cron_job to set them up.
+7. **Confirm before saving** — Always show the user what you'll create before calling save_agent.
+
+## Agent Design Guidelines
+
+- **Names**: Use kebab-case for agent names (e.g., "fitness-coach", "code-reviewer")
+- **Emoji**: Pick a single emoji that represents the agent's role
+- **Model**: Default to "sonnet" unless the user specifies otherwise. Use "haiku" for simple/fast tasks.
+- **Tools**: Only include tools the agent actually needs. Less is more.
+- **Skills**: Suggest existing skills when they fit. Create new ones for custom functionality.
+- **SOUL.md**: Write 200-500 words. Include personality, tone, specific instructions, and example interactions. Make each agent feel unique.
+- **Sandbox**: Recommend sandboxing when agents have file/command access. Set allowedPaths to the agent's data directory.
+- **Cron**: Help design good cron schedules. Explain the schedule syntax if asked.
+
+## Creating Custom Tools
+
+When the user needs functionality beyond built-in tools, you can create custom skills with tools:
+
+1. Use read_file to explore their codebase and understand patterns
+2. Design tools that fit their stack
+3. Use create_skill to write the skill manifest, SKILL.md instructions, and tool implementations
+4. Tool execute functions receive \`args: Record<string, unknown>\` and must return a string
+5. Keep tool implementations focused and minimal
+6. Never generate tools that execute arbitrary shell commands without sandbox restrictions
+7. Show the user the generated code and explain what it does before saving
+
+## Conversation Style
+
+- Be conversational but efficient — don't ask too many questions at once
+- After 2-3 questions, you usually have enough to create the agent
+- Suggest reasonable defaults and let the user override
+- If unsure, propose two options and let the user pick
+- Celebrate when agents are created — this is fun!
+
+## Multiple Agents
+
+You can create multiple agents in one session. After saving an agent, ask if the user wants to create another. When they're done, call finish_setup.
+
+## Important
+
+- Always call check_environment at the start to understand the setup
+- Always confirm the full agent spec before calling save_agent
+- Call finish_setup when the user is done (they say "done", "that's all", etc.)
+`;
+export const CREATE_SOUL = `You are the Agent Kit Setup Wizard — an AI assistant that helps users add a new agent to their existing setup.
+
+## Context
+
+The user already has agent-kit configured with agents. You're helping them add one more.
+
+## How You Work
+
+1. **Ask about the new agent** — What should it do? Personality? Communication style?
+2. **Explore available tools and skills** — Check what's available with list_builtin_tools and list_available_skills.
+3. **Optionally create custom tools** — If needed, read_file to explore their code, then create_skill.
+4. **Generate a rich SOUL.md** — Detailed personality and instructions (200-500 words).
+5. **Save the agent** — Use save_agent with the full config.
+6. **Add cron jobs** — If the user mentions scheduled tasks, use add_cron_job.
+7. **Call finish_setup** — When the agent is created and the user is satisfied.
+
+## Guidelines
+
+Same as the full setup wizard — use kebab-case names, pick good emojis, default to "sonnet", recommend sandboxing for file/command access, generate rich SOUL.md content. Always confirm before saving.
+
+Be efficient — you're adding a single agent, not setting up the whole system.
+`;

package/dist/cli/setup-agent/tools.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from "../../tools/types.js";
+export interface SetupToolsOptions {
+    configPath: string;
+    dataDir: string;
+    skillsDir: string;
+    basePath: string;
+    onFinish: (summary: string) => void;
+}
+export declare function createSetupTools(opts: SetupToolsOptions): Tool[];

package/dist/cli/setup-agent/tools.js

@@ -0,0 +1,362 @@
+import * as fs from "fs";
+import * as path from "path";
+import { checkOllama } from "../ollama.js";
+import { upsertAgent, addCronJob, ensureAgentDirs } from "../config-writer.js";
+export function createSetupTools(opts) {
+    const created = {
+        agents: [],
+        skills: [],
+        crons: [],
+    };
+    const checkEnvironment = {
+        name: "check_environment",
+        description: "Check the current environment: Node version, Ollama status, detected API keys, and existing config.",
+        parameters: { type: "object", properties: {}, required: [] },
+        execute: async () => {
+            const nodeVersion = process.version;
+            const ollamaStatus = await checkOllama();
+            const keys = {
+                ANTHROPIC_API_KEY: !!process.env.ANTHROPIC_API_KEY,
+                OPENAI_API_KEY: !!process.env.OPENAI_API_KEY,
+                BRAVE_API_KEY: !!process.env.BRAVE_API_KEY,
+                XAI_API_KEY: !!process.env.XAI_API_KEY,
+            };
+            const configExists = fs.existsSync(opts.configPath);
+            return JSON.stringify({
+                nodeVersion,
+                ollama: ollamaStatus,
+                apiKeys: keys,
+                configExists,
+                basePath: opts.basePath,
+            });
+        },
+    };
+    const listAvailableSkills = {
+        name: "list_available_skills",
+        description: "List all available skills in the skills directory with their names and descriptions.",
+        parameters: { type: "object", properties: {}, required: [] },
+        execute: async () => {
+            if (!fs.existsSync(opts.skillsDir)) {
+                return JSON.stringify({ skills: [] });
+            }
+            const entries = fs.readdirSync(opts.skillsDir, { withFileTypes: true });
+            const skills = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const manifestPath = path.join(opts.skillsDir, entry.name, "skill.json");
+                if (!fs.existsSync(manifestPath))
+                    continue;
+                try {
+                    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+                    skills.push({
+                        name: manifest.name ?? entry.name,
+                        description: manifest.description ?? "(no description)",
+                        tools: manifest.tools ?? [],
+                    });
+                }
+                catch {
+                    // Skip malformed manifests
+                }
+            }
+            return JSON.stringify({ skills });
+        },
+    };
+    const listBuiltinTools = {
+        name: "list_builtin_tools",
+        description: "List all built-in tools available to agents with their names and descriptions.",
+        parameters: { type: "object", properties: {}, required: [] },
+        execute: async () => {
+            return JSON.stringify({
+                tools: [
+                    { name: "read_file", description: "Read the contents of a file from the filesystem" },
+                    { name: "write_file", description: "Write content to a file on the filesystem" },
+                    { name: "run_command", description: "Execute a shell command and return stdout/stderr" },
+                    { name: "web_search", description: "Search the web using Brave Search or Grok" },
+                    { name: "store_memory", description: "Store a memory with content and metadata" },
+                    { name: "search_memory", description: "Semantic search across stored memories" },
+                    { name: "get_memory", description: "Retrieve a specific memory by ID" },
+                    { name: "update_memory", description: "Update an existing memory's content or metadata" },
+                    { name: "forget_memory", description: "Delete a memory by ID" },
+                    { name: "list_memories", description: "List all stored memories with optional filtering" },
+                ],
+            });
+        },
+    };
+    const readFile = {
+        name: "read_file",
+        description: "Read a file from the user's project. Use this to understand their codebase when creating custom tools.",
+        parameters: {
+            type: "object",
+            properties: {
+                path: {
+                    type: "string",
+                    description: "Path to the file (relative to project root or absolute)",
+                },
+            },
+            required: ["path"],
+        },
+        execute: async (args) => {
+            const filePath = args.path;
+            const resolved = path.isAbsolute(filePath) ? filePath : path.join(opts.basePath, filePath);
+            // Basic safety: don't read outside basePath
+            const realBase = fs.realpathSync(opts.basePath);
+            try {
+                const realPath = fs.realpathSync(resolved);
+                if (!realPath.startsWith(realBase)) {
+                    return `Error: path is outside the project directory`;
+                }
+            }
+            catch {
+                return `Error: file not found: ${filePath}`;
+            }
+            try {
+                const content = fs.readFileSync(resolved, "utf-8");
+                if (content.length > 10_000) {
+                    return content.slice(0, 10_000) + "\n\n... (truncated, file is " + content.length + " chars)";
+                }
+                return content;
+            }
+            catch (err) {
+                return `Error: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    };
+    const createSkill = {
+        name: "create_skill",
+        description: "Create a new skill with its manifest, prompt, and tool implementations. The skill will be written to the skills/ directory.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Skill name (kebab-case, e.g. 'db-monitor')" },
+                description: { type: "string", description: "Short description of what this skill does" },
+                prompt: { type: "string", description: "Full SKILL.md content — instructions for the agent using this skill" },
+                tools: {
+                    type: "array",
+                    description: "Array of tool definitions to create",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string", description: "Tool name (snake_case)" },
+                            description: { type: "string", description: "What this tool does" },
+                            parameters: { type: "object", description: "JSON Schema for tool parameters" },
+                            code: { type: "string", description: "TypeScript implementation of the execute function body. Receives `args: Record<string, unknown>` and must return a string." },
+                        },
+                        required: ["name", "description", "parameters", "code"],
+                    },
+                },
+            },
+            required: ["name", "description", "prompt", "tools"],
+        },
+        execute: async (args) => {
+            const skillName = args.name;
+            const description = args.description;
+            const prompt = args.prompt;
+            const tools = args.tools;
+            const skillDir = path.join(opts.skillsDir, skillName);
+            const toolsDir = path.join(skillDir, "tools");
+            fs.mkdirSync(toolsDir, { recursive: true });
+            // Write skill.json
+            const manifest = {
+                name: skillName,
+                description,
+                tools: tools.map((t) => t.name),
+                prompt: "SKILL.md",
+            };
+            fs.writeFileSync(path.join(skillDir, "skill.json"), JSON.stringify(manifest, null, 2) + "\n");
+            // Write SKILL.md
+            fs.writeFileSync(path.join(skillDir, "SKILL.md"), prompt + "\n");
+            // Write tool files
+            for (const tool of tools) {
+                const toolContent = `import type { Tool } from "../../../src/tools/types.js";
+
+const tool: Tool = {
+  name: "${tool.name}",
+  description: "${tool.description.replace(/"/g, '\\"')}",
+  parameters: ${JSON.stringify(tool.parameters, null, 2).split("\n").join("\n  ")},
+  execute: async (args) => {
+${tool.code.split("\n").map((line) => "    " + line).join("\n")}
+  },
+};
+
+export default tool;
+`;
+                fs.writeFileSync(path.join(toolsDir, `${tool.name}.ts`), toolContent);
+            }
+            created.skills.push(skillName);
+            return JSON.stringify({
+                success: true,
+                skill: skillName,
+                files: [
+                    `skills/${skillName}/skill.json`,
+                    `skills/${skillName}/SKILL.md`,
+                    ...tools.map((t) => `skills/${skillName}/tools/${t.name}.ts`),
+                ],
+            });
+        },
+    };
+    const saveAgent = {
+        name: "save_agent",
+        description: "Save a new agent to the config. Creates the agent entry in agent-kit.json, the data directory, and writes the SOUL.md file.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Agent identifier (kebab-case)" },
+                displayName: { type: "string", description: "Human-readable name" },
+                emoji: { type: "string", description: "Single emoji for the agent" },
+                model: { type: "string", description: "Model alias (e.g. 'sonnet', 'haiku')" },
+                tools: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of builtin tool names",
+                },
+                skills: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of skill names to attach",
+                },
+                soul: { type: "string", description: "Full SOUL.md content for this agent" },
+                sandbox: {
+                    type: "object",
+                    description: "Optional sandbox config",
+                    properties: {
+                        allowedCommands: { type: "array", items: { type: "string" } },
+                        allowedPaths: { type: "array", items: { type: "string" } },
+                    },
+                },
+                slack: {
+                    type: "object",
+                    description: "Optional Slack binding",
+                    properties: {
+                        channelId: { type: "string" },
+                        channelName: { type: "string" },
+                    },
+                },
+                heartbeat: {
+                    type: "object",
+                    description: "Optional heartbeat config",
+                    properties: {
+                        enabled: { type: "boolean" },
+                        intervalMinutes: { type: "number" },
+                        model: { type: "string" },
+                    },
+                },
+                webSearch: {
+                    type: "object",
+                    description: "Optional web search config",
+                    properties: {
+                        provider: { type: "string" },
+                    },
+                },
+            },
+            required: ["name", "displayName", "emoji", "tools", "soul"],
+        },
+        execute: async (args) => {
+            const name = args.name;
+            const soul = args.soul;
+            // Build the agent definition (only include non-empty optional fields)
+            const agentDef = {
+                displayName: args.displayName,
+                emoji: args.emoji,
+                tools: args.tools,
+            };
+            if (args.model)
+                agentDef.model = args.model;
+            if (args.skills && args.skills.length > 0)
+                agentDef.skills = args.skills;
+            if (args.sandbox)
+                agentDef.sandbox = args.sandbox;
+            if (args.slack)
+                agentDef.slack = args.slack;
+            if (args.heartbeat)
+                agentDef.heartbeat = args.heartbeat;
+            if (args.webSearch)
+                agentDef.webSearch = args.webSearch;
+            try {
+                upsertAgent(opts.configPath, name, agentDef);
+            }
+            catch (err) {
+                return `Error saving agent: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            // Create data dirs and write SOUL.md
+            ensureAgentDirs(opts.dataDir, name);
+            const soulPath = path.join(opts.dataDir, "agents", name, "SOUL.md");
+            fs.writeFileSync(soulPath, soul + "\n");
+            created.agents.push(name);
+            return JSON.stringify({
+                success: true,
+                agent: name,
+                files: [
+                    `agent-kit.json (updated)`,
+                    `data/agents/${name}/SOUL.md`,
+                ],
+            });
+        },
+    };
+    const addCronJobTool = {
+        name: "add_cron_job",
+        description: "Add a cron job to the config for scheduling automated agent tasks.",
+        parameters: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Unique job identifier (kebab-case)" },
+                agent: { type: "string", description: "Agent name to run" },
+                schedule: { type: "string", description: "Cron expression (e.g. '0 8 * * *' for daily at 8am)" },
+                prompt: { type: "string", description: "The prompt to send to the agent" },
+                enabled: { type: "boolean", description: "Whether the job is enabled (default: true)" },
+                slack: {
+                    type: "object",
+                    description: "Optional Slack channel override for posting results",
+                    properties: {
+                        channelId: { type: "string" },
+                        channelName: { type: "string" },
+                    },
+                },
+            },
+            required: ["id", "agent", "schedule", "prompt", "enabled"],
+        },
+        execute: async (args) => {
+            const job = {
+                id: args.id,
+                agent: args.agent,
+                schedule: args.schedule,
+                prompt: args.prompt,
+                enabled: args.enabled ?? true,
+            };
+            if (args.slack)
+                job.slack = args.slack;
+            try {
+                addCronJob(opts.configPath, job);
+            }
+            catch (err) {
+                return `Error adding cron job: ${err instanceof Error ? err.message : String(err)}`;
+            }
+            created.crons.push(args.id);
+            return JSON.stringify({ success: true, job });
+        },
+    };
+    const finishSetup = {
+        name: "finish_setup",
+        description: "Call this when the user is done creating agents. Signals that setup is complete.",
+        parameters: { type: "object", properties: {}, required: [] },
+        execute: async () => {
+            const summary = [
+                created.agents.length > 0 ? `Agents created: ${created.agents.join(", ")}` : null,
+                created.skills.length > 0 ? `Skills created: ${created.skills.join(", ")}` : null,
+                created.crons.length > 0 ? `Cron jobs added: ${created.crons.join(", ")}` : null,
+            ].filter(Boolean).join("\n");
+            opts.onFinish(summary || "No changes made.");
+            return summary || "Setup complete — no changes were made.";
+        },
+    };
+    return [
+        checkEnvironment,
+        listAvailableSkills,
+        listBuiltinTools,
+        readFile,
+        createSkill,
+        saveAgent,
+        addCronJobTool,
+        finishSetup,
+    ];
+}

package/dist/cli/start.d.ts

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