@poncho-ai/cli 0.2.0

package/dist/run-interactive-ink-R5W3ZEMY.js

@@ -0,0 +1,818 @@
+// src/run-interactive-ink.ts
+import { access, mkdir, readFile, writeFile } from "fs/promises";
+import { resolve } from "path";
+import { render } from "ink";
+import { createElement } from "react";
+import { parseAgentFile } from "@agentl/harness";
+
+// src/interactive-ink.tsx
+import { memo, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
+import { ScrollView as RawScrollView } from "ink-scroll-view";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ScrollView = RawScrollView;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var MAX_PERSISTED_LINES = 500;
+var MAX_PERSISTED_TIMELINE = 200;
+var STREAM_FLUSH_MS = 33;
+var INPUT_FLUSH_MS = 33;
+var MOUSE_SEQUENCE_FRAGMENT_PATTERN = /^\[?<\d+(;\d+){0,2}[mM]?$/;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var randomId = () => `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
+var colorForKind = (kind) => {
+  if (kind === "user") return "cyan";
+  if (kind === "assistant") return "green";
+  if (kind === "tool") return "yellow";
+  if (kind === "warning") return "magenta";
+  if (kind === "error") return "red";
+  return "gray";
+};
+var stringifyValue = (value) => {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+var truncate = (value, maxLength) => value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+var compactPreview = (value, maxLength = 120) => truncate(stringifyValue(value).replace(/\s+/g, " "), maxLength);
+var withLimit = (items, max) => items.length <= max ? items : items.slice(items.length - max);
+var toUiLineEntries = (kind, text, turn) => text.split(/\r?\n/).map((lineText) => ({
+  id: randomId(),
+  kind,
+  text: lineText,
+  turn,
+  timestamp: Date.now()
+}));
+var createInitialLines = () => [
+  {
+    id: randomId(),
+    kind: "meta",
+    text: "AgentL Interactive (Ink) - full screen mode",
+    turn: 0,
+    timestamp: Date.now()
+  },
+  {
+    id: randomId(),
+    kind: "meta",
+    text: "Enter to send | Alt+Enter newline | /help for commands",
+    turn: 0,
+    timestamp: Date.now()
+  }
+];
+var HeaderBar = memo(function HeaderBar2({ text }) {
+  return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: "cyan", children: text }) });
+});
+var InputBar = memo(function InputBar2({
+  inputHeight,
+  inputPreview,
+  cursorVisible
+}) {
+  const cursor = cursorVisible ? "\u2588" : " ";
+  return /* @__PURE__ */ jsx(Box, { height: inputHeight, paddingLeft: 1, children: /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+    "you> ",
+    inputPreview,
+    cursor
+  ] }) });
+});
+var StatusBar = memo(function StatusBar2({
+  notice,
+  runStateText,
+  scrollOffset,
+  pendingApproval
+}) {
+  const scrollHint = scrollOffset > 0 ? ` | \u2191 scrolled ${scrollOffset}` : "";
+  if (pendingApproval) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs(Text, { color: "yellow", bold: true, children: [
+        'Tool "',
+        pendingApproval.tool,
+        '" requires approval \u2014 press Y to approve, N to deny'
+      ] }),
+      /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+        "input: ",
+        compactPreview(pendingApproval.input, 100)
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs(Text, { color: notice ? colorForKind(notice.kind) : "gray", children: [
+      notice ? notice.text : runStateText,
+      scrollHint
+    ] }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "Ctrl+L clear | Ctrl+R resend | Ctrl+S toggle mouse/select | Ctrl+U/D scroll | Ctrl+O tools" })
+  ] });
+});
+var InteractiveInkApp = ({
+  harness,
+  params,
+  metadata,
+  initialSnapshot,
+  persistenceEnabled,
+  onPersist,
+  onSetApprovalCallback
+}) => {
+  const { exit } = useApp();
+  const [dimensions, setDimensions] = useState({
+    columns: process.stdout.columns ?? 120,
+    rows: process.stdout.rows ?? 40
+  });
+  const [input, setInput] = useState("");
+  const [lines, setLines] = useState(
+    initialSnapshot?.lines?.length ? initialSnapshot.lines : createInitialLines()
+  );
+  const [timeline, setTimeline] = useState(initialSnapshot?.timeline ?? []);
+  const [isRunning, setIsRunning] = useState(false);
+  const [streamingText, setStreamingText] = useState("");
+  const [showToolPayloads, setShowToolPayloads] = useState(false);
+  const [notice, setNotice] = useState();
+  const [scrollInfo, setScrollInfo] = useState(0);
+  const scrollRef = useRef(null);
+  const autoScrollRef = useRef(true);
+  const [toolState, setToolState] = useState({ state: "idle" });
+  const messagesRef = useRef(initialSnapshot?.messages ?? []);
+  const turnRef = useRef(initialSnapshot?.nextTurn ?? 1);
+  const lastPromptRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const persistTimer = useRef();
+  const streamBufferRef = useRef("");
+  const streamFlushRef = useRef();
+  const inputBufferRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const inputFlushRef = useRef();
+  const [cursorVisible, setCursorVisible] = useState(true);
+  const [pendingApproval, setPendingApproval] = useState(null);
+  useEffect(() => {
+    if (onSetApprovalCallback) {
+      onSetApprovalCallback((req) => {
+        setPendingApproval(req);
+      });
+    }
+  }, [onSetApprovalCallback]);
+  useEffect(() => {
+    const onResize = () => {
+      setDimensions({
+        columns: process.stdout.columns ?? 120,
+        rows: process.stdout.rows ?? 40
+      });
+      scrollRef.current?.remeasure();
+    };
+    process.stdout.on("resize", onResize);
+    return () => {
+      process.stdout.off("resize", onResize);
+    };
+  }, []);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setCursorVisible((current) => !current);
+    }, 500);
+    return () => clearInterval(timer);
+  }, []);
+  const [mouseEnabled, setMouseEnabled] = useState(true);
+  const mouseEnabledRef = useRef(true);
+  const pasteBufferRef = useRef(null);
+  useEffect(() => {
+    const stdout = process.stdout;
+    const stdin = process.stdin;
+    const enableMouse = () => {
+      stdout.write("\x1B[?1000h\x1B[?1006h");
+    };
+    const disableMouse = () => {
+      stdout.write("\x1B[?1000l\x1B[?1006l");
+    };
+    const enableBracketPaste = () => {
+      stdout.write("\x1B[?2004h");
+    };
+    const disableBracketPaste = () => {
+      stdout.write("\x1B[?2004l");
+    };
+    const PASTE_START = "\x1B[200~";
+    const PASTE_END = "\x1B[201~";
+    const onData = (chunk) => {
+      const value = chunk.toString("utf8");
+      if (pasteBufferRef.current !== null) {
+        const endIdx = value.indexOf(PASTE_END);
+        if (endIdx >= 0) {
+          pasteBufferRef.current += value.slice(0, endIdx);
+          inputBufferRef.current += pasteBufferRef.current;
+          pasteBufferRef.current = null;
+          setInput(inputBufferRef.current);
+        } else {
+          pasteBufferRef.current += value;
+        }
+        return;
+      }
+      const startIdx = value.indexOf(PASTE_START);
+      if (startIdx >= 0) {
+        const afterStart = value.slice(startIdx + PASTE_START.length);
+        const endIdx = afterStart.indexOf(PASTE_END);
+        if (endIdx >= 0) {
+          const pasted = afterStart.slice(0, endIdx);
+          inputBufferRef.current += pasted;
+          setInput(inputBufferRef.current);
+        } else {
+          pasteBufferRef.current = afterStart;
+        }
+        return;
+      }
+      if (!mouseEnabledRef.current) {
+        return;
+      }
+      const matches = [...value.matchAll(/\u001B\[<(\d+);(\d+);(\d+)([mM])/g)];
+      if (matches.length === 0) {
+        return;
+      }
+      for (const match of matches) {
+        const button = Number(match[1] ?? -1);
+        if (button === 64) {
+          scrollRef.current?.scrollBy(-1);
+          autoScrollRef.current = false;
+        } else if (button === 65) {
+          scrollRef.current?.scrollBy(1);
+          const sv = scrollRef.current;
+          if (sv && sv.getScrollOffset() >= sv.getBottomOffset()) {
+            autoScrollRef.current = true;
+          }
+        }
+      }
+    };
+    enableMouse();
+    enableBracketPaste();
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
+      disableMouse();
+      disableBracketPaste();
+    };
+  }, []);
+  useEffect(() => {
+    mouseEnabledRef.current = mouseEnabled;
+    if (mouseEnabled) {
+      process.stdout.write("\x1B[?1000h\x1B[?1006h");
+    } else {
+      process.stdout.write("\x1B[?1000l\x1B[?1006l");
+    }
+  }, [mouseEnabled]);
+  const persistSnapshot = useCallback(() => {
+    if (!persistenceEnabled || !onPersist) {
+      return;
+    }
+    if (persistTimer.current) {
+      clearTimeout(persistTimer.current);
+    }
+    persistTimer.current = setTimeout(() => {
+      void onPersist({
+        messages: messagesRef.current,
+        lines: withLimit(lines, MAX_PERSISTED_LINES),
+        timeline: withLimit(timeline, MAX_PERSISTED_TIMELINE),
+        nextTurn: turnRef.current,
+        lastPrompt: lastPromptRef.current
+      }).catch(() => {
+      });
+    }, 60);
+  }, [lines, onPersist, persistenceEnabled, timeline]);
+  const appendLine = useCallback((kind, text, turn) => {
+    const entries = toUiLineEntries(kind, text, turn);
+    setLines(
+      (previous) => withLimit(
+        [
+          ...previous,
+          ...entries
+        ],
+        MAX_PERSISTED_LINES
+      )
+    );
+  }, []);
+  const flushInputBuffer = useCallback(() => {
+    setInput(inputBufferRef.current);
+  }, []);
+  const queueInputFlush = useCallback(() => {
+    if (inputFlushRef.current) {
+      return;
+    }
+    inputFlushRef.current = setTimeout(() => {
+      inputFlushRef.current = void 0;
+      flushInputBuffer();
+    }, INPUT_FLUSH_MS);
+  }, [flushInputBuffer]);
+  const runSlashCommand = useCallback(
+    (command) => {
+      const normalized = command.trim().toLowerCase();
+      if (normalized === "/help") {
+        appendLine(
+          "meta",
+          "commands> /help /clear /sidebar /tools /export /exit",
+          Math.max(1, turnRef.current - 1)
+        );
+        return;
+      }
+      if (normalized === "/clear") {
+        setLines(createInitialLines());
+        setNotice({ kind: "meta", text: "Cleared scrollback." });
+        scrollRef.current?.scrollToTop();
+        autoScrollRef.current = true;
+        return;
+      }
+      if (normalized === "/sidebar") {
+        appendLine("meta", "sidebar> removed for now", Math.max(1, turnRef.current - 1));
+        return;
+      }
+      if (normalized === "/tools") {
+        setShowToolPayloads((value) => !value);
+        return;
+      }
+      if (normalized === "/export") {
+        appendLine(
+          "meta",
+          persistenceEnabled ? "export> session is saved to .agentl/interactive-session.json" : "export> session persistence is disabled (set AGENTL_INTERACTIVE_PERSIST=true)",
+          0
+        );
+        return;
+      }
+      if (normalized === "/exit") {
+        exit();
+        return;
+      }
+      setNotice({ kind: "warning", text: `Unknown command: ${command}` });
+    },
+    [appendLine, exit, persistenceEnabled]
+  );
+  const handleToolEvent = useCallback(
+    (event, turn) => {
+      if (event.type === "tool:started") {
+        const inputPreview2 = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+        setToolState({
+          tool: event.tool,
+          state: "started",
+          startedAt: Date.now(),
+          input: inputPreview2
+        });
+        appendLine("tool", `tools> start ${event.tool} input=${inputPreview2}`, turn);
+        return 1;
+      }
+      if (event.type === "tool:completed") {
+        const outputPreview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+        setToolState((current) => ({
+          ...current,
+          tool: event.tool,
+          state: "completed",
+          durationMs: event.duration,
+          output: outputPreview
+        }));
+        appendLine("tool", `tools> done  ${event.tool} in ${formatDuration(event.duration)}`, turn);
+        if (showToolPayloads) {
+          appendLine("tool", `tools> output ${outputPreview}`, turn);
+        }
+        return 0;
+      }
+      if (event.type === "tool:error") {
+        setToolState((current) => ({
+          ...current,
+          tool: event.tool,
+          state: "error",
+          error: event.error
+        }));
+        appendLine("error", `tools> error ${event.tool}: ${event.error}`, turn);
+        setNotice({ kind: "error", text: `Tool error on ${event.tool}` });
+      }
+      if (event.type === "tool:approval:required") {
+        appendLine("warning", `tools> approval required for ${event.tool}`, turn);
+      }
+      if (event.type === "tool:approval:granted") {
+        appendLine("meta", `tools> approval granted (${event.approvalId})`, turn);
+      }
+      if (event.type === "tool:approval:denied") {
+        appendLine("warning", `tools> approval denied (${event.approvalId})`, turn);
+      }
+      return 0;
+    },
+    [appendLine, showToolPayloads]
+  );
+  const runTurn = useCallback(
+    async (task) => {
+      if (isRunning) {
+        return;
+      }
+      setIsRunning(true);
+      setStreamingText("");
+      streamBufferRef.current = "";
+      const turn = turnRef.current;
+      turnRef.current = turn + 1;
+      const startedAt = Date.now();
+      setToolState({ state: "idle" });
+      setNotice(void 0);
+      lastPromptRef.current = task;
+      appendLine("meta", "", turn);
+      appendLine("meta", `--- turn ${turn} ---`, turn);
+      appendLine("meta", "", turn);
+      appendLine("user", `you> ${task}`, turn);
+      appendLine("meta", "", turn);
+      let responseText = "";
+      let streamedText = "";
+      let committedText = false;
+      let sawChunk = false;
+      let toolEvents = 0;
+      let runFailed = false;
+      let usage;
+      try {
+        const flushStreamBuffer = () => {
+          if (streamBufferRef.current.length === 0) {
+            return;
+          }
+          setStreamingText(streamBufferRef.current);
+        };
+        const queueStreamFlush = () => {
+          if (streamFlushRef.current) {
+            return;
+          }
+          streamFlushRef.current = setTimeout(() => {
+            streamFlushRef.current = void 0;
+            flushStreamBuffer();
+          }, STREAM_FLUSH_MS);
+        };
+        for await (const event of harness.run({
+          task,
+          parameters: params,
+          messages: messagesRef.current
+        })) {
+          if (event.type === "model:chunk") {
+            sawChunk = true;
+            responseText += event.content;
+            streamedText += event.content;
+            streamBufferRef.current = streamedText;
+            queueStreamFlush();
+          } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+            if (streamedText.length > 0) {
+              if (streamFlushRef.current) {
+                clearTimeout(streamFlushRef.current);
+                streamFlushRef.current = void 0;
+              }
+              appendLine("assistant", `assistant> ${streamedText}`, turn);
+              committedText = true;
+              streamedText = "";
+              streamBufferRef.current = "";
+              setStreamingText("");
+            }
+            toolEvents += handleToolEvent(event, turn);
+          } else if (event.type === "run:error") {
+            runFailed = true;
+            appendLine("error", `error> ${event.error.message}`, turn);
+            setNotice({ kind: "error", text: event.error.message });
+          } else if (event.type === "model:response") {
+            usage = event.usage;
+          } else if (event.type === "run:completed" && !sawChunk) {
+            responseText = event.result.response ?? "";
+            streamBufferRef.current = responseText;
+            setStreamingText(responseText);
+          }
+        }
+        if (streamFlushRef.current) {
+          clearTimeout(streamFlushRef.current);
+          streamFlushRef.current = void 0;
+        }
+        flushStreamBuffer();
+      } catch (error) {
+        runFailed = true;
+        appendLine(
+          "error",
+          `error> ${error instanceof Error ? error.message : "Unknown error"}`,
+          turn
+        );
+        setNotice({
+          kind: "error",
+          text: error instanceof Error ? error.message : "Unknown error"
+        });
+      } finally {
+        if (streamFlushRef.current) {
+          clearTimeout(streamFlushRef.current);
+          streamFlushRef.current = void 0;
+        }
+        appendLine("meta", "", turn);
+        if (streamedText.length > 0) {
+          appendLine("assistant", `assistant> ${streamedText}`, turn);
+        } else if (!committedText && responseText.length > 0) {
+          appendLine("assistant", `assistant> ${responseText}`, turn);
+        } else if (!committedText) {
+          appendLine("assistant", "assistant> (no response)", turn);
+        }
+        appendLine("meta", "", turn);
+        const fullResponse = responseText || streamedText;
+        if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+          appendLine(
+            "warning",
+            "warning> assistant described tool execution but no real tool events occurred.",
+            turn
+          );
+          setNotice({
+            kind: "warning",
+            text: "Assistant described tool calls, but no real tool events occurred."
+          });
+        }
+        const durationMs = Date.now() - startedAt;
+        appendLine("meta", `meta> ${formatDuration(durationMs)} | tools: ${toolEvents}`, turn);
+        setTimeline(
+          (previous) => withLimit(
+            [
+              ...previous,
+              {
+                turn,
+                durationMs,
+                toolEvents,
+                status: runFailed ? "error" : "ok",
+                usage
+              }
+            ],
+            MAX_PERSISTED_TIMELINE
+          )
+        );
+        messagesRef.current = [
+          ...messagesRef.current,
+          { role: "user", content: task },
+          { role: "assistant", content: responseText }
+        ];
+        setStreamingText("");
+        streamBufferRef.current = "";
+        setIsRunning(false);
+        persistSnapshot();
+      }
+    },
+    [appendLine, handleToolEvent, harness, isRunning, params, persistSnapshot]
+  );
+  useEffect(
+    () => () => {
+      if (persistTimer.current) {
+        clearTimeout(persistTimer.current);
+      }
+      if (streamFlushRef.current) {
+        clearTimeout(streamFlushRef.current);
+      }
+      if (inputFlushRef.current) {
+        clearTimeout(inputFlushRef.current);
+      }
+    },
+    []
+  );
+  useInput((value, key) => {
+    if (MOUSE_SEQUENCE_FRAGMENT_PATTERN.test(value)) {
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "c" || value === "") {
+      exit();
+      return;
+    }
+    if (pendingApproval) {
+      const lower = value.toLowerCase();
+      if (lower === "y") {
+        appendLine("meta", `approval> approved ${pendingApproval.tool}`, turnRef.current);
+        pendingApproval.resolve(true);
+        setPendingApproval(null);
+        return;
+      }
+      if (lower === "n") {
+        appendLine("meta", `approval> denied ${pendingApproval.tool}`, turnRef.current);
+        pendingApproval.resolve(false);
+        setPendingApproval(null);
+        return;
+      }
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "l") {
+      setLines(createInitialLines());
+      setNotice({ kind: "meta", text: "Cleared scrollback." });
+      persistSnapshot();
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "r") {
+      if (lastPromptRef.current.trim().length > 0 && !isRunning) {
+        void runTurn(lastPromptRef.current);
+      }
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "o") {
+      setShowToolPayloads((current) => !current);
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "s") {
+      setMouseEnabled((current) => {
+        const next = !current;
+        setNotice({
+          kind: "meta",
+          text: next ? "Mouse scroll enabled (text selection disabled)" : "Mouse scroll disabled (text selection enabled)"
+        });
+        return next;
+      });
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "u") {
+      scrollRef.current?.scrollBy(-3);
+      autoScrollRef.current = false;
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "d") {
+      scrollRef.current?.scrollBy(3);
+      const sv = scrollRef.current;
+      if (sv && sv.getScrollOffset() >= sv.getBottomOffset()) {
+        autoScrollRef.current = true;
+      }
+      return;
+    }
+    if (key.pageUp) {
+      const height = scrollRef.current?.getViewportHeight() ?? 12;
+      scrollRef.current?.scrollBy(-height);
+      autoScrollRef.current = false;
+      return;
+    }
+    if (key.pageDown) {
+      const height = scrollRef.current?.getViewportHeight() ?? 12;
+      scrollRef.current?.scrollBy(height);
+      const sv = scrollRef.current;
+      if (sv && sv.getScrollOffset() >= sv.getBottomOffset()) {
+        autoScrollRef.current = true;
+      }
+      return;
+    }
+    if (key.return && (key.meta || key.shift)) {
+      inputBufferRef.current = `${inputBufferRef.current}
+`;
+      queueInputFlush();
+      return;
+    }
+    if (key.return) {
+      const task = inputBufferRef.current.trimEnd();
+      if (task.length === 0 || isRunning) {
+        return;
+      }
+      if (task.toLowerCase() === "exit") {
+        exit();
+        return;
+      }
+      if (task.startsWith("/")) {
+        inputBufferRef.current = "";
+        flushInputBuffer();
+        runSlashCommand(task);
+        persistSnapshot();
+        return;
+      }
+      inputBufferRef.current = "";
+      flushInputBuffer();
+      scrollRef.current?.scrollToBottom();
+      autoScrollRef.current = true;
+      void runTurn(task);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      inputBufferRef.current = inputBufferRef.current.slice(0, -1);
+      queueInputFlush();
+      return;
+    }
+    if (value.length > 0 && !key.ctrl) {
+      const cleaned = value.replace(/\u001B\[200~/g, "").replace(/\u001B\[201~/g, "").replace(/\u001B\[[0-9;]*[a-zA-Z]/g, "").replace(/\u001B/g, "");
+      if (cleaned.length === 0) return;
+      if (MOUSE_SEQUENCE_FRAGMENT_PATTERN.test(cleaned)) return;
+      inputBufferRef.current += cleaned;
+      queueInputFlush();
+    }
+  });
+  const { columns, rows } = dimensions;
+  const headerText = `agent: ${metadata.agentName} | provider: ${metadata.provider} | model: ${metadata.model} | env: ${metadata.environment}`;
+  const inputLines = input.split("\n");
+  const inputHeight = Math.max(3, Math.min(6, inputLines.length + 1));
+  const contentLines = useMemo(() => {
+    if (streamingText.length === 0) {
+      return lines;
+    }
+    const streamSegments = streamingText.split(/\r?\n/);
+    return [
+      ...lines,
+      ...streamSegments.map((segment, index) => ({
+        id: `streaming-live-${index}`,
+        kind: "assistant",
+        text: index === 0 ? `assistant> ${segment}` : segment,
+        turn: turnRef.current,
+        timestamp: Date.now()
+      }))
+    ];
+  }, [lines, streamingText]);
+  useEffect(() => {
+    if (!autoScrollRef.current) return;
+    const timer = setTimeout(() => {
+      scrollRef.current?.scrollToBottom();
+    }, 16);
+    return () => clearTimeout(timer);
+  }, [contentLines]);
+  const handleScroll = useCallback((offset) => {
+    setScrollInfo(offset);
+    const sv = scrollRef.current;
+    if (sv) {
+      const atBottom = offset >= sv.getBottomOffset() - 1;
+      autoScrollRef.current = atBottom;
+    }
+  }, []);
+  const runStateText = useMemo(() => {
+    if (isRunning && streamingText.length === 0 && toolState.state !== "started") {
+      return "assistant thinking...";
+    }
+    if (isRunning && streamingText.length > 0) {
+      return "assistant streaming...";
+    }
+    if (isRunning && toolState.state === "started") {
+      return `running tool: ${toolState.tool ?? "unknown"}`;
+    }
+    return "ready";
+  }, [isRunning, streamingText, toolState.state, toolState.tool]);
+  const inputPreview = inputLines.slice(-inputHeight).join("\n");
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width: columns, height: rows, children: [
+    /* @__PURE__ */ jsx(HeaderBar, { text: truncate(headerText, Math.max(30, columns - 4)) }),
+    /* @__PURE__ */ jsx(Box, { flexGrow: 1, flexShrink: 1, flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: /* @__PURE__ */ jsx(
+      ScrollView,
+      {
+        ref: scrollRef,
+        onScroll: handleScroll,
+        onContentHeightChange: () => {
+          if (autoScrollRef.current) {
+            scrollRef.current?.scrollToBottom();
+          }
+        },
+        flexGrow: 1,
+        flexShrink: 1,
+        children: contentLines.map((line) => /* @__PURE__ */ jsx(Text, { color: colorForKind(line.kind), children: line.text }, line.id))
+      }
+    ) }),
+    /* @__PURE__ */ jsx(Box, { height: 1 }),
+    /* @__PURE__ */ jsx(InputBar, { inputHeight, inputPreview, cursorVisible }),
+    /* @__PURE__ */ jsx(StatusBar, { notice, runStateText, scrollOffset: scrollInfo, pendingApproval })
+  ] });
+};
+
+// src/run-interactive-ink.ts
+var SESSION_PATH = [".agentl", "interactive-session.json"];
+var shouldPersistSessions = () => {
+  const value = (process.env.AGENTL_INTERACTIVE_PERSIST ?? "").toLowerCase();
+  return value === "1" || value === "true" || value === "yes";
+};
+var loadSessionSnapshot = async (workingDir) => {
+  const sessionPath = resolve(workingDir, ...SESSION_PATH);
+  try {
+    await access(sessionPath);
+    const content = await readFile(sessionPath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+};
+var persistSessionSnapshot = async (workingDir, snapshot) => {
+  const sessionPath = resolve(workingDir, ...SESSION_PATH);
+  await mkdir(resolve(workingDir, ".agentl"), { recursive: true });
+  await writeFile(sessionPath, JSON.stringify(snapshot), "utf8");
+};
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsedAgent = await parseAgentFile(workingDir);
+    agentName = parsedAgent.frontmatter.name ?? agentName;
+    model = parsedAgent.frontmatter.model?.name ?? model;
+    provider = parsedAgent.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: process.env.AGENTL_ENV ?? process.env.NODE_ENV ?? "development"
+  };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  onSetApprovalCallback
+}) => {
+  const persistenceEnabled = shouldPersistSessions();
+  const [sessionSnapshot, metadata] = await Promise.all([
+    persistenceEnabled ? loadSessionSnapshot(workingDir) : Promise.resolve(void 0),
+    loadMetadata(workingDir)
+  ]);
+  const app = render(
+    createElement(InteractiveInkApp, {
+      harness,
+      params,
+      metadata,
+      initialSnapshot: sessionSnapshot,
+      persistenceEnabled,
+      onPersist: persistenceEnabled ? async (snapshot) => {
+        await persistSessionSnapshot(workingDir, snapshot);
+      } : void 0,
+      onSetApprovalCallback
+    }),
+    {
+      maxFps: 30,
+      incrementalRendering: true,
+      patchConsole: false
+    }
+  );
+  await app.waitUntilExit();
+};
+export {
+  runInteractiveInk
+};