@theia/ai-ide 1.62.0-next.3 → 1.62.1

package/src/browser/ai-configuration/template-settings-renderer.tsx

@@ -13,84 +13,64 @@
 //
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
-import { AISettingsService, PromptCustomizationService, PromptService, PromptTemplate } from '@theia/ai-core/lib/common';
+import { AISettingsService, PromptService, PromptVariantSet } from '@theia/ai-core/lib/common';
 import * as React from '@theia/core/shared/react';
 import { nls } from '@theia/core/lib/common/nls';
 
-const DEFAULT_VARIANT = 'default';
-
-export interface TemplateRendererProps {
+export interface PromptVariantRendererProps {
     agentId: string;
-    template: PromptTemplate;
-    promptCustomizationService: PromptCustomizationService;
+    promptVariantSet: PromptVariantSet;
     promptService: PromptService;
     aiSettingsService: AISettingsService;
 }
 
-export const TemplateRenderer: React.FC<TemplateRendererProps> = ({
+export const PromptVariantRenderer: React.FC<PromptVariantRendererProps> = ({
     agentId,
-    template,
-    promptCustomizationService,
+    promptVariantSet,
     promptService,
     aiSettingsService,
 }) => {
-    const variantIds = [DEFAULT_VARIANT, ...promptService.getVariantIds(template.id)];
-    const [selectedVariant, setSelectedVariant] = React.useState<string>(DEFAULT_VARIANT);
+    const variantIds = promptService.getVariantIds(promptVariantSet.id);
+    const defaultVariantId = promptService.getDefaultVariantId(promptVariantSet.id);
+    const [selectedVariant, setSelectedVariant] = React.useState<string>(defaultVariantId!);
 
     React.useEffect(() => {
         (async () => {
-            const agentSettings = await aiSettingsService.getAgentSettings(agentId);
             const currentVariant =
-                agentSettings?.selectedVariants?.[template.id] || DEFAULT_VARIANT;
-            setSelectedVariant(currentVariant);
+                await promptService.getSelectedVariantId(promptVariantSet.id);
+            setSelectedVariant(currentVariant!);
         })();
-    }, [template.id, aiSettingsService, agentId]);
+    }, [promptVariantSet.id, aiSettingsService, agentId]);
 
     const isInvalidVariant = !variantIds.includes(selectedVariant);
 
     const handleVariantChange = async (event: React.ChangeEvent<HTMLSelectElement>) => {
         const newVariant = event.target.value;
         setSelectedVariant(newVariant);
-
-        const agentSettings = await aiSettingsService.getAgentSettings(agentId);
-        const selectedVariants = agentSettings?.selectedVariants || {};
-
-        const updatedVariants = { ...selectedVariants };
-        if (newVariant === DEFAULT_VARIANT) {
-            delete updatedVariants[template.id];
-        } else {
-            updatedVariants[template.id] = newVariant;
-        }
-
-        await aiSettingsService.updateAgentSettings(agentId, {
-            selectedVariants: updatedVariants,
-        });
+        promptService.updateSelectedVariantId(agentId, promptVariantSet.id, newVariant);
     };
 
     const openTemplate = () => {
-        const templateId = selectedVariant === DEFAULT_VARIANT ? template.id : selectedVariant;
-        const selectedTemplate = promptService.getRawPrompt(templateId);
-        promptCustomizationService.editTemplate(templateId, selectedTemplate?.template || '');
+        promptService.editBuiltInCustomization(selectedVariant);
     };
 
     const resetTemplate = () => {
-        const templateId = selectedVariant === DEFAULT_VARIANT ? template.id : selectedVariant;
-        promptCustomizationService.resetTemplate(templateId);
+        promptService.resetToBuiltIn(selectedVariant);
     };
 
     return (
         <div className="template-renderer">
             <div className="settings-section-title template-header">
-                <strong>{template.id}</strong>
+                <strong>{promptVariantSet.id}</strong>
             </div>
             <div className="template-controls">
                 {(variantIds.length > 1 || isInvalidVariant) && (
                     <>
-                        <label htmlFor={`variant-selector-${template.id}`} className="template-select-label">
+                        <label htmlFor={`variant-selector-${promptVariantSet.id}`} className="template-select-label">
                             {nls.localize('theia/ai/core/templateSettings/selectVariant', 'Select Variant:')}
                         </label>
                         <select
-                            id={`variant-selector-${template.id}`}
+                            id={`variant-selector-${promptVariantSet.id}`}
                             className={`theia-select template-variant-selector ${isInvalidVariant ? 'error' : ''}`}
                             value={isInvalidVariant ? 'invalid' : selectedVariant}
                             onChange={handleVariantChange}
@@ -102,7 +82,7 @@ export const TemplateRenderer: React.FC<TemplateRendererProps> = ({
                             )}
                             {variantIds.map(variantId => (
                                 <option key={variantId} value={variantId}>
-                                    {variantId}
+                                    {variantId === defaultVariantId ? variantId + ' (default)' : variantId}
                                 </option>
                             ))}
                         </select>

package/src/browser/architect-agent.ts

@@ -16,7 +16,7 @@
 import { AbstractStreamParsingChatAgent, ChatRequestModel, ChatService, ChatSession, MutableChatModel, MutableChatRequestModel } from '@theia/ai-chat/lib/common';
 import { LanguageModelRequirement } from '@theia/ai-core';
 import { inject, injectable } from '@theia/core/shared/inversify';
-import { architectPromptTemplate, architectTaskSummaryPromptTemplate } from '../common/architect-prompt-template';
+import { architectVariants } from '../common/architect-prompt-template';
 import { FILE_CONTENT_FUNCTION_ID, GET_WORKSPACE_FILE_LIST_FUNCTION_ID } from '../common/workspace-functions';
 import { nls } from '@theia/core';
 import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
@@ -38,9 +38,9 @@ export class ArchitectAgent extends AbstractStreamParsingChatAgent {
         'An AI assistant integrated into Theia IDE, designed to assist software developers. This agent can access the users workspace, it can get a list of all available files \
          and folders and retrieve their content. It cannot modify files. It can therefore answer questions about the current project, project files and source code in the \
          workspace, such as how to build the project, where to put source code, where to find specific code or configurations, etc.');
-    override promptTemplates = [architectPromptTemplate, architectTaskSummaryPromptTemplate];
+    override prompts = [architectVariants];
     override functions = [GET_WORKSPACE_FILE_LIST_FUNCTION_ID, FILE_CONTENT_FUNCTION_ID];
-    protected override systemPromptId: string | undefined = architectPromptTemplate.id;
+    protected override systemPromptId: string | undefined = architectVariants.id;
 
     override async invoke(request: MutableChatRequestModel): Promise<void> {
         await super.invoke(request);

package/src/browser/coder-agent.ts

@@ -16,9 +16,9 @@
 import { AbstractStreamParsingChatAgent, ChatRequestModel, ChatService, ChatSession, MutableChatModel, MutableChatRequestModel } from '@theia/ai-chat/lib/common';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { FILE_CONTENT_FUNCTION_ID, GET_WORKSPACE_FILE_LIST_FUNCTION_ID, GET_WORKSPACE_DIRECTORY_STRUCTURE_FUNCTION_ID } from '../common/workspace-functions';
-import { CODER_REPLACE_PROMPT_TEMPLATE_ID, getCoderReplacePromptTemplate, getCoderReplacePromptTemplateNext } from '../common/coder-replace-prompt-template';
+import { CODER_SYSTEM_PROMPT_ID, getCoderAgentModePromptTemplate, getCoderReplacePromptTemplate, getCoderReplacePromptTemplateNext } from '../common/coder-replace-prompt-template';
 import { WriteChangeToFileProvider } from './file-changeset-functions';
-import { LanguageModelRequirement } from '@theia/ai-core';
+import { LanguageModelRequirement, PromptVariantSet } from '@theia/ai-core';
 import { nls } from '@theia/core';
 import { MarkdownStringImpl } from '@theia/core/lib/common/markdown-rendering';
 import { AI_CHAT_NEW_CHAT_WINDOW_COMMAND, ChatCommands } from '@theia/ai-chat-ui/lib/browser/chat-view-commands';
@@ -36,11 +36,15 @@ export class CoderAgent extends AbstractStreamParsingChatAgent {
 
     override description = nls.localize('theia/ai/workspace/coderAgent/description',
         'An AI assistant integrated into Theia IDE, designed to assist software developers. This agent can access the users workspace, it can get a list of all available files \
-        and folders and retrieve their content. Futhermore, it can suggest modifications of files to the user. It can therefore assist the user with coding tasks or other \
+        and folders and retrieve their content. Furthermore, it can suggest modifications of files to the user. It can therefore assist the user with coding tasks or other \
         tasks involving file changes.');
-    override promptTemplates = [getCoderReplacePromptTemplate(true), getCoderReplacePromptTemplate(false), getCoderReplacePromptTemplateNext()];
+    override prompts: PromptVariantSet[] = [{
+        id: CODER_SYSTEM_PROMPT_ID,
+        defaultVariant: getCoderReplacePromptTemplate(true),
+        variants: [getCoderReplacePromptTemplate(false), getCoderReplacePromptTemplateNext(), getCoderAgentModePromptTemplate()]
+    }];
     override functions = [GET_WORKSPACE_DIRECTORY_STRUCTURE_FUNCTION_ID, GET_WORKSPACE_FILE_LIST_FUNCTION_ID, FILE_CONTENT_FUNCTION_ID, WriteChangeToFileProvider.ID];
-    protected override systemPromptId: string | undefined = CODER_REPLACE_PROMPT_TEMPLATE_ID;
+    protected override systemPromptId: string | undefined = CODER_SYSTEM_PROMPT_ID;
     override async invoke(request: MutableChatRequestModel): Promise<void> {
         await super.invoke(request);
         this.suggest(request);
@@ -63,4 +67,5 @@ export class CoderAgent extends AbstractStreamParsingChatAgent {
                 + ` or [start a new chat with a summary of this one](command:${ChatCommands.AI_CHAT_NEW_WITH_TASK_CONTEXT.id}).`)]);
         }
     }
+
 }

package/src/browser/file-changeset-functions.ts

@@ -16,10 +16,11 @@
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { ToolProvider, ToolRequest, ToolRequestParameters, ToolRequestParametersProperties } from '@theia/ai-core';
 import { WorkspaceFunctionScope } from './workspace-functions';
-import { ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
-import { ChangeSetImpl, MutableChatRequestModel } from '@theia/ai-chat';
+import { ChangeSetFileElement, ChangeSetFileElementFactory } from '@theia/ai-chat/lib/browser/change-set-file-element';
+import { ChangeSet, ChangeSetImpl, MutableChatRequestModel } from '@theia/ai-chat';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { ContentReplacer, Replacement } from '@theia/core/lib/common/content-replacer';
+import { URI } from '@theia/core/lib/common/uri';
 
 @injectable()
 export class WriteChangeToFileProvider implements ToolProvider {
@@ -106,7 +107,7 @@ export class ReplaceContentInFileFunctionHelper {
         this.replacer = new ContentReplacer();
     }
 
-    getToolMetadata(supportMutipleReplace: boolean = false): { description: string, parameters: ToolRequestParameters } {
+    getToolMetadata(supportMultipleReplace: boolean = false): { description: string, parameters: ToolRequestParameters } {
         const replacementProperties: ToolRequestParametersProperties = {
             oldContent: {
                 type: 'string',
@@ -118,7 +119,7 @@ export class ReplaceContentInFileFunctionHelper {
             }
         };
 
-        if (supportMutipleReplace) {
+        if (supportMultipleReplace) {
             replacementProperties.multiple = {
                 type: 'boolean',
                 description: 'Set to true if multiple occurrences of the oldContent are expected to be replaced.'
@@ -139,12 +140,16 @@ export class ReplaceContentInFileFunctionHelper {
                         required: ['oldContent', 'newContent']
                     },
                     description: 'An array of replacement objects, each containing oldContent and newContent strings.'
+                },
+                reset: {
+                    type: 'boolean',
+                    description: 'Set to true to clear any existing pending changes for this file and start fresh. Default is false, which merges with existing changes.'
                 }
             },
             required: ['path', 'replacements']
         } as ToolRequestParameters;
 
-        const replacementSentence = supportMutipleReplace
+        const replacementSentence = supportMultipleReplace
             ? 'By default, a single occurrence of each old content in the tuples is expected to be replaced. If the optional \'multiple\' flag is set to true, all occurrences will\
              be replaced. In either case, if the number of occurrences in the file does not match the expectation the function will return an error. \
              In that case try a different approach.'
@@ -152,10 +157,10 @@ export class ReplaceContentInFileFunctionHelper {
               the function will return an error. In that case try a different approach.';
 
         const replacementDescription = `Propose to replace sections of content in an existing file by providing a list of tuples with old content to be matched and replaced.
-            ${replacementSentence}. For deletions, use an empty new content in the tuple.\
-            Make sure you use the same line endings and whitespace as in the original file content. The proposed changes will be applied when the user accepts.\
-            If called again for the same file, it will override previous change proposals for this file. So you must ultimatly call this function only once per file with a tuple\
-            containing all proposed changes for this file`;
+            ${replacementSentence}. For deletions, use an empty new content in the tuple.
+            Make sure you use the same line endings and whitespace as in the original file content. The proposed changes will be applied when the user accepts.
+            Multiple calls for the same file will merge replacements unless the reset parameter is set to true. Use the reset parameter to clear previous changes and start 
+            fresh if needed.`;
 
         return {
             description: replacementDescription,
@@ -166,17 +171,33 @@ export class ReplaceContentInFileFunctionHelper {
 
     async createChangesetFromToolCall(toolCallString: string, ctx: MutableChatRequestModel): Promise<string> {
         try {
-            const { path, replacements } = JSON.parse(toolCallString) as { path: string, replacements: Replacement[] };
+            const { path, replacements, reset } = JSON.parse(toolCallString) as { path: string, replacements: Replacement[], reset?: boolean };
             const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
-            const fileContent = (await this.fileService.read(fileUri)).value.toString();
 
-            const { updatedContent, errors } = this.replacer.applyReplacements(fileContent, replacements);
+            // Get the starting content - either original file or existing proposed state
+            let startingContent: string;
+            if (reset || !ctx.session.changeSet) {
+                // Start from original file content
+                startingContent = (await this.fileService.read(fileUri)).value.toString();
+            } else {
+                // Start from existing proposed state if available
+                const existingElement = this.findExistingChangeElement(ctx.session.changeSet, fileUri);
+                if (existingElement) {
+                    startingContent = existingElement.targetState || (await this.fileService.read(fileUri)).value.toString();
+                } else {
+                    startingContent = (await this.fileService.read(fileUri)).value.toString();
+                }
+            }
+
+            const { updatedContent, errors } = this.replacer.applyReplacements(startingContent, replacements);
 
             if (errors.length > 0) {
                 return `Errors encountered: ${errors.join('; ')}`;
             }
 
-            if (updatedContent !== fileContent) {
+            // Only create/update changeset if content actually changed
+            const originalContent = (await this.fileService.read(fileUri)).value.toString();
+            if (updatedContent !== originalContent) {
                 let changeSet = ctx.session.changeSet;
                 if (!changeSet) {
                     changeSet = new ChangeSetImpl('Changes proposed by Coder');
@@ -194,12 +215,70 @@ export class ReplaceContentInFileFunctionHelper {
                     })
                 );
             }
-            return `Proposed replacements in file ${path}. The user will review and potentially apply the changes.`;
+
+            const action = reset ? 'reset and applied' : 'applied';
+            return `Proposed replacements ${action} to file ${path}. The user will review and potentially apply the changes.`;
         } catch (error) {
             console.debug('Error processing replacements:', error.message);
             return JSON.stringify({ error: error.message });
         }
     }
+
+    private findExistingChangeElement(changeSet: ChangeSet, fileUri: URI): ChangeSetFileElement | undefined {
+        return changeSet.getElementByURI(fileUri) as ChangeSetFileElement;
+    }
+
+    async clearFileChanges(path: string, ctx: MutableChatRequestModel): Promise<string> {
+        try {
+            const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
+
+            if (!ctx.session.changeSet) {
+                return `No pending changes found for file ${path}.`;
+            }
+
+            const elements = ctx.session.changeSet.getElements();
+            const indicesToRemove: number[] = [];
+            elements.forEach((element, index) => {
+                if (element.uri && element.uri.toString() === fileUri.toString()) {
+                    indicesToRemove.push(index);
+                }
+            });
+
+            if (indicesToRemove.length > 0) {
+                ctx.session.changeSet.removeElements(...indicesToRemove);
+                return `Cleared ${indicesToRemove.length} pending change(s) for file ${path}.`;
+            } else {
+                return `No pending changes found for file ${path}.`;
+            }
+        } catch (error) {
+            console.debug('Error clearing file changes:', error.message);
+            return JSON.stringify({ error: error.message });
+        }
+    }
+
+    async getProposedFileState(path: string, ctx: MutableChatRequestModel): Promise<string> {
+        try {
+            const fileUri = await this.workspaceFunctionScope.resolveRelativePath(path);
+
+            if (!ctx.session.changeSet) {
+                // No changeset exists, return original file content
+                const originalContent = (await this.fileService.read(fileUri)).value.toString();
+                return `File ${path} has no pending changes. Original content:\n\n${originalContent}`;
+            }
+
+            const existingElement = this.findExistingChangeElement(ctx.session.changeSet, fileUri);
+            if (existingElement && existingElement.targetState) {
+                return `File ${path} has pending changes. Proposed content:\n\n${existingElement.targetState}`;
+            } else {
+                // No pending changes for this file
+                const originalContent = (await this.fileService.read(fileUri)).value.toString();
+                return `File ${path} has no pending changes. Original content:\n\n${originalContent}`;
+            }
+        } catch (error) {
+            console.debug('Error getting proposed file state:', error.message);
+            return JSON.stringify({ error: error.message });
+        }
+    }
 }
 
 @injectable()
@@ -239,3 +318,62 @@ export class ReplaceContentInFileProvider implements ToolProvider {
         };
     }
 }
+
+@injectable()
+export class ClearFileChangesProvider implements ToolProvider {
+    static ID = 'changeSet_clearFileChanges';
+    @inject(ReplaceContentInFileFunctionHelper)
+    protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
+
+    getTool(): ToolRequest {
+        return {
+            id: ClearFileChangesProvider.ID,
+            name: ClearFileChangesProvider.ID,
+            description: 'Clears all pending changes for a specific file, allowing you to start fresh with new modifications.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The path of the file to clear pending changes for.'
+                    }
+                },
+                required: ['path']
+            },
+            handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> => {
+                const { path } = JSON.parse(args);
+                return this.replaceContentInFileFunctionHelper.clearFileChanges(path, ctx);
+            }
+        };
+    }
+}
+
+@injectable()
+export class GetProposedFileStateProvider implements ToolProvider {
+    static ID = 'changeSet_getProposedFileState';
+    @inject(ReplaceContentInFileFunctionHelper)
+    protected readonly replaceContentInFileFunctionHelper: ReplaceContentInFileFunctionHelper;
+
+    getTool(): ToolRequest {
+        return {
+            id: GetProposedFileStateProvider.ID,
+            name: GetProposedFileStateProvider.ID,
+            description: 'Returns the current proposed state of a file, including all pending changes that have been proposed ' +
+                'but not yet applied. This allows you to inspect the current state before making additional changes.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: {
+                        type: 'string',
+                        description: 'The path of the file to get the proposed state for.'
+                    }
+                },
+                required: ['path']
+            },
+            handler: async (args: string, ctx: MutableChatRequestModel): Promise<string> => {
+                const { path } = JSON.parse(args);
+                return this.replaceContentInFileFunctionHelper.getProposedFileState(path, ctx);
+            }
+        };
+    }
+}

package/src/browser/frontend-module.ts

@@ -20,12 +20,14 @@ import { Agent, AIVariableContribution, bindToolProvider } from '@theia/ai-core/
 import { ArchitectAgent } from './architect-agent';
 import { CoderAgent } from './coder-agent';
 import { SummarizeSessionCommandContribution } from './summarize-session-command-contribution';
-import { FileContentFunction, FileDiagonsticProvider, GetWorkspaceDirectoryStructure, GetWorkspaceFileList, WorkspaceFunctionScope } from './workspace-functions';
+import { FileContentFunction, FileDiagnosticProvider, GetWorkspaceDirectoryStructure, GetWorkspaceFileList, WorkspaceFunctionScope } from './workspace-functions';
 import { WorkspaceSearchProvider } from './workspace-search-provider';
 import { FrontendApplicationContribution, PreferenceContribution, WidgetFactory, bindViewContribution } from '@theia/core/lib/browser';
 import { TaskListProvider, TaskRunnerProvider } from './workspace-task-provider';
 import { WorkspacePreferencesSchema } from './workspace-preferences';
 import {
+    ClearFileChangesProvider,
+    GetProposedFileStateProvider,
     ReplaceContentInFileFunctionHelper,
     ReplaceContentInFileProvider,
     SimpleReplaceContentInFileProvider,
@@ -52,6 +54,7 @@ import { TaskContextSummaryVariableContribution } from './task-background-summar
 import { TaskContextFileStorageService } from './task-context-file-storage-service';
 import { TaskContextStorageService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { CommandContribution } from '@theia/core';
+import { AIPromptFragmentsConfigurationWidget } from './ai-configuration/prompt-fragments-configuration-widget';
 
 export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(PreferenceContribution).toConstantValue({ schema: WorkspacePreferencesSchema });
@@ -84,7 +87,7 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bindToolProvider(GetWorkspaceFileList, bind);
     bindToolProvider(FileContentFunction, bind);
     bindToolProvider(GetWorkspaceDirectoryStructure, bind);
-    bindToolProvider(FileDiagonsticProvider, bind);
+    bindToolProvider(FileDiagnosticProvider, bind);
     bind(WorkspaceFunctionScope).toSelf().inSingletonScope();
     bindToolProvider(WorkspaceSearchProvider, bind);
 
@@ -124,6 +127,8 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
         .inSingletonScope();
 
     bindToolProvider(SimpleReplaceContentInFileProvider, bind);
+    bindToolProvider(ClearFileChangesProvider, bind);
+    bindToolProvider(GetProposedFileStateProvider, bind);
     bindToolProvider(AddFileToChatContext, bind);
     bind(AIVariableContribution).to(ContextFilesVariableContribution).inSingletonScope();
     bind(PreferenceContribution).toConstantValue({ schema: AiConfigurationPreferences });
@@ -152,4 +157,11 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     rebind(TaskContextStorageService).toService(TaskContextFileStorageService);
 
     bind(CommandContribution).to(SummarizeSessionCommandContribution);
+    bind(AIPromptFragmentsConfigurationWidget).toSelf();
+    bind(WidgetFactory)
+        .toDynamicValue(ctx => ({
+            id: AIPromptFragmentsConfigurationWidget.ID,
+            createWidget: () => ctx.container.get(AIPromptFragmentsConfigurationWidget)
+        }))
+        .inSingletonScope();
 });