@theia/ai-ide 1.63.0-next.0 → 1.63.0-next.52

package/src/browser/style/index.css

@@ -2,6 +2,14 @@
   padding: var(--theia-ui-padding);
 }
 
+.ai-configuration-widget [role="tablist"] {
+  overflow: scroll;
+}
+
+.ai-configuration-widget [role="tablist"]::-webkit-scrollbar {
+  height: 4px;
+}
+
 .theia-ai-settings-container {
   padding: var(--theia-ui-padding);
 }
@@ -90,8 +98,15 @@
   flex-direction: row;
 }
 
-.configuration-agents-list {
-  width: 128px;
+#ai-agent-configuration-container-widget
+  .ai-agent-configuration-main
+  .configuration-agents-list {
+  min-width: 160px;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  padding-left: 0;
+  padding: var(--theia-ui-padding);
 }
 
 .configuration-agent-panel {
@@ -128,9 +143,12 @@
 }
 
 /* Prompt Fragments Configuration Styles */
+.configuration-variables-list,
+.token-usage-configuration-container,
+.ai-tools-configuration-container,
 .ai-prompt-fragments-configuration {
   padding: var(--theia-ui-padding);
-  max-width: 1200px;
+  max-width: 600px;
   margin: 0 auto;
 }
 
@@ -422,7 +440,8 @@
   gap: 8px;
 }
 
-.prompt-fragment-title h2, h4 {
+.prompt-fragment-title h2,
+h4 {
   margin-right: 8px;
   margin: 0;
 }
@@ -448,10 +467,6 @@
 }
 
 /* MCP Configuration Styles */
-.mcp-configuration-container {
-  padding: 16px;
-}
-
 .mcp-configuration-title {
   margin: 0 0 16px 0;
   border-bottom: 1px solid var(--theia-panelTitle-activeBorder);
@@ -669,11 +684,69 @@
   font-style: normal;
 }
 
-/* Token Usage Configuration Styles */
-.token-usage-configuration-container {
-  padding: 16px;
+/*
+ * AI Tools Configuration Widget Styles
+ * Only touch styles in this section for the tools configuration widget
+ */
+.ai-tools-configuration-default-section {
+  margin-bottom: 24px;
+}
+
+.ai-tools-configuration-default-label {
+  font-weight: bold;
+  margin-bottom: 4px;
+}
+
+.ai-tools-configuration-default-select {
+  font-size: 14px;
+  padding: 4px;
+}
+
+.ai-tools-configuration-tools-label {
+  font-weight: bold;
+  margin-bottom: 8px;
+}
+
+.ai-tools-configuration-tools-list {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+.ai-tools-configuration-tool-item {
+  display: flex;
+  align-items: center;
+  margin-bottom: 12px;
+  border-radius: 4px;
+  padding: 4px;
+  transition: background 0.2s, opacity 0.2s;
 }
 
+.ai-tools-configuration-tool-item.default {
+  opacity: 0.5;
+  background: none;
+}
+
+.ai-tools-configuration-tool-item.custom {
+  opacity: 1;
+  background: var(--theia-editor-inactiveSelectionBackground);
+}
+
+.ai-tools-configuration-tool-name {
+  flex: 1;
+}
+
+.ai-tools-configuration-tool-select {
+  margin-right: 8px;
+}
+
+.ai-tools-configuration-tool-icon {
+  font-size: 18px;
+}
+
+/* End AI Tools Configuration Widget Styles */
+
+/* Token Usage Configuration Styles */
 .token-usage-configuration-title {
   margin: 0 0 16px 0;
   border-bottom: 1px solid var(--theia-widget-border);

package/src/browser/summarize-session-command-contribution.ts

@@ -16,12 +16,16 @@
 
 import { ChatAgentLocation, ChatService } from '@theia/ai-chat/lib/common';
 import { CommandContribution, CommandRegistry, CommandService } from '@theia/core';
+import { TaskContextStorageService, TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { injectable, inject } from '@theia/core/shared/inversify';
-import { AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER } from '../common/summarize-session-commands';
-import { TaskContextService } from '@theia/ai-chat/lib/browser/task-context-service';
+import { AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER, AI_UPDATE_TASK_CONTEXT_COMMAND } from '../common/summarize-session-commands';
 import { CoderAgent } from './coder-agent';
 import { TASK_CONTEXT_VARIABLE } from '@theia/ai-chat/lib/browser/task-context-variable';
-import { ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID } from '../common/architect-prompt-template';
+import { ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID, ARCHITECT_TASK_SUMMARY_UPDATE_PROMPT_TEMPLATE_ID } from '../common/architect-prompt-template';
+import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
+import { AIVariableResolutionRequest } from '@theia/ai-core';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { WorkspaceService } from '@theia/workspace/lib/browser';
 
 @injectable()
 export class SummarizeSessionCommandContribution implements CommandContribution {
@@ -37,7 +41,35 @@ export class SummarizeSessionCommandContribution implements CommandContribution
     @inject(CoderAgent)
     protected readonly coderAgent: CoderAgent;
 
+    @inject(TaskContextStorageService)
+    protected readonly taskContextStorageService: TaskContextStorageService;
+
+    @inject(FileService)
+    protected readonly fileService: FileService;
+
+    @inject(WorkspaceService)
+    protected readonly wsService: WorkspaceService;
+
     registerCommands(registry: CommandRegistry): void {
+        registry.registerCommand(AI_UPDATE_TASK_CONTEXT_COMMAND, {
+            execute: async () => {
+                const activeSession = this.chatService.getActiveSession();
+
+                if (!activeSession) {
+                    return;
+                }
+
+                // Check if there is an existing summary for this session
+                if (!this.taskContextService.hasSummary(activeSession)) {
+                    // If no summary exists, create one first
+                    await this.taskContextService.summarize(activeSession, ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID);
+                } else {
+                    // Update existing summary
+                    await this.taskContextService.update(activeSession, ARCHITECT_TASK_SUMMARY_UPDATE_PROMPT_TEMPLATE_ID);
+                }
+            }
+        });
+
         registry.registerCommand(AI_SUMMARIZE_SESSION_AS_TASK_FOR_CODER, {
             execute: async () => {
                 const activeSession = this.chatService.getActiveSession();
@@ -48,9 +80,29 @@ export class SummarizeSessionCommandContribution implements CommandContribution
 
                 const summaryId = await this.taskContextService.summarize(activeSession, ARCHITECT_TASK_SUMMARY_PROMPT_TEMPLATE_ID);
 
-                const newSession = this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }, this.coderAgent);
-                const summaryVariable = { variable: TASK_CONTEXT_VARIABLE, arg: summaryId };
-                newSession.model.context.addVariables(summaryVariable);
+                // Open the summary in a new editor
+                await this.taskContextStorageService.open(summaryId);
+
+                // Add the summary file to the context of the active Architect session
+                const summary = this.taskContextService.getAll().find(s => s.id === summaryId);
+                if (summary?.uri) {
+                    if (await this.fileService.exists(summary?.uri)) {
+                        const wsRelativePath = await this.wsService.getWorkspaceRelativePath(summary?.uri);
+                        // Create a file variable for the summary
+                        const fileVariable: AIVariableResolutionRequest = {
+                            variable: FILE_VARIABLE,
+                            arg: wsRelativePath
+                        };
+
+                        // Add the file to the active session's context
+                        activeSession.model.context.addVariables(fileVariable);
+                    }
+
+                    // Create a new session with the coder agent
+                    const newSession = this.chatService.createSession(ChatAgentLocation.Panel, { focus: true }, this.coderAgent);
+                    const summaryVariable = { variable: TASK_CONTEXT_VARIABLE, arg: summaryId };
+                    newSession.model.context.addVariables(summaryVariable);
+                }
             }
         });
     }

package/src/browser/task-context-file-storage-service.ts

@@ -17,7 +17,7 @@
 import { Summary, SummaryMetadata, TaskContextStorageService } from '@theia/ai-chat/lib/browser/task-context-service';
 import { InMemoryTaskContextStorage } from '@theia/ai-chat/lib/browser/task-context-storage-service';
 import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
-import { DisposableCollection, EOL, Emitter, Path, URI, unreachable } from '@theia/core';
+import { DisposableCollection, EOL, Emitter, ILogger, Path, URI, unreachable } from '@theia/core';
 import { PreferenceService, OpenerService, open } from '@theia/core/lib/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
@@ -33,10 +33,16 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     @inject(WorkspaceService) protected readonly workspaceService: WorkspaceService;
     @inject(FileService) protected readonly fileService: FileService;
     @inject(OpenerService) protected readonly openerService: OpenerService;
+    @inject(ILogger) protected readonly logger: ILogger;
     protected readonly onDidChangeEmitter = new Emitter<void>();
     readonly onDidChange = this.onDidChangeEmitter.event;
 
-    protected getStorageLocation(): URI | undefined {
+    protected sanitizeLabel(label: string): string {
+        return label.replace(/^[^\p{L}\p{N}]+/vg, '');
+    }
+
+    protected async getStorageLocation(): Promise<URI | undefined> {
+        await this.workspaceService.ready;
         if (!this.workspaceService.opened) { return; }
         const values = this.preferenceService.inspect(TASK_CONTEXT_STORAGE_DIRECTORY_PREF);
         const configuredPath = values?.globalValue === undefined ? values?.defaultValue : values?.globalValue;
@@ -47,9 +53,11 @@ export class TaskContextFileStorageService implements TaskContextStorageService
 
     @postConstruct()
     protected init(): void {
-        this.watchStorage();
+        this.watchStorage().catch(error => this.logger.error(error));
         this.preferenceService.onPreferenceChanged(e => {
-            if (e.affects(TASK_CONTEXT_STORAGE_DIRECTORY_PREF)) { this.watchStorage(); }
+            if (e.affects(TASK_CONTEXT_STORAGE_DIRECTORY_PREF)) {
+                this.watchStorage().catch(error => this.logger.error(error));
+            }
         });
     }
 
@@ -57,7 +65,7 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     protected async watchStorage(): Promise<void> {
         this.toDisposeOnStorageChange?.dispose();
         this.toDisposeOnStorageChange = undefined;
-        const newStorage = this.getStorageLocation();
+        const newStorage = await this.getStorageLocation();
         if (!newStorage) { return; }
         this.toDisposeOnStorageChange = new DisposableCollection(
             this.fileService.watch(newStorage, { recursive: true, excludes: [] }),
@@ -109,10 +117,11 @@ export class TaskContextFileStorageService implements TaskContextStorageService
         const content = await this.fileService.read(uri).then(read => read.value).catch(() => undefined);
         if (content === undefined) { return; }
         const { frontmatter, body } = this.maybeReadFrontmatter(content);
+        const rawLabel = frontmatter?.label || uri.path.base.slice(0, (-1 * uri.path.ext.length) || uri.path.base.length);
         const summary = {
             ...frontmatter,
             summary: body,
-            label: frontmatter?.label || uri.path.base.slice(0, (-1 * uri.path.ext.length) || uri.path.base.length),
+            label: this.sanitizeLabel(rawLabel),
             uri,
             id: frontmatter?.sessionId || uri.path.base
         };
@@ -124,21 +133,22 @@ export class TaskContextFileStorageService implements TaskContextStorageService
     }
 
     async store(summary: Summary): Promise<void> {
-        const storageLocation = this.getStorageLocation();
+        const label = this.sanitizeLabel(summary.label);
+        const storageLocation = await this.getStorageLocation();
         if (storageLocation) {
             const frontmatter = {
                 sessionId: summary.sessionId,
                 date: new Date().toISOString(),
-                label: summary.label,
+                label,
             };
-            const derivedName = summary.label.trim().replace(/[^\p{L}\p{N}]/vg, '-').replace(/^-+|-+$/g, '');
+            const derivedName = label.trim().replace(/[^\p{L}\p{N}]/vg, '-').replace(/^-+|-+$/g, '');
             const filename = (derivedName.length > 32 ? derivedName.slice(0, derivedName.indexOf('-', 32)) : derivedName) + '.md';
             const content = yaml.dump(frontmatter).trim() + `${EOL}---${EOL}` + summary.summary;
             const uri = storageLocation.resolve(filename);
             summary.uri = uri;
             await this.fileService.writeFile(uri, BinaryBuffer.fromString(content));
         }
-        this.inMemoryStorage.store(summary);
+        this.inMemoryStorage.store({ ...summary, label });
         this.onDidChangeEmitter.fire();
     }
 

package/src/browser/workspace-functions.ts

@@ -157,27 +157,26 @@ export class GetWorkspaceDirectoryStructure implements ToolProvider {
     @inject(WorkspaceFunctionScope)
     protected workspaceScope: WorkspaceFunctionScope;
 
-    private async getDirectoryStructure(): Promise<string[]> {
+    private async getDirectoryStructure(): Promise<Record<string, unknown>> {
         let workspaceRoot;
         try {
             workspaceRoot = await this.workspaceScope.getWorkspaceRoot();
         } catch (error) {
-            return [`Error: ${error.message}`];
+            return { error: error.message };
         }
 
         return this.buildDirectoryStructure(workspaceRoot);
     }
 
-    private async buildDirectoryStructure(uri: URI, prefix: string = ''): Promise<string[]> {
+    private async buildDirectoryStructure(uri: URI): Promise<Record<string, unknown>> {
         const stat = await this.fileService.resolve(uri);
-        const result: string[] = [];
+        const result: Record<string, unknown> = {};
 
         if (stat && stat.isDirectory && stat.children) {
             for (const child of stat.children) {
                 if (!child.isDirectory || await this.workspaceScope.shouldExclude(child)) { continue; };
-                const path = `${prefix}${child.resource.path.base}/`;
-                result.push(path);
-                result.push(...await this.buildDirectoryStructure(child.resource, `${path}`));
+                const dirName = child.resource.path.base;
+                result[dirName] = await this.buildDirectoryStructure(child.resource);
             }
         }
 
@@ -323,10 +322,7 @@ export class GetWorkspaceFileList implements ToolProvider {
                     if (await this.workspaceScope.shouldExclude(child)) {
                         continue;
                     };
-                    const relativePath = workspaceRootUri.relative(child.resource);
-                    if (relativePath) {
-                        result.push(relativePath.toString());
-                    }
+                    result.push(child.resource.path.base);
                 }
             }
         }

package/src/browser/workspace-preferences.ts

@@ -19,6 +19,7 @@ import { PreferenceSchema } from '@theia/core/lib/browser/preferences/preference
 
 export const CONSIDER_GITIGNORE_PREF = 'ai-features.workspaceFunctions.considerGitIgnore';
 export const USER_EXCLUDE_PATTERN_PREF = 'ai-features.workspaceFunctions.userExcludes';
+export const SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF = 'ai-features.workspaceFunctions.searchMaxResults';
 export const PROMPT_TEMPLATE_WORKSPACE_DIRECTORIES_PREF = 'ai-features.promptTemplates.WorkspaceTemplateDirectories';
 export const PROMPT_TEMPLATE_ADDITIONAL_EXTENSIONS_PREF = 'ai-features.promptTemplates.TemplateExtensions';
 export const PROMPT_TEMPLATE_WORKSPACE_FILES_PREF = 'ai-features.promptTemplates.WorkspaceTemplateFiles';
@@ -46,6 +47,14 @@ export const WorkspacePreferencesSchema: PreferenceSchema = {
                 type: 'string'
             }
         },
+        [SEARCH_IN_WORKSPACE_MAX_RESULTS_PREF]: {
+            type: 'number',
+            title: nls.localize('theia/ai/workspace/searchMaxResults/title', 'Maximum Search Results'),
+            description: nls.localize('theia/ai/workspace/searchMaxResults/description',
+                'Maximum number of search results returned by the workspace search function.'),
+            default: 30,
+            minimum: 1
+        },
         [PROMPT_TEMPLATE_WORKSPACE_DIRECTORIES_PREF]: {
             type: 'array',
             title: nls.localize('theia/ai/promptTemplates/directories/title', 'Workspace-specific Prompt Template Directories'),

package/src/browser/workspace-search-provider.spec.ts

@@ -0,0 +1,255 @@
+// *****************************************************************************
+// 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 { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+FrontendApplicationConfigProvider.set({});
+
+import { expect } from 'chai';
+import { URI } from '@theia/core';
+import { SearchInWorkspaceResult, LinePreview } from '@theia/search-in-workspace/lib/common/search-in-workspace-interface';
+import { optimizeSearchResults } from '../common/workspace-search-provider-util';
+
+disableJSDOM();
+
+describe('WorkspaceSearchProvider - Token Optimization', () => {
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    describe('optimizeSearchResults method', () => {
+        it('should preserve all information while optimizing format', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/src/test.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 5,
+                            length: 8,
+                            lineText: '  const test = "hello";  '
+                        },
+                        {
+                            line: 5,
+                            character: 10,
+                            length: 4,
+                            lineText: '\t\tfunction test() { }\n'
+                        }
+                    ]
+                },
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/lib/utils.js',
+                    matches: [
+                        {
+                            line: 10,
+                            character: 0,
+                            length: 6,
+                            lineText: 'export default function() {}'
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result).to.have.length(2);
+
+            // First file
+            expect(result[0]).to.deep.equal({
+                file: 'src/test.ts',
+                matches: [
+                    {
+                        line: 1,
+                        text: 'const test = "hello";'
+                    },
+                    {
+                        line: 5,
+                        text: 'function test() { }'
+                    }
+                ]
+            });
+
+            // Second file
+            expect(result[1]).to.deep.equal({
+                file: 'lib/utils.js',
+                matches: [
+                    {
+                        line: 10,
+                        text: 'export default function() {}'
+                    }
+                ]
+            });
+        });
+
+        it('should handle LinePreview objects correctly', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const linePreview: LinePreview = {
+                text: '  preview text with spaces  ',
+                character: 5
+            };
+
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/preview.ts',
+                    matches: [
+                        {
+                            line: 3,
+                            character: 5,
+                            length: 7,
+                            lineText: linePreview
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0]).to.deep.equal({
+                line: 3,
+                text: 'preview text with spaces'
+            });
+        });
+
+        it('should handle empty LinePreview text gracefully', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const linePreview: LinePreview = {
+                text: '',
+                character: 0
+            };
+
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/empty.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 0,
+                            lineText: linePreview
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0]).to.deep.equal({
+                line: 1,
+                text: ''
+            });
+        });
+
+        it('should preserve semantic whitespace within lines', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/spaces.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 20,
+                            lineText: '  if (a    &&    b) {  '
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].matches[0].text).to.equal('if (a    &&    b) {');
+        });
+
+        it('should use absolute URI when relative path cannot be determined', () => {
+            const workspaceRoot = new URI('file:///different-workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/outside.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 0,
+                            length: 4,
+                            lineText: 'test'
+                        }
+                    ]
+                }
+            ];
+
+            const result = optimizeSearchResults(mockResults, workspaceRoot);
+
+            expect(result[0].file).to.equal('file:///workspace/outside.ts');
+        });
+    });
+
+    describe('token efficiency validation', () => {
+        it('should produce more compact JSON than original format', () => {
+            const workspaceRoot = new URI('file:///workspace');
+            const mockResults: SearchInWorkspaceResult[] = [
+                {
+                    root: 'file:///workspace',
+                    fileUri: 'file:///workspace/src/test.ts',
+                    matches: [
+                        {
+                            line: 1,
+                            character: 5,
+                            length: 8,
+                            lineText: '  const test = "hello";  '
+                        }
+                    ]
+                }
+            ];
+
+            // Original format (simulated)
+            const originalFormat = JSON.stringify([{
+                root: 'file:///workspace',
+                fileUri: 'file:///workspace/src/test.ts',
+                matches: [{
+                    line: 1,
+                    character: 5,
+                    length: 8,
+                    lineText: '  const test = "hello";  '
+                }]
+            }]);
+
+            // Optimized format
+            const optimizedResults = optimizeSearchResults(mockResults, workspaceRoot);
+            const optimizedFormat = JSON.stringify(optimizedResults);
+
+            // The optimized format should be significantly shorter
+            expect(optimizedFormat.length).to.be.lessThan(originalFormat.length);
+
+            // But should preserve essential information
+            const parsed = JSON.parse(optimizedFormat);
+            expect(parsed[0].file).to.equal('src/test.ts');
+            expect(parsed[0].matches[0].line).to.equal(1);
+            expect(parsed[0].matches[0].text).to.equal('const test = "hello";');
+        });
+    });
+});