@within-7/minto 0.4.2 → 0.4.3

package/dist/screens/REPL.js

@@ -1,1240 +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 { StreamingTextPreview } from "../components/StreamingTextPreview.js";
-import { MessageSelector } from "../components/MessageSelector.js";
-import {
-  RewindPanel
-} from "../components/RewindPanel.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 { ThinkingSelector } from "../components/ThinkingSelector.js";
-import { TurnCompletionIndicator } from "../components/TurnCompletionIndicator.js";
-import { getTodos, initTodoSession } from "../utils/todoStorage.js";
-import {
-  setMessagesGetter,
-  setMessagesSetter,
-  setModelConfigChangeHandler,
-  setLanguageChangeHandler
-} from "../messages.js";
-import { getGlobalConfig, saveGlobalConfig } from "../utils/config.js";
-import { useBackgroundShells } from "../hooks/useBackgroundShells.js";
-import { useDeferredLoading } from "../hooks/useDeferredLoading.js";
-import { useSessionTracking } from "../hooks/useSessionTracking.js";
-import { getNextAvailableLogForkNumber } from "../utils/log.js";
-import {
-  getErroredToolUseMessages,
-  getInProgressToolUseIDs,
-  getLastAssistantMessageId,
-  getToolUseID,
-  getUnresolvedToolUseIDs,
-  INTERRUPT_MESSAGE,
-  isNotEmptyMessage,
-  normalizeMessages,
-  normalizeMessagesForAPI,
-  processUserInput,
-  reorderMessages
-} from "../utils/messages.js";
-import { logError } from "../utils/log.js";
-import {
-  clearTerminal,
-  clearScreen
-} 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 { animationManager } from "../utils/animationManager.js";
-import { handleHashCommand } from "../commands/terminalSetup.js";
-import { getMessagesPath } from "../utils/log.js";
-import { BackgroundShellManager } from "../utils/BackgroundShellManager.js";
-import { BackgroundTasksPanel } from "../components/BackgroundTasksPanel.js";
-import { TeamMemberPanel } from "../components/TeamMemberPanel.js";
-import { AgentViewBanner } from "../components/AgentViewBanner.js";
-import { TitledDivider } from "../components/TitledDivider.js";
-import { t } from "../i18n/index.js";
-import { IdleNotificationBar } from "../components/IdleNotificationBar.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 { useIdleNotifications } from "../hooks/useIdleNotifications.js";
-import { useTeamMembers } from "../hooks/useTeamMembers.js";
-import {
-  recordFirstPrompt,
-  incrementMessageCount,
-  flushSessionStats
-} from "../utils/sessionTracker.js";
-import {
-  getActiveTeams,
-  disbandTeam,
-  formatUserGuidanceForInjection,
-  teamEvents
-} from "../services/agentTeams/index.js";
-import { AgentEngine } from "../engine/AgentEngine.js";
-import { EngineRegistry, setGlobalRegistry } from "../engine/EngineRegistry.js";
-import { useAgentEngine } from "../hooks/useAgentEngine.js";
-const RESUME_VISIBLE_MESSAGE_COUNT = Infinity;
-const TRANSCRIPT_VISIBLE_COUNT = 10;
-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
-}) {
-  const [screen, setScreen] = useState(
-    verboseFromCLI === true ? "transcript" : "prompt"
-  );
-  const [showAllInTranscript, setShowAllInTranscript] = useState(false);
-  const verbose = screen === "transcript";
-  const [forkNumber, setForkNumber] = useState(
-    getNextAvailableLogForkNumber(messageLogName, initialForkNumber, 0)
-  );
-  const [isResizeClearing, setIsResizeClearing] = useState(false);
-  const safeRefork = useCallback(async (beforeRefork) => {
-    setIsResizeClearing(true);
-    await new Promise((resolve) => setTimeout(resolve, 50));
-    await clearTerminal();
-    beforeRefork?.();
-    setForkNumber((prev) => prev + 1);
-    setIsResizeClearing(false);
-  }, []);
-  const { exit: unmountREPL } = useApp();
-  useFullscreenExitCallback(() => safeRefork());
-  useEffect(() => {
-    const unsubscribe = animationManager.onResume(() => safeRefork());
-    return unsubscribe;
-  }, [safeRefork]);
-  useEffect(() => {
-    const handler = () => safeRefork();
-    process.on("SIGCONT", handler);
-    return () => {
-      process.off("SIGCONT", handler);
-    };
-  }, [safeRefork]);
-  const [
-    forkConvoWithMessagesOnTheNextRender,
-    setForkConvoWithMessagesOnTheNextRender
-  ] = useState(null);
-  const defaultEngine = useMemo(() => {
-    const engine = new AgentEngine({
-      agentId: "default",
-      name: "default",
-      role: "default",
-      systemPrompt: () => getSystemPrompt(),
-      context: () => getContext(),
-      tools,
-      commands,
-      initialMessages: initialMessages ?? [],
-      verbose: verboseFromCLI === true,
-      safeMode,
-      safetyMode,
-      messageLogName,
-      forkNumber: getNextAvailableLogForkNumber(
-        messageLogName,
-        initialForkNumber,
-        0
-      )
-    });
-    return engine;
-  }, []);
-  const registry = useMemo(() => {
-    const r = new EngineRegistry();
-    r.register("default", defaultEngine);
-    setGlobalRegistry(r);
-    return r;
-  }, [defaultEngine]);
-  const {
-    messages,
-    isLoading,
-    lastTurnDurationMs,
-    submitPrompt: engineSubmitPrompt,
-    abort: engineAbort,
-    setMessages: engineSetMessages,
-    appendMessages: engineAppendMessages
-  } = useAgentEngine(registry.focused ?? null);
-  const [toolJSX, setToolJSX] = useState(null);
-  const [toolUseConfirm, setToolUseConfirm] = useState(
-    null
-  );
-  const [messageHistory, setMessageHistory] = useState([]);
-  const [inputValue, setInputValue] = useState("");
-  const [inputMode, setInputMode] = useState(
-    "prompt"
-  );
-  const [submitCount, setSubmitCount] = useState(0);
-  const [isMessageSelectorVisible, setIsMessageSelectorVisible] = useState(false);
-  const [isRewindPanelVisible, setIsRewindPanelVisible] = 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 [showThinkingSelector, setShowThinkingSelector] = useState(false);
-  const {
-    shells: backgroundShells,
-    isPanelVisible: showBackgroundPanel,
-    setIsPanelVisible: setShowBackgroundPanel,
-    runningCount: backgroundShellRunningCount
-  } = useBackgroundShells();
-  const [showTeamPanel, setShowTeamPanel] = useState(false);
-  const [currentViewAgent, setCurrentViewAgent] = useState(null);
-  const { notifications: idleNotifications } = useIdleNotifications();
-  const { members: teamMembers, teamName, hasActiveTeam } = useTeamMembers();
-  useEffect(() => {
-    if (!hasActiveTeam) {
-      setShowTeamPanel(false);
-      setToolJSX(null);
-      setToolUseConfirm(null);
-      if (currentViewAgent) {
-        setIsResizeClearing(true);
-        clearScreen();
-        registry.setFocus("default");
-        setCurrentViewAgent(null);
-        setForkNumber((prev) => prev + 1);
-        setImmediate(() => setIsResizeClearing(false));
-      }
-      defaultEngine.updateConfig({
-        systemPrompt: () => getSystemPrompt()
-      });
-      defaultEngine.demoteFromTeamLead();
-    }
-  }, [hasActiveTeam]);
-  useEffect(() => {
-    const unsub = registry.onChange(() => {
-      if (isSwitchingViewRef.current) return;
-      if (registry.focusedId === "default" && currentViewAgent) {
-        setIsResizeClearing(true);
-        clearScreen();
-        setCurrentViewAgent(null);
-        setForkNumber((prev) => prev + 1);
-        setImmediate(() => setIsResizeClearing(false));
-      }
-    });
-    return unsub;
-  }, [registry, currentViewAgent]);
-  const prevUnresolvedRef = useRef(/* @__PURE__ */ new Set());
-  const isSwitchingViewRef = useRef(false);
-  const getBinaryFeedbackResponse = useCallback(
-    (m1, m2) => {
-      return new Promise((resolvePromise) => {
-        setBinaryFeedbackContext({
-          m1,
-          m2,
-          resolve: resolvePromise
-        });
-      });
-    },
-    []
-  );
-  const readFileTimestamps = useRef({});
-  const { status: apiKeyStatus, reverify } = useApiKeyVerification();
-  const onInterrupt = useCallback(() => {
-    if (!isLoading) {
-      return;
-    }
-    const currentMessages = registry.focused?.messages;
-    if (currentMessages && currentMessages.length > 0) {
-      const serializedMessages = [...currentMessages].map(
-        serializeMessageForLog
-      );
-      overwriteLog(
-        getMessagesPath(messageLogName, forkNumber, 0),
-        serializedMessages
-      );
-    }
-    setToolJSX(null);
-    setToolUseConfirm(null);
-    setBinaryFeedbackContext(null);
-    if (toolUseConfirm) {
-      toolUseConfirm.onAbort();
-    } else {
-      engineAbort();
-    }
-  }, [
-    isLoading,
-    registry.focused?.messages,
-    messageLogName,
-    forkNumber,
-    toolUseConfirm,
-    engineAbort
-  ]);
-  const onCancel = useCallback(() => {
-    onInterrupt();
-  }, [onInterrupt]);
-  useEffect(() => {
-    if (forkConvoWithMessagesOnTheNextRender) {
-      setForkNumber((_) => _ + 1);
-      setForkConvoWithMessagesOnTheNextRender(null);
-      engineSetMessages(forkConvoWithMessagesOnTheNextRender);
-    }
-  }, [forkConvoWithMessagesOnTheNextRender, engineSetMessages]);
-  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;
-    }
-    try {
-      const tempAbortController = new AbortController();
-      const newMessages = await processUserInput(
-        initialPrompt,
-        "prompt",
-        setToolJSX,
-        {
-          abortController: tempAbortController,
-          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);
-          }
-        }
-        await onQuery(newMessages);
-      } else {
-        addToHistory(initialPrompt);
-      }
-      setHaveShownCostDialog(
-        getGlobalConfig().hasAcknowledgedCostThreshold || false
-      );
-    } catch (error) {
-      logError(error);
-    }
-  }
-  const rollbackConversation = useCallback(() => {
-    if (messageHistory.length === 0) {
-      return false;
-    }
-    const previousMessages = messageHistory[messageHistory.length - 1];
-    if (!previousMessages) return false;
-    engineSetMessages(previousMessages);
-    setMessageHistory((history) => history.slice(0, -1));
-    return true;
-  }, [messageHistory, engineSetMessages]);
-  async function onQuery(newMessages, _passedAbortController) {
-    setScreen("prompt");
-    setShowAllInTranscript(false);
-    const firstMessage = newMessages[0];
-    const isKodingRequest = newMessages.length > 0 && firstMessage !== void 0 && firstMessage.type === "user" && "options" in firstMessage && firstMessage.options?.isKodingRequest === true;
-    setMessageHistory((history) => [...history, [...messages]].slice(-10));
-    markProjectOnboardingComplete();
-    const lastMessage = newMessages[newMessages.length - 1];
-    if (lastMessage && lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
-      recordFirstPrompt(lastMessage.message.content);
-      incrementMessageCount(1);
-    }
-    if (lastMessage && lastMessage.type === "assistant") {
-      engineAppendMessages(newMessages);
-      return;
-    }
-    const maxThinkingTokens = await getMaxThinkingTokens([
-      ...messages,
-      ...newMessages
-    ]);
-    const targetEngine = registry.focused ?? defaultEngine;
-    targetEngine.updateConfig({ maxThinkingTokens });
-    if (isKodingRequest) {
-      targetEngine.updateConfig({ isKodingRequest: true });
-    }
-    await engineSubmitPrompt(newMessages);
-    flushSessionStats();
-    if (isKodingRequest) {
-      const engineMsgs = registry.focused?.messages ?? [];
-      const lastAssistantMsg = [...engineMsgs].reverse().find((m) => m.type === "assistant");
-      if (lastAssistantMsg && lastAssistantMsg.type === "assistant") {
-        try {
-          const content = typeof lastAssistantMsg.message.content === "string" ? lastAssistantMsg.message.content : lastAssistantMsg.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);
-        }
-      }
-      targetEngine.updateConfig({ isKodingRequest: void 0 });
-    }
-  }
-  useCostSummary();
-  useEffect(() => {
-    const getMessages = () => messages;
-    setMessagesGetter(getMessages);
-    setMessagesSetter(engineSetMessages);
-  }, [messages, engineSetMessages]);
-  useEffect(() => {
-    const todoSessionId = `${messageLogName}-${forkNumber}`;
-    initTodoSession(todoSessionId);
-    if (initialMessages && initialMessages.length > 0) {
-      restoreToolUseAgentMappings();
-    }
-  }, [messageLogName, forkNumber, initialMessages]);
-  useEffect(() => {
-    setModelConfigChangeHandler(() => safeRefork());
-  }, [safeRefork]);
-  useEffect(() => {
-    setLanguageChangeHandler(() => safeRefork());
-  }, [safeRefork]);
-  useLogMessages(messages, messageLogName, forkNumber);
-  useLogStartupTime();
-  useEffect(() => {
-    onInit();
-  }, []);
-  useSessionTracking(messageLogName, forkNumber);
-  const activeMessages = useMemo(() => {
-    const engine = registry.focused;
-    if (engine && engine !== defaultEngine && engine.ownMessagesStartIndex > 0) {
-      return messages.slice(engine.ownMessagesStartIndex);
-    }
-    return messages;
-  }, [messages, currentViewAgent, registry, defaultEngine]);
-  const normalizedMessages = useMemo(
-    () => normalizeMessages(activeMessages).filter(isNotEmptyMessage),
-    [activeMessages]
-  );
-  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 isTranscript = screen === "transcript";
-    const shouldTruncateTranscript = isTranscript && !showAllInTranscript;
-    const totalMessageCount = reorderedMessages.length;
-    const transcriptTruncatedCount = shouldTruncateTranscript && totalMessageCount > TRANSCRIPT_VISIBLE_COUNT ? totalMessageCount - TRANSCRIPT_VISIBLE_COUNT : 0;
-    const resumeHiddenCount = !isTranscript && isResumedConversation && reorderedMessages.length > RESUME_VISIBLE_MESSAGE_COUNT ? reorderedMessages.length - RESUME_VISIBLE_MESSAGE_COUNT : 0;
-    const visibleMessages = transcriptTruncatedCount > 0 ? reorderedMessages.slice(-TRANSCRIPT_VISIBLE_COUNT) : resumeHiddenCount > 0 ? reorderedMessages.slice(-RESUME_VISIBLE_MESSAGE_COUNT) : reorderedMessages;
-    const result = [];
-    result.push({
-      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() }), currentViewAgent && (() => {
-        const focusedEngine = registry.get(registry.focusedId);
-        const engineName = focusedEngine?.engineConfig?.name ?? "unknown";
-        const engineState = focusedEngine?.state ?? "pending";
-        return /* @__PURE__ */ React.createElement(
-          AgentViewBanner,
-          {
-            displayName: currentViewAgent.includes("@") ? currentViewAgent.split("@")[0] : currentViewAgent,
-            agentType: engineName,
-            status: engineState
-          }
-        );
-      })())
-    });
-    if (transcriptTruncatedCount > 0) {
-      result.push({
-        type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { key: `transcript-truncation-${forkNumber}`, width: "100%" }, /* @__PURE__ */ React.createElement(
-          TitledDivider,
-          {
-            title: t("ui.transcript.showPrevious").replace(
-              "{count}",
-              String(transcriptTruncatedCount)
-            )
-          }
-        ))
-      });
-    } else if (isTranscript && showAllInTranscript && totalMessageCount > TRANSCRIPT_VISIBLE_COUNT) {
-      result.push({
-        type: "static",
-        jsx: /* @__PURE__ */ React.createElement(Box, { key: `transcript-hide-${forkNumber}`, width: "100%" }, /* @__PURE__ */ React.createElement(
-          TitledDivider,
-          {
-            title: t("ui.transcript.hidePrevious").replace(
-              "{count}",
-              String(totalMessageCount - TRANSCRIPT_VISIBLE_COUNT)
-            )
-          }
-        ))
-      });
-    }
-    if (resumeHiddenCount > 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 ", resumeHiddenCount, " 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 && !isRewindPanelVisible && !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;
-      }
-      if (!isNotEmptyMessage(_)) {
-        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 && !isRewindPanelVisible && (!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,
-    isRewindPanelVisible,
-    unresolvedToolUseIDs,
-    currentMcpClients,
-    isDefaultModel,
-    isResumedConversation,
-    // Transcript mode dependencies
-    screen,
-    showAllInTranscript,
-    // V1+ dependencies
-    messageGroups,
-    getGroupForMessage,
-    getGroupForToolUse,
-    shouldGroupBeStatic,
-    displayConfig,
-    agentTranscripts,
-    toolOutputs,
-    // Agent view dependencies
-    currentViewAgent
-  ]);
-  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 noopSetBool = useCallback((_) => {
-  }, []);
-  const noopSetAbort = useCallback((_) => {
-  }, []);
-  const handleShowMessageSelector = useCallback(() => {
-    setIsMessageSelectorVisible((prev) => !prev);
-  }, []);
-  const handleShowRewindPanel = useCallback(() => {
-    if (messages.length === 0) return;
-    setIsRewindPanelVisible(true);
-  }, [messages.length]);
-  const handleRewindAction = useCallback(
-    (action, point) => {
-      setIsRewindPanelVisible(false);
-      if (action === "never_mind") return;
-      if (action === "restore_code_and_conversation" || action === "restore_conversation") {
-        onCancel();
-        setImmediate(async () => {
-          await clearTerminal();
-          const truncatedMessages = messages.slice(0, point.messageIndex);
-          engineSetMessages([]);
-          setForkConvoWithMessagesOnTheNextRender(truncatedMessages);
-          if (point.userText) {
-            setInputValue(point.userText);
-          }
-        });
-        return;
-      }
-      if (action === "restore_code") {
-        return;
-      }
-      if (action === "summarize_from_here") {
-        onCancel();
-        setImmediate(async () => {
-          await clearTerminal();
-          const preserved = messages.slice(0, point.messageIndex);
-          engineSetMessages([]);
-          setForkConvoWithMessagesOnTheNextRender(preserved);
-          if (point.userText) {
-            setInputValue(point.userText);
-          }
-        });
-      }
-    },
-    [
-      messages,
-      onCancel,
-      engineSetMessages,
-      setForkConvoWithMessagesOnTheNextRender
-    ]
-  );
-  const handleToggleTodoPanel = useCallback(() => {
-    setIsTodoPanelVisible((prev) => !prev);
-  }, []);
-  const handleToggleThinkingSelector = useCallback(() => {
-    setShowThinkingSelector((prev) => !prev);
-  }, []);
-  const handleToggleBackgroundPanel = useCallback(() => {
-    setShowBackgroundPanel((prev) => !prev);
-  }, []);
-  const handleToggleTeamPanel = useCallback(() => {
-    setShowTeamPanel((prev) => !prev);
-  }, []);
-  const handleKillAllAgents = useCallback(() => {
-    const teams = getActiveTeams();
-    for (const team of teams) {
-      disbandTeam(team.name);
-    }
-  }, []);
-  const handleSwitchView = useCallback(
-    async (agentId) => {
-      isSwitchingViewRef.current = true;
-      setShowTeamPanel(false);
-      const isTeamLead = agentId === null || agentId.startsWith("team-lead") || agentId === "team-lead";
-      const oldFocused = registry.focused;
-      if (oldFocused && oldFocused !== defaultEngine) {
-        oldFocused.setIdlePaused(false);
-      }
-      await safeRefork(() => {
-        setCurrentViewAgent(isTeamLead ? null : agentId);
-        const targetId = isTeamLead ? "default" : agentId;
-        if (registry.get(targetId)) {
-          registry.setFocus(targetId);
-          const newFocused = registry.get(targetId);
-          if (newFocused && newFocused !== defaultEngine) {
-            newFocused.setIdlePaused(true);
-          }
-        } else {
-          registry.setFocus("default");
-        }
-      });
-      isSwitchingViewRef.current = false;
-    },
-    [registry, defaultEngine]
-  );
-  const handleBackFromAgent = useCallback(async () => {
-    await handleSwitchView(null);
-  }, [handleSwitchView]);
-  const handleCycleTeammate = useCallback(
-    (direction) => {
-      const activeMembers = teamMembers.filter((m) => m.status !== "stopped");
-      if (activeMembers.length === 0) return;
-      const memberIds = [
-        null,
-        ...activeMembers.map((m) => m.name)
-      ];
-      const currentIdx = currentViewAgent === null ? 0 : memberIds.findIndex(
-        (id) => id !== null && (currentViewAgent.includes(id) || id.includes(currentViewAgent?.split("@")[0] || ""))
-      );
-      let nextIdx;
-      if (direction === "next") {
-        nextIdx = currentIdx < 0 ? 0 : (currentIdx + 1) % memberIds.length;
-      } else {
-        nextIdx = currentIdx < 0 ? memberIds.length - 1 : (currentIdx - 1 + memberIds.length) % memberIds.length;
-      }
-      const nextId = memberIds[nextIdx];
-      if (nextId) handleSwitchView(nextId);
-    },
-    [teamMembers, currentViewAgent, handleSwitchView]
-  );
-  const handleToggleAgentView = useCallback(() => {
-    if (currentViewAgent) {
-      handleBackFromAgent();
-    } else {
-      const activeMembers = teamMembers.filter((m) => m.status !== "stopped");
-      const firstActive = activeMembers[0];
-      if (firstActive) {
-        handleSwitchView(firstActive.name);
-      }
-    }
-  }, [currentViewAgent, teamMembers, handleBackFromAgent, handleSwitchView]);
-  const handleModelChange = useCallback(() => safeRefork(), [safeRefork]);
-  const handleToggleScreen = useCallback(async () => {
-    setShowAllInTranscript(false);
-    await safeRefork(
-      () => setScreen((prev) => prev === "transcript" ? "prompt" : "transcript")
-    );
-  }, [safeRefork]);
-  const handleToggleShowAll = useCallback(async () => {
-    await safeRefork(() => setShowAllInTranscript((prev) => !prev));
-  }, [safeRefork]);
-  useEffect(() => {
-    const unsubscribe = teamEvents.onTeamChange(
-      (data) => {
-        if (data.event === "created") {
-          defaultEngine.promoteToTeamLead(data.teamName);
-          defaultEngine.updateConfig({
-            systemPrompt: () => getSystemPrompt("team-lead")
-          });
-        } else if (data.event === "disbanded") {
-          defaultEngine.updateConfig({
-            systemPrompt: () => getSystemPrompt()
-          });
-        }
-      }
-    );
-    return unsubscribe;
-  }, [defaultEngine]);
-  useEffect(() => {
-    const engine = registry.focused;
-    if (!engine) return;
-    engine.setCanUseTool(canUseTool);
-    engine.setAskUser(askUser);
-    engine.setToolJSX(setToolJSX);
-    engine.setBinaryFeedbackResponse(getBinaryFeedbackResponse);
-  }, [registry.focusedId, canUseTool, askUser, getBinaryFeedbackResponse]);
-  useEffect(() => {
-    defaultEngine.start();
-    return () => {
-      defaultEngine.stop();
-    };
-  }, [defaultEngine]);
-  useEffect(() => {
-    defaultEngine.updateConfig({
-      tools: currentTools,
-      commands: currentCommands
-    });
-  }, [currentTools, currentCommands, defaultEngine]);
-  useEffect(() => {
-    defaultEngine.updateConfig({ verbose, safeMode, safetyMode });
-  }, [verbose, safeMode, safetyMode, defaultEngine]);
-  return /* @__PURE__ */ React.createElement(
-    PermissionProvider,
-    {
-      isBypassPermissionsModeAvailable: !safeMode,
-      children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__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)), isLoading && !isResizeClearing && /* @__PURE__ */ React.createElement(StreamingTextPreview, null), /* @__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,
-            focusedAgentId: currentViewAgent
-          }
-        ),
-        !isResizeClearing && !isLoading && !toolJSX && !toolUseConfirm && !binaryFeedbackContext && !defaultEngine.injectionChannel.hasMessages() && /* @__PURE__ */ React.createElement(
-          TurnCompletionIndicator,
-          {
-            durationMs: lastTurnDurationMs,
-            isVisible: lastTurnDurationMs !== null
-          }
-        ),
-        toolJSX?.shouldHidePromptInput ? toolJSX.jsx : null,
-        !toolJSX && binaryFeedbackContext && !isMessageSelectorVisible && !isRewindPanelVisible && /* @__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 && !isRewindPanelVisible && !binaryFeedbackContext && !askUserQuestionContext && /* @__PURE__ */ React.createElement(
-          PermissionRequest,
-          {
-            toolUseConfirm,
-            onDone: () => setToolUseConfirm(null),
-            verbose
-          }
-        ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !binaryFeedbackContext && askUserQuestionContext && /* @__PURE__ */ React.createElement(
-          AskUserQuestionDialog,
-          {
-            context: askUserQuestionContext,
-            onDone: () => setAskUserQuestionContext(null)
-          }
-        ),
-        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !isRewindPanelVisible && !binaryFeedbackContext && !askUserQuestionContext && showingCostDialog && /* @__PURE__ */ React.createElement(
-          CostThresholdDialog,
-          {
-            onDone: () => {
-              setShowCostDialog(false);
-              setHaveShownCostDialog(true);
-              const projectConfig = getGlobalConfig();
-              saveGlobalConfig({
-                ...projectConfig,
-                hasAcknowledgedCostThreshold: true
-              });
-            }
-          }
-        ),
-        !toolUseConfirm && !toolJSX?.shouldHidePromptInput && shouldShowPromptInput && !isMessageSelectorVisible && !isRewindPanelVisible && !showThinkingSelector && !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)
-          }
-        ), !isResizeClearing && /* @__PURE__ */ React.createElement(IdleNotificationBar, { notifications: idleNotifications }), /* @__PURE__ */ React.createElement(
-          PromptInput,
-          {
-            commands: currentCommands,
-            forkNumber,
-            focusedAgentName: currentViewAgent ? teamMembers.find((m) => m.id === currentViewAgent)?.name ?? currentViewAgent.split("@")[0] : hasActiveTeam ? "team-lead" : null,
-            messageLogName,
-            tools: currentTools,
-            isDisabled: apiKeyStatus === "invalid",
-            isLoading,
-            onQuery,
-            debug,
-            verbose,
-            messages,
-            setToolJSX,
-            input: inputValue,
-            onInputChange: setInputValue,
-            mode: inputMode,
-            onModeChange: setInputMode,
-            submitCount,
-            onSubmitCountChange: setSubmitCount,
-            setIsLoading: noopSetBool,
-            setAbortController: noopSetAbort,
-            onShowMessageSelector: handleShowMessageSelector,
-            setForkConvoWithMessagesOnTheNextRender,
-            readFileTimestamps: readFileTimestamps.current,
-            abortController: null,
-            onModelChange: handleModelChange,
-            onShowRewindPanel: handleShowRewindPanel,
-            onToggleTodoPanel: handleToggleTodoPanel,
-            onToggleThinkingSelector: handleToggleThinkingSelector,
-            onToggleScreen: handleToggleScreen,
-            onToggleShowAllInTranscript: handleToggleShowAll,
-            screen,
-            onToggleBackgroundPanel: handleToggleBackgroundPanel,
-            onToggleTeamPanel: handleToggleTeamPanel,
-            onCycleTeammate: handleCycleTeammate,
-            onToggleAgentView: handleToggleAgentView,
-            onKillAllAgents: handleKillAllAgents,
-            backgroundShellCount: backgroundShells.filter((s) => s.status === "running").length,
-            isBackgroundPanelOpen: showBackgroundPanel,
-            fallbackMode,
-            onInjectMessage: (input) => {
-              const formatted = formatUserGuidanceForInjection(input);
-              const focusedEng = registry.focused ?? defaultEngine;
-              focusedEng.injectionChannel.push(
-                formatted,
-                "user",
-                input
-              );
-            },
-            onRemoveQueuedMessage: () => {
-              const focusedEng = registry.focused ?? defaultEngine;
-              return focusedEng.injectionChannel.removeLastUserMessage();
-            },
-            injectionPending: (registry.focused ?? defaultEngine).injectionChannel.size > 0,
-            getQueuedUserMessages: () => (registry.focused ?? defaultEngine).injectionChannel.peekUserDisplayTexts(),
-            onInterrupt,
-            isOverlayActive: showTeamPanel || !!(toolJSX && !toolJSX.shouldHidePromptInput),
-            unmount: unmountREPL,
-            startupItems,
-            teamMembers,
-            hasActiveTeam
-          }
-        ), toolJSX && !toolJSX.shouldHidePromptInput && toolJSX.jsx, /* @__PURE__ */ React.createElement(
-          TeamMemberPanel,
-          {
-            isVisible: showTeamPanel,
-            onClose: () => setShowTeamPanel(false),
-            onFocusAgent: handleSwitchView
-          }
-        ), screen === "transcript" && /* @__PURE__ */ React.createElement(
-          Box,
-          {
-            width: "100%",
-            paddingLeft: 2,
-            marginTop: 1,
-            borderStyle: "single",
-            borderTop: true,
-            borderBottom: false,
-            borderLeft: false,
-            borderRight: false,
-            borderColor: SEMANTIC_COLORS.dim
-          },
-          /* @__PURE__ */ React.createElement(Text, { dimColor: true }, t("ui.transcript.showing"))
-        ))
-      ), 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();
-              engineSetMessages([]);
-              setForkConvoWithMessagesOnTheNextRender(
-                messages.slice(0, messages.indexOf(message))
-              );
-              if (typeof message.message.content === "string") {
-                setInputValue(message.message.content);
-              }
-            });
-          },
-          onEscape: () => setIsMessageSelectorVisible(false),
-          tools: currentTools
-        }
-      )), isRewindPanelVisible && /* @__PURE__ */ React.createElement(
-        RewindPanel,
-        {
-          messages,
-          onAction: handleRewindAction,
-          onEscape: () => setIsRewindPanelVisible(false)
-        }
-      ), showThinkingSelector && /* @__PURE__ */ React.createElement(
-        ThinkingSelector,
-        {
-          onClose: () => setShowThinkingSelector(false)
-        }
-      ), /* @__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