@theia/ai-ide 1.70.0-next.21 → 1.70.0-next.26

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

@@ -32,6 +32,7 @@ import {
 import { ToolInvocationContext } from '@theia/ai-core';
 import { Container } from '@theia/core/shared/inversify';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { FileOperationError, FileOperationResult } from '@theia/filesystem/lib/common/files';
 import { URI } from '@theia/core/lib/common/uri';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { ProblemManager } from '@theia/markers/lib/browser';
@@ -254,6 +255,420 @@ describe('FileContentFunction.getArgumentsShortLabel', () => {
         const result = getArgumentsShortLabel(JSON.stringify({ path: 'src/index.ts' }));
         expect(result).to.be.undefined;
     });
+
+    it('returns hasMore true when offset is provided', () => {
+        const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', offset: 10 }));
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+    });
+
+    it('returns hasMore true when limit is provided', () => {
+        const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', limit: 50 }));
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+    });
+
+    it('returns hasMore true when both offset and limit are provided', () => {
+        const result = getArgumentsShortLabel(JSON.stringify({ file: 'src/index.ts', offset: 10, limit: 50 }));
+        expect(result).to.deep.equal({ label: 'src/index.ts', hasMore: true });
+    });
+});
+
+describe('FileContentFunction handler', () => {
+    let container: Container;
+    let fileContentFunction: FileContentFunction;
+    // Mutable delegates — tests reassign these directly instead of casting the mock object.
+    let mockResolve: () => Promise<unknown>;
+    let mockRead: () => Promise<unknown>;
+    let mockReadStream: () => Promise<unknown>;
+    let mockMonacoWorkspace: MonacoWorkspace;
+    let mockPreferenceService: { get: <T>(path: string, defaultValue: T) => T };
+
+    const makeMockStream = (content: string) => {
+        const handlers: Record<string, Function> = {};
+        // Use setTimeout so the macro-task fires after all pending microtasks
+        // (including the await continuation that registers the listeners).
+        setTimeout(() => {
+            handlers['data']?.(content);
+            handlers['end']?.();
+        }, 0);
+        return {
+            on(event: string, cb: Function): void { handlers[event] = cb; },
+            pause(): void { },
+            resume(): void { },
+            destroy(): void { },
+            removeListener(): void { }
+        };
+    };
+
+    let disableJSDOMInner: () => void;
+    before(() => {
+        disableJSDOMInner = enableJSDOM();
+    });
+    after(() => {
+        disableJSDOMInner();
+    });
+
+    beforeEach(() => {
+        container = new Container();
+
+        const mockWorkspaceService = {
+            roots: [{ resource: new URI('file:///workspace') }]
+        } as unknown as WorkspaceService;
+
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: 1024,
+            resource: new URI('file:///workspace/test.txt')
+        });
+
+        mockRead = async () => ({ value: 'line1\nline2\nline3\nline4\nline5' });
+
+        mockReadStream = async () => ({ value: makeMockStream('line1\nline2\nline3\nline4\nline5') });
+
+        // The mock object is stable across a test; individual methods delegate to
+        // the mutable variables above so tests can substitute behaviour without
+        // the fragile `(obj as unknown as {…}).method = …` double-cast pattern.
+        const mockFileService = {
+            exists: async () => true,
+            resolve: () => mockResolve(),
+            read: () => mockRead(),
+            readStream: () => mockReadStream(),
+        } as unknown as FileService;
+
+        mockPreferenceService = {
+            get: <T>(_path: string, defaultValue: T) => defaultValue
+        };
+
+        mockMonacoWorkspace = {
+            getTextDocument: () => undefined
+        } as unknown as MonacoWorkspace;
+
+        container.bind(WorkspaceService).toConstantValue(mockWorkspaceService);
+        container.bind(FileService).toConstantValue(mockFileService);
+        container.bind(PreferenceService).toConstantValue(mockPreferenceService);
+        container.bind(MonacoWorkspace).toConstantValue(mockMonacoWorkspace);
+        container.bind(WorkspaceFunctionScope).toSelf();
+        container.bind(FileContentFunction).toSelf();
+
+        fileContentFunction = container.get(FileContentFunction);
+    });
+
+    it('returns file content when file is within size limit', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
+        expect(result).to.equal('line1\nline2\nline3\nline4\nline5');
+    });
+
+    it('rejects without reading when on-disk size exceeds limit', async () => {
+        // Stat reports 512 KB; default limit is 256 KB
+        let readCalled = false;
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: 512 * 1024,
+            resource: new URI('file:///workspace/big.txt')
+        });
+        mockRead = async () => {
+            readCalled = true;
+            return { value: 'should not be read' };
+        };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'big.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.sizeKB).to.equal(512);
+        expect(readCalled).to.be.false;
+    });
+
+    it('returns editor content when file is open in editor and within size limit', async () => {
+        let resolveCalled = false;
+        mockResolve = async () => {
+            resolveCalled = true;
+            return { isFile: true, isDirectory: false, size: 1024, resource: new URI('file:///workspace/open.txt') };
+        };
+        mockMonacoWorkspace.getTextDocument = () => ({
+            getText: () => 'editor content'
+        } as unknown as ReturnType<MonacoWorkspace['getTextDocument']>);
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'open.txt' }), undefined);
+
+        expect(result).to.equal('editor content');
+        expect(resolveCalled).to.be.false;
+    });
+
+    it('rejects editor content when it exceeds the size limit', async () => {
+        const bigContent = 'x'.repeat(512 * 1024);
+        mockMonacoWorkspace.getTextDocument = () => ({
+            getText: () => bigContent
+        } as unknown as ReturnType<MonacoWorkspace['getTextDocument']>);
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'open.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.sizeKB).to.equal(512);
+    });
+
+    it('returns sliced content with header when offset and limit are provided', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: 1, limit: 2 }), undefined);
+
+        expect(result).to.include('[Lines 2\u20133 of 5 total.');
+        expect(result).to.include('line2\nline3');
+    });
+
+    it('returns sliced editor content with header when file is open and offset/limit are provided', async () => {
+        mockMonacoWorkspace.getTextDocument = () => ({
+            getText: () => 'alpha\nbeta\ngamma\ndelta\nepsilon'
+        } as unknown as ReturnType<MonacoWorkspace['getTextDocument']>);
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'open.txt', offset: 1, limit: 2 }), undefined);
+
+        expect(result).to.include('[Lines 2\u20133 of 5 total.');
+        expect(result).to.include('beta\ngamma');
+    });
+
+    it('does not call resolve() or read() for paginated disk reads, uses readStream instead', async () => {
+        // Stat would report huge file, but the streaming path bypasses both stat and read
+        let resolveCalled = false;
+        let readCalled = false;
+        mockResolve = async () => {
+            resolveCalled = true;
+            return {
+                isFile: true,
+                isDirectory: false,
+                size: 512 * 1024,
+                resource: new URI('file:///workspace/big.txt')
+            };
+        };
+        mockRead = async () => {
+            readCalled = true;
+            return { value: 'should not be read' };
+        };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 3 }), undefined);
+
+        // resolve and read are NOT called in the streaming path
+        expect(resolveCalled).to.be.false;
+        expect(readCalled).to.be.false;
+        expect(result).to.include('line1\nline2\nline3');
+    });
+
+    it('rejects when the requested slice itself exceeds the size limit', async () => {
+        const bigLine = 'x'.repeat(1024);
+        const bigContent = Array.from({ length: 300 }, () => bigLine).join('\n');
+        mockReadStream = async () => ({ value: makeMockStream(bigContent) });
+
+        const handler = fileContentFunction.getTool().handler;
+        // Reading all 300 lines × 1 KB each = ~300 KB, over the 256 KB default limit
+        const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 300 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.resultSizeKB).to.be.greaterThan(256);
+    });
+
+    it('returns File not found error when file does not exist', async () => {
+        mockResolve = async () => { throw new Error('File not found'); };
+        mockRead = async () => { throw new Error('File not found'); };
+        mockReadStream = async () => { throw new Error('File not found'); };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'nonexistent.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.equal('File not found');
+    });
+
+    it('rejects negative offset', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: -1 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('non-negative integer');
+    });
+
+    it('rejects fractional offset', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: 1.5 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('non-negative integer');
+    });
+
+    it('rejects negative limit', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', limit: -1 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('positive integer');
+    });
+
+    it('rejects zero limit', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', limit: 0 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('positive integer');
+    });
+
+    it('returns content from offset to end when only offset is provided', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: 2 }), undefined);
+
+        expect(result).to.include('[Lines 3\u20135 of 5 total.');
+        expect(result).to.include('line3\nline4\nline5');
+    });
+
+    it('returns last line when offset is at boundary', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: 4, limit: 1 }), undefined);
+
+        expect(result).to.include('[Lines 5\u20135 of 5 total.');
+        expect(result).to.include('line5');
+    });
+
+    it('returns empty content when offset is beyond end of file', async () => {
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt', offset: 100, limit: 5 }), undefined);
+
+        // slice beyond end returns empty array → empty joined string
+        expect(result).to.include('[Lines 101\u2013100 of 5 total.');
+    });
+
+    it('uses custom preference value for size limit', async () => {
+        // Set a very small limit of 1 KB
+        mockPreferenceService.get = <T>(_path: string, _defaultValue: T) => 1 as unknown as T;
+
+        const content = 'x'.repeat(2 * 1024); // 2 KB
+        mockRead = async () => ({ value: content });
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: 2 * 1024,
+            resource: new URI('file:///workspace/test.txt')
+        });
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.maxSizeKB).to.equal(1);
+    });
+
+    it('falls back to streaming when stat.size is undefined and file is within limit', async () => {
+        // stat does not include a size — the code must not treat this as "0 KB"
+        // but instead stream the file and succeed when content is small.
+        let readCalled = false;
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: undefined,
+            resource: new URI('file:///workspace/test.txt')
+        });
+        mockRead = async () => {
+            readCalled = true;
+            return { value: 'should not be used' };
+        };
+        // mockReadStream already returns the small 5-line fixture from beforeEach
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
+
+        expect(readCalled).to.be.false;
+        expect(result).to.include('line1');
+        // Full-file streaming fallback must NOT include the [Lines...] header
+        expect(result).to.not.include('[Lines');
+    });
+
+    it('returns size-limit error (not "File not found") when stat.size is undefined and streamed content exceeds limit', async () => {
+        // stat does not include a size; the streamed content is larger than the limit.
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: undefined,
+            resource: new URI('file:///workspace/big.txt')
+        });
+        const bigLine = 'x'.repeat(1024);
+        const bigContent = Array.from({ length: 300 }, () => bigLine).join('\n'); // ~300 KB
+        mockReadStream = async () => ({ value: makeMockStream(bigContent) });
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'big.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.error).not.to.equal('File not found');
+    });
+
+    it('returns size-limit error (not "File not found") when fileService.read throws FILE_TOO_LARGE', async () => {
+        // Simulate a file system provider that enforces its own hard size limit below maxSizeKB.
+        // stat.size is present and within our configured limit, but read() still throws.
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: 100 * 1024, // 100 KB — under the 256 KB default limit
+            resource: new URI('file:///workspace/test.txt')
+        });
+        mockRead = async () => {
+            throw new FileOperationError('File too large', FileOperationResult.FILE_TOO_LARGE);
+        };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.maxSizeKB).to.equal(256);
+    });
+
+    it('returns size-limit error (not "File not found") when fileService.read throws FILE_EXCEEDS_MEMORY_LIMIT', async () => {
+        mockResolve = async () => ({
+            isFile: true,
+            isDirectory: false,
+            size: 100 * 1024,
+            resource: new URI('file:///workspace/test.txt')
+        });
+        mockRead = async () => {
+            throw new FileOperationError('Exceeds memory limit', FileOperationResult.FILE_EXCEEDS_MEMORY_LIMIT);
+        };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'test.txt' }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.maxSizeKB).to.equal(256);
+    });
+
+    it('returns size-limit error (not "File not found") when readStream throws FILE_TOO_LARGE for paginated read', async () => {
+        // This is the key scenario: files.maxFileSizeMB is lower than the file size,
+        // but the caller is trying to read a chunk with offset/limit.
+        // Before the fix, readStream would throw FILE_TOO_LARGE and the catch block
+        // would return "File not found".
+        mockReadStream = async () => {
+            throw new FileOperationError('File too large', FileOperationResult.FILE_TOO_LARGE);
+        };
+
+        const handler = fileContentFunction.getTool().handler;
+        const result = await handler(JSON.stringify({ file: 'big.txt', offset: 0, limit: 50 }), undefined);
+
+        const parsed = JSON.parse(result as string);
+        expect(parsed.error).to.include('size limit');
+        expect(parsed.error).to.include('offset');
+        expect(parsed.error).not.to.equal('File not found');
+        expect(parsed.maxSizeKB).to.equal(256);
+    });
 });
 
 describe('FindFilesByPattern.getArgumentsShortLabel', () => {