@theia/ai-chat 1.63.0-next.52 → 1.63.1

package/src/browser/change-set-file-element.ts

@@ -14,16 +14,29 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { DisposableCollection, Emitter, URI } from '@theia/core';
-import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { Replacement } from '@theia/core/lib/common/content-replacer';
 import { ConfigurableInMemoryResources, ConfigurableMutableReferenceResource } from '@theia/ai-core';
+import { CancellationToken, DisposableCollection, Emitter, URI } from '@theia/core';
+import { ConfirmDialog } from '@theia/core/lib/browser';
+import { Replacement } from '@theia/core/lib/common/content-replacer';
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { EditorPreferences } from '@theia/editor/lib/browser';
+import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { IReference } from '@theia/monaco-editor-core/esm/vs/base/common/lifecycle';
+import { TrimTrailingWhitespaceCommand } from '@theia/monaco-editor-core/esm/vs/editor/common/commands/trimTrailingWhitespaceCommand';
+import { Selection } from '@theia/monaco-editor-core/esm/vs/editor/common/core/selection';
+import { CommandExecutor } from '@theia/monaco-editor-core/esm/vs/editor/common/cursor/cursor';
+import { formatDocumentWithSelectedProvider, FormattingMode } from '@theia/monaco-editor-core/esm/vs/editor/contrib/format/browser/format';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+import { MonacoTextModelService } from '@theia/monaco/lib/browser/monaco-text-model-service';
+import { insertFinalNewline } from '@theia/monaco/lib/browser/monaco-utilities';
+import { MonacoEditorModel } from '@theia/monaco/lib/browser/monaco-editor-model';
 import { ChangeSetElement } from '../common';
 import { createChangeSetFileUri } from './change-set-file-resource';
 import { ChangeSetFileService } from './change-set-file-service';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
-import { ConfirmDialog } from '@theia/core/lib/browser';
-import { ChangeSetDecoratorService } from './change-set-decorator-service';
+import { Deferred } from '@theia/core/lib/common/promise-util';
+import { MonacoCodeActionService } from '@theia/monaco/lib/browser';
 
 export const ChangeSetFileElementFactory = Symbol('ChangeSetFileElementFactory');
 export type ChangeSetFileElementFactory = (elementProps: ChangeSetElementArgs) => ChangeSetFileElement;
@@ -62,16 +75,23 @@ export class ChangeSetFileElement implements ChangeSetElement {
     @inject(ChangeSetFileService)
     protected readonly changeSetFileService: ChangeSetFileService;
 
-    @inject(ChangeSetDecoratorService)
-    protected readonly changeSetDecoratorService: ChangeSetDecoratorService;
-
     @inject(FileService)
     protected readonly fileService: FileService;
 
     @inject(ConfigurableInMemoryResources)
     protected readonly inMemoryResources: ConfigurableInMemoryResources;
 
-    @inject(ChangeSetFileElementFactory) protected readonly factory: ChangeSetFileElementFactory;
+    @inject(MonacoTextModelService)
+    protected readonly monacoTextModelService: MonacoTextModelService;
+
+    @inject(EditorPreferences)
+    protected readonly editorPreferences: EditorPreferences;
+
+    @inject(FileSystemPreferences)
+    protected readonly fileSystemPreferences: FileSystemPreferences;
+
+    @inject(MonacoCodeActionService)
+    protected readonly codeActionService: MonacoCodeActionService;
 
     protected readonly toDispose = new DisposableCollection();
     protected _state: ChangeSetElementState;
@@ -79,11 +99,13 @@ export class ChangeSetFileElement implements ChangeSetElement {
     private _originalContent: string | undefined;
     protected _initialized = false;
     protected _initializationPromise: Promise<void> | undefined;
+    protected _targetStateWithCodeActions: string | undefined;
+    protected codeActionDeferred?: Deferred<string>;
 
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
-    protected _readOnlyResource: ConfigurableMutableReferenceResource;
-    protected _changeResource: ConfigurableMutableReferenceResource;
+    protected _readOnlyResource?: ConfigurableMutableReferenceResource;
+    protected _changeResource?: ConfigurableMutableReferenceResource;
 
     @postConstruct()
     init(): void {
@@ -174,7 +196,8 @@ export class ChangeSetFileElement implements ChangeSetElement {
     protected get changeResource(): ConfigurableMutableReferenceResource {
         if (!this._changeResource) {
             this._changeResource = this.getInMemoryUri(createChangeSetFileUri(this.elementProps.chatSessionId, this.uri));
-            this._changeResource.update({ autosaveable: false });
+            this._changeResource.update({ autosaveable: false, contents: this.targetState });
+            this.applyCodeActionsToTargetState();
             this.toDispose.push(this._changeResource);
         }
         return this._changeResource;
@@ -236,6 +259,10 @@ export class ChangeSetFileElement implements ChangeSetElement {
     }
 
     get targetState(): string {
+        return this._targetStateWithCodeActions ?? this.elementProps.targetState ?? '';
+    }
+
+    get originalTargetState(): string {
         return this.elementProps.targetState ?? '';
     }
 
@@ -255,14 +282,16 @@ export class ChangeSetFileElement implements ChangeSetElement {
     async apply(contents?: string): Promise<void> {
         await this.ensureInitialized();
         if (!await this.confirm('Apply')) { return; }
-        if (!(await this.changeSetFileService.trySave(this.changedUri))) {
-            if (this.type === 'delete') {
-                await this.changeSetFileService.delete(this.uri);
-                this.state = 'applied';
-            } else {
-                await this.writeChanges(contents);
-            }
+
+        if (this.type === 'delete') {
+            await this.changeSetFileService.delete(this.uri);
+            this.state = 'applied';
+            this.changeSetFileService.closeDiff(this.readOnlyUri);
+            return;
         }
+
+        // Load Monaco model for the base file URI and apply changes
+        await this.applyChangesWithMonaco(contents);
         this.changeSetFileService.closeDiff(this.readOnlyUri);
     }
 
@@ -271,9 +300,124 @@ export class ChangeSetFileElement implements ChangeSetElement {
         this.state = 'applied';
     }
 
+    /**
+     * Applies changes using Monaco utilities, including loading the model for the base file URI,
+     * setting the value to the intended state, and running code actions on save.
+     */
+    protected async applyChangesWithMonaco(contents?: string): Promise<void> {
+        let modelReference: IReference<MonacoEditorModel> | undefined;
+
+        try {
+            modelReference = await this.monacoTextModelService.createModelReference(this.uri);
+            const model = modelReference.object;
+            const targetContent = contents ?? this.targetState;
+            model.textEditorModel.setValue(targetContent);
+
+            const languageId = model.languageId;
+            const uriStr = this.uri.toString();
+
+            await this.codeActionService.applyOnSaveCodeActions(model.textEditorModel, languageId, uriStr, CancellationToken.None);
+            await this.applyFormatting(model, languageId, uriStr);
+
+            await model.save();
+            this.state = 'applied';
+
+        } catch (error) {
+            console.error('Failed to apply changes with Monaco:', error);
+            await this.writeChanges(contents);
+        } finally {
+            modelReference?.dispose();
+        }
+    }
+
+    protected applyCodeActionsToTargetState(): Promise<string> {
+        if (!this.codeActionDeferred) {
+            this.codeActionDeferred = new Deferred();
+            this.codeActionDeferred.resolve(this.doApplyCodeActionsToTargetState());
+        }
+        return this.codeActionDeferred.promise;
+    }
+
+    protected async doApplyCodeActionsToTargetState(): Promise<string> {
+        const targetState = this.originalTargetState;
+        if (!targetState) {
+            this._targetStateWithCodeActions = '';
+            return this._targetStateWithCodeActions;
+        }
+
+        let tempResource: ConfigurableMutableReferenceResource | undefined;
+        let tempModel: IReference<MonacoEditorModel> | undefined;
+        try {
+            // Create a temporary model to apply code actions
+            const tempUri = new URI(`untitled://changeset/${Date.now()}${this.uri.path.ext}`);
+            tempResource = this.inMemoryResources.add(tempUri, { contents: this.targetState });
+            tempModel = await this.monacoTextModelService.createModelReference(tempUri);
+            tempModel.object.suppressOpenEditorWhenDirty = true;
+            tempModel.object.textEditorModel.setValue(this.targetState);
+
+            const languageId = tempModel.object.languageId;
+            const uriStr = this.uri.toString();
+
+            await this.codeActionService.applyOnSaveCodeActions(tempModel.object.textEditorModel, languageId, uriStr, CancellationToken.None);
+
+            // Apply formatting and other editor preferences
+            await this.applyFormatting(tempModel.object, languageId, uriStr);
+
+            this._targetStateWithCodeActions = tempModel.object.textEditorModel.getValue();
+            if (this._changeResource?.contents === this.elementProps.targetState) {
+                this._changeResource?.update({ contents: this.targetState });
+            }
+        } catch (error) {
+            console.warn('Failed to apply code actions to target state:', error);
+            this._targetStateWithCodeActions = targetState;
+        } finally {
+            tempModel?.dispose();
+            tempResource?.dispose();
+        }
+
+        return this.targetState;
+    }
+
+    /**
+     * Applies formatting preferences like format on save, trim trailing whitespace, and insert final newline.
+     */
+    protected async applyFormatting(model: MonacoEditorModel, languageId: string, uriStr: string): Promise<void> {
+        try {
+            const formatOnSave = this.editorPreferences.get({ preferenceName: 'editor.formatOnSave', overrideIdentifier: languageId }, undefined, uriStr);
+            if (formatOnSave) {
+                const instantiation = StandaloneServices.get(IInstantiationService);
+                await instantiation.invokeFunction(
+                    formatDocumentWithSelectedProvider,
+                    model.textEditorModel,
+                    FormattingMode.Explicit,
+                    { report(): void { } },
+                    CancellationToken.None, true
+                );
+            }
+
+            const trimTrailingWhitespace = this.fileSystemPreferences.get({ preferenceName: 'files.trimTrailingWhitespace', overrideIdentifier: languageId }, undefined, uriStr);
+            if (trimTrailingWhitespace) {
+                const ttws = new TrimTrailingWhitespaceCommand(new Selection(1, 1, 1, 1), [], false);
+                CommandExecutor.executeCommands(model.textEditorModel, [], [ttws]);
+            }
+
+            const shouldInsertFinalNewline = this.fileSystemPreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier: languageId }, undefined, uriStr);
+            if (shouldInsertFinalNewline) {
+                insertFinalNewline(model);
+            }
+        } catch (error) {
+            console.warn('Failed to apply formatting:', error);
+        }
+    }
+
     onShow(): void {
-        // Ensure we have the latest state when showing
-        this.changeResource.update({ contents: this.targetState, onSave: content => this.writeChanges(content) });
+        this.changeResource.update({
+            contents: this.targetState,
+            onSave: async content => {
+                // Use Monaco utilities when saving from the change resource
+                await this.applyChangesWithMonaco(content);
+            }
+        });
     }
 
     async revert(): Promise<void> {
@@ -290,11 +434,11 @@ export class ChangeSetFileElement implements ChangeSetElement {
     async confirm(verb: string): Promise<boolean> {
         if (this._state !== 'stale') { return true; }
         await this.openChange();
-        const thing = await new ConfirmDialog({
+        const answer = await new ConfirmDialog({
             title: `${verb} suggestion.`,
             msg: `The file ${this.uri.path.toString()} has changed since this suggestion was created. Are you certain you wish to ${verb.toLowerCase()} the change?`
         }).open(true);
-        return !!thing;
+        return !!answer;
     }
 
     dispose(): void {

package/src/browser/frontend-chat-service.ts

@@ -32,17 +32,8 @@ export class FrontendChatServiceImpl extends ChatServiceImpl {
     @inject(ChangeSetFileService)
     protected readonly changeSetFileService: ChangeSetFileService;
 
-    protected override getAgent(parsedRequest: ParsedChatRequest, session: ChatSession): ChatAgent | undefined {
-        let agent = this.initialAgentSelection(parsedRequest);
-        if (!this.preferenceService.get<boolean>(PIN_CHAT_AGENT_PREF)) {
-            return agent;
-        }
-        if (!session.pinnedAgent && agent && agent.id !== this.defaultChatAgentId?.id) {
-            session.pinnedAgent = agent;
-        } else if (session.pinnedAgent && this.getMentionedAgent(parsedRequest) === undefined) {
-            agent = session.pinnedAgent;
-        }
-        return agent;
+    protected override isPinChatAgentEnabled(): boolean {
+        return this.preferenceService.get<boolean>(PIN_CHAT_AGENT_PREF, true);
     }
 
     protected override initialAgentSelection(parsedRequest: ParsedChatRequest): ChatAgent | undefined {

package/src/common/chat-model.ts

@@ -25,6 +25,7 @@ import {
     ResolvedAIContextVariable,
     TextMessage,
     ThinkingMessage,
+    ToolCallResult,
     ToolResultMessage,
     ToolUseMessage
 } from '@theia/ai-core';
@@ -389,7 +390,7 @@ export interface ToolCallChatResponseContent extends Required<ChatResponseConten
     name?: string;
     arguments?: string;
     finished: boolean;
-    result?: string;
+    result?: ToolCallResult;
     confirmed: Promise<boolean>;
     confirm(): void;
     deny(): void;
@@ -1497,12 +1498,12 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
     protected _name?: string;
     protected _arguments?: string;
     protected _finished?: boolean;
-    protected _result?: string;
+    protected _result?: ToolCallResult;
     protected _confirmed: Promise<boolean>;
     protected _confirmationResolver?: (value: boolean) => void;
     protected _confirmationRejecter?: (reason?: unknown) => void;
 
-    constructor(id?: string, name?: string, arg_string?: string, finished?: boolean, result?: string) {
+    constructor(id?: string, name?: string, arg_string?: string, finished?: boolean, result?: ToolCallResult) {
         this._id = id;
         this._name = name;
         this._arguments = arg_string;
@@ -1527,7 +1528,7 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
     get finished(): boolean {
         return this._finished === undefined ? false : this._finished;
     }
-    get result(): string | undefined {
+    get result(): ToolCallResult | undefined {
         return this._result;
     }
 

package/src/common/chat-request-parser.ts

@@ -228,18 +228,6 @@ export class ChatRequestParserImpl implements ChatRequestParser {
             return;
         }
 
-        // The agent must come first
-        if (
-            parts.some(
-                p =>
-                    (p instanceof ParsedChatRequestTextPart &&
-                        p.text.trim() !== '') ||
-                    !(p instanceof ParsedChatRequestAgentPart)
-            )
-        ) {
-            return;
-        }
-
         return new ParsedChatRequestAgentPart(agentRange, agent.id, agent.name);
     }
 

package/src/common/chat-service.ts

@@ -313,15 +313,44 @@ export class ChatServiceImpl implements ChatService {
     }
 
     protected getAgent(parsedRequest: ParsedChatRequest, session: ChatSession): ChatAgent | undefined {
-        let agent = this.initialAgentSelection(parsedRequest);
-        if (this.pinChatAgent === false) {
+        const agent = this.initialAgentSelection(parsedRequest);
+        if (!this.isPinChatAgentEnabled()) {
             return agent;
         }
-        if (!session.pinnedAgent && agent && agent.id !== this.defaultChatAgentId?.id) {
-            session.pinnedAgent = agent;
-        } else if (session.pinnedAgent && this.getMentionedAgent(parsedRequest) === undefined) {
-            agent = session.pinnedAgent;
+
+        return this.handlePinnedAgent(parsedRequest, session, agent);
+    }
+
+    /**
+     * Determines if chat agent pinning is enabled.
+     * Can be overridden by subclasses to provide different logic (e.g., using preferences).
+     */
+    protected isPinChatAgentEnabled(): boolean {
+        return this.pinChatAgent !== false;
+    }
+
+    /**
+     * Handle pinned agent by:
+     * - checking if an agent is pinned, and use it if no other agent is mentioned
+     * - pinning the current agent
+     */
+    protected handlePinnedAgent(parsedRequest: ParsedChatRequest, session: ChatSession, agent: ChatAgent | undefined): ChatAgent | undefined {
+        const mentionedAgentPart = this.getMentionedAgent(parsedRequest);
+        const mentionedAgent = mentionedAgentPart ? this.chatAgentService.getAgent(mentionedAgentPart.agentId) : undefined;
+        if (mentionedAgent) {
+            // If an agent is explicitly mentioned, it becomes the new pinned agent
+            session.pinnedAgent = mentionedAgent;
+            return mentionedAgent;
+        } else if (session.pinnedAgent) {
+            // If we have a valid pinned agent, use it (pinned agent may become stale
+            // if it was disabled; so we always need to recheck)
+            const pinnedAgent = this.chatAgentService.getAgent(session.pinnedAgent.id);
+            if (pinnedAgent) {
+                return pinnedAgent;
+            }
         }
+        // Otherwise, override the pinned agent and return the suggested one
+        session.pinnedAgent = agent;
         return agent;
     }
 

package/src/common/chat-session-naming-service.ts

@@ -30,9 +30,9 @@ import { ChatSession } from './chat-service';
 import { generateUuid } from '@theia/core';
 
 const CHAT_SESSION_NAMING_PROMPT: PromptVariantSet = {
-    id: 'chat-session-naming-prompt',
+    id: 'chat-session-naming-system',
     defaultVariant: {
-        id: 'chat-session-naming-prompt',
+        id: 'chat-session-naming-system-default',
         template: '{{!-- Made improvements or adaptations to this prompt template? We\'d love for you to share it with the community! Contribute back here: ' +
             'https://github.com/eclipse-theia/theia/discussions/new?category=prompt-template-contribution --}}\n\n' +
             'Provide a short and descriptive name for the given AI chat conversation of an AI-powered tool based on the conversation below.\n\n' +

package/src/common/chat-session-summary-agent-prompt.ts

@@ -11,9 +11,9 @@
 import { CHANGE_SET_SUMMARY_VARIABLE_ID } from './context-variables';
 
 export const CHAT_SESSION_SUMMARY_PROMPT = {
-    id: 'chat-session-summary-system-prompt',
+    id: 'chat-session-summary-system',
     defaultVariant: {
-        id: 'chat-session-summary-prompt',
+        id: 'chat-session-summary-system-default',
         template: '{{!-- !-- This prompt is licensed under the MIT License (https://opensource.org/license/mit).\n' +
             'Made improvements or adaptations to this prompt template? We\'d love for you to share it with the community! Contribute back here:  ' +
             'https://github.com/eclipse-theia/theia/discussions/new?category=prompt-template-contribution --}}\n\n' +
@@ -23,7 +23,7 @@ export const CHAT_SESSION_SUMMARY_PROMPT = {
             'Ensure that the summary is sufficiently comprehensive to allow seamless continuation of the workflow. ' +
             'The summary will primarily be used by other AI agents, so tailor your response for use by AI agents. ' +
             'Also consider the system message. ' +
-            'Make sure you include all necessary context information and use unique references(such as URIs, file paths, etc.). ' +
+            'Make sure you include all necessary context information and use unique references (such as URIs, file paths, etc.). ' +
             'If the conversation was about a task, describe the state of the task, i.e.what has been completed and what is open. ' +
             'If a changeset is open in the session, describe the state of the suggested changes. ' +
             `\n\n{{${CHANGE_SET_SUMMARY_VARIABLE_ID}}}`,

package/src/common/chat-tool-request-service.ts

@@ -19,8 +19,8 @@ import { injectable } from '@theia/core/shared/inversify';
 import { MutableChatRequestModel } from './chat-model';
 
 export interface ChatToolRequest extends ToolRequest {
-    handler(arg_string: string, context: MutableChatRequestModel): Promise<unknown>;
-    handler(arg_string: string, ctx?: unknown): Promise<unknown>;
+    handler(arg_string: string, context: MutableChatRequestModel): ReturnType<ToolRequest['handler']>;
+    handler(arg_string: string, ctx?: unknown): ReturnType<ToolRequest['handler']>;
 }
 
 /**