zames_pro 2.80.1 → 2.80.2

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.80.2] - 2026-10-20
+
+### Fixed
+
+- wrapToWidth keeps the indentation and inner spaces of a line
+- **undo:** derive the backup name hash with sha1 instead of a path prefix
+
 ## [2.80.1] - 2026-10-20
 
 ### Fixed

package/dist/input/layout.js

@@ -183,41 +183,67 @@ export function wrapToWidth(s, maxCols) {
             out.push('');
             continue;
         }
-        let line = '';
-        let lineW = 0;
-        for (const word of raw.split(' ')) {
+        // A line that already fits is returned VERBATIM: wrapping is a width
+        // operation, not a normalizer. Splitting on spaces and re-joining ate the
+        // leading indentation (and emptied a line of only spaces), so an indented
+        // warning / echoed operator line lost its layout.
+        if (visLen(raw) <= width) {
+            out.push(raw);
+            continue;
+        }
+        // Wrapping is a WIDTH operation, not a normalizer: the spaces BETWEEN words
+        // (and the leading indentation) belong to the line and are reproduced
+        // verbatim. The old split(' ')/join(' ') glued the words back with ONE
+        // separator, so `'aaa bbb'` at width 7 became `'aaabbb'` and an indented
+        // warning lost its indent.
+        const words = raw.split(/ +/).filter((w) => w !== '');
+        const indent = raw.slice(0, raw.length - raw.trimStart().length);
+        let line = indent;
+        let lineW = visLen(indent);
+        let first = true;
+        for (let i = 0; i < words.length; i++) {
+            const word = words[i];
             const w = visLen(word);
             // Hard-split a word longer than a whole line.
             if (w > width) {
-                if (line) {
+                if (!first) {
                     out.push(line);
+                    line = '';
+                    lineW = 0;
                 }
                 let piece = '';
                 let pieceW = 0;
                 for (const ch of word) {
                     const cw = charWidth(ch.codePointAt(0));
                     if (pieceW + cw > width) {
-                        out.push(piece);
+                        out.push(line + piece);
+                        line = '';
+                        lineW = 0;
                         piece = '';
                         pieceW = 0;
                     }
                     piece += ch;
                     pieceW += cw;
                 }
-                line = piece;
-                lineW = pieceW;
+                line += piece;
+                lineW += pieceW;
+                first = false;
                 continue;
             }
-            const sep = line ? 1 : 0;
-            if (lineW + sep + w > width) {
+            if (!first && lineW + 1 + w > width) {
                 out.push(line);
                 line = word;
                 lineW = w;
+                first = false;
+                continue;
             }
-            else {
-                line = line ? line + ' ' + word : word;
-                lineW += sep + w;
+            if (!first) {
+                line += ' ';
+                lineW += 1;
             }
+            line += word;
+            lineW += w;
+            first = false;
         }
         out.push(line);
     }

package/dist/undo.js

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
-import { randomBytes } from 'crypto';
+import { randomBytes, createHash } from 'crypto';
 import { writeJsonAtomic } from './fsutil.js';
 const UNDO_DIR = path.join(os.homedir(), '.zames', 'undo');
 const INDEX = path.join(UNDO_DIR, 'index.json');
@@ -42,13 +42,17 @@ export class UndoStore {
                 throw e;
         }
         const stamp = Date.now();
-        const hash = Buffer.from(filePath).toString('hex').slice(0, 16);
+        // The name only needs to be SHORT and unique; the backup name also
+        // carries a random suffix. A 16-hex prefix of the hex-encoded path is
+        // the first 8 BYTES of the path, which for files in one directory is
+        // the SAME string (and identical without the random part).
+        const hash = createHash('sha1').update(filePath).digest('hex').slice(0, 16);
         let backupFile = null;
         if (existed) {
-            // The stamp is only ms-precision and the hash is the first 8 bytes of
-            // the path, so two SIBLING files edited in the same millisecond would
-            // collide and the second write would clobber the first (losing the
-            // backup). Add a random suffix so a backup name is unique.
+            // The stamp is only ms-precision, so two edits in the same
+            // millisecond would share a backup name and the second write would
+            // clobber the first (losing the backup). Add a random suffix so a
+            // backup name is unique.
             const uniq = randomBytes(4).toString('hex');
             backupFile = path.join(UNDO_DIR, `${stamp}-${hash}-${uniq}.bak`);
             await fs.writeFile(backupFile, content);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.80.1",
+  "version": "2.80.2",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {