@nexrall/code-core 1.4.11 → 1.4.12

package/dist/tools/executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AAsgEtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAiBrB"}
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/tools/executor.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAC3C,OAAO,EAAyB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AA6iEtE,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,WAAW,CAAC,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,EAClC,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CAiBrB"}

package/dist/tools/executor.js

@@ -52,8 +52,24 @@ const tsLangService_1 = require("./tsLangService");
 // ─── Constants ────────────────────────────────────────────────────────────────
 const DEFAULT_TIMEOUT_MS = 60000;
 const MAX_FETCH_BYTES = 200 * 1024; // 200 KB
-const MAX_READ_BYTES = 500 * 1024; // 500 KB
+const MAX_READ_BYTES = 500 * 1024; // 500 KB — still used by notebook_read (JSON.parse needs it whole)
 const MAX_OUTPUT_CHARS = 100000; // bash / grep output cap (~100 KB)
+// read_file has NO byte-size gate (unlike the old 500KB cutoff) — like Claude
+// Code, a file of any size can be read; it's always streamed line-by-line so
+// memory is bounded regardless of file size. Instead there are two independent
+// caps per call, mirroring Claude Code's Read tool:
+//   - MAX_READ_LINES:  a hard line-count ceiling (default window AND clamp on
+//     an explicit limit) so one call never floods context with thousands of
+//     short lines (JSON/minified/logs) just because the file is small in bytes.
+//   - MAX_READ_TOKENS: a hard token budget (rough chars/4 estimate). If the
+//     requested window would exceed it, we either return a PARTIAL page (no
+//     explicit limit — same UX as Claude Code's "first page + how to continue"
+//     notice) or an error (explicit limit given and it still doesn't fit —
+//     caller must shrink the limit or use search_files instead).
+const MAX_READ_LINES = 2000;
+const MAX_READ_TOKENS = 25000;
+const READ_CHARS_PER_TOKEN = 4; // rough, conservative — consistent with loop.ts's resume estimator
+const MAX_READ_CHARS = MAX_READ_TOKENS * READ_CHARS_PER_TOKEN; // 100,000 chars
 // GAP B — output spillover. The inline bash result keeps only HEAD+TAIL (~100 KB),
 // which loses the MIDDLE of a large log — often exactly where a stack trace's root
 // cause or a failing assertion lives. To make the full log recoverable WITHOUT
@@ -217,51 +233,99 @@ function isBinaryFile(filePath) {
         return false;
     }
 }
+function formatNumberedLine(offset, indexInKept, line) {
+    return `${String(offset + indexInKept + 1).padStart(4, ' ')}\t${line}`;
+}
 /**
- * Read a bounded line window [offset, offset+limit) from a file too large to load
- * whole, by streaming it in chunks and keeping only the requested lines. Memory is
- * bounded by (limit lines actually kept) + one chunk, never the whole file — so a
- * 20MB bash-output spill file can be inspected section-by-section. (GAP B.)
+ * Read a bounded window [offset, offset+limit) of a file by streaming it in
+ * chunks — memory is bounded by what's actually kept, never the whole file, so
+ * this is safe for files of ANY size (there is no byte-size gate on read_file
+ * at all, matching Claude Code). Two independent hard caps apply per call:
+ *   - MAX_READ_LINES lines
+ *   - MAX_READ_TOKENS tokens (~MAX_READ_CHARS chars) of formatted output
+ * If an explicit `requestedLimit` was given and the token cap is hit before
+ * that many lines were produced, the call fails with an actionable error
+ * (mirrors Claude Code: "a read that passes an explicit offset or limit and
+ * still exceeds the token limit returns an error"). Otherwise (default,
+ * no explicit limit) it silently returns a partial page with a continuation
+ * note — never an error just for being a big file.
  */
-async function readLargeFileWindow(resolved, offset, limit, kb) {
+async function readFileWindowed(resolved, offset, requestedLimit) {
     return new Promise((resolve) => {
-        const endLine = offset + limit; // exclusive, 0-based
+        const explicitLimit = requestedLimit > 0;
+        const lineScanCap = explicitLimit ? Math.min(requestedLimit, MAX_READ_LINES) : MAX_READ_LINES;
+        const hardEndLine = offset + lineScanCap; // exclusive, 0-based
         const kept = [];
+        let keptChars = 0;
         let lineNo = 0; // 0-based index of the NEXT line to be completed
         let carry = ''; // partial line spanning chunk boundaries
         let stopped = false;
+        let hitTokenCap = false;
+        let sawEof = false;
         const stream = fs.createReadStream(resolved, { encoding: 'utf-8', highWaterMark: 256 * 1024 });
+        // Returns false if adding this line would exceed the token budget (line NOT kept).
+        const tryPushLine = (line) => {
+            const formatted = formatNumberedLine(offset, kept.length, line);
+            const added = formatted.length + 1; // +1 for the join newline
+            if (keptChars + added > MAX_READ_CHARS) {
+                hitTokenCap = true;
+                return false;
+            }
+            kept.push(line);
+            keptChars += added;
+            return true;
+        };
         const finish = () => {
             if (stopped)
                 return;
             stopped = true;
             stream.destroy();
+            if (hitTokenCap && explicitLimit) {
+                resolve({
+                    error: `Requested range (offset:${offset}, limit:${requestedLimit}) is too large — exceeds ${MAX_READ_TOKENS} tokens. ` +
+                        `Pass a smaller limit, or use search_files to locate the relevant part first.`,
+                });
+                return;
+            }
             const first = offset + 1;
             const last = offset + kept.length;
-            const numbered = kept.map((l, i) => `${String(offset + i + 1).padStart(4, ' ')}\t${l}`).join('\n');
-            const note = kept.length < limit
+            const numbered = kept.map((l, i) => formatNumberedLine(offset, i, l)).join('\n');
+            const totalNote = sawEof ? `/${lineNo}` : '';
+            const note = sawEof
                 ? ` (reached end of file at line ${last})`
-                : ` (more lines follow — increase offset to continue)`;
-            resolve({ output: `[File: ${resolved} — ${kb} KB, showing lines ${first}-${last}${note}]\n${numbered}` });
+                : ` (more lines follow — pass offset:${last} to continue, or search_files to locate the relevant part)`;
+            resolve({ output: `[File: ${resolved} — lines ${first}-${last}${totalNote}${note}]\n${numbered}` });
         };
         stream.on('data', (chunk) => {
             const text = carry + (typeof chunk === 'string' ? chunk : chunk.toString('utf-8'));
             const lines = text.split('\n');
             carry = lines.pop() ?? ''; // last element is an incomplete line (or '')
             for (const line of lines) {
-                if (lineNo >= offset && lineNo < endLine)
-                    kept.push(line);
-                lineNo++;
-                if (lineNo >= endLine) {
-                    finish();
-                    return;
+                if (lineNo >= offset) {
+                    if (lineNo >= hardEndLine) {
+                        finish();
+                        return;
+                    }
+                    if (!tryPushLine(line)) {
+                        finish();
+                        return;
+                    }
                 }
+                lineNo++;
             }
         });
         stream.on('end', () => {
+            if (stopped)
+                return;
             // Flush the final carry (file not ending in newline) if it's in range.
-            if (!stopped && carry !== '' && lineNo >= offset && lineNo < endLine)
-                kept.push(carry);
+            if (carry !== '' && lineNo >= offset && lineNo < hardEndLine) {
+                if (!tryPushLine(carry)) {
+                    finish();
+                    return;
+                }
+                lineNo++;
+            }
+            sawEof = true;
             finish();
         });
         stream.on('error', (err) => { if (!stopped) {
@@ -278,38 +342,19 @@ async function readFile(input, workDir) {
         return { error: 'Missing required parameter: path' };
     try {
         const resolved = resolvePath(filePath, workDir);
-        const stat = fs.statSync(resolved);
+        fs.statSync(resolved); // throws ENOENT/EISDIR etc with a clear message if the path is bad
         // Reject binary files early — reading them as UTF-8 produces garbage.
+        // (isBinaryFile only samples the first 8KB, so this is cheap regardless of file size.)
         if (isBinaryFile(resolved)) {
             const ext = path.extname(resolved).toLowerCase();
             return { error: `Cannot read binary file: ${resolved} (${ext || 'no extension'}). Use a text-based tool or convert it first.` };
         }
-        // Large-file path: when the file exceeds the in-memory cap, a full readFileSync
-        // would OOM — but we must still be able to inspect SECTIONS (this is what makes a
-        // 20MB bash-output spill file usable, GAP B). If offset+limit are given we stream
-        // line-by-line and materialise only the requested window; otherwise we require it.
-        if (stat.size > MAX_READ_BYTES) {
-            const kb = (stat.size / 1024).toFixed(0);
-            if (limit <= 0) {
-                return { error: `File too large (${kb} KB, max ${MAX_READ_BYTES / 1024} KB). Pass offset + limit to read a section (e.g. {offset:0, limit:500}), or search_files to locate the relevant part first.` };
-            }
-            return await readLargeFileWindow(resolved, offset, limit, kb);
-        }
-        const content = fs.readFileSync(resolved, 'utf-8');
-        const allLines = content.split('\n');
-        const totalLines = allLines.length;
-        const startLine = offset; // 0-based
-        const endLine = limit > 0 ? Math.min(startLine + limit, totalLines) : totalLines;
-        const slice = allLines.slice(startLine, endLine);
-        // Prefix each line with its 1-based line number (like cat -n / Claude Code view)
-        const numbered = slice.map((l, i) => {
-            const lineNo = String(startLine + i + 1).padStart(4, ' ');
-            return `${lineNo}\t${l}`;
-        }).join('\n');
-        const rangeNote = (offset > 0 || limit > 0)
-            ? ` lines ${startLine + 1}-${endLine}/${totalLines}`
-            : ` ${totalLines} lines`;
-        return { output: `[File: ${resolved} (${rangeNote})]\n${numbered}` };
+        // No byte-size gate — a file of any size can be read; it's always streamed
+        // line-by-line so memory is bounded regardless of file size (matches Claude
+        // Code, which has no separate "too large" error either). Instead, one call
+        // is capped at MAX_READ_LINES lines and MAX_READ_TOKENS tokens (see
+        // readFileWindowed for exact semantics of each cap).
+        return await readFileWindowed(resolved, offset, limit);
     }
     catch (err) {
         return { error: err.message };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.11",
+  "version": "1.4.12",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",