summaryrefslogtreecommitdiff
path: root/packages/server/src
diff options
context:
space:
mode:
Diffstat (limited to 'packages/server/src')
-rw-r--r--packages/server/src/core/turn.ts3
-rw-r--r--packages/server/src/tools/read-file.test.ts228
-rw-r--r--packages/server/src/tools/read-file.ts186
-rw-r--r--packages/server/src/tools/read-many-files.test.ts27
-rw-r--r--packages/server/src/tools/read-many-files.ts113
-rw-r--r--packages/server/src/utils/fileUtils.test.ts433
-rw-r--r--packages/server/src/utils/fileUtils.ts280
7 files changed, 1035 insertions, 235 deletions
diff --git a/packages/server/src/core/turn.ts b/packages/server/src/core/turn.ts
index 97e93f59..22b01cce 100644
--- a/packages/server/src/core/turn.ts
+++ b/packages/server/src/core/turn.ts
@@ -5,7 +5,6 @@
*/
import {
- Part,
PartListUnion,
GenerateContentResponse,
FunctionCall,
@@ -57,7 +56,7 @@ export interface ToolCallRequestInfo {
export interface ToolCallResponseInfo {
callId: string;
- responsePart: Part;
+ responseParts: PartListUnion;
resultDisplay: ToolResultDisplay | undefined;
error: Error | undefined;
}
diff --git a/packages/server/src/tools/read-file.test.ts b/packages/server/src/tools/read-file.test.ts
new file mode 100644
index 00000000..8ea42134
--- /dev/null
+++ b/packages/server/src/tools/read-file.test.ts
@@ -0,0 +1,228 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { vi, describe, it, expect, beforeEach, afterEach, Mock } from 'vitest';
+import { ReadFileTool, ReadFileToolParams } from './read-file.js';
+import * as fileUtils from '../utils/fileUtils.js';
+import path from 'path';
+import os from 'os';
+import fs from 'fs'; // For actual fs operations in setup
+
+// Mock fileUtils.processSingleFileContent
+vi.mock('../utils/fileUtils', async () => {
+ const actualFileUtils =
+ await vi.importActual<typeof fileUtils>('../utils/fileUtils');
+ return {
+ ...actualFileUtils, // Spread actual implementations
+ processSingleFileContent: vi.fn(), // Mock specific function
+ };
+});
+
+const mockProcessSingleFileContent = fileUtils.processSingleFileContent as Mock;
+
+describe('ReadFileTool', () => {
+ let tempRootDir: string;
+ let tool: ReadFileTool;
+ const abortSignal = new AbortController().signal;
+
+ beforeEach(() => {
+ // Create a unique temporary root directory for each test run
+ tempRootDir = fs.mkdtempSync(
+ path.join(os.tmpdir(), 'read-file-tool-root-'),
+ );
+ tool = new ReadFileTool(tempRootDir);
+ mockProcessSingleFileContent.mockReset();
+ });
+
+ afterEach(() => {
+ // Clean up the temporary root directory
+ if (fs.existsSync(tempRootDir)) {
+ fs.rmSync(tempRootDir, { recursive: true, force: true });
+ }
+ });
+
+ describe('validateToolParams', () => {
+ it('should return null for valid params (absolute path within root)', () => {
+ const params: ReadFileToolParams = {
+ path: path.join(tempRootDir, 'test.txt'),
+ };
+ expect(tool.validateToolParams(params)).toBeNull();
+ });
+
+ it('should return null for valid params with offset and limit', () => {
+ const params: ReadFileToolParams = {
+ path: path.join(tempRootDir, 'test.txt'),
+ offset: 0,
+ limit: 10,
+ };
+ expect(tool.validateToolParams(params)).toBeNull();
+ });
+
+ it('should return error for relative path', () => {
+ const params: ReadFileToolParams = { path: 'test.txt' };
+ expect(tool.validateToolParams(params)).toMatch(
+ /File path must be absolute/,
+ );
+ });
+
+ it('should return error for path outside root', () => {
+ const outsidePath = path.resolve(os.tmpdir(), 'outside-root.txt');
+ const params: ReadFileToolParams = { path: outsidePath };
+ expect(tool.validateToolParams(params)).toMatch(
+ /File path must be within the root directory/,
+ );
+ });
+
+ it('should return error for negative offset', () => {
+ const params: ReadFileToolParams = {
+ path: path.join(tempRootDir, 'test.txt'),
+ offset: -1,
+ limit: 10,
+ };
+ expect(tool.validateToolParams(params)).toBe(
+ 'Offset must be a non-negative number',
+ );
+ });
+
+ it('should return error for non-positive limit', () => {
+ const paramsZero: ReadFileToolParams = {
+ path: path.join(tempRootDir, 'test.txt'),
+ offset: 0,
+ limit: 0,
+ };
+ expect(tool.validateToolParams(paramsZero)).toBe(
+ 'Limit must be a positive number',
+ );
+ const paramsNegative: ReadFileToolParams = {
+ path: path.join(tempRootDir, 'test.txt'),
+ offset: 0,
+ limit: -5,
+ };
+ expect(tool.validateToolParams(paramsNegative)).toBe(
+ 'Limit must be a positive number',
+ );
+ });
+
+ it('should return error for schema validation failure (e.g. missing path)', () => {
+ const params = { offset: 0 } as unknown as ReadFileToolParams;
+ expect(tool.validateToolParams(params)).toBe(
+ 'Parameters failed schema validation.',
+ );
+ });
+ });
+
+ describe('getDescription', () => {
+ it('should return a shortened, relative path', () => {
+ const filePath = path.join(tempRootDir, 'sub', 'dir', 'file.txt');
+ const params: ReadFileToolParams = { path: filePath };
+ // Assuming tempRootDir is something like /tmp/read-file-tool-root-XXXXXX
+ // The relative path would be sub/dir/file.txt
+ expect(tool.getDescription(params)).toBe('sub/dir/file.txt');
+ });
+
+ it('should return . if path is the root directory', () => {
+ const params: ReadFileToolParams = { path: tempRootDir };
+ expect(tool.getDescription(params)).toBe('.');
+ });
+ });
+
+ describe('execute', () => {
+ it('should return validation error if params are invalid', async () => {
+ const params: ReadFileToolParams = { path: 'relative/path.txt' };
+ const result = await tool.execute(params, abortSignal);
+ expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
+ expect(result.returnDisplay).toMatch(/File path must be absolute/);
+ });
+
+ it('should return error from processSingleFileContent if it fails', async () => {
+ const filePath = path.join(tempRootDir, 'error.txt');
+ const params: ReadFileToolParams = { path: filePath };
+ const errorMessage = 'Simulated read error';
+ mockProcessSingleFileContent.mockResolvedValue({
+ llmContent: `Error reading file ${filePath}: ${errorMessage}`,
+ returnDisplay: `Error reading file ${filePath}: ${errorMessage}`,
+ error: errorMessage,
+ });
+
+ const result = await tool.execute(params, abortSignal);
+ expect(mockProcessSingleFileContent).toHaveBeenCalledWith(
+ filePath,
+ tempRootDir,
+ undefined,
+ undefined,
+ );
+ expect(result.llmContent).toContain(errorMessage);
+ expect(result.returnDisplay).toContain(errorMessage);
+ });
+
+ it('should return success result for a text file', async () => {
+ const filePath = path.join(tempRootDir, 'textfile.txt');
+ const fileContent = 'This is a test file.';
+ const params: ReadFileToolParams = { path: filePath };
+ mockProcessSingleFileContent.mockResolvedValue({
+ llmContent: fileContent,
+ returnDisplay: `Read text file: ${path.basename(filePath)}`,
+ });
+
+ const result = await tool.execute(params, abortSignal);
+ expect(mockProcessSingleFileContent).toHaveBeenCalledWith(
+ filePath,
+ tempRootDir,
+ undefined,
+ undefined,
+ );
+ expect(result.llmContent).toBe(fileContent);
+ expect(result.returnDisplay).toBe(
+ `Read text file: ${path.basename(filePath)}`,
+ );
+ });
+
+ it('should return success result for an image file', async () => {
+ const filePath = path.join(tempRootDir, 'image.png');
+ const imageData = {
+ inlineData: { mimeType: 'image/png', data: 'base64...' },
+ };
+ const params: ReadFileToolParams = { path: filePath };
+ mockProcessSingleFileContent.mockResolvedValue({
+ llmContent: imageData,
+ returnDisplay: `Read image file: ${path.basename(filePath)}`,
+ });
+
+ const result = await tool.execute(params, abortSignal);
+ expect(mockProcessSingleFileContent).toHaveBeenCalledWith(
+ filePath,
+ tempRootDir,
+ undefined,
+ undefined,
+ );
+ expect(result.llmContent).toEqual(imageData);
+ expect(result.returnDisplay).toBe(
+ `Read image file: ${path.basename(filePath)}`,
+ );
+ });
+
+ it('should pass offset and limit to processSingleFileContent', async () => {
+ const filePath = path.join(tempRootDir, 'paginated.txt');
+ const params: ReadFileToolParams = {
+ path: filePath,
+ offset: 10,
+ limit: 5,
+ };
+ mockProcessSingleFileContent.mockResolvedValue({
+ llmContent: 'some lines',
+ returnDisplay: 'Read text file (paginated)',
+ });
+
+ await tool.execute(params, abortSignal);
+ expect(mockProcessSingleFileContent).toHaveBeenCalledWith(
+ filePath,
+ tempRootDir,
+ 10,
+ 5,
+ );
+ });
+ });
+});
diff --git a/packages/server/src/tools/read-file.ts b/packages/server/src/tools/read-file.ts
index de09161d..4bb3bd56 100644
--- a/packages/server/src/tools/read-file.ts
+++ b/packages/server/src/tools/read-file.ts
@@ -4,11 +4,11 @@
* SPDX-License-Identifier: Apache-2.0
*/
-import fs from 'fs';
import path from 'path';
import { SchemaValidator } from '../utils/schemaValidator.js';
import { makeRelative, shortenPath } from '../utils/paths.js';
import { BaseTool, ToolResult } from './tools.js';
+import { isWithinRoot, processSingleFileContent } from '../utils/fileUtils.js';
/**
* Parameters for the ReadFile tool
@@ -35,14 +35,12 @@ export interface ReadFileToolParams {
*/
export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
static readonly Name: string = 'read_file';
- private static readonly DEFAULT_MAX_LINES = 2000;
- private static readonly MAX_LINE_LENGTH = 2000;
constructor(private rootDirectory: string) {
super(
ReadFileTool.Name,
'ReadFile',
- 'Reads and returns the content of a specified file from the local filesystem. Handles large files by allowing reading specific line ranges.',
+ 'Reads and returns the content of a specified file from the local filesystem. Handles text, images (PNG, JPG, GIF, WEBP, SVG, BMP), and PDF files. For text files, it can read specific line ranges.',
{
properties: {
path: {
@@ -52,12 +50,12 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
},
offset: {
description:
- "Optional: The 0-based line number to start reading from. Requires 'limit' to be set. Use for paginating through large files.",
+ "Optional: For text files, the 0-based line number to start reading from. Requires 'limit' to be set. Use for paginating through large files.",
type: 'number',
},
limit: {
description:
- "Optional: Maximum number of lines to read. Use with 'offset' to paginate through large files. If omitted, reads the entire file (if feasible).",
+ "Optional: For text files, maximum number of lines to read. Use with 'offset' to paginate through large files. If omitted, reads the entire file (if feasible, up to a default limit).",
type: 'number',
},
},
@@ -68,28 +66,6 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
this.rootDirectory = path.resolve(rootDirectory);
}
- /**
- * Checks if a path is within the root directory
- * @param pathToCheck The path to check
- * @returns True if the path is within the root directory, false otherwise
- */
- private isWithinRoot(pathToCheck: string): boolean {
- const normalizedPath = path.normalize(pathToCheck);
- const normalizedRoot = path.normalize(this.rootDirectory);
- const rootWithSep = normalizedRoot.endsWith(path.sep)
- ? normalizedRoot
- : normalizedRoot + path.sep;
- return (
- normalizedPath === normalizedRoot ||
- normalizedPath.startsWith(rootWithSep)
- );
- }
-
- /**
- * Validates the parameters for the ReadFile tool
- * @param params Parameters to validate
- * @returns True if parameters are valid, false otherwise
- */
validateToolParams(params: ReadFileToolParams): string | null {
if (
this.schema.parameters &&
@@ -104,7 +80,7 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
if (!path.isAbsolute(filePath)) {
return `File path must be absolute: ${filePath}`;
}
- if (!this.isWithinRoot(filePath)) {
+ if (!isWithinRoot(filePath, this.rootDirectory)) {
return `File path must be within the root directory (${this.rootDirectory}): ${filePath}`;
}
if (params.offset !== undefined && params.offset < 0) {
@@ -116,83 +92,11 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
return null;
}
- /**
- * Determines if a file is likely binary based on content sampling
- * @param filePath Path to the file
- * @returns True if the file appears to be binary
- */
- private isBinaryFile(filePath: string): boolean {
- try {
- // Read the first 4KB of the file
- const fd = fs.openSync(filePath, 'r');
- const buffer = Buffer.alloc(4096);
- const bytesRead = fs.readSync(fd, buffer, 0, 4096, 0);
- fs.closeSync(fd);
-
- // Check for null bytes or high concentration of non-printable characters
- let nonPrintableCount = 0;
- for (let i = 0; i < bytesRead; i++) {
- // Null byte is a strong indicator of binary data
- if (buffer[i] === 0) {
- return true;
- }
-
- // Count non-printable characters
- if (buffer[i] < 9 || (buffer[i] > 13 && buffer[i] < 32)) {
- nonPrintableCount++;
- }
- }
-
- // If more than 30% are non-printable, likely binary
- return nonPrintableCount / bytesRead > 0.3;
- } catch {
- return false;
- }
- }
-
- /**
- * Detects the type of file based on extension and content
- * @param filePath Path to the file
- * @returns File type description
- */
- private detectFileType(filePath: string): string {
- const ext = path.extname(filePath).toLowerCase();
-
- // Common image formats
- if (
- ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp', '.svg'].includes(ext)
- ) {
- return 'image';
- }
-
- // Other known binary formats
- if (['.pdf', '.zip', '.tar', '.gz', '.exe', '.dll', '.so'].includes(ext)) {
- return 'binary';
- }
-
- // Check content for binary indicators
- if (this.isBinaryFile(filePath)) {
- return 'binary';
- }
-
- return 'text';
- }
-
- /**
- * Gets a description of the file reading operation
- * @param params Parameters for the file reading
- * @returns A string describing the file being read
- */
getDescription(params: ReadFileToolParams): string {
const relativePath = makeRelative(params.path, this.rootDirectory);
return shortenPath(relativePath);
}
- /**
- * Reads a file and returns its contents with line numbers
- * @param params Parameters for the file reading
- * @returns Result with file contents
- */
async execute(
params: ReadFileToolParams,
_signal: AbortSignal,
@@ -205,75 +109,23 @@ export class ReadFileTool extends BaseTool<ReadFileToolParams, ToolResult> {
};
}
- const filePath = params.path;
- try {
- if (!fs.existsSync(filePath)) {
- return {
- llmContent: `File not found: ${filePath}`,
- returnDisplay: `File not found.`,
- };
- }
-
- const stats = fs.statSync(filePath);
- if (stats.isDirectory()) {
- return {
- llmContent: `Path is a directory, not a file: ${filePath}`,
- returnDisplay: `File is directory.`,
- };
- }
-
- const fileType = this.detectFileType(filePath);
- if (fileType !== 'text') {
- return {
- llmContent: `Binary file: ${filePath} (${fileType})`,
- // For binary files, maybe returnDisplay should be empty or indicate binary?
- // Keeping it empty for now.
- returnDisplay: ``,
- };
- }
-
- const content = fs.readFileSync(filePath, 'utf8');
- const lines = content.split('\n');
-
- const startLine = params.offset || 0;
- const endLine = params.limit
- ? startLine + params.limit
- : Math.min(startLine + ReadFileTool.DEFAULT_MAX_LINES, lines.length);
- const selectedLines = lines.slice(startLine, endLine);
-
- let truncated = false;
- const formattedLines = selectedLines.map((line) => {
- let processedLine = line;
- if (line.length > ReadFileTool.MAX_LINE_LENGTH) {
- processedLine =
- line.substring(0, ReadFileTool.MAX_LINE_LENGTH) + '... [truncated]';
- truncated = true;
- }
-
- return processedLine;
- });
-
- const contentTruncated = endLine < lines.length || truncated;
-
- let llmContent = '';
- if (contentTruncated) {
- llmContent += `[File truncated: showing lines ${startLine + 1}-${endLine} of ${lines.length} total lines. Use offset parameter to view more.]\n`;
- }
- llmContent += formattedLines.join('\n');
-
- // Here, returnDisplay could potentially be enhanced, but for now,
- // it's kept empty as the LLM content itself is descriptive.
- return {
- llmContent,
- returnDisplay: '',
- };
- } catch (error) {
- const errorMsg = `Error reading file: ${error instanceof Error ? error.message : String(error)}`;
+ const result = await processSingleFileContent(
+ params.path,
+ this.rootDirectory,
+ params.offset,
+ params.limit,
+ );
+ if (result.error) {
return {
- llmContent: `Error reading file ${filePath}: ${errorMsg}`,
- returnDisplay: `Failed to read file: ${errorMsg}`,
+ llmContent: result.error, // The detailed error for LLM
+ returnDisplay: result.returnDisplay, // User-friendly error
};
}
+
+ return {
+ llmContent: result.llmContent,
+ returnDisplay: result.returnDisplay,
+ };
}
}
diff --git a/packages/server/src/tools/read-many-files.test.ts b/packages/server/src/tools/read-many-files.test.ts
index ea801ddb..5c6d94fa 100644
--- a/packages/server/src/tools/read-many-files.test.ts
+++ b/packages/server/src/tools/read-many-files.test.ts
@@ -115,6 +115,33 @@ describe('ReadManyFilesTool', () => {
};
expect(tool.validateParams(params)).toBeNull();
});
+
+ it('should return error if paths array contains an empty string', () => {
+ const params = { paths: ['file1.txt', ''] };
+ expect(tool.validateParams(params)).toBe(
+ 'Each item in "paths" must be a non-empty string/glob pattern.',
+ );
+ });
+
+ it('should return error if include array contains non-string elements', () => {
+ const params = {
+ paths: ['file1.txt'],
+ include: ['*.ts', 123] as string[],
+ };
+ expect(tool.validateParams(params)).toBe(
+ 'If provided, "include" must be an array of strings/glob patterns.',
+ );
+ });
+
+ it('should return error if exclude array contains non-string elements', () => {
+ const params = {
+ paths: ['file1.txt'],
+ exclude: ['*.log', {}] as string[],
+ };
+ expect(tool.validateParams(params)).toBe(
+ 'If provided, "exclude" must be an array of strings/glob patterns.',
+ );
+ });
});
describe('execute', () => {
diff --git a/packages/server/src/tools/read-many-files.ts b/packages/server/src/tools/read-many-files.ts
index b825de04..d826c9ba 100644
--- a/packages/server/src/tools/read-many-files.ts
+++ b/packages/server/src/tools/read-many-files.ts
@@ -7,13 +7,16 @@
import { BaseTool, ToolResult } from './tools.js';
import { SchemaValidator } from '../utils/schemaValidator.js';
import { getErrorMessage } from '../utils/errors.js';
-import * as fs from 'fs/promises';
import * as path from 'path';
import fg from 'fast-glob';
import { GEMINI_MD_FILENAME } from './memoryTool.js';
-
+import {
+ detectFileType,
+ processSingleFileContent,
+ DEFAULT_ENCODING,
+} from '../utils/fileUtils.js';
import { PartListUnion } from '@google/genai';
-import mime from 'mime-types';
+
/**
* Parameters for the ReadManyFilesTool.
*/
@@ -98,8 +101,6 @@ const DEFAULT_EXCLUDES: string[] = [
`**/${GEMINI_MD_FILENAME}`,
];
-// Default values for encoding and separator format
-const DEFAULT_ENCODING: BufferEncoding = 'utf-8';
const DEFAULT_OUTPUT_SEPARATOR_FORMAT = '--- {filePath} ---';
/**
@@ -256,11 +257,10 @@ Use this tool when the user's query implies needing the content of several files
} = params;
const toolBaseDir = this.targetDir;
-
const filesToConsider = new Set<string>();
const skippedFiles: Array<{ path: string; reason: string }> = [];
const processedFilesRelativePaths: string[] = [];
- const content: PartListUnion = [];
+ const contentParts: PartListUnion = [];
const effectiveExcludes = useDefaultExcludes
? [...DEFAULT_EXCLUDES, ...exclude]
@@ -315,69 +315,50 @@ Use this tool when the user's query implies needing the content of several files
const relativePathForDisplay = path
.relative(toolBaseDir, filePath)
.replace(/\\/g, '/');
- try {
- const mimeType = mime.lookup(filePath);
- if (
- mimeType &&
- (mimeType.startsWith('image/') || mimeType === 'application/pdf')
- ) {
- const fileExtension = path.extname(filePath);
- const fileNameWithoutExtension = path.basename(
- filePath,
- fileExtension,
- );
- const requestedExplicitly = inputPatterns.some(
- (pattern: string) =>
- pattern.toLowerCase().includes(fileExtension) ||
- pattern.includes(fileNameWithoutExtension),
- );
- if (!requestedExplicitly) {
- skippedFiles.push({
- path: relativePathForDisplay,
- reason:
- 'asset file (image/pdf) was not explicitly requested by name or extension',
- });
- continue;
- }
- const contentBuffer = await fs.readFile(filePath);
- const base64Data = contentBuffer.toString('base64');
- content.push({
- inlineData: {
- data: base64Data,
- mimeType,
- },
+ const fileType = detectFileType(filePath);
+
+ if (fileType === 'image' || fileType === 'pdf') {
+ const fileExtension = path.extname(filePath).toLowerCase();
+ const fileNameWithoutExtension = path.basename(filePath, fileExtension);
+ const requestedExplicitly = inputPatterns.some(
+ (pattern: string) =>
+ pattern.toLowerCase().includes(fileExtension) ||
+ pattern.includes(fileNameWithoutExtension),
+ );
+
+ if (!requestedExplicitly) {
+ skippedFiles.push({
+ path: relativePathForDisplay,
+ reason:
+ 'asset file (image/pdf) was not explicitly requested by name or extension',
});
- processedFilesRelativePaths.push(relativePathForDisplay);
- } else {
- const contentBuffer = await fs.readFile(filePath);
- // Basic binary detection: check for null bytes in the first 1KB
- const sample = contentBuffer.subarray(
- 0,
- Math.min(contentBuffer.length, 1024),
- );
- if (sample.includes(0)) {
- skippedFiles.push({
- path: relativePathForDisplay,
- reason: 'appears to be binary',
- });
- continue;
- }
- // Using default encoding
- const fileContent = contentBuffer.toString(DEFAULT_ENCODING);
- // Using default separator format
+ continue;
+ }
+ }
+
+ // Use processSingleFileContent for all file types now
+ const fileReadResult = await processSingleFileContent(
+ filePath,
+ toolBaseDir,
+ );
+
+ if (fileReadResult.error) {
+ skippedFiles.push({
+ path: relativePathForDisplay,
+ reason: `Read error: ${fileReadResult.error}`,
+ });
+ } else {
+ if (typeof fileReadResult.llmContent === 'string') {
const separator = DEFAULT_OUTPUT_SEPARATOR_FORMAT.replace(
'{filePath}',
relativePathForDisplay,
);
- content.push(`${separator}\n\n${fileContent}\n\n`);
- processedFilesRelativePaths.push(relativePathForDisplay);
+ contentParts.push(`${separator}\n\n${fileReadResult.llmContent}\n\n`);
+ } else {
+ contentParts.push(fileReadResult.llmContent); // This is a Part for image/pdf
}
- } catch (error) {
- skippedFiles.push({
- path: relativePathForDisplay,
- reason: `Read error: ${getErrorMessage(error)}`,
- });
+ processedFilesRelativePaths.push(relativePathForDisplay);
}
}
@@ -422,13 +403,13 @@ Use this tool when the user's query implies needing the content of several files
displayMessage += `No files were read and concatenated based on the criteria.\n`;
}
- if (content.length === 0) {
- content.push(
+ if (contentParts.length === 0) {
+ contentParts.push(
'No files matching the criteria were found or all were skipped.',
);
}
return {
- llmContent: content,
+ llmContent: contentParts,
returnDisplay: displayMessage.trim(),
};
}
diff --git a/packages/server/src/utils/fileUtils.test.ts b/packages/server/src/utils/fileUtils.test.ts
new file mode 100644
index 00000000..df912b0c
--- /dev/null
+++ b/packages/server/src/utils/fileUtils.test.ts
@@ -0,0 +1,433 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+ describe,
+ it,
+ expect,
+ vi,
+ beforeEach,
+ afterEach,
+ type Mock,
+} 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 as Mock;
+
+describe('fileUtils', () => {
+ let tempRootDir: string;
+ const originalProcessCwd = process.cwd;
+
+ let testTextFilePath: string;
+ let testImageFilePath: string;
+ let testPdfFilePath: string;
+ let testBinaryFilePath: string;
+ let nonExistentFilePath: string;
+ let directoryPath: string;
+
+ 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, 'notfound.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: string;
+
+ beforeEach(() => {
+ filePathForBinaryTest = path.join(tempRootDir, 'binaryCheck.tmp');
+ });
+
+ afterEach(() => {
+ if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+ actualNodeFs.unlinkSync(filePathForBinaryTest);
+ }
+ });
+
+ it('should return false for an empty file', () => {
+ actualNodeFs.writeFileSync(filePathForBinaryTest, '');
+ expect(isBinaryFile(filePathForBinaryTest)).toBe(false);
+ });
+
+ it('should return false for a typical text file', () => {
+ actualNodeFs.writeFileSync(
+ filePathForBinaryTest,
+ 'Hello, world!\nThis is a test file with normal text content.',
+ );
+ expect(isBinaryFile(filePathForBinaryTest)).toBe(false);
+ });
+
+ it('should return true for a file with many null bytes', () => {
+ 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(isBinaryFile(filePathForBinaryTest)).toBe(true);
+ });
+
+ it('should return true for a file with high percentage of non-printable ASCII', () => {
+ 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(isBinaryFile(filePathForBinaryTest)).toBe(true);
+ });
+
+ it('should return false if file access fails (e.g., ENOENT)', () => {
+ // Ensure the file does not exist
+ if (actualNodeFs.existsSync(filePathForBinaryTest)) {
+ actualNodeFs.unlinkSync(filePathForBinaryTest);
+ }
+ expect(isBinaryFile(filePathForBinaryTest)).toBe(false);
+ });
+ });
+
+ describe('detectFileType', () => {
+ let filePathForDetectTest: string;
+
+ 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 image type by extension (png)', () => {
+ mockMimeLookup.mockReturnValueOnce('image/png');
+ expect(detectFileType('file.png')).toBe('image');
+ });
+
+ it('should detect image type by extension (jpeg)', () => {
+ mockMimeLookup.mockReturnValueOnce('image/jpeg');
+ expect(detectFileType('file.jpg')).toBe('image');
+ });
+
+ it('should detect pdf type by extension', () => {
+ mockMimeLookup.mockReturnValueOnce('application/pdf');
+ expect(detectFileType('file.pdf')).toBe('pdf');
+ });
+
+ it('should detect known binary extensions as binary (e.g. .zip)', () => {
+ mockMimeLookup.mockReturnValueOnce('application/zip');
+ expect(detectFileType('archive.zip')).toBe('binary');
+ });
+ it('should detect known binary extensions as binary (e.g. .exe)', () => {
+ mockMimeLookup.mockReturnValueOnce('application/octet-stream'); // Common for .exe
+ expect(detectFileType('app.exe')).toBe('binary');
+ });
+
+ it('should use isBinaryFile for unknown extensions and detect as binary', () => {
+ 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(detectFileType(filePathForDetectTest)).toBe('binary');
+ });
+
+ it('should default to text if mime type is unknown and content is not binary', () => {
+ mockMimeLookup.mockReturnValueOnce(false); // Unknown mime type
+ // filePathForDetectTest is already a text file by default from beforeEach
+ expect(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).toContain('Read text file: test.txt');
+ 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 as { inlineData: unknown }).inlineData,
+ ).toBeDefined();
+ expect(
+ (result.llmContent as { inlineData: { mimeType: string } }).inlineData
+ .mimeType,
+ ).toBe('image/png');
+ expect(
+ (result.llmContent as { inlineData: { data: string } }).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 as { inlineData: unknown }).inlineData,
+ ).toBeDefined();
+ expect(
+ (result.llmContent as { inlineData: { mimeType: string } }).inlineData
+ .mimeType,
+ ).toBe('application/pdf');
+ expect(
+ (result.llmContent as { inlineData: { data: string } }).inlineData.data,
+ ).toBe(fakePdfData.toString('base64'));
+ expect(result.returnDisplay).toContain('Read pdf file: document.pdf');
+ });
+
+ 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).toContain(
+ 'Read text file: test.txt (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).toContain('Read text file: test.txt');
+ 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);
+ });
+ });
+});
diff --git a/packages/server/src/utils/fileUtils.ts b/packages/server/src/utils/fileUtils.ts
new file mode 100644
index 00000000..0e9eef4c
--- /dev/null
+++ b/packages/server/src/utils/fileUtils.ts
@@ -0,0 +1,280 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { PartUnion } from '@google/genai';
+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: BufferEncoding = 'utf-8';
+
+/**
+ * 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: string,
+ rootDirectory: string,
+): boolean {
+ const normalizedPathToCheck = path.normalize(pathToCheck);
+ const normalizedRootDirectory = path.normalize(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 True if the file appears to be binary.
+ */
+export function isBinaryFile(filePath: string): boolean {
+ try {
+ const fd = fs.openSync(filePath, 'r');
+ // Read up to 4KB or file size, whichever is smaller
+ const fileSize = fs.fstatSync(fd).size;
+ if (fileSize === 0) {
+ // Empty file is not considered binary for content checking
+ fs.closeSync(fd);
+ return false;
+ }
+ const bufferSize = Math.min(4096, fileSize);
+ const buffer = Buffer.alloc(bufferSize);
+ const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+ fs.closeSync(fd);
+
+ 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 {
+ // 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;
+ }
+}
+
+/**
+ * Detects the type of file based on extension and content.
+ * @param filePath Path to the file.
+ * @returns 'text', 'image', 'pdf', or 'binary'.
+ */
+export function detectFileType(
+ filePath: string,
+): 'text' | 'image' | 'pdf' | 'binary' {
+ const ext = path.extname(filePath).toLowerCase();
+ const lookedUpMimeType = mime.lookup(filePath); // Returns false if not found, or the mime type string
+
+ if (lookedUpMimeType && lookedUpMimeType.startsWith('image/')) {
+ return 'image';
+ }
+ if (lookedUpMimeType && 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';
+ }
+
+ // Fallback to content-based check if mime type wasn't conclusive for image/pdf
+ // and it's not a known binary extension.
+ if (isBinaryFile(filePath)) {
+ return 'binary';
+ }
+
+ return 'text';
+}
+
+export interface ProcessedFileReadResult {
+ llmContent: PartUnion; // string for text, Part for image/pdf/unreadable binary
+ returnDisplay: string;
+ error?: string; // Optional error message for the LLM if file processing failed
+ isTruncated?: boolean; // For text files, indicates if content was truncated
+ originalLineCount?: number; // For text files
+ linesShown?: [number, number]; // For text files [startLine, endLine] (1-based for display)
+}
+
+/**
+ * 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: string,
+ rootDirectory: string,
+ offset?: number,
+ limit?: number,
+): Promise<ProcessedFileReadResult> {
+ 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 = fs.statSync(filePath); // Sync check
+ if (stats.isDirectory()) {
+ return {
+ llmContent: '',
+ returnDisplay: 'Path is a directory.',
+ error: `Path is a directory, not a file: ${filePath}`,
+ };
+ }
+
+ const fileType = 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 '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: `Read text file: ${relativePathForDisplay}${isTruncated ? ' (truncated)' : ''}`,
+ isTruncated,
+ originalLineCount,
+ linesShown: [actualStartLine + 1, endLine],
+ };
+ }
+ case 'image':
+ case 'pdf': {
+ 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: never = 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}`,
+ };
+ }
+}
generated by cgit v1.2.3 (git 2.51.0) at 2025-11-05 10:00:12 +0000