@machina.ai/cell-cli-core 1.0.13-rc3

package/dist/src/utils/fileUtils.js

@@ -0,0 +1,300 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import mime from 'mime-types';
+// Constants for text file processing
+const DEFAULT_MAX_LINES_TEXT_FILE = 2000;
+const MAX_LINE_LENGTH_TEXT_FILE = 2000;
+// Default values for encoding and separator format
+export const DEFAULT_ENCODING = 'utf-8';
+/**
+ * Looks up the specific MIME type for a file path.
+ * @param filePath Path to the file.
+ * @returns The specific MIME type string (e.g., 'text/python', 'application/javascript') or undefined if not found or ambiguous.
+ */
+export function getSpecificMimeType(filePath) {
+    const lookedUpMime = mime.lookup(filePath);
+    return typeof lookedUpMime === 'string' ? lookedUpMime : undefined;
+}
+/**
+ * Checks if a path is within a given root directory.
+ * @param pathToCheck The absolute path to check.
+ * @param rootDirectory The absolute root directory.
+ * @returns True if the path is within the root directory, false otherwise.
+ */
+export function isWithinRoot(pathToCheck, rootDirectory) {
+    const normalizedPathToCheck = path.resolve(pathToCheck);
+    const normalizedRootDirectory = path.resolve(rootDirectory);
+    // Ensure the rootDirectory path ends with a separator for correct startsWith comparison,
+    // unless it's the root path itself (e.g., '/' or 'C:\').
+    const rootWithSeparator = normalizedRootDirectory === path.sep ||
+        normalizedRootDirectory.endsWith(path.sep)
+        ? normalizedRootDirectory
+        : normalizedRootDirectory + path.sep;
+    return (normalizedPathToCheck === normalizedRootDirectory ||
+        normalizedPathToCheck.startsWith(rootWithSeparator));
+}
+/**
+ * Determines if a file is likely binary based on content sampling.
+ * @param filePath Path to the file.
+ * @returns Promise that resolves to true if the file appears to be binary.
+ */
+export async function isBinaryFile(filePath) {
+    let fileHandle;
+    try {
+        fileHandle = await fs.promises.open(filePath, 'r');
+        // Read up to 4KB or file size, whichever is smaller
+        const stats = await fileHandle.stat();
+        const fileSize = stats.size;
+        if (fileSize === 0) {
+            // Empty file is not considered binary for content checking
+            return false;
+        }
+        const bufferSize = Math.min(4096, fileSize);
+        const buffer = Buffer.alloc(bufferSize);
+        const result = await fileHandle.read(buffer, 0, buffer.length, 0);
+        const bytesRead = result.bytesRead;
+        if (bytesRead === 0)
+            return false;
+        let nonPrintableCount = 0;
+        for (let i = 0; i < bytesRead; i++) {
+            if (buffer[i] === 0)
+                return true; // Null byte is a strong indicator
+            if (buffer[i] < 9 || (buffer[i] > 13 && buffer[i] < 32)) {
+                nonPrintableCount++;
+            }
+        }
+        // If >30% non-printable characters, consider it binary
+        return nonPrintableCount / bytesRead > 0.3;
+    }
+    catch (error) {
+        // Log error for debugging while maintaining existing behavior
+        console.warn(`Failed to check if file is binary: ${filePath}`, error instanceof Error ? error.message : String(error));
+        // If any error occurs (e.g. file not found, permissions),
+        // treat as not binary here; let higher-level functions handle existence/access errors.
+        return false;
+    }
+    finally {
+        // Safely close the file handle if it was successfully opened
+        if (fileHandle) {
+            try {
+                await fileHandle.close();
+            }
+            catch (closeError) {
+                // Log close errors for debugging while continuing with cleanup
+                console.warn(`Failed to close file handle for: ${filePath}`, closeError instanceof Error ? closeError.message : String(closeError));
+                // The important thing is that we attempted to clean up
+            }
+        }
+    }
+}
+/**
+ * Detects the type of file based on extension and content.
+ * @param filePath Path to the file.
+ * @returns Promise that resolves to 'text', 'image', 'pdf', 'audio', 'video', 'binary' or 'svg'.
+ */
+export async function detectFileType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    // The mimetype for "ts" is MPEG transport stream (a video format) but we want
+    // to assume these are typescript files instead.
+    if (ext === '.ts') {
+        return 'text';
+    }
+    if (ext === '.svg') {
+        return 'svg';
+    }
+    const lookedUpMimeType = mime.lookup(filePath); // Returns false if not found, or the mime type string
+    if (lookedUpMimeType) {
+        if (lookedUpMimeType.startsWith('image/')) {
+            return 'image';
+        }
+        if (lookedUpMimeType.startsWith('audio/')) {
+            return 'audio';
+        }
+        if (lookedUpMimeType.startsWith('video/')) {
+            return 'video';
+        }
+        if (lookedUpMimeType === 'application/pdf') {
+            return 'pdf';
+        }
+    }
+    // Stricter binary check for common non-text extensions before content check
+    // These are often not well-covered by mime-types or might be misidentified.
+    if ([
+        '.zip',
+        '.tar',
+        '.gz',
+        '.exe',
+        '.dll',
+        '.so',
+        '.class',
+        '.jar',
+        '.war',
+        '.7z',
+        '.doc',
+        '.docx',
+        '.xls',
+        '.xlsx',
+        '.ppt',
+        '.pptx',
+        '.odt',
+        '.ods',
+        '.odp',
+        '.bin',
+        '.dat',
+        '.obj',
+        '.o',
+        '.a',
+        '.lib',
+        '.wasm',
+        '.pyc',
+        '.pyo',
+    ].includes(ext)) {
+        return 'binary';
+    }
+    // Fall back to content-based check if mime type wasn't conclusive for image/pdf
+    // and it's not a known binary extension.
+    if (await isBinaryFile(filePath)) {
+        return 'binary';
+    }
+    return 'text';
+}
+/**
+ * Reads and processes a single file, handling text, images, and PDFs.
+ * @param filePath Absolute path to the file.
+ * @param rootDirectory Absolute path to the project root for relative path display.
+ * @param offset Optional offset for text files (0-based line number).
+ * @param limit Optional limit for text files (number of lines to read).
+ * @returns ProcessedFileReadResult object.
+ */
+export async function processSingleFileContent(filePath, rootDirectory, offset, limit) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            // Sync check is acceptable before async read
+            return {
+                llmContent: '',
+                returnDisplay: 'File not found.',
+                error: `File not found: ${filePath}`,
+            };
+        }
+        const stats = await fs.promises.stat(filePath);
+        if (stats.isDirectory()) {
+            return {
+                llmContent: '',
+                returnDisplay: 'Path is a directory.',
+                error: `Path is a directory, not a file: ${filePath}`,
+            };
+        }
+        const fileSizeInBytes = stats.size;
+        // 20MB limit
+        const maxFileSize = 20 * 1024 * 1024;
+        if (fileSizeInBytes > maxFileSize) {
+            throw new Error(`File size exceeds the 20MB limit: ${filePath} (${(fileSizeInBytes /
+                (1024 * 1024)).toFixed(2)}MB)`);
+        }
+        const fileType = await detectFileType(filePath);
+        const relativePathForDisplay = path
+            .relative(rootDirectory, filePath)
+            .replace(/\\/g, '/');
+        switch (fileType) {
+            case 'binary': {
+                return {
+                    llmContent: `Cannot display content of binary file: ${relativePathForDisplay}`,
+                    returnDisplay: `Skipped binary file: ${relativePathForDisplay}`,
+                };
+            }
+            case 'svg': {
+                const SVG_MAX_SIZE_BYTES = 1 * 1024 * 1024;
+                if (stats.size > SVG_MAX_SIZE_BYTES) {
+                    return {
+                        llmContent: `Cannot display content of SVG file larger than 1MB: ${relativePathForDisplay}`,
+                        returnDisplay: `Skipped large SVG file (>1MB): ${relativePathForDisplay}`,
+                    };
+                }
+                const content = await fs.promises.readFile(filePath, 'utf8');
+                return {
+                    llmContent: content,
+                    returnDisplay: `Read SVG as text: ${relativePathForDisplay}`,
+                };
+            }
+            case 'text': {
+                const content = await fs.promises.readFile(filePath, 'utf8');
+                const lines = content.split('\n');
+                const originalLineCount = lines.length;
+                const startLine = offset || 0;
+                const effectiveLimit = limit === undefined ? DEFAULT_MAX_LINES_TEXT_FILE : limit;
+                // Ensure endLine does not exceed originalLineCount
+                const endLine = Math.min(startLine + effectiveLimit, originalLineCount);
+                // Ensure selectedLines doesn't try to slice beyond array bounds if startLine is too high
+                const actualStartLine = Math.min(startLine, originalLineCount);
+                const selectedLines = lines.slice(actualStartLine, endLine);
+                let linesWereTruncatedInLength = false;
+                const formattedLines = selectedLines.map((line) => {
+                    if (line.length > MAX_LINE_LENGTH_TEXT_FILE) {
+                        linesWereTruncatedInLength = true;
+                        return (line.substring(0, MAX_LINE_LENGTH_TEXT_FILE) + '... [truncated]');
+                    }
+                    return line;
+                });
+                const contentRangeTruncated = endLine < originalLineCount;
+                const isTruncated = contentRangeTruncated || linesWereTruncatedInLength;
+                let llmTextContent = '';
+                if (contentRangeTruncated) {
+                    llmTextContent += `[File content truncated: showing lines ${actualStartLine + 1}-${endLine} of ${originalLineCount} total lines. Use offset/limit parameters to view more.]\n`;
+                }
+                else if (linesWereTruncatedInLength) {
+                    llmTextContent += `[File content partially truncated: some lines exceeded maximum length of ${MAX_LINE_LENGTH_TEXT_FILE} characters.]\n`;
+                }
+                llmTextContent += formattedLines.join('\n');
+                return {
+                    llmContent: llmTextContent,
+                    returnDisplay: isTruncated ? '(truncated)' : '',
+                    isTruncated,
+                    originalLineCount,
+                    linesShown: [actualStartLine + 1, endLine],
+                };
+            }
+            case 'image':
+            case 'pdf':
+            case 'audio':
+            case 'video': {
+                const contentBuffer = await fs.promises.readFile(filePath);
+                const base64Data = contentBuffer.toString('base64');
+                return {
+                    llmContent: {
+                        inlineData: {
+                            data: base64Data,
+                            mimeType: mime.lookup(filePath) || 'application/octet-stream',
+                        },
+                    },
+                    returnDisplay: `Read ${fileType} file: ${relativePathForDisplay}`,
+                };
+            }
+            default: {
+                // Should not happen with current detectFileType logic
+                const exhaustiveCheck = fileType;
+                return {
+                    llmContent: `Unhandled file type: ${exhaustiveCheck}`,
+                    returnDisplay: `Skipped unhandled file type: ${relativePathForDisplay}`,
+                    error: `Unhandled file type for ${filePath}`,
+                };
+            }
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const displayPath = path
+            .relative(rootDirectory, filePath)
+            .replace(/\\/g, '/');
+        return {
+            llmContent: `Error reading file ${displayPath}: ${errorMessage}`,
+            returnDisplay: `Error reading file ${displayPath}: ${errorMessage}`,
+            error: `Error reading file ${filePath}: ${errorMessage}`,
+        };
+    }
+}
+//# sourceMappingURL=fileUtils.js.map

package/dist/src/utils/fileUtils.js.map

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

package/dist/src/utils/fileUtils.test.d.ts

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

package/dist/src/utils/fileUtils.test.js

@@ -0,0 +1,321 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { describe, it, expect, vi, beforeEach, afterEach, } from 'vitest';
+import * as actualNodeFs from 'node:fs'; // For setup/teardown
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import mime from 'mime-types';
+import { isWithinRoot, isBinaryFile, detectFileType, processSingleFileContent, } from './fileUtils.js';
+vi.mock('mime-types', () => ({
+    default: { lookup: vi.fn() },
+    lookup: vi.fn(),
+}));
+const mockMimeLookup = mime.lookup;
+describe('fileUtils', () => {
+    let tempRootDir;
+    const originalProcessCwd = process.cwd;
+    let testTextFilePath;
+    let testImageFilePath;
+    let testPdfFilePath;
+    let testBinaryFilePath;
+    let nonexistentFilePath;
+    let directoryPath;
+    beforeEach(() => {
+        vi.resetAllMocks(); // Reset all mocks, including mime.lookup
+        tempRootDir = actualNodeFs.mkdtempSync(path.join(os.tmpdir(), 'fileUtils-test-'));
+        process.cwd = vi.fn(() => tempRootDir); // Mock cwd if necessary for relative path logic within tests
+        testTextFilePath = path.join(tempRootDir, 'test.txt');
+        testImageFilePath = path.join(tempRootDir, 'image.png');
+        testPdfFilePath = path.join(tempRootDir, 'document.pdf');
+        testBinaryFilePath = path.join(tempRootDir, 'app.exe');
+        nonexistentFilePath = path.join(tempRootDir, 'nonexistent.txt');
+        directoryPath = path.join(tempRootDir, 'subdir');
+        actualNodeFs.mkdirSync(directoryPath, { recursive: true }); // Ensure subdir exists
+    });
+    afterEach(() => {
+        if (actualNodeFs.existsSync(tempRootDir)) {
+            actualNodeFs.rmSync(tempRootDir, { recursive: true, force: true });
+        }
+        process.cwd = originalProcessCwd;
+        vi.restoreAllMocks(); // Restore any spies
+    });
+    describe('isWithinRoot', () => {
+        const root = path.resolve('/project/root');
+        it('should return true for paths directly within the root', () => {
+            expect(isWithinRoot(path.join(root, 'file.txt'), root)).toBe(true);
+            expect(isWithinRoot(path.join(root, 'subdir', 'file.txt'), root)).toBe(true);
+        });
+        it('should return true for the root path itself', () => {
+            expect(isWithinRoot(root, root)).toBe(true);
+        });
+        it('should return false for paths outside the root', () => {
+            expect(isWithinRoot(path.resolve('/project/other', 'file.txt'), root)).toBe(false);
+            expect(isWithinRoot(path.resolve('/unrelated', 'file.txt'), root)).toBe(false);
+        });
+        it('should return false for paths that only partially match the root prefix', () => {
+            expect(isWithinRoot(path.resolve('/project/root-but-actually-different'), root)).toBe(false);
+        });
+        it('should handle paths with trailing slashes correctly', () => {
+            expect(isWithinRoot(path.join(root, 'file.txt') + path.sep, root)).toBe(true);
+            expect(isWithinRoot(root + path.sep, root)).toBe(true);
+        });
+        it('should handle different path separators (POSIX vs Windows)', () => {
+            const posixRoot = '/project/root';
+            const posixPathInside = '/project/root/file.txt';
+            const posixPathOutside = '/project/other/file.txt';
+            expect(isWithinRoot(posixPathInside, posixRoot)).toBe(true);
+            expect(isWithinRoot(posixPathOutside, posixRoot)).toBe(false);
+        });
+        it('should return false for a root path that is a sub-path of the path to check', () => {
+            const pathToCheck = path.resolve('/project/root/sub');
+            const rootSub = path.resolve('/project/root');
+            expect(isWithinRoot(pathToCheck, rootSub)).toBe(true);
+            const pathToCheckSuper = path.resolve('/project/root');
+            const rootSuper = path.resolve('/project/root/sub');
+            expect(isWithinRoot(pathToCheckSuper, rootSuper)).toBe(false);
+        });
+    });
+    describe('isBinaryFile', () => {
+        let filePathForBinaryTest;
+        beforeEach(() => {
+            filePathForBinaryTest = path.join(tempRootDir, 'binaryCheck.tmp');
+        });
+        afterEach(() => {
+            if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+                actualNodeFs.unlinkSync(filePathForBinaryTest);
+            }
+        });
+        it('should return false for an empty file', async () => {
+            actualNodeFs.writeFileSync(filePathForBinaryTest, '');
+            expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+        });
+        it('should return false for a typical text file', async () => {
+            actualNodeFs.writeFileSync(filePathForBinaryTest, 'Hello, world!\nThis is a test file with normal text content.');
+            expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+        });
+        it('should return true for a file with many null bytes', async () => {
+            const binaryContent = Buffer.from([
+                0x48, 0x65, 0x00, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x00, 0x00,
+            ]); // "He\0llo\0\0\0\0\0"
+            actualNodeFs.writeFileSync(filePathForBinaryTest, binaryContent);
+            expect(await isBinaryFile(filePathForBinaryTest)).toBe(true);
+        });
+        it('should return true for a file with high percentage of non-printable ASCII', async () => {
+            const binaryContent = Buffer.from([
+                0x41, 0x42, 0x01, 0x02, 0x03, 0x04, 0x05, 0x43, 0x44, 0x06,
+            ]); // AB\x01\x02\x03\x04\x05CD\x06
+            actualNodeFs.writeFileSync(filePathForBinaryTest, binaryContent);
+            expect(await isBinaryFile(filePathForBinaryTest)).toBe(true);
+        });
+        it('should return false if file access fails (e.g., ENOENT)', async () => {
+            // Ensure the file does not exist
+            if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+                actualNodeFs.unlinkSync(filePathForBinaryTest);
+            }
+            expect(await isBinaryFile(filePathForBinaryTest)).toBe(false);
+        });
+    });
+    describe('detectFileType', () => {
+        let filePathForDetectTest;
+        beforeEach(() => {
+            filePathForDetectTest = path.join(tempRootDir, 'detectType.tmp');
+            // Default: create as a text file for isBinaryFile fallback
+            actualNodeFs.writeFileSync(filePathForDetectTest, 'Plain text content');
+        });
+        afterEach(() => {
+            if (actualNodeFs.existsSync(filePathForDetectTest)) {
+                actualNodeFs.unlinkSync(filePathForDetectTest);
+            }
+            vi.restoreAllMocks(); // Restore spies on actualNodeFs
+        });
+        it('should detect typescript type by extension (ts)', async () => {
+            expect(await detectFileType('file.ts')).toBe('text');
+            expect(await detectFileType('file.test.ts')).toBe('text');
+        });
+        it('should detect image type by extension (png)', async () => {
+            mockMimeLookup.mockReturnValueOnce('image/png');
+            expect(await detectFileType('file.png')).toBe('image');
+        });
+        it('should detect image type by extension (jpeg)', async () => {
+            mockMimeLookup.mockReturnValueOnce('image/jpeg');
+            expect(await detectFileType('file.jpg')).toBe('image');
+        });
+        it('should detect svg type by extension', async () => {
+            expect(await detectFileType('image.svg')).toBe('svg');
+            expect(await detectFileType('image.icon.svg')).toBe('svg');
+        });
+        it('should detect pdf type by extension', async () => {
+            mockMimeLookup.mockReturnValueOnce('application/pdf');
+            expect(await detectFileType('file.pdf')).toBe('pdf');
+        });
+        it('should detect audio type by extension', async () => {
+            mockMimeLookup.mockReturnValueOnce('audio/mpeg');
+            expect(await detectFileType('song.mp3')).toBe('audio');
+        });
+        it('should detect video type by extension', async () => {
+            mockMimeLookup.mockReturnValueOnce('video/mp4');
+            expect(await detectFileType('movie.mp4')).toBe('video');
+        });
+        it('should detect known binary extensions as binary (e.g. .zip)', async () => {
+            mockMimeLookup.mockReturnValueOnce('application/zip');
+            expect(await detectFileType('archive.zip')).toBe('binary');
+        });
+        it('should detect known binary extensions as binary (e.g. .exe)', async () => {
+            mockMimeLookup.mockReturnValueOnce('application/octet-stream'); // Common for .exe
+            expect(await detectFileType('app.exe')).toBe('binary');
+        });
+        it('should use isBinaryFile for unknown extensions and detect as binary', async () => {
+            mockMimeLookup.mockReturnValueOnce(false); // Unknown mime type
+            // Create a file that isBinaryFile will identify as binary
+            const binaryContent = Buffer.from([
+                0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a,
+            ]);
+            actualNodeFs.writeFileSync(filePathForDetectTest, binaryContent);
+            expect(await detectFileType(filePathForDetectTest)).toBe('binary');
+        });
+        it('should default to text if mime type is unknown and content is not binary', async () => {
+            mockMimeLookup.mockReturnValueOnce(false); // Unknown mime type
+            // filePathForDetectTest is already a text file by default from beforeEach
+            expect(await detectFileType(filePathForDetectTest)).toBe('text');
+        });
+    });
+    describe('processSingleFileContent', () => {
+        beforeEach(() => {
+            // Ensure files exist for statSync checks before readFile might be mocked
+            if (actualNodeFs.existsSync(testTextFilePath))
+                actualNodeFs.unlinkSync(testTextFilePath);
+            if (actualNodeFs.existsSync(testImageFilePath))
+                actualNodeFs.unlinkSync(testImageFilePath);
+            if (actualNodeFs.existsSync(testPdfFilePath))
+                actualNodeFs.unlinkSync(testPdfFilePath);
+            if (actualNodeFs.existsSync(testBinaryFilePath))
+                actualNodeFs.unlinkSync(testBinaryFilePath);
+        });
+        it('should read a text file successfully', async () => {
+            const content = 'Line 1\\nLine 2\\nLine 3';
+            actualNodeFs.writeFileSync(testTextFilePath, content);
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir);
+            expect(result.llmContent).toBe(content);
+            expect(result.returnDisplay).toBe('');
+            expect(result.error).toBeUndefined();
+        });
+        it('should handle file not found', async () => {
+            const result = await processSingleFileContent(nonexistentFilePath, tempRootDir);
+            expect(result.error).toContain('File not found');
+            expect(result.returnDisplay).toContain('File not found');
+        });
+        it('should handle read errors for text files', async () => {
+            actualNodeFs.writeFileSync(testTextFilePath, 'content'); // File must exist for initial statSync
+            const readError = new Error('Simulated read error');
+            vi.spyOn(fsPromises, 'readFile').mockRejectedValueOnce(readError);
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir);
+            expect(result.error).toContain('Simulated read error');
+            expect(result.returnDisplay).toContain('Simulated read error');
+        });
+        it('should handle read errors for image/pdf files', async () => {
+            actualNodeFs.writeFileSync(testImageFilePath, 'content'); // File must exist
+            mockMimeLookup.mockReturnValue('image/png');
+            const readError = new Error('Simulated image read error');
+            vi.spyOn(fsPromises, 'readFile').mockRejectedValueOnce(readError);
+            const result = await processSingleFileContent(testImageFilePath, tempRootDir);
+            expect(result.error).toContain('Simulated image read error');
+            expect(result.returnDisplay).toContain('Simulated image read error');
+        });
+        it('should process an image file', async () => {
+            const fakePngData = Buffer.from('fake png data');
+            actualNodeFs.writeFileSync(testImageFilePath, fakePngData);
+            mockMimeLookup.mockReturnValue('image/png');
+            const result = await processSingleFileContent(testImageFilePath, tempRootDir);
+            expect(result.llmContent.inlineData).toBeDefined();
+            expect(result.llmContent.inlineData
+                .mimeType).toBe('image/png');
+            expect(result.llmContent.inlineData.data).toBe(fakePngData.toString('base64'));
+            expect(result.returnDisplay).toContain('Read image file: image.png');
+        });
+        it('should process a PDF file', async () => {
+            const fakePdfData = Buffer.from('fake pdf data');
+            actualNodeFs.writeFileSync(testPdfFilePath, fakePdfData);
+            mockMimeLookup.mockReturnValue('application/pdf');
+            const result = await processSingleFileContent(testPdfFilePath, tempRootDir);
+            expect(result.llmContent.inlineData).toBeDefined();
+            expect(result.llmContent.inlineData
+                .mimeType).toBe('application/pdf');
+            expect(result.llmContent.inlineData.data).toBe(fakePdfData.toString('base64'));
+            expect(result.returnDisplay).toContain('Read pdf file: document.pdf');
+        });
+        it('should read an SVG file as text when under 1MB', async () => {
+            const svgContent = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="100" height="100">
+      <rect width="100" height="100" fill="blue" />
+    </svg>
+  `;
+            const testSvgFilePath = path.join(tempRootDir, 'test.svg');
+            actualNodeFs.writeFileSync(testSvgFilePath, svgContent, 'utf-8');
+            mockMimeLookup.mockReturnValue('image/svg+xml');
+            const result = await processSingleFileContent(testSvgFilePath, tempRootDir);
+            expect(result.llmContent).toBe(svgContent);
+            expect(result.returnDisplay).toContain('Read SVG as text');
+        });
+        it('should skip binary files', async () => {
+            actualNodeFs.writeFileSync(testBinaryFilePath, Buffer.from([0x00, 0x01, 0x02]));
+            mockMimeLookup.mockReturnValueOnce('application/octet-stream');
+            // isBinaryFile will operate on the real file.
+            const result = await processSingleFileContent(testBinaryFilePath, tempRootDir);
+            expect(result.llmContent).toContain('Cannot display content of binary file');
+            expect(result.returnDisplay).toContain('Skipped binary file: app.exe');
+        });
+        it('should handle path being a directory', async () => {
+            const result = await processSingleFileContent(directoryPath, tempRootDir);
+            expect(result.error).toContain('Path is a directory');
+            expect(result.returnDisplay).toContain('Path is a directory');
+        });
+        it('should paginate text files correctly (offset and limit)', async () => {
+            const lines = Array.from({ length: 20 }, (_, i) => `Line ${i + 1}`);
+            actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir, 5, 5); // Read lines 6-10
+            const expectedContent = lines.slice(5, 10).join('\n');
+            expect(result.llmContent).toContain(expectedContent);
+            expect(result.llmContent).toContain('[File content truncated: showing lines 6-10 of 20 total lines. Use offset/limit parameters to view more.]');
+            expect(result.returnDisplay).toBe('(truncated)');
+            expect(result.isTruncated).toBe(true);
+            expect(result.originalLineCount).toBe(20);
+            expect(result.linesShown).toEqual([6, 10]);
+        });
+        it('should handle limit exceeding file length', async () => {
+            const lines = ['Line 1', 'Line 2'];
+            actualNodeFs.writeFileSync(testTextFilePath, lines.join('\n'));
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir, 0, 10);
+            const expectedContent = lines.join('\n');
+            expect(result.llmContent).toBe(expectedContent);
+            expect(result.returnDisplay).toBe('');
+            expect(result.isTruncated).toBe(false);
+            expect(result.originalLineCount).toBe(2);
+            expect(result.linesShown).toEqual([1, 2]);
+        });
+        it('should truncate long lines in text files', async () => {
+            const longLine = 'a'.repeat(2500);
+            actualNodeFs.writeFileSync(testTextFilePath, `Short line\n${longLine}\nAnother short line`);
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir);
+            expect(result.llmContent).toContain('Short line');
+            expect(result.llmContent).toContain(longLine.substring(0, 2000) + '... [truncated]');
+            expect(result.llmContent).toContain('Another short line');
+            expect(result.llmContent).toContain('[File content partially truncated: some lines exceeded maximum length of 2000 characters.]');
+            expect(result.isTruncated).toBe(true);
+        });
+        it('should return an error if the file size exceeds 20MB', async () => {
+            // Create a file just over 20MB
+            const twentyOneMB = 21 * 1024 * 1024;
+            const buffer = Buffer.alloc(twentyOneMB, 0x61); // Fill with 'a'
+            actualNodeFs.writeFileSync(testTextFilePath, buffer);
+            const result = await processSingleFileContent(testTextFilePath, tempRootDir);
+            expect(result.error).toContain('File size exceeds the 20MB limit');
+            expect(result.returnDisplay).toContain('File size exceeds the 20MB limit');
+            expect(result.llmContent).toContain('File size exceeds the 20MB limit');
+        });
+    });
+});
+//# sourceMappingURL=fileUtils.test.js.map