@within-7/minto 0.4.1 → 0.4.3

package/dist/screens/REPL.js

@@ -1,1097 +0,0 @@
-import { Box, Newline, Static, Text, useApp } from "ink";
-import ProjectOnboarding, {
-  markProjectOnboardingComplete
-} from "../components/ProjectOnboarding.js";
-import { CostThresholdDialog } from "../components/CostThresholdDialog.js";
-import * as React from "react";
-import { useEffect, useMemo, useRef, useState, useCallback } from "react";
-import { Logo } from "../components/Logo.js";
-import { Message } from "../components/Message.js";
-import { MessageResponse } from "../components/MessageResponse.js";
-import { BashStreamingProgress } from "../components/BashStreamingProgress.js";
-import { MessageSelector } from "../components/MessageSelector.js";
-import { MessageBatchBuffer } from "../utils/MessageBatchBuffer.js";
-import {
-  PermissionRequest
-} from "../components/permissions/PermissionRequest.js";
-import PromptInput from "../components/PromptInput.js";
-import { getSystemPrompt } from "../constants/prompts/index.js";
-import { getContext } from "../context.js";
-import { getTotalCost, useCostSummary } from "../cost-tracker.js";
-import { useLogStartupTime } from "../hooks/useLogStartupTime.js";
-import { addToHistory } from "../history.js";
-import { useApiKeyVerification } from "../hooks/useApiKeyVerification.js";
-import useCanUseTool from "../hooks/useCanUseTool.js";
-import { useLogMessages, serializeMessageForLog } from "../hooks/useLogMessages.js";
-import { overwriteLog } from "../utils/log.js";
-import { PermissionProvider } from "../context/PermissionContext.js";
-import { useFullscreenExitCallback } from "../hooks/useTerminalSize.js";
-import { TodoPanel } from "../components/TodoPanel.js";
-import { TurnCompletionIndicator } from "../components/TurnCompletionIndicator.js";
-import { getTodos, initTodoSession } from "../utils/todoStorage.js";
-import {
-  setMessagesGetter,
-  setMessagesSetter,
-  setModelConfigChangeHandler,
-  setLanguageChangeHandler
-} from "../messages.js";
-import {
-  query
-} from "../query.js";
-import {
-  getGlobalConfig,
-  saveGlobalConfig,
-  getVerboseLabel
-} from "../utils/config.js";
-import { loadMessagesFromLog } from "../utils/conversationRecovery.js";
-import { useBackgroundShells } from "../hooks/useBackgroundShells.js";
-import { useDeferredLoading } from "../hooks/useDeferredLoading.js";
-import { useSessionTracking } from "../hooks/useSessionTracking.js";
-import { emitReminderEvent } from "../services/systemReminder.js";
-import {
-  getNextAvailableLogForkNumber,
-  loadLogList,
-  CACHE_PATHS
-} from "../utils/log.js";
-import {
-  getErroredToolUseMessages,
-  getInProgressToolUseIDs,
-  getLastAssistantMessageId,
-  getToolUseID,
-  getUnresolvedToolUseIDs,
-  INTERRUPT_MESSAGE,
-  isNotEmptyMessage,
-  normalizeMessages,
-  normalizeMessagesForAPI,
-  processUserInput,
-  reorderMessages,
-  createAssistantAPIErrorMessage
-} from "../utils/messages.js";
-import { logError } from "../utils/log.js";
-import { ModelManager } from "../utils/model.js";
-import { clearTerminal } from "../utils/terminal.js";
-import { BinaryFeedback } from "../components/binary-feedback/BinaryFeedback.js";
-import { getMaxThinkingTokens } from "../utils/thinking.js";
-import { getOriginalCwd } from "../utils/state.js";
-import { handleHashCommand } from "../commands/terminalSetup.js";
-import { randomUUID } from "crypto";
-import { getMessagesPath } from "../utils/log.js";
-import {
-  BackgroundShellManager
-} from "../utils/BackgroundShellManager.js";
-import { BackgroundTasksPanel } from "../components/BackgroundTasksPanel.js";
-import { AskUserQuestionDialog } from "../components/AskUserQuestionDialog/AskUserQuestionDialog.js";
-import {
-  getToolUseIdByAgentId,
-  restoreToolUseAgentMappings
-} from "../utils/agentTranscripts.js";
-import useAskUser from "../hooks/useAskUser.js";
-import { useMessageGroups } from "../hooks/useMessageGroups.js";
-import { useAgentTranscripts } from "../hooks/useAgentTranscripts.js";
-import { GroupRenderer } from "../components/messages/GroupRenderer.js";
-import { SEMANTIC_COLORS } from "../constants/colors.js";
-import {
-  recordFirstPrompt,
-  incrementMessageCount,
-  incrementToolCallCount,
-  flushSessionStats
-} from "../utils/sessionTracker.js";
-const RESUME_VISIBLE_MESSAGE_COUNT = Infinity;
-function REPL({
-  commands,
-  safeMode,
-  safetyMode = "yolo",
-  debug = false,
-  initialForkNumber = 0,
-  initialPrompt,
-  messageLogName,
-  shouldShowPromptInput,
-  tools,
-  verbose: verboseFromCLI,
-  initialMessages,
-  mcpClients = [],
-  isDefaultModel = true,
-  initialUpdateVersion,
-  initialUpdateCommands,
-  fallbackMode = false,
-  isResumedConversation = false,
-  enableArchitect,
-  autoResume = false
-}) {
-  const [verbose, setVerbose] = useState(
-    verboseFromCLI === true ? true : false
-  );
-  const [forkNumber, setForkNumber] = useState(
-    getNextAvailableLogForkNumber(messageLogName, initialForkNumber, 0)
-  );
-  const [isResizeClearing, setIsResizeClearing] = useState(false);
-  const { exit: unmountREPL } = useApp();
-  useFullscreenExitCallback(async () => {
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
-  });
-  const [
-    forkConvoWithMessagesOnTheNextRender,
-    setForkConvoWithMessagesOnTheNextRender
-  ] = useState(null);
-  const [abortController, setAbortController] = useState(null);
-  const [isLoading, setIsLoading] = useState(false);
-  const [toolJSX, setToolJSX] = useState(null);
-  const [toolUseConfirm, setToolUseConfirm] = useState(
-    null
-  );
-  const [messages, setMessages] = useState(initialMessages ?? []);
-  const messagesRef = useRef(initialMessages ?? []);
-  const [messageHistory, setMessageHistory] = useState([]);
-  const [inputValue, setInputValue] = useState("");
-  const [inputMode, setInputMode] = useState(
-    "prompt"
-  );
-  const [submitCount, setSubmitCount] = useState(0);
-  const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
-  const [showCostDialog, setShowCostDialog] = useState(false);
-  const [haveShownCostDialog, setHaveShownCostDialog] = useState(
-    getGlobalConfig().hasAcknowledgedCostThreshold
-  );
-  const [binaryFeedbackContext, setBinaryFeedbackContext] = useState(null);
-  const [askUserQuestionContext, setAskUserQuestionContext] = useState(null);
-  const {
-    commands: currentCommands,
-    tools: currentTools,
-    mcpClients: currentMcpClients,
-    updateVersion: updateAvailableVersion,
-    updateCommands,
-    startupItems
-  } = useDeferredLoading({
-    initialCommands: commands,
-    initialTools: tools,
-    initialMcpClients: mcpClients,
-    initialUpdateVersion,
-    initialUpdateCommands,
-    enableArchitect
-  });
-  const [isTodoPanelVisible, setIsTodoPanelVisible] = useState(true);
-  const [verboseToggleMessage, setVerboseToggleMessage] = useState(null);
-  const turnStartTimeRef = useRef(null);
-  const [lastTurnDurationMs, setLastTurnDurationMs] = useState(
-    null
-  );
-  const [queuedPrompts, setQueuedPrompts] = useState([]);
-  const queuedPromptsRef = useRef([]);
-  useEffect(() => {
-    queuedPromptsRef.current = queuedPrompts;
-  }, [queuedPrompts]);
-  useEffect(() => {
-    if (isLoading) {
-      turnStartTimeRef.current = Date.now();
-      setLastTurnDurationMs(null);
-    } else if (turnStartTimeRef.current !== null) {
-      const duration = Date.now() - turnStartTimeRef.current;
-      setLastTurnDurationMs(duration);
-      turnStartTimeRef.current = null;
-    }
-  }, [isLoading]);
-  const {
-    shells: backgroundShells,
-    isPanelVisible: showBackgroundPanel,
-    setIsPanelVisible: setShowBackgroundPanel,
-    runningCount: backgroundShellRunningCount
-  } = useBackgroundShells();
-  const prevUnresolvedRef = useRef(/* @__PURE__ */ new Set());
-  const messageBatchBufferRef = useRef(null);
-  if (messageBatchBufferRef.current === null) {
-    messageBatchBufferRef.current = new MessageBatchBuffer(
-      (batchedMessages) => {
-        setMessages((prev) => [...prev, ...batchedMessages]);
-      },
-      {
-        flushInterval: 100,
-        // Batch messages for 100ms
-        maxBatchSize: 50,
-        // Force flush if 50+ messages buffered
-        debug: false
-        // Set to true for debugging
-      }
-    );
-  }
-  useEffect(() => {
-    return () => {
-      messageBatchBufferRef.current?.dispose();
-    };
-  }, []);
-  const getBinaryFeedbackResponse = useCallback(
-    (m1, m2) => {
-      return new Promise((resolvePromise) => {
-        setBinaryFeedbackContext({
-          m1,
-          m2,
-          resolve: resolvePromise
-        });
-      });
-    },
-    []
-  );
-  const readFileTimestamps = useRef({});
-  const { status: apiKeyStatus, reverify } = useApiKeyVerification();
-  function onInterrupt() {
-    if (!isLoading) {
-      return;
-    }
-    const currentMessages = messagesRef.current;
-    if (currentMessages.length > 0) {
-      const serializedMessages = currentMessages.map(serializeMessageForLog);
-      overwriteLog(
-        getMessagesPath(messageLogName, forkNumber, 0),
-        serializedMessages
-      );
-    }
-    setToolJSX(null);
-    setToolUseConfirm(null);
-    setBinaryFeedbackContext(null);
-    setIsLoading(false);
-    if (toolUseConfirm) {
-      toolUseConfirm.onAbort();
-    } else if (abortController && !abortController.signal.aborted) {
-      abortController.abort();
-    }
-  }
-  function onCancel() {
-    onInterrupt();
-  }
-  useEffect(() => {
-    if (forkConvoWithMessagesOnTheNextRender) {
-      setForkNumber((_) => _ + 1);
-      setForkConvoWithMessagesOnTheNextRender(null);
-      setMessages(forkConvoWithMessagesOnTheNextRender);
-    }
-  }, [forkConvoWithMessagesOnTheNextRender]);
-  useEffect(() => {
-    const totalCost = getTotalCost();
-    if (totalCost >= 5 && !showCostDialog && !haveShownCostDialog) {
-      setShowCostDialog(true);
-    }
-  }, [messages, showCostDialog, haveShownCostDialog]);
-  const canUseTool = useCanUseTool(setToolUseConfirm);
-  const askUser = useAskUser(setAskUserQuestionContext);
-  async function onInit() {
-    reverify();
-    if (!initialPrompt) {
-      return;
-    }
-    setIsLoading(true);
-    const newAbortController = new AbortController();
-    setAbortController(newAbortController);
-    try {
-      const model = new ModelManager(getGlobalConfig()).getModelName("main");
-      const newMessages = await processUserInput(
-        initialPrompt,
-        "prompt",
-        setToolJSX,
-        {
-          abortController: newAbortController,
-          options: {
-            commands: currentCommands,
-            forkNumber,
-            messageLogName,
-            tools: currentTools,
-            verbose,
-            maxThinkingTokens: 0
-          },
-          messageId: getLastAssistantMessageId(messages),
-          setForkConvoWithMessagesOnTheNextRender,
-          readFileTimestamps: readFileTimestamps.current
-        },
-        null
-      );
-      if (newMessages.length) {
-        for (const message of newMessages) {
-          if (message.type === "user") {
-            addToHistory(initialPrompt);
-          }
-        }
-        setMessages((_) => [..._, ...newMessages]);
-        const lastMessage = newMessages[newMessages.length - 1];
-        if (lastMessage.type === "assistant") {
-          return;
-        }
-        const [systemPrompt, context, model2, maxThinkingTokens] = await Promise.all([
-          getSystemPrompt(),
-          getContext(),
-          new ModelManager(getGlobalConfig()).getModelName("main"),
-          getMaxThinkingTokens([...messages, ...newMessages])
-        ]);
-        for await (const message of query(
-          [...messages, ...newMessages],
-          systemPrompt,
-          context,
-          canUseTool,
-          {
-            options: {
-              commands: currentCommands,
-              forkNumber,
-              messageLogName,
-              tools: currentTools,
-              verbose,
-              safeMode,
-              safetyMode,
-              maxThinkingTokens
-            },
-            messageId: getLastAssistantMessageId([...messages, ...newMessages]),
-            readFileTimestamps: readFileTimestamps.current,
-            abortController: newAbortController,
-            setToolJSX,
-            askUser
-          },
-          getBinaryFeedbackResponse
-        )) {
-          messageBatchBufferRef.current?.add(message);
-        }
-        messageBatchBufferRef.current?.flush();
-      } else {
-        addToHistory(initialPrompt);
-      }
-      setHaveShownCostDialog(
-        getGlobalConfig().hasAcknowledgedCostThreshold || false
-      );
-    } catch (error) {
-      logError(error);
-      setMessages((oldMessages) => [
-        ...oldMessages,
-        createAssistantAPIErrorMessage(
-          `Request failed: ${error instanceof Error ? error.message : String(error)}`
-        )
-      ]);
-    } finally {
-      setIsLoading(false);
-      setAbortController(null);
-    }
-  }
-  function rollbackConversation() {
-    if (messageHistory.length === 0) {
-      return false;
-    }
-    const previousMessages = messageHistory[messageHistory.length - 1];
-    setMessages(previousMessages);
-    setMessageHistory((history) => history.slice(0, -1));
-    return true;
-  }
-  const processNextQueuedPromptRef = useRef(null);
-  async function onQuery(newMessages, passedAbortController) {
-    const controllerToUse = passedAbortController || new AbortController();
-    if (!passedAbortController) {
-      setAbortController(controllerToUse);
-    }
-    setIsLoading(true);
-    setVerbose(false);
-    const isKodingRequest = newMessages.length > 0 && newMessages[0].type === "user" && "options" in newMessages[0] && newMessages[0].options?.isKodingRequest === true;
-    setMessages((oldMessages) => {
-      setMessageHistory((history) => [...history, oldMessages].slice(-10));
-      return [...oldMessages, ...newMessages];
-    });
-    markProjectOnboardingComplete();
-    const lastMessage = newMessages[newMessages.length - 1];
-    if (lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
-      recordFirstPrompt(lastMessage.message.content);
-      incrementMessageCount(1);
-    }
-    if (lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
-    }
-    if (lastMessage.type === "assistant") {
-      setAbortController(null);
-      setIsLoading(false);
-      return;
-    }
-    try {
-      const [systemPrompt, context, model, maxThinkingTokens] = await Promise.all([
-        getSystemPrompt(),
-        getContext(),
-        new ModelManager(getGlobalConfig()).getModelName("main"),
-        getMaxThinkingTokens([...messages, lastMessage])
-      ]);
-      let lastAssistantMessage = null;
-      for await (const message of query(
-        [...messages, lastMessage],
-        systemPrompt,
-        context,
-        canUseTool,
-        {
-          options: {
-            commands: currentCommands,
-            forkNumber,
-            messageLogName,
-            tools: currentTools,
-            verbose,
-            safeMode,
-            safetyMode,
-            maxThinkingTokens,
-            // If this came from Koding mode, pass that along
-            isKodingRequest: isKodingRequest || void 0
-          },
-          messageId: getLastAssistantMessageId([...messages, lastMessage]),
-          readFileTimestamps: readFileTimestamps.current,
-          abortController: controllerToUse,
-          setToolJSX,
-          askUser
-        },
-        getBinaryFeedbackResponse
-      )) {
-        messageBatchBufferRef.current?.add(message);
-        if (message.type === "assistant") {
-          lastAssistantMessage = message;
-          incrementMessageCount(1);
-          if (Array.isArray(message.message.content)) {
-            const toolUseCount = message.message.content.filter(
-              (block) => typeof block === "object" && block.type === "tool_use"
-            ).length;
-            if (toolUseCount > 0) {
-              incrementToolCallCount(toolUseCount);
-            }
-          }
-        }
-      }
-      if (isKodingRequest && lastAssistantMessage && lastAssistantMessage.type === "assistant") {
-        try {
-          const content = typeof lastAssistantMessage.message.content === "string" ? lastAssistantMessage.message.content : lastAssistantMessage.message.content.filter((block) => block.type === "text").map((block) => block.type === "text" ? block.text : "").join("\n");
-          if (content && content.trim().length > 0) {
-            handleHashCommand(content);
-          }
-        } catch (error) {
-          console.error("Error saving response to project docs:", error);
-        }
-      }
-      messageBatchBufferRef.current?.flush();
-    } catch (error) {
-      logError(error);
-      messageBatchBufferRef.current?.flush();
-      setMessages((oldMessages) => [
-        ...oldMessages,
-        createAssistantAPIErrorMessage(
-          `Request failed: ${error instanceof Error ? error.message : String(error)}`
-        )
-      ]);
-    } finally {
-      setIsLoading(false);
-      setAbortController(null);
-      flushSessionStats();
-      if (queuedPromptsRef.current.length > 0) {
-        setTimeout(() => {
-          if (processNextQueuedPromptRef.current) {
-            processNextQueuedPromptRef.current();
-          }
-        }, 100);
-      }
-    }
-  }
-  useCostSummary();
-  useEffect(() => {
-    const getMessages = () => messages;
-    setMessagesGetter(getMessages);
-    setMessagesSetter(setMessages);
-  }, [messages]);
-  useEffect(() => {
-    const todoSessionId = `${messageLogName}-${forkNumber}`;
-    initTodoSession(todoSessionId);
-    if (initialMessages && initialMessages.length > 0) {
-      restoreToolUseAgentMappings();
-    }
-  }, [messageLogName, forkNumber, initialMessages]);
-  useEffect(() => {
-    setModelConfigChangeHandler(() => {
-      setForkNumber((prev) => prev + 1);
-    });
-  }, []);
-  useEffect(() => {
-    setLanguageChangeHandler(async () => {
-      setIsResizeClearing(true);
-      await new Promise((resolve) => setTimeout(resolve, 50));
-      await clearTerminal();
-      setForkNumber((prev) => prev + 1);
-      setIsResizeClearing(false);
-    });
-  }, []);
-  useEffect(() => {
-    messagesRef.current = messages;
-  }, [messages]);
-  useLogMessages(messages, messageLogName, forkNumber);
-  useLogStartupTime();
-  useEffect(() => {
-    if (!autoResume) return;
-    loadLogList(CACHE_PATHS.messages()).then(async (logs) => {
-      for (const log of logs) {
-        try {
-          const loaded = await loadMessagesFromLog(log.fullPath, tools);
-          if (loaded && loaded.length > 0) {
-            setMessages(loaded);
-            emitReminderEvent("session:continuation", {
-              messageCount: loaded.length
-            });
-            break;
-          }
-        } catch {
-          continue;
-        }
-      }
-    }).catch(() => {
-    });
-  }, []);
-  useEffect(() => {
-    onInit();
-  }, []);
-  useSessionTracking(messageLogName, forkNumber);
-  const normalizedMessages = useMemo(
-    () => normalizeMessages(messages).filter(isNotEmptyMessage),
-    [messages]
-  );
-  const unresolvedToolUseIDs = useMemo(
-    () => getUnresolvedToolUseIDs(normalizedMessages),
-    [normalizedMessages]
-  );
-  useEffect(() => {
-    prevUnresolvedRef.current = new Set(unresolvedToolUseIDs);
-  }, [unresolvedToolUseIDs]);
-  const inProgressToolUseIDs = useMemo(
-    () => getInProgressToolUseIDs(normalizedMessages),
-    [normalizedMessages]
-  );
-  const erroredToolUseIDs = useMemo(
-    () => new Set(
-      getErroredToolUseMessages(normalizedMessages).map(
-        (_) => _.message.content[0].id
-      )
-    ),
-    [normalizedMessages]
-  );
-  const {
-    groups: messageGroups,
-    getGroupForMessage,
-    getGroupForToolUse,
-    shouldGroupBeStatic,
-    displayConfig
-  } = useMessageGroups(
-    normalizedMessages,
-    unresolvedToolUseIDs,
-    inProgressToolUseIDs,
-    verbose
-  );
-  const { transcripts: agentTranscripts, getTranscript } = useAgentTranscripts();
-  const toolOutputs = useMemo(() => {
-    const outputs = /* @__PURE__ */ new Map();
-    for (const msg of normalizedMessages) {
-      if (msg.type === "user" && msg.message.role === "user") {
-        for (const block of msg.message.content) {
-          if (typeof block === "object" && block.type === "tool_result") {
-            outputs.set(block.tool_use_id, block);
-          }
-        }
-      }
-    }
-    return outputs;
-  }, [normalizedMessages]);
-  const messagesJSX = useMemo(() => {
-    const reorderedMessages = reorderMessages(normalizedMessages);
-    const hiddenMessageCount = isResumedConversation && reorderedMessages.length > RESUME_VISIBLE_MESSAGE_COUNT ? reorderedMessages.length - RESUME_VISIBLE_MESSAGE_COUNT : 0;
-    const visibleMessages = hiddenMessageCount > 0 ? reorderedMessages.slice(-RESUME_VISIBLE_MESSAGE_COUNT) : reorderedMessages;
-    const result = [
-      {
-        type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", width: "100%", key: "logo" }, /* @__PURE__ */ React.createElement(
-          Logo,
-          {
-            mcpClients: currentMcpClients,
-            isDefaultModel,
-            updateBannerVersion: updateAvailableVersion,
-            updateBannerCommands: updateCommands
-          }
-        ), /* @__PURE__ */ React.createElement(ProjectOnboarding, { workspaceDir: getOriginalCwd() }))
-      }
-    ];
-    if (hiddenMessageCount > 0) {
-      result.push({
-        type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { key: "collapsed-history", paddingLeft: 2, marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { color: SEMANTIC_COLORS.dim }, "\xB7\xB7\xB7 ", hiddenMessageCount, " earlier messages hidden \xB7\xB7\xB7"))
-      });
-    }
-    const renderedGroupIds = /* @__PURE__ */ new Set();
-    const groupToolUseIds = /* @__PURE__ */ new Set();
-    const taskOutputToolUseIdsToSkip = /* @__PURE__ */ new Set();
-    for (const _ of visibleMessages) {
-      const toolUseID = getToolUseID(_);
-      let group = getGroupForMessage(_.uuid);
-      if (!group && _.type === "progress") {
-        group = getGroupForToolUse(_.toolUseID);
-      }
-      if (!group && toolUseID) {
-        group = getGroupForToolUse(toolUseID);
-      }
-      if (group && (group.type === "parallel-tasks" || group.type === "task")) {
-        if (renderedGroupIds.has(group.id)) {
-          continue;
-        }
-        renderedGroupIds.add(group.id);
-        if (group.metadata.siblingToolUseIds) {
-          for (const id of group.metadata.siblingToolUseIds) {
-            groupToolUseIds.add(id);
-          }
-        }
-        if (group.metadata.toolUseId) {
-          groupToolUseIds.add(group.metadata.toolUseId);
-        }
-        const isGroupStatic = shouldGroupBeStatic(group);
-        const groupType = isGroupStatic ? "static" : "transient";
-        const shouldAnimate = !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isGroupStatic;
-        result.push({
-          type: groupType,
-          jsx: /* @__PURE__ */ React.createElement(Box, { key: `group-${group.id}`, width: "100%" }, /* @__PURE__ */ React.createElement(
-            GroupRenderer,
-            {
-              group,
-              context: {
-                depth: 0,
-                isLastChild: true,
-                displayConfig,
-                shouldAnimate,
-                getTranscript
-              },
-              messages: normalizedMessages,
-              transcripts: agentTranscripts,
-              outputs: toolOutputs
-            }
-          ))
-        });
-        continue;
-      }
-      if (_.type === "user" && _.message.role === "user") {
-        const content = _.message.content;
-        if (Array.isArray(content)) {
-          const toolResult = content.find(
-            (block) => typeof block === "object" && block.type === "tool_result"
-          );
-          if (toolResult && (groupToolUseIds.has(toolResult.tool_use_id) || taskOutputToolUseIdsToSkip.has(toolResult.tool_use_id))) {
-            continue;
-          }
-        }
-      }
-      if (_.type === "assistant") {
-        const content = _.message.content;
-        if (Array.isArray(content)) {
-          const taskOutputCall = content.find(
-            (block) => typeof block === "object" && block.type === "tool_use" && block.name === "TaskOutput"
-          );
-          if (taskOutputCall) {
-            const taskId = taskOutputCall.input?.task_id;
-            if (taskId) {
-              const correspondingToolUseId = getToolUseIdByAgentId(taskId);
-              if (correspondingToolUseId && groupToolUseIds.has(correspondingToolUseId)) {
-                taskOutputToolUseIdsToSkip.add(taskOutputCall.id);
-                continue;
-              }
-            }
-          }
-        }
-      }
-      if (_.type === "progress" && !unresolvedToolUseIDs.has(_.toolUseID)) {
-        continue;
-      }
-      const message = _.type === "progress" ? (
-        // Check if this is a streaming progress content (e.g., from BashTool)
-        "type" in _.content && _.content.type === "streaming" ? /* @__PURE__ */ React.createElement(
-          BashStreamingProgress,
-          {
-            stdout: _.content.stdout,
-            stderr: _.content.stderr,
-            isStreaming: _.content.isStreaming
-          }
-        ) : _.content.message.content[0]?.type === "text" && // TaskTool interrupts use Progress messages without extra ⎿
-        // since <Message /> component already adds the margin
-        _.content.message.content[0].text === INTERRUPT_MESSAGE ? /* @__PURE__ */ React.createElement(
-          Message,
-          {
-            message: _.content,
-            messages: _.normalizedMessages,
-            addMargin: false,
-            tools: _.tools,
-            verbose: verbose ?? false,
-            debug,
-            erroredToolUseIDs: /* @__PURE__ */ new Set(),
-            inProgressToolUseIDs: /* @__PURE__ */ new Set(),
-            unresolvedToolUseIDs: /* @__PURE__ */ new Set(),
-            shouldAnimate: false,
-            shouldShowDot: false
-          }
-        ) : /* @__PURE__ */ React.createElement(
-          MessageResponse,
-          {
-            children: /* @__PURE__ */ React.createElement(
-              Message,
-              {
-                message: _.content,
-                messages: _.normalizedMessages,
-                addMargin: false,
-                tools: _.tools,
-                verbose: verbose ?? false,
-                debug,
-                erroredToolUseIDs: /* @__PURE__ */ new Set(),
-                inProgressToolUseIDs: /* @__PURE__ */ new Set(),
-                unresolvedToolUseIDs: /* @__PURE__ */ new Set([
-                  _.content.message.content[0].id
-                ]),
-                shouldAnimate: false,
-                shouldShowDot: false
-              }
-            )
-          }
-        )
-      ) : /* @__PURE__ */ React.createElement(
-        Message,
-        {
-          message: _,
-          messages: normalizedMessages,
-          addMargin: true,
-          tools: currentTools,
-          verbose,
-          debug,
-          erroredToolUseIDs,
-          inProgressToolUseIDs,
-          shouldAnimate: !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && (!toolUseID || inProgressToolUseIDs.has(toolUseID)),
-          shouldShowDot: true,
-          unresolvedToolUseIDs
-        }
-      );
-      const type = shouldRenderStatically(
-        _,
-        normalizedMessages,
-        unresolvedToolUseIDs
-      ) ? "static" : "transient";
-      if (debug) {
-        result.push({
-          type,
-          jsx: /* @__PURE__ */ React.createElement(
-            Box,
-            {
-              borderStyle: "single",
-              borderColor: type === "static" ? "green" : "red",
-              key: _.uuid,
-              width: "100%"
-            },
-            message
-          )
-        });
-      } else {
-        result.push({
-          type,
-          jsx: /* @__PURE__ */ React.createElement(Box, { key: _.uuid, width: "100%" }, message)
-        });
-      }
-    }
-    return result;
-  }, [
-    forkNumber,
-    normalizedMessages,
-    currentTools,
-    verbose,
-    debug,
-    erroredToolUseIDs,
-    inProgressToolUseIDs,
-    toolJSX,
-    toolUseConfirm,
-    isMessageSelectorVisible,
-    unresolvedToolUseIDs,
-    currentMcpClients,
-    isDefaultModel,
-    isResumedConversation,
-    // V1+ dependencies
-    messageGroups,
-    getGroupForMessage,
-    getGroupForToolUse,
-    shouldGroupBeStatic,
-    displayConfig,
-    agentTranscripts,
-    toolOutputs
-  ]);
-  const showingCostDialog = !isLoading && showCostDialog;
-  const { staticItems, dynamicItems } = useMemo(() => {
-    const staticItems2 = [];
-    const dynamicItems2 = [];
-    for (const item of messagesJSX) {
-      if (item.type === "static") {
-        const key = item.jsx.key?.toString() || `static-${staticItems2.length}`;
-        staticItems2.push({ id: key, jsx: item.jsx });
-      } else if (item.type === "transient") {
-        dynamicItems2.push(item);
-      }
-    }
-    return { staticItems: staticItems2, dynamicItems: dynamicItems2 };
-  }, [messagesJSX]);
-  const handleShowMessageSelector = useCallback(() => {
-    setIsMessageSelectorVisible((prev) => !prev);
-  }, []);
-  const handleToggleTodoPanel = useCallback(() => {
-    setIsTodoPanelVisible((prev) => !prev);
-  }, []);
-  const handleToggleBackgroundPanel = useCallback(() => {
-    setShowBackgroundPanel((prev) => !prev);
-  }, []);
-  const handleModelChange = useCallback(async () => {
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
-  }, []);
-  const handleToggleVerbose = useCallback(async (newVerbose) => {
-    const message = `${getVerboseLabel(newVerbose)} (Ctrl+O)`;
-    setVerboseToggleMessage(message);
-    setTimeout(() => setVerboseToggleMessage(null), 2e3);
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    setVerbose(newVerbose);
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
-  }, []);
-  const handleQueueAwareQuery = useCallback(
-    async (newMessages, abortController2) => {
-      if (!isLoading) {
-        return onQuery(newMessages, abortController2);
-      }
-      const userMessage = newMessages.find((m) => m.type === "user");
-      if (userMessage && userMessage.type === "user") {
-        const promptText = typeof userMessage.message.content === "string" ? userMessage.message.content : "";
-        if (promptText) {
-          setQueuedPrompts((prev) => [...prev, promptText]);
-        }
-      }
-    },
-    [isLoading]
-  );
-  useEffect(() => {
-    processNextQueuedPromptRef.current = async () => {
-      if (queuedPrompts.length === 0) return;
-      const nextPrompt = queuedPrompts[0];
-      setQueuedPrompts((prev) => prev.slice(1));
-      if (!nextPrompt) return;
-      const userMessage = {
-        type: "user",
-        uuid: randomUUID(),
-        message: {
-          role: "user",
-          content: nextPrompt
-        }
-      };
-      setIsLoading(true);
-      const newAbortController = new AbortController();
-      setAbortController(newAbortController);
-      await onQuery([userMessage], newAbortController);
-    };
-  }, [queuedPrompts]);
-  return /* @__PURE__ */ React.createElement(
-    PermissionProvider,
-    {
-      isBypassPermissionsModeAvailable: !safeMode,
-      children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(React.Fragment, { key: `static-wrapper-${forkNumber}` }, /* @__PURE__ */ React.createElement(
-        Static,
-        {
-          items: staticItems,
-          children: (item) => /* @__PURE__ */ React.createElement(React.Fragment, { key: item.id }, item.jsx)
-        }
-      )), /* @__PURE__ */ React.createElement(React.Fragment, { key: `dynamic-messages-${forkNumber}` }, dynamicItems.map((item) => item.jsx)), /* @__PURE__ */ React.createElement(
-        Box,
-        {
-          key: `transient-ui-${forkNumber}`,
-          borderColor: "red",
-          borderStyle: debug ? "single" : void 0,
-          flexDirection: "column",
-          width: "100%"
-        },
-        !isResizeClearing && !toolJSX && !toolUseConfirm && !binaryFeedbackContext && /* @__PURE__ */ React.createElement(
-          TodoPanel,
-          {
-            todos: getTodos(),
-            isVisible: isTodoPanelVisible,
-            isLoading,
-            showTodoList: isTodoPanelVisible
-          }
-        ),
-        !isResizeClearing && !isLoading && !toolJSX && !toolUseConfirm && !binaryFeedbackContext && queuedPrompts.length === 0 && /* @__PURE__ */ React.createElement(
-          TurnCompletionIndicator,
-          {
-            durationMs: lastTurnDurationMs,
-            isVisible: lastTurnDurationMs !== null
-          }
-        ),
-        toolJSX?.shouldHidePromptInput ? toolJSX.jsx : null,
-        !toolJSX && binaryFeedbackContext && !isMessageSelectorVisible && /* @__PURE__ */ React.createElement(
-          BinaryFeedback,
-          {
-            m1: binaryFeedbackContext.m1,
-            m2: binaryFeedbackContext.m2,
-            resolve: (result) => {
-              binaryFeedbackContext.resolve(result);
-              setTimeout(() => setBinaryFeedbackContext(null), 0);
-            },
-            verbose,
-            normalizedMessages,
-            tools: currentTools,
-            debug,
-            erroredToolUseIDs,
-            inProgressToolUseIDs,
-            unresolvedToolUseIDs
-          }
-        ),
-        !toolJSX && toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && /* @__PURE__ */ React.createElement(
-          PermissionRequest,
-          {
-            toolUseConfirm,
-            onDone: () => setToolUseConfirm(null),
-            verbose
-          }
-        ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && askUserQuestionContext && /* @__PURE__ */ React.createElement(
-          AskUserQuestionDialog,
-          {
-            context: askUserQuestionContext,
-            onDone: () => setAskUserQuestionContext(null)
-          }
-        ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && showingCostDialog && /* @__PURE__ */ React.createElement(
-          CostThresholdDialog,
-          {
-            onDone: () => {
-              setShowCostDialog(false);
-              setHaveShownCostDialog(true);
-              const projectConfig = getGlobalConfig();
-              saveGlobalConfig({
-                ...projectConfig,
-                hasAcknowledgedCostThreshold: true
-              });
-            }
-          }
-        ),
-        !toolUseConfirm && !toolJSX?.shouldHidePromptInput && shouldShowPromptInput && !isMessageSelectorVisible && !binaryFeedbackContext && !askUserQuestionContext && !showingCostDialog && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
-          BackgroundTasksPanel,
-          {
-            shells: backgroundShells,
-            isVisible: showBackgroundPanel,
-            onSelect: (shell) => {
-              setShowBackgroundPanel(false);
-            },
-            onKill: (shell) => {
-              BackgroundShellManager.getInstance().kill(shell.id);
-            },
-            onClose: () => setShowBackgroundPanel(false)
-          }
-        ), /* @__PURE__ */ React.createElement(
-          PromptInput,
-          {
-            commands: currentCommands,
-            forkNumber,
-            messageLogName,
-            tools: currentTools,
-            isDisabled: apiKeyStatus === "invalid",
-            isLoading,
-            onQuery,
-            debug,
-            verbose,
-            verboseToggleMessage,
-            messages,
-            setToolJSX,
-            input: inputValue,
-            onInputChange: setInputValue,
-            mode: inputMode,
-            onModeChange: setInputMode,
-            submitCount,
-            onSubmitCountChange: setSubmitCount,
-            setIsLoading,
-            setAbortController,
-            onShowMessageSelector: handleShowMessageSelector,
-            setForkConvoWithMessagesOnTheNextRender,
-            readFileTimestamps: readFileTimestamps.current,
-            abortController,
-            onModelChange: handleModelChange,
-            onRollbackConversation: rollbackConversation,
-            onToggleTodoPanel: handleToggleTodoPanel,
-            onToggleVerbose: handleToggleVerbose,
-            onToggleBackgroundPanel: handleToggleBackgroundPanel,
-            backgroundShellCount: backgroundShells.filter((s) => s.status === "running").length,
-            isBackgroundPanelOpen: showBackgroundPanel,
-            fallbackMode,
-            queuedPrompts,
-            onQueuePrompt: (prompt) => setQueuedPrompts((prev) => [...prev, prompt]),
-            onPopQueuedPrompt: () => {
-              if (queuedPrompts.length === 0) return void 0;
-              const lastPrompt = queuedPrompts[queuedPrompts.length - 1];
-              setQueuedPrompts((prev) => prev.slice(0, -1));
-              return lastPrompt;
-            },
-            onInterrupt,
-            isOverlayActive: !!(toolJSX && !toolJSX.shouldHidePromptInput),
-            unmount: unmountREPL,
-            startupItems
-          }
-        ), toolJSX && !toolJSX.shouldHidePromptInput && toolJSX.jsx)
-      ), isMessageSelectorVisible && /* @__PURE__ */ React.createElement(React.Fragment, { key: `message-selector-wrapper-${forkNumber}` }, /* @__PURE__ */ React.createElement(
-        MessageSelector,
-        {
-          erroredToolUseIDs,
-          unresolvedToolUseIDs,
-          messages: normalizeMessagesForAPI(messages),
-          onSelect: async (message) => {
-            setIsMessageSelectorVisible(false);
-            if (!messages.includes(message)) {
-              return;
-            }
-            onCancel();
-            setImmediate(async () => {
-              await clearTerminal();
-              setMessages([]);
-              setForkConvoWithMessagesOnTheNextRender(
-                messages.slice(0, messages.indexOf(message))
-              );
-              if (typeof message.message.content === "string") {
-                setInputValue(message.message.content);
-              }
-            });
-          },
-          onEscape: () => setIsMessageSelectorVisible(false),
-          tools: currentTools
-        }
-      )), /* @__PURE__ */ React.createElement(Newline, null))
-    }
-  );
-}
-function shouldRenderStatically(message, messages, unresolvedToolUseIDs) {
-  switch (message.type) {
-    case "user":
-    case "assistant": {
-      const toolUseID = getToolUseID(message);
-      if (!toolUseID) {
-        return true;
-      }
-      if (unresolvedToolUseIDs.has(toolUseID)) {
-        return false;
-      }
-      const correspondingProgressMessage = messages.find(
-        (_) => _.type === "progress" && _.toolUseID === toolUseID
-      );
-      if (!correspondingProgressMessage) {
-        return true;
-      }
-      return !intersects(
-        unresolvedToolUseIDs,
-        correspondingProgressMessage.siblingToolUseIDs
-      );
-    }
-    case "progress":
-      return !intersects(unresolvedToolUseIDs, message.siblingToolUseIDs);
-  }
-}
-function intersects(a, b) {
-  return a.size > 0 && b.size > 0 && [...a].some((_) => b.has(_));
-}
-export {
-  REPL
-};
-//# sourceMappingURL=REPL.js.map