feat: enhance slash command processing and summary generation in mentions

Author: hannesrudolph

src/__tests__/command-mentions.spec.ts

@@ -27,7 +27,7 @@ describe("Command Mentions", () => {
 
 	// Helper function to call parseMentions with required parameters
 	const callParseMentions = async (text: string) => {
-		const result = await parseMentions(
+		return parseMentions(
 			text,
 			"/test/cwd", // cwd
 			mockUrlContentFetcher, // urlContentFetcher
@@ -38,8 +38,6 @@ describe("Command Mentions", () => {
 			50, // maxDiagnosticMessages
 			undefined, // maxReadFileLine
 		)
-		// Return just the text for backward compatibility with existing tests
-		return result.text
 	}
 
 	describe("parseMentions with command support", () => {
@@ -56,10 +54,10 @@ describe("Command Mentions", () => {
 			const result = await callParseMentions(input)
 
 			expect(mockGetCommand).toHaveBeenCalledWith("/test/cwd", "setup")
-			expect(result).toContain('<command name="setup">')
-			expect(result).toContain(commandContent)
-			expect(result).toContain("</command>")
-			expect(result).toContain("Please help me set up the project")
+			expect(result.slashCommandHelp).toContain('<command name="setup">')
+			expect(result.slashCommandHelp).toContain(commandContent)
+			expect(result.slashCommandHelp).toContain("</command>")
+			expect(result.text).toContain("Please help me set up the project")
 		})
 
 		it("should handle multiple commands in message", async () => {
@@ -99,10 +97,10 @@ describe("Command Mentions", () => {
 			expect(mockGetCommand).toHaveBeenCalledWith("/test/cwd", "setup")
 			expect(mockGetCommand).toHaveBeenCalledWith("/test/cwd", "deploy")
 			expect(mockGetCommand).toHaveBeenCalledTimes(2) // Each unique command called once (optimized)
-			expect(result).toContain('<command name="setup">')
-			expect(result).toContain("# Setup Environment")
-			expect(result).toContain('<command name="deploy">')
-			expect(result).toContain("# Deploy Environment")
+			expect(result.slashCommandHelp).toContain('<command name="setup">')
+			expect(result.slashCommandHelp).toContain("# Setup Environment")
+			expect(result.slashCommandHelp).toContain('<command name="deploy">')
+			expect(result.slashCommandHelp).toContain("# Deploy Environment")
 		})
 
 		it("should leave non-existent commands unchanged", async () => {
@@ -114,10 +112,10 @@ describe("Command Mentions", () => {
 
 			expect(mockGetCommand).toHaveBeenCalledWith("/test/cwd", "nonexistent")
 			// The command should remain unchanged in the text
-			expect(result).toBe("/nonexistent command")
+			expect(result.text).toBe("/nonexistent command")
 			// Should not contain any command tags
-			expect(result).not.toContain('<command name="nonexistent">')
-			expect(result).not.toContain("Command 'nonexistent' not found")
+			expect(result.slashCommandHelp).toBeUndefined()
+			expect(result.text).not.toContain("Command 'nonexistent' not found")
 		})
 
 		it("should handle command loading errors during existence check", async () => {
@@ -129,8 +127,8 @@ describe("Command Mentions", () => {
 
 			// When getCommand throws an error during existence check,
 			// the command is treated as non-existent and left unchanged
-			expect(result).toBe("/error-command test")
-			expect(result).not.toContain('<command name="error-command">')
+			expect(result.text).toBe("/error-command test")
+			expect(result.slashCommandHelp).toBeUndefined()
 		})
 
 		it("should handle command loading errors during processing", async () => {
@@ -145,9 +143,9 @@ describe("Command Mentions", () => {
 			const input = "/error-command test"
 			const result = await callParseMentions(input)
 
-			expect(result).toContain('<command name="error-command">')
-			expect(result).toContain("# Error command")
-			expect(result).toContain("</command>")
+			expect(result.slashCommandHelp).toContain('<command name="error-command">')
+			expect(result.slashCommandHelp).toContain("# Error command")
+			expect(result.slashCommandHelp).toContain("</command>")
 		})
 
 		it("should handle command names with hyphens and underscores at start", async () => {
@@ -162,8 +160,8 @@ describe("Command Mentions", () => {
 			const result = await callParseMentions(input)
 
 			expect(mockGetCommand).toHaveBeenCalledWith("/test/cwd", "setup-dev")
-			expect(result).toContain('<command name="setup-dev">')
-			expect(result).toContain("# Dev setup")
+			expect(result.slashCommandHelp).toContain('<command name="setup-dev">')
+			expect(result.slashCommandHelp).toContain("# Dev setup")
 		})
 
 		it("should preserve command content formatting", async () => {
@@ -192,13 +190,13 @@ npm install
 			const input = "/complex command"
 			const result = await callParseMentions(input)
 
-			expect(result).toContain('<command name="complex">')
-			expect(result).toContain("# Complex Command")
-			expect(result).toContain("```bash")
-			expect(result).toContain("npm install")
-			expect(result).toContain("- Check file1.js")
-			expect(result).toContain("> **Note**: This is important!")
-			expect(result).toContain("</command>")
+			expect(result.slashCommandHelp).toContain('<command name="complex">')
+			expect(result.slashCommandHelp).toContain("# Complex Command")
+			expect(result.slashCommandHelp).toContain("```bash")
+			expect(result.slashCommandHelp).toContain("npm install")
+			expect(result.slashCommandHelp).toContain("- Check file1.js")
+			expect(result.slashCommandHelp).toContain("> **Note**: This is important!")
+			expect(result.slashCommandHelp).toContain("</command>")
 		})
 
 		it("should handle empty command content", async () => {
@@ -212,8 +210,8 @@ npm install
 			const input = "/empty command"
 			const result = await callParseMentions(input)
 
-			expect(result).toContain('<command name="empty">')
-			expect(result).toContain("</command>")
+			expect(result.slashCommandHelp).toContain('<command name="empty">')
+			expect(result.slashCommandHelp).toContain("</command>")
 			// Should still include the command tags even with empty content
 		})
 	})
@@ -295,7 +293,7 @@ npm install
 			const input = "/setup the project"
 			const result = await callParseMentions(input)
 
-			expect(result).toContain("Command 'setup' (see below for command content)")
+			expect(result.text).toContain("Command 'setup' (see below for command content)")
 		})
 
 		it("should leave non-existent command mentions unchanged", async () => {
@@ -304,7 +302,7 @@ npm install
 			const input = "/nonexistent the project"
 			const result = await callParseMentions(input)
 
-			expect(result).toBe("/nonexistent the project")
+			expect(result.text).toBe("/nonexistent the project")
 		})
 
 		it("should process multiple commands in message", async () => {
@@ -325,8 +323,8 @@ npm install
 			const input = "/setup the project\nThen /deploy later"
 			const result = await callParseMentions(input)
 
-			expect(result).toContain("Command 'setup' (see below for command content)")
-			expect(result).toContain("Command 'deploy' (see below for command content)")
+			expect(result.text).toContain("Command 'setup' (see below for command content)")
+			expect(result.text).toContain("Command 'deploy' (see below for command content)")
 		})
 
 		it("should match commands anywhere with proper word boundaries", async () => {
@@ -340,22 +338,22 @@ npm install
 			// At the beginning - should match
 			let input = "/build the project"
 			let result = await callParseMentions(input)
-			expect(result).toContain("Command 'build'")
+			expect(result.text).toContain("Command 'build'")
 
 			// After space - should match
 			input = "Please /build and test"
 			result = await callParseMentions(input)
-			expect(result).toContain("Command 'build'")
+			expect(result.text).toContain("Command 'build'")
 
 			// At the end - should match
 			input = "Run the /build"
 			result = await callParseMentions(input)
-			expect(result).toContain("Command 'build'")
+			expect(result.text).toContain("Command 'build'")
 
 			// At start of new line - should match
 			input = "Some text\n/build the project"
 			result = await callParseMentions(input)
-			expect(result).toContain("Command 'build'")
+			expect(result.text).toContain("Command 'build'")
 		})
 	})
 })

src/core/condense/__tests__/condense.spec.ts

@@ -139,6 +139,41 @@ describe("Condense", () => {
 			expect(effectiveHistory[0].role).toBe("user")
 		})
 
+		it("should include slash command content in the summary message", async () => {
+			const messages: ApiMessage[] = [
+				{
+					role: "user",
+					content: [
+						{ type: "text", text: "Some user text" },
+						{ type: "text", text: '<command name="prr">Help content</command>' },
+					],
+				},
+				{ role: "assistant", content: "Second message" },
+				{ role: "user", content: "Third message" },
+				{ role: "assistant", content: "Fourth message" },
+				{ role: "user", content: "Fifth message" },
+				{ role: "assistant", content: "Sixth message" },
+				{ role: "user", content: "Seventh message" },
+				{ role: "assistant", content: "Eighth message" },
+				{ role: "user", content: "Ninth message" },
+			]
+
+			const result = await summarizeConversation(messages, mockApiHandler, "System prompt", taskId, 5000, false)
+
+			const summaryMessage = result.messages.find((msg) => msg.isSummary)
+			const content = summaryMessage!.content as Anthropic.Messages.ContentBlockParam[]
+
+			// Should have: summary text block, slash command block, ...reminders
+			expect(content[0]).toEqual({
+				type: "text",
+				text: expect.stringContaining("Mock summary of the conversation"),
+			})
+			expect(content[1]).toEqual({
+				type: "text",
+				text: '<system-reminder>\n<command name="prr">Help content</command>\n</system-reminder>',
+			})
+		})
+
 		it("should handle complex first message content", async () => {
 			const complexContent: Anthropic.Messages.ContentBlockParam[] = [
 				{ type: "text", text: "/mode code" },

src/core/condense/index.ts

@@ -350,6 +350,23 @@ export async function summarizeConversation(
 		text: `${prefaceParagraph}\n\n${summary}`,
 	}
 
+	// Check if the first message has a slash command block
+	let slashCommandBlock: Anthropic.Messages.ContentBlockParam | undefined
+	if (messages.length > 0) {
+		const firstMessage = messages[0]
+		if (firstMessage.role === "user" && Array.isArray(firstMessage.content)) {
+			const foundBlock = firstMessage.content.find(
+				(block) => block.type === "text" && block.text.includes("<command name="),
+			)
+			if (foundBlock && foundBlock.type === "text") {
+				slashCommandBlock = {
+					type: "text",
+					text: `<system-reminder>\n${foundBlock.text}\n</system-reminder>`,
+				}
+			}
+		}
+	}
+
 	const reminderBlocks: Anthropic.Messages.TextBlockParam[] = reminders.map((msg) => {
 		const tsValue = msg.ts ?? null
 		const rawContentJson = JSON.stringify(msg.content)
@@ -367,10 +384,11 @@ export async function summarizeConversation(
 		})
 	}
 
-	const summaryContent: Anthropic.Messages.ContentBlockParam[] = [summaryTextBlock, ...reminderBlocks].slice(
-		0,
-		1 + N_MESSAGES_TO_KEEP,
-	)
+	const summaryContent: Anthropic.Messages.ContentBlockParam[] = [
+		summaryTextBlock,
+		...(slashCommandBlock ? [slashCommandBlock] : []),
+		...reminderBlocks,
+	]
 
 	// Generate a unique condenseId for this summary
 	const condenseId = crypto.randomUUID()

src/core/mentions/__tests__/processUserContentMentions.spec.ts

@@ -335,4 +335,121 @@ describe("processUserContentMentions", () => {
 			)
 		})
 	})
+
+	describe("slash command content processing", () => {
+		it("should separate slash command content into a new block", async () => {
+			vi.mocked(parseMentions).mockResolvedValueOnce({
+				text: "parsed text",
+				slashCommandHelp: "command help",
+				mode: undefined,
+			})
+
+			const userContent = [
+				{
+					type: "text" as const,
+					text: "<user_message>Run command</user_message>",
+				},
+			]
+
+			const result = await processUserContentMentions({
+				userContent,
+				cwd: "/test",
+				urlContentFetcher: mockUrlContentFetcher,
+				fileContextTracker: mockFileContextTracker,
+			})
+
+			expect(result.content).toHaveLength(2)
+			expect(result.content[0]).toEqual({
+				type: "text",
+				text: "parsed text",
+			})
+			expect(result.content[1]).toEqual({
+				type: "text",
+				text: "command help",
+			})
+		})
+
+		it("should include slash command content in tool_result string content", async () => {
+			vi.mocked(parseMentions).mockResolvedValueOnce({
+				text: "parsed tool output",
+				slashCommandHelp: "command help",
+				mode: undefined,
+			})
+
+			const userContent = [
+				{
+					type: "tool_result" as const,
+					tool_use_id: "123",
+					content: "<user_message>Tool output</user_message>",
+				},
+			]
+
+			const result = await processUserContentMentions({
+				userContent,
+				cwd: "/test",
+				urlContentFetcher: mockUrlContentFetcher,
+				fileContextTracker: mockFileContextTracker,
+			})
+
+			expect(result.content).toHaveLength(1)
+			expect(result.content[0]).toEqual({
+				type: "tool_result",
+				tool_use_id: "123",
+				content: [
+					{
+						type: "text",
+						text: "parsed tool output",
+					},
+					{
+						type: "text",
+						text: "command help",
+					},
+				],
+			})
+		})
+
+		it("should include slash command content in tool_result array content", async () => {
+			vi.mocked(parseMentions).mockResolvedValueOnce({
+				text: "parsed array item",
+				slashCommandHelp: "command help",
+				mode: undefined,
+			})
+
+			const userContent = [
+				{
+					type: "tool_result" as const,
+					tool_use_id: "123",
+					content: [
+						{
+							type: "text" as const,
+							text: "<user_message>Array item</user_message>",
+						},
+					],
+				},
+			]
+
+			const result = await processUserContentMentions({
+				userContent,
+				cwd: "/test",
+				urlContentFetcher: mockUrlContentFetcher,
+				fileContextTracker: mockFileContextTracker,
+			})
+
+			expect(result.content).toHaveLength(1)
+			expect(result.content[0]).toEqual({
+				type: "tool_result",
+				tool_use_id: "123",
+				content: [
+					{
+						type: "text",
+						text: "parsed array item",
+					},
+					{
+						type: "text",
+						text: "command help",
+					},
+				],
+			})
+		})
+	})
 })