@agentskit/cli 0.5.2 → 0.6.0

package/dist/{chunk-KXI7545I.js → chunk-V7E4HWTG.js}

@@ -1,16 +1,18 @@
 #!/usr/bin/env node
 import { mkdir, writeFile, readFile } from 'fs/promises';
-import path, { resolve, join, basename } from 'path';
+import { homedir } from 'os';
+import path3, { join, resolve, basename } from 'path';
 import { kimi, grok, deepseek, ollama, gemini, anthropic, openai } from '@agentskit/adapters';
-import React3, { useMemo, useState, useEffect } from 'react';
+import React3, { useState, useMemo, useRef, useEffect } from 'react';
 import { Box, Text, render } from 'ink';
-import { useChat, ChatContainer, Message, ToolCallView, ThinkingIndicator, InputBar } from '@agentskit/ink';
-import { shell, filesystem, webSearch } from '@agentskit/tools';
+import { useChat, StatusHeader, ChatContainer, Message, ToolCallView, ToolConfirmation, ThinkingIndicator, InputBar } from '@agentskit/ink';
+import { shell, filesystem, fetchUrl, webSearch } from '@agentskit/tools';
 import { summarizer, critic, planner, coder, researcher, composeSkills } from '@agentskit/skills';
 import { fileChatMemory, sqliteChatMemory } from '@agentskit/memory';
+import { randomBytes, createHash } from 'crypto';
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, readFileSync } from 'fs';
 import { jsxs, jsx } from 'react/jsx-runtime';
 import { createRuntime } from '@agentskit/runtime';
-import { existsSync } from 'fs';
 import { spawn } from 'child_process';
 import chokidar from 'chokidar';
 import kleur3 from 'kleur';
@@ -45,16 +47,39 @@ async function loadPackageJsonConfig(dir) {
     return void 0;
   }
 }
-async function loadConfig(options) {
-  const cwd = resolve(options?.cwd ?? process.cwd());
-  const tsPath = join(cwd, ".agentskit.config.ts");
-  const tsConfig = await loadTsConfig(tsPath);
+function mergeConfigs(base, override) {
+  if (!base && !override) return void 0;
+  if (!base) return override;
+  if (!override) return base;
+  return {
+    ...base,
+    ...override,
+    tools: { ...base.tools, ...override.tools },
+    defaults: { ...base.defaults, ...override.defaults },
+    runtime: { ...base.runtime, ...override.runtime },
+    observability: { ...base.observability, ...override.observability }
+  };
+}
+async function loadLocalConfig(cwd) {
+  const tsConfig = await loadTsConfig(join(cwd, ".agentskit.config.ts"));
   if (tsConfig) return tsConfig;
-  const jsonPath = join(cwd, ".agentskit.config.json");
-  const jsonConfig = await loadJsonConfig(jsonPath);
+  const jsonConfig = await loadJsonConfig(join(cwd, ".agentskit.config.json"));
   if (jsonConfig) return jsonConfig;
   return await loadPackageJsonConfig(cwd);
 }
+async function loadGlobalConfig(home) {
+  if (home === null) return void 0;
+  const globalDir = join(home ?? homedir(), ".agentskit");
+  const tsConfig = await loadTsConfig(join(globalDir, "config.ts"));
+  if (tsConfig) return tsConfig;
+  return await loadJsonConfig(join(globalDir, "config.json"));
+}
+async function loadConfig(options) {
+  const cwd = resolve(options?.cwd ?? process.cwd());
+  const global = await loadGlobalConfig(options?.home);
+  const local = await loadLocalConfig(cwd);
+  return mergeConfigs(global, local);
+}
 var providers = {
   openai: {
     label: "OpenAI",
@@ -172,19 +197,34 @@ var skillRegistry = {
   critic,
   summarizer
 };
+function instantiate(kind) {
+  switch (kind) {
+    case "web_search":
+      return [webSearch()];
+    case "fetch_url":
+      return [fetchUrl()];
+    case "filesystem":
+      return filesystem({ basePath: process.cwd() });
+    case "shell":
+      return [shell({ timeout: 3e4 })];
+  }
+}
+function gateTool(tool) {
+  if (tool.requiresConfirmation === false) return tool;
+  return { ...tool, requiresConfirmation: true };
+}
 function resolveTools(toolNames) {
-  if (!toolNames) return [];
+  if (!toolNames) {
+    return [...instantiate("web_search"), ...instantiate("fetch_url")].map(gateTool);
+  }
   const tools = [];
-  for (const name of toolNames.split(",").map((s) => s.trim())) {
+  for (const name of toolNames.split(",").map((s) => s.trim()).filter(Boolean)) {
     switch (name) {
       case "web_search":
-        tools.push(webSearch());
-        break;
+      case "fetch_url":
       case "filesystem":
-        tools.push(...filesystem({ basePath: process.cwd() }));
-        break;
       case "shell":
-        tools.push(shell({ timeout: 3e4 }));
+        tools.push(...instantiate(name));
         break;
       default:
         process.stderr.write(`Unknown tool: ${name}
@@ -224,41 +264,475 @@ function resolveMemory(backend, memoryPath) {
       return fileChatMemory(memoryPath);
   }
 }
+var ROOT = join(homedir(), ".agentskit", "sessions");
+var META_SUFFIX = ".meta.json";
+function cwdHash(cwd = process.cwd()) {
+  return createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+}
+function dirFor(cwd = process.cwd()) {
+  return join(ROOT, cwdHash(cwd));
+}
+function ensureDir(dir) {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+function generateSessionId() {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const suffix = randomBytes(3).toString("hex");
+  return `${ts}-${suffix}`;
+}
+function sessionFilePath(id, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  return join(dirFor(cwd), `${id}.json`);
+}
+function metaPath(id, cwd = process.cwd()) {
+  return join(dirFor(cwd), `${id}${META_SUFFIX}`);
+}
+function readMeta(id, cwd = process.cwd()) {
+  const path4 = metaPath(id, cwd);
+  if (!existsSync(path4)) return null;
+  try {
+    return JSON.parse(readFileSync(path4, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeSessionMeta(meta, cwd = process.cwd()) {
+  ensureDir(dirFor(cwd));
+  writeFileSync(metaPath(meta.id, cwd), JSON.stringify(meta, null, 2));
+}
+function derivePreview(messages) {
+  const firstUser = messages.find((m) => m.role === "user" && m.content.trim());
+  if (!firstUser) return "(empty)";
+  const single = firstUser.content.replace(/\s+/g, " ").trim();
+  return single.length > 80 ? `${single.slice(0, 80)}\u2026` : single;
+}
+function listSessions(cwd = process.cwd()) {
+  const dir = dirFor(cwd);
+  if (!existsSync(dir)) return [];
+  const entries = readdirSync(dir);
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json") || entry.endsWith(META_SUFFIX)) continue;
+    const id = entry.replace(/\.json$/, "");
+    const meta = readMeta(id, cwd);
+    const file = join(dir, entry);
+    if (meta) {
+      records.push({ metadata: meta, file });
+    } else {
+      const stats = statSync(file);
+      records.push({
+        metadata: {
+          id,
+          cwd,
+          createdAt: stats.birthtime.toISOString(),
+          updatedAt: stats.mtime.toISOString(),
+          messageCount: 0,
+          preview: "(legacy session)"
+        },
+        file
+      });
+    }
+  }
+  records.sort((a, b) => b.metadata.updatedAt.localeCompare(a.metadata.updatedAt));
+  return records;
+}
+function findLatestSession(cwd = process.cwd()) {
+  const all = listSessions(cwd);
+  return all[0] ?? null;
+}
+function findSession(id, cwd = process.cwd()) {
+  const exact = listSessions(cwd).find((s) => s.metadata.id === id);
+  if (exact) return exact;
+  const prefix = listSessions(cwd).find((s) => s.metadata.id.startsWith(id));
+  return prefix ?? null;
+}
+function resolveSession(input2) {
+  const cwd = input2.cwd ?? process.cwd();
+  if (input2.explicitPath) {
+    return { id: "custom", file: input2.explicitPath, isNew: !existsSync(input2.explicitPath) };
+  }
+  if (input2.forceNew) {
+    const id2 = generateSessionId();
+    return { id: id2, file: sessionFilePath(id2, cwd), isNew: true };
+  }
+  if (input2.resumeId) {
+    const target = input2.resumeId === true ? findLatestSession(cwd) : findSession(input2.resumeId, cwd);
+    if (target) {
+      return { id: target.metadata.id, file: target.file, isNew: false };
+    }
+    process.stderr.write(
+      `No session matching "${String(input2.resumeId)}" \u2014 starting a new one.
+`
+    );
+  }
+  const latest = findLatestSession(cwd);
+  if (latest) return { id: latest.metadata.id, file: latest.file, isNew: false };
+  const id = generateSessionId();
+  return { id, file: sessionFilePath(id, cwd), isNew: true };
+}
+
+// src/slash-commands.ts
+function parseSlashCommand(input2) {
+  if (!input2.startsWith("/")) return null;
+  const match = input2.slice(1).match(/^(\S+)\s*([\s\S]*)$/);
+  if (!match) return null;
+  return { name: match[1], args: match[2] ?? "" };
+}
+function createSlashRegistry(commands) {
+  const map = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    map.set(cmd.name, cmd);
+    for (const alias of cmd.aliases ?? []) map.set(alias, cmd);
+  }
+  return map;
+}
+var builtinSlashCommands = [
+  {
+    name: "help",
+    aliases: ["?"],
+    description: "List available slash commands.",
+    run(ctx) {
+      const seen = /* @__PURE__ */ new Set();
+      const lines = [];
+      for (const cmd of ctx.commands) {
+        if (seen.has(cmd.name)) continue;
+        seen.add(cmd.name);
+        const suffix = cmd.usage ? `  (${cmd.usage})` : "";
+        lines.push(`  /${cmd.name.padEnd(10)} ${cmd.description}${suffix}`);
+      }
+      ctx.feedback(`Slash commands:
+${lines.join("\n")}`, "info");
+    }
+  },
+  {
+    name: "model",
+    description: "Switch the active model.",
+    usage: "/model <name>",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value) {
+        ctx.feedback(
+          `Current model: ${ctx.runtime.model ?? "unset"}. Usage: /model <name>`,
+          "warn"
+        );
+        return;
+      }
+      ctx.setModel(value);
+      ctx.feedback(`Model \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "provider",
+    description: "Switch the adapter provider.",
+    usage: "/provider openai|anthropic|gemini|ollama|deepseek|grok|kimi|demo",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value) {
+        ctx.feedback(
+          `Current provider: ${ctx.runtime.provider}. Usage: /provider <name>`,
+          "warn"
+        );
+        return;
+      }
+      ctx.setProvider(value);
+      ctx.feedback(`Provider \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "base-url",
+    aliases: ["baseurl"],
+    description: "Override provider base URL.",
+    usage: "/base-url <url|clear>",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setBaseUrl(void 0);
+        ctx.feedback("Base URL cleared.", "success");
+        return;
+      }
+      ctx.setBaseUrl(value);
+      ctx.feedback(`Base URL \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "tools",
+    description: "Set active tools (comma-separated) or clear them.",
+    usage: "/tools web_search,fetch_url | /tools clear",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setTools(void 0);
+        ctx.feedback("Tools reset to defaults.", "success");
+        return;
+      }
+      ctx.setTools(value);
+      ctx.feedback(`Tools \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "skill",
+    description: "Set active skill(s) (comma-separated) or clear them.",
+    usage: "/skill researcher,coder | /skill clear",
+    run(ctx, args) {
+      const value = args.trim();
+      if (!value || value === "clear") {
+        ctx.setSkill(void 0);
+        ctx.feedback("Skills cleared.", "success");
+        return;
+      }
+      ctx.setSkill(value);
+      ctx.feedback(`Skills \u2192 ${value}`, "success");
+    }
+  },
+  {
+    name: "clear",
+    aliases: ["reset"],
+    description: "Clear the conversation history in this session.",
+    async run(ctx) {
+      await ctx.chat.clear();
+      ctx.feedback("History cleared.", "success");
+    }
+  },
+  {
+    name: "exit",
+    aliases: ["quit", "q"],
+    description: "Exit the chat.",
+    run() {
+      process.exit(0);
+    }
+  }
+];
+function groupIntoTurns(messages) {
+  const turns = [];
+  let current = [];
+  for (const message of messages) {
+    if (message.role === "user") {
+      if (current.length > 0) turns.push(current);
+      current = [message];
+    } else if (message.role === "system") {
+      if (current.length > 0) turns.push(current);
+      turns.push([message]);
+      current = [];
+    } else {
+      current.push(message);
+    }
+  }
+  if (current.length > 0) turns.push(current);
+  return turns;
+}
 function ChatApp(options) {
-  const adapter = useMemo(
-    () => resolveChatProvider(options).adapter,
-    [options.apiKey, options.baseUrl, options.model, options.provider]
+  const [provider, setProvider] = useState(options.provider);
+  const [model, setModel] = useState(options.model);
+  const [apiKey, setApiKey] = useState(options.apiKey);
+  const [baseUrl, setBaseUrl] = useState(options.baseUrl);
+  const [toolsFlag, setToolsFlag] = useState(options.tools);
+  const [skillFlag, setSkillFlag] = useState(options.skill);
+  const runtime = useMemo(
+    () => resolveChatProvider({ provider, model, apiKey, baseUrl }),
+    [provider, model, apiKey, baseUrl]
   );
   const memory = useMemo(
     () => resolveMemory(options.memoryBackend, options.memoryPath ?? ".agentskit-history.json"),
     [options.memoryPath, options.memoryBackend]
   );
-  const tools = useMemo(() => resolveTools(options.tools), [options.tools]);
+  const tools = useMemo(() => resolveTools(toolsFlag), [toolsFlag]);
   const skills = useMemo(() => {
-    if (!options.skill) return void 0;
-    const names = options.skill.split(",").map((s) => s.trim());
+    if (!skillFlag) return void 0;
+    const names = skillFlag.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]);
+  }, [skillFlag]);
   const chat = useChat({
-    adapter,
+    adapter: runtime.adapter,
     memory,
     systemPrompt: options.system,
     tools: tools.length > 0 ? tools : void 0,
     skills
   });
+  const [sessionAllowed, setSessionAllowed] = useState(/* @__PURE__ */ new Set());
+  const autoApprovedRef = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    if (sessionAllowed.size === 0) return;
+    for (const message of chat.messages) {
+      for (const call of message.toolCalls ?? []) {
+        if (call.status === "requires_confirmation" && sessionAllowed.has(call.name) && !autoApprovedRef.current.has(call.id)) {
+          autoApprovedRef.current.add(call.id);
+          void chat.approve(call.id);
+        }
+      }
+    }
+  }, [chat.messages, sessionAllowed, chat.approve]);
+  const handleApproveAlways = (toolCallId, toolName) => {
+    setSessionAllowed((prev) => {
+      if (prev.has(toolName)) return prev;
+      const next = new Set(prev);
+      next.add(toolName);
+      return next;
+    });
+    autoApprovedRef.current.add(toolCallId);
+    void chat.approve(toolCallId);
+  };
+  const sessionCreatedAtRef = useRef(void 0);
+  const messageCount = chat.messages.length;
+  const firstUserContent = chat.messages.find((m) => m.role === "user")?.content ?? "";
+  useEffect(() => {
+    const sessionId = options.sessionId;
+    if (!sessionId || sessionId === "custom") return;
+    if (!sessionCreatedAtRef.current) {
+      sessionCreatedAtRef.current = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    try {
+      writeSessionMeta({
+        id: sessionId,
+        cwd: process.cwd(),
+        createdAt: sessionCreatedAtRef.current,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        messageCount,
+        preview: derivePreview(chat.messages),
+        provider: runtime.provider,
+        model: runtime.model
+      });
+    } catch {
+    }
+  }, [options.sessionId, messageCount, firstUserContent, runtime.provider, runtime.model]);
+  const turns = useMemo(() => groupIntoTurns(chat.messages), [chat.messages]);
+  const toolNames = toolsFlag ? toolsFlag.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  const [feedback, setFeedback] = useState(null);
+  const slashCommands = useMemo(
+    () => [...builtinSlashCommands, ...options.slashCommands ?? []],
+    [options.slashCommands]
+  );
+  const slashRegistry = useMemo(() => createSlashRegistry(slashCommands), [slashCommands]);
+  const handleSubmitInput = async (raw) => {
+    const parsed = parseSlashCommand(raw);
+    if (!parsed) {
+      setFeedback(null);
+      return false;
+    }
+    const cmd = slashRegistry.get(parsed.name);
+    if (!cmd) {
+      setFeedback({
+        message: `Unknown command: /${parsed.name}. Type /help for the list.`,
+        kind: "error"
+      });
+      return true;
+    }
+    const ctx = {
+      chat,
+      runtime: {
+        provider: runtime.provider,
+        model: runtime.model,
+        mode: runtime.mode,
+        baseUrl,
+        tools: toolsFlag,
+        skill: skillFlag
+      },
+      setProvider,
+      setModel,
+      setApiKey,
+      setBaseUrl,
+      setTools: setToolsFlag,
+      setSkill: setSkillFlag,
+      feedback: (message, kind = "info") => setFeedback({ message, kind }),
+      commands: slashCommands
+    };
+    try {
+      await cmd.run(ctx, parsed.args);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      setFeedback({ message: `/${parsed.name} failed: ${message}`, kind: "error" });
+    }
+    return true;
+  };
+  const awaitingConfirmation = useMemo(
+    () => chat.messages.some(
+      (message) => message.toolCalls?.some(
+        (call) => call.status === "requires_confirmation" && !sessionAllowed.has(call.name)
+      )
+    ),
+    [chat.messages, sessionAllowed]
+  );
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", gap: 1, children: [
-    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "AgentsKit CLI" }),
-    /* @__PURE__ */ jsx(Text, { dimColor: true, children: "Press Enter to send. Live providers use env vars or --api-key, and demo mode stays available for zero-config usage." }),
-    /* @__PURE__ */ jsx(ChatContainer, { children: chat.messages.map((message) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx(Message, { message }),
-      message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsx(ToolCallView, { toolCall }, toolCall.id))
-    ] }, message.id)) }),
-    /* @__PURE__ */ jsx(ThinkingIndicator, { visible: chat.status === "streaming" }),
-    /* @__PURE__ */ jsx(InputBar, { chat, placeholder: "Type a message and press Enter..." })
+    /* @__PURE__ */ jsx(
+      StatusHeader,
+      {
+        provider: runtime.provider,
+        model: runtime.model,
+        mode: runtime.mode,
+        tools: toolNames,
+        messageCount: chat.messages.length,
+        sessionId: options.sessionId
+      }
+    ),
+    /* @__PURE__ */ jsx(ChatContainer, { children: turns.map((turn, turnIdx) => {
+      const assistantSteps = turn.filter((m) => m.role === "assistant").length;
+      let stepIndex = 0;
+      return /* @__PURE__ */ jsx(Box, { flexDirection: "column", gap: 1, children: turn.map((message) => {
+        const showStep = message.role === "assistant" && assistantSteps > 1;
+        if (showStep) stepIndex++;
+        return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+          showStep ? /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+            "\u21BB step ",
+            stepIndex,
+            "/",
+            assistantSteps
+          ] }) : null,
+          /* @__PURE__ */ jsx(Message, { message }),
+          message.toolCalls?.map((toolCall) => /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+            /* @__PURE__ */ jsx(ToolCallView, { toolCall, expanded: true }),
+            toolCall.status === "requires_confirmation" && !sessionAllowed.has(toolCall.name) ? /* @__PURE__ */ jsx(
+              ToolConfirmation,
+              {
+                toolCall,
+                onApprove: chat.approve,
+                onDeny: chat.deny,
+                onApproveAlways: handleApproveAlways
+              }
+            ) : null
+          ] }, toolCall.id))
+        ] }, message.id);
+      }) }, `turn-${turnIdx}`);
+    }) }),
+    /* @__PURE__ */ jsx(
+      ThinkingIndicator,
+      {
+        visible: chat.status === "streaming",
+        label: toolNames.length > 0 ? "agent working" : "thinking"
+      }
+    ),
+    chat.error ? /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "red", paddingX: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "red", bold: true, children: [
+        "\u2717 ",
+        chat.error.name || "Error"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { color: "red", children: chat.error.message })
+    ] }) : null,
+    feedback ? /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor: feedbackBorder(feedback.kind), paddingX: 1, children: /* @__PURE__ */ jsx(Text, { color: feedbackBorder(feedback.kind), children: feedback.message }) }) : null,
+    /* @__PURE__ */ jsx(
+      InputBar,
+      {
+        chat,
+        placeholder: "Type a message or /help for commands",
+        disabled: awaitingConfirmation,
+        onSubmitInput: handleSubmitInput
+      }
+    )
   ] });
 }
+function feedbackBorder(kind) {
+  switch (kind) {
+    case "error":
+      return "red";
+    case "warn":
+      return "yellow";
+    case "success":
+      return "green";
+    case "info":
+    default:
+      return "cyan";
+  }
+}
 function renderChatHeader(options) {
   const runtime = resolveChatProvider(options);
   const parts = [`provider=${runtime.provider}`];
@@ -367,7 +841,7 @@ function reactStarter(ctx) {
   return {
     "package.json": JSON.stringify(
       {
-        name: path.basename(ctx.template === "react" ? "agentskit-react-app" : "agentskit-app"),
+        name: path3.basename(ctx.template === "react" ? "agentskit-react-app" : "agentskit-app"),
         private: true,
         type: "module",
         scripts: {
@@ -736,8 +1210,8 @@ async function writeStarterProject(options) {
   await mkdir(options.targetDir, { recursive: true });
   await Promise.all(
     Object.entries(files).map(async ([relativePath, content]) => {
-      const absolutePath = path.join(options.targetDir, relativePath);
-      await mkdir(path.dirname(absolutePath), { recursive: true });
+      const absolutePath = path3.join(options.targetDir, relativePath);
+      await mkdir(path3.dirname(absolutePath), { recursive: true });
       await writeFile(absolutePath, content, "utf8");
     })
   );
@@ -1245,7 +1719,7 @@ ${kleur3.bold().green("\u25B2")} ${kleur3.bold("agentskit init")}
       default: defaults.dir ?? "agentskit-app",
       validate: (value) => {
         if (!value.trim()) return "A directory name is required.";
-        const abs = path.resolve(process.cwd(), value);
+        const abs = path3.resolve(process.cwd(), value);
         if (existsSync(abs)) return `${value} already exists. Pick a different name.`;
         return true;
       }
@@ -1323,7 +1797,7 @@ ${kleur3.bold().green("\u25B2")} ${kleur3.bold("agentskit init")}
     return {
       cancelled: false,
       options: {
-        targetDir: path.resolve(process.cwd(), targetDir),
+        targetDir: path3.resolve(process.cwd(), targetDir),
         template,
         provider,
         tools,
@@ -1340,7 +1814,7 @@ ${kleur3.bold().green("\u25B2")} ${kleur3.bold("agentskit init")}
   }
 }
 function printNextSteps(options) {
-  const dir = path.relative(process.cwd(), options.targetDir) || ".";
+  const dir = path3.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`;
@@ -1463,34 +1937,87 @@ function RunApp({ task, options }) {
 // src/commands.ts
 function mergeWithConfig(options, config) {
   if (!config) return options;
+  const d = config.defaults ?? {};
+  const resolvedApiKey = options.apiKey ?? (d.apiKeyEnv ? process.env[d.apiKeyEnv] : void 0) ?? d.apiKey;
   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
+    provider: options.provider !== "demo" ? options.provider : d.provider ?? options.provider,
+    model: options.model ?? d.model,
+    apiKey: resolvedApiKey,
+    baseUrl: options.baseUrl ?? d.baseUrl,
+    tools: options.tools ?? d.tools,
+    skill: options.skill ?? d.skill,
+    system: options.system ?? d.system,
+    memoryBackend: options.memoryBackend ?? d.memoryBackend
   };
 }
 function createCli() {
   const program = new 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) => {
+  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>", "Explicit memory file path (overrides session management)").option("--tools <tools>", "Comma-separated tools: web_search,fetch_url,filesystem,shell").option("--skill <skills>", "Comma-separated skills: researcher,coder,planner,critic,summarizer").option("--memory-backend <backend>", "Memory backend: file (default), sqlite").option("--new", "Start a fresh chat session (ignore previous conversations in this directory)").option("--resume [id]", "Resume a prior session by id; omit id to resume the latest").option("--list-sessions", "List saved sessions for this directory and exit").option("--no-config", "Skip loading .agentskit.config.json").action(async (options) => {
+    if (options.listSessions) {
+      const sessions = listSessions();
+      if (sessions.length === 0) {
+        process.stdout.write("No saved sessions for this directory.\n");
+        return;
+      }
+      for (const s of sessions) {
+        const { id, updatedAt, messageCount, preview, model } = s.metadata;
+        process.stdout.write(
+          `${id}  ${updatedAt}  msgs=${messageCount}${model ? `  model=${model}` : ""}
+    ${preview}
+`
+        );
+      }
+      return;
+    }
     const config = options.config !== false ? await loadConfig() : void 0;
     const merged = mergeWithConfig(options, config);
+    const session = resolveSession({
+      explicitPath: options.memory,
+      forceNew: Boolean(options.new),
+      resumeId: options.resume
+    });
+    if (!session.isNew && !options.memory) {
+      process.stdout.write(
+        `Resuming session ${session.id}. Start fresh with --new or list with --list-sessions.
+`
+      );
+    }
     const chatOptions = {
       apiKey: merged.apiKey ?? options.apiKey,
       baseUrl: merged.baseUrl ?? options.baseUrl,
       provider: merged.provider,
       model: merged.model,
-      system: options.system,
-      memoryPath: options.memory,
-      tools: options.tools,
-      skill: options.skill,
-      memoryBackend: options.memoryBackend,
+      system: merged.system ?? options.system,
+      memoryPath: session.file,
+      sessionId: session.id,
+      tools: merged.tools ?? options.tools,
+      skill: merged.skill ?? options.skill,
+      memoryBackend: merged.memoryBackend ?? options.memoryBackend,
       agentsKitConfig: config
     };
     process.stdout.write(`${renderChatHeader(chatOptions)}
 `);
-    render(React3.createElement(ChatApp, chatOptions));
+    const instance = render(React3.createElement(ChatApp, chatOptions));
+    await instance.waitUntilExit();
+    if (options.memory) {
+      process.stdout.write(
+        `
+Session saved to ${session.file}. Resume with --memory ${session.file}
+`
+      );
+    } else {
+      process.stdout.write(
+        `
+Session saved. Resume with:
+  agentskit chat --resume ${session.id}
+Or start fresh with:
+  agentskit chat --new
+`
+      );
+    }
   });
   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;
@@ -1518,7 +2045,7 @@ function createCli() {
     if (isCi) {
       const template = rawOptions.template ?? "react";
       resolved = {
-        targetDir: path.resolve(process.cwd(), rawOptions.dir),
+        targetDir: path3.resolve(process.cwd(), rawOptions.dir),
         template,
         provider: rawOptions.provider ?? "demo",
         tools: rawOptions.tools ? rawOptions.tools.split(",").map((t) => t.trim()) : [],
@@ -1538,7 +2065,7 @@ function createCli() {
     await writeStarterProject(resolved);
     if (isCi) {
       process.stdout.write(
-        `Created ${resolved.template} starter in ${path.relative(process.cwd(), resolved.targetDir) || "."}
+        `Created ${resolved.template} starter in ${path3.relative(process.cwd(), resolved.targetDir) || "."}
 `
       );
     } else {
@@ -1579,6 +2106,43 @@ function createCli() {
       process.exit(1);
     }
   });
+  program.command("config").description("Show or scaffold the AgentsKit config.").argument("[action]", 'Action: "init" to create a template, "show" to print the merged config.', "show").option("--global", "Write/read the global config at ~/.agentskit/config.json (default)").option("--local", "Write/read a project-level .agentskit.config.json in the current directory").option("--force", "Overwrite an existing config file").action(async (action, options) => {
+    const isLocal = Boolean(options.local);
+    const targetPath = isLocal ? path3.join(process.cwd(), ".agentskit.config.json") : path3.join(homedir(), ".agentskit", "config.json");
+    if (action === "show") {
+      const config = await loadConfig();
+      process.stdout.write(JSON.stringify(config ?? {}, null, 2) + "\n");
+      return;
+    }
+    if (action !== "init") {
+      process.stderr.write(`Unknown action: ${action}. Use "init" or "show".
+`);
+      process.exit(2);
+    }
+    if (existsSync(targetPath) && !options.force) {
+      process.stderr.write(`Config already exists at ${targetPath}. Re-run with --force to overwrite.
+`);
+      process.exit(1);
+    }
+    const template = {
+      defaults: {
+        provider: "openai",
+        baseUrl: "https://openrouter.ai/api",
+        apiKeyEnv: "OPENROUTER_API_KEY",
+        model: "openai/gpt-oss-120b:free",
+        tools: "web_search,fetch_url"
+      }
+    };
+    mkdirSync(path3.dirname(targetPath), { recursive: true });
+    writeFileSync(targetPath, JSON.stringify(template, null, 2) + "\n");
+    process.stdout.write(
+      `Wrote ${targetPath}
+Edit it to taste, then run:
+  agentskit chat
+(flags on the CLI still win over config values.)
+`
+    );
+  });
   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) {
@@ -1603,5 +2167,5 @@ function createCli() {
 }
 
 export { ChatApp, createCli, loadConfig, renderChatHeader, renderReport, resolveChatProvider, runAgent, runDoctor, startDev, startTunnel, writeStarterProject };
-//# sourceMappingURL=chunk-KXI7545I.js.map
-//# sourceMappingURL=chunk-KXI7545I.js.map
+//# sourceMappingURL=chunk-V7E4HWTG.js.map
+//# sourceMappingURL=chunk-V7E4HWTG.js.map