@ddlqhd/agent-sdk 0.1.0

package/dist/cli/index.cjs

@@ -0,0 +1,926 @@
+#!/usr/bin/env node
+'use strict';
+
+var chunk5QMA2YBY_cjs = require('../chunk-5QMA2YBY.cjs');
+var chunkX35MHWXE_cjs = require('../chunk-X35MHWXE.cjs');
+var chunkJF5AJQMU_cjs = require('../chunk-JF5AJQMU.cjs');
+require('../chunk-CNSGZVRN.cjs');
+var commander = require('commander');
+var chalk = require('chalk');
+var promises = require('readline/promises');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+
+function tokenUsageEqual(a, b) {
+  return a.promptTokens === b.promptTokens && a.completionTokens === b.completionTokens && a.totalTokens === b.totalTokens;
+}
+function toolCallIdTag(id) {
+  return `[${id}]`;
+}
+function formatStreamToolCallLine(verbose, toolCallId, name, args) {
+  const idPart = chalk__default.default.gray(` ${toolCallIdTag(toolCallId)}`);
+  if (verbose) {
+    const argsStr2 = args != null ? ` ${JSON.stringify(args, null, 2)}` : "";
+    return chalk__default.default.yellow(`
+\u{1F527} ${name}`) + idPart + chalk__default.default.gray(argsStr2);
+  }
+  const argsStr = args != null ? `(${truncate(JSON.stringify(args), 80)})` : "()";
+  return chalk__default.default.yellow(`
+\u{1F527} ${name}`) + idPart + chalk__default.default.gray(argsStr);
+}
+function createStreamFormatter(config = {}) {
+  const { verbose = false } = config;
+  let lastEventType = null;
+  let isFirstThinking = true;
+  let lastPrintedUsage = null;
+  let needsGapAfterToolBlock = false;
+  return {
+    format(event) {
+      let output = "";
+      if (lastEventType === "thinking" && event.type !== "thinking") {
+        output += "\n";
+        isFirstThinking = true;
+      }
+      if (needsGapAfterToolBlock && (event.type === "text_delta" || event.type === "thinking")) {
+        output += "\n";
+        needsGapAfterToolBlock = false;
+      }
+      switch (event.type) {
+        case "text_start":
+        case "text_end":
+        case "tool_call_start":
+        case "tool_call_delta":
+        case "tool_call_end":
+          break;
+        case "context_compressed":
+          if (verbose) {
+            output += chalk__default.default.gray(
+              `
+\u{1F4E6} Context compressed: ${event.stats.originalMessageCount} \u2192 ${event.stats.compressedMessageCount} messages (${event.stats.durationMs}ms)
+`
+            );
+          }
+          break;
+        case "text_delta":
+          output += event.content;
+          break;
+        case "thinking":
+          if (isFirstThinking) {
+            output += `
+${chalk__default.default.gray(`\u{1F4AD} ${event.content}`)}`;
+            isFirstThinking = false;
+          } else {
+            output += chalk__default.default.gray(event.content);
+          }
+          break;
+        case "tool_call":
+          output += formatStreamToolCallLine(verbose, event.id, event.name, event.arguments);
+          break;
+        case "tool_result": {
+          const idTag = toolCallIdTag(event.toolCallId);
+          if (verbose) {
+            output += chalk__default.default.green("\n\u2713 ") + chalk__default.default.gray(`${idTag} `) + chalk__default.default.green(`Result:
+${event.result}
+`);
+          } else {
+            const resultStr = truncate(event.result, 120);
+            output += chalk__default.default.green("\n\u2713 ") + chalk__default.default.gray(`${idTag} `) + chalk__default.default.green(resultStr);
+          }
+          needsGapAfterToolBlock = true;
+          break;
+        }
+        case "tool_error": {
+          const idTag = toolCallIdTag(event.toolCallId);
+          if (verbose) {
+            output += chalk__default.default.red("\n\u2717 ") + chalk__default.default.gray(`${idTag} `) + chalk__default.default.red(`Error:
+${event.error.message}
+`);
+          } else {
+            output += chalk__default.default.red("\n\u2717 ") + chalk__default.default.gray(`${idTag} `) + chalk__default.default.red(event.error.message);
+          }
+          needsGapAfterToolBlock = true;
+          break;
+        }
+        case "model_usage": {
+          const usage = event.usage;
+          if (!lastPrintedUsage || !tokenUsageEqual(lastPrintedUsage, usage)) {
+            lastPrintedUsage = usage;
+            output += `
+${formatUsage(usage)}`;
+          }
+          break;
+        }
+        case "session_summary": {
+          const usage = event.usage;
+          if (!lastPrintedUsage || !tokenUsageEqual(lastPrintedUsage, usage)) {
+            lastPrintedUsage = usage;
+            output += `
+${formatUsage(usage)}`;
+          }
+          break;
+        }
+        case "end":
+          if (event.reason === "error" && event.error) {
+            output += chalk__default.default.red(`
+\u2717 ${event.error.message}`);
+          } else if (event.reason === "aborted") {
+            output += chalk__default.default.yellow("\n[interrupted]");
+          }
+          break;
+      }
+      lastEventType = event.type;
+      return output;
+    },
+    finalize() {
+      return lastEventType === "thinking" ? "\n" : "";
+    }
+  };
+}
+function formatUsage(usage, config = {}) {
+  const { color = true } = config;
+  const text = `\u{1F4CA} Tokens: ${usage.promptTokens} in, ${usage.completionTokens} out (${usage.totalTokens} total)`;
+  return color ? chalk__default.default.gray(text) : text;
+}
+function formatSessionUsage(usage, config = {}) {
+  const { color = true } = config;
+  let text = `\u{1F4CA} Input: ${usage.inputTokens} | Output: ${usage.outputTokens} | Total: ${usage.totalTokens}`;
+  if (usage.cacheReadTokens > 0 || usage.cacheWriteTokens > 0) {
+    text += ` | Cache: ${usage.cacheReadTokens}r/${usage.cacheWriteTokens}w`;
+  }
+  return color ? chalk__default.default.gray(text) : text;
+}
+function formatTable(data, columns) {
+  if (data.length === 0) {
+    return "No data";
+  }
+  const widths = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxDataLen = Math.max(
+      ...data.map((row) => String(row[col.key] || "").length),
+      0
+    );
+    const minW = col.width ?? 0;
+    return Math.max(minW, headerLen, maxDataLen, 10);
+  });
+  const header = columns.map((col, i) => col.header.padEnd(widths[i])).join(" \u2502 ");
+  const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
+  const rows = data.map(
+    (row) => columns.map((col, i) => String(row[col.key] || "").padEnd(widths[i])).join(" \u2502 ")
+  );
+  return [header, separator, ...rows].join("\n");
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// src/cli/utils/keypress.ts
+var isActive = false;
+var currentHandler = null;
+var paused = false;
+var onKeypress = (chunk) => {
+  if (!isActive || !currentHandler) return;
+  const key = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+  if (key === "\x1B" || key.charCodeAt(0) === 27) {
+    currentHandler.onAbort();
+  }
+  if (key === "") {
+    currentHandler.onExit?.() || process.exit(130);
+  }
+};
+function initKeypressListener() {
+  if (!process.stdin.isTTY) {
+    return () => {
+    };
+  }
+  if (isActive) {
+    return () => {
+    };
+  }
+  isActive = true;
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.on("data", onKeypress);
+  return () => {
+    if (!isActive) return;
+    isActive = false;
+    currentHandler = null;
+    paused = false;
+    process.stdin.off("data", onKeypress);
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+    }
+    if (process.stdin.isPaused()) {
+      process.stdin.resume();
+    }
+  };
+}
+function setKeypressHandler(handler) {
+  currentHandler = handler;
+}
+function clearKeypressHandler() {
+  currentHandler = null;
+}
+function pauseKeypressListener() {
+  if (!process.stdin.isTTY || !isActive || paused) {
+    return () => {
+    };
+  }
+  paused = true;
+  process.stdin.off("data", onKeypress);
+  try {
+    process.stdin.setRawMode(false);
+  } catch {
+  }
+  if (process.stdin.isPaused()) {
+    process.stdin.resume();
+  }
+  return () => {
+    if (!paused) return;
+    paused = false;
+    if (!process.stdin.isTTY || !isActive) return;
+    try {
+      process.stdin.setRawMode(true);
+    } catch {
+    }
+    process.stdin.on("data", onKeypress);
+    if (process.stdin.isPaused()) {
+      process.stdin.resume();
+    }
+  };
+}
+var MAX_PROMPT_RETRIES = 10;
+function parseSingleLine(line, optionCount) {
+  const t = line.trim().toLowerCase();
+  if (t === "0" || t === "o") {
+    return { kind: "other" };
+  }
+  const n = parseInt(t, 10);
+  if (!Number.isFinite(n) || n < 1 || n > optionCount) {
+    return null;
+  }
+  return { kind: "indices", indices: [n - 1] };
+}
+function parseMultiLine(line, optionCount) {
+  const t = line.trim().toLowerCase();
+  if (t === "0" || t === "o") {
+    return { kind: "other" };
+  }
+  const parts = t.split(/[\s,]+/).filter(Boolean);
+  if (parts.length === 0) {
+    return null;
+  }
+  const indices = /* @__PURE__ */ new Set();
+  for (const p of parts) {
+    const n = parseInt(p, 10);
+    if (!Number.isFinite(n) || n < 1 || n > optionCount) {
+      return null;
+    }
+    indices.add(n - 1);
+  }
+  if (indices.size === 0) {
+    return null;
+  }
+  return { kind: "indices", indices: [...indices] };
+}
+async function runInteractiveAskUserQuestion(questions, readLine) {
+  const answers = [];
+  for (let qi = 0; qi < questions.length; qi++) {
+    const q = questions[qi];
+    const n = q.options.length;
+    let attempt = 0;
+    let resolved = null;
+    const block = [
+      `[${q.header}] ${q.question}`,
+      ...q.options.map((opt, i) => `  ${i + 1}. ${opt.label} \u2014 ${opt.description}`),
+      "  0. Other \u2014 custom answer when chosen",
+      "",
+      q.multiSelect ? "Enter one or more numbers (1-" + n + ") separated by comma or space, or 0/o for Other:" : "Enter a number 1-" + n + ", or 0/o for Other:"
+    ].join("\n");
+    while (attempt < MAX_PROMPT_RETRIES && !resolved) {
+      attempt++;
+      process.stdout.write(block + "\n");
+      const line = await readLine("> ");
+      const parsed = q.multiSelect ? parseMultiLine(line, n) : parseSingleLine(line, n);
+      if (!parsed) {
+        process.stdout.write(
+          `Invalid input. ${q.multiSelect ? "Use numbers 1-" + n + " (comma/space separated)" : "Enter 1-" + n}, or 0/o for Other.
+`
+        );
+        continue;
+      }
+      if (parsed.kind === "other") {
+        const otherText = (await readLine("Other (custom text): ")).trim();
+        resolved = {
+          questionIndex: qi,
+          selectedLabels: [],
+          otherText
+        };
+        break;
+      }
+      const labels = parsed.indices.map((idx) => q.options[idx].label);
+      resolved = {
+        questionIndex: qi,
+        selectedLabels: labels
+      };
+      break;
+    }
+    if (!resolved) {
+      resolved = {
+        questionIndex: qi,
+        selectedLabels: [],
+        otherText: "(skipped after invalid input)"
+      };
+    }
+    answers.push(resolved);
+  }
+  return answers;
+}
+function createTtyReadLineSession() {
+  const stdin = process.stdin;
+  const ttyIn = stdin.isTTY ? stdin : null;
+  const wasRaw = Boolean(ttyIn?.isRaw);
+  if (wasRaw) {
+    try {
+      stdin.setRawMode(false);
+    } catch {
+    }
+  }
+  if (stdin.isPaused()) {
+    stdin.resume();
+  }
+  const rl = promises.createInterface({ input: stdin, output: process.stdout });
+  return {
+    readLine: (prompt) => rl.question(prompt),
+    close: () => {
+      rl.close();
+      if (wasRaw && stdin.isTTY) {
+        try {
+          stdin.setRawMode(true);
+        } catch {
+        }
+      }
+    }
+  };
+}
+function createTtyAskUserQuestionResolver() {
+  return async (questions) => {
+    const session = createTtyReadLineSession();
+    try {
+      return await runInteractiveAskUserQuestion(questions, session.readLine);
+    } finally {
+      session.close();
+    }
+  };
+}
+
+// src/cli/commands/chat.ts
+function parseOllamaThinkCli(value) {
+  if (value === void 0 || value === "") return true;
+  const s = value.toLowerCase();
+  if (s === "true" || s === "1" || s === "yes") return true;
+  if (s === "false" || s === "0" || s === "no") return false;
+  if (s === "low" || s === "medium" || s === "high") return s;
+  throw new Error(`Invalid --ollama-think: ${value} (use true, false, low, medium, or high)`);
+}
+function addModelOptions(cmd) {
+  return cmd.option("-m, --model <model>", "Model to use (openai/anthropic/ollama)", "openai").option("-k, --api-key <key>", "API key").option("-u, --base-url <url>", "Base URL for API").option("-M, --model-name <name>", "Model name").option("-s, --session <id>", "Session ID to resume").option("-S, --system <prompt>", "System prompt").option("-t, --temperature <temp>", "Temperature", parseFloat).option("--max-tokens <tokens>", "Max tokens", (v) => parseInt(v, 10)).option("--no-stream", "Disable streaming").option("-v, --verbose", "Show full tool calls and results").option("--mcp-config <path>", "Path to MCP config file (mcp_config.json)").option("--user-base-path <path>", "User base path (default: ~)").option("--cwd <path>", "Working directory (default: current directory)").option(
+    "--resume",
+    "Resume the most recently updated session (uses same storage as --user-base-path; ignored if --session is set)"
+  ).option(
+    "--ollama-think [value]",
+    "Ollama only: `think` param (true|false|low|medium|high; bare flag => true)",
+    (v) => parseOllamaThinkCli(v)
+  );
+}
+function createModelFromOptions(options) {
+  const provider = options.model || "openai";
+  return chunkX35MHWXE_cjs.createModel({
+    provider,
+    apiKey: options.apiKey,
+    baseUrl: options.baseUrl,
+    model: options.modelName,
+    ...provider === "ollama" && options.ollamaThink !== void 0 ? { think: options.ollamaThink } : {}
+  });
+}
+function createChatCommand() {
+  return addModelOptions(
+    new commander.Command("chat").description("Start an interactive chat session")
+  ).action(async (options) => {
+    try {
+      let sessionId = options.session;
+      if (options.resume && !sessionId) {
+        sessionId = await chunk5QMA2YBY_cjs.getLatestSessionId(options.userBasePath);
+        if (!sessionId) {
+          console.warn(chalk__default.default.yellow("No saved sessions found; starting a new session."));
+        }
+      }
+      const model = createModelFromOptions(options);
+      const mcpResult = chunk5QMA2YBY_cjs.loadMCPConfig(options.mcpConfig, options.cwd || process.cwd(), options.userBasePath);
+      if (mcpResult.configPath) {
+        console.log(chalk__default.default.gray(`Loaded MCP config from: ${mcpResult.configPath}`));
+        if (mcpResult.servers.length > 0) {
+          console.log(chalk__default.default.gray(`MCP servers: ${mcpResult.servers.map((s) => s.name).join(", ")}`));
+        }
+      }
+      const cwd = options.cwd || process.cwd();
+      const agent = new chunk5QMA2YBY_cjs.Agent({
+        model,
+        cwd,
+        hookConfigDir: cwd,
+        systemPrompt: options.system,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        mcpServers: mcpResult.servers,
+        userBasePath: options.userBasePath,
+        askUserQuestion: process.stdin.isTTY ? createTtyAskUserQuestionResolver() : void 0
+      });
+      await agent.waitForInit();
+      const skillRegistry = agent.getSkillRegistry();
+      const skills = skillRegistry.getUserInvocableSkills();
+      console.log(chalk__default.default.cyan("\u{1F916} Agent SDK Chat"));
+      console.log(chalk__default.default.gray(`Model: ${model.name}`));
+      console.log(chalk__default.default.gray(`Sessions: ${chunk5QMA2YBY_cjs.getSessionStoragePath(options.userBasePath)}`));
+      if (skills.length > 0) {
+        console.log(chalk__default.default.gray(`Skills: ${skills.map((s) => `/${s.name}`).join(", ")}`));
+      }
+      console.log(chalk__default.default.gray('Type "exit" or "quit" to end the session'));
+      console.log(chalk__default.default.gray("Press ESC to interrupt streaming"));
+      console.log(chalk__default.default.gray("Use /skill-name to invoke a skill\n"));
+      const readline = await import('readline');
+      let rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false
+      });
+      const askQuestion = () => {
+        return new Promise((resolve) => {
+          rl.question(chalk__default.default.green("You: "), resolve);
+        });
+      };
+      try {
+        while (true) {
+          const input = await askQuestion();
+          if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
+            console.log(chalk__default.default.gray("\nGoodbye! \u{1F44B}"));
+            break;
+          }
+          if (!input.trim()) continue;
+          let releasedOuterReadline = false;
+          rl.close();
+          releasedOuterReadline = true;
+          try {
+            const processed = await agent.processInput(input);
+            if (processed.invoked) {
+              console.log(chalk__default.default.yellow(`
+\u26A1 Invoked skill: ${processed.skillName}`));
+            }
+            process.stdout.write(chalk__default.default.blue("\nAssistant: "));
+            if (options.stream === false) {
+              const result = await agent.run(input, { sessionId });
+              console.log(result.content);
+              if (result.usage) {
+                console.log(`
+${formatUsage(result.usage)}`);
+              }
+              console.log(`
+${formatSessionUsage(agent.getSessionUsage())}`);
+              const sid = agent.getSessionManager().sessionId;
+              if (sid) {
+                console.log(chalk__default.default.gray(`Session id: ${sid} (next time: add --resume or -s ${sid})`));
+              }
+            } else {
+              const abortController = new AbortController();
+              let interrupted = false;
+              const cleanupKeypress = initKeypressListener();
+              setKeypressHandler({
+                onAbort: () => {
+                  interrupted = true;
+                  abortController.abort();
+                  process.stdout.write(chalk__default.default.yellow("\n[interrupted]\n"));
+                }
+              });
+              let resumeAskStdin = null;
+              const pendingAskToolCallIds = /* @__PURE__ */ new Set();
+              try {
+                const formatter = createStreamFormatter({ verbose: options.verbose });
+                for await (const event of agent.stream(input, {
+                  sessionId,
+                  signal: abortController.signal
+                })) {
+                  if (interrupted) break;
+                  if (event.type === "tool_call" && event.name === "AskUserQuestion") {
+                    pendingAskToolCallIds.add(event.id);
+                    if (!resumeAskStdin) {
+                      resumeAskStdin = pauseKeypressListener();
+                    }
+                  }
+                  if (event.type === "tool_result" && pendingAskToolCallIds.has(event.toolCallId)) {
+                    pendingAskToolCallIds.delete(event.toolCallId);
+                    if (pendingAskToolCallIds.size === 0 && resumeAskStdin) {
+                      resumeAskStdin();
+                      resumeAskStdin = null;
+                    }
+                  }
+                  if (event.type === "tool_error" && pendingAskToolCallIds.has(event.toolCallId)) {
+                    pendingAskToolCallIds.delete(event.toolCallId);
+                    if (pendingAskToolCallIds.size === 0 && resumeAskStdin) {
+                      resumeAskStdin();
+                      resumeAskStdin = null;
+                    }
+                  }
+                  const output = formatter.format(event);
+                  if (output) process.stdout.write(output);
+                }
+                if (!interrupted) {
+                  const tail = formatter.finalize();
+                  if (tail) process.stdout.write(tail);
+                  console.log(`
+${formatSessionUsage(agent.getSessionUsage())}`);
+                  const sid = agent.getSessionManager().sessionId;
+                  if (sid) {
+                    console.log(chalk__default.default.gray(`Session id: ${sid} (next time: add --resume or -s ${sid})`));
+                  }
+                }
+              } finally {
+                if (resumeAskStdin) {
+                  resumeAskStdin();
+                }
+                clearKeypressHandler();
+                cleanupKeypress();
+              }
+            }
+            console.log("\n");
+          } finally {
+            if (releasedOuterReadline) {
+              rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: false
+              });
+              if (process.stdin.isPaused()) {
+                process.stdin.resume();
+              }
+            }
+          }
+        }
+      } finally {
+        await agent.destroy();
+        rl.close();
+      }
+    } catch (err) {
+      console.error(chalk__default.default.red(`Error: ${err instanceof Error ? err.message : err}`));
+      process.exit(1);
+    }
+  });
+}
+function createRunCommand() {
+  return addModelOptions(
+    new commander.Command("run").description("Run a single prompt").argument("<prompt>", "The prompt to run")
+  ).option("-o, --output <format>", "Output format (text/json)", "text").action(async (prompt, options) => {
+    try {
+      let sessionId = options.session;
+      if (options.resume && !sessionId) {
+        sessionId = await chunk5QMA2YBY_cjs.getLatestSessionId(options.userBasePath);
+        if (!sessionId) {
+          console.warn(chalk__default.default.yellow("No saved sessions found; starting a new session."));
+        }
+      }
+      const model = createModelFromOptions(options);
+      const mcpResult = chunk5QMA2YBY_cjs.loadMCPConfig(options.mcpConfig, options.cwd || process.cwd(), options.userBasePath);
+      if (mcpResult.configPath) {
+        console.log(chalk__default.default.gray(`Loaded MCP config from: ${mcpResult.configPath}`));
+      }
+      const cwd = options.cwd || process.cwd();
+      const agent = new chunk5QMA2YBY_cjs.Agent({
+        model,
+        cwd,
+        hookConfigDir: cwd,
+        systemPrompt: options.system,
+        temperature: options.temperature,
+        maxTokens: options.maxTokens,
+        mcpServers: mcpResult.servers,
+        userBasePath: options.userBasePath,
+        askUserQuestion: process.stdin.isTTY ? createTtyAskUserQuestionResolver() : void 0
+      });
+      await agent.waitForInit();
+      try {
+        if (options.output === "json") {
+          const result = await agent.run(prompt, { sessionId });
+          console.log(JSON.stringify(result, null, 2));
+        } else if (options.stream !== false) {
+          const formatter = createStreamFormatter({ verbose: options.verbose });
+          for await (const event of agent.stream(prompt, { sessionId })) {
+            const output = formatter.format(event);
+            if (output) process.stdout.write(output);
+          }
+          const tail = formatter.finalize();
+          if (tail) process.stdout.write(tail);
+        } else {
+          const result = await agent.run(prompt, { sessionId });
+          console.log(result.content);
+          if (result.usage) {
+            console.log(`
+${formatUsage(result.usage)}`);
+          }
+        }
+      } finally {
+        await agent.destroy();
+      }
+    } catch (err) {
+      console.error(chalk__default.default.red(`Error: ${err instanceof Error ? err.message : err}`));
+      process.exit(1);
+    }
+  });
+}
+function createToolsCommand() {
+  const command = new commander.Command("tools").description("Manage agent tools");
+  command.command("list").description("List all available tools").option("-f, --format <format>", "Output format (table/json)", "table").option("-c, --category <category>", "Filter by category").action((options) => {
+    const registry = new chunkJF5AJQMU_cjs.ToolRegistry();
+    const skillRegistry = chunk5QMA2YBY_cjs.createSkillRegistry();
+    registry.registerMany(chunkJF5AJQMU_cjs.getAllBuiltinTools(skillRegistry));
+    let tools = registry.getAll();
+    if (options.category) {
+      tools = tools.filter(
+        (t) => t.name.startsWith(options.category) || t.description.toLowerCase().includes(options.category.toLowerCase())
+      );
+    }
+    if (options.format === "json") {
+      console.log(JSON.stringify(tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        dangerous: t.isDangerous || false,
+        category: t.category || null
+      })), null, 2));
+    } else {
+      console.log(chalk__default.default.cyan("\n\u{1F4E6} Available Tools\n"));
+      console.log(formatTable(
+        tools.map((t) => ({
+          name: t.name,
+          description: t.description.slice(0, 50) + (t.description.length > 50 ? "..." : ""),
+          category: t.category || "",
+          dangerous: t.isDangerous ? "\u26A0\uFE0F" : ""
+        })),
+        [
+          { key: "name", header: "Name", width: 20 },
+          { key: "description", header: "Description", width: 50 },
+          { key: "category", header: "Category", width: 12 },
+          { key: "dangerous", header: "", width: 3 }
+        ]
+      ));
+      console.log(chalk__default.default.gray(`
+Total: ${tools.length} tools`));
+    }
+  });
+  command.command("show <name>").description("Show tool details").action((name) => {
+    const registry = new chunkJF5AJQMU_cjs.ToolRegistry();
+    const skillRegistry = chunk5QMA2YBY_cjs.createSkillRegistry();
+    registry.registerMany(chunkJF5AJQMU_cjs.getAllBuiltinTools(skillRegistry));
+    const tool = registry.get(name);
+    if (!tool) {
+      console.error(chalk__default.default.red(`Tool "${name}" not found`));
+      process.exit(1);
+    }
+    console.log(chalk__default.default.cyan(`
+\u{1F527} ${tool.name}
+`));
+    console.log(`Description: ${tool.description}`);
+    console.log(`Category: ${tool.category || "none"}`);
+    console.log(`Dangerous: ${tool.isDangerous ? "Yes \u26A0\uFE0F" : "No"}`);
+    console.log(`
+Parameters Schema:`);
+    console.log(JSON.stringify(tool.parameters, null, 2));
+  });
+  command.command("test <name>").description(
+    "Test a tool with arguments. Note: AskUserQuestion returns formatted text only unless the Agent is configured with askUserQuestion (e.g. CLI TTY)."
+  ).option("-a, --args <json>", "Tool arguments as JSON").action(async (name, options) => {
+    const registry = new chunkJF5AJQMU_cjs.ToolRegistry();
+    const skillRegistry = chunk5QMA2YBY_cjs.createSkillRegistry();
+    registry.registerMany(chunkJF5AJQMU_cjs.getAllBuiltinTools(skillRegistry));
+    if (!registry.has(name)) {
+      console.error(chalk__default.default.red(`Tool "${name}" not found`));
+      process.exit(1);
+    }
+    let args = {};
+    if (options.args) {
+      try {
+        args = JSON.parse(options.args);
+      } catch {
+        console.error(chalk__default.default.red("Invalid JSON in --args"));
+        process.exit(1);
+      }
+    }
+    console.log(chalk__default.default.cyan(`
+\u{1F9EA} Testing tool: ${name}
+`));
+    console.log(chalk__default.default.gray(`Arguments: ${JSON.stringify(args)}
+`));
+    const result = await registry.execute(name, args);
+    if (result.isError) {
+      console.log(chalk__default.default.red("\u274C Error:"));
+      console.log(result.content);
+    } else {
+      console.log(chalk__default.default.green("\u2705 Result:"));
+      console.log(result.content);
+    }
+  });
+  return command;
+}
+function addUserBasePathOption(cmd) {
+  return cmd.option("--user-base-path <path>", "User base path (default: ~), must match chat/run");
+}
+function createSessionsCommand() {
+  const command = new commander.Command("sessions").description("Manage chat sessions");
+  addUserBasePathOption(
+    command.command("list").description("List all sessions").option("-l, --limit <n>", "Limit number of sessions", parseInt, 20).option("-f, --format <format>", "Output format (table/json)", "table")
+  ).action(async (options) => {
+    const manager = new chunk5QMA2YBY_cjs.SessionManager({
+      type: "jsonl",
+      basePath: chunk5QMA2YBY_cjs.getSessionStoragePath(options.userBasePath)
+    });
+    const sessions = await manager.listSessions();
+    const limited = sessions.slice(0, options.limit);
+    if (options.format === "json") {
+      console.log(JSON.stringify(limited, null, 2));
+    } else {
+      if (limited.length === 0) {
+        console.log(chalk__default.default.gray("No sessions found"));
+        return;
+      }
+      console.log(chalk__default.default.cyan("\n\u{1F4AC} Sessions\n"));
+      console.log(formatTable(
+        limited.map((s) => ({
+          id: s.id,
+          messages: s.messageCount,
+          created: new Date(s.createdAt).toLocaleString(),
+          updated: new Date(s.updatedAt).toLocaleString()
+        })),
+        [
+          { key: "id", header: "ID", width: 36 },
+          { key: "messages", header: "Messages", width: 10 },
+          { key: "created", header: "Created", width: 20 },
+          { key: "updated", header: "Updated", width: 20 }
+        ]
+      ));
+      console.log(chalk__default.default.gray(`
+Total: ${sessions.length} sessions`));
+    }
+  });
+  addUserBasePathOption(
+    command.command("show <id>").description("Show session messages").option("-l, --limit <n>", "Limit number of messages", parseInt, 50)
+  ).action(async (id, options) => {
+    const manager = new chunk5QMA2YBY_cjs.SessionManager({
+      type: "jsonl",
+      basePath: chunk5QMA2YBY_cjs.getSessionStoragePath(options.userBasePath)
+    });
+    const exists = await manager.sessionExists(id);
+    if (!exists) {
+      console.error(chalk__default.default.red(`Session "${id}" not found`));
+      process.exit(1);
+    }
+    const messages = await manager.resumeSession(id);
+    const limited = messages.slice(-options.limit);
+    console.log(chalk__default.default.cyan(`
+\u{1F4AC} Session: ${id}
+`));
+    console.log(chalk__default.default.gray(`Showing ${limited.length} of ${messages.length} messages
+`));
+    for (const msg of limited) {
+      const role = msg.role === "user" ? chalk__default.default.green("You") : msg.role === "assistant" ? chalk__default.default.blue("Assistant") : chalk__default.default.yellow(msg.role);
+      console.log(`${role}: ${msg.content}
+`);
+    }
+  });
+  addUserBasePathOption(
+    command.command("delete <id>").description("Delete a session").option("-f, --force", "Skip confirmation")
+  ).action(async (id, options) => {
+    const manager = new chunk5QMA2YBY_cjs.SessionManager({
+      type: "jsonl",
+      basePath: chunk5QMA2YBY_cjs.getSessionStoragePath(options.userBasePath)
+    });
+    const exists = await manager.sessionExists(id);
+    if (!exists) {
+      console.error(chalk__default.default.red(`Session "${id}" not found`));
+      process.exit(1);
+    }
+    if (!options.force) {
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk__default.default.yellow(`Delete session "${id}"? (y/N) `), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk__default.default.gray("Cancelled"));
+        return;
+      }
+    }
+    await manager.deleteSession(id);
+    console.log(chalk__default.default.green(`\u2713 Session "${id}" deleted`));
+  });
+  addUserBasePathOption(
+    command.command("clear").description("Delete all sessions").option("-f, --force", "Skip confirmation")
+  ).action(async (options) => {
+    const manager = new chunk5QMA2YBY_cjs.SessionManager({
+      type: "jsonl",
+      basePath: chunk5QMA2YBY_cjs.getSessionStoragePath(options.userBasePath)
+    });
+    const sessions = await manager.listSessions();
+    if (sessions.length === 0) {
+      console.log(chalk__default.default.gray("No sessions to clear"));
+      return;
+    }
+    if (!options.force) {
+      const readline = await import('readline');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk__default.default.yellow(`Delete all ${sessions.length} sessions? (y/N) `), resolve);
+      });
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        console.log(chalk__default.default.gray("Cancelled"));
+        return;
+      }
+    }
+    const storage = manager.getStorage();
+    for (const session of sessions) {
+      await storage.delete(session.id);
+    }
+    console.log(chalk__default.default.green(`\u2713 Deleted ${sessions.length} sessions`));
+  });
+  return command;
+}
+function createMCPCommand() {
+  const command = new commander.Command("mcp").description("Manage MCP servers");
+  command.command("connect <command>").description("Connect to an MCP server and list available tools").option("-n, --name <name>", "Server name", "default").option("-a, --args <args>", "Command arguments (comma-separated)").option("-e, --env <env>", "Environment variables (KEY=VALUE,comma-separated)").action(async (cmd, options) => {
+    try {
+      const adapter = new chunk5QMA2YBY_cjs.MCPAdapter();
+      const args = options.args ? options.args.split(",") : [];
+      const env = {};
+      if (options.env) {
+        for (const pair of options.env.split(",")) {
+          const [key, value] = pair.split("=");
+          if (key && value) {
+            env[key] = value;
+          }
+        }
+      }
+      console.log(chalk__default.default.cyan(`
+\u{1F50C} Connecting to MCP server: ${options.name}
+`));
+      const config = {
+        name: options.name,
+        command: cmd,
+        args,
+        env: Object.keys(env).length > 0 ? env : void 0
+      };
+      await adapter.addServer(config);
+      console.log(chalk__default.default.green("\u2713 Connected successfully"));
+      const tools = await adapter.listAllTools();
+      const serverTools = tools.get(options.name) || [];
+      if (serverTools.length > 0) {
+        console.log(chalk__default.default.cyan("\n\u{1F4E6} Available tools:\n"));
+        for (const tool of serverTools) {
+          console.log(`  \u2022 ${tool.name}: ${tool.description || "No description"}`);
+        }
+      } else {
+        console.log(chalk__default.default.gray("\nNo tools available"));
+      }
+      await adapter.disconnectAll();
+    } catch (err) {
+      console.error(chalk__default.default.red(`Connection failed: ${err instanceof Error ? err.message : err}`));
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/cli/index.ts
+var isMainModule = process.argv[1]?.endsWith("cli/index.js") || process.argv[1]?.endsWith("cli\\index.js") || process.argv[1]?.includes("agent-sdk");
+if (isMainModule) {
+  const program = new commander.Command();
+  program.name("agent-sdk").description("A TypeScript Agent SDK with multi-model support, MCP integration, and streaming").version("0.1.0");
+  program.addCommand(createChatCommand());
+  program.addCommand(createRunCommand());
+  program.addCommand(createToolsCommand());
+  program.addCommand(createSessionsCommand());
+  program.addCommand(createMCPCommand());
+  program.parse();
+}
+
+exports.createChatCommand = createChatCommand;
+exports.createMCPCommand = createMCPCommand;
+exports.createRunCommand = createRunCommand;
+exports.createSessionsCommand = createSessionsCommand;
+exports.createToolsCommand = createToolsCommand;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map