Fix slash command triggering and prompt body exclusions

core/commands/index.ts

@@ -1,74 +1,41 @@
 import { CustomCommand, SlashCommand, SlashCommandDescription } from "../";
 import { renderTemplatedString } from "../promptFiles/v1/renderTemplatedString";
+import { replaceSlashCommandWithPromptInChatHistory } from "../promptFiles/v1/updateChatHistory";
 import { renderChatMessage } from "../util/messageContent";
 
 import SlashCommands from "./slash";
 
 export function slashFromCustomCommand(
   customCommand: CustomCommand,
 ): SlashCommand {
+  const commandName = customCommand.name.startsWith("/")
+    ? customCommand.name.substring(1)
+    : customCommand.name;
   return {
-    name: customCommand.name,
+    name: commandName,
     description: customCommand.description ?? "",
     prompt: customCommand.prompt,
     run: async function* ({ input, llm, history, ide, completionOptions }) {
-      // Remove slash command prefix from input
-      let userInput = input;
-      if (userInput.startsWith(`/${customCommand.name}`)) {
-        userInput = userInput
-          .slice(customCommand.name.length + 1, userInput.length)
-          .trimStart();
-      }
-
       // Render prompt template
-      let promptUserInput: string;
+      let renderedPrompt: string;
       if (customCommand.prompt.includes("{{{ input }}}")) {
-        promptUserInput = await renderTemplatedString(
+        renderedPrompt = await renderTemplatedString(
           customCommand.prompt,
           ide.readFile.bind(ide),
-          { input: userInput },
+          { input },
         );
       } else {
-        promptUserInput = customCommand.prompt + "\n\n" + userInput;
+        renderedPrompt = customCommand.prompt + "\n\n" + input;
       }
 
-      const messages = [...history];
-      // Find the last chat message with this slash command and replace it with the user input
-      for (let i = messages.length - 1; i >= 0; i--) {
-        const message = messages[i];
-        const { role, content } = message;
-        if (role !== "user") {
-          continue;
-        }
-
-        if (
-          Array.isArray(content) &&
-          content.some(
-            (part) =>
-              "text" in part && part.text?.startsWith(`/${customCommand.name}`),
-          )
-        ) {
-          messages[i] = {
-            ...message,
-            content: content.map((part) => {
-              if (
-                "text" in part &&
-                part.text.startsWith(`/${customCommand.name}`)
-              ) {
-                return { type: "text", text: promptUserInput };
-              }
-              return part;
-            }),
-          };
-          break;
-        } else if (
-          typeof content === "string" &&
-          content.startsWith(`/${customCommand.name}`)
-        ) {
-          messages[i] = { ...message, content: promptUserInput };
-          break;
-        }
-      }
+      // Replaces slash command messages with the rendered prompt
+      // which INCLUDES the input
+      const messages = replaceSlashCommandWithPromptInChatHistory(
+        history,
+        commandName,
+        renderedPrompt,
+        undefined,
+      );
 
       for await (const chunk of llm.streamChat(
         messages,

core/promptFiles/v1/slashCommandFromPromptFile.ts

@@ -5,7 +5,7 @@ import { parsePromptFileV1V2 } from "../v2/parsePromptFileV1V2";
 
 import { getContextProviderHelpers } from "./getContextProviderHelpers";
 import { renderTemplatedString } from "./renderTemplatedString";
-import { updateChatHistory } from "./updateChatHistory";
+import { replaceSlashCommandWithPromptInChatHistory } from "./updateChatHistory";
 
 export function extractName(preamble: { name?: string }, path: string): string {
   return preamble.name ?? getLastNPathParts(path, 1).split(".prompt")[0];
@@ -68,7 +68,7 @@ export function slashCommandFromPromptFileV1(
 
       const userInput = extractUserInput(context.input, name);
       const renderedPrompt = await renderPromptV1(prompt, context, userInput);
-      const messages = updateChatHistory(
+      const messages = replaceSlashCommandWithPromptInChatHistory(
         context.history,
         name,
         renderedPrompt,

core/promptFiles/v1/updateChatHistory.ts

@@ -1,4 +1,4 @@
-export function updateChatHistory(
+export function replaceSlashCommandWithPromptInChatHistory(
   history: any[],
   commandName: string,
   renderedPrompt: string,

gui/src/components/mainInput/tiptap/editorConfig.ts

@@ -30,7 +30,6 @@ import { getFontSize } from "../../../util";
 import { AddCodeToEdit } from "./extensions/AddCodeToEditExtension";
 import { CodeBlockExtension } from "./extensions/CodeBlockExtension";
 import { SlashCommand } from "./extensions/CommandsExtension";
-import { MockExtension } from "./extensions/FillerExtension";
 import { Mention } from "./extensions/MentionExtension";
 import {
   getContextProviderDropdownOptions,
@@ -352,22 +351,20 @@ export function createEditorConfig(options: {
           },
         },
       }),
-      props.availableSlashCommands.length
-        ? SlashCommand.configure({
-            HTMLAttributes: {
-              class: "mention",
-            },
-            suggestion: getSlashCommandDropdownOptions(
-              availableSlashCommandsRef,
-              onClose,
-              onOpen,
-              ideMessenger,
-            ),
-            renderText: (props) => {
-              return props.node.attrs.label;
-            },
-          })
-        : MockExtension,
+      SlashCommand.configure({
+        HTMLAttributes: {
+          class: "mention",
+        },
+        suggestion: getSlashCommandDropdownOptions(
+          availableSlashCommandsRef,
+          onClose,
+          onOpen,
+          ideMessenger,
+        ),
+        renderText: (props) => {
+          return props.node.attrs.label;
+        },
+      }),
       CodeBlockExtension,
     ],
     editorProps: {

gui/src/components/mainInput/tiptap/getSuggestion.ts

@@ -203,7 +203,7 @@ export function getSlashCommandDropdownOptions(
     const filteredCommands =
       query.length > 0
         ? options.filter((slashCommand) => {
-            const sc = slashCommand.title.substring(1).toLowerCase();
+            const sc = slashCommand.title.toLowerCase();
             const iv = query.toLowerCase();
             return sc.startsWith(iv);
           })
@@ -219,7 +219,7 @@ export function getSlashCommandDropdownOptions(
       action: provider.action,
     }));
 
-    if (query.length === 0 && commandItems.length > 0) {
+    if (query.length === 0 && commandItems.length === 0) {
       commandItems.push({
         title: "Explore prompts",
         type: "action",

gui/src/components/mainInput/tiptap/resolveInput.ts

@@ -7,10 +7,11 @@ import {
   MessageContent,
   MessagePart,
   RangeInFile,
+  SlashCommandDescription,
   TextMessagePart,
 } from "core";
 import { ctxItemToRifWithContents } from "core/commands/util";
-import { stripImages } from "core/util/messageContent";
+import { renderChatMessage, stripImages } from "core/util/messageContent";
 import { getUriFileExtension } from "core/util/uri";
 import { IIdeMessenger } from "../../../context/IdeMessenger";
 import { setIsGatheringContext } from "../../../redux/slices/sessionSlice";
@@ -27,6 +28,7 @@ interface ResolveEditorContentInput {
   modifiers: InputModifiers;
   ideMessenger: IIdeMessenger;
   defaultContextProviders: DefaultContextProvider[];
+  availableSlashCommands: SlashCommandDescription[];
   selectedModelTitle: string;
   dispatch: Dispatch;
 }
@@ -40,22 +42,37 @@ async function resolveEditorContent({
   modifiers,
   ideMessenger,
   defaultContextProviders,
+  availableSlashCommands,
   selectedModelTitle,
   dispatch,
 }: ResolveEditorContentInput): Promise<
-  [ContextItemWithId[], RangeInFile[], MessageContent]
+  [
+    ContextItemWithId[],
+    RangeInFile[],
+    MessageContent,
+    (
+      | {
+          command: SlashCommandDescription;
+          input: string;
+        }
+      | undefined
+    ),
+  ]
 > {
   let parts: MessagePart[] = [];
   let contextItemAttrs: MentionAttrs[] = [];
   const selectedCode: RangeInFile[] = [];
-  let slashCommand: string | undefined = undefined;
+  let slashCommandName: string | undefined = undefined;
+  let slashCommandWithInput:
+    | { command: SlashCommandDescription; input: string }
+    | undefined = undefined;
   if (editorState?.content) {
     for (const p of editorState.content) {
       if (p.type === "paragraph") {
         const [text, ctxItems, foundSlashCommand] = resolveParagraph(p);
-        // Only take the first slash command\
-        if (foundSlashCommand && typeof slashCommand === "undefined") {
-          slashCommand = foundSlashCommand;
+        // Only take the first slash command
+        if (foundSlashCommand && typeof slashCommandName === "undefined") {
+          slashCommandName = foundSlashCommand;
         }
 
         contextItemAttrs.push(...ctxItems);
@@ -113,7 +130,38 @@ async function resolveEditorContent({
     }
   }
 
-  const shouldGatherContext = modifiers.useCodebase || slashCommand;
+  if (slashCommandName) {
+    const command = availableSlashCommands.find(
+      (c) => c.name === slashCommandName,
+    );
+    if (command) {
+      const lastTextIndex = findLastIndex(
+        parts,
+        (part) => part.type === "text",
+      );
+      const lastTextPart = parts[lastTextIndex] as TextMessagePart;
+
+      let input: string;
+      // Get input and add text of last slash command text back in to last text node
+      if (lastTextPart) {
+        input = renderChatMessage({
+          role: "user",
+          content: lastTextPart.text,
+        }).trimStart();
+        lastTextPart.text = `/${command.name} ${lastTextPart.text}`;
+      } else {
+        input = "";
+        parts.push({ type: "text", text: `/${command.name}` });
+      }
+
+      slashCommandWithInput = {
+        command,
+        input,
+      };
+    }
+  }
+
+  const shouldGatherContext = modifiers.useCodebase || slashCommandWithInput;
   if (shouldGatherContext) {
     dispatch(setIsGatheringContext(true));
   }
@@ -179,21 +227,11 @@ async function resolveEditorContent({
     contextItemsText += "\n";
   }
 
-  if (slashCommand) {
-    let lastTextIndex = findLastIndex(parts, (part) => part.type === "text");
-    const lastTextPart = parts[lastTextIndex] as TextMessagePart;
-    const lastPart = `${slashCommand} ${lastTextPart?.text || ""}`;
-    if (parts.length > 0) {
-      lastTextPart.text = lastPart;
-    } else {
-      parts = [{ type: "text", text: lastPart }];
-    }
-  }
   if (shouldGatherContext) {
     dispatch(setIsGatheringContext(false));
   }
 
-  return [contextItems, selectedCode, parts];
+  return [contextItems, selectedCode, parts, slashCommandWithInput];
 }
 
 function findLastIndex<T>(
@@ -236,30 +274,4 @@ function resolveParagraph(
   return [text, contextItems, slashCommand];
 }
 
-export function hasSlashCommandOrContextProvider(
-  editorState: JSONContent,
-): boolean {
-  if (!editorState?.content) {
-    return false;
-  }
-
-  for (const p of editorState.content) {
-    if (p.type === "paragraph" && p.content) {
-      for (const child of p.content) {
-        if (child.type === "slashcommand") {
-          return true;
-        }
-        if (
-          child.type === "mention" &&
-          child.attrs?.itemType === "contextProvider"
-        ) {
-          return true;
-        }
-      }
-    }
-  }
-
-  return false;
-}
-
 export default resolveEditorContent;

gui/src/pages/gui/Chat.tsx

@@ -235,14 +235,16 @@ export function Chat() {
       console.error("No selected chat model");
       return;
     }
-    const [contextItems, __, userInstructions] = await resolveEditorContent({
+
+    const [contextItems, __, userInstructions, _] = await resolveEditorContent({
       editorState,
       modifiers: {
         noContext: true,
         useCodebase: false,
       },
       ideMessenger,
       defaultContextProviders: [],
+      availableSlashCommands: [],
       dispatch,
       selectedModelTitle: defaultModel.title,
     });

gui/src/redux/selectors/index.ts

@@ -8,7 +8,7 @@ export const selectSlashCommandComboBoxInputs = createSelector(
     return (
       slashCommands?.map((cmd) => {
         return {
-          title: `${cmd.name}`,
+          title: cmd.name,
           description: cmd.description,
           type: "slashCommand" as ComboBoxItemType,
         };