@theia/ai-claude-code 1.65.0

package/src/browser/claude-code-edit-tool-service.ts

@@ -0,0 +1,313 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { MutableChatRequestModel } from '@theia/ai-chat';
+import { ChangeSetFileElement, ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
+import { ChangeSetElement } from '@theia/ai-chat/lib/common/change-set';
+import { ContentReplacer, Replacement } from '@theia/core/lib/common/content-replacer';
+import { URI } from '@theia/core/lib/common/uri';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { FileEditBackupService } from './claude-code-file-edit-backup-service';
+
+export interface EditToolInput {
+    file_path: string;
+    old_string: string;
+    new_string: string;
+}
+
+export interface MultiEditToolInput {
+    file_path: string;
+    edits: Array<{
+        old_string: string;
+        new_string: string;
+    }>;
+}
+
+export interface WriteToolInput {
+    file_path: string;
+    content: string;
+}
+
+export interface ToolUseBlock {
+    name: string;
+    input: EditToolInput | MultiEditToolInput | WriteToolInput;
+}
+
+export interface EditToolContext {
+    sessionId: string | undefined;
+    isEditMode: boolean;
+}
+
+export const ClaudeCodeEditToolService = Symbol('ClaudeCodeEditToolService');
+
+/**
+ * Service for handling edit tool operations.
+ *
+ * Invoked by the ClaudeCodeChatAgent on each finished edit tool request.
+ * This can be used to track and manage file edits made by the agent, e.g.
+ * to propagate them to ChangeSets (see ClaudeCodeEditToolServiceImpl below).
+ */
+export interface ClaudeCodeEditToolService {
+    handleEditTool(toolUse: ToolUseBlock, request: MutableChatRequestModel, context: EditToolContext): Promise<void>;
+}
+
+/**
+ * Propagates edit tool results to change sets in the specified request's session.
+ */
+@injectable()
+export class ClaudeCodeEditToolServiceImpl implements ClaudeCodeEditToolService {
+
+    @inject(ChangeSetFileElementFactory)
+    protected readonly fileChangeFactory: ChangeSetFileElementFactory;
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    @inject(FileEditBackupService)
+    protected readonly backupService: FileEditBackupService;
+
+    private readonly contentReplacer = new ContentReplacer();
+
+    async handleEditTool(toolUse: ToolUseBlock, request: MutableChatRequestModel, context: EditToolContext): Promise<void> {
+        try {
+            const { name, input } = toolUse;
+
+            switch (name) {
+                case 'Edit':
+                    await this.handleEditSingle(input as EditToolInput, request, context);
+                    break;
+                case 'MultiEdit':
+                    await this.handleEditMultiple(input as MultiEditToolInput, request, context);
+                    break;
+                case 'Write':
+                    await this.handleWriteFile(input as WriteToolInput, request, context);
+                    break;
+            }
+        } catch (error) {
+            console.error('Error handling edit tool:', error);
+        }
+    }
+
+    protected async handleEditSingle(input: EditToolInput, request: MutableChatRequestModel, context: EditToolContext): Promise<void> {
+        try {
+            const workspaceUri = await this.toWorkspaceUri(input.file_path);
+            const currentContent = await this.fileService.read(workspaceUri);
+            const currentContentString = currentContent.value.toString();
+            const existingChangeSetElement = request.session.changeSet.getElementByURI(workspaceUri);
+
+            const replacement: Replacement = {
+                oldContent: input.old_string,
+                newContent: input.new_string
+            };
+
+            if (context.isEditMode) {
+                await this.handleEditModeCommon(
+                    workspaceUri,
+                    currentContentString,
+                    [replacement],
+                    existingChangeSetElement,
+                    request,
+                    context
+                );
+            } else {
+                await this.handleNonEditModeCommon(
+                    workspaceUri,
+                    currentContentString,
+                    [replacement],
+                    existingChangeSetElement,
+                    request
+                );
+            }
+
+            request.session.changeSet.setTitle('Changes by Claude Code');
+        } catch (error) {
+            console.error('Error handling Edit tool:', error);
+        }
+    }
+
+    protected async handleEditMultiple(input: MultiEditToolInput, request: MutableChatRequestModel, context: EditToolContext): Promise<void> {
+        try {
+            const workspaceUri = await this.toWorkspaceUri(input.file_path);
+            const currentContent = await this.fileService.read(workspaceUri);
+            const currentContentString = currentContent.value.toString();
+            const existingChangeSetElement = request.session.changeSet.getElementByURI(workspaceUri);
+
+            const replacements: Replacement[] = input.edits.map(edit => ({
+                oldContent: edit.old_string,
+                newContent: edit.new_string
+            }));
+
+            if (context.isEditMode) {
+                await this.handleEditModeCommon(
+                    workspaceUri,
+                    currentContentString,
+                    replacements,
+                    existingChangeSetElement,
+                    request,
+                    context
+                );
+            } else {
+                await this.handleNonEditModeCommon(
+                    workspaceUri,
+                    currentContentString,
+                    replacements,
+                    existingChangeSetElement,
+                    request
+                );
+            }
+
+            request.session.changeSet.setTitle('Changes by Claude Code');
+        } catch (error) {
+            console.error('Error handling MultiEdit tool:', error);
+        }
+    }
+
+    protected async handleWriteFile(input: WriteToolInput, request: MutableChatRequestModel, context: EditToolContext): Promise<void> {
+        try {
+            const workspaceUri = await this.toWorkspaceUri(input.file_path);
+            const fileExists = await this.fileService.exists(workspaceUri);
+
+            if (context.isEditMode) {
+                if (input.content === '') {
+                    const originalState = await this.backupService.getOriginal(workspaceUri, context.sessionId);
+                    const fileElement = this.fileChangeFactory({
+                        uri: workspaceUri,
+                        type: 'delete',
+                        state: 'applied',
+                        originalState,
+                        targetState: '',
+                        requestId: request.id,
+                        chatSessionId: request.session.id
+                    });
+
+                    request.session.changeSet.addElements(fileElement);
+                } else {
+                    const type = !fileExists ? 'add' : 'modify';
+                    let originalState = '';
+                    if (type === 'modify') {
+                        originalState = (await this.backupService.getOriginal(workspaceUri, context.sessionId)) ?? '';
+                    }
+
+                    const fileElement = this.fileChangeFactory({
+                        uri: workspaceUri,
+                        type,
+                        state: 'applied',
+                        originalState,
+                        targetState: input.content,
+                        requestId: request.id,
+                        chatSessionId: request.session.id
+                    });
+
+                    request.session.changeSet.addElements(fileElement);
+                }
+            } else {
+                const type = input.content === '' ? 'delete' :
+                    !fileExists ? 'add' : 'modify';
+
+                const fileElement = this.fileChangeFactory({
+                    uri: workspaceUri,
+                    type,
+                    state: 'pending',
+                    targetState: input.content,
+                    requestId: request.id,
+                    chatSessionId: request.session.id
+                });
+
+                request.session.changeSet.addElements(fileElement);
+            }
+
+            request.session.changeSet.setTitle('Changes by Claude Code');
+        } catch (error) {
+            console.error('Error handling Write tool:', error);
+        }
+    }
+
+    protected async handleEditModeCommon(
+        workspaceUri: URI,
+        currentContentString: string,
+        replacements: Replacement[],
+        existingChangeSetElement: ChangeSetElement | undefined,
+        request: MutableChatRequestModel,
+        context: EditToolContext
+    ): Promise<void> {
+        const originalState = await this.backupService.getOriginal(workspaceUri, context.sessionId);
+        const existingReplacements = (existingChangeSetElement instanceof ChangeSetFileElement) && existingChangeSetElement.replacements || [];
+
+        const fileElement = this.fileChangeFactory({
+            uri: workspaceUri,
+            type: 'modify',
+            state: 'applied',
+            originalState,
+            targetState: currentContentString,
+            requestId: request.id,
+            chatSessionId: request.session.id,
+            replacements: [...existingReplacements, ...replacements]
+        });
+
+        request.session.changeSet.addElements(fileElement);
+    }
+
+    protected async handleNonEditModeCommon(
+        workspaceUri: URI,
+        currentContentString: string,
+        replacements: Replacement[],
+        existingChangeSetElement: ChangeSetElement | undefined,
+        request: MutableChatRequestModel
+    ): Promise<void> {
+        const { updatedContent, errors } = this.contentReplacer.applyReplacements(
+            currentContentString,
+            replacements
+        );
+
+        if (errors.length > 0) {
+            console.error('Content replacement errors:', errors);
+            return;
+        }
+
+        if (updatedContent !== currentContentString) {
+            const existingReplacements = (existingChangeSetElement instanceof ChangeSetFileElement) && existingChangeSetElement.replacements || [];
+
+            const fileElement = this.fileChangeFactory({
+                uri: workspaceUri,
+                type: 'modify',
+                state: 'pending',
+                targetState: updatedContent,
+                requestId: request.id,
+                chatSessionId: request.session.id,
+                replacements: [...existingReplacements, ...replacements]
+            });
+
+            request.session.changeSet.addElements(fileElement);
+        }
+    }
+
+    protected async toWorkspaceUri(absolutePath: string): Promise<URI> {
+        const absoluteUri = new URI(absolutePath);
+        const workspaceUri = this.workspaceService.getWorkspaceRootUri(absoluteUri);
+        if (!workspaceUri) {
+            throw new Error(`No workspace found for ${absolutePath}`);
+        }
+
+        const relativeUri = await this.workspaceService.getWorkspaceRelativePath(absoluteUri);
+        return workspaceUri?.resolve(relativeUri);
+    }
+
+}

package/src/browser/claude-code-file-edit-backup-service.ts

@@ -0,0 +1,141 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { MutableChatRequestModel } from '@theia/ai-chat';
+import { ChangeSetFileElement } from '@theia/ai-chat/lib/browser/change-set-file-element';
+import { URI } from '@theia/core/lib/common/uri';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
+import { CLAUDE_SESSION_ID_KEY } from './claude-code-chat-agent';
+
+export const FileEditBackupService = Symbol('FileEditBackupService');
+
+/**
+ * Service for managing file backup operations during Claude Code edit sessions.
+ *
+ * This service handles the retrieval of original file content from backup files
+ * created by the file backup hooks in ClaudeCodeServiceImpl. The backup hooks
+ * run before file modification tools (Write, Edit, MultiEdit) and create backups
+ * in the `.claude/.edit-baks/{session_id}/` directory structure.
+ *
+ * @see packages/ai-claude-code/src/node/claude-code-service-impl.ts#ensureFileBackupHook
+ * The coupling with the backup hooks is intentional - this service reads from
+ * the same backup location that the hooks write to.
+ */
+export interface FileEditBackupService {
+    /**
+     * Retrieves the original content of a file from its backup.
+     *
+     * This method reads from backup files created by the file backup hooks
+     * that are installed by ClaudeCodeServiceImpl.ensureFileBackupHook().
+     *
+     * @param workspaceUri The URI of the file to get backup content for
+     * @param sessionId The Claude session ID used for backup organization
+     * @returns The original file content, or undefined if no backup exists
+     */
+    getOriginal(workspaceUri: URI, sessionId: string | undefined): Promise<string | undefined>;
+
+    /**
+     * Cleans up backup files for a completed chat session.
+     *
+     * This method removes the backup directory structure for the given session
+     * from all workspaces that have change set elements.
+     *
+     * @param request The chat request model containing session and change set information
+     */
+    cleanUp(request: MutableChatRequestModel): Promise<void>;
+
+    /**
+     * Gets the backup location for a workspace root.
+     *
+     * This must match the backup location used by the file backup hooks
+     * in ClaudeCodeServiceImpl.
+     *
+     * @param workspaceRoot The workspace root URI
+     * @returns The backup directory URI
+     */
+    getLocation(workspaceRoot: URI): URI;
+}
+
+@injectable()
+export class FileEditBackupServiceImpl implements FileEditBackupService {
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly workspaceService: WorkspaceService;
+
+    getLocation(workspaceRoot: URI): URI {
+        // This path structure must match the backup hooks in claude-code-service-impl.ts
+        // See ensureFileBackupHook() method which creates backups at:
+        // path.join(hookData.cwd, '.claude', '.edit-baks', hookData.session_id)
+        return workspaceRoot.resolve('.claude').resolve('.edit-baks');
+    }
+
+    async getOriginal(workspaceUri: URI, sessionId: string | undefined): Promise<string | undefined> {
+        if (!sessionId) {
+            return undefined;
+        }
+
+        try {
+            const workspaceRoot = this.workspaceService.getWorkspaceRootUri(workspaceUri);
+            if (!workspaceRoot) {
+                return undefined;
+            }
+
+            const relativePath = await this.workspaceService.getWorkspaceRelativePath(workspaceUri);
+            // This path structure must match the backup hooks in claude-code-service-impl.ts
+            const backupPath = this.getLocation(workspaceRoot).resolve(sessionId).resolve(relativePath);
+
+            if (await this.fileService.exists(backupPath)) {
+                const backupContent = await this.fileService.read(backupPath);
+                return backupContent.value.toString();
+            }
+        } catch (error) {
+            console.error('Error reading backup file:', error);
+        }
+
+        return undefined;
+    }
+
+    async cleanUp(request: MutableChatRequestModel): Promise<void> {
+        const sessionId = request.getDataByKey(CLAUDE_SESSION_ID_KEY) as string | undefined;
+        if (!sessionId) {
+            return;
+        }
+        if (request.session.changeSet.getElements().length < 1) {
+            return;
+        }
+
+        const workspaceUris = new Set<URI>();
+        request.session.changeSet.getElements()
+            .filter((element): element is ChangeSetFileElement => element instanceof ChangeSetFileElement)
+            .map(element => this.workspaceService.getWorkspaceRootUri(element.uri))
+            .filter((element): element is URI => element !== undefined)
+            .forEach(element => workspaceUris.add(element));
+
+        for (const workspaceUri of workspaceUris) {
+            const backupLocation = this.getLocation(workspaceUri).resolve(sessionId);
+            try {
+                await this.fileService.delete(backupLocation, { recursive: true });
+            } catch (error) {
+                // Ignore cleanup errors - not critical
+            }
+        }
+    }
+}

package/src/browser/claude-code-frontend-module.ts

@@ -0,0 +1,100 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { ChatAgent } from '@theia/ai-chat';
+import { ChatResponsePartRenderer } from '@theia/ai-chat-ui/lib/browser/chat-response-part-renderer';
+import { Agent } from '@theia/ai-core';
+import { CommandContribution, PreferenceContribution } from '@theia/core';
+import { FrontendApplicationContribution, RemoteConnectionProvider, ServiceConnectionProvider } from '@theia/core/lib/browser';
+import { ContainerModule } from '@theia/core/shared/inversify';
+import '../../src/browser/style/claude-code-tool-renderers.css';
+import {
+    CLAUDE_CODE_SERVICE_PATH,
+    ClaudeCodeClient,
+    ClaudeCodeService
+} from '../common/claude-code-service';
+import { ClaudeCodePreferencesSchema } from '../common/claude-code-preferences';
+import { ClaudeCodeChatAgent } from './claude-code-chat-agent';
+import { ClaudeCodeEditToolService, ClaudeCodeEditToolServiceImpl } from './claude-code-edit-tool-service';
+import { FileEditBackupService, FileEditBackupServiceImpl } from './claude-code-file-edit-backup-service';
+import { ClaudeCodeClientImpl, ClaudeCodeFrontendService } from './claude-code-frontend-service';
+import { BashToolRenderer } from './renderers/bash-tool-renderer';
+import { EditToolRenderer } from './renderers/edit-tool-renderer';
+import { GlobToolRenderer } from './renderers/glob-tool-renderer';
+import { GrepToolRenderer } from './renderers/grep-tool-renderer';
+import { LSToolRenderer } from './renderers/ls-tool-renderer';
+import { MultiEditToolRenderer } from './renderers/multiedit-tool-renderer';
+import { ReadToolRenderer } from './renderers/read-tool-renderer';
+import { TodoWriteRenderer } from './renderers/todo-write-renderer';
+import { WebFetchToolRenderer } from './renderers/web-fetch-tool-renderer';
+import { WriteToolRenderer } from './renderers/write-tool-renderer';
+import { ClaudeCodeSlashCommandsContribution } from './claude-code-slash-commands-contribution';
+import { ClaudeCodeCommandContribution } from './claude-code-command-contribution';
+
+export default new ContainerModule(bind => {
+    bind(PreferenceContribution).toConstantValue({ schema: ClaudeCodePreferencesSchema });
+    bind(FrontendApplicationContribution).to(ClaudeCodeSlashCommandsContribution).inSingletonScope();
+    bind(CommandContribution).to(ClaudeCodeCommandContribution).inSingletonScope();
+
+    bind(ClaudeCodeFrontendService).toSelf().inSingletonScope();
+    bind(ClaudeCodeClientImpl).toSelf().inSingletonScope();
+    bind(ClaudeCodeClient).toService(ClaudeCodeClientImpl);
+    bind(ClaudeCodeService).toDynamicValue(ctx => {
+        const connection = ctx.container.get<ServiceConnectionProvider>(RemoteConnectionProvider);
+        const backendClient: ClaudeCodeClient = ctx.container.get(ClaudeCodeClient);
+        return connection.createProxy(CLAUDE_CODE_SERVICE_PATH, backendClient);
+    }).inSingletonScope();
+
+    bind(FileEditBackupServiceImpl).toSelf().inSingletonScope();
+    bind(FileEditBackupService).toService(FileEditBackupServiceImpl);
+
+    bind(ClaudeCodeEditToolServiceImpl).toSelf().inSingletonScope();
+    bind(ClaudeCodeEditToolService).toService(ClaudeCodeEditToolServiceImpl);
+
+    bind(ClaudeCodeChatAgent).toSelf().inSingletonScope();
+    bind(Agent).toService(ClaudeCodeChatAgent);
+    bind(ChatAgent).toService(ClaudeCodeChatAgent);
+
+    bind(TodoWriteRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(TodoWriteRenderer);
+
+    bind(ReadToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(ReadToolRenderer);
+
+    bind(BashToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(BashToolRenderer);
+
+    bind(LSToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(LSToolRenderer);
+
+    bind(EditToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(EditToolRenderer);
+
+    bind(GrepToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(GrepToolRenderer);
+
+    bind(GlobToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(GlobToolRenderer);
+
+    bind(WriteToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(WriteToolRenderer);
+
+    bind(MultiEditToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(MultiEditToolRenderer);
+
+    bind(WebFetchToolRenderer).toSelf().inSingletonScope();
+    bind(ChatResponsePartRenderer).toService(WebFetchToolRenderer);
+});