@hncode/hncode 0.3.6 → 0.4.0

package/src/tools/read.js

@@ -25,6 +25,14 @@ function hashLines(lines, start, end) {
 // Public alias so edit.js (and the line-range path) share ONE implementation.
 export const hashRegion = hashLines;
 
+// Reset the Read snapshot pool after files were rewound on disk. The pool holds
+// per-file content hashes plus the line regions the model has "seen"; once /undo
+// has put an older version back, every hash in it describes content that is no
+// longer there. Keeping them made the NEXT Edit fail with a staleness rejection
+// against a file the model had just watched being restored.
+export function forgetReadPool(ctx) {
+  if (ctx && ctx.readPool && typeof ctx.readPool.clear === 'function') ctx.readPool.clear();
+}
 export const spec = {
   name: 'Read',
   description: 'Read a text file. Returns the whole file by default; use line_offset / n_lines for a range.',
@@ -42,6 +50,13 @@ export const spec = {
     required: ['path'],
   },
   async execute(args, ctx) {
+    // A missing `path` used to reach resolvePath(undefined), which resolves to the
+    // workspace ROOT — so the failure surfaced as an EISDIR from fs.readFileSync
+    // instead of "you forgot the path". Cheap to check, and it tells the model
+    // exactly what to fix.
+    if (typeof args.path !== 'string' || !args.path.trim()) {
+      return 'Error: `path` is required and must be a non-empty string.';
+    }
     let p;
     try { p = resolvePath(args.path, ctx); } catch (e) { return e.message; }
     let buf;
@@ -50,7 +65,6 @@ export const spec = {
       return `Cannot read: ${args.path} appears to be a binary file (use a tool suited for binary).`;
     }
     let st;
-    try { st = fs.statSync(p); } catch { st = null; }
     // NO truncation: the caller asked for the file, so the whole file is returned
     // (line ranges still work via line_offset / n_lines). The old 1000-line and
     // 128 KB caps silently cut the content, which also corrupted the

package/src/tools/utils.js

@@ -3,6 +3,7 @@
 import path from 'node:path';
 import os from 'node:os';
 import fs from 'node:fs';
+import { recordBeforeWrite } from '../file-history.js';
 
 export const MAX_OUTPUT_BYTES = 128 * 1024; // cap tool results to avoid token blowup
 
@@ -54,6 +55,19 @@ export function ensureDir(p) {
   fs.mkdirSync(path.dirname(p), { recursive: true });
 }
 
+// Checkpoint `p` before a write tool modifies it, so /undo can put it back (see
+// file-history.js). The record is taken ONCE per turn, so what is captured is the
+// file as it stood before ANY of this turn's changes — the state the user would
+// expect "Undid 1 prompt" to restore.
+//
+// ctx.sessionId identifies the checkpoint store. A caller without one (a
+// subagent's own context, a test) simply gets no checkpoint rather than an error:
+// losing the safety net must never fail the actual write.
+export function checkpointBeforeWrite(p, ctx) {
+  if (!ctx || !ctx.sessionId) return false;
+  try { return recordBeforeWrite(ctx.sessionId, p); } catch { return false; }
+}
+
 // Read a file fully, returning its string. Throws if not a file.
 export function readFileBytes(p) {
   const st = fs.statSync(p);

package/src/tools/write.js

@@ -1,7 +1,7 @@
 // Write tool — mirrors the hncode Write tool schema & behavior.
 
 import fs from 'node:fs';
-import { resolvePath, ensureDir, truncateBuf } from './utils.js';
+import { resolvePath, ensureDir, truncateBuf, checkpointBeforeWrite } from './utils.js';
 
 export const spec = {
   name: 'Write',
@@ -16,14 +16,44 @@ export const spec = {
     required: ['path', 'content'],
   },
   async execute(args, ctx) {
+    // Validate BEFORE touching the filesystem. A truncated or malformed tool call
+    // arrives as `{ raw, _rawLen }` (agent.js falls back to that shape when the
+    // streamed JSON will not parse) or with `content` simply missing — and
+    // `fs.writeFileSync(p, undefined)` then threw Node's own
+    // `The "data" argument must be of type string…`, which told the model nothing
+    // about what to do or why. An unvalidated path is worse: `resolvePath(undefined)`
+    // resolves to the workspace root, so a truncated call could target the wrong
+    // file while the model believed it was writing a new one.
+    const truncated = args && args.raw
+      ? ` The arguments did not parse as JSON${args._rawLen ? ` (${args._rawLen} characters received)` : ''} — the call was most likely truncated. Retry, and split a large file across several Write calls (first part with mode "overwrite", the rest appended with mode "append").`
+      : '';
+    const path_ = args && args.path;
+    if (typeof path_ !== 'string' || !path_.trim()) {
+      return `Error: \`path\` is required and must be a non-empty string.${truncated}`;
+    }
+    if (typeof args.content !== 'string') {
+      const got = args.content === null ? 'null' : typeof args.content;
+      return `Error: \`content\` is required and must be a string (got ${got}).${truncated}`;
+    }
     let p;
-    try { p = resolvePath(args.path, ctx); } catch (e) { return e.message; }
+    try { p = resolvePath(path_, ctx); } catch (e) { return e.message; }
+    // `mode` is an enum in the schema, but the schema is not enforced locally: an
+    // unexpected value silently meant "overwrite" before. Say so instead.
+    const mode = args.mode == null ? 'overwrite' : args.mode;
+    if (mode !== 'overwrite' && mode !== 'append') {
+      return `Error: invalid mode ${JSON.stringify(mode)}; use "overwrite" or "append".`;
+    }
+    // Checkpoint the pre-write content so /undo can put it back (file-history.js).
+    // Taken BEFORE the write, once per turn, so the recorded version is the state
+    // before any of this turn's changes.
+    checkpointBeforeWrite(p, ctx);
     try {
       ensureDir(p);
-      const flag = args.mode === 'append' ? 'a' : 'w';
+      const flag = mode === 'append' ? 'a' : 'w';
       fs.writeFileSync(p, args.content, { flag });
-    } catch (e) { return `Error writing ${args.path}: ${e.message}`; }
+    } catch (e) { return `Error writing ${path_}: ${e.message}`; }
     const size = fs.statSync(p).size;
-    return `File written: ${args.path} (${size} bytes)`;
+    const verb = mode === 'append' ? 'appended to' : 'written';
+    return `File ${verb}: ${path_} (${size} bytes)`;
   },
 };