@vybestack/llxprt-code 0.8.0-nightly.260112.d9cf7fbc6 → 0.8.0-nightly.260113.48db4b09b

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

@@ -9,6 +9,7 @@ import { FileDiscoveryService, GlobTool, ReadManyFilesTool, StandardFileSystemSe
 import * as os from 'os';
 import { ToolCallStatus } from '../types.js';
 import * as fsPromises from 'fs/promises';
+import * as fs from 'fs';
 import * as path from 'path';
 // No mocking - use the real FileDiscoveryService
 describe('handleAtCommand', () => {
@@ -20,17 +21,29 @@ describe('handleAtCommand', () => {
     async function createTestFile(fullPath, fileContents) {
         await fsPromises.mkdir(path.dirname(fullPath), { recursive: true });
         await fsPromises.writeFile(fullPath, fileContents);
-        return path.resolve(testRootDir, fullPath);
+        return fs.realpathSync(fullPath);
     }
+    let originalCwd;
     beforeEach(async () => {
         vi.resetAllMocks();
         testRootDir = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'folder-structure-test-'));
+        originalCwd = process.cwd();
+        process.chdir(testRootDir);
         abortController = new AbortController();
         const getToolRegistry = vi.fn();
         mockConfig = {
             getToolRegistry,
             getTargetDir: () => testRootDir,
             isSandboxed: () => false,
+            getMessageBus: vi.fn(() => ({
+                subscribe: vi.fn(),
+                unsubscribe: vi.fn(),
+                publish: vi.fn(),
+                respondToConfirmation: vi.fn(),
+                requestConfirmation: vi.fn().mockResolvedValue(true),
+                removeAllListeners: vi.fn(),
+                listenerCount: vi.fn().mockReturnValue(0),
+            })),
             getFileService: () => new FileDiscoveryService(testRootDir),
             getFileFilteringRespectGitIgnore: () => true,
             getFileFilteringRespectLlxprtIgnore: () => true,
@@ -40,10 +53,31 @@ describe('handleAtCommand', () => {
             }),
             getFileSystemService: () => new StandardFileSystemService(),
             getEnableRecursiveFileSearch: vi.fn(() => true),
-            getWorkspaceContext: () => ({
-                isPathWithinWorkspace: () => true,
-                getDirectories: () => [testRootDir],
-            }),
+            getWorkspaceContext: () => {
+                const workspaceRoot = fs.realpathSync(testRootDir);
+                return {
+                    isPathWithinWorkspace: (inputPath) => {
+                        const absoluteInput = path.isAbsolute(inputPath)
+                            ? inputPath
+                            : path.resolve(testRootDir, inputPath);
+                        let resolved;
+                        try {
+                            resolved = fs.realpathSync(absoluteInput);
+                        }
+                        catch {
+                            if (absoluteInput.startsWith(testRootDir)) {
+                                resolved = path.resolve(workspaceRoot, path.relative(testRootDir, absoluteInput));
+                            }
+                            else {
+                                resolved = path.normalize(absoluteInput);
+                            }
+                        }
+                        return (resolved === workspaceRoot ||
+                            resolved.startsWith(workspaceRoot + path.sep));
+                    },
+                    getDirectories: () => [workspaceRoot],
+                };
+            },
             getEphemeralSettings: () => ({}), // No disabled tools
             getMcpServers: () => ({}),
             getMcpServerCommand: () => undefined,
@@ -67,6 +101,7 @@ describe('handleAtCommand', () => {
     });
     afterEach(async () => {
         abortController.abort();
+        process.chdir(originalCwd);
         await fsPromises.rm(testRootDir, { recursive: true, force: true });
     });
     it('should pass through query if no @ command is present', async () => {
@@ -110,7 +145,7 @@ describe('handleAtCommand', () => {
         const fileContent = 'This is the file content.';
         // Create file in the test directory
         const relativePath = path.join('path', 'to', 'file.txt');
-        const filePath = await createTestFile(path.join(testRootDir, relativePath), fileContent);
+        await createTestFile(path.join(testRootDir, relativePath), fileContent);
         // Use relative path in the query
         const query = `@${relativePath}`;
         const result = await handleAtCommand({
@@ -125,7 +160,7 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { 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 ---' },
             ],
@@ -141,7 +176,7 @@ describe('handleAtCommand', () => {
         const fileContent = 'This is the file content.';
         const relativeDirPath = path.join('path', 'to');
         const relativeFilePath = path.join(relativeDirPath, 'file.txt');
-        const filePath = await createTestFile(path.join(testRootDir, relativeFilePath), fileContent);
+        await createTestFile(path.join(testRootDir, relativeFilePath), fileContent);
         const query = `@${relativeDirPath}`;
         const resolvedGlob = `${relativeDirPath}/**`;
         const result = await handleAtCommand({
@@ -156,7 +191,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 ---' },
             ],
@@ -167,23 +202,23 @@ describe('handleAtCommand', () => {
     it('should handle query with text before and after @command', async () => {
         const fileContent = 'Markdown content.';
         const relativePath = 'doc.md';
-        const filePath = await createTestFile(path.join(testRootDir, relativePath), fileContent);
-        const textBefore = 'Explain this: ';
-        const textAfter = ' in detail.';
+        await createTestFile(path.join(testRootDir, relativePath), fileContent);
+        const textBefore = 'Please read ';
+        const textAfter = ' and summarize.';
         const query = `${textBefore}@${relativePath}${textAfter}`;
         const result = await handleAtCommand({
             query,
             config: mockConfig,
             addItem: mockAddItem,
             onDebugMessage: mockOnDebugMessage,
-            messageId: 128,
+            messageId: 127,
             signal: abortController.signal,
         });
         expect(result).toEqual({
             processedQuery: [
                 { 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,7 +228,7 @@ describe('handleAtCommand', () => {
     it('should correctly unescape paths with escaped spaces', async () => {
         const fileContent = 'This is the file content.';
         const relativePath = path.join('path', 'to', 'my file.txt');
-        const filePath = await createTestFile(path.join(testRootDir, relativePath), fileContent);
+        await createTestFile(path.join(testRootDir, relativePath), fileContent);
         const escapedPath = path.join('path', 'to', 'my\\ file.txt');
         const query = `@${escapedPath}`;
         const result = await handleAtCommand({
@@ -208,7 +243,7 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { 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 ---' },
             ],
@@ -223,10 +258,10 @@ describe('handleAtCommand', () => {
     it('should handle multiple @file references', async () => {
         const content1 = 'Content file1';
         const relativePath1 = 'file1.txt';
-        const file1Path = await createTestFile(path.join(testRootDir, relativePath1), content1);
+        await createTestFile(path.join(testRootDir, relativePath1), content1);
         const content2 = 'Content file2';
         const relativePath2 = 'file2.md';
-        const file2Path = await createTestFile(path.join(testRootDir, relativePath2), content2);
+        await createTestFile(path.join(testRootDir, relativePath2), content2);
         const query = `@${relativePath1} @${relativePath2}`;
         const result = await handleAtCommand({
             query,
@@ -240,9 +275,9 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { text: query },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${file1Path}:\n` },
+                { text: `\nContent from @${relativePath1}:\n` },
                 { text: content1 },
-                { text: `\nContent from @${file2Path}:\n` },
+                { text: `\nContent from @${relativePath2}:\n` },
                 { text: content2 },
                 { text: '\n--- End of content ---' },
             ],
@@ -253,11 +288,11 @@ describe('handleAtCommand', () => {
         const text1 = 'Check ';
         const content1 = 'C1';
         const relativePath1 = 'f1.txt';
-        const file1Path = await createTestFile(path.join(testRootDir, relativePath1), content1);
+        await createTestFile(path.join(testRootDir, relativePath1), content1);
         const text2 = ' and ';
         const content2 = 'C2';
         const relativePath2 = 'f2.md';
-        const file2Path = await createTestFile(path.join(testRootDir, relativePath2), content2);
+        await createTestFile(path.join(testRootDir, relativePath2), content2);
         const text3 = ' please.';
         const query = `${text1}@${relativePath1}${text2}@${relativePath2}${text3}`;
         const result = await handleAtCommand({
@@ -272,9 +307,9 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { text: query },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${file1Path}:\n` },
+                { text: `\nContent from @${relativePath1}:\n` },
                 { text: content1 },
-                { text: `\nContent from @${file2Path}:\n` },
+                { text: `\nContent from @${relativePath2}:\n` },
                 { text: content2 },
                 { text: '\n--- End of content ---' },
             ],
@@ -284,11 +319,11 @@ describe('handleAtCommand', () => {
     it('should handle a mix of valid, invalid, and lone @ references', async () => {
         const content1 = 'Valid content 1';
         const relativePath1 = 'valid1.txt';
-        const file1Path = await createTestFile(path.join(testRootDir, relativePath1), content1);
+        await createTestFile(path.join(testRootDir, relativePath1), content1);
         const invalidFile = 'nonexistent.txt';
         const content2 = 'Globbed content';
         const relativePath2 = path.join('resolved', 'valid2.actual');
-        const file2Path = await createTestFile(path.join(testRootDir, relativePath2), content2);
+        await createTestFile(path.join(testRootDir, relativePath2), content2);
         const query = `Look at @${relativePath1} then @${invalidFile} and also just @ symbol, then @${relativePath2}`;
         const result = await handleAtCommand({
             query,
@@ -309,9 +344,9 @@ describe('handleAtCommand', () => {
             .map((p) => p.text)
             .join('');
         expect(queryText).toContain('--- Content from referenced files ---');
-        expect(queryText).toContain(`Content from @${file1Path}:`);
+        expect(queryText).toContain(`Content from @${relativePath1}:`);
         expect(queryText).toContain(content1);
-        expect(queryText).toContain(`Content from @${file2Path}:`);
+        expect(queryText).toContain(`Content from @${relativePath2}:`);
         expect(queryText).toContain(content2);
         expect(queryText).toContain('--- End of content ---');
         expect(mockOnDebugMessage).toHaveBeenCalledWith(`Path ${invalidFile} not found directly, attempting glob search.`);
@@ -341,8 +376,8 @@ describe('handleAtCommand', () => {
         });
         it('should skip git-ignored files in @ commands', async () => {
             await createTestFile(path.join(testRootDir, '.gitignore'), 'node_modules/package.json');
-            const gitIgnoredFile = await createTestFile(path.join(testRootDir, 'node_modules', 'package.json'), 'the file contents');
-            const query = `@${gitIgnoredFile}`;
+            await createTestFile(path.join(testRootDir, 'node_modules', 'package.json'), 'the file contents');
+            const query = '@node_modules/package.json';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -355,13 +390,13 @@ describe('handleAtCommand', () => {
                 processedQuery: [{ text: query }],
                 shouldProceed: true,
             });
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Path ${gitIgnoredFile} is git-ignored and will be skipped.`);
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Ignored 1 files:\nGit-ignored: ${gitIgnoredFile}`);
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Path node_modules/package.json is git-ignored and will be skipped.');
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Ignored 1 files:\nGit-ignored: node_modules/package.json');
         });
         it('should process non-git-ignored files normally', async () => {
             await createTestFile(path.join(testRootDir, '.gitignore'), 'node_modules/package.json');
             const relativePath = path.join('src', 'index.ts');
-            const validFile = await createTestFile(path.join(testRootDir, relativePath), 'console.log("Hello world");');
+            await createTestFile(path.join(testRootDir, relativePath), 'console.log("Hello world");');
             const query = `@${relativePath}`;
             const result = await handleAtCommand({
                 query,
@@ -375,7 +410,7 @@ describe('handleAtCommand', () => {
                 processedQuery: [
                     { text: `@${relativePath}` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${validFile}:\n` },
+                    { text: `\nContent from @${relativePath}:\n` },
                     { text: 'console.log("Hello world");' },
                     { text: '\n--- End of content ---' },
                 ],
@@ -385,7 +420,7 @@ describe('handleAtCommand', () => {
         it('should handle mixed git-ignored and valid files', async () => {
             await createTestFile(path.join(testRootDir, '.gitignore'), '.env');
             const relativePath1 = 'README.md';
-            const validFile = await createTestFile(path.join(testRootDir, relativePath1), '# Project README');
+            await createTestFile(path.join(testRootDir, relativePath1), '# Project README');
             const relativePath2 = '.env';
             await createTestFile(path.join(testRootDir, relativePath2), 'SECRET=123');
             const query = `@${relativePath1} @${relativePath2}`;
@@ -401,7 +436,7 @@ describe('handleAtCommand', () => {
                 processedQuery: [
                     { text: `@${relativePath1} @${relativePath2}` },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${validFile}:\n` },
+                    { text: `\nContent from @${relativePath1}:\n` },
                     { text: '# Project README' },
                     { text: '\n--- End of content ---' },
                 ],
@@ -411,8 +446,8 @@ describe('handleAtCommand', () => {
             expect(mockOnDebugMessage).toHaveBeenCalledWith(`Ignored 1 files:\nGit-ignored: ${relativePath2}`);
         });
         it('should always ignore .git directory files', async () => {
-            const gitFile = await createTestFile(path.join(testRootDir, '.git', 'config'), '[core]\n\trepositoryformatversion = 0\n');
-            const query = `@${gitFile}`;
+            await createTestFile(path.join(testRootDir, '.git', 'config'), '[core]\n\trepositoryformatversion = 0\n');
+            const query = '@.git/config';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -425,8 +460,8 @@ describe('handleAtCommand', () => {
                 processedQuery: [{ text: query }],
                 shouldProceed: true,
             });
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Path ${gitFile} is git-ignored and will be skipped.`);
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Ignored 1 files:\nGit-ignored: ${gitFile}`);
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Path .git/config is git-ignored and will be skipped.');
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Ignored 1 files:\nGit-ignored: .git/config');
         });
     });
     describe('when recursive file search is disabled', () => {
@@ -452,8 +487,8 @@ describe('handleAtCommand', () => {
     describe('llxprt-ignore filtering', () => {
         it('should skip llxprt-ignored files in @ commands', async () => {
             await createTestFile(path.join(testRootDir, '.llxprtignore'), 'build/output.js');
-            const llxprtIgnoredFile = await createTestFile(path.join(testRootDir, 'build', 'output.js'), 'console.log("Hello");');
-            const query = `@${llxprtIgnoredFile}`;
+            await createTestFile(path.join(testRootDir, 'build', 'output.js'), 'console.log("Hello");');
+            const query = '@build/output.js';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -466,14 +501,14 @@ describe('handleAtCommand', () => {
                 processedQuery: [{ text: query }],
                 shouldProceed: true,
             });
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Path ${llxprtIgnoredFile} is llxprt-ignored and will be skipped.`);
-            expect(mockOnDebugMessage).toHaveBeenCalledWith(`Ignored 1 files:\nLlxprt-ignored: ${llxprtIgnoredFile}`);
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Path build/output.js is llxprt-ignored and will be skipped.');
+            expect(mockOnDebugMessage).toHaveBeenCalledWith('Ignored 1 files:\nLlxprt-ignored: build/output.js');
         });
     });
     it('should process non-ignored files when .geminiignore is present', async () => {
         await createTestFile(path.join(testRootDir, '.llxprtignore'), 'build/output.js');
         const relativePath = path.join('src', 'index.ts');
-        const validFile = await createTestFile(path.join(testRootDir, relativePath), 'console.log("Hello world");');
+        await createTestFile(path.join(testRootDir, relativePath), 'console.log("Hello world");');
         const query = `@${relativePath}`;
         const result = await handleAtCommand({
             query,
@@ -487,7 +522,7 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { text: `@${relativePath}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${validFile}:\n` },
+                { text: `\nContent from @${relativePath}:\n` },
                 { text: 'console.log("Hello world");' },
                 { text: '\n--- End of content ---' },
             ],
@@ -497,7 +532,7 @@ describe('handleAtCommand', () => {
     it('should handle mixed llxprt-ignored and valid files', async () => {
         await createTestFile(path.join(testRootDir, '.llxprtignore'), 'dist/bundle.js');
         const relativePath1 = path.join('src', 'main.ts');
-        const validFile = await createTestFile(path.join(testRootDir, relativePath1), '// Main application entry');
+        await createTestFile(path.join(testRootDir, relativePath1), '// Main application entry');
         const relativePath2 = path.join('dist', 'bundle.js');
         await createTestFile(path.join(testRootDir, relativePath2), 'console.log("bundle");');
         const query = `@${relativePath1} @${relativePath2}`;
@@ -513,7 +548,7 @@ describe('handleAtCommand', () => {
             processedQuery: [
                 { text: `@${relativePath1} @${relativePath2}` },
                 { text: '\n--- Content from referenced files ---' },
-                { text: `\nContent from @${validFile}:\n` },
+                { text: `\nContent from @${relativePath1}:\n` },
                 { text: '// Main application entry' },
                 { text: '\n--- End of content ---' },
             ],
@@ -603,8 +638,8 @@ describe('handleAtCommand', () => {
             },
         ];
         it.each(punctuationTestCases)('should terminate @path at $name', async ({ fileName, fileContent, queryTemplate, messageId }) => {
-            const filePath = await createTestFile(path.join(testRootDir, fileName), fileContent);
-            const query = queryTemplate(filePath);
+            await createTestFile(path.join(testRootDir, fileName), fileContent);
+            const query = queryTemplate(fileName);
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -613,11 +648,12 @@ describe('handleAtCommand', () => {
                 messageId,
                 signal: abortController.signal,
             });
+            const fileInQuery = fileName;
             expect(result).toEqual({
                 processedQuery: [
                     { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: `\nContent from @${fileInQuery}:\n` },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -626,10 +662,10 @@ describe('handleAtCommand', () => {
         });
         it('should handle multiple @paths terminated by different punctuation', async () => {
             const content1 = 'First file';
-            const file1Path = await createTestFile(path.join(testRootDir, 'first.txt'), content1);
+            await createTestFile(path.join(testRootDir, 'first.txt'), content1);
             const content2 = 'Second file';
-            const file2Path = await createTestFile(path.join(testRootDir, 'second.txt'), content2);
-            const query = `Compare @${file1Path}, @${file2Path}; what's different?`;
+            await createTestFile(path.join(testRootDir, 'second.txt'), content2);
+            const query = "Compare @first.txt, @second.txt; what's different?";
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -640,11 +676,11 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Compare @${file1Path}, @${file2Path}; what's different?` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${file1Path}:\n` },
+                    { text: '\nContent from @first.txt:\n' },
                     { text: content1 },
-                    { text: `\nContent from @${file2Path}:\n` },
+                    { text: '\nContent from @second.txt:\n' },
                     { text: content2 },
                     { text: '\n--- End of content ---' },
                 ],
@@ -653,8 +689,8 @@ describe('handleAtCommand', () => {
         });
         it('should still handle escaped spaces in paths before punctuation', async () => {
             const fileContent = 'Spaced file content';
-            const filePath = await createTestFile(path.join(testRootDir, 'spaced file.txt'), fileContent);
-            const escapedPath = path.join(testRootDir, 'spaced\\ file.txt');
+            await createTestFile(path.join(testRootDir, 'spaced file.txt'), fileContent);
+            const escapedPath = path.join('spaced\\ file.txt');
             const query = `Check @${escapedPath}, it has spaces.`;
             const result = await handleAtCommand({
                 query,
@@ -666,9 +702,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath}, it has spaces.` },
+                    { text: 'Check @spaced file.txt, it has spaces.' },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @spaced file.txt:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -677,8 +713,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'example.d.ts'), fileContent);
+            const query = 'Analyze @example.d.ts for type definitions.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -689,9 +725,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Analyze @${filePath} for type definitions.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @example.d.ts:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -700,8 +736,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'config.json'), fileContent);
+            const query = 'Check @config.json. This file contains settings.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -712,9 +748,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath}. This file contains settings.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @config.json:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -723,8 +759,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'package.json'), fileContent);
+            const query = 'Review @package.json, then check dependencies.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -735,9 +771,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Review @${filePath}, then check dependencies.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @package.json:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -746,8 +782,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'version.1.2.3.txt'), fileContent);
+            const query = 'Check @version.1.2.3.txt contains version information.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -758,9 +794,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} contains version information.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @version.1.2.3.txt:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -769,8 +805,8 @@ 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}.`;
+            await createTestFile(path.join(testRootDir, 'end.txt'), fileContent);
+            const query = 'Show me @end.txt.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -781,9 +817,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Show me @${filePath}.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @end.txt:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -792,8 +828,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'file$with&special#chars.txt'), fileContent);
+            const query = 'Check @file$with&special#chars.txt for content.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -804,9 +840,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} for content.` },
+                    { text: 'Check @file$with&special#chars.txt for content.' },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @file$with&special#chars.txt:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -815,8 +851,8 @@ 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.`;
+            await createTestFile(path.join(testRootDir, 'basicfile.txt'), fileContent);
+            const query = 'Check @basicfile.txt please.';
             const result = await handleAtCommand({
                 query,
                 config: mockConfig,
@@ -827,9 +863,9 @@ describe('handleAtCommand', () => {
             });
             expect(result).toEqual({
                 processedQuery: [
-                    { text: `Check @${filePath} please.` },
+                    { text: query },
                     { text: '\n--- Content from referenced files ---' },
-                    { text: `\nContent from @${filePath}:\n` },
+                    { text: '\nContent from @basicfile.txt:\n' },
                     { text: fileContent },
                     { text: '\n--- End of content ---' },
                 ],
@@ -840,8 +876,8 @@ describe('handleAtCommand', () => {
     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}`;
+        await createTestFile(path.join(testRootDir, 'path', 'to', 'another-file.txt'), fileContent);
+        const query = 'A query with @path/to/another-file.txt';
         // Act
         await handleAtCommand({
             query,