Implement claude code slash commands (#1181)

Author: roblourens

.github/copilot-instructions.md

@@ -257,6 +257,8 @@ function f(x: number, y: string): void { }
 - Do not introduce new `types` or `values` to the global namespace
 - Use proper types. Do not use `any` unless absolutely necessary.
 - Use `readonly` whenever possible.
+- Avoid casts in TypeScript unless absolutely necessary. If you get type errors after your changes, look up the types of the variables involved and set up a proper system of types and interfaces instead of adding type casts.
+- Do not use `any` or `unknown` as the type for variables, parameters, or return values unless absolutely necessary. If they need type annotations, they should have proper types or interfaces defined.
 
 ## Key APIs and Integrations
 

package.json

@@ -3999,7 +3999,29 @@
 				"capabilities": {
 					"supportsFileAttachments": true,
 					"supportsToolAttachments": false
-				}
+				},
+				"commands": [
+					{
+						"name": "init",
+						"description": "Initialize a new CLAUDE.md file with codebase documentation"
+					},
+					{
+						"name": "compact",
+						"description": "Clear conversation history but keep a summary in context. Optional: /compact [instructions for summarization]"
+					},
+					{
+						"name": "pr-comments",
+						"description": "Get comments from a GitHub pull request"
+					},
+					{
+						"name": "review",
+						"description": "Review a pull request"
+					},
+					{
+						"name": "security-review",
+						"description": "Complete a security review of the pending changes on the current branch"
+					}
+				]
 			}
 		],
 		"debuggers": [
@@ -4211,4 +4233,4 @@
 		"string_decoder": "npm:string_decoder@1.2.0",
 		"node-gyp": "npm:node-gyp@10.3.1"
 	}
-}
+}

src/extension/agents/claude/node/claudeCodeSessionService.ts

@@ -12,15 +12,16 @@ import { FileType } from '../../../../platform/filesystem/common/fileTypes';
 import { ILogService } from '../../../../platform/log/common/logService';
 import { IWorkspaceService } from '../../../../platform/workspace/common/workspaceService';
 import { createServiceIdentifier } from '../../../../util/common/services';
+import { CancellationError } from '../../../../util/vs/base/common/errors';
 import { ResourceMap, ResourceSet } from '../../../../util/vs/base/common/map';
 import { isEqualOrParent } from '../../../../util/vs/base/common/resources';
 import { URI } from '../../../../util/vs/base/common/uri';
-import { CancellationError } from '../../../../util/vs/base/common/errors';
 
 type RawStoredSDKMessage = SDKMessage & {
 	readonly parentUuid: string | null;
 	readonly sessionId: string;
 	readonly timestamp: string;
+	readonly isMeta?: boolean;
 }
 interface SummaryEntry {
 	readonly type: 'summary';
@@ -35,8 +36,16 @@ type StoredSDKMessage = SDKMessage & {
 	readonly timestamp: Date;
 }
 
+interface ParsedSessionMessage {
+	readonly raw: RawStoredSDKMessage;
+	readonly isMeta: boolean;
+}
+
 export const IClaudeCodeSessionService = createServiceIdentifier<IClaudeCodeSessionService>('IClaudeCodeSessionService');
 
+/**
+ * Service to load and manage Claude Code chat sessions from disk.
+ */
 export interface IClaudeCodeSessionService {
 	readonly _serviceBrand: undefined;
 	getAllSessions(token: CancellationToken): Promise<readonly IClaudeCodeSession[]>;
@@ -290,7 +299,6 @@ export class ClaudeCodeSessionService implements IClaudeCodeSessionService {
 	}
 
 	private async _getMessagesFromSession(fileUri: URI, token: CancellationToken): Promise<{ messages: Map<string, StoredSDKMessage>; summaries: Map<string, SummaryEntry> }> {
-		const messages = new Map<string, StoredSDKMessage>();
 		const summaries = new Map<string, SummaryEntry>();
 		try {
 			// Read and parse the JSONL file
@@ -303,18 +311,30 @@ export class ClaudeCodeSessionService implements IClaudeCodeSessionService {
 
 			// Parse JSONL content line by line
 			const lines = text.trim().split('\n').filter(line => line.trim());
+			const rawMessages = new Map<string, ParsedSessionMessage>();
 
 			// Parse each line and build message map
 			for (const line of lines) {
 				try {
 					const entry = JSON.parse(line) as ClaudeSessionFileEntry;
 
 					if ('uuid' in entry && entry.uuid && 'message' in entry) {
-						const sdkMessage = this._reviveStoredSDKMessage(entry as RawStoredSDKMessage);
-						const uuid = sdkMessage.uuid;
-						if (uuid) {
-							messages.set(uuid, sdkMessage);
+						const rawEntry = entry;
+						const uuid = rawEntry.uuid;
+						if (!uuid) {
+							continue;
 						}
+
+						const { isMeta, ...rest } = rawEntry;
+						const normalizedRaw = {
+							...rest,
+							parentUuid: rawEntry.parentUuid ?? null
+						} as RawStoredSDKMessage;
+
+						rawMessages.set(uuid, {
+							raw: normalizedRaw,
+							isMeta: Boolean(isMeta)
+						});
 					} else if ('summary' in entry && entry.summary && !entry.summary.toLowerCase().startsWith('api error: 401') && !entry.summary.toLowerCase().startsWith('invalid api key')) {
 						const summaryEntry = entry as SummaryEntry;
 						const uuid = summaryEntry.leafUuid;
@@ -326,6 +346,8 @@ export class ClaudeCodeSessionService implements IClaudeCodeSessionService {
 					this._logService.warn(`Failed to parse line in ${fileUri}: ${line} - ${parseError}`);
 				}
 			}
+
+			const messages = this._reviveStoredMessages(rawMessages);
 			return { messages, summaries };
 		} catch (e) {
 			this._logService.error(e, `[ClaudeChatSessionItemProvider] Failed to load session: ${fileUri}`);
@@ -380,22 +402,100 @@ export class ClaudeCodeSessionService implements IClaudeCodeSessionService {
 		return text.replace(/<system-reminder>[\s\S]*?<\/system-reminder>\s*/g, '').trim();
 	}
 
+	private _normalizeCommandContent(text: string): string {
+		const parsed = this._extractCommandContent(text);
+		if (parsed !== null) {
+			return parsed;
+		}
+		return this._removeCommandTags(text);
+	}
+
+	private _extractCommandContent(text: string): string | null {
+		const commandMessageMatch = /<command-message>([\s\S]*?)<\/command-message>/i.exec(text);
+		if (!commandMessageMatch) {
+			return null;
+		}
+
+		const commandMessage = commandMessageMatch[1]?.trim();
+		return commandMessage ? `/${commandMessage}` : null;
+	}
+
+	private _removeCommandTags(text: string): string {
+		return text
+			.replace(/<command-message>/gi, '')
+			.replace(/<\/command-message>/gi, '')
+			.replace(/<command-name>/gi, '')
+			.replace(/<\/command-name>/gi, '')
+			.trim();
+	}
+
+	private _reviveStoredMessages(rawMessages: Map<string, ParsedSessionMessage>): Map<string, StoredSDKMessage> {
+		const messages = new Map<string, StoredSDKMessage>();
+
+		for (const [uuid, entry] of rawMessages) {
+			if (entry.isMeta) {
+				continue;
+			}
+
+			const parentUuid = this._resolveParentUuid(entry.raw.parentUuid ?? null, rawMessages);
+			const revived = this._reviveStoredSDKMessage({
+				...entry.raw,
+				parentUuid
+			});
+
+			if (uuid) {
+				messages.set(uuid, revived);
+			}
+		}
+
+		return messages;
+	}
+
+	private _resolveParentUuid(parentUuid: string | null, rawMessages: Map<string, ParsedSessionMessage>): string | null {
+		let current = parentUuid;
+		const visited = new Set<string>();
+
+		while (current) {
+			if (visited.has(current)) {
+				return current;
+			}
+			visited.add(current);
+
+			const candidate = rawMessages.get(current);
+			if (!candidate) {
+				return current;
+			}
+
+			if (!candidate.isMeta) {
+				return current;
+			}
+
+			current = candidate.raw.parentUuid ?? null;
+		}
+
+		return current ?? null;
+	}
+
 	/**
 	 * Strip attachments from message content, handling both string and array formats
 	 */
 	private _stripAttachmentsFromMessageContent(content: Anthropic.MessageParam['content']): string | Anthropic.ContentBlockParam[] {
 		if (typeof content === 'string') {
-			return this._stripAttachments(content);
+			const withoutAttachments = this._stripAttachments(content);
+			return this._normalizeCommandContent(withoutAttachments);
 		} else if (Array.isArray(content)) {
-			return content.map(block => {
+			const processedBlocks = content.map(block => {
 				if (block.type === 'text') {
+					const textBlock = block;
+					const cleanedText = this._normalizeCommandContent(this._stripAttachments(textBlock.text));
 					return {
 						...block,
-						text: this._stripAttachments((block as Anthropic.TextBlockParam).text)
+						text: cleanedText
 					};
 				}
 				return block;
-			});
+			}).filter(block => block.type !== 'text' || block.text.trim().length > 0);
+			return processedBlocks;
 		}
 		return content;
 	}

src/extension/agents/claude/node/test/claudeCodeSessionService.spec.ts

@@ -19,6 +19,7 @@ import { URI } from '../../../../../util/vs/base/common/uri';
 import { IInstantiationService } from '../../../../../util/vs/platform/instantiation/common/instantiation';
 import { createExtensionUnitTestingServices } from '../../../../test/node/services';
 import { ClaudeCodeSessionService } from '../claudeCodeSessionService';
+import { SDKUserMessage } from '@anthropic-ai/claude-code';
 
 function computeFolderSlug(folderUri: URI): string {
 	return folderUri.path.replace(/\//g, '-');
@@ -122,6 +123,37 @@ describe('ClaudeCodeSessionService', () => {
 		`);
 	});
 
+	it('filters meta user messages and normalizes command content', async () => {
+		const fileName = '30530d66-37fb-4f3b-aa5f-d92b6a8afae2.jsonl';
+		const fixturePath = path.resolve(__dirname, 'fixtures', fileName);
+		const fileContents = await readFile(fixturePath, 'utf8');
+
+		mockFs.mockDirectory(dirUri, [[fileName, FileType.File]]);
+		mockFs.mockFile(URI.joinPath(dirUri, fileName), fileContents, 1000);
+
+		const sessions = await service.getAllSessions(CancellationToken.None);
+
+		expect(sessions).toHaveLength(1);
+
+		const session = sessions[0];
+		const metaUuid = 'e7f4ab9f-8e19-4262-a430-18d3e48b0c6c';
+
+		expect(session.messages.some(message => message.uuid === metaUuid)).toBe(false);
+
+		const commandUuid = 'a867fb32-ba62-4d51-917c-0fe40fa36067';
+		const commandMessage = session.messages.find((message): message is SDKUserMessage => message.uuid === commandUuid && message.type === 'user');
+		expect(commandMessage).toBeDefined();
+		if (!commandMessage) {
+			return;
+		}
+
+		const commandContent = commandMessage.message.content;
+		expect(typeof commandContent === 'string' ? commandContent : null).toBe('/init is analyzing your codebase…');
+		const assistantUuid = '6ed016f4-0df4-4a9f-8c3b-82303b68d29e';
+		const assistantMessage = session.messages.find(message => message.uuid === assistantUuid);
+		expect((assistantMessage as { readonly parentUuid?: string | null } | undefined)?.parentUuid).toBe(commandUuid);
+	});
+
 	it('handles empty directory correctly', async () => {
 		mockFs.mockDirectory(dirUri, []);