@theia/ai-ide 1.64.0-next.35 → 1.64.0

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

@@ -14,242 +14,92 @@
 // 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();
+import { CancellationTokenSource } from '@theia/core';
+import { WorkspaceSearchProvider } from './workspace-search-provider';
+import { MutableChatRequestModel, MutableChatResponseModel } from '@theia/ai-chat';
+import { Container } from '@theia/core/shared/inversify';
+import { SearchInWorkspaceService, SearchInWorkspaceCallbacks } from '@theia/search-in-workspace/lib/browser/search-in-workspace-service';
+import { WorkspaceFunctionScope } from './workspace-functions';
+import { PreferenceService } from '@theia/core/lib/browser';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { URI } from '@theia/core/lib/common/uri';
+import { SearchInWorkspaceOptions } from '@theia/search-in-workspace/lib/common/search-in-workspace-interface';
+
+describe('Workspace Search Provider Cancellation Tests', () => {
+    let cancellationTokenSource: CancellationTokenSource;
+    let mockCtx: Partial<MutableChatRequestModel>;
+    let container: Container;
+    let searchService: SearchInWorkspaceService;
+
+    beforeEach(() => {
+        cancellationTokenSource = new CancellationTokenSource();
+
+        // Setup mock context
+        mockCtx = {
+            response: {
+                cancellationToken: cancellationTokenSource.token
+            } as MutableChatResponseModel
+        };
+
+        // Create a new container for each test
+        container = new Container();
+
+        // Mock dependencies
+        searchService = {
+            searchWithCallback: async (
+                query: string,
+                rootUris: string[],
+                callbacks: SearchInWorkspaceCallbacks,
+                options: SearchInWorkspaceOptions
+            ) => {
+                const searchId = 1;
+                return searchId;
+            },
+            cancel: (searchId: number) => {
+                // Mock cancellation
+            }
+        } as unknown as SearchInWorkspaceService;
+
+        const mockWorkspaceScope = {
+            getWorkspaceRoot: async () => new URI('file:///workspace'),
+            ensureWithinWorkspace: () => { },
+            resolveRelativePath: async (path: string) => new URI(`file:///workspace/${path}`)
+        } as unknown as WorkspaceFunctionScope;
+
+        const mockPreferenceService = {
+            get: () => 30
+        };
+
+        const mockFileService = {
+            exists: async () => true,
+            resolve: async () => ({ isDirectory: true })
+        } as unknown as FileService;
+
+        // Register mocks in the container
+        container.bind(SearchInWorkspaceService).toConstantValue(searchService);
+        container.bind(WorkspaceFunctionScope).toConstantValue(mockWorkspaceScope);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(WorkspaceSearchProvider).toSelf();
     });
 
-    after(() => {
-        disableJSDOM();
+    afterEach(() => {
+        cancellationTokenSource.dispose();
     });
 
-    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
-            };
+    it('should respect cancellation token at the beginning of the search', async () => {
+        const searchProvider = container.get(WorkspaceSearchProvider);
+        cancellationTokenSource.cancel();
 
-            const mockResults: SearchInWorkspaceResult[] = [
-                {
-                    root: 'file:///workspace',
-                    fileUri: 'file:///workspace/empty.ts',
-                    matches: [
-                        {
-                            line: 1,
-                            character: 0,
-                            length: 0,
-                            lineText: linePreview
-                        }
-                    ]
-                }
-            ];
+        const handler = searchProvider.getTool().handler;
+        const result = await handler(
+            JSON.stringify({ query: 'test', useRegExp: false }),
+            mockCtx as MutableChatRequestModel
+        );
 
-            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');
-        });
+        const jsonResponse = JSON.parse(result as string);
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
     });
 
-    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";');
-        });
-    });
 });

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

@@ -111,6 +111,16 @@ export class WorkspaceSearchProvider implements ToolProvider {
             let expectedSearchId: number | undefined;
             let searchCompleted = false;
 
+            cancellationToken?.onCancellationRequested(() => {
+                if (expectedSearchId !== undefined && !searchCompleted) {
+                    this.searchService.cancel(expectedSearchId);
+                    searchCompleted = true;
+                }
+            });
+            if (cancellationToken?.isCancellationRequested) {
+                return JSON.stringify({ error: 'Operation cancelled by user' });
+            }
+
             const searchPromise = new Promise<SearchInWorkspaceResult[]>(async (resolve, reject) => {
                 const callbacks: SearchInWorkspaceCallbacks = {
                     onResult: (id, result) => {
@@ -167,7 +177,6 @@ export class WorkspaceSearchProvider implements ToolProvider {
                         searchCompleted = true;
                         reject(err);
                     });
-
             });
 
             const timeoutPromise = new Promise<SearchInWorkspaceResult[]>((_, reject) => {

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

@@ -0,0 +1,125 @@
+// *****************************************************************************
+// 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 { expect } from 'chai';
+import { CancellationTokenSource } from '@theia/core';
+import { TaskListProvider, TaskRunnerProvider } from './workspace-task-provider';
+import { MutableChatRequestModel, MutableChatResponseModel } from '@theia/ai-chat';
+import { Container } from '@theia/core/shared/inversify';
+import { TaskService } from '@theia/task/lib/browser/task-service';
+import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
+import { TaskConfiguration, TaskInfo } from '@theia/task/lib/common';
+import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
+
+describe('Workspace Task Provider Cancellation Tests', () => {
+    let cancellationTokenSource: CancellationTokenSource;
+    let mockCtx: Partial<MutableChatRequestModel>;
+    let container: Container;
+    let mockTaskService: TaskService;
+    let mockTerminalService: TerminalService;
+
+    beforeEach(() => {
+        cancellationTokenSource = new CancellationTokenSource();
+
+        // Setup mock context
+        mockCtx = {
+            response: {
+                cancellationToken: cancellationTokenSource.token
+            } as MutableChatResponseModel
+        };
+
+        // Create a new container for each test
+        container = new Container();
+
+        // Mock dependencies
+        mockTaskService = {
+            startUserAction: () => 123,
+            getTasks: async (token: number) => [
+                {
+                    label: 'build',
+                    _scope: 'workspace',
+                    type: 'shell'
+                } as TaskConfiguration,
+                {
+                    label: 'test',
+                    _scope: 'workspace',
+                    type: 'shell'
+                } as TaskConfiguration
+            ],
+            runTaskByLabel: async (token: number, taskLabel: string) => {
+                if (taskLabel === 'build' || taskLabel === 'test') {
+                    return {
+                        taskId: 0,
+                        terminalId: 0,
+                        config: {
+                            label: taskLabel,
+                            _scope: 'workspace',
+                            type: 'shell'
+                        }
+                    } as TaskInfo;
+                }
+                return undefined;
+            },
+            terminateTask: async (activeTaskInfo: TaskInfo) => {
+                // Track termination
+            },
+            getTerminateSignal: async () => 'SIGTERM'
+        } as unknown as TaskService;
+
+        mockTerminalService = {
+            getByTerminalId: () => ({
+                buffer: {
+                    length: 10,
+                    getLines: () => ['line1', 'line2', 'line3'],
+                },
+                clearOutput: () => { }
+            } as unknown as TerminalWidget)
+        } as unknown as TerminalService;
+
+        // Register mocks in the container
+        container.bind(TaskService).toConstantValue(mockTaskService);
+        container.bind(TerminalService).toConstantValue(mockTerminalService);
+        container.bind(TaskListProvider).toSelf();
+        container.bind(TaskRunnerProvider).toSelf();
+    });
+
+    afterEach(() => {
+        cancellationTokenSource.dispose();
+    });
+
+    it('TaskListProvider should respect cancellation token', async () => {
+        const taskListProvider = container.get(TaskListProvider);
+        cancellationTokenSource.cancel();
+
+        const handler = taskListProvider.getTool().handler;
+        const result = await handler(JSON.stringify({ filter: '' }), mockCtx as MutableChatRequestModel);
+
+        const jsonResponse = JSON.parse(result as string);
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
+    });
+
+    it('TaskRunnerProvider should respect cancellation token at the beginning', async () => {
+        const taskRunnerProvider = container.get(TaskRunnerProvider);
+        cancellationTokenSource.cancel();
+
+        const handler = taskRunnerProvider.getTool().handler;
+        const result = await handler(JSON.stringify({ taskName: 'build' }), mockCtx as MutableChatRequestModel);
+
+        const jsonResponse = JSON.parse(result as string);
+        expect(jsonResponse.error).to.equal('Operation cancelled by user');
+    });
+
+});

package/src/browser/workspace-task-provider.ts

@@ -43,7 +43,10 @@ export class TaskListProvider implements ToolProvider {
                 },
                 required: ['filter']
             },
-            handler: async (argString: string) => {
+            handler: async (argString: string, ctx: MutableChatRequestModel) => {
+                if (ctx?.response?.cancellationToken?.isCancellationRequested) {
+                    return JSON.stringify({ error: 'Operation cancelled by user' });
+                }
                 const filterArgs: { filter: string } = JSON.parse(argString);
                 const tasks = await this.getAvailableTasks(filterArgs.filter);
                 const taskString = JSON.stringify(tasks);
@@ -101,7 +104,9 @@ export class TaskRunnerProvider implements ToolProvider {
             cancellationToken?.onCancellationRequested(() => {
                 this.taskService.terminateTask(taskInfo);
             });
-
+            if (cancellationToken?.isCancellationRequested) {
+                return JSON.stringify({ error: 'Operation cancelled by user' });
+            }
             const signal = await this.taskService.getTerminateSignal(taskInfo.taskId);
             if (taskInfo.terminalId) {
                 const terminal = this.terminalService.getByTerminalId(taskInfo.terminalId!);

package/src/common/architect-prompt-template.ts

@@ -109,6 +109,7 @@ Skip irrelevant information, e.g. for discussions, only sum up the final result.
 2. Identify the main coding objective and requirements.
 3. Propose a clear approach to implement the requested functionality in task steps.
 4. If any part of the task is ambiguous, note the ambiguity so that it can be clarified later.
+5. If there are any relevant examples on how to implement something correctly, add them
 
 Focus on providing actionable steps and implementation guidance. The coding agent needs practical help with this specific coding task.
 
@@ -144,6 +145,16 @@ Use the following format, but only include the sections that were discussed in t
 **Technology Choices:**  
 - [Frameworks, libraries, services, tools]
 
+**Files expected to be changed**
+List all files that are expected to be changed (using relative file path) and quickly explain what is expected to be changed in this file.
+
+### Examples
+
+List all examples of existing code that are useful to understand the design and do the implementation.
+These examples are not the files supposed to be changed, but code that shows how to implement specific things.
+Prefer to mention files instead of adding their content.
+Explain the purpose of every example.
+
 ---
 
 ## 3. 🧪 Testing

package/src/common/command-chat-agents.ts

@@ -51,7 +51,7 @@ export class CommandChatAgent extends AbstractTextToModelParsingChatAgent<Parsed
     name = 'Command';
     languageModelRequirements: LanguageModelRequirement[] = [{
         purpose: 'command',
-        identifier: 'openai/gpt-4o',
+        identifier: 'default/universal',
     }];
     protected defaultLanguageModelPurpose: string = 'command';
 

package/src/common/orchestrator-chat-agent.ts

@@ -32,7 +32,7 @@ export class OrchestratorChatAgent extends AbstractStreamParsingChatAgent {
     name = OrchestratorChatAgentId;
     languageModelRequirements: LanguageModelRequirement[] = [{
         purpose: 'agent-selection',
-        identifier: 'openai/gpt-4o',
+        identifier: 'default/universal',
     }];
     protected defaultLanguageModelPurpose: string = 'agent-selection';
 

package/src/common/universal-chat-agent.ts

@@ -27,7 +27,7 @@ export class UniversalChatAgent extends AbstractStreamParsingChatAgent {
    name = UniversalChatAgentId;
    languageModelRequirements: LanguageModelRequirement[] = [{
       purpose: 'chat',
-      identifier: 'openai/gpt-4o',
+      identifier: 'default/universal',
    }];
    protected defaultLanguageModelPurpose: string = 'chat';
    override description = nls.localize('theia/ai/chat/universal/description', 'This agent is designed to help software developers by providing concise and accurate '

package/src/common/workspace-functions.ts

@@ -20,3 +20,6 @@ export const GET_FILE_DIAGNOSTICS_ID = 'getFileDiagnostics';
 export const SEARCH_IN_WORKSPACE_FUNCTION_ID = 'searchInWorkspace';
 export const LIST_TASKS_FUNCTION_ID = 'listTasks';
 export const RUN_TASK_FUNCTION_ID = 'runTask';
+export const LIST_LAUNCH_CONFIGURATIONS_FUNCTION_ID = 'listLaunchConfigurations';
+export const RUN_LAUNCH_CONFIGURATION_FUNCTION_ID = 'runLaunchConfiguration';
+export const STOP_LAUNCH_CONFIGURATION_FUNCTION_ID = 'stopLaunchConfiguration';