@poncho-ai/cli 0.2.0

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

@@ -0,0 +1,520 @@
+// 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, useRef, useState } from "react";
+import { Box, Static, Text, useApp, useInput } from "ink";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var MAX_BLOCKS = 200;
+var MAX_TIMELINE = 200;
+var INPUT_FLUSH_MS = 33;
+var STATUS_THROTTLE_MS = 80;
+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 = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var withLimit = (items, max) => items.length <= max ? items : items.slice(items.length - max);
+var InputBar = memo(function InputBar2({
+  inputPreview,
+  cursorVisible
+}) {
+  const cursor = cursorVisible ? "\u2588" : " ";
+  return /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { color: "cyan", children: [
+    "you> ",
+    inputPreview,
+    cursor
+  ] }) });
+});
+var StatusBar = memo(function StatusBar2({
+  notice,
+  statusText,
+  pendingApproval
+}) {
+  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__ */ jsx(Box, { children: /* @__PURE__ */ jsx(Text, { color: notice ? colorForKind(notice.kind) : "gray", children: notice ? notice.text : statusText }) });
+});
+var InteractiveInkApp = ({
+  harness,
+  params,
+  metadata,
+  initialSnapshot,
+  persistenceEnabled,
+  onPersist,
+  onSetApprovalCallback
+}) => {
+  const { exit } = useApp();
+  const [blocks, setBlocks] = useState(() => {
+    const initial = initialSnapshot?.blocks;
+    if (initial && initial.length > 0) return initial;
+    const legacyLines = initialSnapshot?.lines;
+    if (legacyLines && legacyLines.length > 0) {
+      return [{ id: "migrated", lines: legacyLines.map((l) => ({ kind: l.kind, text: l.text })) }];
+    }
+    return [];
+  });
+  const [timeline, setTimeline] = useState(
+    initialSnapshot?.timeline ?? []
+  );
+  const [input, setInput] = useState("");
+  const [isRunning, setIsRunning] = useState(false);
+  const [statusText, setStatusText] = useState(
+    "Enter to send | Alt+Enter newline | Ctrl+L clear | /help"
+  );
+  const [showToolPayloads, setShowToolPayloads] = useState(false);
+  const [notice, setNotice] = useState();
+  const [cursorVisible, setCursorVisible] = useState(true);
+  const [pendingApproval, setPendingApproval] = useState(null);
+  const messagesRef = useRef(initialSnapshot?.messages ?? []);
+  const turnRef = useRef(initialSnapshot?.nextTurn ?? 1);
+  const lastPromptRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const persistTimer = useRef();
+  const inputBufferRef = useRef(initialSnapshot?.lastPrompt ?? "");
+  const inputFlushRef = useRef();
+  const statusThrottleRef = useRef();
+  const turnLinesRef = useRef([]);
+  useEffect(() => {
+    if (onSetApprovalCallback) {
+      onSetApprovalCallback((req) => setPendingApproval(req));
+    }
+  }, [onSetApprovalCallback]);
+  useEffect(() => {
+    const t = setInterval(() => setCursorVisible((c) => !c), 500);
+    return () => clearInterval(t);
+  }, []);
+  const pasteBufferRef = useRef(null);
+  useEffect(() => {
+    const stdout = process.stdout;
+    const stdin = process.stdin;
+    const PASTE_START = "\x1B[200~";
+    const PASTE_END = "\x1B[201~";
+    stdout.write("\x1B[?2004h");
+    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) {
+          inputBufferRef.current += afterStart.slice(0, endIdx);
+          setInput(inputBufferRef.current);
+        } else {
+          pasteBufferRef.current = afterStart;
+        }
+      }
+    };
+    stdin.on("data", onData);
+    return () => {
+      stdin.off("data", onData);
+      stdout.write("\x1B[?2004l");
+    };
+  }, []);
+  const persistSnapshot = useCallback(() => {
+    if (!persistenceEnabled || !onPersist) return;
+    if (persistTimer.current) clearTimeout(persistTimer.current);
+    persistTimer.current = setTimeout(() => {
+      void onPersist({
+        messages: messagesRef.current,
+        blocks: withLimit(blocks, MAX_BLOCKS),
+        timeline: withLimit(timeline, MAX_TIMELINE),
+        nextTurn: turnRef.current,
+        lastPrompt: lastPromptRef.current
+      }).catch(() => {
+      });
+    }, 60);
+  }, [blocks, onPersist, persistenceEnabled, timeline]);
+  const commitBlock = useCallback((lines) => {
+    if (lines.length === 0) return;
+    setBlocks(
+      (prev) => withLimit([...prev, { id: randomId(), lines }], MAX_BLOCKS)
+    );
+  }, []);
+  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 setStatusThrottled = useCallback((text) => {
+    if (statusThrottleRef.current) return;
+    setStatusText(text);
+    statusThrottleRef.current = setTimeout(() => {
+      statusThrottleRef.current = void 0;
+    }, STATUS_THROTTLE_MS);
+  }, []);
+  const runSlashCommand = useCallback(
+    (command) => {
+      const norm = command.trim().toLowerCase();
+      if (norm === "/help") {
+        commitBlock([
+          { kind: "meta", text: "commands> /help /clear /tools /export /exit" }
+        ]);
+        return;
+      }
+      if (norm === "/clear") {
+        setBlocks([]);
+        setNotice({ kind: "meta", text: "Cleared." });
+        return;
+      }
+      if (norm === "/tools") {
+        setShowToolPayloads((v) => !v);
+        return;
+      }
+      if (norm === "/export") {
+        commitBlock([{
+          kind: "meta",
+          text: persistenceEnabled ? "export> session saved to .agentl/interactive-session.json" : "export> persistence disabled (set AGENTL_INTERACTIVE_PERSIST=true)"
+        }]);
+        return;
+      }
+      if (norm === "/exit") {
+        exit();
+        return;
+      }
+      setNotice({ kind: "warning", text: `Unknown command: ${command}` });
+    },
+    [commitBlock, exit, persistenceEnabled]
+  );
+  const runTurn = useCallback(
+    async (task) => {
+      if (isRunning) return;
+      setIsRunning(true);
+      setNotice(void 0);
+      setStatusText("thinking...");
+      const turn = turnRef.current;
+      turnRef.current = turn + 1;
+      const startedAt = Date.now();
+      lastPromptRef.current = task;
+      const lines = [];
+      lines.push({ kind: "meta", text: "" });
+      lines.push({ kind: "meta", text: `--- turn ${turn} ---` });
+      lines.push({ kind: "user", text: `you> ${task}` });
+      lines.push({ kind: "meta", text: "" });
+      let responseText = "";
+      let streamedText = "";
+      let committedText = false;
+      let sawChunk = false;
+      let toolEvents = 0;
+      let runFailed = false;
+      let usage;
+      try {
+        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;
+            setStatusThrottled(`streaming... (${responseText.length} chars)`);
+          } 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) {
+              lines.push({ kind: "assistant", text: `assistant> ${streamedText}` });
+              committedText = true;
+              streamedText = "";
+            }
+            if (event.type === "tool:started") {
+              const preview = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+              lines.push({ kind: "tool", text: `tools> start ${event.tool} input=${preview}` });
+              setStatusText(`running tool: ${event.tool}`);
+              toolEvents += 1;
+            } else if (event.type === "tool:completed") {
+              const preview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+              lines.push({ kind: "tool", text: `tools> done  ${event.tool} in ${formatDuration(event.duration)}` });
+              if (showToolPayloads) {
+                lines.push({ kind: "tool", text: `tools> output ${preview}` });
+              }
+              setStatusText("streaming...");
+            } else if (event.type === "tool:error") {
+              lines.push({ kind: "error", text: `tools> error ${event.tool}: ${event.error}` });
+              setNotice({ kind: "error", text: `Tool error on ${event.tool}` });
+            } else if (event.type === "tool:approval:required") {
+              lines.push({ kind: "warning", text: `tools> approval required for ${event.tool}` });
+            } else if (event.type === "tool:approval:granted") {
+              lines.push({ kind: "meta", text: `tools> approval granted (${event.approvalId})` });
+            } else if (event.type === "tool:approval:denied") {
+              lines.push({ kind: "warning", text: `tools> approval denied (${event.approvalId})` });
+            }
+          } else if (event.type === "run:error") {
+            runFailed = true;
+            lines.push({ kind: "error", text: `error> ${event.error.message}` });
+            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 ?? "";
+          }
+        }
+      } catch (error) {
+        runFailed = true;
+        lines.push({
+          kind: "error",
+          text: `error> ${error instanceof Error ? error.message : "Unknown error"}`
+        });
+        setNotice({
+          kind: "error",
+          text: error instanceof Error ? error.message : "Unknown error"
+        });
+      } finally {
+        if (statusThrottleRef.current) {
+          clearTimeout(statusThrottleRef.current);
+          statusThrottleRef.current = void 0;
+        }
+        lines.push({ kind: "meta", text: "" });
+        if (streamedText.length > 0) {
+          lines.push({ kind: "assistant", text: `assistant> ${streamedText}` });
+        } else if (!committedText && responseText.length > 0) {
+          lines.push({ kind: "assistant", text: `assistant> ${responseText}` });
+        } else if (!committedText) {
+          lines.push({ kind: "assistant", text: "assistant> (no response)" });
+        }
+        lines.push({ kind: "meta", text: "" });
+        const fullResponse = responseText || streamedText;
+        if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+          lines.push({
+            kind: "warning",
+            text: "warning> assistant described tool execution but no real tool events occurred."
+          });
+          setNotice({ kind: "warning", text: "Fabricated tool calls detected." });
+        }
+        const durationMs = Date.now() - startedAt;
+        lines.push({ kind: "meta", text: `meta> ${formatDuration(durationMs)} | tools: ${toolEvents}` });
+        commitBlock(lines);
+        setTimeline(
+          (prev) => withLimit(
+            [...prev, { turn, durationMs, toolEvents, status: runFailed ? "error" : "ok", usage }],
+            MAX_TIMELINE
+          )
+        );
+        messagesRef.current = [
+          ...messagesRef.current,
+          { role: "user", content: task },
+          { role: "assistant", content: responseText }
+        ];
+        setIsRunning(false);
+        setStatusText("Enter to send | Alt+Enter newline | Ctrl+L clear | /help");
+        persistSnapshot();
+      }
+    },
+    [commitBlock, harness, isRunning, params, persistSnapshot, setStatusThrottled, showToolPayloads]
+  );
+  useEffect(
+    () => () => {
+      if (persistTimer.current) clearTimeout(persistTimer.current);
+      if (inputFlushRef.current) clearTimeout(inputFlushRef.current);
+      if (statusThrottleRef.current) clearTimeout(statusThrottleRef.current);
+    },
+    []
+  );
+  useInput((value, key) => {
+    if (key.ctrl && value.toLowerCase() === "c" || value === "") {
+      exit();
+      return;
+    }
+    if (pendingApproval) {
+      const lower = value.toLowerCase();
+      if (lower === "y") {
+        turnLinesRef.current.push({ kind: "meta", text: `approval> approved ${pendingApproval.tool}` });
+        pendingApproval.resolve(true);
+        setPendingApproval(null);
+        return;
+      }
+      if (lower === "n") {
+        turnLinesRef.current.push({ kind: "meta", text: `approval> denied ${pendingApproval.tool}` });
+        pendingApproval.resolve(false);
+        setPendingApproval(null);
+        return;
+      }
+      return;
+    }
+    if (key.ctrl && value.toLowerCase() === "l") {
+      setBlocks([]);
+      setNotice({ kind: "meta", text: "Cleared." });
+      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((c) => !c);
+      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();
+      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\[[0-9;?]*[a-zA-Z~]/g, "").replace(/\u001B\][^\u0007]*\u0007/g, "").replace(/\u001B./g, "").replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "");
+      if (cleaned.length === 0) return;
+      inputBufferRef.current += cleaned;
+      queueInputFlush();
+    }
+  });
+  const headerText = `${metadata.agentName} | ${metadata.provider}/${metadata.model} | ${metadata.environment}`;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(Static, { items: blocks, children: (block) => /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: block.lines.map((line, i) => /* @__PURE__ */ jsx(Text, { color: colorForKind(line.kind), children: line.text }, `${block.id}-${i}`)) }, block.id) }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: headerText }),
+    /* @__PURE__ */ jsx(InputBar, { inputPreview: input, cursorVisible }),
+    /* @__PURE__ */ jsx(
+      StatusBar,
+      {
+        notice,
+        statusText,
+        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
+};