@robota-sdk/agent-cli 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/node/{chunk-C56WFH5S.js → chunk-UT4RQDTI.js}

@@ -1,6 +1,6 @@
 // src/cli.ts
 import { parseArgs } from "util";
-import { readFileSync as readFileSync2 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync, writeFileSync, unlinkSync } from "fs";
 import { join as join2, dirname } from "path";
 import { fileURLToPath } from "url";
 import * as readline from "readline";
@@ -8,9 +8,10 @@ import {
   loadConfig,
   loadContext,
   detectProject,
-  Session as Session2,
+  createSession as createSession2,
   SessionStore,
-  buildSystemPrompt
+  FileSessionLogger as FileSessionLogger2,
+  projectPaths as projectPaths2
 } from "@robota-sdk/agent-sdk";
 
 // src/permissions/permission-prompt.ts
@@ -39,7 +40,7 @@ import { render } from "ink";
 // src/ui/App.tsx
 import { useState as useState4, useCallback as useCallback2, useRef as useRef2 } from "react";
 import { Box as Box6, Text as Text8, useApp, useInput as useInput4 } from "ink";
-import { Session } from "@robota-sdk/agent-sdk";
+import { createSession, FileSessionLogger, projectPaths } from "@robota-sdk/agent-sdk";
 
 // src/commands/command-registry.ts
 var CommandRegistry = class {
@@ -101,6 +102,7 @@ function createBuiltinCommands() {
     { name: "cost", description: "Show session info", source: "builtin" },
     { name: "context", description: "Context window info", source: "builtin" },
     { name: "permissions", description: "Permission rules", source: "builtin" },
+    { name: "reset", description: "Delete settings and exit", source: "builtin" },
     { name: "exit", description: "Exit CLI", source: "builtin" }
   ];
 }
@@ -152,7 +154,8 @@ function scanSkillsDir(skillsDir) {
     commands.push({
       name: frontmatter?.name ?? entry.name,
       description: frontmatter?.description ?? `Skill: ${entry.name}`,
-      source: "skill"
+      source: "skill",
+      skillContent: content
     });
   }
   return commands;
@@ -328,50 +331,60 @@ function CjkTextInput({
   }
   useInput(
     (input, key) => {
-      if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
-        return;
-      }
-      if (key.return) {
-        onSubmit?.(valueRef.current);
-        return;
-      }
-      if (key.leftArrow) {
-        if (cursorRef.current > 0) {
-          cursorRef.current -= 1;
-          forceRender((n) => n + 1);
+      try {
+        if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
+          return;
         }
-        return;
-      }
-      if (key.rightArrow) {
-        if (cursorRef.current < valueRef.current.length) {
-          cursorRef.current += 1;
-          forceRender((n) => n + 1);
+        if (key.return) {
+          onSubmit?.(valueRef.current);
+          return;
         }
-        return;
-      }
-      if (key.backspace || key.delete) {
-        if (cursorRef.current > 0) {
-          const v2 = valueRef.current;
-          const next2 = v2.slice(0, cursorRef.current - 1) + v2.slice(cursorRef.current);
-          cursorRef.current -= 1;
-          valueRef.current = next2;
-          onChange(next2);
+        if (key.leftArrow) {
+          if (cursorRef.current > 0) {
+            cursorRef.current -= 1;
+            forceRender((n) => n + 1);
+          }
+          return;
         }
-        return;
+        if (key.rightArrow) {
+          if (cursorRef.current < valueRef.current.length) {
+            cursorRef.current += 1;
+            forceRender((n) => n + 1);
+          }
+          return;
+        }
+        if (key.backspace || key.delete) {
+          if (cursorRef.current > 0) {
+            const v2 = valueRef.current;
+            const next2 = v2.slice(0, cursorRef.current - 1) + v2.slice(cursorRef.current);
+            cursorRef.current -= 1;
+            valueRef.current = next2;
+            onChange(next2);
+          }
+          return;
+        }
+        if (!input || input.length === 0) return;
+        const printable = input.replace(/[\x00-\x1f\x7f]/g, "");
+        if (printable.length === 0) return;
+        const v = valueRef.current;
+        const c = cursorRef.current;
+        const next = v.slice(0, c) + printable + v.slice(c);
+        cursorRef.current = c + printable.length;
+        valueRef.current = next;
+        onChange(next);
+      } catch {
       }
-      const v = valueRef.current;
-      const c = cursorRef.current;
-      const next = v.slice(0, c) + input + v.slice(c);
-      cursorRef.current = c + input.length;
-      valueRef.current = next;
-      onChange(next);
     },
     { isActive: focus }
   );
   if (showCursor && focus) {
-    const textBeforeCursor = [...valueRef.current].slice(0, cursorRef.current).join("");
-    const cursorX = 4 + stringWidth(textBeforeCursor);
-    setCursorPosition({ x: cursorX, y: 0 });
+    try {
+      const textBeforeCursor = [...valueRef.current].slice(0, cursorRef.current).join("");
+      const cursorX = 4 + stringWidth(textBeforeCursor);
+      setCursorPosition({ x: cursorX, y: 0 });
+    } catch {
+      setCursorPosition({ x: 4, y: 0 });
+    }
   }
   return /* @__PURE__ */ jsx3(Text3, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
 }
@@ -607,7 +620,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
 import React4 from "react";
 import { Box as Box5, Text as Text7, useInput as useInput3 } from "ink";
 import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var OPTIONS = ["Allow", "Deny"];
+var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
 function formatArgs2(args) {
   const entries = Object.entries(args);
   if (entries.length === 0) return "(no arguments)";
@@ -623,10 +636,12 @@ function PermissionPrompt({ request }) {
     setSelected(0);
   }
   const doResolve = React4.useCallback(
-    (allowed) => {
+    (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
-      request.resolve(allowed);
+      if (index === 0) request.resolve(true);
+      else if (index === 1) request.resolve("allow-session");
+      else request.resolve(false);
     },
     [request]
   );
@@ -637,11 +652,13 @@ function PermissionPrompt({ request }) {
     } else if (key.downArrow || key.rightArrow) {
       setSelected((prev) => prev < OPTIONS.length - 1 ? prev + 1 : prev);
     } else if (key.return) {
-      doResolve(selected === 0);
-    } else if (input === "y" || input === "a" || input === "1") {
-      doResolve(true);
-    } else if (input === "n" || input === "d" || input === "2") {
-      doResolve(false);
+      doResolve(selected);
+    } else if (input === "y" || input === "1") {
+      doResolve(0);
+    } else if (input === "a" || input === "2") {
+      doResolve(1);
+    } else if (input === "n" || input === "d" || input === "3") {
+      doResolve(2);
     }
   });
   return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
@@ -701,11 +718,11 @@ function useSession(props) {
     setPermissionRequest({
       toolName: next.toolName,
       toolArgs: next.toolArgs,
-      resolve: (allowed) => {
+      resolve: (result) => {
         permissionQueueRef.current.shift();
         processingRef.current = false;
         setPermissionRequest(null);
-        next.resolve(allowed);
+        next.resolve(result);
         setTimeout(() => processNextPermission(), 0);
       }
     });
@@ -721,10 +738,12 @@ function useSession(props) {
     const onTextDelta = (delta) => {
       setStreamingText((prev) => prev + delta);
     };
-    sessionRef.current = new Session({
+    const paths = projectPaths(props.cwd ?? process.cwd());
+    sessionRef.current = createSession({
       config: props.config,
       context: props.context,
       terminal: NOOP_TERMINAL,
+      sessionLogger: new FileSessionLogger(paths.logs),
       projectInfo: props.projectInfo,
       sessionStore: props.sessionStore,
       permissionMode: props.permissionMode,
@@ -750,6 +769,7 @@ var HELP_TEXT = [
   "  /compact [instr]   \u2014 Compact context (optional focus instructions)",
   "  /mode [m]          \u2014 Show/change permission mode",
   "  /cost              \u2014 Show session info",
+  "  /reset             \u2014 Delete settings and exit",
   "  /exit              \u2014 Exit CLI"
 ].join("\n");
 function handleModeCommand(arg, session, addMessage) {
@@ -795,6 +815,39 @@ async function executeSlashCommand(cmd, parts, session, addMessage, setMessages,
 Messages: ${session.getMessageCount()}`
       });
       return true;
+    case "permissions": {
+      const mode = session.getPermissionMode();
+      const sessionAllowed = session.getSessionAllowedTools();
+      const lines = [`Permission mode: ${mode}`];
+      if (sessionAllowed.length > 0) {
+        lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
+      } else {
+        lines.push("No session-approved tools.");
+      }
+      addMessage({ role: "system", content: lines.join("\n") });
+      return true;
+    }
+    case "context": {
+      const ctx = session.getContextState();
+      addMessage({
+        role: "system",
+        content: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`
+      });
+      return true;
+    }
+    case "reset": {
+      const { existsSync: exists, unlinkSync: unlink } = await import("fs");
+      const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+      const settingsPath = `${home}/.robota/settings.json`;
+      if (exists(settingsPath)) {
+        unlink(settingsPath);
+        addMessage({ role: "system", content: `Deleted ${settingsPath}. Exiting...` });
+      } else {
+        addMessage({ role: "system", content: "No user settings found." });
+      }
+      setTimeout(() => exit(), 500);
+      return true;
+    }
     case "exit":
       exit();
       return true;
@@ -835,15 +888,42 @@ function StreamingIndicator({ text }) {
 async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextPercentage) {
   setIsThinking(true);
   clearStreamingText();
+  const historyBefore = session.getHistory().length;
   try {
     const response = await session.run(prompt);
     clearStreamingText();
+    const history = session.getHistory();
+    const toolLines = [];
+    for (let i = historyBefore; i < history.length; i++) {
+      const msg = history[i];
+      if (msg.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          let value = "";
+          try {
+            const parsed = JSON.parse(tc.function.arguments);
+            const firstVal = Object.values(parsed)[0];
+            value = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal);
+          } catch {
+            value = tc.function.arguments;
+          }
+          const truncated = value.length > 80 ? value.slice(0, 77) + "..." : value;
+          toolLines.push(`${tc.function.name}(${truncated})`);
+        }
+      }
+    }
+    if (toolLines.length > 0) {
+      addMessage({ role: "tool", content: toolLines.join("\n"), toolName: `${toolLines.length} tools` });
+    }
     addMessage({ role: "assistant", content: response || "(empty response)" });
     setContextPercentage(session.getContextState().usedPercentage);
   } catch (err) {
     clearStreamingText();
-    const errMsg = err instanceof Error ? err.message : String(err);
-    addMessage({ role: "system", content: `Error: ${errMsg}` });
+    if (err instanceof DOMException && err.name === "AbortError") {
+      addMessage({ role: "system", content: "Cancelled." });
+    } else {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      addMessage({ role: "system", content: `Error: ${errMsg}` });
+    }
   } finally {
     setIsThinking(false);
   }
@@ -854,7 +934,15 @@ function buildSkillPrompt(input, registry) {
   const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
   if (!skillCmd) return null;
   const args = parts.slice(1).join(" ").trim();
-  return args ? `Use the "${cmd}" skill: ${args}` : `Use the "${cmd}" skill: ${skillCmd.description}`;
+  const userInstruction = args || skillCmd.description;
+  if (skillCmd.skillContent) {
+    return `<skill name="${cmd}">
+${skillCmd.skillContent}
+</skill>
+
+Execute the "${cmd}" skill: ${userInstruction}`;
+  }
+  return `Use the "${cmd}" skill: ${userInstruction}`;
 }
 function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextPercentage, registry) {
   return useCallback2(
@@ -927,8 +1015,9 @@ function App(props) {
   useInput4(
     (_input, key) => {
       if (key.ctrl && _input === "c") exit();
+      if (key.escape && isThinking) session.abort();
     },
-    { isActive: !permissionRequest && !isThinking }
+    { isActive: !permissionRequest }
   );
   return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
@@ -1048,7 +1137,8 @@ function parseCliArgs() {
       model: { type: "string" },
       "permission-mode": { type: "string" },
       "max-turns": { type: "string" },
-      version: { type: "boolean", default: false }
+      version: { type: "boolean", default: false },
+      reset: { type: "boolean", default: false }
     }
   });
   return {
@@ -1059,7 +1149,8 @@ function parseCliArgs() {
     model: values["model"],
     permissionMode: parsePermissionMode(values["permission-mode"]),
     maxTurns: parseMaxTurns(values["max-turns"]),
-    version: values["version"] ?? false
+    version: values["version"] ?? false,
+    reset: values["reset"] ?? false
   };
 }
 var PrintTerminal = class {
@@ -1110,6 +1201,83 @@ var PrintTerminal = class {
     } };
   }
 };
+function getUserSettingsPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+  return join2(home, ".robota", "settings.json");
+}
+async function ensureConfig(cwd) {
+  const userPath = getUserSettingsPath();
+  const projectPath = join2(cwd, ".robota", "settings.json");
+  const localPath = join2(cwd, ".robota", "settings.local.json");
+  if (existsSync2(userPath) || existsSync2(projectPath) || existsSync2(localPath)) {
+    return;
+  }
+  process.stdout.write("\n");
+  process.stdout.write("  Welcome to Robota CLI!\n");
+  process.stdout.write("  No configuration found. Let's set up your API key.\n");
+  process.stdout.write("\n");
+  const apiKey = await new Promise((resolve) => {
+    process.stdout.write("  Anthropic API key: ");
+    let input = "";
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (data) => {
+      for (const ch of data) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(wasRaw ?? false);
+          stdin.pause();
+          process.stdout.write("\n");
+          resolve(input.trim());
+          return;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch === "") {
+          process.stdout.write("\n");
+          process.exit(0);
+        } else if (ch.charCodeAt(0) >= 32) {
+          input += ch;
+          process.stdout.write("*");
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+  if (!apiKey) {
+    process.stderr.write("\n  No API key provided. Exiting.\n");
+    process.exit(1);
+  }
+  const settingsDir = dirname(userPath);
+  mkdirSync(settingsDir, { recursive: true });
+  const settings = {
+    provider: {
+      name: "anthropic",
+      model: "claude-sonnet-4-6",
+      apiKey
+    }
+  };
+  writeFileSync(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  process.stdout.write(`
+  Config saved to ${userPath}
+
+`);
+}
+function resetConfig() {
+  const userPath = getUserSettingsPath();
+  if (existsSync2(userPath)) {
+    unlinkSync(userPath);
+    process.stdout.write(`Deleted ${userPath}
+`);
+  } else {
+    process.stdout.write("No user settings found.\n");
+  }
+}
 async function startCli() {
   const args = parseCliArgs();
   if (args.version) {
@@ -1117,7 +1285,12 @@ async function startCli() {
 `);
     return;
   }
+  if (args.reset) {
+    resetConfig();
+    return;
+  }
   const cwd = process.cwd();
+  await ensureConfig(cwd);
   const [config, context, projectInfo] = await Promise.all([
     loadConfig(cwd),
     loadContext(cwd),
@@ -1134,13 +1307,14 @@ async function startCli() {
       process.exit(1);
     }
     const terminal = new PrintTerminal();
-    const session = new Session2({
+    const paths = projectPaths2(cwd);
+    const session = createSession2({
       config,
       context,
       terminal,
+      sessionLogger: new FileSessionLogger2(paths.logs),
       projectInfo,
       permissionMode: args.permissionMode,
-      systemPromptBuilder: buildSystemPrompt,
       promptForApproval
     });
     const response = await session.run(prompt);