@within-7/minto 0.0.5-dev.1

package/dist/utils/messages.js

@@ -0,0 +1,650 @@
+import { randomUUID } from "crypto";
+import { getCommand, hasCommand } from "../commands.js";
+import { MalformedCommandError } from "./errors.js";
+import { logError } from "./log.js";
+import { resolve } from "path";
+import { last, memoize } from "lodash-es";
+import { NO_CONTENT_MESSAGE } from "../services/claude.js";
+import { setCwd } from "./state.js";
+import { getCwd } from "./state.js";
+import chalk from "chalk";
+import * as React from "react";
+import { StreamingBashOutput } from "../components/StreamingBashOutput.js";
+import { BashTool } from "../tools/BashTool/BashTool.js";
+const INTERRUPT_MESSAGE = "[Request interrupted by user]";
+const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
+const CANCEL_MESSAGE = "The user doesn't want to take this action right now. STOP what you are doing and wait for the user to tell you how to proceed.";
+const REJECT_MESSAGE = "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed.";
+const NO_RESPONSE_REQUESTED = "No response requested.";
+const SYNTHETIC_ASSISTANT_MESSAGES = /* @__PURE__ */ new Set([
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  CANCEL_MESSAGE,
+  REJECT_MESSAGE,
+  NO_RESPONSE_REQUESTED
+]);
+function baseCreateAssistantMessage(content, extra) {
+  return {
+    type: "assistant",
+    costUSD: 0,
+    durationMs: 0,
+    uuid: randomUUID(),
+    message: {
+      id: randomUUID(),
+      model: "<synthetic>",
+      role: "assistant",
+      stop_reason: "stop_sequence",
+      stop_sequence: "",
+      type: "message",
+      usage: {
+        input_tokens: 0,
+        output_tokens: 0,
+        cache_creation_input_tokens: 0,
+        cache_read_input_tokens: 0
+      },
+      content
+    },
+    ...extra
+  };
+}
+function createAssistantMessage(content) {
+  return baseCreateAssistantMessage([
+    {
+      type: "text",
+      text: content === "" ? NO_CONTENT_MESSAGE : content,
+      citations: []
+    }
+  ]);
+}
+function createAssistantAPIErrorMessage(content) {
+  return baseCreateAssistantMessage(
+    [
+      {
+        type: "text",
+        text: content === "" ? NO_CONTENT_MESSAGE : content,
+        citations: []
+      }
+    ],
+    { isApiErrorMessage: true }
+  );
+}
+function createUserMessage(content, toolUseResult) {
+  const m = {
+    type: "user",
+    message: {
+      role: "user",
+      content
+    },
+    uuid: randomUUID(),
+    toolUseResult
+  };
+  return m;
+}
+function createProgressMessage(toolUseID, siblingToolUseIDs, content, normalizedMessages, tools) {
+  return {
+    type: "progress",
+    content,
+    normalizedMessages,
+    siblingToolUseIDs,
+    tools,
+    toolUseID,
+    uuid: randomUUID()
+  };
+}
+function createToolResultStopMessage(toolUseID) {
+  return {
+    type: "tool_result",
+    content: CANCEL_MESSAGE,
+    is_error: true,
+    tool_use_id: toolUseID
+  };
+}
+async function processUserInput(input, mode, setToolJSX, context, pastedImage) {
+  if (mode === "bash") {
+    const userMessage2 = createUserMessage(`<bash-input>${input}</bash-input>`);
+    if (input.startsWith("cd ")) {
+      const oldCwd = getCwd();
+      const newCwd = resolve(oldCwd, input.slice(3));
+      try {
+        await setCwd(newCwd);
+        return [
+          userMessage2,
+          createAssistantMessage(
+            `<bash-stdout>Changed directory to ${chalk.bold(`${newCwd}/`)}</bash-stdout>`
+          )
+        ];
+      } catch (e) {
+        logError(e);
+        return [
+          userMessage2,
+          createAssistantMessage(
+            `<bash-stderr>cwd error: ${e instanceof Error ? e.message : String(e)}</bash-stderr>`
+          )
+        ];
+      }
+    }
+    const validationResult = await BashTool.validateInput({
+      command: input
+    });
+    if (!validationResult.result) {
+      return [userMessage2, createAssistantMessage(validationResult.message)];
+    }
+    const { BackgroundShellManager } = await import("./BackgroundShellManager.js");
+    const shellId = BackgroundShellManager.getInstance().create(
+      input,
+      context.readFileTimestamps ? getCwd() : process.cwd()
+    );
+    let movedToBackground = false;
+    let completed = false;
+    let completionData = null;
+    setToolJSX({
+      jsx: /* @__PURE__ */ React.createElement(
+        StreamingBashOutput,
+        {
+          shellId,
+          command: input,
+          onMoveToBackground: () => {
+            movedToBackground = true;
+            setToolJSX(null);
+          },
+          onComplete: (stdout, stderr, exitCode) => {
+            completed = true;
+            completionData = { stdout, stderr, exitCode };
+            setToolJSX(null);
+          }
+        }
+      ),
+      shouldHidePromptInput: false
+    });
+    await new Promise((resolve2) => {
+      const checkInterval = setInterval(() => {
+        if (movedToBackground || completed) {
+          clearInterval(checkInterval);
+          resolve2();
+        }
+      }, 100);
+    });
+    if (movedToBackground) {
+      return [
+        userMessage2,
+        createAssistantMessage(
+          `<bash-stdout>Command moved to background (shell ID: ${shellId})
+Use Shift+B to view background tasks</bash-stdout>`
+        )
+      ];
+    } else if (completed && completionData) {
+      return [
+        userMessage2,
+        createAssistantMessage(
+          `<bash-stdout>${completionData.stdout}</bash-stdout><bash-stderr>${completionData.stderr}</bash-stderr>`
+        )
+      ];
+    } else {
+      return [
+        userMessage2,
+        createAssistantMessage(
+          `<bash-stderr>Unexpected error in bash execution</bash-stderr>`
+        )
+      ];
+    }
+  } else if (mode === "koding") {
+    const userMessage2 = createUserMessage(
+      `<koding-input>${input}</koding-input>`
+    );
+    userMessage2.options = {
+      ...userMessage2.options,
+      isKodingRequest: true
+    };
+    return [userMessage2];
+  }
+  if (input.startsWith("/")) {
+    const words = input.slice(1).split(" ");
+    let commandName = words[0];
+    if (words.length > 1 && words[1] === "(MCP)") {
+      commandName = commandName + " (MCP)";
+    }
+    if (!commandName) {
+      return [
+        createAssistantMessage("Commands are in the form `/command [args]`")
+      ];
+    }
+    if (!hasCommand(commandName, context.options.commands)) {
+      return [createUserMessage(input)];
+    }
+    const args = input.slice(commandName.length + 2);
+    const newMessages = await getMessagesForSlashCommand(
+      commandName,
+      args,
+      setToolJSX,
+      context
+    );
+    if (newMessages.length === 0) {
+      return [];
+    }
+    if (newMessages.length === 2 && newMessages[0].type === "user" && newMessages[1].type === "assistant" && typeof newMessages[1].message.content === "string" && newMessages[1].message.content.startsWith("Unknown command:")) {
+      return newMessages;
+    }
+    if (newMessages.length === 2) {
+      return newMessages;
+    }
+    return newMessages;
+  }
+  const isKodingRequest = context.options?.isKodingRequest === true;
+  const kodingContextInfo = context.options?.kodingContext;
+  let userMessage;
+  if (pastedImage) {
+    userMessage = createUserMessage([
+      {
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: "image/png",
+          data: pastedImage
+        }
+      },
+      {
+        type: "text",
+        text: isKodingRequest && kodingContextInfo ? `${kodingContextInfo}
+
+${input}` : input
+      }
+    ]);
+  } else {
+    let processedInput = isKodingRequest && kodingContextInfo ? `${kodingContextInfo}
+
+${input}` : input;
+    if (input.includes("!`") || input.includes("@")) {
+      try {
+        const { executeBashCommands } = await import("../services/customCommands.js");
+        if (input.includes("!`")) {
+          processedInput = await executeBashCommands(processedInput);
+        }
+        if (input.includes("@")) {
+          const { processMentions } = await import("../services/mentionProcessor.js");
+          await processMentions(input);
+        }
+      } catch (error) {
+        console.warn("Dynamic content processing failed:", error);
+      }
+    }
+    userMessage = createUserMessage(processedInput);
+  }
+  if (isKodingRequest) {
+    userMessage.options = {
+      ...userMessage.options,
+      isKodingRequest: true
+    };
+  }
+  return [userMessage];
+}
+async function getMessagesForSlashCommand(commandName, args, setToolJSX, context) {
+  try {
+    const command = getCommand(commandName, context.options.commands);
+    switch (command.type) {
+      case "local-jsx": {
+        return new Promise((resolve2) => {
+          command.call((r) => {
+            setToolJSX(null);
+            resolve2([
+              createUserMessage(`<command-name>${command.userFacingName()}</command-name>
+          <command-message>${command.userFacingName()}</command-message>
+          <command-args>${args}</command-args>`),
+              r ? createAssistantMessage(r) : createAssistantMessage(NO_RESPONSE_REQUESTED)
+            ]);
+          }, context).then((jsx) => {
+            setToolJSX({
+              jsx,
+              shouldHidePromptInput: true
+            });
+          });
+        });
+      }
+      case "local": {
+        const userMessage = createUserMessage(`<command-name>${command.userFacingName()}</command-name>
+        <command-message>${command.userFacingName()}</command-message>
+        <command-args>${args}</command-args>`);
+        try {
+          const result = await command.call(args, {
+            ...context,
+            options: {
+              commands: context.options.commands || [],
+              tools: context.options.tools || [],
+              slowAndCapableModel: context.options.slowAndCapableModel || "main"
+            }
+          });
+          return [
+            userMessage,
+            createAssistantMessage(
+              `<local-command-stdout>${result}</local-command-stdout>`
+            )
+          ];
+        } catch (e) {
+          logError(e);
+          return [
+            userMessage,
+            createAssistantMessage(
+              `<local-command-stderr>${String(e)}</local-command-stderr>`
+            )
+          ];
+        }
+      }
+      case "prompt": {
+        const prompt = await command.getPromptForCommand(args);
+        return prompt.map((msg) => {
+          const userMessage = createUserMessage(
+            typeof msg.content === "string" ? msg.content : msg.content.map((block) => block.type === "text" ? block.text : "").join("\n")
+          );
+          userMessage.options = {
+            ...userMessage.options,
+            isCustomCommand: true,
+            commandName: command.userFacingName(),
+            commandArgs: args
+          };
+          return userMessage;
+        });
+      }
+    }
+  } catch (e) {
+    if (e instanceof MalformedCommandError) {
+      return [createAssistantMessage(e.message)];
+    }
+    throw e;
+  }
+}
+function extractTagFromMessage(message, tagName) {
+  if (message.type === "progress") {
+    return null;
+  }
+  if (typeof message.message.content !== "string") {
+    return null;
+  }
+  return extractTag(message.message.content, tagName);
+}
+function extractTag(html, tagName) {
+  if (!html.trim() || !tagName.trim()) {
+    return null;
+  }
+  const escapedTag = tagName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(
+    `<${escapedTag}(?:\\s+[^>]*)?>([\\s\\S]*?)<\\/${escapedTag}>`,
+    // Closing tag
+    "gi"
+  );
+  let match;
+  let depth = 0;
+  let lastIndex = 0;
+  const openingTag = new RegExp(`<${escapedTag}(?:\\s+[^>]*?)?>`, "gi");
+  const closingTag = new RegExp(`<\\/${escapedTag}>`, "gi");
+  while ((match = pattern.exec(html)) !== null) {
+    const content = match[1];
+    const beforeMatch = html.slice(lastIndex, match.index);
+    depth = 0;
+    openingTag.lastIndex = 0;
+    while (openingTag.exec(beforeMatch) !== null) {
+      depth++;
+    }
+    closingTag.lastIndex = 0;
+    while (closingTag.exec(beforeMatch) !== null) {
+      depth--;
+    }
+    if (depth === 0 && content) {
+      return content;
+    }
+    lastIndex = match.index + match[0].length;
+  }
+  return null;
+}
+function isNotEmptyMessage(message) {
+  if (message.type === "progress") {
+    return true;
+  }
+  if (typeof message.message.content === "string") {
+    return message.message.content.trim().length > 0;
+  }
+  if (message.message.content.length === 0) {
+    return false;
+  }
+  if (message.message.content.length > 1) {
+    return true;
+  }
+  if (message.message.content[0].type !== "text") {
+    return true;
+  }
+  return message.message.content[0].text.trim().length > 0 && message.message.content[0].text !== NO_CONTENT_MESSAGE && message.message.content[0].text !== INTERRUPT_MESSAGE_FOR_TOOL_USE;
+}
+function normalizeMessages(messages) {
+  return messages.flatMap((message) => {
+    if (message.type === "progress") {
+      return [message];
+    }
+    if (typeof message.message.content === "string") {
+      return [message];
+    }
+    return message.message.content.map((_) => {
+      switch (message.type) {
+        case "assistant":
+          return {
+            type: "assistant",
+            uuid: randomUUID(),
+            message: {
+              ...message.message,
+              content: [_]
+            },
+            costUSD: message.costUSD / message.message.content.length,
+            durationMs: message.durationMs
+          };
+        case "user":
+          return message;
+      }
+    });
+  });
+}
+function isToolUseRequestMessage(message) {
+  return message.type === "assistant" && "costUSD" in message && // Note: stop_reason === 'tool_use' is unreliable -- it's not always set correctly
+  message.message.content.some((_) => _.type === "tool_use");
+}
+function reorderMessages(messages) {
+  const ms = [];
+  const toolUseMessages = [];
+  for (const message of messages) {
+    if (isToolUseRequestMessage(message)) {
+      toolUseMessages.push(message);
+    }
+    if (message.type === "progress") {
+      const existingProgressMessage = ms.find(
+        (_) => _.type === "progress" && _.toolUseID === message.toolUseID
+      );
+      if (existingProgressMessage) {
+        ms[ms.indexOf(existingProgressMessage)] = message;
+        continue;
+      }
+      const toolUseMessage = toolUseMessages.find(
+        (_) => _.message.content[0]?.id === message.toolUseID
+      );
+      if (toolUseMessage) {
+        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
+        continue;
+      }
+    }
+    if (message.type === "user" && Array.isArray(message.message.content) && message.message.content[0]?.type === "tool_result") {
+      const toolUseID = message.message.content[0]?.tool_use_id;
+      const lastProgressMessage = ms.find(
+        (_) => _.type === "progress" && _.toolUseID === toolUseID
+      );
+      if (lastProgressMessage) {
+        ms.splice(ms.indexOf(lastProgressMessage) + 1, 0, message);
+        continue;
+      }
+      const toolUseMessage = toolUseMessages.find(
+        (_) => _.message.content[0]?.id === toolUseID
+      );
+      if (toolUseMessage) {
+        ms.splice(ms.indexOf(toolUseMessage) + 1, 0, message);
+        continue;
+      }
+    } else {
+      ms.push(message);
+    }
+  }
+  return ms;
+}
+const getToolResultIDs = memoize(
+  (normalizedMessages) => Object.fromEntries(
+    normalizedMessages.flatMap(
+      (_) => _.type === "user" && _.message.content[0]?.type === "tool_result" ? [
+        [
+          _.message.content[0].tool_use_id,
+          _.message.content[0].is_error ?? false
+        ]
+      ] : []
+    )
+  )
+);
+function getUnresolvedToolUseIDs(normalizedMessages) {
+  const toolResults = getToolResultIDs(normalizedMessages);
+  return new Set(
+    normalizedMessages.filter(
+      (_) => _.type === "assistant" && Array.isArray(_.message.content) && _.message.content[0]?.type === "tool_use" && !(_.message.content[0]?.id in toolResults)
+    ).map((_) => _.message.content[0].id)
+  );
+}
+function getInProgressToolUseIDs(normalizedMessages) {
+  const unresolvedToolUseIDs = getUnresolvedToolUseIDs(normalizedMessages);
+  const toolUseIDsThatHaveProgressMessages = new Set(
+    normalizedMessages.filter((_) => _.type === "progress").map((_) => _.toolUseID)
+  );
+  return new Set(
+    normalizedMessages.filter((_) => {
+      if (_.type !== "assistant") {
+        return false;
+      }
+      if (_.message.content[0]?.type !== "tool_use") {
+        return false;
+      }
+      const toolUseID = _.message.content[0].id;
+      if (toolUseID === unresolvedToolUseIDs.values().next().value) {
+        return true;
+      }
+      if (toolUseIDsThatHaveProgressMessages.has(toolUseID) && unresolvedToolUseIDs.has(toolUseID)) {
+        return true;
+      }
+      return false;
+    }).map((_) => _.message.content[0].id)
+  );
+}
+function getErroredToolUseMessages(normalizedMessages) {
+  const toolResults = getToolResultIDs(normalizedMessages);
+  return normalizedMessages.filter(
+    (_) => _.type === "assistant" && Array.isArray(_.message.content) && _.message.content[0]?.type === "tool_use" && _.message.content[0]?.id in toolResults && toolResults[_.message.content[0]?.id]
+  );
+}
+function normalizeMessagesForAPI(messages) {
+  const result = [];
+  messages.filter((_) => _.type !== "progress").forEach((message) => {
+    switch (message.type) {
+      case "user": {
+        if (!Array.isArray(message.message.content) || message.message.content[0]?.type !== "tool_result") {
+          result.push(message);
+          return;
+        }
+        const lastMessage = last(result);
+        if (!lastMessage || lastMessage?.type === "assistant" || !Array.isArray(lastMessage.message.content) || lastMessage.message.content[0]?.type !== "tool_result") {
+          result.push(message);
+          return;
+        }
+        result[result.indexOf(lastMessage)] = {
+          ...lastMessage,
+          message: {
+            ...lastMessage.message,
+            content: [
+              ...lastMessage.message.content,
+              ...message.message.content
+            ]
+          }
+        };
+        return;
+      }
+      case "assistant":
+        result.push(message);
+        return;
+    }
+  });
+  return result;
+}
+function normalizeContentFromAPI(content) {
+  const filteredContent = content.filter(
+    (_) => _.type !== "text" || _.text.trim().length > 0
+  );
+  if (filteredContent.length === 0) {
+    return [{ type: "text", text: NO_CONTENT_MESSAGE, citations: [] }];
+  }
+  return filteredContent;
+}
+function isEmptyMessageText(text) {
+  return stripSystemMessages(text).trim() === "" || text.trim() === NO_CONTENT_MESSAGE;
+}
+const STRIPPED_TAGS = [
+  "commit_analysis",
+  "context",
+  "function_analysis",
+  "pr_analysis"
+];
+function stripSystemMessages(content) {
+  const regex = new RegExp(`<(${STRIPPED_TAGS.join("|")})>.*?</\\1>
+?`, "gs");
+  return content.replace(regex, "").trim();
+}
+function getToolUseID(message) {
+  switch (message.type) {
+    case "assistant":
+      if (message.message.content[0]?.type !== "tool_use") {
+        return null;
+      }
+      return message.message.content[0].id;
+    case "user":
+      if (message.message.content[0]?.type !== "tool_result") {
+        return null;
+      }
+      return message.message.content[0].tool_use_id;
+    case "progress":
+      return message.toolUseID;
+  }
+}
+function getLastAssistantMessageId(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message && message.type === "assistant") {
+      return message.message.id;
+    }
+  }
+  return void 0;
+}
+export {
+  CANCEL_MESSAGE,
+  INTERRUPT_MESSAGE,
+  INTERRUPT_MESSAGE_FOR_TOOL_USE,
+  NO_RESPONSE_REQUESTED,
+  REJECT_MESSAGE,
+  SYNTHETIC_ASSISTANT_MESSAGES,
+  createAssistantAPIErrorMessage,
+  createAssistantMessage,
+  createProgressMessage,
+  createToolResultStopMessage,
+  createUserMessage,
+  extractTag,
+  extractTagFromMessage,
+  getErroredToolUseMessages,
+  getInProgressToolUseIDs,
+  getLastAssistantMessageId,
+  getToolUseID,
+  getUnresolvedToolUseIDs,
+  isEmptyMessageText,
+  isNotEmptyMessage,
+  normalizeContentFromAPI,
+  normalizeMessages,
+  normalizeMessagesForAPI,
+  processUserInput,
+  reorderMessages,
+  stripSystemMessages
+};
+//# sourceMappingURL=messages.js.map