@blackbox_ai/blackbox-cli-core 0.0.4

package/dist/src/tools/glob.js

@@ -0,0 +1,237 @@
+/**
+ * @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 } from './tool-names.js';
+import { shortenPath, makeRelative } from '../utils/paths.js';
+import { ToolErrorType } from './tool-error.js';
+/**
+ * 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;
+    constructor(config, params) {
+        super(params);
+        this.config = config;
+    }
+    getDescription() {
+        let description = `'${this.params.pattern}'`;
+        if (this.params.path) {
+            const searchDir = path.resolve(this.config.getTargetDir(), this.params.path || '.');
+            const relativePath = makeRelative(searchDir, this.config.getTargetDir());
+            description += ` within ${shortenPath(relativePath)}`;
+        }
+        return description;
+    }
+    async execute(signal) {
+        try {
+            const workspaceContext = this.config.getWorkspaceContext();
+            const workspaceDirectories = workspaceContext.getDirectories();
+            // If a specific path is provided, resolve it and check if it's within workspace
+            let searchDirectories;
+            if (this.params.path) {
+                const searchDirAbsolute = path.resolve(this.config.getTargetDir(), this.params.path);
+                if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
+                    const rawError = `Error: Path "${this.params.path}" is not within any workspace directory`;
+                    return {
+                        llmContent: rawError,
+                        returnDisplay: `Path is not within workspace`,
+                        error: {
+                            message: rawError,
+                            type: ToolErrorType.PATH_NOT_IN_WORKSPACE,
+                        },
+                    };
+                }
+                searchDirectories = [searchDirAbsolute];
+            }
+            else {
+                // Search across all workspace directories
+                searchDirectories = workspaceDirectories;
+            }
+            // Get centralized file discovery service
+            const respectGitIgnore = this.params.respect_git_ignore ??
+                this.config.getFileFilteringRespectGitIgnore();
+            const fileDiscovery = this.config.getFileService();
+            // Collect entries from all search directories
+            let allEntries = [];
+            for (const searchDir of searchDirectories) {
+                let pattern = this.params.pattern;
+                const fullPath = path.join(searchDir, pattern);
+                if (fs.existsSync(fullPath)) {
+                    pattern = escape(pattern);
+                }
+                const entries = (await glob(pattern, {
+                    cwd: searchDir,
+                    withFileTypes: true,
+                    nodir: true,
+                    stat: true,
+                    nocase: !this.params.case_sensitive,
+                    dot: true,
+                    ignore: this.config.getFileExclusions().getGlobExcludes(),
+                    follow: false,
+                    signal,
+                }));
+                allEntries = allEntries.concat(entries);
+            }
+            const entries = allEntries;
+            // Apply git-aware filtering if enabled and in git repository
+            let filteredEntries = entries;
+            let gitIgnoredCount = 0;
+            if (respectGitIgnore) {
+                const relativePaths = entries.map((p) => path.relative(this.config.getTargetDir(), p.fullpath()));
+                const filteredRelativePaths = fileDiscovery.filterFiles(relativePaths, {
+                    respectGitIgnore,
+                });
+                const filteredAbsolutePaths = new Set(filteredRelativePaths.map((p) => path.resolve(this.config.getTargetDir(), p)));
+                filteredEntries = entries.filter((entry) => filteredAbsolutePaths.has(entry.fullpath()));
+                gitIgnoredCount = entries.length - filteredEntries.length;
+            }
+            if (!filteredEntries || filteredEntries.length === 0) {
+                let message = `No files found matching pattern "${this.params.pattern}"`;
+                if (searchDirectories.length === 1) {
+                    message += ` within ${searchDirectories[0]}`;
+                }
+                else {
+                    message += ` within ${searchDirectories.length} workspace directories`;
+                }
+                if (gitIgnoredCount > 0) {
+                    message += ` (${gitIgnoredCount} files were git-ignored)`;
+                }
+                return {
+                    llmContent: message,
+                    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 sortedAbsolutePaths = sortedEntries.map((entry) => entry.fullpath());
+            const fileListDescription = sortedAbsolutePaths.join('\n');
+            const fileCount = sortedAbsolutePaths.length;
+            let resultMessage = `Found ${fileCount} file(s) matching "${this.params.pattern}"`;
+            if (searchDirectories.length === 1) {
+                resultMessage += ` within ${searchDirectories[0]}`;
+            }
+            else {
+                resultMessage += ` across ${searchDirectories.length} workspace directories`;
+            }
+            if (gitIgnoredCount > 0) {
+                resultMessage += ` (${gitIgnoredCount} additional files were git-ignored)`;
+            }
+            resultMessage += `, sorted by modification time (newest first):\n${fileListDescription}`;
+            return {
+                llmContent: resultMessage,
+                returnDisplay: `Found ${fileCount} matching file(s)`,
+            };
+        }
+        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: An unexpected error occurred.`,
+                error: {
+                    message: rawError,
+                    type: ToolErrorType.GLOB_EXECUTION_ERROR,
+                },
+            };
+        }
+    }
+}
+/**
+ * Implementation of the Glob tool logic
+ */
+export class GlobTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.GLOB;
+    constructor(config) {
+        super(GlobTool.Name, 'FindFiles', 'Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Ideal for quickly locating files based on their name or path structure, especially in large codebases.', Kind.Search, {
+            properties: {
+                pattern: {
+                    description: "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
+                    type: 'string',
+                },
+                path: {
+                    description: 'Optional: The absolute path to the directory to search within. If omitted, searches the root directory.',
+                    type: 'string',
+                },
+                case_sensitive: {
+                    description: 'Optional: Whether the search should be case-sensitive. Defaults to false.',
+                    type: 'boolean',
+                },
+                respect_git_ignore: {
+                    description: 'Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.',
+                    type: 'boolean',
+                },
+            },
+            required: ['pattern'],
+            type: 'object',
+        });
+        this.config = config;
+    }
+    /**
+     * Validates the parameters for the tool.
+     */
+    validateToolParamValues(params) {
+        const searchDirAbsolute = path.resolve(this.config.getTargetDir(), params.path || '.');
+        const workspaceContext = this.config.getWorkspaceContext();
+        if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
+            const directories = workspaceContext.getDirectories();
+            return `Search path ("${searchDirAbsolute}") resolves outside the allowed workspace directories: ${directories.join(', ')}`;
+        }
+        const targetDir = searchDirAbsolute || this.config.getTargetDir();
+        try {
+            if (!fs.existsSync(targetDir)) {
+                return `Search path does not exist ${targetDir}`;
+            }
+            if (!fs.statSync(targetDir).isDirectory()) {
+                return `Search path is not a directory: ${targetDir}`;
+            }
+        }
+        catch (e) {
+            return `Error accessing search path: ${e}`;
+        }
+        if (!params.pattern ||
+            typeof params.pattern !== 'string' ||
+            params.pattern.trim() === '') {
+            return "The 'pattern' parameter cannot be empty.";
+        }
+        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,375 @@
+/**
+ * @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,
+        getTargetDir: () => tempRootDir,
+        getWorkspaceContext: () => createMockWorkspaceContext(tempRootDir),
+        getFileExclusions: () => ({
+            getGlobExcludes: () => [],
+        }),
+    };
+    beforeEach(async () => {
+        // Create a unique root directory for each test run
+        tempRootDir = await fs.mkdtemp(path.join(os.tmpdir(), 'glob-tool-root-'));
+        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-sensitively when case_sensitive is true', async () => {
+            const params = { pattern: '*.txt', case_sensitive: true };
+            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, 'fileA.txt'));
+            expect(result.llmContent).not.toContain(path.join(tempRootDir, 'FileB.TXT'));
+        });
+        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 case-insensitively when case_sensitive is false (pattern: *.TXT)', async () => {
+            const params = {
+                pattern: '*.TXT',
+                case_sensitive: false,
+            };
+            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(1)
+                .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 a PATH_NOT_IN_WORKSPACE 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.error?.type).toBe(ToolErrorType.PATH_NOT_IN_WORKSPACE);
+            expect(result.returnDisplay).toBe('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 null for valid parameters (pattern, path, and case_sensitive)', () => {
+            const params = {
+                pattern: '*.js',
+                path: 'sub',
+                case_sensitive: true,
+            };
+            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 pass if path is provided but is not a string (type coercion)', () => {
+            const params = {
+                pattern: '*.ts',
+                path: 123,
+            }; // Force incorrect type
+            expect(globTool.validateToolParams(params)).toBeNull();
+        });
+        it('should pass if case_sensitive is provided but is not a boolean (type coercion)', () => {
+            const params = {
+                pattern: '*.ts',
+                case_sensitive: 'true',
+            }; // Force incorrect type
+            expect(globTool.validateToolParams(params)).toBeNull();
+        });
+        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('resolves outside the allowed workspace directories');
+        });
+        it('should return error if specified search path does not exist', async () => {
+            const params = {
+                pattern: '*.txt',
+                path: 'nonexistent_subdir',
+            };
+            expect(globTool.validateToolParams(params)).toContain('Search 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('Search 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('resolves outside the allowed workspace directories');
+        });
+        it('should provide clear error messages when path is outside workspace', () => {
+            const invalidPath = { pattern: '*.ts', path: '/etc' };
+            const error = globTool.validateToolParams(invalidPath);
+            expect(error).toContain('resolves outside the allowed workspace directories');
+            expect(error).toContain(tempRootDir);
+        });
+        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('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