@theia/ai-ide 1.66.2 → 1.67.0-next.13

package/src/browser/context-functions.spec.ts

@@ -22,7 +22,8 @@ import { ListChatContext, ResolveChatContext, AddFileToChatContext } from './con
 import { CancellationTokenSource } from '@theia/core';
 import { ChatContextManager, MutableChatModel, MutableChatRequestModel, MutableChatResponseModel } from '@theia/ai-chat';
 import { fail } from 'assert';
-import { ResolvedAIContextVariable } from '@theia/ai-core';
+import { AIVariableResolutionRequest, ResolvedAIContextVariable } from '@theia/ai-core';
+import { ContextFileValidationService, FileValidationState } from '@theia/ai-chat/lib/browser/context-file-validation-service';
 disableJSDOM();
 
 describe('Context Functions Cancellation Tests', () => {
@@ -100,3 +101,156 @@ describe('Context Functions Cancellation Tests', () => {
         expect(jsonResponse.error).to.equal('Operation cancelled by user');
     });
 });
+
+describe('AddFileToChatContext Validation Tests', () => {
+    let mockCtx: Partial<MutableChatRequestModel>;
+    let addedFiles: AIVariableResolutionRequest[];
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        addedFiles = [];
+        const context: Partial<ChatContextManager> = {
+            addVariables: (...vars: AIVariableResolutionRequest[]) => {
+                addedFiles.push(...vars);
+            },
+            getVariables: () => []
+        };
+        mockCtx = {
+            response: {
+                cancellationToken: new CancellationTokenSource().token
+            } as MutableChatResponseModel,
+            context: {
+                variables: []
+            },
+            session: {
+                context
+            } as MutableChatModel
+        };
+    });
+
+    it('should add valid files to context', async () => {
+        const mockValidationService: ContextFileValidationService = {
+            validateFile: async () => ({ state: FileValidationState.VALID })
+        };
+
+        const addFileToChatContext = new AddFileToChatContext();
+        (addFileToChatContext as unknown as { validationService: ContextFileValidationService }).validationService = mockValidationService;
+
+        const result = await addFileToChatContext.getTool().handler(
+            '{"filesToAdd":["/valid/file1.ts","/valid/file2.ts"]}',
+            mockCtx
+        );
+
+        if (typeof result !== 'string') {
+            fail(`Wrong tool call result type: ${result}`);
+        }
+
+        const jsonResponse = JSON.parse(result);
+        expect(jsonResponse.added).to.have.lengthOf(2);
+        expect(jsonResponse.added).to.include('/valid/file1.ts');
+        expect(jsonResponse.added).to.include('/valid/file2.ts');
+        expect(jsonResponse.rejected).to.have.lengthOf(0);
+        expect(jsonResponse.summary.totalRequested).to.equal(2);
+        expect(jsonResponse.summary.added).to.equal(2);
+        expect(jsonResponse.summary.rejected).to.equal(0);
+        expect(addedFiles).to.have.lengthOf(2);
+    });
+
+    it('should reject non-existent files', async () => {
+        const mockValidationService: ContextFileValidationService = {
+            validateFile: async file => {
+                if (file === '/nonexistent/file.ts') {
+                    return {
+                        state: FileValidationState.INVALID_NOT_FOUND,
+                        message: 'File does not exist'
+                    };
+                }
+                return { state: FileValidationState.VALID };
+            }
+        };
+
+        const addFileToChatContext = new AddFileToChatContext();
+        (addFileToChatContext as unknown as { validationService: ContextFileValidationService }).validationService = mockValidationService;
+
+        const result = await addFileToChatContext.getTool().handler(
+            '{"filesToAdd":["/valid/file.ts","/nonexistent/file.ts"]}',
+            mockCtx
+        );
+
+        if (typeof result !== 'string') {
+            fail(`Wrong tool call result type: ${result}`);
+        }
+
+        const jsonResponse = JSON.parse(result);
+        expect(jsonResponse.added).to.have.lengthOf(1);
+        expect(jsonResponse.added).to.include('/valid/file.ts');
+        expect(jsonResponse.rejected).to.have.lengthOf(1);
+        expect(jsonResponse.rejected[0].file).to.equal('/nonexistent/file.ts');
+        expect(jsonResponse.rejected[0].reason).to.equal('File does not exist');
+        expect(jsonResponse.rejected[0].state).to.equal(FileValidationState.INVALID_NOT_FOUND);
+        expect(jsonResponse.summary.totalRequested).to.equal(2);
+        expect(jsonResponse.summary.added).to.equal(1);
+        expect(jsonResponse.summary.rejected).to.equal(1);
+        expect(addedFiles).to.have.lengthOf(1);
+    });
+
+    it('should reject files in secondary workspace roots', async () => {
+        const mockValidationService: ContextFileValidationService = {
+            validateFile: async file => {
+                if (file === '/secondary/root/file.ts') {
+                    return {
+                        state: FileValidationState.INVALID_SECONDARY,
+                        message: 'File is in a secondary workspace root. AI agents can only access files in the first workspace root.'
+                    };
+                }
+                return { state: FileValidationState.VALID };
+            }
+        };
+
+        const addFileToChatContext = new AddFileToChatContext();
+        (addFileToChatContext as unknown as { validationService: ContextFileValidationService }).validationService = mockValidationService;
+
+        const result = await addFileToChatContext.getTool().handler(
+            '{"filesToAdd":["/secondary/root/file.ts"]}',
+            mockCtx
+        );
+
+        if (typeof result !== 'string') {
+            fail(`Wrong tool call result type: ${result}`);
+        }
+
+        const jsonResponse = JSON.parse(result);
+        expect(jsonResponse.added).to.have.lengthOf(0);
+        expect(jsonResponse.rejected).to.have.lengthOf(1);
+        expect(jsonResponse.rejected[0].file).to.equal('/secondary/root/file.ts');
+        expect(jsonResponse.rejected[0].state).to.equal(FileValidationState.INVALID_SECONDARY);
+        expect(addedFiles).to.have.lengthOf(0);
+    });
+
+    it('should add all files when validation service is not available', async () => {
+        const addFileToChatContext = new AddFileToChatContext();
+
+        const result = await addFileToChatContext.getTool().handler(
+            '{"filesToAdd":["/file1.ts","/file2.ts"]}',
+            mockCtx
+        );
+
+        if (typeof result !== 'string') {
+            fail(`Wrong tool call result type: ${result}`);
+        }
+
+        const jsonResponse = JSON.parse(result);
+        expect(jsonResponse.added).to.have.lengthOf(2);
+        expect(jsonResponse.rejected).to.have.lengthOf(0);
+        expect(jsonResponse.summary.totalRequested).to.equal(2);
+        expect(jsonResponse.summary.added).to.equal(2);
+        expect(jsonResponse.summary.rejected).to.equal(0);
+        expect(addedFiles).to.have.lengthOf(2);
+    });
+});

package/src/browser/context-functions.ts

@@ -16,9 +16,10 @@
 
 import { MutableChatRequestModel } from '@theia/ai-chat';
 import { ToolProvider, ToolRequest } from '@theia/ai-core';
-import { injectable } from '@theia/core/shared/inversify';
+import { inject, injectable, optional } from '@theia/core/shared/inversify';
 import { LIST_CHAT_CONTEXT_FUNCTION_ID, RESOLVE_CHAT_CONTEXT_FUNCTION_ID, UPDATE_CONTEXT_FILES_FUNCTION_ID } from '../common/context-functions';
 import { FILE_VARIABLE } from '@theia/ai-core/lib/browser/file-variable-contribution';
+import { ContextFileValidationService, FileValidationState } from '@theia/ai-chat/lib/browser/context-file-validation-service';
 
 @injectable()
 export class ListChatContext implements ToolProvider {
@@ -91,6 +92,9 @@ export class ResolveChatContext implements ToolProvider {
 export class AddFileToChatContext implements ToolProvider {
     static ID = UPDATE_CONTEXT_FILES_FUNCTION_ID;
 
+    @inject(ContextFileValidationService) @optional()
+    protected readonly validationService: ContextFileValidationService | undefined;
+
     getTool(): ToolRequest {
         return {
             id: AddFileToChatContext.ID,
@@ -106,7 +110,10 @@ export class AddFileToChatContext implements ToolProvider {
                 },
                 required: ['filesToAdd']
             },
-            description: 'Adds one or more files to the context of the current chat session, and returns the current list of files in the context.',
+            description: 'Adds one or more files to the context of the current chat session. ' +
+                'Only files that exist within the workspace boundaries will be added. ' +
+                'Files outside the workspace or non-existent files will be rejected. ' +
+                'Returns a detailed status for each file, including which were successfully added and which were rejected with reasons.',
             handler: async (arg: string, ctx: MutableChatRequestModel): Promise<string> => {
                 if (ctx?.response?.cancellationToken?.isCancellationRequested) {
                     return JSON.stringify({ error: 'Operation cancelled by user' });
@@ -114,11 +121,38 @@ export class AddFileToChatContext implements ToolProvider {
 
                 const { filesToAdd } = JSON.parse(arg) as { filesToAdd: string[] };
 
-                ctx.session.context.addVariables(...filesToAdd.map(file => ({ arg: file, variable: FILE_VARIABLE })));
-                const result = ctx.session.context.getVariables().filter(candidate => candidate.variable.id === FILE_VARIABLE.id && !!candidate.arg)
-                    .map(fileRequest => fileRequest.arg);
+                const added: string[] = [];
+                const rejected: Array<{ file: string; reason: string; state: string }> = [];
+
+                for (const file of filesToAdd) {
+                    if (this.validationService) {
+                        const validationResult = await this.validationService.validateFile(file);
+
+                        if (validationResult.state === FileValidationState.VALID) {
+                            ctx.session.context.addVariables({ arg: file, variable: FILE_VARIABLE });
+                            added.push(file);
+                        } else {
+                            rejected.push({
+                                file,
+                                reason: validationResult.message || 'File validation failed',
+                                state: validationResult.state
+                            });
+                        }
+                    } else {
+                        ctx.session.context.addVariables({ arg: file, variable: FILE_VARIABLE });
+                        added.push(file);
+                    }
+                }
 
-                return JSON.stringify(result);
+                return JSON.stringify({
+                    added,
+                    rejected,
+                    summary: {
+                        totalRequested: filesToAdd.length,
+                        added: added.length,
+                        rejected: rejected.length
+                    }
+                });
             }
         };
     }

package/src/browser/frontend-module.ts

@@ -96,6 +96,8 @@ import { AiConfigurationPreferences } from '../common/ai-configuration-preferenc
 import { TaskContextAgent } from './task-context-agent';
 import { ProjectInfoAgent } from './project-info-agent';
 import { SuggestTerminalCommand } from './ai-terminal-functions';
+import { ContextFileValidationService } from '@theia/ai-chat/lib/browser/context-file-validation-service';
+import { ContextFileValidationServiceImpl } from './context-file-validation-service-impl';
 
 export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
     bind(PreferenceContribution).toConstantValue({ schema: aiIdePreferenceSchema });
@@ -270,4 +272,7 @@ export default new ContainerModule((bind, _unbind, _isBound, rebind) => {
         .inSingletonScope();
 
     bindToolProvider(SuggestTerminalCommand, bind);
+
+    bind(ContextFileValidationServiceImpl).toSelf().inSingletonScope();
+    bind(ContextFileValidationService).toService(ContextFileValidationServiceImpl);
 });

package/src/browser/workspace-functions.ts

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { ToolProvider, ToolRequest } from '@theia/ai-core';
-import { CancellationToken, Disposable, PreferenceService, URI } from '@theia/core';
+import { CancellationToken, Disposable, PreferenceService, URI, Path } from '@theia/core';
 import { inject, injectable } from '@theia/core/shared/inversify';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileStat } from '@theia/filesystem/lib/common/files';
@@ -69,6 +69,73 @@ export class WorkspaceFunctionScope {
         return workspaceRoot.resolve(relativePath);
     }
 
+    isInWorkspace(uri: URI): boolean {
+        try {
+            const wsRoots = this.workspaceService.tryGetRoots();
+
+            if (wsRoots.length === 0) {
+                return false;
+            }
+
+            for (const root of wsRoots) {
+                const rootUri = root.resource;
+                if (rootUri.scheme === uri.scheme && rootUri.isEqualOrParent(uri)) {
+                    return true;
+                }
+            }
+
+            return false;
+        } catch {
+            return false;
+        }
+    }
+
+    isInPrimaryWorkspace(uri: URI): boolean {
+        try {
+            const wsRoots = this.workspaceService.tryGetRoots();
+
+            if (wsRoots.length === 0) {
+                return false;
+            }
+
+            const primaryRoot = wsRoots[0].resource;
+            return primaryRoot.scheme === uri.scheme && primaryRoot.isEqualOrParent(uri);
+        } catch {
+            return false;
+        }
+    }
+
+    async resolveToUri(pathOrUri: string | URI): Promise<URI | undefined> {
+        if (pathOrUri instanceof URI) {
+            return pathOrUri;
+        }
+
+        if (!pathOrUri) {
+            return undefined;
+        }
+
+        if (pathOrUri.includes('://')) {
+            try {
+                const uri = new URI(pathOrUri);
+                return uri;
+            } catch (error) {
+            }
+        }
+
+        const normalizedPath = Path.normalizePathSeparator(pathOrUri);
+        const path = new Path(normalizedPath);
+
+        if (normalizedPath.includes('..')) {
+            return undefined;
+        }
+
+        if (path.isAbsolute) {
+            return URI.fromFilePath(normalizedPath);
+        }
+
+        return this.resolveRelativePath(normalizedPath);
+    }
+
     private async initializeGitignoreWatcher(workspaceRoot: URI): Promise<void> {
         if (this.gitignoreWatcherInitialized) {
             return;