@agentskit/cli 0.4.0 → 0.5.0

package/dist/bin.cjs

@@ -1,61 +1,109 @@
 #!/usr/bin/env node
 'use strict';
 
-var React2 = require('react');
+var React3 = require('react');
 var ink = require('ink');
 var commander = require('commander');
 var path = require('path');
-var core = require('@agentskit/core');
+var promises = require('fs/promises');
 var ink$1 = require('@agentskit/ink');
 var adapters = require('@agentskit/adapters');
+var tools = require('@agentskit/tools');
+var skills = require('@agentskit/skills');
+var memory = require('@agentskit/memory');
 var jsxRuntime = require('react/jsx-runtime');
-var promises = require('fs/promises');
+var prompts = require('@inquirer/prompts');
+var kleur = require('kleur');
+var fs = require('fs');
+var runtime = require('@agentskit/runtime');
+var child_process = require('child_process');
+var chokidar = require('chokidar');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React2__default = /*#__PURE__*/_interopDefault(React2);
+var React3__default = /*#__PURE__*/_interopDefault(React3);
 var path__default = /*#__PURE__*/_interopDefault(path);
+var kleur__default = /*#__PURE__*/_interopDefault(kleur);
+var chokidar__default = /*#__PURE__*/_interopDefault(chokidar);
 
+async function loadJsonConfig(path4) {
+  try {
+    const raw = await promises.readFile(path4, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function loadTsConfig(path4) {
+  try {
+    const mod = await import(path4);
+    return mod.default ?? mod;
+  } catch {
+    return void 0;
+  }
+}
+async function loadPackageJsonConfig(dir) {
+  try {
+    const raw = await promises.readFile(path.join(dir, "package.json"), "utf8");
+    const pkg = JSON.parse(raw);
+    if (pkg.agentskit && typeof pkg.agentskit === "object") {
+      return pkg.agentskit;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function loadConfig(options) {
+  const cwd = path.resolve(process.cwd());
+  const tsPath = path.join(cwd, ".agentskit.config.ts");
+  const tsConfig = await loadTsConfig(tsPath);
+  if (tsConfig) return tsConfig;
+  const jsonPath = path.join(cwd, ".agentskit.config.json");
+  const jsonConfig = await loadJsonConfig(jsonPath);
+  if (jsonConfig) return jsonConfig;
+  return await loadPackageJsonConfig(cwd);
+}
 var providers = {
   openai: {
     label: "OpenAI",
-    envKey: "OPENAI_API_KEY",
+    envKeys: ["OPENAI_API_KEY"],
     defaultModel: "gpt-4o-mini",
     factory: (c) => adapters.openai(c)
   },
   anthropic: {
     label: "Anthropic",
-    envKey: "ANTHROPIC_API_KEY",
+    envKeys: ["ANTHROPIC_API_KEY"],
     defaultModel: "claude-3-5-sonnet-latest",
     factory: (c) => adapters.anthropic(c)
   },
   gemini: {
     label: "Gemini",
-    envKey: "GEMINI_API_KEY",
+    envKeys: ["GEMINI_API_KEY"],
     defaultModel: "gemini-2.5-flash",
     factory: (c) => adapters.gemini(c)
   },
   ollama: {
     label: "Ollama",
-    envKey: "",
+    envKeys: [],
     defaultModel: "llama3.1",
     factory: (c) => adapters.ollama({ model: c.model, baseUrl: c.baseUrl })
   },
   deepseek: {
     label: "DeepSeek",
-    envKey: "DEEPSEEK_API_KEY",
+    envKeys: ["DEEPSEEK_API_KEY"],
     defaultModel: "deepseek-chat",
     factory: (c) => adapters.deepseek(c)
   },
   grok: {
     label: "xAI Grok",
-    envKey: "XAI_API_KEY",
+    envKeys: ["XAI_API_KEY"],
     requiresModel: true,
     factory: (c) => adapters.grok(c)
   },
   kimi: {
     label: "Kimi",
-    envKey: "KIMI_API_KEY",
+    envKeys: ["KIMI_API_KEY", "MOONSHOT_API_KEY"],
     requiresModel: true,
     factory: (c) => adapters.kimi(c)
   }
@@ -75,7 +123,7 @@ function createDemoAdapter(provider, model) {
           ].join(" ");
           for (const chunk of reply.match(/.{1,18}/g) ?? []) {
             if (cancelled) return;
-            await new Promise((resolve) => setTimeout(resolve, 35));
+            await new Promise((resolve2) => setTimeout(resolve2, 35));
             yield { type: "text", content: chunk };
           }
           yield { type: "done" };
@@ -103,12 +151,16 @@ function resolveChatProvider(options) {
     const supported = ["demo", ...Object.keys(providers)].join(", ");
     throw new Error(`Unsupported provider "${options.provider}". Try ${supported}.`);
   }
-  let apiKey = options.apiKey ?? (entry.envKey ? process.env[entry.envKey] : void 0);
-  if (name === "kimi" && !apiKey) {
-    apiKey = process.env.MOONSHOT_API_KEY;
+  let apiKey = options.apiKey;
+  if (!apiKey) {
+    for (const key of entry.envKeys) {
+      apiKey = process.env[key];
+      if (apiKey) break;
+    }
   }
-  if (!apiKey && entry.envKey) {
-    throw new Error(`${entry.label} requires an API key. Pass --api-key or set ${entry.envKey}.`);
+  if (!apiKey && entry.envKeys.length > 0) {
+    const keyList = entry.envKeys.join(" or ");
+    throw new Error(`${entry.label} requires an API key. Pass --api-key or set ${keyList}.`);
   }
   const model = options.model ?? entry.defaultModel;
   if (!model) {
@@ -122,19 +174,88 @@ function resolveChatProvider(options) {
     summary: `${entry.label} live adapter`
   };
 }
+var skillRegistry = {
+  researcher: skills.researcher,
+  coder: skills.coder,
+  planner: skills.planner,
+  critic: skills.critic,
+  summarizer: skills.summarizer
+};
+function resolveTools(toolNames) {
+  if (!toolNames) return [];
+  const tools$1 = [];
+  for (const name of toolNames.split(",").map((s) => s.trim())) {
+    switch (name) {
+      case "web_search":
+        tools$1.push(tools.webSearch());
+        break;
+      case "filesystem":
+        tools$1.push(...tools.filesystem({ basePath: process.cwd() }));
+        break;
+      case "shell":
+        tools$1.push(tools.shell({ timeout: 3e4 }));
+        break;
+      default:
+        process.stderr.write(`Unknown tool: ${name}
+`);
+    }
+  }
+  return tools$1;
+}
+function resolveSkill(skillName) {
+  if (!skillName) return void 0;
+  const skill = skillRegistry[skillName.trim()];
+  if (!skill) {
+    process.stderr.write(`Unknown skill: ${skillName}
+`);
+    return void 0;
+  }
+  return skill;
+}
+function resolveSkills(skillNames) {
+  if (!skillNames) return void 0;
+  const names = skillNames.split(",").map((s) => s.trim());
+  const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
+  if (resolved.length === 0) {
+    process.stderr.write(`No valid skills found in: ${skillNames}
+`);
+    return void 0;
+  }
+  if (resolved.length === 1) return resolved[0];
+  return skills.composeSkills(...resolved);
+}
+function resolveMemory(backend, memoryPath) {
+  switch (backend) {
+    case "sqlite":
+      return memory.sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
+    case "file":
+    default:
+      return memory.fileChatMemory(memoryPath);
+  }
+}
 function ChatApp(options) {
-  const adapter = React2.useMemo(
+  const adapter = React3.useMemo(
     () => resolveChatProvider(options).adapter,
     [options.apiKey, options.baseUrl, options.model, options.provider]
   );
-  const memory = React2.useMemo(
-    () => core.createFileMemory(options.memoryPath ?? ".agentskit-history.json"),
-    [options.memoryPath]
+  const memory = React3.useMemo(
+    () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
+    [options.memoryPath, options.memoryBackend]
   );
+  const tools = React3.useMemo(() => resolveTools(options.tools), [options.tools]);
+  const skills = React3.useMemo(() => {
+    if (!options.skill) return void 0;
+    const names = options.skill.split(",").map((s) => s.trim());
+    const resolved = names.map((n) => skillRegistry[n]).filter(Boolean);
+    if (resolved.length === 0) return void 0;
+    return resolved;
+  }, [options.skill]);
   const chat = ink$1.useChat({
     adapter,
     memory,
-    systemPrompt: options.system
+    systemPrompt: options.system,
+    tools: tools.length > 0 ? tools : void 0,
+    skills
   });
   return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
     /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "cyan", children: "AgentsKit CLI" }),
@@ -149,94 +270,475 @@ function ChatApp(options) {
 }
 function renderChatHeader(options) {
   const runtime = resolveChatProvider(options);
-  return `provider=${runtime.provider}${runtime.model ? ` model=${runtime.model}` : ""} mode=${runtime.mode}`;
+  const parts = [`provider=${runtime.provider}`];
+  if (runtime.model) parts.push(`model=${runtime.model}`);
+  parts.push(`mode=${runtime.mode}`);
+  if (options.tools) parts.push(`tools=${options.tools}`);
+  if (options.skill) parts.push(`skill=${options.skill}`);
+  if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
+  return parts.join(" ");
+}
+var PROVIDER_IMPORT = {
+  openai: "openai",
+  anthropic: "anthropic",
+  gemini: "gemini",
+  ollama: "ollama"
+};
+var PROVIDER_DEFAULT_MODEL = {
+  openai: "gpt-4o-mini",
+  anthropic: "claude-sonnet-4-6",
+  gemini: "gemini-2.5-flash",
+  ollama: "llama3.1",
+  demo: "demo"
+};
+var PROVIDER_ENV_KEY = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  ollama: null,
+  demo: null
+};
+function adapterCall(provider, prefix = "process.env") {
+  const model = PROVIDER_DEFAULT_MODEL[provider];
+  if (provider === "demo") return `demoAdapter()`;
+  if (provider === "ollama") return `ollama({ model: '${model}' })`;
+  const envKey = PROVIDER_ENV_KEY[provider];
+  return `${PROVIDER_IMPORT[provider]}({ apiKey: ${prefix}.${envKey} ?? '', model: '${model}' })`;
+}
+function viteAdapterCall(provider) {
+  if (provider === "demo") return `demoAdapter()`;
+  if (provider === "ollama") return `ollama({ model: '${PROVIDER_DEFAULT_MODEL[provider]}' })`;
+  const envKey = PROVIDER_ENV_KEY[provider];
+  return `${PROVIDER_IMPORT[provider]}({ apiKey: import.meta.env.VITE_${envKey} ?? '', model: '${PROVIDER_DEFAULT_MODEL[provider]}' })`;
+}
+function adapterImport(provider) {
+  if (provider === "demo") return "";
+  return `import { ${PROVIDER_IMPORT[provider]} } from '@agentskit/adapters'
+`;
+}
+function toolImports(tools) {
+  if (tools.length === 0) return "";
+  return `import { ${tools.map((t) => t === "web_search" ? "webSearch" : t).join(", ")} } from '@agentskit/tools'
+`;
+}
+function toolList(tools) {
+  if (tools.length === 0) return "[]";
+  const calls = tools.map((t) => {
+    if (t === "web_search") return "webSearch()";
+    if (t === "filesystem") return `...filesystem({ basePath: './workspace' })`;
+    if (t === "shell") return `shell({ allowedCommands: ['ls', 'cat'] })`;
+    return "";
+  });
+  return `[${calls.join(", ")}]`;
+}
+function memoryImport(memory) {
+  if (memory === "file") return `import { fileChatMemory } from '@agentskit/memory'
+`;
+  if (memory === "sqlite") return `import { sqliteChatMemory } from '@agentskit/memory'
+`;
+  return "";
+}
+function memoryCall(memory) {
+  if (memory === "file") return `fileChatMemory('./.agentskit-history.json')`;
+  if (memory === "sqlite") return `sqliteChatMemory({ path: './.agentskit-history.db' })`;
+  return "undefined";
 }
-function reactStarter() {
+function demoAdapterSnippet() {
+  return `function demoAdapter() {
   return {
-    "package.json": JSON.stringify({
-      name: "agentskit-react-app",
-      private: true,
-      type: "module",
-      scripts: {
-        dev: "vite"
+    createSource: () => ({
+      stream: async function* () {
+        yield { type: 'text' as const, content: 'Hello from your AgentsKit starter. ' }
+        yield { type: 'text' as const, content: 'Configure a real adapter to talk to a model.' }
+        yield { type: 'done' as const }
       },
-      dependencies: {
-        "@agentskit/adapters": "^0.1.0",
-        "@agentskit/react": "^0.1.0",
-        react: "^18.3.1",
-        "react-dom": "^18.3.1"
-      }
-    }, null, 2),
+      abort: () => {},
+    }),
+  }
+}
+
+`;
+}
+function reactStarter(ctx) {
+  const deps = {
+    "@agentskit/react": "^0.4.0",
+    react: "^19.0.0",
+    "react-dom": "^19.0.0"
+  };
+  if (ctx.provider !== "demo") deps["@agentskit/adapters"] = "^0.4.0";
+  if (ctx.tools.length > 0) deps["@agentskit/tools"] = "^0.4.0";
+  if (ctx.memory !== "none") deps["@agentskit/memory"] = "^0.4.0";
+  const includesDemo = ctx.provider === "demo";
+  const adapter = ctx.provider === "demo" ? viteAdapterCall(ctx.provider) : viteAdapterCall(ctx.provider);
+  const envKey = PROVIDER_ENV_KEY[ctx.provider];
+  const envContent = envKey ? `VITE_${envKey}=
+` : "# No API key required for the local provider\n";
+  return {
+    "package.json": JSON.stringify(
+      {
+        name: path__default.default.basename(ctx.template === "react" ? "agentskit-react-app" : "agentskit-app"),
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "vite",
+          build: "vite build",
+          preview: "vite preview"
+        },
+        dependencies: deps,
+        devDependencies: {
+          "@vitejs/plugin-react": "^5.0.0",
+          typescript: "^5.5.0",
+          vite: "^7.0.0"
+        }
+      },
+      null,
+      2
+    ) + "\n",
+    "index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>AgentsKit React Starter</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`,
+    "vite.config.ts": `import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+export default defineConfig({ plugins: [react()] })
+`,
+    "tsconfig.json": JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          lib: ["ES2022", "DOM"],
+          module: "ESNext",
+          moduleResolution: "bundler",
+          jsx: "react-jsx",
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true
+        },
+        include: ["src"]
+      },
+      null,
+      2
+    ) + "\n",
     "src/main.tsx": `import React from 'react'
 import ReactDOM from 'react-dom/client'
-import { ChatContainer, InputBar, Message, useChat } from '@agentskit/react'
-import { openai } from '@agentskit/adapters'
-import '@agentskit/react/theme'
+import App from './App'
 
-function App() {
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)
+`,
+    "src/App.tsx": `import { ChatContainer, InputBar, Message, useChat } from '@agentskit/react'
+${adapterImport(ctx.provider)}${toolImports(ctx.tools)}${memoryImport(ctx.memory)}import '@agentskit/react/theme'
+
+${includesDemo ? demoAdapterSnippet() : ""}export default function App() {
   const chat = useChat({
-    adapter: openai({ apiKey: import.meta.env.VITE_OPENAI_API_KEY ?? '', model: 'gpt-4o-mini' }),
+    adapter: ${adapter},${ctx.tools.length > 0 ? `
+    tools: ${toolList(ctx.tools)},` : ""}${ctx.memory !== "none" ? `
+    memory: ${memoryCall(ctx.memory)},` : ""}
   })
 
   return (
     <ChatContainer>
-      {chat.messages.map(message => <Message key={message.id} message={message} />)}
+      {chat.messages.map(message => (
+        <Message key={message.id} message={message} />
+      ))}
       <InputBar chat={chat} />
     </ChatContainer>
   )
 }
-
-ReactDOM.createRoot(document.getElementById('root')!).render(<App />)
 `,
-    ".env.example": "VITE_OPENAI_API_KEY=\n"
+    ".env.example": envContent,
+    ".gitignore": `node_modules
+dist
+.env
+.env.local
+.agentskit-history.*
+`,
+    "README.md": readmeFor(ctx)
   };
 }
-function inkStarter() {
+function inkStarter(ctx) {
+  const deps = {
+    "@agentskit/ink": "^0.4.0",
+    ink: "^7.0.0",
+    react: "^19.0.0"
+  };
+  if (ctx.provider !== "demo") deps["@agentskit/adapters"] = "^0.4.0";
+  if (ctx.tools.length > 0) deps["@agentskit/tools"] = "^0.4.0";
+  if (ctx.memory !== "none") deps["@agentskit/memory"] = "^0.4.0";
   return {
-    "package.json": JSON.stringify({
-      name: "agentskit-ink-app",
-      private: true,
-      type: "module",
-      scripts: {
-        dev: "tsx src/index.tsx"
+    "package.json": JSON.stringify(
+      {
+        name: "agentskit-ink-app",
+        private: true,
+        type: "module",
+        scripts: {
+          dev: "tsx src/index.tsx",
+          start: "tsx src/index.tsx"
+        },
+        dependencies: deps,
+        devDependencies: {
+          "@types/react": "^19.0.0",
+          tsx: "^4.20.0",
+          typescript: "^5.5.0"
+        }
       },
-      dependencies: {
-        "@agentskit/ink": "^0.1.0",
-        react: "^18.3.1"
-      }
-    }, null, 2),
+      null,
+      2
+    ) + "\n",
+    "tsconfig.json": JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          jsx: "react-jsx",
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true
+        },
+        include: ["src"]
+      },
+      null,
+      2
+    ) + "\n",
     "src/index.tsx": `import React from 'react'
 import { render } from 'ink'
 import { ChatContainer, InputBar, Message, useChat } from '@agentskit/ink'
+${adapterImport(ctx.provider)}${toolImports(ctx.tools)}${memoryImport(ctx.memory)}
+${ctx.provider === "demo" ? demoAdapterSnippet() : ""}function App() {
+  const chat = useChat({
+    adapter: ${adapterCall(ctx.provider)},${ctx.tools.length > 0 ? `
+    tools: ${toolList(ctx.tools)},` : ""}${ctx.memory !== "none" ? `
+    memory: ${memoryCall(ctx.memory)},` : ""}
+  })
 
-function DemoAdapter() {
-  return {
-    createSource: () => ({
-      async *stream() {
-        yield { type: 'text', content: 'Hello from AgentsKit Ink.' }
-        yield { type: 'done' }
-      },
-      abort() {},
-    }),
-  }
-}
-
-function App() {
-  const chat = useChat({ adapter: DemoAdapter() })
   return (
     <ChatContainer>
-      {chat.messages.map(message => <Message key={message.id} message={message} />)}
+      {chat.messages.map(message => (
+        <Message key={message.id} message={message} />
+      ))}
       <InputBar chat={chat} />
     </ChatContainer>
   )
 }
 
 render(<App />)
-`
+`,
+    ".env.example": PROVIDER_ENV_KEY[ctx.provider] ? `${PROVIDER_ENV_KEY[ctx.provider]}=
+` : "# No API key required for the local provider\n",
+    ".gitignore": `node_modules
+.env
+.env.local
+.agentskit-history.*
+`,
+    "README.md": readmeFor(ctx)
+  };
+}
+function runtimeStarter(ctx) {
+  const deps = {
+    "@agentskit/runtime": "^0.4.0"
+  };
+  if (ctx.provider !== "demo") deps["@agentskit/adapters"] = "^0.4.0";
+  if (ctx.tools.length > 0) deps["@agentskit/tools"] = "^0.4.0";
+  if (ctx.memory !== "none") deps["@agentskit/memory"] = "^0.4.0";
+  return {
+    "package.json": JSON.stringify(
+      {
+        name: "agentskit-runtime-app",
+        private: true,
+        type: "module",
+        scripts: {
+          start: "tsx src/index.ts",
+          dev: "tsx src/index.ts"
+        },
+        dependencies: deps,
+        devDependencies: {
+          tsx: "^4.20.0",
+          typescript: "^5.5.0"
+        }
+      },
+      null,
+      2
+    ) + "\n",
+    "tsconfig.json": JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true
+        },
+        include: ["src"]
+      },
+      null,
+      2
+    ) + "\n",
+    "src/index.ts": `import { createRuntime } from '@agentskit/runtime'
+${adapterImport(ctx.provider)}${toolImports(ctx.tools)}${memoryImport(ctx.memory)}
+${ctx.provider === "demo" ? demoAdapterSnippet() : ""}const runtime = createRuntime({
+  adapter: ${adapterCall(ctx.provider)},${ctx.tools.length > 0 ? `
+  tools: ${toolList(ctx.tools)},` : ""}${ctx.memory !== "none" ? `
+  memory: ${memoryCall(ctx.memory)},` : ""}
+  maxSteps: 10,
+})
+
+const task = process.argv.slice(2).join(' ') || 'Say hello and tell me one fact about TypeScript.'
+const result = await runtime.run(task)
+
+console.log(result.content)
+console.log(\`\\n\u2014 \${result.steps} steps \xB7 \${result.toolCalls.length} tool calls \xB7 \${result.durationMs}ms\`)
+`,
+    ".env.example": PROVIDER_ENV_KEY[ctx.provider] ? `${PROVIDER_ENV_KEY[ctx.provider]}=
+` : "# No API key required for the local provider\n",
+    ".gitignore": `node_modules
+.env
+.env.local
+.agentskit-history.*
+`,
+    "README.md": readmeFor(ctx)
   };
 }
+function multiAgentStarter(ctx) {
+  const deps = {
+    "@agentskit/runtime": "^0.4.0",
+    "@agentskit/skills": "^0.4.0"
+  };
+  if (ctx.provider !== "demo") deps["@agentskit/adapters"] = "^0.4.0";
+  if (ctx.tools.length === 0) ctx.tools = ["web_search"];
+  deps["@agentskit/tools"] = "^0.4.0";
+  return {
+    "package.json": JSON.stringify(
+      {
+        name: "agentskit-multi-agent",
+        private: true,
+        type: "module",
+        scripts: {
+          start: "tsx src/index.ts",
+          dev: "tsx src/index.ts"
+        },
+        dependencies: deps,
+        devDependencies: {
+          tsx: "^4.20.0",
+          typescript: "^5.5.0"
+        }
+      },
+      null,
+      2
+    ) + "\n",
+    "tsconfig.json": JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ES2022",
+          module: "ESNext",
+          moduleResolution: "bundler",
+          strict: true,
+          noEmit: true,
+          skipLibCheck: true
+        },
+        include: ["src"]
+      },
+      null,
+      2
+    ) + "\n",
+    "src/index.ts": `import { createRuntime } from '@agentskit/runtime'
+import { planner, researcher } from '@agentskit/skills'
+${adapterImport(ctx.provider)}${toolImports(ctx.tools)}
+${ctx.provider === "demo" ? demoAdapterSnippet() : ""}const runtime = createRuntime({
+  adapter: ${adapterCall(ctx.provider)},
+  maxSteps: 10,
+  maxDelegationDepth: 2,
+})
+
+const task = process.argv.slice(2).join(' ') || 'Research the current state of WebGPU and summarize.'
+
+const result = await runtime.run(task, {
+  skill: planner,
+  delegates: {
+    researcher: {
+      skill: researcher,
+      tools: ${toolList(ctx.tools)},
+      maxSteps: 5,
+    },
+  },
+})
+
+console.log(result.content)
+console.log(\`\\n\u2014 \${result.steps} steps \xB7 \${result.toolCalls.length} tool calls\`)
+`,
+    ".env.example": PROVIDER_ENV_KEY[ctx.provider] ? `${PROVIDER_ENV_KEY[ctx.provider]}=
+` : "# No API key required for the local provider\n",
+    ".gitignore": `node_modules
+.env
+.env.local
+`,
+    "README.md": readmeFor(ctx)
+  };
+}
+function readmeFor(ctx) {
+  const installCmd = ctx.pm === "npm" ? "npm install" : `${ctx.pm} install`;
+  const runCmd = ctx.pm === "npm" ? "npm run dev" : `${ctx.pm} dev`;
+  const envKey = PROVIDER_ENV_KEY[ctx.provider];
+  return `# AgentsKit ${ctx.template} starter
+
+Generated by \`agentskit init\`.
+
+## Stack
+
+- **Template**: \`${ctx.template}\`
+- **Provider**: \`${ctx.provider}\`${ctx.tools.length ? `
+- **Tools**: ${ctx.tools.map((t) => `\`${t}\``).join(", ")}` : ""}${ctx.memory !== "none" ? `
+- **Memory**: \`${ctx.memory}\`` : ""}
+
+## Run
+
+\`\`\`bash
+${installCmd}
+${envKey ? `cp .env.example .env
+# add ${envKey}=...` : "# No API key required"}
+${runCmd}
+\`\`\`
+
+## Next steps
+
+- Open the AgentsKit docs at https://agentskit.io/docs
+- Add a custom skill: https://agentskit.io/docs/concepts/skill
+- Wire up RAG: https://agentskit.io/docs/recipes/rag-chat
+
+## License
+
+ISC
+`;
+}
+var TEMPLATE_FN = {
+  react: reactStarter,
+  ink: inkStarter,
+  runtime: runtimeStarter,
+  "multi-agent": multiAgentStarter
+};
 async function writeStarterProject(options) {
-  const files = options.template === "ink" ? inkStarter() : reactStarter();
+  const ctx = {
+    template: options.template,
+    provider: options.provider ?? "demo",
+    tools: options.tools ?? [],
+    memory: options.memory ?? "none",
+    pm: options.packageManager ?? "pnpm"
+  };
+  const files = TEMPLATE_FN[ctx.template](ctx);
   await promises.mkdir(options.targetDir, { recursive: true });
   await Promise.all(
     Object.entries(files).map(async ([relativePath, content]) => {
@@ -246,30 +748,824 @@ async function writeStarterProject(options) {
     })
   );
 }
+async function runInteractiveInit(defaults = {}) {
+  process.stdout.write(`
+${kleur__default.default.bold().green("\u25B2")} ${kleur__default.default.bold("agentskit init")}
+`);
+  process.stdout.write(kleur__default.default.dim("   Generate a starter project \u2014 answer five questions.\n\n"));
+  try {
+    const targetDir = await prompts.input({
+      message: "Project directory:",
+      default: defaults.dir ?? "agentskit-app",
+      validate: (value) => {
+        if (!value.trim()) return "A directory name is required.";
+        const abs = path__default.default.resolve(process.cwd(), value);
+        if (fs.existsSync(abs)) return `${value} already exists. Pick a different name.`;
+        return true;
+      }
+    });
+    const template = await prompts.select({
+      message: "Template:",
+      default: defaults.template ?? "react",
+      choices: [
+        { name: "React chat (Vite + browser)", value: "react", description: "Streaming UI with @agentskit/react" },
+        { name: "Ink chat (terminal UI)", value: "ink", description: "Same chat but in your terminal" },
+        { name: "Runtime (headless agent, no UI)", value: "runtime", description: "Autonomous task \u2192 result" },
+        { name: "Multi-agent (planner + delegates)", value: "multi-agent", description: "Supervisor pattern, ready to extend" }
+      ]
+    });
+    const provider = await prompts.select({
+      message: "LLM provider:",
+      default: "demo",
+      choices: [
+        { name: "Demo (no API key \u2014 deterministic stub)", value: "demo" },
+        { name: "OpenAI", value: "openai" },
+        { name: "Anthropic", value: "anthropic" },
+        { name: "Gemini", value: "gemini" },
+        { name: "Ollama (local, no key)", value: "ollama" }
+      ]
+    });
+    let tools = [];
+    if (template !== "react") {
+      tools = await prompts.checkbox({
+        message: "Tools (space to toggle, enter to confirm):",
+        choices: [
+          { name: "web_search", value: "web_search" },
+          { name: "filesystem", value: "filesystem" },
+          { name: "shell", value: "shell" }
+        ]
+      });
+    }
+    const memory = await prompts.select({
+      message: "Memory backend:",
+      default: "none",
+      choices: [
+        { name: "None (stateless)", value: "none" },
+        { name: "File (JSON on disk)", value: "file" },
+        { name: "SQLite (better-sqlite3)", value: "sqlite" }
+      ]
+    });
+    const packageManager = await prompts.select({
+      message: "Package manager:",
+      default: "pnpm",
+      choices: [
+        { name: "pnpm", value: "pnpm" },
+        { name: "npm", value: "npm" },
+        { name: "yarn", value: "yarn" },
+        { name: "bun", value: "bun" }
+      ]
+    });
+    process.stdout.write("\n" + kleur__default.default.dim("  Summary:\n"));
+    process.stdout.write(kleur__default.default.dim(`    dir       ${targetDir}
+`));
+    process.stdout.write(kleur__default.default.dim(`    template  ${template}
+`));
+    process.stdout.write(kleur__default.default.dim(`    provider  ${provider}
+`));
+    if (tools.length) process.stdout.write(kleur__default.default.dim(`    tools     ${tools.join(", ")}
+`));
+    process.stdout.write(kleur__default.default.dim(`    memory    ${memory}
+`));
+    process.stdout.write(kleur__default.default.dim(`    pm        ${packageManager}
+
+`));
+    const proceed = await prompts.confirm({ message: "Generate?", default: true });
+    if (!proceed) {
+      process.stdout.write(kleur__default.default.yellow("Cancelled.\n"));
+      return { cancelled: true, options: { targetDir, template, provider, tools, memory, packageManager } };
+    }
+    return {
+      cancelled: false,
+      options: {
+        targetDir: path__default.default.resolve(process.cwd(), targetDir),
+        template,
+        provider,
+        tools,
+        memory,
+        packageManager
+      }
+    };
+  } catch (err) {
+    if (err.name === "ExitPromptError") {
+      process.stdout.write(kleur__default.default.yellow("\nCancelled.\n"));
+      return { cancelled: true, options: { targetDir: "", template: "react" } };
+    }
+    throw err;
+  }
+}
+function printNextSteps(options) {
+  const dir = path__default.default.relative(process.cwd(), options.targetDir) || ".";
+  const pm = options.packageManager ?? "pnpm";
+  const installCmd = pm === "npm" ? "npm install" : `${pm} install`;
+  const runCmd = pm === "npm" ? "npm run dev" : `${pm} dev`;
+  process.stdout.write("\n" + kleur__default.default.green("\u2713 Created starter at ") + kleur__default.default.bold(dir) + "\n\n");
+  process.stdout.write(kleur__default.default.bold("Next steps:\n\n"));
+  process.stdout.write(`  ${kleur__default.default.cyan("cd")} ${dir}
+`);
+  process.stdout.write(`  ${kleur__default.default.cyan(installCmd)}
+`);
+  if (options.provider && options.provider !== "demo" && options.provider !== "ollama") {
+    process.stdout.write(
+      `  ${kleur__default.default.cyan("cp")} .env.example .env  ${kleur__default.default.dim("# add your API key")}
+`
+    );
+  }
+  process.stdout.write(`  ${kleur__default.default.cyan(runCmd)}
+
+`);
+  process.stdout.write(kleur__default.default.dim("  Docs: https://agentskit.io/docs\n\n"));
+}
+function formatEvent(event) {
+  switch (event.type) {
+    case "agent:step":
+      return `[step ${event.step}] ${event.action}`;
+    case "llm:start":
+      return `[llm] start (${event.messageCount} messages)`;
+    case "llm:end": {
+      const preview = event.content.length > 100 ? event.content.slice(0, 100) + "..." : event.content;
+      return `[llm] done (${event.durationMs}ms) "${preview}"`;
+    }
+    case "tool:start":
+      return `[tool] ${event.name} ${JSON.stringify(event.args)}`;
+    case "tool:end":
+      return `[tool] ${event.name} done (${event.durationMs}ms)`;
+    case "error":
+      return `[error] ${event.error.message}`;
+    default:
+      return `[${event.type}]`;
+  }
+}
+async function runAgent(task, options) {
+  if (options.skill && options.skills) {
+    process.stderr.write("Error: --skill and --skills are mutually exclusive. Use one or the other.\n");
+    process.exit(1);
+  }
+  const { adapter } = resolveChatProvider({
+    provider: options.provider,
+    model: options.model,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl
+  });
+  const tools = resolveTools(options.tools);
+  const skill = options.skills ? resolveSkills(options.skills) : resolveSkill(options.skill);
+  const memory = options.memory ? resolveMemory(options.memoryBackend, options.memory) : void 0;
+  const observers = [];
+  if (options.verbose) {
+    observers.push({
+      name: "cli-verbose",
+      on(event) {
+        process.stderr.write(formatEvent(event) + "\n");
+      }
+    });
+  }
+  const runtime$1 = runtime.createRuntime({
+    adapter,
+    tools,
+    memory,
+    systemPrompt: options.systemPrompt,
+    maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
+    observers
+  });
+  const result = await runtime$1.run(task, {
+    skill: skill ?? void 0
+  });
+  process.stdout.write(result.content + "\n");
+}
+function RunApp({ task, options }) {
+  const [status, setStatus] = React3.useState("running");
+  const [currentStep, setCurrentStep] = React3.useState(0);
+  const [toolCalls, setToolCalls] = React3.useState([]);
+  const [result, setResult] = React3.useState("");
+  const [error, setError] = React3.useState("");
+  const [durationMs, setDurationMs] = React3.useState(0);
+  React3.useEffect(() => {
+    async function execute() {
+      if (options.skill && options.skills) {
+        setError("--skill and --skills are mutually exclusive.");
+        setStatus("error");
+        return;
+      }
+      const { adapter } = resolveChatProvider({
+        provider: options.provider,
+        model: options.model,
+        apiKey: options.apiKey,
+        baseUrl: options.baseUrl
+      });
+      const tools = resolveTools(options.tools);
+      const skill = options.skills ? resolveSkills(options.skills) : resolveSkill(options.skill);
+      const memory = options.memory ? resolveMemory(options.memoryBackend, options.memory) : void 0;
+      const observers = [{
+        name: "run-ui",
+        on(event) {
+          switch (event.type) {
+            case "agent:step":
+              setCurrentStep(event.step);
+              break;
+            case "tool:start":
+              setToolCalls((prev) => [...prev, { name: event.name, status: "running" }]);
+              break;
+            case "tool:end":
+              setToolCalls((prev) => prev.map(
+                (tc) => tc.name === event.name && tc.status === "running" ? { ...tc, status: "done", durationMs: event.durationMs } : tc
+              ));
+              break;
+            case "error":
+              setToolCalls((prev) => prev.map(
+                (tc) => tc.status === "running" ? { ...tc, status: "error" } : tc
+              ));
+              break;
+          }
+        }
+      }];
+      const runtime$1 = runtime.createRuntime({
+        adapter,
+        tools,
+        memory,
+        systemPrompt: options.systemPrompt,
+        maxSteps: options.maxSteps ? parseInt(options.maxSteps, 10) : void 0,
+        observers
+      });
+      try {
+        const runResult = await runtime$1.run(task, { skill: skill ?? void 0 });
+        setResult(runResult.content);
+        setDurationMs(runResult.durationMs);
+        setStatus("done");
+      } catch (err) {
+        setError(err instanceof Error ? err.message : String(err));
+        setStatus("error");
+      }
+    }
+    void execute();
+  }, []);
+  return /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", gap: 1, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { bold: true, color: "cyan", children: "agentskit run" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { dimColor: true, children: [
+      "Task: ",
+      task
+    ] }),
+    status === "running" && currentStep > 0 && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "yellow", children: [
+      "\u27F3",
+      " Step ",
+      currentStep
+    ] }),
+    toolCalls.map((tc, i) => /* @__PURE__ */ jsxRuntime.jsx(ink.Box, { marginLeft: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: tc.status === "running" ? "yellow" : tc.status === "done" ? "green" : "red", children: [
+      tc.status === "running" ? "\u27F3" : tc.status === "done" ? "\u2713" : "\u2717",
+      " ",
+      tc.name,
+      tc.durationMs !== void 0 ? ` (${tc.durationMs}ms)` : ""
+    ] }) }, i)),
+    status === "running" && /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { color: "yellow", children: "Running..." }),
+    status === "done" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "green", bold: true, children: [
+        "Done (",
+        durationMs,
+        "ms)"
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(ink.Text, { children: result })
+    ] }),
+    status === "error" && /* @__PURE__ */ jsxRuntime.jsxs(ink.Text, { color: "red", bold: true, children: [
+      "Error: ",
+      error
+    ] })
+  ] });
+}
+var PROVIDER_ENV_KEYS = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  grok: "XAI_API_KEY",
+  kimi: "KIMI_API_KEY"
+};
+var PROVIDER_REACH_URLS = {
+  openai: "https://api.openai.com/v1/models",
+  anthropic: "https://api.anthropic.com",
+  gemini: "https://generativelanguage.googleapis.com",
+  ollama: "http://localhost:11434/api/tags"
+};
+async function checkNodeVersion() {
+  const major = Number(process.versions.node.split(".")[0]);
+  if (Number.isNaN(major)) {
+    return { status: "fail", name: "Node version", detail: "Could not parse process.versions.node" };
+  }
+  if (major < 22) {
+    return {
+      status: "fail",
+      name: "Node version",
+      detail: `Node ${process.versions.node} (need 22+)`,
+      fix: "Install Node 22 LTS or newer (https://nodejs.org)"
+    };
+  }
+  if (major === 25) {
+    return {
+      status: "warn",
+      name: "Node version",
+      detail: `Node ${process.versions.node} \u2014 Docusaurus apps may break here`,
+      fix: "Use Node 22 LTS for the legacy docs app, or stay on 25 for everything else"
+    };
+  }
+  return { status: "pass", name: "Node version", detail: `Node ${process.versions.node}` };
+}
+async function checkPnpm() {
+  const cwd = process.cwd();
+  const hasPnpm = fs.existsSync(path.join(cwd, "pnpm-lock.yaml")) || fs.existsSync(path.join(cwd, "pnpm-workspace.yaml"));
+  if (hasPnpm) {
+    return { status: "pass", name: "Package manager", detail: "pnpm detected (lockfile)" };
+  }
+  if (fs.existsSync(path.join(cwd, "package-lock.json"))) {
+    return { status: "warn", name: "Package manager", detail: "npm detected \u2014 pnpm recommended for monorepo workflows" };
+  }
+  if (fs.existsSync(path.join(cwd, "yarn.lock"))) {
+    return { status: "pass", name: "Package manager", detail: "yarn detected" };
+  }
+  if (fs.existsSync(path.join(cwd, "bun.lock")) || fs.existsSync(path.join(cwd, "bun.lockb"))) {
+    return { status: "pass", name: "Package manager", detail: "bun detected" };
+  }
+  return {
+    status: "skip",
+    name: "Package manager",
+    detail: "No lockfile found in cwd"
+  };
+}
+async function checkPackageJson() {
+  const path4 = path.join(process.cwd(), "package.json");
+  if (!fs.existsSync(path4)) {
+    return {
+      status: "warn",
+      name: "package.json",
+      detail: "No package.json in cwd",
+      fix: "Run from a project directory (or use `agentskit init` to create one)"
+    };
+  }
+  try {
+    const pkg = JSON.parse(await promises.readFile(path4, "utf8"));
+    const deps = {
+      ...pkg.dependencies ?? {},
+      ...pkg.devDependencies ?? {}
+    };
+    const akDeps = Object.entries(deps).filter(([name]) => name.startsWith("@agentskit/"));
+    if (akDeps.length === 0) {
+      return { status: "skip", name: "AgentsKit packages", detail: "No @agentskit/* deps found in package.json" };
+    }
+    return {
+      status: "pass",
+      name: "AgentsKit packages",
+      detail: `${akDeps.length} installed: ${akDeps.map(([n]) => n.replace("@agentskit/", "")).join(", ")}`
+    };
+  } catch (err) {
+    return {
+      status: "fail",
+      name: "package.json",
+      detail: `Could not parse: ${err.message}`
+    };
+  }
+}
+async function checkProviderEnv(provider) {
+  const envKey = PROVIDER_ENV_KEYS[provider];
+  if (!envKey) {
+    return { status: "skip", name: `${provider} API key`, detail: "No env-key requirement for this provider" };
+  }
+  const value = process.env[envKey];
+  if (!value) {
+    return {
+      status: "fail",
+      name: `${provider} API key`,
+      detail: `${envKey} is not set`,
+      fix: `export ${envKey}=...`
+    };
+  }
+  if (value.length < 16) {
+    return {
+      status: "warn",
+      name: `${provider} API key`,
+      detail: `${envKey} looks too short (${value.length} chars)`,
+      fix: "Verify the key is complete and not truncated"
+    };
+  }
+  return { status: "pass", name: `${provider} API key`, detail: `${envKey} set (${value.length} chars)` };
+}
+async function checkProviderReachable(provider, fetchImpl = fetch, timeoutMs = 4e3) {
+  const url = PROVIDER_REACH_URLS[provider];
+  if (!url) {
+    return { status: "skip", name: `${provider} reachable`, detail: "No reachability check for this provider" };
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, {
+      method: "GET",
+      signal: controller.signal
+      // No auth — we just want to confirm DNS + network reach.
+    });
+    return {
+      status: "pass",
+      name: `${provider} reachable`,
+      detail: `${url} \u2192 HTTP ${res.status}`
+    };
+  } catch (err) {
+    const reason = err.name === "AbortError" ? `timeout after ${timeoutMs}ms` : err.message;
+    return {
+      status: "fail",
+      name: `${provider} reachable`,
+      detail: `${url} \u2192 ${reason}`,
+      fix: provider === "ollama" ? "Start Ollama: `ollama serve` (or install from https://ollama.com)" : "Check network / firewall / VPN settings"
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function checkConfig() {
+  try {
+    const config = await loadConfig();
+    if (!config) {
+      return { status: "skip", name: "AgentsKit config", detail: "No .agentskit.config or package.json#agentskit found" };
+    }
+    return {
+      status: "pass",
+      name: "AgentsKit config",
+      detail: `loaded \u2014 defaults: ${JSON.stringify(config.defaults ?? {})}`
+    };
+  } catch (err) {
+    return {
+      status: "warn",
+      name: "AgentsKit config",
+      detail: `Could not load: ${err.message}`
+    };
+  }
+}
+async function runDoctor(options = {}) {
+  const providers2 = options.providers ?? ["openai", "anthropic", "gemini", "ollama"];
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const checks = [
+    checkNodeVersion(),
+    checkPnpm(),
+    checkPackageJson(),
+    checkConfig()
+  ];
+  for (const provider of providers2) {
+    checks.push(checkProviderEnv(provider));
+    if (!options.noNetwork) {
+      checks.push(checkProviderReachable(provider, fetchImpl));
+    }
+  }
+  const results = await Promise.all(checks);
+  return {
+    results,
+    pass: results.filter((r) => r.status === "pass").length,
+    warn: results.filter((r) => r.status === "warn").length,
+    fail: results.filter((r) => r.status === "fail").length,
+    skip: results.filter((r) => r.status === "skip").length
+  };
+}
+var ICON = {
+  pass: "\u2713",
+  warn: "!",
+  fail: "\u2717",
+  skip: "\xB7"
+};
+function renderReport(report, opts = {}) {
+  const color = opts.color ?? true;
+  const c = (code, text) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
+  const colorFor = {
+    pass: (t) => c("32", t),
+    warn: (t) => c("33", t),
+    fail: (t) => c("31", t),
+    skip: (t) => c("90", t)
+  };
+  const lines = [];
+  lines.push("");
+  lines.push(c("1", "agentskit doctor"));
+  lines.push("");
+  for (const r of report.results) {
+    const icon = colorFor[r.status](ICON[r.status]);
+    const name = r.name.padEnd(28);
+    const detail = r.detail ? c("90", r.detail) : "";
+    lines.push(`  ${icon}  ${name} ${detail}`);
+    if (r.fix && (r.status === "fail" || r.status === "warn")) {
+      lines.push(`     ${c("90", "\u21B3 " + r.fix)}`);
+    }
+  }
+  lines.push("");
+  const summary = [
+    `${report.pass} pass`,
+    report.warn > 0 ? colorFor.warn(`${report.warn} warn`) : `${report.warn} warn`,
+    report.fail > 0 ? colorFor.fail(`${report.fail} fail`) : `${report.fail} fail`,
+    `${report.skip} skip`
+  ].join("  \xB7  ");
+  lines.push(`  ${c("1", "Summary:")} ${summary}`);
+  lines.push("");
+  return lines.join("\n");
+}
+var DEFAULT_WATCH = [
+  "**/*.ts",
+  "**/*.tsx",
+  "**/*.mjs",
+  "**/*.json",
+  ".agentskit.config.*"
+];
+var DEFAULT_IGNORE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/.turbo/**",
+  "**/.git/**",
+  "**/coverage/**",
+  "**/*.test.ts",
+  "**/*.spec.ts"
+];
+function startDev(options) {
+  const entry = path.resolve(process.cwd(), options.entry);
+  if (!fs.existsSync(entry)) {
+    throw new Error(`Entry file not found: ${entry}`);
+  }
+  const stdout = options.stdout ?? process.stdout;
+  const stderr = options.stderr ?? process.stderr;
+  const debounceMs = options.debounceMs ?? 200;
+  const isTs = entry.endsWith(".ts") || entry.endsWith(".tsx");
+  const cmd = isTs ? "tsx" : "node";
+  const baseArgs = [entry, ...options.scriptArgs ?? []];
+  const spawnFn = options.spawn ?? ((c, a) => child_process.spawn(c, a, {
+    stdio: ["inherit", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "1" }
+  }));
+  const watchPaths = options.watch ?? DEFAULT_WATCH;
+  const ignorePaths = [...DEFAULT_IGNORE, ...options.ignore ?? []];
+  const watcherFactory = options.watcher ?? ((paths, opts) => chokidar__default.default.watch(paths, { ignored: opts.ignored, ignoreInitial: true }));
+  const watcher = watcherFactory(watchPaths, { ignored: ignorePaths });
+  let child;
+  let restartCount = 0;
+  let restartTimer;
+  let stopped = false;
+  let resolveDone;
+  const done = new Promise((r) => {
+    resolveDone = r;
+  });
+  const banner = (msg, color = "green") => {
+    const time = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+    stdout.write(kleur__default.default[color](`[agentskit dev ${time}] `) + msg + "\n");
+  };
+  const startChild = () => {
+    restartCount++;
+    banner(`\u25B8 starting ${kleur__default.default.bold(path.basename(entry))} (restart #${restartCount - 1})`, "cyan");
+    const c = spawnFn(cmd, baseArgs);
+    child = c;
+    c.stdout?.on("data", (d) => stdout.write(d));
+    c.stderr?.on("data", (d) => stderr.write(d));
+    c.on("exit", (code, signal) => {
+      if (stopped) return;
+      if (signal === "SIGTERM" || signal === "SIGINT") return;
+      if (code === 0) {
+        banner(`\u2713 exited cleanly \u2014 waiting for changes`, "green");
+      } else {
+        banner(`\u2717 exited with code ${code} \u2014 waiting for changes`, "red");
+      }
+    });
+  };
+  const restart = (path4) => {
+    if (restartTimer) clearTimeout(restartTimer);
+    restartTimer = setTimeout(() => {
+      restartTimer = void 0;
+      banner(`\u21BB change detected \u2014 ${path4}`, "yellow");
+      if (child && !child.killed && child.exitCode === null) {
+        child.kill("SIGTERM");
+      }
+      setTimeout(startChild, 80);
+    }, debounceMs);
+  };
+  watcher.on("change", restart);
+  watcher.on("add", restart);
+  watcher.on("unlink", restart);
+  startChild();
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    if (restartTimer) clearTimeout(restartTimer);
+    if (child && !child.killed && child.exitCode === null) {
+      child.kill("SIGTERM");
+    }
+    await watcher.close();
+    banner(`stopped`, "cyan");
+    resolveDone();
+  };
+  if (process.stdin.isTTY && process.stdin.setRawMode) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on("data", (data) => {
+      const key = data.toString();
+      if (key === "r") restart("manual");
+      if (key === "q" || key === "") void stop();
+    });
+  }
+  return {
+    done,
+    stop,
+    restarts: () => restartCount
+  };
+}
+async function startTunnel(options) {
+  const stdout = options.stdout ?? process.stdout;
+  const open = options.open ?? (async (opts) => {
+    const lt = (await import('localtunnel')).default;
+    return await lt(opts);
+  });
+  const banner = (msg, color = "green") => {
+    const time = (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8);
+    stdout.write(kleur__default.default[color](`[agentskit tunnel ${time}] `) + msg + "\n");
+  };
+  banner(`opening tunnel to ${options.host ?? "localhost"}:${options.port}...`, "cyan");
+  const tunnel = await open({
+    port: options.port,
+    subdomain: options.subdomain,
+    local_host: options.host
+  });
+  let requests = 0;
+  let stopped = false;
+  let resolveDone;
+  const done = new Promise((r) => {
+    resolveDone = r;
+  });
+  tunnel.on("request", () => {
+    requests++;
+  });
+  tunnel.on("close", () => {
+    if (stopped) return;
+    banner(`tunnel closed by remote`, "yellow");
+    resolveDone();
+  });
+  tunnel.on("error", (...args) => {
+    const err = args[0];
+    banner(`error: ${err?.message ?? "unknown"}`, "red");
+  });
+  banner(`\u2713 ready`, "green");
+  stdout.write("\n");
+  stdout.write(`  ${kleur__default.default.bold("Public URL:")}  ${kleur__default.default.cyan(tunnel.url)}
+`);
+  stdout.write(`  ${kleur__default.default.bold("Local:")}       http://${options.host ?? "localhost"}:${options.port}
+`);
+  stdout.write("\n");
+  stdout.write(kleur__default.default.dim(`  Forward webhooks here, then ${kleur__default.default.bold("Ctrl+C")} to stop.
+
+`));
+  options.onReady?.(tunnel.url);
+  const stop = async () => {
+    if (stopped) return;
+    stopped = true;
+    tunnel.close();
+    banner(`stopped \u2014 proxied ${requests} request${requests === 1 ? "" : "s"}`, "cyan");
+    resolveDone();
+  };
+  if (process.stdin.isTTY) {
+    process.on("SIGINT", () => {
+      void stop();
+    });
+  }
+  return {
+    url: tunnel.url,
+    done,
+    stop,
+    requests: () => requests
+  };
+}
 
 // src/commands.ts
+function mergeWithConfig(options, config) {
+  if (!config) return options;
+  return {
+    ...options,
+    // Config defaults — only apply if CLI flag wasn't set
+    provider: options.provider !== "demo" ? options.provider : config.defaults?.provider ?? options.provider,
+    model: options.model ?? config.defaults?.model
+  };
+}
 function createCli() {
   const program = new commander.Command();
   program.name("agentskit").description("AgentsKit CLI for chat demos and project bootstrapping.");
-  program.command("chat").description("Start a terminal chat session.").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--system <prompt>", "System prompt").option("--memory <path>", "Path for file-based memory", ".agentskit-history.json").action((options) => {
-    process.stdout.write(`${renderChatHeader(options)}
-`);
-    ink.render(React2__default.default.createElement(ChatApp, {
-      apiKey: options.apiKey,
-      baseUrl: options.baseUrl,
-      provider: options.provider,
-      model: options.model,
+  program.command("chat").description("Start a terminal chat session.").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--system <prompt>", "System prompt").option("--memory <path>", "Path for file-based memory", ".agentskit-history.json").option("--tools <tools>", "Comma-separated tools: web_search,filesystem,shell").option("--skill <skills>", "Comma-separated skills: researcher,coder,planner,critic,summarizer").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--no-config", "Skip loading .agentskit.config.json").action(async (options) => {
+    const config = options.config !== false ? await loadConfig() : void 0;
+    const merged = mergeWithConfig(options, config);
+    const chatOptions = {
+      apiKey: merged.apiKey ?? options.apiKey,
+      baseUrl: merged.baseUrl ?? options.baseUrl,
+      provider: merged.provider,
+      model: merged.model,
       system: options.system,
-      memoryPath: options.memory
-    }));
+      memoryPath: options.memory,
+      tools: options.tools,
+      skill: options.skill,
+      memoryBackend: options.memoryBackend,
+      agentsKitConfig: config
+    };
+    process.stdout.write(`${renderChatHeader(chatOptions)}
+`);
+    ink.render(React3__default.default.createElement(ChatApp, chatOptions));
+  });
+  program.command("run [task]").description("Execute an agent task and output the result.").option("--task <task>", "Task string (alternative to positional argument)").option("--provider <provider>", "Provider to use", "demo").option("--model <model>", "Model name").option("--api-key <key>", "API key for the selected provider").option("--base-url <url>", "Override provider base URL").option("--skill <skill>", "Single skill to use").option("--skills <skills>", "Comma-separated skills (composed together)").option("--tools <tools>", "Comma-separated tools: web_search,filesystem,shell").option("--memory <path>", "Path for memory persistence").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--system-prompt <prompt>", "System prompt").option("--max-steps <steps>", "Maximum agent steps", "10").option("--verbose", "Stream agent steps to stderr").option("--pretty", "Use rich Ink-based output").option("--no-config", "Skip loading .agentskit.config.json").action(async (positionalTask, options) => {
+    const task = options.task ?? positionalTask;
+    if (!task) {
+      process.stderr.write("Error: task is required. Pass as argument or use --task.\n");
+      process.exit(1);
+    }
+    const config = options.config !== false ? await loadConfig() : void 0;
+    const merged = mergeWithConfig(options, config);
+    if (options.pretty) {
+      ink.render(React3__default.default.createElement(RunApp, { task, options }));
+    } else {
+      try {
+        await runAgent(task, { ...options, provider: merged.provider, model: merged.model });
+      } catch (err) {
+        process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+        process.exit(1);
+      }
+    }
+  });
+  program.command("init").description("Generate a starter project. Run with no flags for interactive mode.").option("--template <template>", "Starter template (react|ink|runtime|multi-agent)").option("--dir <directory>", "Target directory", "agentskit-app").option("--provider <provider>", "LLM provider (openai|anthropic|gemini|ollama|demo)").option("--tools <tools>", "Comma-separated tools (web_search,filesystem,shell)").option("--memory <backend>", "Memory backend (none|file|sqlite)").option("--pm <packageManager>", "Package manager (pnpm|npm|yarn|bun)").option("-y, --yes", "Skip interactive prompts; use flag values + defaults").action(async (rawOptions) => {
+    const isCi = !process.stdout.isTTY || rawOptions.yes || rawOptions.template;
+    let resolved;
+    if (isCi) {
+      const template = rawOptions.template ?? "react";
+      resolved = {
+        targetDir: path__default.default.resolve(process.cwd(), rawOptions.dir),
+        template,
+        provider: rawOptions.provider ?? "demo",
+        tools: rawOptions.tools ? rawOptions.tools.split(",").map((t) => t.trim()) : [],
+        memory: rawOptions.memory ?? "none",
+        packageManager: rawOptions.pm ?? "pnpm"
+      };
+    } else {
+      const result = await runInteractiveInit({
+        dir: rawOptions.dir,
+        template: rawOptions.template
+      });
+      if (result.cancelled) {
+        process.exit(0);
+      }
+      resolved = result.options;
+    }
+    await writeStarterProject(resolved);
+    if (isCi) {
+      process.stdout.write(
+        `Created ${resolved.template} starter in ${path__default.default.relative(process.cwd(), resolved.targetDir) || "."}
+`
+      );
+    } else {
+      printNextSteps(resolved);
+    }
   });
-  program.command("init").description("Generate a starter project.").option("--template <template>", "Starter template (react|ink)", "react").option("--dir <directory>", "Target directory", "agentskit-starter").action(async (options) => {
-    await writeStarterProject({
-      template: options.template === "ink" ? "ink" : "react",
-      targetDir: path__default.default.resolve(process.cwd(), options.dir)
+  program.command("doctor").description("Diagnose your AgentsKit environment.").option("--no-network", "Skip provider reachability checks").option(
+    "--providers <providers>",
+    "Comma-separated providers to check (default: openai,anthropic,gemini,ollama)"
+  ).option("--json", "Emit JSON instead of formatted output").action(async (options) => {
+    const providers2 = options.providers ? options.providers.split(",").map((p) => p.trim()).filter(Boolean) : void 0;
+    const report = await runDoctor({
+      providers: providers2,
+      noNetwork: options.network === false
     });
-    process.stdout.write(`Created ${options.template} starter in ${options.dir}
+    if (options.json) {
+      process.stdout.write(JSON.stringify(report, null, 2) + "\n");
+    } else {
+      process.stdout.write(renderReport(report, { color: process.stdout.isTTY }));
+    }
+    if (report.fail > 0) process.exit(1);
+  });
+  program.command("dev [entry]").description("Run an entry file with hot-reload on file changes.").option("--watch <globs>", "Comma-separated glob patterns to watch").option("--ignore <globs>", "Comma-separated glob patterns to ignore").option("--debounce <ms>", "Debounce window before restart", "200").action(async (positional, options) => {
+    const entry = positional ?? "src/index.ts";
+    const watch = options.watch ? options.watch.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    const ignore = options.ignore ? options.ignore.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+    try {
+      const controller = startDev({
+        entry,
+        watch,
+        ignore,
+        debounceMs: Number(options.debounce) || 200
+      });
+      await controller.done;
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
+`);
+      process.exit(1);
+    }
+  });
+  program.command("tunnel <port>").description("Open a public URL pointing to a local port (great for webhooks).").option("--subdomain <name>", "Hint for a stable subdomain (provider may decline)").option("--host <host>", "Local hostname", "localhost").action(async (port, options) => {
+    const portNum = Number(port);
+    if (Number.isNaN(portNum) || portNum < 1 || portNum > 65535) {
+      process.stderr.write(`Error: invalid port: ${port}
+`);
+      process.exit(2);
+    }
+    try {
+      const controller = await startTunnel({
+        port: portNum,
+        subdomain: options.subdomain,
+        host: options.host
+      });
+      await controller.done;
+    } catch (err) {
+      process.stderr.write(`Error: ${err.message}
 `);
+      process.exit(1);
+    }
   });
   return program;
 }