@hibanacloud/core 0.3.15

package/dist/src/tools/glob.js

@@ -0,0 +1,190 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { glob, escape } from 'glob';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind } from './tools.js';
+import { ToolNames, ToolDisplayNames } from './tool-names.js';
+import { resolveAndValidatePath } from '../utils/paths.js';
+import {} from '../config/config.js';
+import { DEFAULT_FILE_FILTERING_OPTIONS, } from '../config/constants.js';
+import { ToolErrorType } from './tool-error.js';
+import { getErrorMessage } from '../utils/errors.js';
+const MAX_FILE_COUNT = 100;
+/**
+ * Sorts file entries based on recency and then alphabetically.
+ * Recent files (modified within recencyThresholdMs) are listed first, newest to oldest.
+ * Older files are listed after recent ones, sorted alphabetically by path.
+ */
+export function sortFileEntries(entries, nowTimestamp, recencyThresholdMs) {
+    const sortedEntries = [...entries];
+    sortedEntries.sort((a, b) => {
+        const mtimeA = a.mtimeMs ?? 0;
+        const mtimeB = b.mtimeMs ?? 0;
+        const aIsRecent = nowTimestamp - mtimeA < recencyThresholdMs;
+        const bIsRecent = nowTimestamp - mtimeB < recencyThresholdMs;
+        if (aIsRecent && bIsRecent) {
+            return mtimeB - mtimeA;
+        }
+        else if (aIsRecent) {
+            return -1;
+        }
+        else if (bIsRecent) {
+            return 1;
+        }
+        else {
+            return a.fullpath().localeCompare(b.fullpath());
+        }
+    });
+    return sortedEntries;
+}
+class GlobToolInvocation extends BaseToolInvocation {
+    config;
+    fileService;
+    constructor(config, params) {
+        super(params);
+        this.config = config;
+        this.fileService = config.getFileService();
+    }
+    getDescription() {
+        let description = `'${this.params.pattern}'`;
+        if (this.params.path) {
+            description += ` in path '${this.params.path}'`;
+        }
+        return description;
+    }
+    async execute(signal) {
+        try {
+            // Default to target directory if no path is provided
+            const searchDirAbs = resolveAndValidatePath(this.config, this.params.path);
+            const searchLocationDescription = this.params.path
+                ? `within ${searchDirAbs}`
+                : `in the workspace directory`;
+            // Collect entries from the search directory
+            let pattern = this.params.pattern;
+            const fullPath = path.join(searchDirAbs, pattern);
+            if (fs.existsSync(fullPath)) {
+                pattern = escape(pattern);
+            }
+            const allEntries = (await glob(pattern, {
+                cwd: searchDirAbs,
+                withFileTypes: true,
+                nodir: true,
+                stat: true,
+                nocase: true,
+                dot: true,
+                follow: false,
+                signal,
+            }));
+            const relativePaths = allEntries.map((p) => path.relative(this.config.getTargetDir(), p.fullpath()));
+            const { filteredPaths } = this.fileService.filterFilesWithReport(relativePaths, this.getFileFilteringOptions());
+            const filteredAbsolutePaths = new Set(filteredPaths.map((p) => path.resolve(this.config.getTargetDir(), p)));
+            const filteredEntries = allEntries.filter((entry) => filteredAbsolutePaths.has(entry.fullpath()));
+            if (!filteredEntries || filteredEntries.length === 0) {
+                return {
+                    llmContent: `No files found matching pattern "${this.params.pattern}" ${searchLocationDescription}`,
+                    returnDisplay: `No files found`,
+                };
+            }
+            // Set filtering such that we first show the most recent files
+            const oneDayInMs = 24 * 60 * 60 * 1000;
+            const nowTimestamp = new Date().getTime();
+            // Sort the filtered entries using the new helper function
+            const sortedEntries = sortFileEntries(filteredEntries, nowTimestamp, oneDayInMs);
+            const totalFileCount = sortedEntries.length;
+            const fileLimit = Math.min(MAX_FILE_COUNT, this.config.getTruncateToolOutputLines());
+            const truncated = totalFileCount > fileLimit;
+            // Limit to fileLimit if needed
+            const entriesToShow = truncated
+                ? sortedEntries.slice(0, fileLimit)
+                : sortedEntries;
+            const sortedAbsolutePaths = entriesToShow.map((entry) => entry.fullpath());
+            const fileListDescription = sortedAbsolutePaths.join('\n');
+            let resultMessage = `Found ${totalFileCount} file(s) matching "${this.params.pattern}" ${searchLocationDescription}`;
+            resultMessage += `, sorted by modification time (newest first):\n---\n${fileListDescription}`;
+            // Add truncation notice if needed
+            if (truncated) {
+                const omittedFiles = totalFileCount - fileLimit;
+                const fileTerm = omittedFiles === 1 ? 'file' : 'files';
+                resultMessage += `\n---\n[${omittedFiles} ${fileTerm} truncated] ...`;
+            }
+            return {
+                llmContent: resultMessage,
+                returnDisplay: `Found ${totalFileCount} matching file(s)${truncated ? ' (truncated)' : ''}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error(`GlobLogic execute Error: ${errorMessage}`, error);
+            const rawError = `Error during glob search operation: ${errorMessage}`;
+            return {
+                llmContent: rawError,
+                returnDisplay: `Error: ${errorMessage || 'An unexpected error occurred.'}`,
+                error: {
+                    message: rawError,
+                    type: ToolErrorType.GLOB_EXECUTION_ERROR,
+                },
+            };
+        }
+    }
+    getFileFilteringOptions() {
+        const options = this.config.getFileFilteringOptions?.();
+        return {
+            respectGitIgnore: options?.respectGitIgnore ??
+                DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
+            respectQwenIgnore: options?.respectQwenIgnore ??
+                DEFAULT_FILE_FILTERING_OPTIONS.respectQwenIgnore,
+        };
+    }
+}
+/**
+ * Implementation of the Glob tool logic
+ */
+export class GlobTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.GLOB;
+    constructor(config) {
+        super(GlobTool.Name, ToolDisplayNames.GLOB, 'Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like "**/*.js" or "src/**/*.ts"\n- Returns matching file paths sorted by modification time\n- Use this tool when you need to find files by name patterns\n- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.', Kind.Search, {
+            properties: {
+                pattern: {
+                    description: 'The glob pattern to match files against',
+                    type: 'string',
+                },
+                path: {
+                    description: 'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+                    type: 'string',
+                },
+            },
+            required: ['pattern'],
+            type: 'object',
+        });
+        this.config = config;
+    }
+    /**
+     * Validates the parameters for the tool.
+     */
+    validateToolParamValues(params) {
+        if (!params.pattern ||
+            typeof params.pattern !== 'string' ||
+            params.pattern.trim() === '') {
+            return "The 'pattern' parameter cannot be empty.";
+        }
+        // Only validate path if one is provided
+        if (params.path) {
+            try {
+                resolveAndValidatePath(this.config, params.path);
+            }
+            catch (error) {
+                return getErrorMessage(error);
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new GlobToolInvocation(this.config, params);
+    }
+}
+//# sourceMappingURL=glob.js.map

package/dist/src/tools/glob.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glob.js","sourceRoot":"","sources":["../../../src/tools/glob.ts"],"names":[],"mappings":"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"}

package/dist/src/tools/glob.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export {};

package/dist/src/tools/glob.test.js

@@ -0,0 +1,442 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { GlobTool, sortFileEntries } from './glob.js';
+import { partListUnionToString } from '../core/geminiRequest.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
+import { createMockWorkspaceContext } from '../test-utils/mockWorkspaceContext.js';
+import { ToolErrorType } from './tool-error.js';
+import * as glob from 'glob';
+vi.mock('glob', { spy: true });
+describe('GlobTool', () => {
+    let tempRootDir; // This will be the rootDirectory for the GlobTool instance
+    let globTool;
+    const abortSignal = new AbortController().signal;
+    // Mock config for testing
+    const mockConfig = {
+        getFileService: () => new FileDiscoveryService(tempRootDir),
+        getFileFilteringRespectGitIgnore: () => true,
+        getFileFilteringOptions: () => ({
+            respectGitIgnore: true,
+            respectQwenIgnore: true,
+        }),
+        getTargetDir: () => tempRootDir,
+        getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
+        getFileExclusions: () => ({
+            getGlobExcludes: () => [],
+        }),
+        getTruncateToolOutputLines: () => 1000,
+    };
+    beforeEach(async () => {
+        // Create a unique root directory for each test run
+        tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'glob-tool-root-'));
+        await fs.writeFile(path.join(tempRootDir, '.git'), ''); // Fake git repo
+        globTool = new GlobTool(mockConfig);
+        // Create some test files and directories within this root
+        // Top-level files
+        await fs.writeFile(path.join(tempRootDir, 'fileA.txt'), 'contentA');
+        await fs.writeFile(path.join(tempRootDir, 'FileB.TXT'), 'contentB'); // Different case for testing
+        // Subdirectory and files within it
+        await fs.mkdir(path.join(tempRootDir, 'sub'));
+        await fs.writeFile(path.join(tempRootDir, 'sub', 'fileC.md'), 'contentC');
+        await fs.writeFile(path.join(tempRootDir, 'sub', 'FileD.MD'), 'contentD'); // Different case
+        // Deeper subdirectory
+        await fs.mkdir(path.join(tempRootDir, 'sub', 'deep'));
+        await fs.writeFile(path.join(tempRootDir, 'sub', 'deep', 'fileE.log'), 'contentE');
+        // Files for mtime sorting test
+        await fs.writeFile(path.join(tempRootDir, 'older.sortme'), 'older_content');
+        // Ensure a noticeable difference in modification time
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        await fs.writeFile(path.join(tempRootDir, 'newer.sortme'), 'newer_content');
+        // For type coercion testing
+        await fs.mkdir(path.join(tempRootDir, '123'));
+    });
+    afterEach(async () => {
+        // Clean up the temporary root directory
+        await fs.rm(tempRootDir, { recursive: true, force: true });
+    });
+    describe('execute', () => {
+        it('should find files matching a simple pattern in the root', async () => {
+            const params = { pattern: '*.txt' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 2 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'FileB.TXT'));
+            expect(result.returnDisplay).toBe('Found 2 matching file(s)');
+        });
+        it('should find files case-insensitively by default (pattern: *.TXT)', async () => {
+            const params = { pattern: '*.TXT' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 2 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'fileA.txt'));
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'FileB.TXT'));
+        });
+        it('should find files using a pattern that includes a subdirectory', async () => {
+            const params = { pattern: 'sub/*.md' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 2 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'sub', 'fileC.md'));
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'sub', 'FileD.MD'));
+        });
+        it('should find files in a specified relative path (relative to rootDir)', async () => {
+            const params = { pattern: '*.md', path: 'sub' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 2 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'sub', 'fileC.md'));
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'sub', 'FileD.MD'));
+        });
+        it('should find files using a deep globstar pattern (e.g., **/*.log)', async () => {
+            const params = { pattern: '**/*.log' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 1 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'sub', 'deep', 'fileE.log'));
+        });
+        it('should return "No files found" message when pattern matches nothing', async () => {
+            const params = { pattern: '*.nonexistent' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('No files found matching pattern "*.nonexistent"');
+            expect(result.returnDisplay).toBe('No files found');
+        });
+        it('should find files with special characters in the name', async () => {
+            await fs.writeFile(path.join(tempRootDir, 'file[1].txt'), 'content');
+            const params = { pattern: 'file[1].txt' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 1 file(s)');
+            expect(result.llmContent).toContain(path.join(tempRootDir, 'file[1].txt'));
+        });
+        it('should find files with special characters like [] and () in the path', async () => {
+            const filePath = path.join(tempRootDir, 'src/app/[test]/(dashboard)/testing/components/code.tsx');
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, 'content');
+            const params = {
+                pattern: 'src/app/[test]/(dashboard)/testing/components/code.tsx',
+            };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 1 file(s)');
+            expect(result.llmContent).toContain(filePath);
+        });
+        it('should correctly sort files by modification time (newest first)', async () => {
+            const params = { pattern: '*.sortme' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            const llmContent = partListUnionToString(result.llmContent);
+            expect(llmContent).toContain('Found 2 file(s)');
+            // Ensure llmContent is a string for TypeScript type checking
+            expect(typeof llmContent).toBe('string');
+            const filesListed = llmContent
+                .trim()
+                .split(/\r?\n/)
+                .slice(2)
+                .map((line) => line.trim())
+                .filter(Boolean);
+            expect(filesListed).toHaveLength(2);
+            expect(path.resolve(filesListed[0])).toBe(path.resolve(tempRootDir, 'newer.sortme'));
+            expect(path.resolve(filesListed[1])).toBe(path.resolve(tempRootDir, 'older.sortme'));
+        });
+        it('should return error if path is outside workspace', async () => {
+            // Bypassing validation to test execute method directly
+            vi.spyOn(globTool, 'validateToolParams').mockReturnValue(null);
+            const params = { pattern: '*.txt', path: '/etc' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.returnDisplay).toBe('Error: Path is not within workspace');
+        });
+        it('should return a GLOB_EXECUTION_ERROR on glob failure', async () => {
+            vi.mocked(glob.glob).mockRejectedValue(new Error('Glob failed'));
+            const params = { pattern: '*.txt' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.error?.type).toBe(ToolErrorType.GLOB_EXECUTION_ERROR);
+            expect(result.llmContent).toContain('Error during glob search operation: Glob failed');
+            // Reset glob.
+            vi.mocked(glob.glob).mockReset();
+        });
+    });
+    describe('validateToolParams', () => {
+        it('should return null for valid parameters (pattern only)', () => {
+            const params = { pattern: '*.js' };
+            expect(globTool.validateToolParams(params)).toBeNull();
+        });
+        it('should return null for valid parameters (pattern and path)', () => {
+            const params = { pattern: '*.js', path: 'sub' };
+            expect(globTool.validateToolParams(params)).toBeNull();
+        });
+        it('should return error if pattern is missing (schema validation)', () => {
+            // Need to correctly define this as an object without pattern
+            const params = { path: '.' };
+            // @ts-expect-error - We're intentionally creating invalid params for testing
+            expect(globTool.validateToolParams(params)).toBe(`params must have required property 'pattern'`);
+        });
+        it('should return error if pattern is an empty string', () => {
+            const params = { pattern: '' };
+            expect(globTool.validateToolParams(params)).toContain("The 'pattern' parameter cannot be empty.");
+        });
+        it('should return error if pattern is only whitespace', () => {
+            const params = { pattern: '   ' };
+            expect(globTool.validateToolParams(params)).toContain("The 'pattern' parameter cannot be empty.");
+        });
+        it('should return error if path is provided but is not a string', () => {
+            const params = {
+                pattern: '*.ts',
+                path: 123,
+            }; // Force incorrect type
+            expect(globTool.validateToolParams(params)).toBe('params/path must be string');
+        });
+        it("should return error if search path resolves outside the tool's root directory", () => {
+            // Create a globTool instance specifically for this test, with a deeper root
+            tempRootDir = path.join(tempRootDir, 'sub');
+            const specificGlobTool = new GlobTool(mockConfig);
+            // const params: GlobToolParams = { pattern: '*.txt', path: '..' }; // This line is unused and will be removed.
+            // This should be fine as tempRootDir is still within the original tempRootDir (the parent of deeperRootDir)
+            // Let's try to go further up.
+            const paramsOutside = {
+                pattern: '*.txt',
+                path: '../../../../../../../../../../tmp', // Definitely outside
+            };
+            expect(specificGlobTool.validateToolParams(paramsOutside)).toContain('Path is not within workspace');
+        });
+        it('should return error if specified search path does not exist', async () => {
+            const params = {
+                pattern: '*.txt',
+                path: 'nonexistent_subdir',
+            };
+            expect(globTool.validateToolParams(params)).toContain('Path does not exist');
+        });
+        it('should return error if specified search path is a file, not a directory', async () => {
+            const params = { pattern: '*.txt', path: 'fileA.txt' };
+            expect(globTool.validateToolParams(params)).toContain('Path is not a directory');
+        });
+    });
+    describe('workspace boundary validation', () => {
+        it('should validate search paths are within workspace boundaries', () => {
+            const validPath = { pattern: '*.ts', path: 'sub' };
+            const invalidPath = { pattern: '*.ts', path: '../..' };
+            expect(globTool.validateToolParams(validPath)).toBeNull();
+            expect(globTool.validateToolParams(invalidPath)).toContain('Path is not within workspace');
+        });
+        it('should work with paths in workspace subdirectories', async () => {
+            const params = { pattern: '*.md', path: 'sub' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 2 file(s)');
+            expect(result.llmContent).toContain('fileC.md');
+            expect(result.llmContent).toContain('FileD.MD');
+        });
+    });
+    describe('ignore file handling', () => {
+        it('should respect .gitignore files by default', async () => {
+            await fs.writeFile(path.join(tempRootDir, '.gitignore'), '*.ignored.txt');
+            await fs.writeFile(path.join(tempRootDir, 'a.ignored.txt'), 'ignored content');
+            await fs.writeFile(path.join(tempRootDir, 'b.notignored.txt'), 'not ignored content');
+            const params = { pattern: '*.txt' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 3 file(s)'); // fileA.txt, FileB.TXT, b.notignored.txt
+            expect(result.llmContent).not.toContain('a.ignored.txt');
+        });
+        it('should respect .qwenignore files by default', async () => {
+            await fs.writeFile(path.join(tempRootDir, '.qwenignore'), '*.qwenignored.txt');
+            await fs.writeFile(path.join(tempRootDir, 'a.qwenignored.txt'), 'ignored content');
+            await fs.writeFile(path.join(tempRootDir, 'b.notignored.txt'), 'not ignored content');
+            // Recreate the tool to pick up the new .qwenignore file
+            globTool = new GlobTool(mockConfig);
+            const params = { pattern: '*.txt' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            expect(result.llmContent).toContain('Found 3 file(s)'); // fileA.txt, FileB.TXT, b.notignored.txt
+            expect(result.llmContent).not.toContain('a.qwenignored.txt');
+        });
+    });
+    describe('file count truncation', () => {
+        it('should truncate results when more than 100 files are found', async () => {
+            // Create 150 test files
+            for (let i = 1; i <= 150; i++) {
+                await fs.writeFile(path.join(tempRootDir, `file${i}.trunctest`), `content${i}`);
+            }
+            const params = { pattern: '*.trunctest' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            const llmContent = partListUnionToString(result.llmContent);
+            // Should report all 150 files found
+            expect(llmContent).toContain('Found 150 file(s)');
+            // Should include truncation notice
+            expect(llmContent).toContain('[50 files truncated] ...');
+            // Count the number of .trunctest files mentioned in the output
+            const fileMatches = llmContent.match(/file\d+\.trunctest/g);
+            expect(fileMatches).toBeDefined();
+            expect(fileMatches?.length).toBe(100);
+            // returnDisplay should indicate truncation
+            expect(result.returnDisplay).toBe('Found 150 matching file(s) (truncated)');
+        });
+        it('should not truncate when exactly 100 files are found', async () => {
+            // Create exactly 100 test files
+            for (let i = 1; i <= 100; i++) {
+                await fs.writeFile(path.join(tempRootDir, `exact${i}.trunctest`), `content${i}`);
+            }
+            const params = { pattern: '*.trunctest' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            // Should report all 100 files found
+            expect(result.llmContent).toContain('Found 100 file(s)');
+            // Should NOT include truncation notice
+            expect(result.llmContent).not.toContain('truncated');
+            // Should show all 100 files
+            expect(result.llmContent).toContain('exact1.trunctest');
+            expect(result.llmContent).toContain('exact100.trunctest');
+            // returnDisplay should NOT indicate truncation
+            expect(result.returnDisplay).toBe('Found 100 matching file(s)');
+        });
+        it('should not truncate when fewer than 100 files are found', async () => {
+            // Create 50 test files
+            for (let i = 1; i <= 50; i++) {
+                await fs.writeFile(path.join(tempRootDir, `small${i}.trunctest`), `content${i}`);
+            }
+            const params = { pattern: '*.trunctest' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            // Should report all 50 files found
+            expect(result.llmContent).toContain('Found 50 file(s)');
+            // Should NOT include truncation notice
+            expect(result.llmContent).not.toContain('truncated');
+            // returnDisplay should NOT indicate truncation
+            expect(result.returnDisplay).toBe('Found 50 matching file(s)');
+        });
+        it('should use correct singular/plural in truncation message for 1 file truncated', async () => {
+            // Create 101 test files (will truncate 1 file)
+            for (let i = 1; i <= 101; i++) {
+                await fs.writeFile(path.join(tempRootDir, `singular${i}.trunctest`), `content${i}`);
+            }
+            const params = { pattern: '*.trunctest' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            // Should use singular "file" for 1 truncated file
+            expect(result.llmContent).toContain('[1 file truncated] ...');
+            expect(result.llmContent).not.toContain('[1 files truncated]');
+        });
+        it('should use correct plural in truncation message for multiple files truncated', async () => {
+            // Create 105 test files (will truncate 5 files)
+            for (let i = 1; i <= 105; i++) {
+                await fs.writeFile(path.join(tempRootDir, `plural${i}.trunctest`), `content${i}`);
+            }
+            const params = { pattern: '*.trunctest' };
+            const invocation = globTool.build(params);
+            const result = await invocation.execute(abortSignal);
+            // Should use plural "files" for multiple truncated files
+            expect(result.llmContent).toContain('[5 files truncated] ...');
+        });
+    });
+});
+describe('sortFileEntries', () => {
+    const nowTimestamp = new Date('2024-01-15T12:00:00.000Z').getTime();
+    const oneDayInMs = 24 * 60 * 60 * 1000;
+    const createFileEntry = (fullpath, mtimeDate) => ({
+        fullpath: () => fullpath,
+        mtimeMs: mtimeDate.getTime(),
+    });
+    it('should sort a mix of recent and older files correctly', () => {
+        const recentTime1 = new Date(nowTimestamp - 1 * 60 * 60 * 1000); // 1 hour ago
+        const recentTime2 = new Date(nowTimestamp - 2 * 60 * 60 * 1000); // 2 hours ago
+        const olderTime1 = new Date(nowTimestamp - (oneDayInMs + 1 * 60 * 60 * 1000)); // 25 hours ago
+        const olderTime2 = new Date(nowTimestamp - (oneDayInMs + 2 * 60 * 60 * 1000)); // 26 hours ago
+        const entries = [
+            createFileEntry('older_zebra.txt', olderTime2),
+            createFileEntry('recent_alpha.txt', recentTime1),
+            createFileEntry('older_apple.txt', olderTime1),
+            createFileEntry('recent_beta.txt', recentTime2),
+            createFileEntry('older_banana.txt', olderTime1), // Same mtime as apple
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        const sortedPaths = sorted.map((e) => e.fullpath());
+        expect(sortedPaths).toEqual([
+            'recent_alpha.txt', // Recent, newest
+            'recent_beta.txt', // Recent, older
+            'older_apple.txt', // Older, alphabetical
+            'older_banana.txt', // Older, alphabetical
+            'older_zebra.txt', // Older, alphabetical
+        ]);
+    });
+    it('should sort only recent files by mtime descending', () => {
+        const recentTime1 = new Date(nowTimestamp - 1000); // Newest
+        const recentTime2 = new Date(nowTimestamp - 2000);
+        const recentTime3 = new Date(nowTimestamp - 3000); // Oldest recent
+        const entries = [
+            createFileEntry('c.txt', recentTime2),
+            createFileEntry('a.txt', recentTime3),
+            createFileEntry('b.txt', recentTime1),
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        expect(sorted.map((e) => e.fullpath())).toEqual([
+            'b.txt',
+            'c.txt',
+            'a.txt',
+        ]);
+    });
+    it('should sort only older files alphabetically by path', () => {
+        const olderTime = new Date(nowTimestamp - 2 * oneDayInMs); // All equally old
+        const entries = [
+            createFileEntry('zebra.txt', olderTime),
+            createFileEntry('apple.txt', olderTime),
+            createFileEntry('banana.txt', olderTime),
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        expect(sorted.map((e) => e.fullpath())).toEqual([
+            'apple.txt',
+            'banana.txt',
+            'zebra.txt',
+        ]);
+    });
+    it('should handle an empty array', () => {
+        const entries = [];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        expect(sorted).toEqual([]);
+    });
+    it('should correctly sort files when mtimes are identical for older files', () => {
+        const olderTime = new Date(nowTimestamp - 2 * oneDayInMs);
+        const entries = [
+            createFileEntry('b.txt', olderTime),
+            createFileEntry('a.txt', olderTime),
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        expect(sorted.map((e) => e.fullpath())).toEqual(['a.txt', 'b.txt']);
+    });
+    it('should correctly sort files when mtimes are identical for recent files (maintaining mtime sort)', () => {
+        const recentTime = new Date(nowTimestamp - 1000);
+        const entries = [
+            createFileEntry('b.txt', recentTime),
+            createFileEntry('a.txt', recentTime),
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, oneDayInMs);
+        expect(sorted.map((e) => e.fullpath())).toContain('a.txt');
+        expect(sorted.map((e) => e.fullpath())).toContain('b.txt');
+        expect(sorted.length).toBe(2);
+    });
+    it('should use recencyThresholdMs parameter correctly', () => {
+        const justOverThreshold = new Date(nowTimestamp - (1000 + 1)); // Barely older
+        const justUnderThreshold = new Date(nowTimestamp - (1000 - 1)); // Barely recent
+        const customThresholdMs = 1000; // 1 second
+        const entries = [
+            createFileEntry('older_file.txt', justOverThreshold),
+            createFileEntry('recent_file.txt', justUnderThreshold),
+        ];
+        const sorted = sortFileEntries(entries, nowTimestamp, customThresholdMs);
+        expect(sorted.map((e) => e.fullpath())).toEqual([
+            'recent_file.txt',
+            'older_file.txt',
+        ]);
+    });
+});
+//# sourceMappingURL=glob.test.js.map