@google/gemini-cli 0.12.0-preview.0 → 0.13.0-nightly.20251030.42c79c64

package/dist/src/ui/hooks/atCommandProcessor.test.js

@@ -23,6 +23,9 @@ describe('handleAtCommand', () => {
         await fsPromises.writeFile(fullPath, fileContents);
         return path.resolve(testRootDir, fullPath);
     }
+    function getRelativePath(absolutePath) {
+        return path.relative(testRootDir, absolutePath);
+    }
     beforeEach(async () => {
         vi.resetAllMocks();
         testRootDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'folder-structure-test-'));
@@ -103,6 +106,7 @@ describe('handleAtCommand', () => {
     it('should process a valid text file path', async () => {
         const fileContent = 'This is the file content.';
         const filePath = await createTestFile(path.join(testRootDir, 'path', 'to', 'file.txt'), fileContent);
+        const relativePath = getRelativePath(filePath);
         const query = `@${filePath}`;
         const result = await handleAtCommand({
             query,
@@ -114,9 +118,9 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: `@${filePath}` },
+                { text: `@${relativePath}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${filePath}:\n` },
+                { text: `\nContent from @${relativePath}:\n` },
                 { text: fileContent },
                 { text: '\n--- End of content ---' },
             ],
@@ -131,8 +135,10 @@ describe('handleAtCommand', () => {
         const fileContent = 'This is the file content.';
         const filePath = await createTestFile(path.join(testRootDir, 'path', 'to', 'file.txt'), fileContent);
         const dirPath = path.dirname(filePath);
+        const relativeDirPath = getRelativePath(dirPath);
+        const relativeFilePath = getRelativePath(filePath);
         const query = `@${dirPath}`;
-        const resolvedGlob = `${dirPath}/**`;
+        const resolvedGlob = path.join(relativeDirPath, '**');
         const result = await handleAtCommand({
             query,
             config: mockConfig,
@@ -145,7 +151,7 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { text: `@${resolvedGlob}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${filePath}:\n` },
+                { text: `\nContent from @${relativeFilePath}:\n` },
                 { text: fileContent },
                 { text: '\n--- End of content ---' },
             ],
@@ -156,6 +162,7 @@ describe('handleAtCommand', () => {
     it('should handle query with text before and after @command', async () => {
         const fileContent = 'Markdown content.';
         const filePath = await createTestFile(path.join(testRootDir, 'doc.md'), fileContent);
+        const relativePath = getRelativePath(filePath);
         const textBefore = 'Explain this: ';
         const textAfter = ' in detail.';
         const query = `${textBefore}@${filePath}${textAfter}`;
@@ -169,9 +176,9 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: `${textBefore}@${filePath}${textAfter}` },
+                { text: `${textBefore}@${relativePath}${textAfter}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${filePath}:\n` },
+                { text: `\nContent from @${relativePath}:\n` },
                 { text: fileContent },
                 { text: '\n--- End of content ---' },
             ],
@@ -193,9 +200,9 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: `@${filePath}` },
+                { text: `@${getRelativePath(filePath)}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${filePath}:\n` },
+                { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                 { text: fileContent },
                 { text: '\n--- End of content ---' },
             ],
@@ -222,11 +229,13 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: query },
+                {
+                    text: `@${getRelativePath(file1Path)} @${getRelativePath(file2Path)}`,
+                },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${file1Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file1Path)}:\n` },
                 { text: content1 },
-                { text: `\nContent from @${file2Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file2Path)}:\n` },
                 { text: content2 },
                 { text: '\n--- End of content ---' },
             ],
@@ -252,11 +261,13 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: query },
+                {
+                    text: `${text1}@${getRelativePath(file1Path)}${text2}@${getRelativePath(file2Path)}${text3}`,
+                },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${file1Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file1Path)}:\n` },
                 { text: content1 },
-                { text: `\nContent from @${file2Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file2Path)}:\n` },
                 { text: content2 },
                 { text: '\n--- End of content ---' },
             ],
@@ -281,12 +292,12 @@ describe('handleAtCommand', () => {
         expect(result).toEqual({
             processedQuery: [
                 {
-                    text: `Look at @${file1Path} then @${invalidFile} and also just @ symbol, then @${file2Path}`,
+                    text: `Look at @${getRelativePath(file1Path)} then @${invalidFile} and also just @ symbol, then @${getRelativePath(file2Path)}`,
                 },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${file2Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file2Path)}:\n` },
                 { text: content2 },
-                { text: `\nContent from @${file1Path}:\n` },
+                { text: `\nContent from @${getRelativePath(file1Path)}:\n` },
                 { text: content1 },
                 { text: '\n--- End of content ---' },
             ],
@@ -350,9 +361,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `@${validFile}` },
+                    { text: `@${getRelativePath(validFile)}` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${validFile}:\n` },
+                    { text: `\nContent from @${getRelativePath(validFile)}:\n` },
                     { text: 'console.log("Hello world");' },
                     { text: '\n--- End of content ---' },
                 ],
@@ -374,9 +385,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `@${validFile} @${gitIgnoredFile}` },
+                    { text: `@${getRelativePath(validFile)} @${gitIgnoredFile}` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${validFile}:\n` },
+                    { text: `\nContent from @${getRelativePath(validFile)}:\n` },
                     { text: '# Project README' },
                     { text: '\n--- End of content ---' },
                 ],
@@ -459,9 +470,9 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: `@${validFile}` },
+                { text: `@${getRelativePath(validFile)}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${validFile}:\n` },
+                { text: `\nContent from @${getRelativePath(validFile)}:\n` },
                 { text: 'console.log("Hello world");' },
                 { text: '\n--- End of content ---' },
             ],
@@ -483,9 +494,9 @@ describe('handleAtCommand', () => {
         });
         expect(result).toEqual({
             processedQuery: [
-                { text: `@${validFile} @${geminiIgnoredFile}` },
+                { text: `@${getRelativePath(validFile)} @${geminiIgnoredFile}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${validFile}:\n` },
+                { text: `\nContent from @${getRelativePath(validFile)}:\n` },
                 { text: '// Main application entry' },
                 { text: '\n--- End of content ---' },
             ],
@@ -500,77 +511,77 @@ describe('handleAtCommand', () => {
                 name: 'comma',
                 fileName: 'test.txt',
                 fileContent: 'File content here',
-                queryTemplate: (filePath) => `Look at @${filePath}, then explain it.`,
+                queryTemplate: (filePath) => `Look at @${getRelativePath(filePath)}, then explain it.`,
                 messageId: 400,
             },
             {
                 name: 'period',
                 fileName: 'readme.md',
                 fileContent: 'File content here',
-                queryTemplate: (filePath) => `Check @${filePath}. What does it say?`,
+                queryTemplate: (filePath) => `Check @${getRelativePath(filePath)}. What does it say?`,
                 messageId: 401,
             },
             {
                 name: 'semicolon',
                 fileName: 'example.js',
                 fileContent: 'Code example',
-                queryTemplate: (filePath) => `Review @${filePath}; check for bugs.`,
+                queryTemplate: (filePath) => `Review @${getRelativePath(filePath)}; check for bugs.`,
                 messageId: 402,
             },
             {
                 name: 'exclamation mark',
                 fileName: 'important.txt',
                 fileContent: 'Important content',
-                queryTemplate: (filePath) => `Look at @${filePath}! This is critical.`,
+                queryTemplate: (filePath) => `Look at @${getRelativePath(filePath)}! This is critical.`,
                 messageId: 403,
             },
             {
                 name: 'question mark',
                 fileName: 'config.json',
                 fileContent: 'Config settings',
-                queryTemplate: (filePath) => `What is in @${filePath}? Please explain.`,
+                queryTemplate: (filePath) => `What is in @${getRelativePath(filePath)}? Please explain.`,
                 messageId: 404,
             },
             {
                 name: 'opening parenthesis',
                 fileName: 'func.ts',
                 fileContent: 'Function definition',
-                queryTemplate: (filePath) => `Analyze @${filePath}(the main function).`,
+                queryTemplate: (filePath) => `Analyze @${getRelativePath(filePath)}(the main function).`,
                 messageId: 405,
             },
             {
                 name: 'closing parenthesis',
                 fileName: 'data.json',
                 fileContent: 'Test data',
-                queryTemplate: (filePath) => `Use data from @${filePath}) for testing.`,
+                queryTemplate: (filePath) => `Use data from @${getRelativePath(filePath)}) for testing.`,
                 messageId: 406,
             },
             {
                 name: 'opening square bracket',
                 fileName: 'array.js',
                 fileContent: 'Array data',
-                queryTemplate: (filePath) => `Check @${filePath}[0] for the first element.`,
+                queryTemplate: (filePath) => `Check @${getRelativePath(filePath)}[0] for the first element.`,
                 messageId: 407,
             },
             {
                 name: 'closing square bracket',
                 fileName: 'list.md',
                 fileContent: 'List content',
-                queryTemplate: (filePath) => `Review item @${filePath}] from the list.`,
+                queryTemplate: (filePath) => `Review item @${getRelativePath(filePath)}] from the list.`,
                 messageId: 408,
             },
             {
                 name: 'opening curly brace',
                 fileName: 'object.ts',
                 fileContent: 'Object definition',
-                queryTemplate: (filePath) => `Parse @${filePath}{prop1: value1}.`,
+                queryTemplate: (filePath) => `Parse @${getRelativePath(filePath)}{prop1: value1}.`,
                 messageId: 409,
             },
             {
                 name: 'closing curly brace',
                 fileName: 'config.yaml',
                 fileContent: 'Configuration',
-                queryTemplate: (filePath) => `Use settings from @${filePath}} for deployment.`,
+                queryTemplate: (filePath) => `Use settings from @${getRelativePath(filePath)}} for deployment.`,
                 messageId: 410,
             },
         ];
@@ -589,7 +600,7 @@ describe('handleAtCommand', () => {
                 processedQuery: [
                     { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -612,11 +623,13 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Compare @${file1Path}, @${file2Path}; what's different?` },
+                    {
+                        text: `Compare @${getRelativePath(file1Path)}, @${getRelativePath(file2Path)}; what's different?`,
+                    },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${file1Path}:\n` },
+                    { text: `\nContent from @${getRelativePath(file1Path)}:\n` },
                     { text: content1 },
-                    { text: `\nContent from @${file2Path}:\n` },
+                    { text: `\nContent from @${getRelativePath(file2Path)}:\n` },
                     { text: content2 },
                     { text: '\n--- End of content ---' },
                 ],
@@ -638,9 +651,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath}, it has spaces.` },
+                    { text: `Check @${getRelativePath(filePath)}, it has spaces.` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -650,7 +663,7 @@ describe('handleAtCommand', () => {
         it('should not break file paths with periods in extensions', async () => {
             const fileContent = 'TypeScript content';
             const filePath = await createTestFile(path.join(testRootDir, 'example.d.ts'), fileContent);
-            const query = `Analyze @${filePath} for type definitions.`;
+            const query = `Analyze @${getRelativePath(filePath)} for type definitions.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -661,9 +674,11 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Analyze @${filePath} for type definitions.` },
+                    {
+                        text: `Analyze @${getRelativePath(filePath)} for type definitions.`,
+                    },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -673,7 +688,7 @@ describe('handleAtCommand', () => {
         it('should handle file paths ending with period followed by space', async () => {
             const fileContent = 'Config content';
             const filePath = await createTestFile(path.join(testRootDir, 'config.json'), fileContent);
-            const query = `Check @${filePath}. This file contains settings.`;
+            const query = `Check @${getRelativePath(filePath)}. This file contains settings.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -684,9 +699,11 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath}. This file contains settings.` },
+                    {
+                        text: `Check @${getRelativePath(filePath)}. This file contains settings.`,
+                    },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -696,7 +713,7 @@ describe('handleAtCommand', () => {
         it('should handle comma termination with complex file paths', async () => {
             const fileContent = 'Package info';
             const filePath = await createTestFile(path.join(testRootDir, 'package.json'), fileContent);
-            const query = `Review @${filePath}, then check dependencies.`;
+            const query = `Review @${getRelativePath(filePath)}, then check dependencies.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -707,9 +724,11 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Review @${filePath}, then check dependencies.` },
+                    {
+                        text: `Review @${getRelativePath(filePath)}, then check dependencies.`,
+                    },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -719,7 +738,7 @@ describe('handleAtCommand', () => {
         it('should not terminate at period within file name', async () => {
             const fileContent = 'Version info';
             const filePath = await createTestFile(path.join(testRootDir, 'version.1.2.3.txt'), fileContent);
-            const query = `Check @${filePath} contains version information.`;
+            const query = `Check @${getRelativePath(filePath)} contains version information.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -730,9 +749,11 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} contains version information.` },
+                    {
+                        text: `Check @${getRelativePath(filePath)} contains version information.`,
+                    },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -742,7 +763,7 @@ describe('handleAtCommand', () => {
         it('should handle end of string termination for period and comma', async () => {
             const fileContent = 'End file content';
             const filePath = await createTestFile(path.join(testRootDir, 'end.txt'), fileContent);
-            const query = `Show me @${filePath}.`;
+            const query = `Show me @${getRelativePath(filePath)}.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -753,9 +774,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Show me @${filePath}.` },
+                    { text: `Show me @${getRelativePath(filePath)}.` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -765,7 +786,7 @@ describe('handleAtCommand', () => {
         it('should handle files with special characters in names', async () => {
             const fileContent = 'File with special chars content';
             const filePath = await createTestFile(path.join(testRootDir, 'file$with&special#chars.txt'), fileContent);
-            const query = `Check @${filePath} for content.`;
+            const query = `Check @${getRelativePath(filePath)} for content.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -776,9 +797,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} for content.` },
+                    { text: `Check @${getRelativePath(filePath)} for content.` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -788,7 +809,7 @@ describe('handleAtCommand', () => {
         it('should handle basic file names without special characters', async () => {
             const fileContent = 'Basic file content';
             const filePath = await createTestFile(path.join(testRootDir, 'basicfile.txt'), fileContent);
-            const query = `Check @${filePath} please.`;
+            const query = `Check @${getRelativePath(filePath)} please.`;
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -799,21 +820,98 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} please.` },
+                    { text: `Check @${getRelativePath(filePath)} please.` },
+                    { text: '\n--- Content from referenced files ---' },
+                    { text: `\nContent from @${getRelativePath(filePath)}:\n` },
+                    { text: fileContent },
+                    { text: '\n--- End of content ---' },
+                ],
+                shouldProceed: true,
+            });
+        });
+    });
+    describe('absolute path handling', () => {
+        it('should handle absolute file paths correctly', async () => {
+            const fileContent = 'console.log("This is an absolute path test");';
+            const relativePath = path.join('src', 'absolute-test.ts');
+            const absolutePath = await createTestFile(path.join(testRootDir, relativePath), fileContent);
+            const query = `Check @${absolutePath} please.`;
+            const result = await handleAtCommand({
+                query,
+                config: mockConfig,
+                addItem: mockAddItem,
+                onDebugMessage: mockOnDebugMessage,
+                messageId: 500,
+                signal: abortController.signal,
+            });
+            expect(result).toEqual({
+                processedQuery: [
+                    { text: `Check @${relativePath} please.` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${relativePath}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
                 shouldProceed: true,
             });
+            expect(mockOnDebugMessage).toHaveBeenCalledWith(expect.stringContaining(`using relative path: ${relativePath}`));
+        });
+        it('should handle absolute directory paths correctly', async () => {
+            const fileContent = 'export default function test() { return "absolute dir test"; }';
+            const subDirPath = path.join('src', 'utils');
+            const fileName = 'helper.ts';
+            await createTestFile(path.join(testRootDir, subDirPath, fileName), fileContent);
+            const absoluteDirPath = path.join(testRootDir, subDirPath);
+            const query = `Check @${absoluteDirPath} please.`;
+            const result = await handleAtCommand({
+                query,
+                config: mockConfig,
+                addItem: mockAddItem,
+                onDebugMessage: mockOnDebugMessage,
+                messageId: 501,
+                signal: abortController.signal,
+            });
+            expect(result.shouldProceed).toBe(true);
+            expect(result.processedQuery).toEqual(expect.arrayContaining([
+                { text: `Check @${path.join(subDirPath, '**')} please.` },
+                expect.objectContaining({
+                    text: '\n--- Content from referenced files ---',
+                }),
+            ]));
+            expect(mockOnDebugMessage).toHaveBeenCalledWith(expect.stringContaining(`using glob: ${path.join(subDirPath, '**')}`));
+        });
+        it('should skip absolute paths outside workspace', async () => {
+            const outsidePath = '/tmp/outside-workspace.txt';
+            const query = `Check @${outsidePath} please.`;
+            const mockWorkspaceContext = {
+                isPathWithinWorkspace: vi.fn((path) => path.startsWith(testRootDir)),
+                getDirectories: () => [testRootDir],
+                addDirectory: vi.fn(),
+                getInitialDirectories: () => [testRootDir],
+                setDirectories: vi.fn(),
+                onDirectoriesChanged: vi.fn(() => () => { }),
+            };
+            mockConfig.getWorkspaceContext = () => mockWorkspaceContext;
+            const result = await handleAtCommand({
+                query,
+                config: mockConfig,
+                addItem: mockAddItem,
+                onDebugMessage: mockOnDebugMessage,
+                messageId: 502,
+                signal: abortController.signal,
+            });
+            expect(result).toEqual({
+                processedQuery: [{ text: `Check @${outsidePath} please.` }],
+                shouldProceed: true,
+            });
+            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Path ${outsidePath} is not in the workspace and will be skipped.`);
         });
     });
     it("should not add the user's turn to history, as that is the caller's responsibility", async () => {
         // Arrange
         const fileContent = 'This is the file content.';
         const filePath = await createTestFile(path.join(testRootDir, 'path', 'to', 'another-file.txt'), fileContent);
-        const query = `A query with @${filePath}`;
+        const query = `A query with @${getRelativePath(filePath)}`;
         // Act
         await handleAtCommand({
             query,