indusagi-coding-agent 0.1.25 → 0.1.27

package/dist/core/tools/read.js

@@ -1,397 +0,0 @@
-/**
- * Read Tool - Read file contents with automatic image handling
- *
- * @module core/tools/read
- * @description
- * Implements the read tool for the agent. Reads file contents with:
- * - Support for line-based offset/limit
- * - Automatic image detection and resizing
- * - Large file truncation handling
- * - Remote execution support (SSH, containers)
- *
- * Based on file reading tools from Anthropic's Claude API and common Unix utilities.
- * Refactored for agent multimodal content handling.
- * - Proper path resolution and validation
- *
- * ## Tool Interface
- *
- * **Input Parameters:**
- * - `path` (required): File path to read (relative or absolute)
- * - `offset` (optional): Starting line number (1-indexed)
- * - `limit` (optional): Maximum number of lines to read
- *
- * **Output:**
- * - Text files: Line content as text
- * - Image files: Image data with metadata
- * - Large files: Truncated with temp file path
- *
- * **Error Behavior:**
- * - File not found → Tool error "ENOENT: no such file"
- * - Permission denied → Tool error "EACCES: permission denied"
- * - Invalid path → Tool error "Path outside working directory"
- * - Large file not truncable → Tool error "File too large"
- *
- * ## Usage in Agent
- *
- * The agent uses this tool to:
- * - Read source code files for analysis
- * - Check configuration files
- * - Read documentation and READMEs
- * - View images and diagrams
- * - Inspect logs and build output
- *
- * ## Features
- *
- * **Line-based Access:**
- * - offset: Start reading from line N (1-indexed)
- * - limit: Read at most N lines
- * - Useful for large files
- *
- * **Image Handling:**
- * - Auto-detect image MIME type
- * - Resize large images (configurable)
- * - Include dimension information
- * - Provide helpful notes for vision models
- *
- * **Truncation:**
- * - Truncate large files at front (keeps last N bytes)
- * - Write full content to temp file if needed
- * - Return truncation info for reference
- *
- * **Path Safety:**
- * - Resolve relative paths relative to cwd
- * - Prevent path traversal attacks (no ../../../etc/passwd)
- * - Validate paths are accessible
- *
- * ## Security
- *
- * **Path validation:**
- * - All paths resolved relative to cwd
- * - No symlink following by default
- * - Directory traversal prevented
- *
- * **Permission checks:**
- * - File must be readable
- * - Working directory must exist
- * - Errors returned for permission denied
- *
- * **Data safety:**
- * - Large files truncated (not read into memory)
- * - Binary files handled gracefully
- * - No automatic execution of file contents
- *
- * ## Customization
- *
- * **Image Resizing:**
- * ```typescript
- * const tool = createReadTool(cwd, {
- *   autoResizeImages: true,
- *   imageMaxBytes: 500 * 1024, // 500KB limit
- * });
- * ```
- *
- * **Remote Execution (SSH):**
- * ```typescript
- * const sshTool = createReadTool(cwd, {
- *   operations: {
- *     readFile: (path) => sshExec(`cat ${path}`),
- *     access: (path) => sshExec(`test -r ${path}`),
- *   },
- * });
- * ```
- *
- * ## Examples
- *
- * ### Read a source file
- * ```typescript
- * // Agent calls: read {path: "src/main.ts"}
- * // Returns: Full file content or truncated with temp file path
- * ```
- *
- * ### Read specific lines
- * ```typescript
- * // Agent calls: read {path: "test.txt", offset: 10, limit: 5}
- * // Returns: Lines 10-14
- * ```
- *
- * ### Auto-resized image
- * ```typescript
- * // Agent calls: read {path: "diagram.png"}
- * // Returns: Image content, resized if > 2MB, with dimensions
- * ```
- *
- * ## Attribution
- *
- * Based on: indusagi-agent read tool
- * Modifications:
- * - Added image auto-detection and resizing
- * - Added line-based offset/limit support
- * - Added custom operations interface
- * - Improved truncation handling
- */
-import { Type } from "@sinclair/typebox";
-import { constants } from "fs";
-import { access as fsAccess, readFile as fsReadFile } from "fs/promises";
-import { formatDimensionNote, resizeImage } from "../../utils/image-resize.js";
-import { detectSupportedImageMimeTypeFromFile } from "../../utils/mime.js";
-import { resolveReadPath } from "./path-utils.js";
-import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead } from "./truncate.js";
-// ============================================================================
-// Schema & Types
-// ============================================================================
-/**
- * JSON Schema for read tool parameters
- * @internal
- */
-const readSchema = Type.Object({
-    path: Type.String({ description: "Path to the file to read (relative or absolute)" }),
-    offset: Type.Optional(Type.Number({ description: "Line number to start reading from (1-indexed)" })),
-    limit: Type.Optional(Type.Number({ description: "Maximum number of lines to read" })),
-});
-/**
- * Default read operations using local filesystem
- * @internal
- */
-const defaultReadOperations = {
-    readFile: (path) => fsReadFile(path),
-    access: (path) => fsAccess(path, constants.R_OK),
-    detectImageMimeType: detectSupportedImageMimeTypeFromFile,
-};
-// ============================================================================
-// Tool Factory & Exports
-// ============================================================================
-/**
- * Create a read tool with custom configuration
- *
- * Creates an AgentTool that can read files with:
- * - Line-based offset and limit
- * - Automatic image detection and resizing
- * - Large file truncation
- * - Remote execution support
- * - Proper path resolution
- *
- * **Tool Behavior:**
- * - Resolves paths relative to working directory
- * - Prevents path traversal (no ../../../etc/passwd)
- * - Detects images and handles specially
- * - Truncates large files at head (keeps tail)
- * - Returns truncation info for reference
- *
- * **Tool Parameters:**
- * - `path` (required): File to read
- * - `offset` (optional): Starting line (1-indexed)
- * - `limit` (optional): Maximum lines to read
- *
- * **Tool Output:**
- * - Text files: File content (possibly truncated)
- * - Image files: Image data with metadata
- * - Details: Truncation info if file was too large
- *
- * **Error Handling:**
- * - File not found: Tool error "ENOENT: no such file"
- * - Permission denied: Tool error "EACCES: permission denied"
- * - Invalid path: Tool error "Path outside working directory"
- * - Other errors: Tool error with message
- *
- * @param cwd - Working directory for relative path resolution
- *   - All relative paths resolved from this directory
- *   - Prevents directory traversal attacks
- *   - Can be overridden per execution
- *
- * @param options - Optional configuration
- *   - autoResizeImages: Enable/disable image resizing (default: true)
- *   - operations: Custom file reading backend (default: filesystem)
- *
- * @returns AgentTool instance ready to use
- *
- * @example
- * ```typescript
- * // Basic tool
- * const tool = createReadTool(process.cwd());
- *
- * // With image resizing disabled
- * const noResizeTool = createReadTool(cwd, {
- *   autoResizeImages: false,
- * });
- *
- * // With remote backend (SSH)
- * const remoteTool = createReadTool(cwd, {
- *   operations: sshOperations,
- * });
- * ```
- *
- * @see ReadToolOptions for detailed configuration
- * @see ReadOperations for custom backend interface
- */
-export function createReadTool(cwd, options) {
-    const autoResizeImages = options?.autoResizeImages ?? true;
-    const ops = options?.operations ?? defaultReadOperations;
-    return {
-        name: "read",
-        label: "read",
-        description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp). Images are sent as attachments. For text files, output is truncated to ${DEFAULT_MAX_LINES} lines or ${DEFAULT_MAX_BYTES / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
-        parameters: readSchema,
-        execute: async (_toolCallId, { path, offset, limit }, signal) => {
-            const absolutePath = resolveReadPath(path, cwd);
-            return new Promise((resolve, reject) => {
-                // Check if already aborted
-                if (signal?.aborted) {
-                    reject(new Error("Operation aborted"));
-                    return;
-                }
-                let aborted = false;
-                // Set up abort handler
-                const onAbort = () => {
-                    aborted = true;
-                    reject(new Error("Operation aborted"));
-                };
-                if (signal) {
-                    signal.addEventListener("abort", onAbort, { once: true });
-                }
-                // Perform the read operation
-                (async () => {
-                    try {
-                        // Check if file exists
-                        await ops.access(absolutePath);
-                        // Check if aborted before reading
-                        if (aborted) {
-                            return;
-                        }
-                        const mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : undefined;
-                        // Read the file based on type
-                        let content;
-                        let details;
-                        if (mimeType) {
-                            // Read as image (binary)
-                            const buffer = await ops.readFile(absolutePath);
-                            const base64 = buffer.toString("base64");
-                            if (autoResizeImages) {
-                                // Resize image if needed
-                                const resized = await resizeImage({ type: "image", data: base64, mimeType });
-                                const dimensionNote = formatDimensionNote(resized);
-                                let textNote = `Read image file [${resized.mimeType}]`;
-                                if (dimensionNote) {
-                                    textNote += `\n${dimensionNote}`;
-                                }
-                                content = [
-                                    { type: "text", text: textNote },
-                                    { type: "image", data: resized.data, mimeType: resized.mimeType },
-                                ];
-                            }
-                            else {
-                                const textNote = `Read image file [${mimeType}]`;
-                                content = [
-                                    { type: "text", text: textNote },
-                                    { type: "image", data: base64, mimeType },
-                                ];
-                            }
-                        }
-                        else {
-                            // Read as text
-                            const buffer = await ops.readFile(absolutePath);
-                            const textContent = buffer.toString("utf-8");
-                            const allLines = textContent.split("\n");
-                            const totalFileLines = allLines.length;
-                            // Apply offset if specified (1-indexed to 0-indexed)
-                            const startLine = offset ? Math.max(0, offset - 1) : 0;
-                            const startLineDisplay = startLine + 1; // For display (1-indexed)
-                            // Check if offset is out of bounds
-                            if (startLine >= allLines.length) {
-                                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
-                            }
-                            // If limit is specified by user, use it; otherwise we'll let truncateHead decide
-                            let selectedContent;
-                            let userLimitedLines;
-                            if (limit !== undefined) {
-                                const endLine = Math.min(startLine + limit, allLines.length);
-                                selectedContent = allLines.slice(startLine, endLine).join("\n");
-                                userLimitedLines = endLine - startLine;
-                            }
-                            else {
-                                selectedContent = allLines.slice(startLine).join("\n");
-                            }
-                            // Apply truncation (respects both line and byte limits)
-                            const truncation = truncateHead(selectedContent);
-                            let outputText;
-                            if (truncation.firstLineExceedsLimit) {
-                                // First line at offset exceeds 30KB - tell model to use bash
-                                const firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
-                                outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(DEFAULT_MAX_BYTES)} limit. Use bash: sed -n '${startLineDisplay}p' ${path} | head -c ${DEFAULT_MAX_BYTES}]`;
-                                details = { truncation };
-                            }
-                            else if (truncation.truncated) {
-                                // Truncation occurred - build actionable notice
-                                const endLineDisplay = startLineDisplay + truncation.outputLines - 1;
-                                const nextOffset = endLineDisplay + 1;
-                                outputText = truncation.content;
-                                if (truncation.truncatedBy === "lines") {
-                                    outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]`;
-                                }
-                                else {
-                                    outputText += `\n\n[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Use offset=${nextOffset} to continue.]`;
-                                }
-                                details = { truncation };
-                            }
-                            else if (userLimitedLines !== undefined && startLine + userLimitedLines < allLines.length) {
-                                // User specified limit, there's more content, but no truncation
-                                const remaining = allLines.length - (startLine + userLimitedLines);
-                                const nextOffset = startLine + userLimitedLines + 1;
-                                outputText = truncation.content;
-                                outputText += `\n\n[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
-                            }
-                            else {
-                                // No truncation, no user limit exceeded
-                                outputText = truncation.content;
-                            }
-                            content = [{ type: "text", text: outputText }];
-                        }
-                        // Check if aborted after reading
-                        if (aborted) {
-                            return;
-                        }
-                        // Clean up abort handler
-                        if (signal) {
-                            signal.removeEventListener("abort", onAbort);
-                        }
-                        resolve({ content, details });
-                    }
-                    catch (error) {
-                        // Clean up abort handler
-                        if (signal) {
-                            signal.removeEventListener("abort", onAbort);
-                        }
-                        if (!aborted) {
-                            reject(error);
-                        }
-                    }
-                })();
-            });
-        },
-    };
-}
-/** Default read tool using process.cwd() - for backwards compatibility */
-/**
- * Default read tool instance
- *
- * Pre-created read tool using current process working directory.
- * Supports line-based reading, image resizing, and truncation.
- *
- * Equivalent to:
- * ```typescript
- * const readTool = createReadTool(process.cwd(), {
- *   autoResizeImages: true,
- * });
- * ```
- *
- * For custom configuration or remote backends, use createReadTool() directly.
- *
- * @example
- * ```typescript
- * import { readTool } from "./tools/read.js";
- * const agent = new Agent({ tools: [readTool] });
- * ```
- *
- * @see createReadTool for custom configuration
- */
-export const readTool = createReadTool(process.cwd());
-//# sourceMappingURL=read.js.map

package/dist/core/tools/read.js.map

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

package/dist/core/tools/truncate.d.ts

@@ -1,70 +0,0 @@
-/**
- * Shared truncation utilities for tool outputs.
- *
- * Truncation is based on two independent limits - whichever is hit first wins:
- * - Line limit (default: 2000 lines)
- * - Byte limit (default: 50KB)
- *
- * Never returns partial lines (except bash tail truncation edge case).
- */
-export declare const DEFAULT_MAX_LINES = 2000;
-export declare const DEFAULT_MAX_BYTES: number;
-export declare const GREP_MAX_LINE_LENGTH = 500;
-export interface TruncationResult {
-    /** The truncated content */
-    content: string;
-    /** Whether truncation occurred */
-    truncated: boolean;
-    /** Which limit was hit: "lines", "bytes", or null if not truncated */
-    truncatedBy: "lines" | "bytes" | null;
-    /** Total number of lines in the original content */
-    totalLines: number;
-    /** Total number of bytes in the original content */
-    totalBytes: number;
-    /** Number of complete lines in the truncated output */
-    outputLines: number;
-    /** Number of bytes in the truncated output */
-    outputBytes: number;
-    /** Whether the last line was partially truncated (only for tail truncation edge case) */
-    lastLinePartial: boolean;
-    /** Whether the first line exceeded the byte limit (for head truncation) */
-    firstLineExceedsLimit: boolean;
-    /** The max lines limit that was applied */
-    maxLines: number;
-    /** The max bytes limit that was applied */
-    maxBytes: number;
-}
-export interface TruncationOptions {
-    /** Maximum number of lines (default: 2000) */
-    maxLines?: number;
-    /** Maximum number of bytes (default: 50KB) */
-    maxBytes?: number;
-}
-/**
- * Format bytes as human-readable size.
- */
-export declare function formatSize(bytes: number): string;
-/**
- * Truncate content from the head (keep first N lines/bytes).
- * Suitable for file reads where you want to see the beginning.
- *
- * Never returns partial lines. If first line exceeds byte limit,
- * returns empty content with firstLineExceedsLimit=true.
- */
-export declare function truncateHead(content: string, options?: TruncationOptions): TruncationResult;
-/**
- * Truncate content from the tail (keep last N lines/bytes).
- * Suitable for bash output where you want to see the end (errors, final results).
- *
- * May return partial first line if the last line of original content exceeds byte limit.
- */
-export declare function truncateTail(content: string, options?: TruncationOptions): TruncationResult;
-/**
- * Truncate a single line to max characters, adding [truncated] suffix.
- * Used for grep match lines.
- */
-export declare function truncateLine(line: string, maxChars?: number): {
-    text: string;
-    wasTruncated: boolean;
-};
-//# sourceMappingURL=truncate.d.ts.map

package/dist/core/tools/truncate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"truncate.d.ts","sourceRoot":"","sources":["../../../src/core/tools/truncate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,QAAY,CAAC;AAC3C,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAExC,MAAM,WAAW,gBAAgB;IAChC,4BAA4B;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;IACtC,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,yFAAyF;IACzF,eAAe,EAAE,OAAO,CAAC;IACzB,2EAA2E;IAC3E,qBAAqB,EAAE,OAAO,CAAC;IAC/B,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IACjC,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CAkF/F;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CAyE/F;AAuBD;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAA6B,GACrC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAAE,CAKzC"}

package/dist/core/tools/truncate.js

@@ -1,205 +0,0 @@
-/**
- * Shared truncation utilities for tool outputs.
- *
- * Truncation is based on two independent limits - whichever is hit first wins:
- * - Line limit (default: 2000 lines)
- * - Byte limit (default: 50KB)
- *
- * Never returns partial lines (except bash tail truncation edge case).
- */
-export const DEFAULT_MAX_LINES = 2000;
-export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
-export const GREP_MAX_LINE_LENGTH = 500; // Max chars per grep match line
-/**
- * Format bytes as human-readable size.
- */
-export function formatSize(bytes) {
-    if (bytes < 1024) {
-        return `${bytes}B`;
-    }
-    else if (bytes < 1024 * 1024) {
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    }
-    else {
-        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-    }
-}
-/**
- * Truncate content from the head (keep first N lines/bytes).
- * Suitable for file reads where you want to see the beginning.
- *
- * Never returns partial lines. If first line exceeds byte limit,
- * returns empty content with firstLineExceedsLimit=true.
- */
-export function truncateHead(content, options = {}) {
-    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-    const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    // Check if no truncation needed
-    if (totalLines <= maxLines && totalBytes <= maxBytes) {
-        return {
-            content,
-            truncated: false,
-            truncatedBy: null,
-            totalLines,
-            totalBytes,
-            outputLines: totalLines,
-            outputBytes: totalBytes,
-            lastLinePartial: false,
-            firstLineExceedsLimit: false,
-            maxLines,
-            maxBytes,
-        };
-    }
-    // Check if first line alone exceeds byte limit
-    const firstLineBytes = Buffer.byteLength(lines[0], "utf-8");
-    if (firstLineBytes > maxBytes) {
-        return {
-            content: "",
-            truncated: true,
-            truncatedBy: "bytes",
-            totalLines,
-            totalBytes,
-            outputLines: 0,
-            outputBytes: 0,
-            lastLinePartial: false,
-            firstLineExceedsLimit: true,
-            maxLines,
-            maxBytes,
-        };
-    }
-    // Collect complete lines that fit
-    const outputLinesArr = [];
-    let outputBytesCount = 0;
-    let truncatedBy = "lines";
-    for (let i = 0; i < lines.length && i < maxLines; i++) {
-        const line = lines[i];
-        const lineBytes = Buffer.byteLength(line, "utf-8") + (i > 0 ? 1 : 0); // +1 for newline
-        if (outputBytesCount + lineBytes > maxBytes) {
-            truncatedBy = "bytes";
-            break;
-        }
-        outputLinesArr.push(line);
-        outputBytesCount += lineBytes;
-    }
-    // If we exited due to line limit
-    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
-        truncatedBy = "lines";
-    }
-    const outputContent = outputLinesArr.join("\n");
-    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
-    return {
-        content: outputContent,
-        truncated: true,
-        truncatedBy,
-        totalLines,
-        totalBytes,
-        outputLines: outputLinesArr.length,
-        outputBytes: finalOutputBytes,
-        lastLinePartial: false,
-        firstLineExceedsLimit: false,
-        maxLines,
-        maxBytes,
-    };
-}
-/**
- * Truncate content from the tail (keep last N lines/bytes).
- * Suitable for bash output where you want to see the end (errors, final results).
- *
- * May return partial first line if the last line of original content exceeds byte limit.
- */
-export function truncateTail(content, options = {}) {
-    const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
-    const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
-    const totalBytes = Buffer.byteLength(content, "utf-8");
-    const lines = content.split("\n");
-    const totalLines = lines.length;
-    // Check if no truncation needed
-    if (totalLines <= maxLines && totalBytes <= maxBytes) {
-        return {
-            content,
-            truncated: false,
-            truncatedBy: null,
-            totalLines,
-            totalBytes,
-            outputLines: totalLines,
-            outputBytes: totalBytes,
-            lastLinePartial: false,
-            firstLineExceedsLimit: false,
-            maxLines,
-            maxBytes,
-        };
-    }
-    // Work backwards from the end
-    const outputLinesArr = [];
-    let outputBytesCount = 0;
-    let truncatedBy = "lines";
-    let lastLinePartial = false;
-    for (let i = lines.length - 1; i >= 0 && outputLinesArr.length < maxLines; i--) {
-        const line = lines[i];
-        const lineBytes = Buffer.byteLength(line, "utf-8") + (outputLinesArr.length > 0 ? 1 : 0); // +1 for newline
-        if (outputBytesCount + lineBytes > maxBytes) {
-            truncatedBy = "bytes";
-            // Edge case: if we haven't added ANY lines yet and this line exceeds maxBytes,
-            // take the end of the line (partial)
-            if (outputLinesArr.length === 0) {
-                const truncatedLine = truncateStringToBytesFromEnd(line, maxBytes);
-                outputLinesArr.unshift(truncatedLine);
-                outputBytesCount = Buffer.byteLength(truncatedLine, "utf-8");
-                lastLinePartial = true;
-            }
-            break;
-        }
-        outputLinesArr.unshift(line);
-        outputBytesCount += lineBytes;
-    }
-    // If we exited due to line limit
-    if (outputLinesArr.length >= maxLines && outputBytesCount <= maxBytes) {
-        truncatedBy = "lines";
-    }
-    const outputContent = outputLinesArr.join("\n");
-    const finalOutputBytes = Buffer.byteLength(outputContent, "utf-8");
-    return {
-        content: outputContent,
-        truncated: true,
-        truncatedBy,
-        totalLines,
-        totalBytes,
-        outputLines: outputLinesArr.length,
-        outputBytes: finalOutputBytes,
-        lastLinePartial,
-        firstLineExceedsLimit: false,
-        maxLines,
-        maxBytes,
-    };
-}
-/**
- * Truncate a string to fit within a byte limit (from the end).
- * Handles multi-byte UTF-8 characters correctly.
- */
-function truncateStringToBytesFromEnd(str, maxBytes) {
-    const buf = Buffer.from(str, "utf-8");
-    if (buf.length <= maxBytes) {
-        return str;
-    }
-    // Start from the end, skip maxBytes back
-    let start = buf.length - maxBytes;
-    // Find a valid UTF-8 boundary (start of a character)
-    while (start < buf.length && (buf[start] & 0xc0) === 0x80) {
-        start++;
-    }
-    return buf.slice(start).toString("utf-8");
-}
-/**
- * Truncate a single line to max characters, adding [truncated] suffix.
- * Used for grep match lines.
- */
-export function truncateLine(line, maxChars = GREP_MAX_LINE_LENGTH) {
-    if (line.length <= maxChars) {
-        return { text: line, wasTruncated: false };
-    }
-    return { text: `${line.slice(0, maxChars)}... [truncated]`, wasTruncated: true };
-}
-//# sourceMappingURL=truncate.js.map