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

package/dist/node/chunk-C56WFH5S.js

@@ -0,0 +1,1163 @@
+// src/cli.ts
+import { parseArgs } from "util";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { fileURLToPath } from "url";
+import * as readline from "readline";
+import {
+  loadConfig,
+  loadContext,
+  detectProject,
+  Session as Session2,
+  SessionStore,
+  buildSystemPrompt
+} from "@robota-sdk/agent-sdk";
+
+// src/permissions/permission-prompt.ts
+import chalk from "chalk";
+var PERMISSION_OPTIONS = ["Allow", "Deny"];
+var ALLOW_INDEX = 0;
+function formatArgs(toolArgs) {
+  const entries = Object.entries(toolArgs);
+  if (entries.length === 0) {
+    return "(no arguments)";
+  }
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+async function promptForApproval(terminal, toolName, toolArgs) {
+  terminal.writeLine("");
+  terminal.writeLine(chalk.yellow(`[Permission Required] Tool: ${toolName}`));
+  terminal.writeLine(chalk.dim(`  ${formatArgs(toolArgs)}`));
+  terminal.writeLine("");
+  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
+  return selected === ALLOW_INDEX;
+}
+
+// src/ui/render.tsx
+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";
+
+// src/commands/command-registry.ts
+var CommandRegistry = class {
+  sources = [];
+  addSource(source) {
+    this.sources.push(source);
+  }
+  /** Get all commands, optionally filtered by prefix */
+  getCommands(filter) {
+    const all = [];
+    for (const source of this.sources) {
+      all.push(...source.getCommands());
+    }
+    if (!filter) return all;
+    const lower = filter.toLowerCase();
+    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
+  }
+  /** Get subcommands for a specific command */
+  getSubcommands(commandName) {
+    const lower = commandName.toLowerCase();
+    for (const source of this.sources) {
+      for (const cmd of source.getCommands()) {
+        if (cmd.name.toLowerCase() === lower && cmd.subcommands) {
+          return cmd.subcommands;
+        }
+      }
+    }
+    return [];
+  }
+};
+
+// src/commands/builtin-source.ts
+function createBuiltinCommands() {
+  return [
+    { name: "help", description: "Show available commands", source: "builtin" },
+    { name: "clear", description: "Clear conversation history", source: "builtin" },
+    {
+      name: "mode",
+      description: "Permission mode",
+      source: "builtin",
+      subcommands: [
+        { name: "plan", description: "Plan only, no execution", source: "builtin" },
+        { name: "default", description: "Ask before risky actions", source: "builtin" },
+        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
+        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
+      ]
+    },
+    {
+      name: "model",
+      description: "Select AI model",
+      source: "builtin",
+      subcommands: [
+        { name: "claude-opus-4-6", description: "Opus 4.6 (highest quality)", source: "builtin" },
+        { name: "claude-sonnet-4-6", description: "Sonnet 4.6 (balanced)", source: "builtin" },
+        { name: "claude-haiku-4-5", description: "Haiku 4.5 (fastest)", source: "builtin" }
+      ]
+    },
+    { name: "compact", description: "Compress context window", source: "builtin" },
+    { name: "cost", description: "Show session info", source: "builtin" },
+    { name: "context", description: "Context window info", source: "builtin" },
+    { name: "permissions", description: "Permission rules", source: "builtin" },
+    { name: "exit", description: "Exit CLI", source: "builtin" }
+  ];
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor() {
+    this.commands = createBuiltinCommands();
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+
+// src/commands/skill-source.ts
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  let name = "";
+  let description = "";
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const nameMatch = line.match(/^name:\s*(.+)/);
+    if (nameMatch) {
+      name = nameMatch[1].trim();
+      continue;
+    }
+    const descMatch = line.match(/^description:\s*(.+)/);
+    if (descMatch) {
+      description = descMatch[1].trim();
+    }
+  }
+  return name ? { name, description } : null;
+}
+function scanSkillsDir(skillsDir) {
+  if (!existsSync(skillsDir)) return [];
+  const commands = [];
+  const entries = readdirSync(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    const content = readFileSync(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    commands.push({
+      name: frontmatter?.name ?? entry.name,
+      description: frontmatter?.description ?? `Skill: ${entry.name}`,
+      source: "skill"
+    });
+  }
+  return commands;
+}
+var SkillCommandSource = class {
+  name = "skill";
+  cwd;
+  cachedCommands = null;
+  constructor(cwd) {
+    this.cwd = cwd;
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const projectSkills = scanSkillsDir(join(this.cwd, ".agents", "skills"));
+    const userSkills = scanSkillsDir(join(homedir(), ".claude", "skills"));
+    const seen = new Set(projectSkills.map((cmd) => cmd.name));
+    const merged = [...projectSkills];
+    for (const cmd of userSkills) {
+      if (!seen.has(cmd.name)) {
+        merged.push(cmd);
+      }
+    }
+    this.cachedCommands = merged;
+    return this.cachedCommands;
+  }
+};
+
+// src/ui/MessageList.tsx
+import { Box, Text } from "ink";
+
+// src/ui/render-markdown.ts
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+function renderMarkdown(md) {
+  const result = marked.parse(md);
+  return typeof result === "string" ? result.trimEnd() : md;
+}
+
+// src/ui/MessageList.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function RoleLabel({ role }) {
+  switch (role) {
+    case "user":
+      return /* @__PURE__ */ jsxs(Text, { color: "green", bold: true, children: [
+        "You:",
+        " "
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs(Text, { color: "cyan", bold: true, children: [
+        "Robota:",
+        " "
+      ] });
+    case "system":
+      return /* @__PURE__ */ jsxs(Text, { color: "yellow", bold: true, children: [
+        "System:",
+        " "
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs(Text, { color: "magenta", bold: true, children: [
+        "Tool:",
+        " "
+      ] });
+  }
+}
+function MessageItem({ message }) {
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(RoleLabel, { role: message.role }),
+      message.toolName && /* @__PURE__ */ jsxs(Text, { color: "magenta", dimColor: true, children: [
+        "[",
+        message.toolName,
+        "]",
+        " "
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(Box, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text, { wrap: "wrap", children: message.role === "assistant" ? renderMarkdown(message.content) : message.content }) })
+  ] });
+}
+function MessageList({ messages }) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ jsx(MessageItem, { message: msg }, msg.id)) });
+}
+
+// src/ui/StatusBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var CONTEXT_YELLOW_THRESHOLD = 70;
+var CONTEXT_RED_THRESHOLD = 90;
+function getContextColor(percentage) {
+  if (percentage >= CONTEXT_RED_THRESHOLD) return "red";
+  if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
+  return "green";
+}
+function StatusBar({
+  permissionMode,
+  modelName,
+  sessionId: _sessionId,
+  messageCount,
+  isThinking,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens
+}) {
+  const contextColor = getContextColor(contextPercentage);
+  return /* @__PURE__ */ jsxs2(
+    Box2,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingLeft: 1,
+      paddingRight: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          /* @__PURE__ */ jsx2(Text2, { color: "cyan", bold: true, children: "Mode:" }),
+          " ",
+          /* @__PURE__ */ jsx2(Text2, { children: permissionMode }),
+          "  |  ",
+          /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: modelName }),
+          "  |  ",
+          /* @__PURE__ */ jsxs2(Text2, { color: contextColor, children: [
+            "Context: ",
+            Math.round(contextPercentage),
+            "% (",
+            (contextUsedTokens / 1e3).toFixed(1),
+            "k/",
+            (contextMaxTokens / 1e3).toFixed(0),
+            "k)"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2(Text2, { children: [
+          isThinking && /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: "Thinking... " }),
+          /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+            "msgs: ",
+            messageCount
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/ui/InputArea.tsx
+import React3, { useState as useState3, useCallback, useMemo } from "react";
+import { Box as Box4, Text as Text6, useInput as useInput2 } from "ink";
+
+// src/ui/CjkTextInput.tsx
+import { useRef, useState } from "react";
+import { Text as Text3, useInput, useCursor } from "ink";
+import stringWidth from "string-width";
+import chalk2 from "chalk";
+import { jsx as jsx3 } from "react/jsx-runtime";
+function CjkTextInput({
+  value,
+  onChange,
+  onSubmit,
+  placeholder = "",
+  focus = true,
+  showCursor = true
+}) {
+  const valueRef = useRef(value);
+  const cursorRef = useRef(value.length);
+  const [, forceRender] = useState(0);
+  const { setCursorPosition } = useCursor();
+  if (value !== valueRef.current) {
+    valueRef.current = value;
+    if (cursorRef.current > value.length) {
+      cursorRef.current = value.length;
+    }
+  }
+  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);
+        }
+        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;
+      }
+      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 });
+  }
+  return /* @__PURE__ */ jsx3(Text3, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
+}
+function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
+  if (!showCursor) {
+    return value.length > 0 ? value : placeholder ? chalk2.gray(placeholder) : "";
+  }
+  if (value.length === 0) {
+    if (placeholder.length > 0) {
+      return chalk2.inverse(placeholder[0]) + chalk2.gray(placeholder.slice(1));
+    }
+    return chalk2.inverse(" ");
+  }
+  const chars = [...value];
+  let rendered = "";
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i] ?? "";
+    rendered += i === cursorOffset ? chalk2.inverse(char) : char;
+  }
+  if (cursorOffset >= chars.length) {
+    rendered += chalk2.inverse(" ");
+  }
+  return rendered;
+}
+
+// src/ui/WaveText.tsx
+import { useState as useState2, useEffect } from "react";
+import { Text as Text4 } from "ink";
+import { jsx as jsx4 } from "react/jsx-runtime";
+var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
+var INTERVAL_MS = 400;
+var CHARS_PER_GROUP = 4;
+function WaveText({ text }) {
+  const [tick, setTick] = useState2(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setTick((prev) => prev + 1);
+    }, INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  const chars = [...text];
+  return /* @__PURE__ */ jsx4(Text4, { children: chars.map((char, i) => {
+    const group = Math.floor(i / CHARS_PER_GROUP);
+    const colorIndex = (tick + group) % WAVE_COLORS.length;
+    return /* @__PURE__ */ jsx4(Text4, { color: WAVE_COLORS[colorIndex], children: char }, i);
+  }) });
+}
+
+// src/ui/SlashAutocomplete.tsx
+import { Box as Box3, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var MAX_VISIBLE = 8;
+function CommandRow(props) {
+  const { cmd, isSelected, showSlash } = props;
+  const prefix = showSlash ? "/" : "";
+  const indicator = isSelected ? "\u25B8 " : "  ";
+  const nameColor = isSelected ? "cyan" : void 0;
+  const dimmed = !isSelected;
+  return /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsxs3(Text5, { color: nameColor, dimColor: dimmed, children: [
+      indicator,
+      prefix,
+      cmd.name
+    ] }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: dimmed, children: "  " }),
+    /* @__PURE__ */ jsx5(Text5, { color: nameColor, dimColor: dimmed, children: cmd.description })
+  ] });
+}
+function SlashAutocomplete({
+  commands,
+  selectedIndex,
+  visible,
+  isSubcommandMode
+}) {
+  if (!visible || commands.length === 0) return null;
+  const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
+  const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
+  return /* @__PURE__ */ jsx5(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx5(
+    CommandRow,
+    {
+      cmd,
+      isSelected: scrollOffset + i === selectedIndex,
+      showSlash: !isSubcommandMode
+    },
+    cmd.name
+  )) });
+}
+function computeScrollOffset(selectedIndex, total) {
+  if (total <= MAX_VISIBLE) return 0;
+  if (selectedIndex < MAX_VISIBLE) return 0;
+  const maxOffset = total - MAX_VISIBLE;
+  return Math.min(selectedIndex - MAX_VISIBLE + 1, maxOffset);
+}
+
+// src/ui/InputArea.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+function parseSlashInput(value) {
+  if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
+  const afterSlash = value.slice(1);
+  const spaceIndex = afterSlash.indexOf(" ");
+  if (spaceIndex === -1) return { isSlash: true, parentCommand: "", filter: afterSlash };
+  const parent = afterSlash.slice(0, spaceIndex);
+  const rest = afterSlash.slice(spaceIndex + 1);
+  return { isSlash: true, parentCommand: parent, filter: rest };
+}
+function useAutocomplete(value, registry) {
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [dismissed, setDismissed] = useState3(false);
+  const prevValueRef = React3.useRef(value);
+  if (prevValueRef.current !== value) {
+    prevValueRef.current = value;
+    if (dismissed) setDismissed(false);
+  }
+  const parsed = parseSlashInput(value);
+  const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
+  const filteredCommands = useMemo(() => {
+    if (!registry || !parsed.isSlash || dismissed) return [];
+    if (isSubcommandMode) {
+      const subs = registry.getSubcommands(parsed.parentCommand);
+      if (subs.length === 0) return [];
+      if (!parsed.filter) return subs;
+      const lower = parsed.filter.toLowerCase();
+      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
+    }
+    return registry.getCommands(parsed.filter);
+  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
+  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
+  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
+    setSelectedIndex(filteredCommands.length - 1);
+  }
+  return {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup: (val) => {
+      if (typeof val === "function") {
+        setDismissed((prev) => {
+          const nextVal = val(!prev);
+          return !nextVal;
+        });
+      } else {
+        setDismissed(!val);
+      }
+    }
+  };
+}
+function InputArea({ onSubmit, isDisabled, registry }) {
+  const [value, setValue] = useState3("");
+  const {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup
+  } = useAutocomplete(value, registry);
+  const handleSubmit = useCallback(
+    (text) => {
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return;
+      if (showPopup && filteredCommands[selectedIndex]) {
+        selectCommand(filteredCommands[selectedIndex]);
+        return;
+      }
+      setValue("");
+      onSubmit(trimmed);
+    },
+    [showPopup, filteredCommands, selectedIndex, onSubmit]
+  );
+  const selectCommand = useCallback(
+    (cmd) => {
+      const parsed = parseSlashInput(value);
+      if (parsed.parentCommand) {
+        const fullCommand = `/${parsed.parentCommand} ${cmd.name}`;
+        setValue("");
+        onSubmit(fullCommand);
+        return;
+      }
+      if (cmd.subcommands && cmd.subcommands.length > 0) {
+        setValue(`/${cmd.name} `);
+        setSelectedIndex(0);
+        return;
+      }
+      setValue("");
+      onSubmit(`/${cmd.name}`);
+    },
+    [value, onSubmit, setSelectedIndex]
+  );
+  useInput2(
+    (_input, key) => {
+      if (!showPopup) return;
+      if (key.upArrow) {
+        setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredCommands.length - 1);
+      } else if (key.downArrow) {
+        setSelectedIndex((prev) => prev < filteredCommands.length - 1 ? prev + 1 : 0);
+      } else if (key.escape) {
+        setShowPopup(false);
+      } else if (key.tab) {
+        const cmd = filteredCommands[selectedIndex];
+        if (cmd) selectCommand(cmd);
+      }
+    },
+    { isActive: showPopup && !isDisabled }
+  );
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx6(
+      SlashAutocomplete,
+      {
+        commands: filteredCommands,
+        selectedIndex,
+        visible: showPopup,
+        isSubcommandMode
+      }
+    ),
+    /* @__PURE__ */ jsx6(Box4, { borderStyle: "single", borderColor: isDisabled ? "gray" : "green", paddingLeft: 1, children: isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response..." }) : /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx6(
+        CjkTextInput,
+        {
+          value,
+          onChange: setValue,
+          onSubmit: handleSubmit,
+          placeholder: "Type a message or /help"
+        }
+      )
+    ] }) })
+  ] });
+}
+
+// src/ui/PermissionPrompt.tsx
+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"];
+function formatArgs2(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "(no arguments)";
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+function PermissionPrompt({ request }) {
+  const [selected, setSelected] = React4.useState(0);
+  const resolvedRef = React4.useRef(false);
+  const prevRequestRef = React4.useRef(request);
+  if (prevRequestRef.current !== request) {
+    prevRequestRef.current = request;
+    resolvedRef.current = false;
+    setSelected(0);
+  }
+  const doResolve = React4.useCallback(
+    (allowed) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      request.resolve(allowed);
+    },
+    [request]
+  );
+  useInput3((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.upArrow || key.leftArrow) {
+      setSelected((prev) => prev > 0 ? prev - 1 : prev);
+    } 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);
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text7, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs5(Text7, { children: [
+      "Tool:",
+      " ",
+      /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: true, children: request.toolName })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
+      " ",
+      formatArgs2(request.toolArgs)
+    ] }),
+    /* @__PURE__ */ jsx7(Box5, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ jsx7(Box5, { marginRight: 2, children: /* @__PURE__ */ jsxs5(Text7, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " left/right to select, Enter to confirm" })
+  ] });
+}
+
+// src/ui/App.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var msgIdCounter = 0;
+function nextId() {
+  msgIdCounter += 1;
+  return `msg_${msgIdCounter}`;
+}
+var NOOP_TERMINAL = {
+  write: () => {
+  },
+  writeLine: () => {
+  },
+  writeMarkdown: () => {
+  },
+  writeError: () => {
+  },
+  prompt: () => Promise.resolve(""),
+  select: () => Promise.resolve(0),
+  spinner: () => ({ stop: () => {
+  }, update: () => {
+  } })
+};
+function useSession(props) {
+  const [permissionRequest, setPermissionRequest] = useState4(null);
+  const [streamingText, setStreamingText] = useState4("");
+  const permissionQueueRef = useRef2([]);
+  const processingRef = useRef2(false);
+  const processNextPermission = useCallback2(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (allowed) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(allowed);
+        setTimeout(() => processNextPermission(), 0);
+      }
+    });
+  }, []);
+  const sessionRef = useRef2(null);
+  if (sessionRef.current === null) {
+    const permissionHandler = (toolName, toolArgs) => {
+      return new Promise((resolve) => {
+        permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+        processNextPermission();
+      });
+    };
+    const onTextDelta = (delta) => {
+      setStreamingText((prev) => prev + delta);
+    };
+    sessionRef.current = new Session({
+      config: props.config,
+      context: props.context,
+      terminal: NOOP_TERMINAL,
+      projectInfo: props.projectInfo,
+      sessionStore: props.sessionStore,
+      permissionMode: props.permissionMode,
+      maxTurns: props.maxTurns,
+      permissionHandler,
+      onTextDelta
+    });
+  }
+  const clearStreamingText = useCallback2(() => setStreamingText(""), []);
+  return { session: sessionRef.current, permissionRequest, streamingText, clearStreamingText };
+}
+function useMessages() {
+  const [messages, setMessages] = useState4([]);
+  const addMessage = useCallback2((msg) => {
+    setMessages((prev) => [...prev, { ...msg, id: nextId(), timestamp: /* @__PURE__ */ new Date() }]);
+  }, []);
+  return { messages, setMessages, addMessage };
+}
+var HELP_TEXT = [
+  "Available commands:",
+  "  /help              \u2014 Show this help",
+  "  /clear             \u2014 Clear conversation",
+  "  /compact [instr]   \u2014 Compact context (optional focus instructions)",
+  "  /mode [m]          \u2014 Show/change permission mode",
+  "  /cost              \u2014 Show session info",
+  "  /exit              \u2014 Exit CLI"
+].join("\n");
+function handleModeCommand(arg, session, addMessage) {
+  const validModes = ["plan", "default", "acceptEdits", "bypassPermissions"];
+  if (!arg) {
+    addMessage({ role: "system", content: `Current mode: ${session.getPermissionMode()}` });
+  } else if (validModes.includes(arg)) {
+    session.setPermissionMode(arg);
+    addMessage({ role: "system", content: `Permission mode set to: ${arg}` });
+  } else {
+    addMessage({ role: "system", content: `Invalid mode. Valid: ${validModes.join(" | ")}` });
+  }
+  return true;
+}
+async function executeSlashCommand(cmd, parts, session, addMessage, setMessages, exit, registry) {
+  switch (cmd) {
+    case "help":
+      addMessage({ role: "system", content: HELP_TEXT });
+      return true;
+    case "clear":
+      setMessages([]);
+      session.clearHistory();
+      addMessage({ role: "system", content: "Conversation cleared." });
+      return true;
+    case "compact": {
+      const instructions = parts.slice(1).join(" ").trim() || void 0;
+      const before = session.getContextState().usedPercentage;
+      addMessage({ role: "system", content: "Compacting context..." });
+      await session.compact(instructions);
+      const after = session.getContextState().usedPercentage;
+      addMessage({
+        role: "system",
+        content: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`
+      });
+      return true;
+    }
+    case "mode":
+      return handleModeCommand(parts[1], session, addMessage);
+    case "cost":
+      addMessage({
+        role: "system",
+        content: `Session: ${session.getSessionId()}
+Messages: ${session.getMessageCount()}`
+      });
+      return true;
+    case "exit":
+      exit();
+      return true;
+    default: {
+      const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
+      if (skillCmd) {
+        addMessage({ role: "system", content: `Invoking skill: ${cmd}` });
+        return false;
+      }
+      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
+      return true;
+    }
+  }
+}
+function useSlashCommands(session, addMessage, setMessages, exit, registry) {
+  return useCallback2(
+    async (input) => {
+      const parts = input.slice(1).split(/\s+/);
+      const cmd = parts[0]?.toLowerCase() ?? "";
+      return executeSlashCommand(cmd, parts, session, addMessage, setMessages, exit, registry);
+    },
+    [session, addMessage, setMessages, exit, registry]
+  );
+}
+function StreamingIndicator({ text }) {
+  if (text) {
+    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs6(Text8, { color: "cyan", bold: true, children: [
+        "Robota:",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx8(Text8, { children: " " }),
+      /* @__PURE__ */ jsx8(Box6, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsx8(Text8, { color: "yellow", children: "Thinking..." });
+}
+async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextPercentage) {
+  setIsThinking(true);
+  clearStreamingText();
+  try {
+    const response = await session.run(prompt);
+    clearStreamingText();
+    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}` });
+  } finally {
+    setIsThinking(false);
+  }
+}
+function buildSkillPrompt(input, registry) {
+  const parts = input.slice(1).split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  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}`;
+}
+function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextPercentage, registry) {
+  return useCallback2(
+    async (input) => {
+      if (input.startsWith("/")) {
+        const handled = await handleSlashCommand(input);
+        if (handled) {
+          setContextPercentage(session.getContextState().usedPercentage);
+          return;
+        }
+        const prompt = buildSkillPrompt(input, registry);
+        if (!prompt) return;
+        return runSessionPrompt(
+          prompt,
+          session,
+          addMessage,
+          clearStreamingText,
+          setIsThinking,
+          setContextPercentage
+        );
+      }
+      addMessage({ role: "user", content: input });
+      return runSessionPrompt(
+        input,
+        session,
+        addMessage,
+        clearStreamingText,
+        setIsThinking,
+        setContextPercentage
+      );
+    },
+    [
+      session,
+      addMessage,
+      handleSlashCommand,
+      clearStreamingText,
+      setIsThinking,
+      setContextPercentage,
+      registry
+    ]
+  );
+}
+function useCommandRegistry(cwd) {
+  const registryRef = useRef2(null);
+  if (registryRef.current === null) {
+    const registry = new CommandRegistry();
+    registry.addSource(new BuiltinCommandSource());
+    registry.addSource(new SkillCommandSource(cwd));
+    registryRef.current = registry;
+  }
+  return registryRef.current;
+}
+function App(props) {
+  const { exit } = useApp();
+  const { session, permissionRequest, streamingText, clearStreamingText } = useSession(props);
+  const { messages, setMessages, addMessage } = useMessages();
+  const [isThinking, setIsThinking] = useState4(false);
+  const [contextPercentage, setContextPercentage] = useState4(0);
+  const registry = useCommandRegistry(props.cwd ?? process.cwd());
+  const handleSlashCommand = useSlashCommands(session, addMessage, setMessages, exit, registry);
+  const handleSubmit = useSubmitHandler(
+    session,
+    addMessage,
+    handleSlashCommand,
+    clearStreamingText,
+    setIsThinking,
+    setContextPercentage,
+    registry
+  );
+  useInput4(
+    (_input, key) => {
+      if (key.ctrl && _input === "c") exit();
+    },
+    { isActive: !permissionRequest && !isThinking }
+  );
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: true, children: `
+  ____   ___  ____   ___ _____  _
+ |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
+ | |_) | | | |  _ \\| | | || | / _ \\
+ |  _ <| |_| | |_) | |_| || |/ ___ \\
+ |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
+` }),
+      /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
+        " v",
+        props.version ?? "0.0.0"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx8(MessageList, { messages }),
+      isThinking && /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx8(StreamingIndicator, { text: streamingText }) })
+    ] }),
+    permissionRequest && /* @__PURE__ */ jsx8(PermissionPrompt, { request: permissionRequest }),
+    /* @__PURE__ */ jsx8(
+      StatusBar,
+      {
+        permissionMode: session.getPermissionMode(),
+        modelName: props.config.provider.model,
+        sessionId: session.getSessionId(),
+        messageCount: messages.length,
+        isThinking,
+        contextPercentage,
+        contextUsedTokens: session.getContextState().usedTokens,
+        contextMaxTokens: session.getContextState().maxTokens
+      }
+    ),
+    /* @__PURE__ */ jsx8(
+      InputArea,
+      {
+        onSubmit: handleSubmit,
+        isDisabled: isThinking || !!permissionRequest,
+        registry
+      }
+    )
+  ] });
+}
+
+// src/ui/render.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function renderApp(options) {
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`
+[UNHANDLED REJECTION] ${reason}
+`);
+    if (reason instanceof Error) {
+      process.stderr.write(`${reason.stack}
+`);
+    }
+  });
+  const instance = render(/* @__PURE__ */ jsx9(App, { ...options }), {
+    exitOnCtrlC: true
+  });
+  instance.waitUntilExit().catch((err) => {
+    if (err) {
+      process.stderr.write(`
+[EXIT ERROR] ${err}
+`);
+    }
+  });
+}
+
+// src/cli.ts
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function readVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const dir = dirname(thisFile);
+    const candidates = [join2(dir, "..", "..", "package.json"), join2(dir, "..", "package.json")];
+    for (const pkgPath of candidates) {
+      try {
+        const raw = readFileSync2(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version !== void 0 && pkg.name !== void 0) {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function parsePermissionMode(raw) {
+  if (raw === void 0) return void 0;
+  if (!VALID_MODES.includes(raw)) {
+    process.stderr.write(`Invalid --permission-mode "${raw}". Valid: ${VALID_MODES.join(" | ")}
+`);
+    process.exit(1);
+  }
+  return raw;
+}
+function parseMaxTurns(raw) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    process.stderr.write(`Invalid --max-turns "${raw}". Must be a positive integer.
+`);
+    process.exit(1);
+  }
+  return n;
+}
+function parseCliArgs() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      p: { type: "boolean", short: "p", default: false },
+      c: { type: "boolean", short: "c", default: false },
+      r: { type: "string", short: "r" },
+      model: { type: "string" },
+      "permission-mode": { type: "string" },
+      "max-turns": { type: "string" },
+      version: { type: "boolean", default: false }
+    }
+  });
+  return {
+    positional: positionals,
+    printMode: values["p"] ?? false,
+    continueMode: values["c"] ?? false,
+    resumeId: values["r"],
+    model: values["model"],
+    permissionMode: parsePermissionMode(values["permission-mode"]),
+    maxTurns: parseMaxTurns(values["max-turns"]),
+    version: values["version"] ?? false
+  };
+}
+var PrintTerminal = class {
+  write(text) {
+    process.stdout.write(text);
+  }
+  writeLine(text) {
+    process.stdout.write(text + "\n");
+  }
+  writeMarkdown(md) {
+    process.stdout.write(md);
+  }
+  writeError(text) {
+    process.stderr.write(text + "\n");
+  }
+  prompt(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+        historySize: 0
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+  async select(options, initialIndex = 0) {
+    for (let i = 0; i < options.length; i++) {
+      const marker = i === initialIndex ? ">" : " ";
+      process.stdout.write(`  ${marker} ${i + 1}) ${options[i]}
+`);
+    }
+    const answer = await this.prompt(
+      `  Choose [1-${options.length}] (default: ${options[initialIndex]}): `
+    );
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "") return initialIndex;
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
+    return initialIndex;
+  }
+  spinner(_message) {
+    return { stop() {
+    }, update() {
+    } };
+  }
+};
+async function startCli() {
+  const args = parseCliArgs();
+  if (args.version) {
+    process.stdout.write(`robota ${readVersion()}
+`);
+    return;
+  }
+  const cwd = process.cwd();
+  const [config, context, projectInfo] = await Promise.all([
+    loadConfig(cwd),
+    loadContext(cwd),
+    detectProject(cwd)
+  ]);
+  if (args.model !== void 0) {
+    config.provider.model = args.model;
+  }
+  const sessionStore = new SessionStore();
+  if (args.printMode) {
+    const prompt = args.positional.join(" ").trim();
+    if (prompt.length === 0) {
+      process.stderr.write("Print mode (-p) requires a prompt argument.\n");
+      process.exit(1);
+    }
+    const terminal = new PrintTerminal();
+    const session = new Session2({
+      config,
+      context,
+      terminal,
+      projectInfo,
+      permissionMode: args.permissionMode,
+      systemPromptBuilder: buildSystemPrompt,
+      promptForApproval
+    });
+    const response = await session.run(prompt);
+    process.stdout.write(response + "\n");
+    return;
+  }
+  renderApp({
+    config,
+    context,
+    projectInfo,
+    sessionStore,
+    permissionMode: args.permissionMode,
+    maxTurns: args.maxTurns,
+    version: readVersion()
+  });
+}
+
+export {
+  startCli
+};