@harperfast/agent 0.16.6 → 0.16.8

package/dist/cli.js

@@ -0,0 +1,2919 @@
+#!/usr/bin/env node
+import {
+  ActionsProvider,
+  agentManager,
+  curryEmitToListeners,
+  defaultAnthropicCompactionModel,
+  defaultAnthropicModel,
+  defaultGoogleCompactionModel,
+  defaultGoogleModel,
+  defaultModelToken,
+  defaultOllamaCompactionModel,
+  defaultOllamaModel,
+  defaultOpenAICompactionModel,
+  defaultOpenAIModel,
+  emitToListeners,
+  excludeFalsy,
+  fetchOllamaModels,
+  handleExit,
+  isOpenAIModel,
+  isTrue,
+  lastEmittedValue,
+  rateLimitTracker,
+  resetTrackedState,
+  setupGlobalErrorHandlers,
+  trackedState,
+  updateEnv,
+  useActions,
+  useListener
+} from "./chunk-LSVGOLBU.js";
+
+// lifecycle/patchFetch.ts
+var originalFetch = globalThis.fetch;
+if (originalFetch) {
+  globalThis.fetch = async (...args) => {
+    const response = await originalFetch(...args);
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    const commonHeaders = [
+      "x-ratelimit-limit-requests",
+      "x-ratelimit-limit-tokens",
+      "x-ratelimit-remaining-requests",
+      "x-ratelimit-remaining-tokens",
+      "x-ratelimit-reset-requests",
+      "x-ratelimit-reset-tokens",
+      "anthropic-ratelimit-requests-limit",
+      "anthropic-ratelimit-requests-remaining",
+      "anthropic-ratelimit-requests-reset",
+      "anthropic-ratelimit-tokens-limit",
+      "anthropic-ratelimit-tokens-remaining",
+      "anthropic-ratelimit-tokens-reset",
+      "retry-after"
+    ];
+    for (const key of commonHeaders) {
+      if (!headers[key]) {
+        const val = response.headers.get(key);
+        if (val) {
+          headers[key] = val;
+        }
+      }
+    }
+    rateLimitTracker.updateFromHeaders(headers);
+    emitToListeners("SettingsUpdated", void 0);
+    const retryAfter = response.headers.get("retry-after");
+    if (retryAfter) {
+      const seconds = parseInt(retryAfter, 10);
+      if (!isNaN(seconds) && seconds > 0) {
+        emitToListeners("PushNewMessages", [{
+          type: "interrupted",
+          text: `Rate limit reached. Sleeping for ${seconds} seconds (Retry-After)...`,
+          version: 1
+        }]);
+        await new Promise((resolve) => setTimeout(resolve, seconds * 1e3));
+      }
+    }
+    return response;
+  };
+}
+
+// cli.ts
+import chalk5 from "chalk";
+
+// ink/main.tsx
+import { render, useApp } from "ink";
+import "react";
+
+// ink/components/ChatContent.tsx
+import { Spinner as Spinner2 } from "@inkjs/ui";
+import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
+import React10, { useCallback as useCallback4, useEffect as useEffect6, useMemo as useMemo9, useRef as useRef2, useState as useState12 } from "react";
+
+// ink/contexts/ChatContext.tsx
+import { createContext, useContext, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var ChatContext = createContext(void 0);
+var useChat = () => {
+  const context = useContext(ChatContext);
+  if (!context) {
+    throw new Error("useChat must be used within a ChatProvider");
+  }
+  return context;
+};
+var initialMessages = [];
+function getInitialMessages() {
+  if (initialMessages.length === 0) {
+    initialMessages = agentManager.initialMessages ? agentManager.initialMessages.map((m, index) => ({
+      ...m,
+      id: index,
+      version: m.version ?? 1
+    })) : [{
+      id: 0,
+      type: "agent",
+      text: 'What shall we build today? (Type "/clear" to reset, "/skills" to add skills, or "/exit" to quit)',
+      version: 1
+    }];
+  }
+  return initialMessages;
+}
+var ChatProvider = ({
+  children
+}) => {
+  const [messages, setMessages] = useState(getInitialMessages());
+  const [userInputMode, setUserInputMode] = useState("waiting");
+  const [isThinking, setIsThinking] = useState(false);
+  const [isCompacting, setIsCompacting] = useState(false);
+  const [pullingState, setPullingState] = useState(null);
+  const [focusedArea, setFocusedArea] = useState("input");
+  useListener("PushNewMessages", (messages2) => {
+    setMessages((prev) => {
+      return prev.concat(
+        messages2.map((message, index) => ({ ...message, id: prev.length + index, version: 1 }))
+      );
+    });
+  }, []);
+  useListener("SetInputMode", (newInputMode) => {
+    setUserInputMode(newInputMode);
+  }, []);
+  useListener("SetThinking", (value2) => {
+    setIsThinking(Boolean(value2));
+  }, []);
+  useListener("SetCompacting", (value2) => {
+    setIsCompacting(Boolean(value2));
+  }, []);
+  useListener("SetPulling", (value2) => {
+    setPullingState(value2);
+  }, []);
+  useListener("InterruptThought", () => {
+    setIsThinking(false);
+  }, []);
+  useListener("UpdateLastMessageText", (text) => {
+    setMessages((prev) => {
+      if (prev.length === 0) {
+        return prev;
+      }
+      const lastIndex = [...prev].reverse().findIndex((m) => m.type === "agent");
+      if (lastIndex === -1) {
+        return prev;
+      }
+      const actualIndex = prev.length - 1 - lastIndex;
+      const last = prev[actualIndex];
+      const updated = [...prev];
+      updated[actualIndex] = {
+        ...last,
+        text: last.text + text,
+        version: last.version + 1
+      };
+      return updated;
+    });
+  }, []);
+  useListener("ClearChatHistory", () => {
+    agentManager.session?.clearSession();
+    setMessages([{
+      id: 0,
+      type: "agent",
+      text: "Chat cleared. What shall we build today?",
+      version: 1
+    }]);
+  }, []);
+  const value = useMemo(() => ({
+    messages,
+    userInputMode,
+    isThinking,
+    isCompacting,
+    pullingState,
+    focusedArea,
+    setFocusedArea
+  }), [messages, userInputMode, isThinking, isCompacting, pullingState, focusedArea]);
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+};
+
+// ink/bindings/useMessageListener.ts
+var hasShownInterruptHint = false;
+function useMessageListener() {
+  const { userInputMode, isThinking } = useChat();
+  useListener("InterruptThought", () => {
+    agentManager.interrupt();
+    emitToListeners("PushNewMessages", [
+      {
+        type: "interrupted",
+        text: "- thought interrupted -",
+        version: 1
+      }
+    ]);
+  }, []);
+  useListener("PushNewMessages", async (messages) => {
+    for (const message of messages) {
+      if ((message.type === "user" || message.type === "prompt") && message.text) {
+        const lowerText = message.text.toLowerCase();
+        if (lowerText === "exit" || lowerText === "bye") {
+          await handleExit();
+        }
+        if (isThinking) {
+          if (!hasShownInterruptHint) {
+            hasShownInterruptHint = true;
+            emitToListeners("PushNewMessages", [{
+              type: "interrupted",
+              text: "- to interrupt the current thinking, press escape -",
+              version: 1
+            }]);
+          }
+          agentManager.enqueueUserInput(message.text);
+          message.handled = true;
+        } else if (!message.handled) {
+          void agentManager.runTask(message.text, message.type === "prompt");
+        }
+      }
+    }
+  }, [userInputMode, isThinking]);
+}
+
+// ink/constants/footerHeight.ts
+var footerHeight = 2;
+
+// ink/contexts/ApprovalContext.tsx
+import { createContext as createContext2, useCallback, useContext as useContext2, useMemo as useMemo2, useState as useState2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ApprovalContext = createContext2(void 0);
+var useApproval = () => {
+  const context = useContext2(ApprovalContext);
+  if (!context) {
+    throw new Error("useApproval must be used within an ApprovalProvider");
+  }
+  return context;
+};
+var ApprovalProvider = ({ children }) => {
+  const [payload, setPayload] = useState2(null);
+  const [toolInfos] = useState2(/* @__PURE__ */ new Map());
+  const registerToolInfo = useCallback(
+    (info) => {
+      toolInfos.set(info.callId, info);
+    },
+    [toolInfos]
+  );
+  useListener("OpenApprovalViewer", (p) => {
+    let finalPayload = { ...p, openedAt: Date.now() };
+    if (p.mode === "info" && p.callId) {
+      const info = toolInfos.get(p.callId);
+      if (info) {
+        finalPayload = { ...finalPayload, ...info };
+      }
+    } else if (p.callId) {
+      registerToolInfo({
+        callId: p.callId,
+        type: p.type,
+        path: p.path,
+        diff: p.diff,
+        code: p.code,
+        commands: p.commands
+      });
+    }
+    setPayload(finalPayload);
+  }, [registerToolInfo, toolInfos]);
+  useListener("CloseApprovalViewer", () => {
+    setPayload(null);
+  }, []);
+  const value = useMemo2(() => ({
+    payload,
+    setPayload,
+    registerToolInfo
+  }), [payload, registerToolInfo]);
+  return /* @__PURE__ */ jsx2(ApprovalContext.Provider, { value, children });
+};
+
+// ink/contexts/PlanContext.tsx
+import { createContext as createContext3, useContext as useContext3, useMemo as useMemo3, useState as useState3 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var PlanContext = createContext3({ planDescription: "", planItems: [], progress: 0 });
+var usePlan = () => {
+  const context = useContext3(PlanContext);
+  if (!context) {
+    throw new Error("usePlan must be used within a PlanProvider");
+  }
+  return context;
+};
+var PlanProvider = ({
+  children
+}) => {
+  const initialPlanDescription = lastEmittedValue("SetPlanDescription") || "";
+  const initialPlanItems = lastEmittedValue("SetPlanItems") || [];
+  const initialProgress = calculatePlanProgress(initialPlanItems);
+  const [planDescription, setPlanDescription] = useState3(initialPlanDescription);
+  const [planItems, setPlanItems] = useState3(initialPlanItems);
+  const [progress, setProgress] = useState3(initialProgress);
+  useListener("SetPlanDescription", (newGoal) => {
+    setPlanDescription(newGoal);
+  }, []);
+  useListener("SetPlanItems", (planItems2) => {
+    const progress2 = calculatePlanProgress(planItems2);
+    setPlanItems(planItems2);
+    setProgress(progress2);
+  }, []);
+  const value = useMemo3(() => ({
+    progress,
+    planDescription,
+    planItems
+  }), [progress, planDescription, planItems]);
+  return /* @__PURE__ */ jsx3(PlanContext.Provider, { value, children });
+};
+function calculatePlanProgress(planItems) {
+  if (!planItems?.length) {
+    return 0;
+  }
+  const completedCount = planItems.filter((item) => item.status === "done" || item.status === "not-needed").length;
+  return Math.round(completedCount / planItems.length * 100);
+}
+
+// ink/library/useTerminalSize.ts
+import { useStdout } from "ink";
+import { useEffect, useState as useState4 } from "react";
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState4({
+    rows: stdout?.rows ?? 24,
+    columns: stdout?.columns ?? 80
+  });
+  useEffect(() => {
+    if (!stdout || !stdout.isTTY) {
+      return;
+    }
+    const handleResize = () => {
+      setSize({
+        rows: stdout.rows ?? 24,
+        columns: stdout.columns ?? 80
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+}
+
+// ink/library/wrapText.ts
+function wrapText(text, width) {
+  if (width <= 1) {
+    return text ? [text] : [""];
+  }
+  const hardLines = text.split("\n");
+  const allWrappedLines = [];
+  for (const hardLine of hardLines) {
+    if (hardLine.length === 0) {
+      allWrappedLines.push("");
+      continue;
+    }
+    const words = hardLine.split(/(\s+)/);
+    let currentLine = "";
+    for (const token of words) {
+      if (token.length === 0) {
+        continue;
+      }
+      if (currentLine.length + token.length <= width) {
+        currentLine += token;
+      } else {
+        if (currentLine) {
+          allWrappedLines.push(currentLine.trimEnd());
+        }
+        if (token.trim().length === 0) {
+          currentLine = "";
+        } else if (token.length > width) {
+          for (let i = 0; i < token.length; i += width) {
+            const chunk = token.slice(i, i + width);
+            if (chunk.length === width) {
+              allWrappedLines.push(chunk);
+            } else {
+              currentLine = chunk;
+            }
+          }
+        } else {
+          currentLine = token;
+        }
+      }
+    }
+    if (currentLine) {
+      allWrappedLines.push(currentLine.trimEnd());
+    }
+  }
+  return allWrappedLines.length ? allWrappedLines : [""];
+}
+
+// ink/components/ActionsView.tsx
+import { Box as Box3, Text as Text3, useInput } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect3, useState as useState6 } from "react";
+
+// ink/components/ActionItemRow.tsx
+import { Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { memo } from "react";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var ActionItemRow = memo(
+  ({ item, isSelected, isFocused, width }) => {
+    const statusColor = item.running ? "yellow" : item.status === "approved" || item.status === "succeeded" || typeof item.exitCode === "number" && item.exitCode === 0 ? "green" : item.status === "denied" || item.status === "failed" || typeof item.exitCode === "number" && item.exitCode !== 0 ? "red" : "cyan";
+    const selectionColor = isFocused ? "cyan" : "gray";
+    const pipe = /* @__PURE__ */ jsx4(Text, { color: isSelected ? selectionColor : "gray", bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " });
+    const statusLabel = item.running ? " " : item.kind === "approval" ? item.status === "approved" ? " approved" : item.status === "denied" ? " denied" : "" : typeof item.exitCode === "number" ? ` ${item.exitCode}` : "";
+    const statusLabelWidth = item.running ? 2 : statusLabel.length;
+    const pipeWidth = 3;
+    const nameWithSpace = `${item.title} `;
+    const availableForDetail = width - pipeWidth - nameWithSpace.length - statusLabelWidth;
+    const fullDetail = item.detail || "";
+    let displayedDetail = fullDetail;
+    if (availableForDetail < fullDetail.length) {
+      if (availableForDetail > 3) {
+        displayedDetail = fullDetail.slice(0, availableForDetail - 3) + "...";
+      } else {
+        displayedDetail = fullDetail.slice(0, Math.max(0, availableForDetail));
+      }
+    }
+    return /* @__PURE__ */ jsxs(Box, { children: [
+      pipe,
+      /* @__PURE__ */ jsxs(Box, { flexGrow: 1, children: [
+        /* @__PURE__ */ jsx4(Text, { color: statusColor, bold: true, children: item.title }),
+        /* @__PURE__ */ jsxs(Text, { color: "gray", children: [
+          " ",
+          displayedDetail
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx4(Box, { children: item.running ? /* @__PURE__ */ jsxs(Box, { children: [
+        /* @__PURE__ */ jsx4(Text, { color: "yellow" }),
+        /* @__PURE__ */ jsx4(Spinner, { type: "dots" })
+      ] }) : /* @__PURE__ */ jsx4(Text, { color: statusColor, bold: true, children: statusLabel }) })
+    ] });
+  }
+);
+
+// ink/components/VirtualList.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { forwardRef, useEffect as useEffect2, useImperativeHandle, useMemo as useMemo4, useRef, useState as useState5 } from "react";
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function getDefaultKey(item, index) {
+  if (item && typeof item === "object") {
+    if ("id" in item && (typeof item.id === "string" || typeof item.id === "number")) {
+      return String(item.id);
+    }
+    if ("key" in item && (typeof item.key === "string" || typeof item.key === "number")) {
+      return String(item.key);
+    }
+  }
+  return String(index);
+}
+var VirtualListInner = (props, ref) => {
+  const {
+    items,
+    renderItem,
+    getItemHeight: getItemHeightProp,
+    itemHeight: fixedItemHeight,
+    selectedIndex = 0,
+    keyExtractor,
+    height: propHeight,
+    reservedLines = 0,
+    showOverflowIndicators = true,
+    overflowIndicatorThreshold = 1,
+    renderOverflowTop,
+    renderOverflowBottom,
+    renderFiller,
+    onViewportChange
+  } = props;
+  const { rows: terminalRows } = useTerminalSize();
+  const resolvedHeight = useMemo4(() => {
+    if (typeof propHeight === "number") {
+      return propHeight;
+    }
+    if (typeof propHeight === "string" && propHeight.endsWith("%")) {
+      const percent = parseFloat(propHeight) / 100;
+      return Math.floor(terminalRows * percent);
+    }
+    return Math.max(1, terminalRows - reservedLines);
+  }, [propHeight, terminalRows, reservedLines]);
+  const getItemHeight = useMemo4(() => {
+    if (getItemHeightProp) {
+      return getItemHeightProp;
+    }
+    if (fixedItemHeight) {
+      return () => fixedItemHeight;
+    }
+    return () => 1;
+  }, [getItemHeightProp, fixedItemHeight]);
+  const indicatorLines = showOverflowIndicators ? 2 : 0;
+  const availableHeight = Math.max(0, resolvedHeight - indicatorLines);
+  const [viewportOffset, setViewportOffset] = useState5(0);
+  const lastItemsLength = useRef(items.length);
+  const viewportOffsetRef = useRef(viewportOffset);
+  useEffect2(() => {
+    viewportOffsetRef.current = viewportOffset;
+  }, [viewportOffset]);
+  const clampedSelectedIndex = Math.max(0, Math.min(selectedIndex, items.length - 1));
+  const { visibleCount, visibleItems } = useMemo4(() => {
+    if (availableHeight <= 0) {
+      return { visibleCount: 0, visibleItems: [] };
+    }
+    let currentHeight = 0;
+    let count = 0;
+    const visibleItems2 = [];
+    for (let i = viewportOffset; i < items.length; i++) {
+      const h = getItemHeight(items[i], i);
+      if (currentHeight + h > availableHeight && count > 0) {
+        break;
+      }
+      currentHeight += h;
+      count++;
+      visibleItems2.push(items[i]);
+    }
+    return { visibleCount: count, visibleItems: visibleItems2 };
+  }, [items, viewportOffset, availableHeight, getItemHeight]);
+  useEffect2(() => {
+    if (items.length === 0 || availableHeight <= 0) {
+      lastItemsLength.current = items.length;
+      return;
+    }
+    const currentViewportOffset = viewportOffsetRef.current;
+    const isSelectingLast = clampedSelectedIndex === items.length - 1;
+    const wasAtBottom = lastItemsLength.current > 0 && currentViewportOffset + visibleCount >= lastItemsLength.current - 1;
+    lastItemsLength.current = items.length;
+    if (clampedSelectedIndex < currentViewportOffset) {
+      setViewportOffset(clampedSelectedIndex);
+      return;
+    }
+    let heightToSelected = 0;
+    let isVisible = false;
+    for (let i = currentViewportOffset; i <= clampedSelectedIndex; i++) {
+      const h = getItemHeight(items[i], i);
+      if (heightToSelected + h > availableHeight) {
+        isVisible = false;
+        break;
+      }
+      heightToSelected += h;
+      if (i === clampedSelectedIndex) {
+        isVisible = true;
+      }
+    }
+    if (!isVisible || isSelectingLast || wasAtBottom) {
+      let tempOffset = clampedSelectedIndex;
+      let hSum2 = 0;
+      while (tempOffset >= 0) {
+        const h = getItemHeight(items[tempOffset], tempOffset);
+        if (hSum2 + h > availableHeight) {
+          tempOffset++;
+          break;
+        }
+        hSum2 += h;
+        if (tempOffset === 0) {
+          break;
+        }
+        tempOffset--;
+      }
+      const finalOffset = Math.max(0, tempOffset);
+      if (finalOffset !== currentViewportOffset) {
+        setViewportOffset(finalOffset);
+      }
+    }
+  }, [clampedSelectedIndex, items, availableHeight, getItemHeight, visibleCount]);
+  const viewport = useMemo4(
+    () => ({
+      offset: viewportOffset,
+      visibleCount,
+      totalCount: items.length
+    }),
+    [viewportOffset, visibleCount, items.length]
+  );
+  const isInitialMount = useRef(true);
+  useEffect2(() => {
+    if (isInitialMount.current) {
+      if (items.length > 0 && availableHeight > 0) {
+        isInitialMount.current = false;
+        let tempOffset = items.length - 1;
+        let hSum2 = 0;
+        while (tempOffset >= 0) {
+          const h = getItemHeight(items[tempOffset], tempOffset);
+          if (hSum2 + h > availableHeight) {
+            tempOffset++;
+            break;
+          }
+          hSum2 += h;
+          if (tempOffset === 0) {
+            break;
+          }
+          tempOffset--;
+        }
+        setViewportOffset(Math.max(0, tempOffset));
+      }
+    }
+  }, [availableHeight, items.length, getItemHeight]);
+  useEffect2(() => {
+    onViewportChange?.(viewport);
+  }, [viewport, onViewportChange]);
+  useImperativeHandle(
+    ref,
+    () => ({
+      scrollToIndex: (index, alignment = "auto") => {
+        const clampedIndex = Math.max(0, Math.min(index, items.length - 1));
+        let newOffset = viewportOffset;
+        switch (alignment) {
+          case "top":
+            newOffset = clampedIndex;
+            break;
+          case "center": {
+            let hSum2 = 0;
+            let tempOffset = clampedIndex;
+            while (tempOffset >= 0 && hSum2 < availableHeight / 2) {
+              hSum2 += getItemHeight(items[tempOffset], tempOffset);
+              tempOffset--;
+            }
+            newOffset = tempOffset + 1;
+            break;
+          }
+          case "bottom": {
+            let hSum2 = 0;
+            let tempOffset = clampedIndex;
+            while (tempOffset >= 0 && hSum2 < availableHeight) {
+              const h = getItemHeight(items[tempOffset], tempOffset);
+              if (hSum2 + h > availableHeight) {
+                tempOffset++;
+                break;
+              }
+              hSum2 += h;
+              if (tempOffset === 0) {
+                break;
+              }
+              tempOffset--;
+            }
+            newOffset = tempOffset;
+            break;
+          }
+          case "auto":
+          default: {
+            if (clampedIndex < viewportOffset) {
+              newOffset = clampedIndex;
+            } else {
+              let heightToSelected = 0;
+              let isVisible = false;
+              for (let i = viewportOffset; i <= clampedIndex; i++) {
+                const h = getItemHeight(items[i], i);
+                if (heightToSelected + h > availableHeight) {
+                  isVisible = false;
+                  break;
+                }
+                heightToSelected += h;
+                if (i === clampedIndex) {
+                  isVisible = true;
+                }
+              }
+              if (!isVisible) {
+                let hSum2 = 0;
+                let tempOffset = clampedIndex;
+                while (tempOffset >= 0) {
+                  const h = getItemHeight(items[tempOffset], tempOffset);
+                  if (hSum2 + h > availableHeight) {
+                    tempOffset++;
+                    break;
+                  }
+                  hSum2 += h;
+                  if (tempOffset === 0) {
+                    break;
+                  }
+                  tempOffset--;
+                }
+                newOffset = tempOffset;
+              }
+            }
+          }
+        }
+        setViewportOffset(Math.max(0, newOffset));
+      },
+      getViewport: () => viewport
+    }),
+    [items, viewportOffset, availableHeight, getItemHeight, viewport]
+  );
+  const overflowTop = viewportOffset;
+  let itemsFittingBelow = 0;
+  let hSum = 0;
+  for (let i = viewportOffset; i < items.length; i++) {
+    const h = getItemHeight(items[i], i);
+    if (hSum + h > availableHeight) {
+      break;
+    }
+    hSum += h;
+    itemsFittingBelow++;
+  }
+  const overflowBottom = Math.max(0, items.length - viewportOffset - itemsFittingBelow);
+  const defaultOverflowTop = (count) => {
+    if (count < overflowIndicatorThreshold) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx5(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "\u25B2 ",
+      count,
+      " more"
+    ] }) });
+  };
+  const defaultOverflowBottom = (count) => {
+    if (count < overflowIndicatorThreshold) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx5(Box2, { paddingLeft: 2, children: /* @__PURE__ */ jsxs2(Text2, { dimColor: true, children: [
+      "\u25BC ",
+      count,
+      " more"
+    ] }) });
+  };
+  const topIndicator = renderOverflowTop ?? defaultOverflowTop;
+  const bottomIndicator = renderOverflowBottom ?? defaultOverflowBottom;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: resolvedHeight, children: [
+    showOverflowIndicators && /* @__PURE__ */ jsx5(Box2, { height: 1, children: topIndicator(overflowTop) }),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", flexGrow: 1, children: [
+      visibleItems.map((item, idx) => {
+        const actualIndex = viewportOffset + idx;
+        const key = keyExtractor ? keyExtractor(item, actualIndex) : getDefaultKey(item, actualIndex);
+        const itemProps = {
+          item,
+          index: actualIndex,
+          isSelected: actualIndex === clampedSelectedIndex
+        };
+        return /* @__PURE__ */ jsx5(Box2, { height: getItemHeight(item, actualIndex), overflow: "hidden", children: renderItem(itemProps) }, key);
+      }),
+      renderFiller && hSum < availableHeight && /* @__PURE__ */ jsx5(Box2, { flexDirection: "column", flexGrow: 1, children: renderFiller(availableHeight - hSum) })
+    ] }),
+    showOverflowIndicators && /* @__PURE__ */ jsx5(Box2, { height: 1, children: bottomIndicator(overflowBottom) })
+  ] });
+};
+var VirtualList = forwardRef(VirtualListInner);
+
+// ink/components/ActionsView.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function ActionsView({ height, isFocused }) {
+  const { actions } = useActions();
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const size = useTerminalSize();
+  const timelineWidth = Math.floor(size.columns * 0.65);
+  const statusWidth = size.columns - timelineWidth;
+  useEffect3(() => {
+    if (actions.length > 0) {
+      setSelectedIndex(actions.length - 1);
+    }
+  }, [actions.length]);
+  useInput((_, key) => {
+    if (!isFocused) {
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(actions.length - 1, prev + 1));
+    }
+    if (key.return) {
+      const selected = actions[selectedIndex];
+      if (selected && (selected.kind === "apply_patch" || selected.kind === "approval" || selected.title === "shell" || selected.title === "code_interpreter")) {
+        if (selected.callId) {
+          emitToListeners("OpenApprovalViewer", {
+            type: selected.kind === "apply_patch" ? "update_file" : selected.title,
+            mode: "info",
+            callId: selected.callId,
+            actionId: selected.id
+          });
+        }
+      }
+    }
+  });
+  const renderOverflowTop = useCallback2((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
+    count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " ",
+      "\u25B2 ",
+      count,
+      " more"
+    ] })
+  ] }), []);
+  const renderOverflowBottom = useCallback2((count) => /* @__PURE__ */ jsxs3(Box3, { children: [
+    /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }),
+    count > 0 && /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      " ",
+      "\u25BC ",
+      count,
+      " more"
+    ] })
+  ] }), []);
+  const renderFiller = useCallback2((h) => /* @__PURE__ */ jsx6(Box3, { flexDirection: "column", children: Array.from({ length: h }).map((_, i) => /* @__PURE__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, { color: "gray", dimColor: true, children: "\u2502" }) }, i)) }), []);
+  const getItemHeight = useCallback2((_item) => 1, []);
+  if (actions.length === 0) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", flexGrow: 1, height, children: [
+      /* @__PURE__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, { italic: true, color: "gray", children: "No actions yet." }) }),
+      Array.from({ length: height - 1 }).map((_, i) => /* @__PURE__ */ jsx6(Box3, { children: /* @__PURE__ */ jsx6(Text3, {}) }, i))
+    ] });
+  }
+  return /* @__PURE__ */ jsx6(Box3, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx6(
+    VirtualList,
+    {
+      items: actions,
+      getItemHeight,
+      height,
+      selectedIndex,
+      renderOverflowTop,
+      renderOverflowBottom,
+      renderFiller,
+      renderItem: ({ item, isSelected }) => /* @__PURE__ */ jsx6(ActionItemRow, { item, isSelected, isFocused, width: statusWidth - 2 })
+    }
+  ) });
+}
+
+// ink/components/CostView.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import "react";
+
+// ink/contexts/CostContext.tsx
+import { createContext as createContext4, useContext as useContext4, useMemo as useMemo5, useState as useState7 } from "react";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var CostContext = createContext4(void 0);
+var useCost = () => {
+  const context = useContext4(CostContext);
+  if (!context) {
+    throw new Error("useCost must be used within a CostProvider");
+  }
+  return context;
+};
+var CostProvider = ({
+  children
+}) => {
+  const [cost, setCost] = useState7({
+    totalCost: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cachedInputTokens: 0,
+    hasUnknownPrices: false
+  });
+  useListener("UpdateCost", (newCost) => {
+    setCost(newCost);
+  }, []);
+  const value = useMemo5(() => ({
+    cost
+  }), [cost]);
+  return /* @__PURE__ */ jsx7(CostContext.Provider, { value, children });
+};
+
+// ink/components/CostView.tsx
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+function CostView({ isDense = false }) {
+  const { cost } = useCost();
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 1, paddingTop: isDense ? 0 : 1, children: [
+    /* @__PURE__ */ jsx8(Box4, { marginBottom: isDense ? 0 : 1, children: /* @__PURE__ */ jsx8(Text4, { bold: true, underline: true, color: "cyan", children: "Session Cost Breakdown" }) }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Total Cost:" }) }),
+      /* @__PURE__ */ jsxs4(Text4, { color: "green", children: [
+        "$",
+        cost.totalCost.toFixed(4)
+      ] }),
+      cost.hasUnknownPrices && /* @__PURE__ */ jsx8(Text4, { color: "yellow", children: "(est.)" })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Input Tokens:" }) }),
+      /* @__PURE__ */ jsx8(Text4, { children: cost.inputTokens.toLocaleString() })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Cached Tokens:" }) }),
+      /* @__PURE__ */ jsx8(Text4, { color: "gray", children: cost.cachedInputTokens.toLocaleString() })
+    ] }),
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx8(Box4, { width: 20, children: /* @__PURE__ */ jsx8(Text4, { children: "Output Tokens:" }) }),
+      /* @__PURE__ */ jsx8(Text4, { children: cost.outputTokens.toLocaleString() })
+    ] })
+  ] });
+}
+
+// ink/components/MessageLineItem.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { memo as memo2 } from "react";
+import { Fragment, jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var MessageLineItem = memo2(
+  ({
+    item,
+    isSelected,
+    isFocused,
+    indent = 0
+  }) => {
+    const color = messageTypeToColor(item.type);
+    const label = item.type === "interrupted" ? "" : item.type.toUpperCase();
+    const selectionColor = isFocused ? "cyan" : "gray";
+    return /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx9(Text5, { color: isSelected ? selectionColor : "gray", dimColor: !isSelected, bold: isSelected, children: isSelected ? "\u2503  " : "\u2502  " }),
+      /* @__PURE__ */ jsx9(Box5, { paddingLeft: indent, children: item.isFirstLine ? /* @__PURE__ */ jsxs5(Text5, { children: [
+        label && /* @__PURE__ */ jsxs5(Text5, { bold: true, color, children: [
+          label,
+          item.type === "tool" ? ": " : item.isArgsLine ? " args: " : ": "
+        ] }),
+        item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx9(Text5, { children: item.text.startsWith(item.toolName) ? /* @__PURE__ */ jsxs5(Fragment, { children: [
+          /* @__PURE__ */ jsx9(Text5, { color: "white", bold: true, children: item.toolName }),
+          /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text.slice(item.toolName.length) })
+        ] }) : /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text.startsWith(" ") ? item.text : ` ${item.text}` }) }) : /* @__PURE__ */ jsx9(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text })
+      ] }) : /* @__PURE__ */ jsx9(Text5, { children: item.type === "tool" && item.toolName ? /* @__PURE__ */ jsx9(Text5, { dimColor: true, italic: true, children: item.text }) : /* @__PURE__ */ jsx9(Text5, { dimColor: !!item.isArgsLine, italic: !!item.isArgsLine, children: item.text }) }) })
+    ] });
+  }
+);
+function messageTypeToColor(type) {
+  switch (type) {
+    case "prompt":
+    case "user":
+      return "green";
+    case "agent":
+      return "cyan";
+    case "interrupted":
+      return "gray";
+    default:
+      return "magenta";
+  }
+}
+
+// ink/components/PlanView.tsx
+import { ProgressBar } from "@inkjs/ui";
+import { Box as Box6, Text as Text6 } from "ink";
+import "react";
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+function PlanView() {
+  const { planDescription, planItems, progress } = usePlan();
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx10(Box6, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx10(Text6, { italic: true, children: planDescription }) }),
+    /* @__PURE__ */ jsx10(Box6, { flexDirection: "column", flexGrow: 1, children: planItems.map((planItem) => /* @__PURE__ */ jsx10(Box6, { children: /* @__PURE__ */ jsxs6(
+      Text6,
+      {
+        color: planItem.status === "done" ? "green" : planItem.status === "in-progress" ? "yellow" : planItem.status === "not-needed" ? "gray" : "white",
+        dimColor: planItem.status === "not-needed",
+        children: [
+          planItem.status === "done" ? " \u25CF " : planItem.status === "in-progress" ? " \u25B6 " : planItem.status === "not-needed" ? " \u25CC " : " \u25CB ",
+          planItem.text
+        ]
+      }
+    ) }, planItem.id)) }),
+    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs6(Text6, { bold: true, children: [
+        "PROGRESS: ",
+        progress,
+        "%"
+      ] }),
+      /* @__PURE__ */ jsx10(ProgressBar, { value: progress })
+    ] })
+  ] });
+}
+
+// ink/components/SettingsView.tsx
+import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
+import path from "path";
+import { useEffect as useEffect4, useMemo as useMemo7, useState as useState9 } from "react";
+
+// ink/contexts/SettingsContext.tsx
+import { createContext as createContext5, useContext as useContext5, useMemo as useMemo6, useState as useState8 } from "react";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var SettingsContext = createContext5(void 0);
+var useSettings = () => {
+  const context = useContext5(SettingsContext);
+  if (!context) {
+    throw new Error("useSettings must be used within a SettingsProvider");
+  }
+  return context;
+};
+var SettingsProvider = ({
+  children
+}) => {
+  const [version, setVersion] = useState8(0);
+  useListener("SettingsUpdated", () => {
+    setVersion((v) => v + 1);
+  }, []);
+  const value = useMemo6(() => ({
+    version,
+    model: trackedState.model,
+    compactionModel: trackedState.compactionModel,
+    sessionPath: trackedState.sessionPath,
+    cwd: trackedState.cwd,
+    useFlexTier: trackedState.useFlexTier,
+    currentTurn: trackedState.currentTurn,
+    maxTurns: trackedState.maxTurns,
+    maxCost: trackedState.maxCost,
+    autoApproveCodeInterpreter: trackedState.autoApproveCodeInterpreter,
+    autoApprovePatches: trackedState.autoApprovePatches,
+    autoApproveShell: trackedState.autoApproveShell,
+    monitorRateLimits: trackedState.monitorRateLimits,
+    rateLimitThreshold: trackedState.rateLimitThreshold,
+    rateLimitStatus: rateLimitTracker.getStatus()
+  }), [version]);
+  return /* @__PURE__ */ jsx11(SettingsContext.Provider, { value, children });
+};
+
+// ink/components/SettingsView.tsx
+import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+function SettingsView({ isDense = false }) {
+  const {
+    model,
+    compactionModel,
+    sessionPath,
+    cwd,
+    useFlexTier,
+    currentTurn,
+    maxTurns,
+    maxCost,
+    autoApproveCodeInterpreter: initialAutoApproveCodeInterpreter,
+    autoApprovePatches: initialAutoApprovePatches,
+    autoApproveShell: initialAutoApproveShell,
+    monitorRateLimits: initialMonitorRateLimits,
+    rateLimitThreshold: initialRateLimitThreshold,
+    rateLimitStatus
+  } = useSettings();
+  const { focusedArea } = useChat();
+  const [autoApproveCodeInterpreter, setAutoApproveCodeInterpreter] = useState9(initialAutoApproveCodeInterpreter);
+  const [autoApprovePatches, setAutoApprovePatches] = useState9(initialAutoApprovePatches);
+  const [autoApproveShell, setAutoApproveShell] = useState9(initialAutoApproveShell);
+  const [monitorRateLimits, setMonitorRateLimits] = useState9(initialMonitorRateLimits);
+  useEffect4(() => {
+    setAutoApproveCodeInterpreter(initialAutoApproveCodeInterpreter);
+  }, [initialAutoApproveCodeInterpreter]);
+  useEffect4(() => {
+    setAutoApprovePatches(initialAutoApprovePatches);
+  }, [initialAutoApprovePatches]);
+  useEffect4(() => {
+    setAutoApproveShell(initialAutoApproveShell);
+  }, [initialAutoApproveShell]);
+  useEffect4(() => {
+    setMonitorRateLimits(initialMonitorRateLimits);
+  }, [initialMonitorRateLimits]);
+  const [selectedIndex, setSelectedIndex] = useState9(0);
+  const selectableOptions = useMemo7(() => [
+    {
+      label: "Code Interpreter",
+      value: autoApproveCodeInterpreter,
+      envKey: "HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER",
+      setter: setAutoApproveCodeInterpreter
+    },
+    {
+      label: "File Patches",
+      value: autoApprovePatches,
+      envKey: "HARPER_AGENT_AUTO_APPROVE_PATCHES",
+      setter: setAutoApprovePatches
+    },
+    {
+      label: "Shell Commands",
+      value: autoApproveShell,
+      envKey: "HARPER_AGENT_AUTO_APPROVE_SHELL",
+      setter: setAutoApproveShell
+    },
+    {
+      label: "Monitor Rate Limits",
+      value: monitorRateLimits,
+      envKey: "HARPER_AGENT_MONITOR_RATE_LIMITS",
+      setter: (val) => {
+        setMonitorRateLimits(val);
+        updateEnv("HARPER_AGENT_MONITOR_RATE_LIMITS", val ? "true" : "false");
+        emitToListeners("SettingsUpdated", void 0);
+      }
+    },
+    {
+      label: "<edit settings>",
+      isAction: true,
+      action: bootstrapConfig
+    }
+  ], [autoApproveCodeInterpreter, autoApprovePatches, autoApproveShell, monitorRateLimits]);
+  useInput2((_input, key) => {
+    if (focusedArea !== "status") {
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => prev > 0 ? prev - 1 : selectableOptions.length - 1);
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => prev < selectableOptions.length - 1 ? prev + 1 : 0);
+    }
+    if (key.return || _input === " ") {
+      const selected = selectableOptions[selectedIndex];
+      if (!selected) {
+        return;
+      }
+      if ("isAction" in selected && selected.isAction) {
+        selected.action();
+      } else if ("setter" in selected) {
+        const newValue = !selected.value;
+        selected.setter(newValue);
+        updateEnv(selected.envKey, newValue ? "1" : "0");
+        emitToListeners("SettingsUpdated", void 0);
+      }
+    }
+  });
+  const displayPath = useMemo7(() => {
+    if (!sessionPath) {
+      return null;
+    }
+    const relative = path.relative(cwd, sessionPath);
+    if (!relative.startsWith("..") && !path.isAbsolute(relative)) {
+      return `./${relative}`;
+    }
+    return sessionPath;
+  }, [cwd, sessionPath]);
+  const marginBottom = isDense ? 0 : 1;
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", flexGrow: 1, paddingLeft: 1, children: [
+    /* @__PURE__ */ jsx12(Box7, { marginBottom, children: /* @__PURE__ */ jsx12(Text7, { bold: true, underline: true, color: "cyan", children: "Configuration" }) }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Model:" }) }),
+      /* @__PURE__ */ jsx12(Text7, { children: model })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Compaction Model:" }) }),
+      /* @__PURE__ */ jsx12(Text7, { children: compactionModel })
+    ] }),
+    displayPath && /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Session Path:" }) }),
+      /* @__PURE__ */ jsx12(Text7, { children: displayPath })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Flex Tier:" }) }),
+      /* @__PURE__ */ jsx12(Text7, { children: useFlexTier ? "Yes" : "No" })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Current Turn:" }) }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        currentTurn,
+        " / ",
+        maxTurns
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Rate Limit @:" }) }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        initialRateLimitThreshold,
+        "%"
+      ] })
+    ] }),
+    rateLimitStatus && /* @__PURE__ */ jsxs7(Box7, { marginBottom, flexDirection: "column", children: [
+      rateLimitStatus.retryAfter !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { color: "red", children: "Retry After:" }) }),
+        /* @__PURE__ */ jsxs7(Text7, { color: "red", children: [
+          rateLimitStatus.retryAfter,
+          "s"
+        ] })
+      ] }),
+      (rateLimitStatus.limitRequests !== null || rateLimitStatus.remainingRequests !== null) && /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "RPM Limit:" }) }),
+        /* @__PURE__ */ jsxs7(Text7, { children: [
+          rateLimitStatus.remainingRequests ?? "?",
+          " / ",
+          rateLimitStatus.limitRequests ?? "?",
+          " (Reset:",
+          " ",
+          rateLimitStatus.resetRequests ?? "?",
+          ")"
+        ] })
+      ] }),
+      rateLimitStatus.remainingTokens !== null && /* @__PURE__ */ jsxs7(Box7, { children: [
+        /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "TPM Limit:" }) }),
+        /* @__PURE__ */ jsxs7(Text7, { children: [
+          rateLimitStatus.remainingTokens ?? "?",
+          " / ",
+          rateLimitStatus.limitTokens ?? "?",
+          " (Reset:",
+          " ",
+          rateLimitStatus.resetTokens ?? "?",
+          ")"
+        ] })
+      ] })
+    ] }),
+    maxCost !== null && /* @__PURE__ */ jsxs7(Box7, { marginBottom, children: [
+      /* @__PURE__ */ jsx12(Box7, { width: 20, children: /* @__PURE__ */ jsx12(Text7, { children: "Max Cost:" }) }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        "$",
+        maxCost.toFixed(2)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Text7, { bold: true, children: "Auto-approvals (up/down & space to toggle):" }),
+      selectableOptions.map((option, index) => {
+        const isSelected = index === selectedIndex && focusedArea === "status";
+        return /* @__PURE__ */ jsx12(Box7, { children: /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "cyan" : "white", children: [
+          isSelected ? "> " : "  ",
+          option.label,
+          "isAction" in option ? "" : `: ${option.value ? "ON" : "OFF"}`
+        ] }) }, option.label);
+      })
+    ] })
+  ] });
+}
+
+// ink/components/UserInput.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { useCallback as useCallback3, useState as useState11 } from "react";
+
+// ink/components/BlinkingTextInput.tsx
+import chalk from "chalk";
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import { useEffect as useEffect5, useMemo as useMemo8, useReducer, useState as useState10 } from "react";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var reducer = (state, action) => {
+  switch (action.type) {
+    case "move-cursor-left":
+      return {
+        ...state,
+        cursorOffset: Math.max(0, state.cursorOffset - 1)
+      };
+    case "move-cursor-right":
+      return {
+        ...state,
+        cursorOffset: Math.min(state.value.length, state.cursorOffset + 1)
+      };
+    case "insert":
+      return {
+        ...state,
+        previousValue: state.value,
+        value: state.value.slice(0, state.cursorOffset) + action.text + state.value.slice(state.cursorOffset),
+        cursorOffset: state.cursorOffset + action.text.length
+      };
+    case "newline":
+      return {
+        ...state,
+        previousValue: state.value,
+        value: state.value.slice(0, state.cursorOffset) + "\n" + state.value.slice(state.cursorOffset),
+        cursorOffset: state.cursorOffset + 1
+      };
+    case "delete": {
+      const newCursorOffset = Math.max(0, state.cursorOffset - 1);
+      return {
+        ...state,
+        previousValue: state.value,
+        value: state.value.slice(0, newCursorOffset) + state.value.slice(state.cursorOffset),
+        cursorOffset: newCursorOffset
+      };
+    }
+    default:
+      return state;
+  }
+};
+function BlinkingTextInput({
+  isDisabled = false,
+  defaultValue = "",
+  placeholder = "",
+  suggestions = [],
+  onChange,
+  onSubmit
+}) {
+  const [state, dispatch] = useReducer(reducer, {
+    value: defaultValue,
+    previousValue: defaultValue,
+    cursorOffset: defaultValue.length
+  });
+  const [isCursorVisible, setIsCursorVisible] = useState10(true);
+  useEffect5(() => {
+    if (isDisabled) {
+      setIsCursorVisible(false);
+      return;
+    }
+    const interval = setInterval(() => {
+      setIsCursorVisible((prev) => !prev);
+    }, 500);
+    return () => clearInterval(interval);
+  }, [isDisabled]);
+  useEffect5(() => {
+    if (state.value !== state.previousValue) {
+      onChange?.(state.value);
+    }
+  }, [state.value, state.previousValue, onChange]);
+  const suggestion = useMemo8(() => {
+    if (state.value.length === 0) {
+      return "";
+    }
+    return suggestions.find((s) => s.startsWith(state.value))?.slice(state.value.length) || "";
+  }, [state.value, suggestions]);
+  useInput3(
+    (input, key) => {
+      if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
+        return;
+      }
+      setIsCursorVisible(true);
+      if (key.return) {
+        if (key.meta) {
+          dispatch({ type: "newline" });
+          return;
+        }
+        if (suggestion) {
+          onSubmit?.(state.value + suggestion);
+        } else {
+          onSubmit?.(state.value);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        dispatch({ type: "move-cursor-left" });
+      } else if (key.rightArrow) {
+        dispatch({ type: "move-cursor-right" });
+      } else if (key.backspace || key.delete) {
+        dispatch({ type: "delete" });
+      } else if (input) {
+        dispatch({ type: "insert", text: input });
+      }
+    },
+    { isActive: !isDisabled }
+  );
+  const renderedValue = useMemo8(() => {
+    if (isDisabled) {
+      const lines2 = (state.value || (placeholder ? chalk.dim(placeholder) : "")).split("\n");
+      return /* @__PURE__ */ jsx13(Box8, { flexDirection: "column", children: lines2.map((line, i) => /* @__PURE__ */ jsx13(Box8, { children: /* @__PURE__ */ jsx13(Text8, { children: line }) }, i)) });
+    }
+    if (state.value.length === 0) {
+      let displayContent = "";
+      if (placeholder && placeholder.length > 0) {
+        displayContent = (isCursorVisible ? chalk.inverse(placeholder[0]) : placeholder[0]) + chalk.dim(placeholder.slice(1));
+      } else {
+        displayContent = isCursorVisible ? chalk.inverse(" ") : " ";
+      }
+      return /* @__PURE__ */ jsx13(Box8, { flexGrow: 1, minWidth: 1, children: /* @__PURE__ */ jsx13(Text8, { wrap: "end", children: displayContent }) });
+    }
+    const lines = state.value.split("\n");
+    const result = [];
+    let totalOffset = 0;
+    lines.forEach((line, lineIndex) => {
+      let lineContent = "";
+      for (let i = 0; i < line.length; i++) {
+        const char = line[i];
+        if (totalOffset === state.cursorOffset) {
+          lineContent += isCursorVisible ? chalk.inverse(char) : char;
+        } else {
+          lineContent += char;
+        }
+        totalOffset++;
+      }
+      if (totalOffset === state.cursorOffset) {
+        if (lineIndex === lines.length - 1 && suggestion) {
+          lineContent += (isCursorVisible ? chalk.inverse(suggestion[0]) : suggestion[0]) + chalk.dim(suggestion.slice(1));
+        } else {
+          lineContent += isCursorVisible ? chalk.inverse(" ") : " ";
+        }
+      } else if (lineIndex === lines.length - 1 && suggestion) {
+        lineContent += chalk.dim(suggestion);
+      }
+      result.push(
+        /* @__PURE__ */ jsx13(Box8, { flexGrow: 1, children: /* @__PURE__ */ jsx13(Text8, { wrap: "end", children: lineContent }) }, lineIndex)
+      );
+      if (lineIndex < lines.length - 1) {
+        totalOffset++;
+      }
+    });
+    return /* @__PURE__ */ jsx13(Box8, { flexDirection: "column", flexGrow: 1, children: result });
+  }, [state.value, state.cursorOffset, suggestion, isCursorVisible, isDisabled, placeholder]);
+  return /* @__PURE__ */ jsx13(Box8, { flexGrow: 1, minWidth: 1, children: renderedValue });
+}
+
+// ink/components/UserInput.tsx
+import { jsx as jsx14, jsxs as jsxs8 } from "react/jsx-runtime";
+var execAsync = promisify(exec);
+var modeSuggestion = {
+  approved: ["/clear", "/skills", "/exit"],
+  approving: ["yes", "approve", "no", "deny"],
+  denied: [],
+  waiting: ["/clear", "/skills", "/exit"]
+};
+function UserInput() {
+  const { userInputMode, focusedArea } = useChat();
+  const [resetKey, setResetKey] = useState11(0);
+  const [, setBlankLines] = useState11(0);
+  useListener("ClearUserInput", () => {
+    setResetKey((prev) => prev + 1);
+  }, []);
+  const borderColor = focusedArea === "input" ? "cyan" : "gray";
+  const placeholder = calculatePlaceholder(userInputMode);
+  const onSubmitResetKey = useCallback3(async (value) => {
+    if (value.length) {
+      const trimmedValue = value.trim();
+      if (trimmedValue === "/clear") {
+        setResetKey((prev) => prev + 1);
+        emitToListeners("ClearChatHistory", void 0);
+        return;
+      }
+      if (trimmedValue === "/exit" || trimmedValue === "exit") {
+        await handleExit();
+        return;
+      }
+      if (trimmedValue === "/skills") {
+        setResetKey((prev) => prev + 1);
+        emitToListeners("PushNewMessages", [{
+          type: "user",
+          text: "/skills",
+          version: 1
+        }, {
+          type: "agent",
+          text: "Installing skills...",
+          version: 1
+        }]);
+        try {
+          const { stdout, stderr } = await execAsync("npx skills add harperfast/skills");
+          emitToListeners(
+            "UpdateLastMessageText",
+            `
+
+Skills installation result:
+${stdout}${stderr ? `
+Errors:
+${stderr}` : ""}`
+          );
+        } catch (error) {
+          emitToListeners("UpdateLastMessageText", `
+
+Failed to install skills: ${error.message}`);
+        }
+        return;
+      }
+      setResetKey((prev) => prev + 1);
+      emitToListeners("PushNewMessages", [{ type: "user", text: trimmedValue, version: 1 }]);
+      setBlankLines(0);
+    } else {
+      setBlankLines((value2) => {
+        value2 += 1;
+        if (value2 === 2) {
+          void handleExit();
+        }
+        return value2;
+      });
+    }
+  }, []);
+  return /* @__PURE__ */ jsxs8(
+    Box9,
+    {
+      minHeight: footerHeight,
+      borderStyle: "bold",
+      borderTop: false,
+      borderColor,
+      flexDirection: "row",
+      alignItems: "flex-start",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx14(Box9, { marginLeft: 1, height: 1, children: /* @__PURE__ */ jsx14(Text9, { bold: true, color: borderColor, children: "\u276F" }) }),
+        /* @__PURE__ */ jsx14(Box9, { flexGrow: 1, children: /* @__PURE__ */ jsx14(
+          BlinkingTextInput,
+          {
+            placeholder,
+            onSubmit: onSubmitResetKey,
+            suggestions: modeSuggestion[userInputMode],
+            isDisabled: focusedArea !== "input"
+          },
+          resetKey
+        ) })
+      ]
+    }
+  );
+}
+function calculatePlaceholder(mode) {
+  const prefix = "  ";
+  switch (mode) {
+    case "denied":
+      return prefix + "OK! Let's find another way.";
+    case "approving":
+      return prefix + "Do you approve? yes / no";
+    default:
+    case "approved":
+    case "waiting":
+      return "";
+  }
+}
+
+// ink/components/ChatContent.tsx
+import { jsx as jsx15, jsxs as jsxs9 } from "react/jsx-runtime";
+function ChatContent() {
+  const { messages, isThinking, isCompacting, pullingState, focusedArea, setFocusedArea } = useChat();
+  const { payload } = useApproval();
+  const size = useTerminalSize();
+  useMessageListener();
+  const [activeTab, setActiveTab] = useState12("settings");
+  const [userHasSwitchedTab, setUserHasSwitchedTab] = useState12(false);
+  const { planDescription, planItems } = usePlan();
+  useEffect6(() => {
+    if (!userHasSwitchedTab && activeTab === "settings") {
+      const hasPlan = planDescription.trim().length > 0 || planItems.length > 0;
+      if (hasPlan) {
+        setActiveTab("planDescription");
+      }
+    }
+  }, [planDescription, planItems, userHasSwitchedTab, activeTab]);
+  const [selectedIndex, setSelectedIndex] = useState12(0);
+  const wrapCache = useRef2(
+    /* @__PURE__ */ new Map()
+  );
+  useInput4((input, key) => {
+    if (key.tab) {
+      const focusOrder = ["input", "timeline", "status"];
+      const currentIndex = focusOrder.indexOf(focusedArea);
+      if (key.shift || input === "\x1B[Z") {
+        const nextIndex = (currentIndex - 1 + focusOrder.length) % focusOrder.length;
+        setFocusedArea(focusOrder[nextIndex]);
+      } else {
+        const nextIndex = (currentIndex + 1) % focusOrder.length;
+        setFocusedArea(focusOrder[nextIndex]);
+      }
+      return;
+    }
+    if (focusedArea === "timeline") {
+      if (key.upArrow) {
+        setSelectedIndex((prev) => Math.max(0, prev - 1));
+      }
+      if (key.downArrow) {
+        setSelectedIndex((prev) => Math.min(Math.max(0, lineItems.length - 1), prev + 1));
+      }
+      if (key.return) {
+        const selected = lineItems[selectedIndex];
+        if (selected && selected.type === "tool" && (selected.toolName === "apply_patch" || selected.toolName === "code_interpreter" || selected.toolName === "shell")) {
+          const msg = messages.find((m) => m.id === selected.messageId);
+          if (msg && msg.callId) {
+            emitToListeners("OpenApprovalViewer", {
+              type: selected.toolName,
+              mode: "info",
+              callId: msg.callId
+            });
+          }
+        }
+      }
+    }
+    if (focusedArea === "status") {
+      if (key.leftArrow || key.rightArrow) {
+        const tabNames = ["settings", "planDescription", "actions"];
+        const currentIndex = tabNames.indexOf(activeTab);
+        if (key.leftArrow) {
+          const nextIndex = (currentIndex - 1 + tabNames.length) % tabNames.length;
+          const newTab = tabNames[nextIndex];
+          setActiveTab(newTab);
+          setUserHasSwitchedTab(true);
+        } else {
+          const nextIndex = (currentIndex + 1) % tabNames.length;
+          const newTab = tabNames[nextIndex];
+          setActiveTab(newTab);
+          setUserHasSwitchedTab(true);
+        }
+      }
+    }
+    if (key.ctrl && input === "x") {
+      void handleExit();
+    }
+    if (key.escape && isThinking && focusedArea === "input" && !payload) {
+      emitToListeners("InterruptThought", void 0);
+    }
+  });
+  const contentHeight = size.rows - footerHeight;
+  const timelineWidth = Math.floor(size.columns * 0.65);
+  const statusWidth = size.columns - timelineWidth;
+  const labelWidthFor = useCallback4((type) => {
+    if (type === "agent") {
+      return 7;
+    }
+    if (type === "prompt") {
+      return 7;
+    }
+    if (type === "user") {
+      return 6;
+    }
+    if (type === "interrupted") {
+      return 0;
+    }
+    return 6;
+  }, []);
+  const availableTextWidth = timelineWidth - 4;
+  const pullingHeight = pullingState ? 1 : 0;
+  const lineItems = useMemo9(() => {
+    const acc = [];
+    for (const msg of messages) {
+      const labelWidth = labelWidthFor(msg.type);
+      const firstLineWidth = Math.max(1, availableTextWidth - labelWidth);
+      let entry = wrapCache.current.get(msg.id);
+      if (!entry || entry.version !== msg.version || entry.width !== firstLineWidth) {
+        const textLines = wrapText(msg.text ?? "", firstLineWidth);
+        const argsLines = msg.args ? wrapText(String(msg.args), firstLineWidth) : [];
+        const msgLineItems = [];
+        if (msg.type === "tool") {
+          const toolName = msg.text ?? "";
+          const toolArgs = msg.args ?? "";
+          const toolNameWithSpace = `${toolName} `;
+          const availableForArgs = firstLineWidth - toolNameWithSpace.length;
+          let displayedArgs = toolArgs;
+          if (availableForArgs < toolArgs.length) {
+            if (availableForArgs > 3) {
+              displayedArgs = toolArgs.slice(0, availableForArgs - 3) + "...";
+            } else {
+              displayedArgs = toolArgs.slice(0, Math.max(0, availableForArgs));
+            }
+          }
+          msgLineItems.push({
+            key: `${msg.id}:tool:0`,
+            messageId: msg.id,
+            type: msg.type,
+            text: `${toolNameWithSpace}${displayedArgs}`,
+            isFirstLine: true,
+            toolName
+          });
+        } else {
+          textLines.forEach((txt, idx) => {
+            msgLineItems.push({
+              key: `${msg.id}:text:${idx}`,
+              messageId: msg.id,
+              type: msg.type,
+              text: txt,
+              isFirstLine: idx === 0
+            });
+          });
+          if (argsLines.length > 0) {
+            argsLines.forEach((txt, idx) => {
+              msgLineItems.push({
+                key: `${msg.id}:args:${idx}`,
+                messageId: msg.id,
+                type: msg.type,
+                text: txt,
+                isFirstLine: idx === 0 && textLines.length === 0,
+                isArgsLine: true
+              });
+            });
+          }
+        }
+        entry = { version: msg.version, width: firstLineWidth, lineItems: msgLineItems };
+        wrapCache.current.set(msg.id, entry);
+      }
+      acc.push(...entry.lineItems);
+    }
+    if (wrapCache.current.size > messages.length * 2) {
+      const messageIds = new Set(messages.map((m) => m.id));
+      for (const id of wrapCache.current.keys()) {
+        if (!messageIds.has(id)) {
+          wrapCache.current.delete(id);
+        }
+      }
+    }
+    return acc;
+  }, [messages, availableTextWidth, labelWidthFor]);
+  useEffect6(() => {
+    if (lineItems.length > 0 && focusedArea !== "timeline") {
+      setSelectedIndex(lineItems.length - 1);
+    }
+  }, [lineItems.length, focusedArea]);
+  useEffect6(() => {
+    if (lineItems.length > 0) {
+      setSelectedIndex(lineItems.length - 1);
+    }
+  }, [size.rows, size.columns]);
+  const tabs = useMemo9(() => [
+    { name: "settings", label: "SETTINGS" },
+    { name: "planDescription", label: "PLAN" },
+    { name: "actions", label: "ACTIONS" }
+  ], []);
+  const timelineTitle = "TIMELINE:";
+  const timelineHeaderWidth = timelineWidth - 1;
+  const showSpinner = isCompacting || isThinking || Boolean(pullingState);
+  const timelineDashes = timelineHeaderWidth - timelineTitle.length - (showSpinner ? 5 : 0);
+  const tabsTotalWidth = tabs.reduce((acc, t) => acc + t.label.length + 2, 0) + (tabs.length - 1);
+  const statusDashes = Math.max(0, statusWidth - tabsTotalWidth - 2);
+  const timelineColor = focusedArea === "timeline" ? "cyan" : "gray";
+  const statusColor = focusedArea === "status" ? "cyan" : "gray";
+  const dividerColor = focusedArea === "timeline" || focusedArea === "status" ? "cyan" : "gray";
+  const timelineBottomColor = focusedArea === "timeline" || focusedArea === "input" ? "cyan" : "gray";
+  const statusBottomColor = focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
+  const junctionLeftColor = focusedArea === "timeline" || focusedArea === "input" ? "cyan" : "gray";
+  const junctionMiddleColor = focusedArea === "timeline" || focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
+  const junctionRightColor = focusedArea === "status" || focusedArea === "input" ? "cyan" : "gray";
+  const timelinePipeFiller = useCallback4((count) => /* @__PURE__ */ jsx15(Box10, { flexDirection: "column", children: Array.from({ length: count }).map((_, i) => /* @__PURE__ */ jsx15(Box10, { children: /* @__PURE__ */ jsx15(Text10, { color: "gray", dimColor: true, children: "\u2502" }) }, i)) }), []);
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", height: size.rows, padding: 0, children: [
+    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: 1, children: [
+      /* @__PURE__ */ jsx15(Text10, { color: timelineColor, children: "\u256D" }),
+      /* @__PURE__ */ jsx15(Text10, { bold: true, color: timelineColor, children: timelineTitle }),
+      showSpinner && /* @__PURE__ */ jsx15(Box10, { paddingLeft: 2, paddingRight: 1, children: /* @__PURE__ */ jsx15(Spinner2, { type: "clock" }) }),
+      /* @__PURE__ */ jsx15(Text10, { color: timelineColor, children: "\u2500".repeat(Math.max(0, timelineDashes)) }),
+      /* @__PURE__ */ jsx15(Text10, { color: dividerColor, children: "\u252C" }),
+      tabs.map((tab, i) => /* @__PURE__ */ jsxs9(React10.Fragment, { children: [
+        /* @__PURE__ */ jsx15(
+          Text10,
+          {
+            color: activeTab === tab.name ? "black" : statusColor,
+            backgroundColor: activeTab === tab.name ? statusColor : "",
+            bold: activeTab === tab.name,
+            children: ` ${tab.label} `
+          }
+        ),
+        i < tabs.length - 1 && /* @__PURE__ */ jsx15(Text10, { color: statusColor, children: "|" })
+      ] }, tab.name)),
+      /* @__PURE__ */ jsxs9(Text10, { color: statusColor, children: [
+        "\u2500".repeat(statusDashes),
+        "\u256E"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: contentHeight - 2 - pullingHeight, children: [
+      /* @__PURE__ */ jsx15(
+        Box10,
+        {
+          flexDirection: "column",
+          width: timelineWidth,
+          paddingLeft: 0,
+          paddingRight: 1,
+          children: /* @__PURE__ */ jsx15(Box10, { flexDirection: "column", flexGrow: 1, children: /* @__PURE__ */ jsx15(
+            VirtualList,
+            {
+              items: lineItems,
+              itemHeight: 1,
+              height: contentHeight - 2 - pullingHeight,
+              selectedIndex,
+              renderOverflowTop: useCallback4((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
+                /* @__PURE__ */ jsx15(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
+                count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
+                  " ",
+                  "\u25B2 ",
+                  count,
+                  " more"
+                ] })
+              ] }), []),
+              renderOverflowBottom: useCallback4((count) => /* @__PURE__ */ jsxs9(Box10, { children: [
+                /* @__PURE__ */ jsx15(Text10, { color: "gray", dimColor: true, children: "\u2502" }),
+                count > 0 && /* @__PURE__ */ jsxs9(Text10, { dimColor: true, children: [
+                  " ",
+                  "\u25BC ",
+                  count,
+                  " more"
+                ] })
+              ] }), []),
+              renderFiller: timelinePipeFiller,
+              keyExtractor: (it) => it.key,
+              renderItem: useCallback4(
+                ({ item, isSelected }) => /* @__PURE__ */ jsx15(
+                  MessageLineItem,
+                  {
+                    item,
+                    isSelected,
+                    isFocused: focusedArea === "timeline",
+                    indent: item.isFirstLine ? 0 : labelWidthFor(item.type)
+                  }
+                ),
+                [labelWidthFor, focusedArea]
+              )
+            }
+          ) })
+        }
+      ),
+      activeTab !== "shell" && activeTab !== "actions" && /* @__PURE__ */ jsx15(
+        Box10,
+        {
+          flexDirection: "column",
+          width: 1,
+          borderStyle: "round",
+          borderColor: dividerColor,
+          borderTop: false,
+          borderBottom: false,
+          borderRight: false
+        }
+      ),
+      /* @__PURE__ */ jsx15(
+        Box10,
+        {
+          flexDirection: "column",
+          width: activeTab === "shell" || activeTab === "actions" ? statusWidth : statusWidth - 1,
+          borderStyle: "round",
+          borderColor: statusColor,
+          borderTop: false,
+          borderBottom: false,
+          borderLeft: false,
+          paddingLeft: activeTab === "shell" || activeTab === "actions" ? 0 : 1,
+          paddingRight: 1,
+          children: /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", flexGrow: 1, marginTop: 0, children: [
+            activeTab === "settings" && /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", children: [
+              /* @__PURE__ */ jsx15(CostView, { isDense: true }),
+              /* @__PURE__ */ jsx15(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx15(SettingsView, { isDense: true }) })
+            ] }),
+            activeTab === "planDescription" && /* @__PURE__ */ jsx15(PlanView, {}),
+            activeTab === "actions" && /* @__PURE__ */ jsx15(
+              ActionsView,
+              {
+                height: contentHeight - 2 - pullingHeight,
+                isFocused: focusedArea === "status"
+              }
+            )
+          ] })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", children: [
+      pullingState && /* @__PURE__ */ jsx15(Box10, { paddingLeft: 2, paddingRight: 2, marginBottom: 0, children: /* @__PURE__ */ jsxs9(Text10, { color: "yellow", children: [
+        `\uF019 Downloading `,
+        /* @__PURE__ */ jsx15(Text10, { bold: true, children: pullingState.modelName }),
+        ` from Ollama... `,
+        /* @__PURE__ */ jsx15(Text10, { dimColor: true, children: pullingState.status === "pulling manifest" ? "initializing" : pullingState.status }),
+        pullingState.total > 0 && /* @__PURE__ */ jsxs9(Text10, { children: [
+          ` [${"=".repeat(Math.floor(pullingState.completed / pullingState.total * 20))}${" ".repeat(20 - Math.floor(pullingState.completed / pullingState.total * 20))}] `,
+          Math.round(pullingState.completed / pullingState.total * 100),
+          "%"
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", height: 1, children: [
+        /* @__PURE__ */ jsx15(Text10, { color: junctionLeftColor, children: "\u2522" }),
+        /* @__PURE__ */ jsx15(Text10, { color: timelineBottomColor, children: "\u2501".repeat(timelineWidth - 1) }),
+        /* @__PURE__ */ jsx15(Text10, { color: junctionMiddleColor, children: "\u2537" }),
+        /* @__PURE__ */ jsx15(Text10, { color: statusBottomColor, children: "\u2501".repeat(Math.max(0, statusWidth - 2)) }),
+        /* @__PURE__ */ jsx15(Text10, { color: junctionRightColor, children: "\u252A" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx15(UserInput, {})
+  ] });
+}
+
+// ink/components/DiffApprovalView.tsx
+import { Box as Box11, Text as Text11, useInput as useInput5 } from "ink";
+import { useMemo as useMemo10, useState as useState13 } from "react";
+import { Fragment as Fragment2, jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+function DiffApprovalView() {
+  const { payload } = useApproval();
+  const size = useTerminalSize();
+  const [scrollIndex, setScrollIndex] = useState13(0);
+  const diffLines = useMemo10(() => {
+    if (!payload?.diff) {
+      return [];
+    }
+    return payload.diff.split("\n");
+  }, [payload?.diff]);
+  const wrappedLines = useMemo10(() => {
+    const result = [];
+    if (!payload) {
+      return result;
+    }
+    if (payload.type === "delete_file") {
+      result.push({ text: "Delete file: " + payload.path, color: "red" });
+      return result;
+    }
+    if (payload.type === "overwrite_file") {
+      for (const line of diffLines) {
+        let color;
+        if (line.startsWith("+")) {
+          color = "green";
+        } else if (line.startsWith("-")) {
+          color = "red";
+        }
+        const wrapped = wrapText(line, size.columns - 4);
+        for (const w of wrapped) {
+          result.push({ text: w, color });
+        }
+      }
+      return result;
+    }
+    if (payload.type === "code_interpreter" && payload.code) {
+      const lines = payload.code.split("\n");
+      for (const line of lines) {
+        const wrapped = wrapText(line, size.columns - 4);
+        for (const w of wrapped) {
+          result.push({ text: w });
+        }
+      }
+      return result;
+    }
+    if (payload.type === "shell" && payload.commands) {
+      for (const cmd of payload.commands) {
+        const wrapped = wrapText(`$ ${cmd}`, size.columns - 4);
+        for (const w of wrapped) {
+          result.push({ text: w, color: "yellow" });
+        }
+      }
+      return result;
+    }
+    for (const line of diffLines) {
+      let color;
+      if (line.startsWith("+")) {
+        color = "green";
+      } else if (line.startsWith("-")) {
+        color = "red";
+      } else if (line.startsWith("@@")) {
+        color = "cyan";
+      }
+      const wrapped = wrapText(line, size.columns - 4);
+      for (const w of wrapped) {
+        result.push({ text: w, color });
+      }
+    }
+    return result;
+  }, [diffLines, size.columns, payload]);
+  const visibleHeight = size.rows - 6;
+  useInput5((input, key) => {
+    if (!payload) {
+      return;
+    }
+    if (key.escape) {
+      if (payload.mode === "ask") {
+        emitToListeners("DenyCurrentApproval", void 0);
+      }
+      emitToListeners("CloseApprovalViewer", void 0);
+      return;
+    }
+    if (key.return) {
+      if (payload.mode === "ask") {
+        const now = Date.now();
+        if (payload.openedAt && now - payload.openedAt > 1e3) {
+          emitToListeners("ApproveCurrentApproval", void 0);
+          emitToListeners("CloseApprovalViewer", void 0);
+          emitToListeners("ClearUserInput", void 0);
+        }
+      } else {
+        emitToListeners("CloseApprovalViewer", void 0);
+      }
+      return;
+    }
+    if (payload.mode === "ask") {
+      const now = Date.now();
+      if (payload.openedAt && now - payload.openedAt > 1e3) {
+        if (input === "y") {
+          emitToListeners("ApproveCurrentApproval", void 0);
+          emitToListeners("CloseApprovalViewer", void 0);
+          emitToListeners("ClearUserInput", void 0);
+        } else if (input === "n") {
+          emitToListeners("DenyCurrentApproval", void 0);
+          emitToListeners("CloseApprovalViewer", void 0);
+          emitToListeners("ClearUserInput", void 0);
+        }
+      }
+    }
+    if (key.upArrow) {
+      setScrollIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setScrollIndex((prev) => Math.min(Math.max(0, wrappedLines.length - visibleHeight), prev + 1));
+    }
+    if (key.pageUp) {
+      setScrollIndex((prev) => Math.max(0, prev - visibleHeight));
+    }
+    if (key.pageDown) {
+      setScrollIndex((prev) => Math.min(Math.max(0, wrappedLines.length - visibleHeight), prev + visibleHeight));
+    }
+  });
+  if (!payload) {
+    return null;
+  }
+  const canRespond = payload.mode === "ask" && payload.openedAt && Date.now() - payload.openedAt > 1e3;
+  return /* @__PURE__ */ jsxs10(
+    Box11,
+    {
+      position: "absolute",
+      flexDirection: "column",
+      width: size.columns,
+      height: size.rows,
+      backgroundColor: "black",
+      borderStyle: "double",
+      borderColor: "cyan",
+      children: [
+        /* @__PURE__ */ jsxs10(
+          Box11,
+          {
+            paddingX: 1,
+            borderStyle: "single",
+            borderBottomColor: "gray",
+            borderTop: false,
+            borderLeft: false,
+            borderRight: false,
+            children: [
+              /* @__PURE__ */ jsxs10(Text11, { bold: true, color: "cyan", children: [
+                payload.mode === "ask" ? "APPROVE " : "VIEW ",
+                payload.type.toUpperCase().replace("_", " ")
+              ] }),
+              /* @__PURE__ */ jsx16(Text11, { color: "gray", children: "\u2502" }),
+              payload.path && /* @__PURE__ */ jsxs10(Fragment2, { children: [
+                /* @__PURE__ */ jsxs10(Text11, { bold: true, children: [
+                  payload.type,
+                  ":"
+                ] }),
+                /* @__PURE__ */ jsx16(Text11, { children: payload.path })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx16(Box11, { flexGrow: 1, flexDirection: "column", paddingX: 1, children: wrappedLines.length === 0 ? /* @__PURE__ */ jsx16(Text11, { italic: true, color: "gray", children: "No diff content." }) : wrappedLines.slice(scrollIndex, scrollIndex + visibleHeight).map((line, i) => /* @__PURE__ */ jsx16(Text11, { color: line.color || "white", children: line.text }, i)) }),
+        /* @__PURE__ */ jsxs10(
+          Box11,
+          {
+            paddingX: 1,
+            borderStyle: "single",
+            borderTopColor: "gray",
+            borderBottom: false,
+            borderLeft: false,
+            borderRight: false,
+            children: [
+              payload.mode === "ask" ? /* @__PURE__ */ jsxs10(Box11, { flexGrow: 1, children: [
+                /* @__PURE__ */ jsx16(Text11, { color: canRespond ? "green" : "gray", children: "[Enter/y] Approve" }),
+                /* @__PURE__ */ jsx16(Text11, {}),
+                /* @__PURE__ */ jsx16(Text11, { color: canRespond ? "red" : "gray", children: "[Esc/n] Deny" }),
+                !canRespond && /* @__PURE__ */ jsx16(Text11, { color: "yellow", children: "(Wait 1s...)" })
+              ] }) : /* @__PURE__ */ jsx16(Box11, { flexGrow: 1, children: /* @__PURE__ */ jsx16(Text11, { color: "cyan", children: "[Enter/Esc] Close" }) }),
+              /* @__PURE__ */ jsxs10(Text11, { color: "gray", children: [
+                "Line ",
+                scrollIndex + 1,
+                "/",
+                wrappedLines.length
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+
+// ink/configurationWizard/ConfigurationWizard.tsx
+import { Box as Box18, useInput as useInput10 } from "ink";
+import { Step, Stepper } from "ink-stepper";
+import { useEffect as useEffect12, useState as useState15 } from "react";
+
+// utils/files/getEnvVarForProvider.ts
+function getEnvVarForProvider(provider) {
+  switch (provider) {
+    case "Anthropic":
+      return "ANTHROPIC_API_KEY";
+    case "Google":
+      return "GOOGLE_GENERATIVE_AI_API_KEY";
+    case "OpenAI":
+      return "OPENAI_API_KEY";
+    case "Ollama":
+      return "OLLAMA_BASE_URL";
+  }
+}
+
+// utils/files/updateEnvKeyForProvider.ts
+function updateEnvKeyForProvider(provider, key) {
+  const envVar = getEnvVarForProvider(provider);
+  return updateEnv(envVar, key);
+}
+
+// ink/configurationWizard/ApiKeyStep.tsx
+import { PasswordInput } from "@inkjs/ui";
+import { Box as Box12, Text as Text12, useInput as useInput6 } from "ink";
+import { useStepperInput } from "ink-stepper";
+import { useEffect as useEffect7 } from "react";
+import { jsx as jsx17, jsxs as jsxs11 } from "react/jsx-runtime";
+function ApiKeyStep({ provider, onConfirm, onBack }) {
+  const { disableNavigation, enableNavigation } = useStepperInput();
+  useEffect7(() => {
+    disableNavigation();
+    return () => enableNavigation();
+  }, [disableNavigation, enableNavigation]);
+  useInput6((input, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  const instructions = {
+    OpenAI: "Get your key at: https://platform.openai.com/api-keys",
+    Anthropic: "Get your key at: https://console.anthropic.com/settings/keys",
+    Google: "Get your key at: https://aistudio.google.com/app/apikey",
+    Ollama: ""
+  };
+  return /* @__PURE__ */ jsxs11(Box12, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs11(Text12, { children: [
+      "Can you provide us with your ",
+      provider,
+      " API key?"
+    ] }),
+    /* @__PURE__ */ jsx17(Text12, { dimColor: true, children: instructions[provider] }),
+    /* @__PURE__ */ jsx17(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx17(
+      PasswordInput,
+      {
+        onSubmit: (v) => {
+          if (v === "exit") {
+            emitToListeners("ExitUI", void 0);
+          } else {
+            onConfirm(v);
+          }
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsx17(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx17(Text12, { dimColor: true, children: "Press ESC to go back" }) })
+  ] });
+}
+
+// ink/configurationWizard/ApiUrlStep.tsx
+import { Box as Box13, Text as Text13, useInput as useInput7 } from "ink";
+import { useStepperInput as useStepperInput2 } from "ink-stepper";
+import { useEffect as useEffect8 } from "react";
+import { jsx as jsx18, jsxs as jsxs12 } from "react/jsx-runtime";
+function ApiUrlStep({ provider, onConfirm, onBack }) {
+  const { disableNavigation, enableNavigation } = useStepperInput2();
+  useEffect8(() => {
+    disableNavigation();
+    return () => enableNavigation();
+  }, [disableNavigation, enableNavigation]);
+  useInput7((input, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  const defaultApi = {
+    OpenAI: "",
+    Anthropic: "",
+    Google: "",
+    Ollama: "http://localhost:11434/api"
+  };
+  return /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs12(Text13, { children: [
+      "Where are you hosting ",
+      provider,
+      "?"
+    ] }),
+    /* @__PURE__ */ jsx18(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx18(
+      BlinkingTextInput,
+      {
+        placeholder: defaultApi[provider] || "",
+        onSubmit: (v) => {
+          if (v === "exit") {
+            emitToListeners("ExitUI", void 0);
+          } else {
+            onConfirm(v || defaultApi[provider] || "");
+          }
+        }
+      }
+    ) }),
+    /* @__PURE__ */ jsx18(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx18(Text13, { dimColor: true, children: "Press ESC to go back" }) })
+  ] });
+}
+
+// ink/configurationWizard/EnvironmentSettingsStep.tsx
+import { MultiSelect } from "@inkjs/ui";
+import { Box as Box14, Text as Text14, useInput as useInput8 } from "ink";
+import { useStepperInput as useStepperInput3 } from "ink-stepper";
+import { useEffect as useEffect9 } from "react";
+import { jsx as jsx19, jsxs as jsxs13 } from "react/jsx-runtime";
+var SETTINGS = [
+  {
+    label: "Save Harper agent memory locally",
+    value: "HARPER_AGENT_SESSION",
+    defaultValue: "./harper-agent-memory.json"
+  },
+  {
+    label: "Automatically approve code interpreter execution",
+    value: "HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER",
+    defaultValue: "1"
+  },
+  {
+    label: "Automatically approve file patches",
+    value: "HARPER_AGENT_AUTO_APPROVE_PATCHES",
+    defaultValue: "1"
+  },
+  {
+    label: "Automatically approve shell commands",
+    value: "HARPER_AGENT_AUTO_APPROVE_SHELL",
+    defaultValue: "1"
+  },
+  {
+    label: "Use flex tier for lower costs when possible",
+    value: "HARPER_AGENT_FLEX_TIER",
+    defaultValue: "true"
+  }
+];
+function EnvironmentSettingsStep({ onConfirm, onBack }) {
+  const { disableNavigation, enableNavigation } = useStepperInput3();
+  useEffect9(() => {
+    disableNavigation();
+    return () => enableNavigation();
+  }, [disableNavigation, enableNavigation]);
+  useInput8((_input, key) => {
+    if (key.escape) {
+      onBack();
+    }
+  });
+  const options = SETTINGS.map((s) => ({
+    label: s.label,
+    value: s.value
+  }));
+  const defaultValues = SETTINGS.map((s) => s.value);
+  const handleSubmit = (values) => {
+    for (const setting of SETTINGS) {
+      if (values.includes(setting.value)) {
+        updateEnv(setting.value, setting.defaultValue);
+      }
+    }
+    onConfirm();
+  };
+  return /* @__PURE__ */ jsxs13(Box14, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx19(Text14, { children: "Additional Settings (all enabled by default):" }),
+    /* @__PURE__ */ jsx19(
+      MultiSelect,
+      {
+        options,
+        defaultValue: defaultValues,
+        onSubmit: handleSubmit
+      }
+    ),
+    /* @__PURE__ */ jsxs13(Text14, { color: "gray", children: [
+      "Press ",
+      "<space>",
+      " to toggle, ",
+      "<enter>",
+      " to confirm."
+    ] })
+  ] });
+}
+
+// ink/configurationWizard/modelsByProvider.ts
+var modelsByProvider = {
+  OpenAI: [defaultOpenAIModel, "gpt-5.0", defaultOpenAICompactionModel],
+  Anthropic: [defaultAnthropicModel, "claude-4-5-sonnet-latest", defaultAnthropicCompactionModel],
+  Google: [defaultGoogleModel, "gemini-3-flash", "gemini-2.5-flash", defaultGoogleCompactionModel],
+  Ollama: [defaultOllamaModel, "ollama-qwen3.5:27b", defaultOllamaCompactionModel]
+};
+var compactorModelsByProvider = {
+  OpenAI: modelsByProvider.OpenAI.slice().reverse(),
+  Anthropic: modelsByProvider.Anthropic.slice().reverse(),
+  Google: modelsByProvider.Google.slice().reverse(),
+  Ollama: modelsByProvider.Ollama.slice().reverse()
+};
+
+// ink/configurationWizard/ModelSelectionStep.tsx
+import { Select } from "@inkjs/ui";
+import { Box as Box15, Text as Text15, useInput as useInput9 } from "ink";
+import { useStepperInput as useStepperInput4 } from "ink-stepper";
+import { useEffect as useEffect10, useState as useState14 } from "react";
+import { jsx as jsx20, jsxs as jsxs14 } from "react/jsx-runtime";
+function ModelSelectionStep({
+  title,
+  models,
+  onConfirm,
+  onBack
+}) {
+  const { disableNavigation, enableNavigation } = useStepperInput4();
+  const [isCustom, setIsCustom] = useState14(false);
+  useEffect10(() => {
+    disableNavigation();
+    return () => enableNavigation();
+  }, [isCustom, disableNavigation, enableNavigation]);
+  useInput9((input, key) => {
+    if (key.escape) {
+      if (isCustom) {
+        setIsCustom(false);
+      } else {
+        onBack();
+      }
+    }
+  });
+  if (isCustom) {
+    return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs14(Text15, { children: [
+        "Enter custom model name for: ",
+        title
+      ] }),
+      /* @__PURE__ */ jsx20(
+        BlinkingTextInput,
+        {
+          onSubmit: (v) => {
+            if (v === "exit") {
+              emitToListeners("ExitUI", void 0);
+            } else {
+              onConfirm(v);
+            }
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx20(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text15, { dimColor: true, children: "Press ESC to go back to list" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx20(Text15, { children: title }),
+    /* @__PURE__ */ jsx20(
+      Select,
+      {
+        options: [
+          ...models.map((m) => ({ label: m, value: m })),
+          { label: "Other...", value: "other" }
+        ],
+        onChange: (v) => {
+          if (v === "other") {
+            setIsCustom(true);
+          } else {
+            onConfirm(v);
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx20(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx20(Text15, { dimColor: true, children: "Press ESC to go back" }) })
+  ] });
+}
+
+// ink/configurationWizard/ProviderStep.tsx
+import { Select as Select2 } from "@inkjs/ui";
+import { Box as Box16, Text as Text16 } from "ink";
+import { useStepperInput as useStepperInput5 } from "ink-stepper";
+import { useEffect as useEffect11 } from "react";
+
+// ink/configurationWizard/providers.ts
+var providers = [
+  { label: "OpenAI", value: "OpenAI" },
+  { label: "Anthropic", value: "Anthropic" },
+  { label: "Google", value: "Google" },
+  { label: "Ollama", value: "Ollama" }
+];
+
+// ink/configurationWizard/ProviderStep.tsx
+import { jsx as jsx21, jsxs as jsxs15 } from "react/jsx-runtime";
+function ProviderStep({ onConfirm }) {
+  const { disableNavigation, enableNavigation } = useStepperInput5();
+  useEffect11(() => {
+    disableNavigation();
+    return () => enableNavigation();
+  }, [disableNavigation, enableNavigation]);
+  return /* @__PURE__ */ jsxs15(Box16, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx21(Text16, { children: "What model provider would you like to use today?" }),
+    /* @__PURE__ */ jsx21(
+      Select2,
+      {
+        options: providers,
+        onChange: (v) => onConfirm(v)
+      }
+    )
+  ] });
+}
+
+// ink/configurationWizard/StepperProgress.tsx
+import { Box as Box17, Text as Text17 } from "ink";
+import { Fragment as Fragment3 } from "react";
+import { jsx as jsx22, jsxs as jsxs16 } from "react/jsx-runtime";
+var markers = {
+  completed: " \u2713 ",
+  current: " \u25CF ",
+  pending: " \u25CB "
+};
+var SEGMENT_WIDTH = 12;
+function StepperProgress({ steps, currentStep }) {
+  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx22(Box17, { children: steps.map((step) => {
+      return /* @__PURE__ */ jsx22(Box17, { width: SEGMENT_WIDTH, justifyContent: "center", children: /* @__PURE__ */ jsx22(
+        Text17,
+        {
+          color: step.completed ? "green" : step.current ? "cyan" : "gray",
+          bold: step.current,
+          dimColor: !step.completed && !step.current,
+          children: step.name
+        }
+      ) }, step.name);
+    }) }),
+    /* @__PURE__ */ jsx22(Box17, { children: steps.map((step, idx) => {
+      const marker = step.completed ? markers.completed : step.current ? markers.current : markers.pending;
+      const beforeLineColor = step.completed || idx <= currentStep ? "green" : "gray";
+      const afterLineColor = step.completed ? "green" : "gray";
+      const markerColor = step.completed ? "green" : step.current ? "cyan" : "gray";
+      return /* @__PURE__ */ jsxs16(Fragment3, { children: [
+        /* @__PURE__ */ jsx22(Text17, { color: beforeLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 2) }),
+        /* @__PURE__ */ jsx22(Text17, { color: markerColor, bold: step.current, children: marker }),
+        /* @__PURE__ */ jsx22(Text17, { color: afterLineColor, children: "\u2501".repeat(SEGMENT_WIDTH / 2 - 1) })
+      ] }, step.name);
+    }) })
+  ] });
+}
+
+// ink/configurationWizard/ConfigurationWizard.tsx
+import { jsx as jsx23, jsxs as jsxs17 } from "react/jsx-runtime";
+function ConfigurationWizard({ onComplete }) {
+  const [provider, setProvider] = useState15("OpenAI");
+  const [ollamaModels, setOllamaModels] = useState15([]);
+  useEffect12(() => {
+    if (provider === "Ollama") {
+      fetchOllamaModels().then((models2) => {
+        if (models2.length > 0) {
+          setOllamaModels(models2);
+        }
+      });
+    }
+  }, [provider]);
+  useInput10((input, key) => {
+    if (key.ctrl && input === "x") {
+      emitToListeners("ExitUI", void 0);
+    }
+  });
+  const models = provider === "Ollama" && ollamaModels.length > 0 ? [.../* @__PURE__ */ new Set([...ollamaModels, ...modelsByProvider[provider]])] : modelsByProvider[provider];
+  const compactorModels = provider === "Ollama" && ollamaModels.length > 0 ? [.../* @__PURE__ */ new Set([...ollamaModels, ...compactorModelsByProvider[provider]])] : compactorModelsByProvider[provider];
+  return /* @__PURE__ */ jsx23(Box18, { flexDirection: "column", padding: 1, minHeight: 10, children: /* @__PURE__ */ jsxs17(
+    Stepper,
+    {
+      onComplete,
+      onCancel: curryEmitToListeners("ExitUI", void 0),
+      keyboardNav: true,
+      renderProgress: StepperProgress,
+      children: [
+        /* @__PURE__ */ jsx23(Step, { name: "AI Provider", children: ({ goNext }) => /* @__PURE__ */ jsx23(
+          ProviderStep,
+          {
+            onConfirm: (p) => {
+              setProvider(p);
+              goNext();
+            }
+          }
+        ) }),
+        /* @__PURE__ */ jsx23(Step, { name: provider !== "Ollama" ? "API Key" : "API", children: ({ goNext, goBack }) => provider !== "Ollama" ? /* @__PURE__ */ jsx23(
+          ApiKeyStep,
+          {
+            provider,
+            onConfirm: (key) => {
+              updateEnvKeyForProvider(provider, key);
+              goNext();
+            },
+            onBack: goBack
+          }
+        ) : /* @__PURE__ */ jsx23(
+          ApiUrlStep,
+          {
+            provider,
+            onConfirm: (key) => {
+              updateEnvKeyForProvider(provider, key);
+              goNext();
+            },
+            onBack: goBack
+          }
+        ) }),
+        /* @__PURE__ */ jsx23(Step, { name: "Model", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx23(
+          ModelSelectionStep,
+          {
+            title: "What model would you like to use?",
+            models,
+            onConfirm: (m) => {
+              const finalModelName = provider === "Ollama" && !m.startsWith("ollama-") && !m.includes(":") ? `ollama-${m}` : m;
+              updateEnv("HARPER_AGENT_MODEL", finalModelName);
+              goNext();
+            },
+            onBack: goBack
+          }
+        ) }),
+        /* @__PURE__ */ jsx23(Step, { name: "Compactor", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx23(
+          ModelSelectionStep,
+          {
+            title: "What model should we use for memory compaction?",
+            models: compactorModels,
+            onConfirm: (m) => {
+              const finalModelName = provider === "Ollama" && !m.startsWith("ollama-") && !m.includes(":") ? `ollama-${m}` : m;
+              updateEnv("HARPER_AGENT_COMPACTION_MODEL", finalModelName);
+              goNext();
+            },
+            onBack: goBack
+          }
+        ) }),
+        /* @__PURE__ */ jsx23(Step, { name: "Settings", children: ({ goNext, goBack }) => /* @__PURE__ */ jsx23(
+          EnvironmentSettingsStep,
+          {
+            onConfirm: () => {
+              goNext();
+            },
+            onBack: goBack
+          }
+        ) })
+      ]
+    }
+  ) });
+}
+
+// ink/main.tsx
+import { jsx as jsx24, jsxs as jsxs18 } from "react/jsx-runtime";
+function bootstrapConfig() {
+  return new Promise((resolve) => {
+    render(/* @__PURE__ */ jsx24(MainConfig, { onComplete: resolve }));
+  });
+}
+function MainConfig({ onComplete }) {
+  const { exit } = useApp();
+  useListener("ExitUI", () => exit(), [exit]);
+  return /* @__PURE__ */ jsx24(ConfigurationWizard, { onComplete });
+}
+function bootstrapMain() {
+  render(/* @__PURE__ */ jsx24(MainChat, {}));
+}
+function MainChat() {
+  const { exit } = useApp();
+  useListener("ExitUI", () => exit(), [exit]);
+  return /* @__PURE__ */ jsx24(CostProvider, { children: /* @__PURE__ */ jsx24(PlanProvider, { children: /* @__PURE__ */ jsx24(ActionsProvider, { children: /* @__PURE__ */ jsx24(ApprovalProvider, { children: /* @__PURE__ */ jsx24(SettingsProvider, { children: /* @__PURE__ */ jsxs18(ChatProvider, { children: [
+    /* @__PURE__ */ jsx24(ChatContent, {}),
+    /* @__PURE__ */ jsx24(DiffApprovalView, {})
+  ] }) }) }) }) }) });
+}
+
+// utils/models/deprecations.ts
+import chalk2 from "chalk";
+var DEPRECATION_RULES = [
+  // Redirect any gpt-4o variants (including dated and -mini) to gpt-5-nano
+  {
+    match: (name) => name.toLowerCase().startsWith("gpt-4o"),
+    replacement: "gpt-5-nano",
+    reason: "OpenAI gpt-4o family is deprecated in this agent"
+  }
+];
+function getDeprecatedReplacement(modelName) {
+  if (!modelName) {
+    return null;
+  }
+  for (const rule of DEPRECATION_RULES) {
+    if (rule.match(modelName)) {
+      return { replacement: rule.replacement, rule };
+    }
+  }
+  return null;
+}
+function warnAndPersistRedirect(original, envKey, replacement, reason) {
+  const reasonSuffix = reason ? ` Reason: ${reason}.` : "";
+  console.warn(
+    chalk2.yellow(
+      `Warning: model "${original}" is deprecated and will be redirected to "${replacement}". Your environment setting (${envKey}) has been updated.${reasonSuffix}`
+    )
+  );
+  updateEnv(envKey, replacement);
+}
+
+// utils/shell/cli.ts
+import chalk3 from "chalk";
+
+// utils/package/getOwnPackageJson.ts
+import { readFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+var __dirname = fileURLToPath(new URL(".", import.meta.url));
+function getOwnPackageJson() {
+  try {
+    const packageContents = readFileSync(join(__dirname, "../package.json"), "utf8");
+    return JSON.parse(packageContents);
+  } catch {
+    return { name: "@harperfast/agent", version: "0.0.0" };
+  }
+}
+
+// utils/shell/cli.ts
+function isHelpRequest(args) {
+  const helpVariants = ["--help", "-h", "help"];
+  return args.some((arg) => helpVariants.includes(arg.toLowerCase()));
+}
+function isVersionRequest(args) {
+  const versionVariants = ["--version", "-v", "version"];
+  return args.some((arg) => versionVariants.includes(arg.toLowerCase()));
+}
+function handleHelp() {
+  console.log(`
+${chalk3.bold("harper-agent")} - AI to help you with Harper app creation and modification
+
+${chalk3.bold("USAGE")}
+  $ harper-agent [options]
+  $ harper-agent [command]
+
+${chalk3.bold("OPTIONS")}
+  -h, --help              Show help information
+  -v, --version           Show version information
+  -m, --model             Specify the model to use (e.g., ${defaultOpenAIModel}, ${defaultAnthropicModel}, ${defaultOllamaModel})
+                          Can also be set via HARPER_AGENT_MODEL environment variable.
+                          For Ollama, use the ollama- prefix (e.g., ${defaultOllamaCompactionModel}).
+  -c, --compaction-model  Specify the compaction model to use (defaults to ${defaultOpenAICompactionModel}).
+                          Can also be set via HARPER_AGENT_COMPACTION_MODEL environment variable.
+  -s, --session           Specify a path to a SQLite database file to persist the chat session.
+                          Can also be set via HARPER_AGENT_SESSION environment variable.
+  --max-turns             Specify the maximum number of turns for the agent run.
+                          Can also be set via HARPER_AGENT_MAX_TURNS environment variable.
+  --max-cost              Specify the maximum cost (in USD) for the agent run.
+                          If exceeded, the agent will exit with a non-zero code.
+                          Can also be set via HARPER_AGENT_MAX_COST environment variable.
+  --flex-tier             Force the use of the flex service tier for lower costs but potentially 
+                          more errors under high system load.
+                          Can also be set via HARPER_AGENT_FLEX_TIER=true environment variable.
+  -p, --prompt            Specify a prompt to be executed autonomously until completion.
+
+${chalk3.bold("COMMANDS")}
+  --help           Show help information
+  --version        Show version information
+
+${chalk3.bold("EXAMPLES")}
+  $ harper-agent --help
+  $ harper-agent --version
+  $ harper-agent
+`);
+  process.exit(0);
+}
+function handleVersion() {
+  const pkg = getOwnPackageJson();
+  console.log(pkg.version);
+  process.exit(0);
+}
+
+// lifecycle/parseArgs.ts
+function stripQuotes(str) {
+  if (str.startsWith('"') && str.endsWith('"') || str.startsWith("'") && str.endsWith("'")) {
+    return str.slice(1, -1);
+  }
+  return str;
+}
+function parseArgs() {
+  const args = process.argv.slice(2);
+  if (isHelpRequest(args)) {
+    handleHelp();
+  }
+  if (isVersionRequest(args)) {
+    handleVersion();
+  }
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    const flagPairs = [
+      ["model", ["--model", "-m", "model"]],
+      ["compactionModel", ["--compaction-model", "-c", "compaction-model"]],
+      ["sessionPath", ["--session", "-s", "session"]],
+      ["maxTurns", ["--max-turns"]],
+      ["maxCost", ["--max-cost"]],
+      ["rateLimitThreshold", ["--rate-limit-threshold"]],
+      ["prompt", ["--prompt", "-p"]]
+    ];
+    let handled = false;
+    for (const [key, prefixes] of flagPairs) {
+      for (const prefix of prefixes) {
+        if (arg === prefix) {
+          if (args[i + 1]) {
+            const val = stripQuotes(args[++i]);
+            if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
+              trackedState[key] = parseFloat(val);
+            } else {
+              trackedState[key] = val;
+            }
+          }
+          handled = true;
+          break;
+        } else if (arg.startsWith(`${prefix}=`)) {
+          const val = stripQuotes(arg.slice(prefix.length + 1));
+          if (key === "maxTurns" || key === "maxCost" || key === "rateLimitThreshold") {
+            trackedState[key] = parseFloat(val);
+          } else {
+            trackedState[key] = val;
+          }
+          handled = true;
+          break;
+        }
+      }
+      if (handled) {
+        break;
+      }
+    }
+    if (handled) {
+      continue;
+    }
+    if (arg === "--flex-tier") {
+      trackedState.useFlexTier = true;
+    } else if (arg === "--no-monitor-rate-limits") {
+      trackedState.monitorRateLimits = false;
+    } else if (arg === "--autonomous" || arg === "-a") {
+      trackedState.autonomous = true;
+    }
+  }
+  if (!trackedState.model && process.env.HARPER_AGENT_MODEL) {
+    trackedState.model = process.env.HARPER_AGENT_MODEL;
+  }
+  if (!trackedState.compactionModel && process.env.HARPER_AGENT_COMPACTION_MODEL) {
+    trackedState.compactionModel = process.env.HARPER_AGENT_COMPACTION_MODEL;
+  }
+  if (!trackedState.sessionPath && process.env.HARPER_AGENT_SESSION) {
+    trackedState.sessionPath = process.env.HARPER_AGENT_SESSION;
+  }
+  if (process.env.HARPER_AGENT_MAX_TURNS) {
+    trackedState.maxTurns = parseFloat(process.env.HARPER_AGENT_MAX_TURNS);
+  }
+  if (process.env.HARPER_AGENT_MAX_COST) {
+    trackedState.maxCost = parseFloat(process.env.HARPER_AGENT_MAX_COST);
+  }
+  if (process.env.HARPER_AGENT_RATE_LIMIT_THRESHOLD) {
+    trackedState.rateLimitThreshold = parseFloat(process.env.HARPER_AGENT_RATE_LIMIT_THRESHOLD);
+  }
+  if (process.env.HARPER_AGENT_MONITOR_RATE_LIMITS === "false") {
+    trackedState.monitorRateLimits = false;
+  }
+  if (!trackedState.useFlexTier && isTrue(process.env.HARPER_AGENT_FLEX_TIER)) {
+    trackedState.useFlexTier = true;
+  }
+  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER)) {
+    trackedState.autoApproveCodeInterpreter = true;
+  }
+  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_PATCHES)) {
+    trackedState.autoApprovePatches = true;
+  }
+  if (isTrue(process.env.HARPER_AGENT_AUTO_APPROVE_SHELL)) {
+    trackedState.autoApproveShell = true;
+  }
+  if (isTrue(process.env.HARPER_AGENT_AUTONOMOUS)) {
+    trackedState.autonomous = true;
+  }
+  if (!trackedState.model || trackedState.model === defaultModelToken) {
+    if (process.env.ANTHROPIC_API_KEY) {
+      trackedState.model = defaultAnthropicModel;
+    } else if (process.env.GOOGLE_GENERATIVE_AI_API_KEY) {
+      trackedState.model = defaultGoogleModel;
+    } else if (process.env.OLLAMA_BASE_URL) {
+      trackedState.model = defaultOllamaModel;
+    } else {
+      trackedState.model = defaultOpenAIModel;
+    }
+  }
+  if (!trackedState.compactionModel || trackedState.compactionModel === defaultModelToken) {
+    const m = trackedState.model;
+    if (m.startsWith("claude-")) {
+      trackedState.compactionModel = defaultAnthropicCompactionModel;
+    } else if (m.startsWith("gemini-")) {
+      trackedState.compactionModel = defaultGoogleCompactionModel;
+    } else if (m.startsWith("ollama-")) {
+      trackedState.compactionModel = defaultOllamaCompactionModel;
+    } else {
+      trackedState.compactionModel = defaultOpenAICompactionModel;
+    }
+  }
+  if (!isOpenAIModel(trackedState.model)) {
+    process.env.OPENAI_AGENTS_DISABLE_TRACING = process.env.OPENAI_AGENTS_DISABLE_TRACING || "1";
+  }
+  const maybeRedirect = (current, envKey) => {
+    const hit = getDeprecatedReplacement(current);
+    if (hit) {
+      const { replacement, rule } = hit;
+      warnAndPersistRedirect(current, envKey, replacement, rule.reason);
+      return replacement;
+    }
+    return current;
+  };
+  trackedState.model = maybeRedirect(trackedState.model, "HARPER_AGENT_MODEL");
+  trackedState.compactionModel = maybeRedirect(trackedState.compactionModel, "HARPER_AGENT_COMPACTION_MODEL");
+}
+
+// utils/envLoader.ts
+import dotenv from "dotenv";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+function loadEnv() {
+  const topLevelEnvPath = join2(homedir(), ".harper", "harper-agent-env");
+  const localEnvPath = join2(process.cwd(), ".env");
+  if (existsSync(topLevelEnvPath)) {
+    dotenv.config({ path: topLevelEnvPath, quiet: true });
+  }
+  if (existsSync(localEnvPath)) {
+    dotenv.config({ path: localEnvPath, override: true, quiet: true });
+  }
+}
+
+// utils/package/checkForUpdate.ts
+import { Select as Select3 } from "@inkjs/ui";
+import chalk4 from "chalk";
+import spawn from "cross-spawn";
+import { Box as Box19, render as render2, Text as Text18 } from "ink";
+import React20 from "react";
+
+// utils/package/getLatestVersion.ts
+async function getLatestVersion(packageName) {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: AbortSignal.timeout(1e3)
+      // 1 second timeout
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+// utils/package/isVersionNewer.ts
+function isVersionNewer(latest, current) {
+  const l = latest.split(".").map((x) => parseInt(x, 10));
+  const c = current.split(".").map((x) => parseInt(x, 10));
+  for (let i = 0; i < 3; i++) {
+    let latestNumber = l[i];
+    let currentNumber = c[i];
+    if (latestNumber === void 0 || currentNumber === void 0 || isNaN(latestNumber) || isNaN(currentNumber)) {
+      break;
+    }
+    if (latestNumber > currentNumber) {
+      return true;
+    }
+    if (latestNumber < currentNumber) {
+      return false;
+    }
+  }
+  return false;
+}
+
+// utils/package/checkForUpdate.ts
+async function checkForUpdate() {
+  const pkg = getOwnPackageJson();
+  const packageName = pkg.name;
+  const packageVersion = pkg.version;
+  if (process.env.HARPER_AGENT_SKIP_UPDATE) {
+    return packageVersion;
+  }
+  try {
+    const latestVersion = await getLatestVersion(packageName);
+    if (latestVersion && isVersionNewer(latestVersion, packageVersion)) {
+      const choice = await promptForUpdateChoice(packageName, packageVersion, latestVersion);
+      if (choice === "later") {
+        return packageVersion;
+      }
+      if (choice === "never") {
+        updateEnv("HARPER_AGENT_SKIP_UPDATE", "1");
+        return packageVersion;
+      }
+      let isGlobal = false;
+      try {
+        const globalRootResult = spawn.sync("npm", ["root", "-g"], { encoding: "utf8" });
+        const globalRoot = globalRootResult.stdout?.trim();
+        if (globalRoot && process.argv[1] && process.argv[1].startsWith(globalRoot)) {
+          isGlobal = true;
+        }
+      } catch {
+      }
+      if (isGlobal) {
+        spawn.sync("npm", ["install", "-g", `${packageName}@latest`], { stdio: "inherit" });
+        const result2 = spawn.sync("harper-agent", process.argv.slice(2), { stdio: "inherit" });
+        process.exit(result2.status ?? 0);
+      }
+      const lsResult = spawn.sync("npm", ["cache", "npx", "ls", packageName], { encoding: "utf8" });
+      if (lsResult.stdout) {
+        const keys = lsResult.stdout.split("\n").map((line) => line.trim()).filter((line) => line.includes(":")).filter((line) => {
+          const [, pkgPart] = line.split(":");
+          return pkgPart && pkgPart.trim().startsWith(`${packageName}@`);
+        }).map((line) => line.split(":")[0].trim());
+        if (keys.length > 0) {
+          spawn.sync("npm", ["cache", "npx", "rm", ...keys], { stdio: "inherit" });
+        }
+      }
+      const result = spawn.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], { stdio: "inherit" });
+      process.exit(result.status ?? 0);
+    }
+  } catch {
+  }
+  return packageVersion;
+}
+function promptForUpdateChoice(pkgName, currentVersion, latestVersion) {
+  return new Promise((resolve) => {
+    const app = render2(
+      React20.createElement(UpdatePrompt, {
+        packageName: pkgName,
+        currentVersion,
+        latestVersion,
+        onSelect: (c) => {
+          resolve(c);
+          app.unmount();
+        }
+      })
+    );
+  });
+}
+function UpdatePrompt({ packageName, currentVersion, latestVersion, onSelect }) {
+  const options = [
+    {
+      label: `Update right now (will run: npx -y @harperfast/agent@latest)`,
+      value: "now"
+    },
+    { label: "Update later", value: "later" },
+    { label: "Don\u2019t ask again", value: "never" }
+  ];
+  return React20.createElement(
+    Box19,
+    { flexDirection: "column", padding: 1 },
+    React20.createElement(
+      Text18,
+      null,
+      `${chalk4.yellow("Update available:")} ${chalk4.bold(packageName)} ${chalk4.dim(`v${currentVersion}`)} \u2192 ${chalk4.green(`v${latestVersion}`)}`
+    ),
+    React20.createElement(
+      Box19,
+      { marginTop: 1 },
+      React20.createElement(Select3, {
+        options,
+        onChange: (v) => onSelect(v)
+      })
+    )
+  );
+}
+
+// utils/shell/ensureApiKey.ts
+function ensureApiKey() {
+  const models = [
+    trackedState.model,
+    trackedState.compactionModel
+  ].filter(excludeFalsy);
+  const requiredEnvVars = /* @__PURE__ */ new Set();
+  for (const model of models) {
+    if (model.startsWith("claude-")) {
+      requiredEnvVars.add("ANTHROPIC_API_KEY");
+    } else if (model.startsWith("gemini-")) {
+      requiredEnvVars.add("GOOGLE_GENERATIVE_AI_API_KEY");
+    } else if (model.startsWith("ollama-") || model.includes(":")) {
+    } else {
+      requiredEnvVars.add("OPENAI_API_KEY");
+    }
+  }
+  for (const envVar of requiredEnvVars) {
+    if (!process.env[envVar]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// cli.ts
+(async function() {
+  setupGlobalErrorHandlers();
+  loadEnv();
+  process.on("SIGINT", handleExit);
+  process.on("SIGTERM", handleExit);
+  await checkForUpdate();
+  parseArgs();
+  if (!ensureApiKey()) {
+    resetTrackedState();
+    await bootstrapConfig();
+    emitToListeners("ExitUI", void 0);
+    parseArgs();
+    if (!ensureApiKey()) {
+      console.log(chalk5.red("No key provided. Exiting."));
+      process.exit(1);
+    }
+  }
+  await agentManager.initialize();
+  bootstrapMain();
+})();