@shareai-lab/kode 1.1.12 → 1.1.13

package/dist/screens/REPL.js

@@ -0,0 +1,596 @@
+import { Box, Newline, Static } from "ink";
+import ProjectOnboarding, {
+  markProjectOnboardingComplete
+} from "../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 { MessageSelector } from "../components/MessageSelector.js";
+import {
+  PermissionRequest
+} from "../components/permissions/PermissionRequest.js";
+import PromptInput from "../components/PromptInput.js";
+import { Spinner } from "../components/Spinner.js";
+import { getSystemPrompt } from "../constants/prompts.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 { useCancelRequest } from "../hooks/useCancelRequest.js";
+import useCanUseTool from "../hooks/useCanUseTool.js";
+import { useLogMessages } from "../hooks/useLogMessages.js";
+import { PermissionProvider } from "../context/PermissionContext.js";
+import { ModeIndicator } from "../components/ModeIndicator.js";
+import {
+  setMessagesGetter,
+  setMessagesSetter,
+  setModelConfigChangeHandler
+} from "../messages.js";
+import {
+  query
+} from "../query.js";
+import { getGlobalConfig, saveGlobalConfig } from "../utils/config.js";
+import { logEvent } from "../services/statsig.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 { 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";
+function REPL({
+  commands,
+  safeMode,
+  debug = false,
+  initialForkNumber = 0,
+  initialPrompt,
+  messageLogName,
+  shouldShowPromptInput,
+  tools,
+  verbose: verboseFromCLI,
+  initialMessages,
+  mcpClients = [],
+  isDefaultModel = true,
+  initialUpdateVersion,
+  initialUpdateCommands
+}) {
+  const verbose = verboseFromCLI ?? getGlobalConfig().verbose;
+  const [forkNumber, setForkNumber] = useState(
+    getNextAvailableLogForkNumber(messageLogName, initialForkNumber, 0)
+  );
+  const [
+    forkConvoWithMessagesOnTheNextRender,
+    setForkConvoWithMessagesOnTheNextRender
+  ] = useState(null);
+  const [abortController, setAbortController] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [autoUpdaterResult, setAutoUpdaterResult] = useState(null);
+  const [toolJSX, setToolJSX] = useState(null);
+  const [toolUseConfirm, setToolUseConfirm] = useState(
+    null
+  );
+  const [messages, setMessages] = useState(initialMessages ?? []);
+  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 updateAvailableVersion = initialUpdateVersion ?? null;
+  const updateCommands = initialUpdateCommands ?? null;
+  const getBinaryFeedbackResponse = useCallback(
+    (m1, m2) => {
+      return new Promise((resolvePromise) => {
+        setBinaryFeedbackContext({
+          m1,
+          m2,
+          resolve: resolvePromise
+        });
+      });
+    },
+    []
+  );
+  const readFileTimestamps = useRef({});
+  const { status: apiKeyStatus, reverify } = useApiKeyVerification();
+  function onCancel() {
+    if (!isLoading) {
+      return;
+    }
+    setIsLoading(false);
+    if (toolUseConfirm) {
+      toolUseConfirm.onAbort();
+    } else if (abortController && !abortController.signal.aborted) {
+      abortController.abort();
+    }
+  }
+  useCancelRequest(
+    setToolJSX,
+    setToolUseConfirm,
+    setBinaryFeedbackContext,
+    onCancel,
+    isLoading,
+    isMessageSelectorVisible,
+    abortController?.signal
+  );
+  useEffect(() => {
+    if (forkConvoWithMessagesOnTheNextRender) {
+      setForkNumber((_) => _ + 1);
+      setForkConvoWithMessagesOnTheNextRender(null);
+      setMessages(forkConvoWithMessagesOnTheNextRender);
+    }
+  }, [forkConvoWithMessagesOnTheNextRender]);
+  useEffect(() => {
+    const totalCost = getTotalCost();
+    if (totalCost >= 5 && !showCostDialog && !haveShownCostDialog) {
+      logEvent("tengu_cost_threshold_reached", {});
+      setShowCostDialog(true);
+    }
+  }, [messages, showCostDialog, haveShownCostDialog]);
+  const canUseTool = useCanUseTool(setToolUseConfirm);
+  async function onInit() {
+    reverify();
+    if (!initialPrompt) {
+      return;
+    }
+    setIsLoading(true);
+    const newAbortController = new AbortController();
+    setAbortController(newAbortController);
+    const model = new ModelManager(getGlobalConfig()).getModelName("main");
+    const newMessages = await processUserInput(
+      initialPrompt,
+      "prompt",
+      setToolJSX,
+      {
+        abortController: newAbortController,
+        options: {
+          commands,
+          forkNumber,
+          messageLogName,
+          tools,
+          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") {
+        setAbortController(null);
+        setIsLoading(false);
+        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,
+            forkNumber,
+            messageLogName,
+            tools,
+            verbose,
+            safeMode,
+            maxThinkingTokens
+          },
+          messageId: getLastAssistantMessageId([...messages, ...newMessages]),
+          readFileTimestamps: readFileTimestamps.current,
+          abortController: newAbortController,
+          setToolJSX
+        },
+        getBinaryFeedbackResponse
+      )) {
+        setMessages((oldMessages) => [...oldMessages, message]);
+      }
+    } else {
+      addToHistory(initialPrompt);
+    }
+    setHaveShownCostDialog(
+      getGlobalConfig().hasAcknowledgedCostThreshold || false
+    );
+    setIsLoading(false);
+    setAbortController(null);
+  }
+  async function onQuery(newMessages, passedAbortController) {
+    const controllerToUse = passedAbortController || new AbortController();
+    if (!passedAbortController) {
+      setAbortController(controllerToUse);
+    }
+    const isKodingRequest = newMessages.length > 0 && newMessages[0].type === "user" && "options" in newMessages[0] && newMessages[0].options?.isKodingRequest === true;
+    setMessages((oldMessages) => [...oldMessages, ...newMessages]);
+    markProjectOnboardingComplete();
+    const lastMessage = newMessages[newMessages.length - 1];
+    if (lastMessage.type === "user" && typeof lastMessage.message.content === "string") {
+    }
+    if (lastMessage.type === "assistant") {
+      setAbortController(null);
+      setIsLoading(false);
+      return;
+    }
+    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,
+          forkNumber,
+          messageLogName,
+          tools,
+          verbose,
+          safeMode,
+          maxThinkingTokens,
+          // If this came from Koding mode, pass that along
+          isKodingRequest: isKodingRequest || void 0
+        },
+        messageId: getLastAssistantMessageId([...messages, lastMessage]),
+        readFileTimestamps: readFileTimestamps.current,
+        abortController: controllerToUse,
+        setToolJSX
+      },
+      getBinaryFeedbackResponse
+    )) {
+      setMessages((oldMessages) => [...oldMessages, message]);
+      if (message.type === "assistant") {
+        lastAssistantMessage = message;
+      }
+    }
+    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);
+      }
+    }
+    setIsLoading(false);
+  }
+  useCostSummary();
+  useEffect(() => {
+    const getMessages = () => messages;
+    setMessagesGetter(getMessages);
+    setMessagesSetter(setMessages);
+  }, [messages]);
+  useEffect(() => {
+    setModelConfigChangeHandler(() => {
+      setForkNumber((prev) => prev + 1);
+    });
+  }, []);
+  useLogMessages(messages, messageLogName, forkNumber);
+  useLogStartupTime();
+  useEffect(() => {
+    onInit();
+  }, []);
+  const normalizedMessages = useMemo(
+    () => normalizeMessages(messages).filter(isNotEmptyMessage),
+    [messages]
+  );
+  const unresolvedToolUseIDs = useMemo(
+    () => getUnresolvedToolUseIDs(normalizedMessages),
+    [normalizedMessages]
+  );
+  const inProgressToolUseIDs = useMemo(
+    () => getInProgressToolUseIDs(normalizedMessages),
+    [normalizedMessages]
+  );
+  const erroredToolUseIDs = useMemo(
+    () => new Set(
+      getErroredToolUseMessages(normalizedMessages).map(
+        (_) => _.message.content[0].id
+      )
+    ),
+    [normalizedMessages]
+  );
+  const messagesJSX = useMemo(() => {
+    return [
+      {
+        type: "static",
+        jsx: /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", key: `logo${forkNumber}` }, /* @__PURE__ */ React.createElement(
+          Logo,
+          {
+            mcpClients,
+            isDefaultModel,
+            updateBannerVersion: updateAvailableVersion,
+            updateBannerCommands: updateCommands
+          }
+        ), /* @__PURE__ */ React.createElement(ProjectOnboarding, { workspaceDir: getOriginalCwd() }))
+      },
+      ...reorderMessages(normalizedMessages).map((_) => {
+        const toolUseID = getToolUseID(_);
+        const message = _.type === "progress" ? _.content.message.content[0]?.type === "text" && // Hack: TaskTool interrupts use Progress messages, so don't
+        // need an extra ⎿ because <Message /> already adds one.
+        // TODO: Find a cleaner way to do this.
+        _.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,
+            verbose,
+            debug,
+            erroredToolUseIDs,
+            inProgressToolUseIDs,
+            shouldAnimate: !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && (!toolUseID || inProgressToolUseIDs.has(toolUseID)),
+            shouldShowDot: true,
+            unresolvedToolUseIDs
+          }
+        );
+        const type = shouldRenderStatically(
+          _,
+          normalizedMessages,
+          unresolvedToolUseIDs
+        ) ? "static" : "transient";
+        if (debug) {
+          return {
+            type,
+            jsx: /* @__PURE__ */ React.createElement(
+              Box,
+              {
+                borderStyle: "single",
+                borderColor: type === "static" ? "green" : "red",
+                key: _.uuid,
+                width: "100%"
+              },
+              message
+            )
+          };
+        }
+        return {
+          type,
+          jsx: /* @__PURE__ */ React.createElement(Box, { key: _.uuid, width: "100%" }, message)
+        };
+      })
+    ];
+  }, [
+    forkNumber,
+    normalizedMessages,
+    tools,
+    verbose,
+    debug,
+    erroredToolUseIDs,
+    inProgressToolUseIDs,
+    toolJSX,
+    toolUseConfirm,
+    isMessageSelectorVisible,
+    unresolvedToolUseIDs,
+    mcpClients,
+    isDefaultModel
+  ]);
+  const showingCostDialog = !isLoading && showCostDialog;
+  return /* @__PURE__ */ React.createElement(
+    PermissionProvider,
+    {
+      isBypassPermissionsModeAvailable: !safeMode,
+      children: /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(ModeIndicator, null), /* @__PURE__ */ React.createElement(React.Fragment, { key: `static-messages-${forkNumber}` }, /* @__PURE__ */ React.createElement(
+        Static,
+        {
+          items: messagesJSX.filter((_) => _.type === "static"),
+          children: (_) => _.jsx
+        }
+      )), messagesJSX.filter((_) => _.type === "transient").map((_) => _.jsx), /* @__PURE__ */ React.createElement(
+        Box,
+        {
+          borderColor: "red",
+          borderStyle: debug ? "single" : void 0,
+          flexDirection: "column",
+          width: "100%"
+        },
+        !toolJSX && !toolUseConfirm && !binaryFeedbackContext && isLoading && /* @__PURE__ */ React.createElement(Spinner, null),
+        toolJSX ? 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,
+            debug,
+            erroredToolUseIDs,
+            inProgressToolUseIDs,
+            unresolvedToolUseIDs
+          }
+        ),
+        !toolJSX && toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && /* @__PURE__ */ React.createElement(
+          PermissionRequest,
+          {
+            toolUseConfirm,
+            onDone: () => setToolUseConfirm(null),
+            verbose
+          }
+        ),
+        !toolJSX && !toolUseConfirm && !isMessageSelectorVisible && !binaryFeedbackContext && showingCostDialog && /* @__PURE__ */ React.createElement(
+          CostThresholdDialog,
+          {
+            onDone: () => {
+              setShowCostDialog(false);
+              setHaveShownCostDialog(true);
+              const projectConfig = getGlobalConfig();
+              saveGlobalConfig({
+                ...projectConfig,
+                hasAcknowledgedCostThreshold: true
+              });
+              logEvent("tengu_cost_threshold_acknowledged", {});
+            }
+          }
+        ),
+        !toolUseConfirm && !toolJSX?.shouldHidePromptInput && shouldShowPromptInput && !isMessageSelectorVisible && !binaryFeedbackContext && !showingCostDialog && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(
+          PromptInput,
+          {
+            commands,
+            forkNumber,
+            messageLogName,
+            tools,
+            isDisabled: apiKeyStatus === "invalid",
+            isLoading,
+            onQuery,
+            debug,
+            verbose,
+            messages,
+            setToolJSX,
+            onAutoUpdaterResult: setAutoUpdaterResult,
+            autoUpdaterResult,
+            input: inputValue,
+            onInputChange: setInputValue,
+            mode: inputMode,
+            onModeChange: setInputMode,
+            submitCount,
+            onSubmitCountChange: setSubmitCount,
+            setIsLoading,
+            setAbortController,
+            onShowMessageSelector: () => setIsMessageSelectorVisible((prev) => !prev),
+            setForkConvoWithMessagesOnTheNextRender,
+            readFileTimestamps: readFileTimestamps.current,
+            abortController,
+            onModelChange: () => setForkNumber((prev) => prev + 1)
+          }
+        ))
+      ), isMessageSelectorVisible && /* @__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
+        }
+      ), /* @__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