@alejandroroman/agent-kit 0.1.0

package/dist/bootstrap.d.ts

@@ -0,0 +1,51 @@
+import { AgentRegistry } from "./multi/registry.js";
+import { type UsageStore } from "./usage/index.js";
+import type { Config } from "./config/schema.js";
+import type { ToolRegistry } from "./tools/registry.js";
+import type { Message } from "./llm/types.js";
+import type { AgentResult } from "./agent/types.js";
+import type { ResolvedAgent } from "./config/resolve.js";
+import type { SessionManager } from "./session/manager.js";
+export interface AgentRuntime {
+    resolved: ResolvedAgent;
+    toolRegistry: ToolRegistry;
+    agentRegistry: AgentRegistry;
+    promptFragments: string[];
+    skillsIndex: string;
+    soul: string | undefined;
+    session: SessionManager;
+}
+export interface AgentExecutorFn {
+    (agentName: string, messages: Message[]): Promise<AgentResult>;
+}
+/**
+ * Build a fully-initialized agent runtime: tool registry, skills, spawn wrappers, session.
+ */
+export declare function buildAgentRuntime(agentName: string, config: Config, opts: {
+    dataDir: string;
+    skillsDir: string;
+    sessionId?: string;
+    usageStore?: UsageStore;
+}): AgentRuntime;
+/**
+ * Assemble a system prompt from soul, date context, skills index, and prompt fragments.
+ */
+export declare function buildSystemPrompt(soul: string | undefined, skillsIndex: string, promptFragments: string[]): string | undefined;
+/**
+ * Initialize usage store if configured. Returns store + API port.
+ */
+export declare function initUsageStore(config: Config): {
+    usageStore?: UsageStore;
+    apiPort: number;
+};
+/**
+ * Create an agent executor function (for Slack gateway, etc.).
+ * Each invocation gets its own isolated tool registry.
+ */
+export declare function createAgentExecutor(config: Config, opts: {
+    dataDir: string;
+    skillsDir: string;
+    agentRegistry: AgentRegistry;
+    usageStore?: UsageStore;
+    source: string;
+}): AgentExecutorFn;

package/dist/bootstrap.js

@@ -0,0 +1,110 @@
+import * as path from "path";
+import * as fs from "fs";
+import { resolveAgent, resolveWebSearch } from "./config/resolve.js";
+import { createBuiltinRegistry } from "./tools/builtin/index.js";
+import { createActivateSkillTool } from "./skills/index.js";
+import { AgentRegistry } from "./multi/registry.js";
+import { registerSpawnWrappers } from "./tools/builtin/spawn.js";
+import { setupAgentSession } from "./agent/setup.js";
+import { runAgentLoop } from "./agent/loop.js";
+import { dateContext } from "./text.js";
+import { createLogger } from "./logger.js";
+import { createUsageStore } from "./usage/index.js";
+const log = createLogger("bootstrap");
+/**
+ * Build a fully-initialized agent runtime: tool registry, skills, spawn wrappers, session.
+ */
+export function buildAgentRuntime(agentName, config, opts) {
+    const agentDef = config.agents[agentName];
+    if (!agentDef)
+        throw new Error(`Agent "${agentName}" not found in config`);
+    const sandbox = agentDef.sandbox ?? config.defaults.sandbox;
+    const toolRegistry = createBuiltinRegistry({
+        allowedCommands: sandbox?.allowedCommands,
+        allowedPaths: sandbox?.allowedPaths,
+        memoryConfig: config.defaults.memory,
+        webSearch: resolveWebSearch(agentName, config),
+    });
+    const agentRegistry = new AgentRegistry(config, opts.dataDir);
+    const resolved = resolveAgent(agentName, config, toolRegistry, opts.skillsDir);
+    // Skills setup
+    const promptFragments = [];
+    let skillsIndex = "";
+    if (resolved.skills.length > 0) {
+        const ctx = {
+            manifests: resolved.skills,
+            skillsDir: opts.skillsDir,
+            toolRegistry,
+            promptFragments,
+            activatedSkills: new Set(),
+        };
+        toolRegistry.register(createActivateSkillTool(ctx));
+        skillsIndex = "\n\nYou have the following skills available:\n\n"
+            + resolved.skills.map((s) => `- **${s.name}**: ${s.description}`).join("\n")
+            + "\n\nTo use a skill, call the `activate_skill` tool with the skill name.";
+    }
+    // Spawn wrapper registration
+    if (resolved.canSpawn.length > 0) {
+        registerSpawnWrappers(resolved.canSpawn, config, agentRegistry, toolRegistry, opts.usageStore);
+        log.info({ targets: resolved.canSpawn.map((t) => `${t.tool} -> ${t.agent}`) }, "spawn wrappers registered");
+    }
+    const sid = opts.sessionId ?? `session-${Date.now()}`;
+    const { soul, session } = setupAgentSession(opts.dataDir, agentName, sid);
+    return { resolved, toolRegistry, agentRegistry, promptFragments, skillsIndex, soul, session };
+}
+/**
+ * Assemble a system prompt from soul, date context, skills index, and prompt fragments.
+ */
+export function buildSystemPrompt(soul, skillsIndex, promptFragments) {
+    return [soul, dateContext(), skillsIndex, ...promptFragments]
+        .filter(Boolean)
+        .join("\n\n") || undefined;
+}
+/**
+ * Initialize usage store if configured. Returns store + API port.
+ */
+export function initUsageStore(config) {
+    let usageStore;
+    let apiPort = 7878;
+    if (config.defaults.usage) {
+        try {
+            const usageDbPath = config.defaults.usage.dbPath.replace(/^~/, process.env.HOME ?? "~");
+            const usageDir = path.dirname(usageDbPath);
+            if (!fs.existsSync(usageDir))
+                fs.mkdirSync(usageDir, { recursive: true });
+            usageStore = createUsageStore(usageDbPath);
+            apiPort = config.defaults.usage.apiPort;
+        }
+        catch (err) {
+            log.warn({ err }, "failed to initialize usage tracking — continuing without it");
+        }
+    }
+    return { usageStore, apiPort };
+}
+/**
+ * Create an agent executor function (for Slack gateway, etc.).
+ * Each invocation gets its own isolated tool registry.
+ */
+export function createAgentExecutor(config, opts) {
+    return async (agentName, messages) => {
+        const runtime = buildAgentRuntime(agentName, config, {
+            dataDir: opts.dataDir,
+            skillsDir: opts.skillsDir,
+            sessionId: `${opts.source}-${Date.now()}`,
+            usageStore: opts.usageStore,
+        });
+        const systemPrompt = buildSystemPrompt(runtime.soul, runtime.skillsIndex, runtime.promptFragments);
+        return runAgentLoop(messages, {
+            model: runtime.resolved.model,
+            fallbacks: runtime.resolved.fallbacks,
+            systemPrompt,
+            toolRegistry: runtime.toolRegistry,
+            maxIterations: runtime.resolved.maxIterations,
+            compactionThreshold: runtime.resolved.compactionThreshold,
+            maxToolResultSize: runtime.resolved.maxToolResultSize,
+            agentName,
+            usageStore: opts.usageStore,
+            source: opts.source,
+        });
+    };
+}

package/dist/cli/chat.d.ts

@@ -0,0 +1 @@
+export declare function chat(agentName?: string): Promise<void>;

package/dist/cli/chat.js

@@ -0,0 +1,102 @@
+import * as readline from "readline";
+import * as path from "path";
+import { loadConfig } from "../config/index.js";
+import { buildAgentRuntime, buildSystemPrompt } from "../bootstrap.js";
+import { runAgentLoop } from "../agent/loop.js";
+import { compactMessages } from "../session/compaction.js";
+import { ensureOllama } from "./ollama.js";
+import { resolveApiKey } from "./ui.js";
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const DATA_DIR = path.join(process.cwd(), "data");
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+export async function chat(agentName) {
+    if (!agentName) {
+        console.error("Usage: agent-kit chat <agent>");
+        process.exit(1);
+    }
+    await resolveApiKey({ save: false });
+    const config = loadConfig(CONFIG_PATH);
+    if (!config.agents[agentName]) {
+        const names = Object.keys(config.agents).join(", ");
+        console.error(`Agent "${agentName}" not found. Available: ${names}`);
+        process.exit(1);
+    }
+    // Warn if Ollama isn't running (memory tools won't work)
+    if (config.defaults.memory) {
+        const ollama = await ensureOllama();
+        if (!ollama.running) {
+            console.log("  (Ollama not running — memory tools unavailable)\n");
+        }
+    }
+    const runtime = buildAgentRuntime(agentName, config, {
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+    });
+    const { resolved, toolRegistry, promptFragments, skillsIndex, soul, session } = runtime;
+    const agentDef = config.agents[agentName];
+    const emoji = agentDef.emoji ?? "";
+    const display = agentDef.displayName ?? agentName;
+    console.log();
+    console.log(`  ${emoji}  ${display}`);
+    console.log(`  Model: ${resolved.model}`);
+    console.log(`  Tools: ${resolved.tools.map((t) => t.name).join(", ") || "(none)"}`);
+    if (resolved.skills.length > 0) {
+        console.log(`  Skills: ${resolved.skills.map((s) => s.name).join(", ")}`);
+    }
+    console.log(`  Commands: /new (reset), /quit`);
+    console.log();
+    let messages = session.getMessages();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const ask = () => {
+        rl.question("You: ", async (input) => {
+            const trimmed = input.trim();
+            if (trimmed === "/quit") {
+                rl.close();
+                return;
+            }
+            if (trimmed === "/new") {
+                messages = [];
+                console.log("  Session reset.\n");
+                ask();
+                return;
+            }
+            if (!trimmed) {
+                ask();
+                return;
+            }
+            const userMsg = { role: "user", content: trimmed };
+            messages.push(userMsg);
+            session.append(userMsg);
+            messages = await compactMessages(messages, resolved.model, resolved.compactionThreshold);
+            try {
+                const systemPrompt = buildSystemPrompt(soul, skillsIndex, promptFragments);
+                const result = await runAgentLoop(messages, {
+                    model: resolved.model,
+                    fallbacks: resolved.fallbacks,
+                    systemPrompt,
+                    toolRegistry,
+                    maxIterations: resolved.maxIterations,
+                    compactionThreshold: resolved.compactionThreshold,
+                    maxToolResultSize: resolved.maxToolResultSize,
+                    agentName,
+                    source: "cli",
+                });
+                const newMessages = result.messages.slice(messages.length - 1);
+                for (const msg of newMessages) {
+                    session.append(msg);
+                }
+                messages = result.messages;
+                console.log(`\nAgent: ${result.text}`);
+                console.log(`  (${result.usage.inputTokens + result.usage.outputTokens} tokens)\n`);
+            }
+            catch (err) {
+                console.error(`\n  Error: ${err instanceof Error ? err.message : err}\n`);
+            }
+            ask();
+        });
+    };
+    ask();
+}

package/dist/cli/config-writer.d.ts

@@ -0,0 +1,40 @@
+import { type Config } from "../config/schema.js";
+/**
+ * Read raw JSON from config file (no Zod defaults expansion).
+ * Returns parsed object or null if file doesn't exist.
+ */
+export declare function readRawConfig(configPath: string): Record<string, unknown> | null;
+/**
+ * Atomically write config JSON. Validates with ConfigSchema before writing.
+ * Writes to .tmp file, then renames for atomicity.
+ */
+export declare function writeConfig(configPath: string, raw: Record<string, unknown>): Config;
+/**
+ * Create a fresh minimal config for `agent-kit init`.
+ */
+export declare function createFreshConfig(opts: {
+    configPath: string;
+    models?: Array<{
+        model: string;
+        alias: string;
+    }>;
+    defaultModel?: string;
+}): Config;
+/**
+ * Add or update an agent in the config file.
+ * Mutates the raw JSON (no Zod default expansion).
+ */
+export declare function upsertAgent(configPath: string, agentName: string, agentDef: Record<string, unknown>): Config;
+/**
+ * Add a cron job to the config file.
+ */
+export declare function addCronJob(configPath: string, job: Record<string, unknown>): Config;
+/**
+ * Ensure data directories exist for an agent.
+ */
+export declare function ensureAgentDirs(dataDir: string, agentName: string): void;
+/**
+ * Scaffold a package.json for a new agent-kit project.
+ * Makes the project self-contained and runnable via `npx agent-kit start`.
+ */
+export declare function scaffoldProjectPackageJson(projectDir: string, projectName?: string): void;

package/dist/cli/config-writer.js

@@ -0,0 +1,108 @@
+import * as fs from "fs";
+import * as path from "path";
+import { ConfigSchema } from "../config/schema.js";
+/**
+ * Read raw JSON from config file (no Zod defaults expansion).
+ * Returns parsed object or null if file doesn't exist.
+ */
+export function readRawConfig(configPath) {
+    if (!fs.existsSync(configPath))
+        return null;
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+}
+/**
+ * Atomically write config JSON. Validates with ConfigSchema before writing.
+ * Writes to .tmp file, then renames for atomicity.
+ */
+export function writeConfig(configPath, raw) {
+    const validated = ConfigSchema.parse(raw);
+    const tmpPath = configPath + ".tmp";
+    fs.writeFileSync(tmpPath, JSON.stringify(raw, null, 2) + "\n", "utf-8");
+    fs.renameSync(tmpPath, configPath);
+    return validated;
+}
+/**
+ * Create a fresh minimal config for `agent-kit init`.
+ */
+export function createFreshConfig(opts) {
+    const raw = {
+        models: opts.models ?? [
+            { model: "anthropic:claude-sonnet-4-6", alias: "sonnet" },
+        ],
+        defaults: {
+            model: opts.defaultModel ?? "sonnet",
+            maxTokens: 4096,
+            maxIterations: 20,
+            compactionThreshold: 100_000,
+            commandTimeout: 30,
+        },
+        agents: {},
+        cron: [],
+    };
+    return writeConfig(opts.configPath, raw);
+}
+/**
+ * Add or update an agent in the config file.
+ * Mutates the raw JSON (no Zod default expansion).
+ */
+export function upsertAgent(configPath, agentName, agentDef) {
+    const raw = readRawConfig(configPath);
+    if (!raw)
+        throw new Error("Config file not found");
+    if (!raw.agents || typeof raw.agents !== "object") {
+        raw.agents = {};
+    }
+    raw.agents[agentName] = agentDef;
+    return writeConfig(configPath, raw);
+}
+/**
+ * Add a cron job to the config file.
+ */
+export function addCronJob(configPath, job) {
+    const raw = readRawConfig(configPath);
+    if (!raw)
+        throw new Error("Config file not found");
+    if (!Array.isArray(raw.cron)) {
+        raw.cron = [];
+    }
+    raw.cron.push(job);
+    return writeConfig(configPath, raw);
+}
+/**
+ * Ensure data directories exist for an agent.
+ */
+export function ensureAgentDirs(dataDir, agentName) {
+    const agentDir = path.join(dataDir, "agents", agentName);
+    const sessionsDir = path.join(agentDir, "sessions");
+    fs.mkdirSync(sessionsDir, { recursive: true });
+}
+/**
+ * Scaffold a package.json for a new agent-kit project.
+ * Makes the project self-contained and runnable via `npx agent-kit start`.
+ */
+export function scaffoldProjectPackageJson(projectDir, projectName) {
+    const pkgPath = path.join(projectDir, "package.json");
+    if (fs.existsSync(pkgPath))
+        return; // don't overwrite existing
+    const name = projectName ?? path.basename(projectDir);
+    const pkg = {
+        name,
+        version: "0.1.0",
+        private: true,
+        type: "module",
+        scripts: {
+            start: "agent-kit start",
+            chat: "agent-kit chat",
+            create: "agent-kit create",
+        },
+        dependencies: {
+            "@alejandroroman/agent-kit": "^0.1.0",
+        },
+    };
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    // Create .gitignore if missing
+    const gitignorePath = path.join(projectDir, ".gitignore");
+    if (!fs.existsSync(gitignorePath)) {
+        fs.writeFileSync(gitignorePath, "node_modules/\n.env\n*.db\n*.db-shm\n*.db-wal\n", "utf-8");
+    }
+}

package/dist/cli/create.d.ts

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

package/dist/cli/create.js

@@ -0,0 +1,37 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as p from "@clack/prompts";
+import { banner, done, resolveApiKey } from "./ui.js";
+import { loadConfig } from "../config/index.js";
+import { runSetupAgent } from "./setup-agent/index.js";
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const DATA_DIR = path.join(process.cwd(), "data");
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+export async function create() {
+    banner();
+    // Require existing config
+    if (!fs.existsSync(CONFIG_PATH)) {
+        p.log.error("No agent-kit.json found. Run `agent-kit init` first.");
+        process.exit(1);
+    }
+    // Load config to verify it's valid
+    try {
+        loadConfig(CONFIG_PATH);
+    }
+    catch (err) {
+        p.log.error(`Invalid config: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    const apiKey = await resolveApiKey({ save: true });
+    p.log.info("Starting setup wizard... (type /quit to exit)\n");
+    const summary = await runSetupAgent({
+        apiKey,
+        configPath: CONFIG_PATH,
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        basePath: process.cwd(),
+        mode: "create",
+    });
+    console.log();
+    done(summary);
+}

package/dist/cli/init.d.ts

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

package/dist/cli/init.js

@@ -0,0 +1,85 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import * as p from "@clack/prompts";
+import { banner, isCancel, done, resolveApiKey } from "./ui.js";
+import { checkOllama } from "./ollama.js";
+import { createFreshConfig, scaffoldProjectPackageJson } from "./config-writer.js";
+import { runSetupAgent } from "./setup-agent/index.js";
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+const DATA_DIR = path.join(process.cwd(), "data");
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+function detectPackageManager() {
+    try {
+        execSync("pnpm --version", { stdio: "ignore" });
+        return "pnpm";
+    }
+    catch {
+        return "npm";
+    }
+}
+export async function init() {
+    banner();
+    // Check if config already exists
+    if (fs.existsSync(CONFIG_PATH)) {
+        p.log.error("agent-kit.json already exists. Use `agent-kit create` to add agents.");
+        process.exit(1);
+    }
+    // Detect or ask for API key (with save-to-.env offer)
+    const apiKey = await resolveApiKey({ save: true });
+    // Check Ollama status
+    const s = p.spinner();
+    s.start("Checking Ollama...");
+    const ollama = await checkOllama();
+    s.stop(ollama.running
+        ? "Ollama is running"
+        : ollama.installed
+            ? "Ollama installed but not running (memory tools will be unavailable until started)"
+            : "Ollama not found (memory tools require it — install from ollama.com)");
+    // Scaffold project
+    s.start("Setting up project...");
+    try {
+        scaffoldProjectPackageJson(process.cwd());
+        createFreshConfig({ configPath: CONFIG_PATH });
+        fs.mkdirSync(DATA_DIR, { recursive: true });
+        fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+    catch (err) {
+        s.stop(`Failed to create project: ${err instanceof Error ? err.message : err}`);
+        process.exit(1);
+    }
+    s.stop("Project created");
+    // Install dependencies
+    const pm = detectPackageManager();
+    s.start(`Installing dependencies (${pm} install)...`);
+    try {
+        execSync(`${pm} install`, { cwd: process.cwd(), stdio: "ignore" });
+    }
+    catch (err) {
+        s.stop(`Failed to install dependencies: ${err instanceof Error ? err.message : err}`);
+        p.log.warn("You can install manually later with: npm install");
+    }
+    s.stop("Dependencies installed");
+    // Ask if they want to create agents now
+    const createNow = await p.confirm({
+        message: "Create your first agent now? (AI-powered setup)",
+    });
+    if (isCancel(createNow))
+        return;
+    if (!createNow) {
+        done("Setup complete. Run `agent-kit create` to add agents later.");
+        return;
+    }
+    // Boot the setup agent
+    p.log.info("Starting setup wizard... (type /quit to exit)\n");
+    const summary = await runSetupAgent({
+        apiKey,
+        configPath: CONFIG_PATH,
+        dataDir: DATA_DIR,
+        skillsDir: SKILLS_DIR,
+        basePath: process.cwd(),
+        mode: "init",
+    });
+    console.log();
+    done(summary);
+}

package/dist/cli/list.d.ts

@@ -0,0 +1 @@
+export declare function list(): void;

package/dist/cli/list.js

@@ -0,0 +1,36 @@
+import * as path from "path";
+import { loadConfig } from "../config/index.js";
+const CONFIG_PATH = path.join(process.cwd(), "agent-kit.json");
+export function list() {
+    const config = loadConfig(CONFIG_PATH);
+    const agents = Object.entries(config.agents);
+    if (agents.length === 0) {
+        console.log("No agents configured. Run `agent-kit init` to get started.");
+        return;
+    }
+    console.log();
+    console.log("  Agents:");
+    console.log();
+    for (const [name, def] of agents) {
+        const emoji = def.emoji ?? " ";
+        const display = def.displayName ?? name;
+        const model = def.model ?? config.defaults.model;
+        const tags = [];
+        if (def.spawn_only)
+            tags.push("spawn-only");
+        if (def.slack)
+            tags.push(`slack:${def.slack.channelName}`);
+        if (def.heartbeat?.enabled)
+            tags.push("heartbeat");
+        if (def.skills.length > 0)
+            tags.push(`${def.skills.length} skill(s)`);
+        const cronJobs = config.cron.filter((j) => j.agent === name && j.enabled);
+        if (cronJobs.length > 0)
+            tags.push(`${cronJobs.length} cron`);
+        const tagStr = tags.length > 0 ? `  [${tags.join(", ")}]` : "";
+        console.log(`  ${emoji}  ${display} (${name})  model:${model}  tools:${def.tools.length}${tagStr}`);
+    }
+    console.log();
+    console.log(`  ${agents.length} agent(s), ${config.cron.length} cron job(s)`);
+    console.log();
+}

package/dist/cli/ollama.d.ts

@@ -0,0 +1,6 @@
+export interface OllamaStatus {
+    running: boolean;
+    installed: boolean;
+}
+export declare function checkOllama(): Promise<OllamaStatus>;
+export declare function ensureOllama(): Promise<OllamaStatus>;

package/dist/cli/ollama.js

@@ -0,0 +1,44 @@
+import { execSync, spawn } from "child_process";
+const OLLAMA_URL = "http://localhost:11434";
+export async function checkOllama() {
+    // Check if running
+    try {
+        const res = await fetch(`${OLLAMA_URL}/api/version`, { signal: AbortSignal.timeout(2000) });
+        if (res.ok)
+            return { running: true, installed: true };
+    }
+    catch {
+        // Not running — check if installed
+    }
+    try {
+        execSync("which ollama", { stdio: "ignore" });
+        return { running: false, installed: true };
+    }
+    catch {
+        return { running: false, installed: false };
+    }
+}
+export async function ensureOllama() {
+    const status = await checkOllama();
+    if (status.running)
+        return status;
+    if (status.installed) {
+        // Try to start it
+        const child = spawn("ollama", ["serve"], {
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        // Give it a moment to start
+        await new Promise((r) => setTimeout(r, 1500));
+        try {
+            const res = await fetch(`${OLLAMA_URL}/api/version`, { signal: AbortSignal.timeout(2000) });
+            if (res.ok)
+                return { running: true, installed: true };
+        }
+        catch {
+            // Failed to start
+        }
+    }
+    return status;
+}

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

@@ -0,0 +1,9 @@
+export interface RunSetupAgentOptions {
+    apiKey: string;
+    configPath: string;
+    dataDir: string;
+    skillsDir: string;
+    basePath: string;
+    mode: "init" | "create";
+}
+export declare function runSetupAgent(opts: RunSetupAgentOptions): Promise<string>;