@agentskit/cli 0.4.2 → 0.5.0

package/dist/index.cjs

@@ -5,21 +5,65 @@ var React3 = require('react');
 var ink$1 = require('ink');
 var commander = require('commander');
 var path = require('path');
-var core = require('@agentskit/core');
+var promises = require('fs/promises');
 var ink = 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 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(options?.cwd ?? 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",
@@ -79,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" };
@@ -186,7 +230,7 @@ function resolveMemory(backend, memoryPath) {
       return memory.sqliteChatMemory({ path: memoryPath.replace(/\.json$/, ".db") });
     case "file":
     default:
-      return core.createFileMemory(memoryPath);
+      return memory.fileChatMemory(memoryPath);
   }
 }
 function ChatApp(options) {
@@ -234,92 +278,467 @@ function renderChatHeader(options) {
   if (options.memoryBackend) parts.push(`memory=${options.memoryBackend}`);
   return parts.join(" ");
 }
-function reactStarter() {
+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 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]) => {
@@ -329,6 +748,133 @@ 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":
@@ -483,6 +1029,404 @@ function RunApp({ task, options }) {
     ] })
   ] });
 }
+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) {
@@ -498,7 +1442,7 @@ 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").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 core.loadConfig() : void 0;
+    const config = options.config !== false ? await loadConfig() : void 0;
     const merged = mergeWithConfig(options, config);
     const chatOptions = {
       apiKey: merged.apiKey ?? options.apiKey,
@@ -522,7 +1466,7 @@ function createCli() {
       process.stderr.write("Error: task is required. Pass as argument or use --task.\n");
       process.exit(1);
     }
-    const config = options.config !== false ? await core.loadConfig() : void 0;
+    const config = options.config !== false ? await loadConfig() : void 0;
     const merged = mergeWithConfig(options, config);
     if (options.pretty) {
       ink$1.render(React3__default.default.createElement(RunApp, { task, options }));
@@ -536,22 +1480,106 @@ function createCli() {
       }
     }
   });
-  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("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("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;
 }
 
 exports.ChatApp = ChatApp;
 exports.createCli = createCli;
+exports.loadConfig = loadConfig;
 exports.renderChatHeader = renderChatHeader;
+exports.renderReport = renderReport;
 exports.resolveChatProvider = resolveChatProvider;
 exports.runAgent = runAgent;
+exports.runDoctor = runDoctor;
+exports.startDev = startDev;
+exports.startTunnel = startTunnel;
 exports.writeStarterProject = writeStarterProject;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map