zames_pro 2.80.4 → 2.80.8

package/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.80.8] - 2026-10-20
+
+### Changed
+
+- Internal improvements.
+
+## [2.80.7] - 2026-10-20
+
+### Fixed
+
+- stop filling the disk with temp dirs, coverage dumps and unbounded logs
+- word delete and word-left stop at a newline
+
+## [2.80.6] - 2026-10-20
+
+### Fixed
+
+- stop filling the disk with temp dirs, coverage dumps and unbounded logs
+- word delete and word-left stop at a newline
+
+## [2.80.5] - 2026-10-20
+
+### Fixed
+
+- a JSON array line in a transcript is not an event
+
 ## [2.80.4] - 2026-10-20
 
 ### Fixed

package/README.md

@@ -124,6 +124,10 @@ Key pieces:
 
 ## Why zames?
 
+- **Built with itself** — `zames_pro` is developed by `zames_pro`. No other
+  coding agent is used on this repository: the agent in this very terminal
+  reads the sources, runs the tests, fixes the bugs and commits the result.
+  That is the daily proof that it works and is actually used.
 - **No API key, no per-token bill** — it uses your own DeepSeek or Qwen chat
   account, not the paid API. Good for long, tool-heavy tasks.
 - **Same workflow as Claude Code / Codex** — tools, `AGENTS.md`, skills, MCP
@@ -707,6 +711,10 @@ zames не вызывает API модели. Он запускает headless C
 
 ## Почему zames?
 
+- **Разрабатывается сам собой** — над `zames_pro` работает `zames_pro`, а не
+  какой-то другой кодинг-агент: агент в этом самом терминале читает исходники,
+  гоняет тесты, чинит баги и коммитит результат. Это ежедневное доказательство,
+  что он работает и реально используется.
 - **Нет API-ключа и счёта за токены** — используется ваш собственный аккаунт
   чата DeepSeek или Qwen, а не платный API. Удобно для долгих задач с
   инструментами.

package/dist/commands.js

@@ -143,7 +143,9 @@ export function parseTranscript(body) {
             continue;
         try {
             const v = JSON.parse(t);
-            if (v && typeof v === 'object')
+            // Only a plain OBJECT is an event: an ARRAY (a stray JSON array line in
+            // a hand-edited/merged transcript) must not be treated as one.
+            if (v && typeof v === 'object' && !Array.isArray(v))
                 out.push(v);
         }
         catch {

package/dist/net-capture.js

@@ -348,19 +348,72 @@ export function extractTokenUsage(body) {
     return found;
 }
 // Saves the DeepSeek network response body to disk for post-mortem analysis.
-// The files live in ~/.zames/net-log — from them the real answer format is visible.
-// DEBUG ONLY: disabled unless ZAMES_NET_DEBUG=1. It writes a file per network
-// response (thousands of files / tens of MB) and is not needed for the agent
-// to work — the answer is taken from extractAnswer() in memory.
+// DEBUG ONLY: disabled unless ZAMES_NET_DEBUG=1.
+//
+// The dumps live in ~/.zames/net-log and one file PER RESPONSE is written, so
+// an unattended `npm run dev` (which sets ZAMES_NET_DEBUG=1) used to grow the
+// directory without bound: 77k files / 800 MB after a few days. On WSL that
+// directory sits inside ext4.vhdx, and the space of thousands of tiny deleted
+// files is never returned to Windows — the host disk fills up. So the log is
+// ROTATED here: `NET_LOG_KEEP` newest dumps are kept and a rotation runs at
+// most once every `NET_LOG_ROTATE_MS` (listing the dir on every response would
+// itself cost time on a huge directory).
+const NET_LOG_KEEP = 200;
+const NET_LOG_ROTATE_MS = 5 * 60_000;
+const NET_LOG_MAX_BYTES = 32 * 1024 * 1024;
+let netLogDir = null;
+let netLogLastRotate = 0;
+function netLogDirectory() {
+    if (netLogDir === null) {
+        netLogDir = path.join(os.homedir(), '.zames', 'net-log');
+    }
+    return netLogDir;
+}
+/** A stamp prefix (`YYYY-MM-DDTHH-MM-SS-mmmZ_`) sorts chronologically. */
+function netLogStamp() {
+    return new Date().toISOString().replace(/[:.]/g, '-');
+}
 export async function dumpNetBody(url, body) {
     if (!process.env.ZAMES_NET_DEBUG)
         return;
     try {
-        const dir = path.join(os.homedir(), '.zames', 'net-log');
+        const dir = netLogDirectory();
         await fs.mkdir(dir, { recursive: true });
-        const stamp = new Date().toISOString().replace(/[:.]/g, '-');
         const safe = url.replace(/[^a-zA-Z0-9_.-]/g, '_').slice(0, 80);
-        await fs.writeFile(path.join(dir, stamp + '_' + safe + '.txt'), body, 'utf-8');
+        await fs.writeFile(path.join(dir, netLogStamp() + '_' + safe + '.txt'), body.slice(0, NET_LOG_MAX_BYTES), 'utf-8');
+        await rotateNetLogThrottled(dir);
     }
     catch { }
 }
+/**
+ * Keeps only the newest `NET_LOG_KEEP` dumps. Exported for the test: the
+ * rotation is the only thing standing between `ZAMES_NET_DEBUG=1` and an
+ * unbounded directory, so it is checked directly.
+ */
+export async function rotateNetLog(dir, keep = NET_LOG_KEEP, now = Date.now()) {
+    // The stamp prefix sorts the names chronologically, so a plain sort is
+    // enough — no stat() per file (a directory with 77k entries would make
+    // 77k syscalls on every response).
+    const names = (await fs.readdir(dir).catch(() => [])).filter((n) => n.endsWith('.txt'));
+    if (names.length <= keep)
+        return 0;
+    names.sort();
+    const stale = names.slice(0, names.length - keep);
+    let removed = 0;
+    for (const n of stale) {
+        await fs
+            .rm(path.join(dir, n), { force: true })
+            .then(() => removed++)
+            .catch(() => { });
+    }
+    netLogLastRotate = now;
+    return removed;
+}
+/** Throttled rotation used by dumpNetBody (at most once per interval). */
+async function rotateNetLogThrottled(dir) {
+    const now = Date.now();
+    if (now - netLogLastRotate < NET_LOG_ROTATE_MS)
+        return;
+    netLogLastRotate = now;
+    await rotateNetLog(dir, NET_LOG_KEEP, now);
+}

package/dist/transcript.js

@@ -1,5 +1,36 @@
 import fs from 'fs';
 import path from 'path';
+// A transcript file is appended per RUN and never deleted, so ~/.zames/logs
+// grew without bound (177 files / 138 MB observed). On WSL the directory sits
+// inside ext4.vhdx: the space of deleted files is not returned to the Windows
+// host, so a big log dir is also a host-disk problem. Rotate on start-up: keep
+// the newest MAX_TRANSCRIPT_FILES and drop the rest.
+const MAX_TRANSCRIPT_FILES = 200;
+// The constructor is SYNCHRONOUS (it opens the stream right away), so the
+// rotation that must happen before the create has to be sync as well.
+export function rotateTranscripts(dir, keep = MAX_TRANSCRIPT_FILES) {
+    let names;
+    try {
+        names = fs.readdirSync(dir).filter((n) => n.endsWith('.jsonl'));
+    }
+    catch {
+        // A missing/unreadable dir must not break the run: the transcript is
+        // created right after and mkdirSync has its own error handling.
+        return 0;
+    }
+    if (names.length <= keep)
+        return 0;
+    names.sort();
+    let removed = 0;
+    for (const n of names.slice(0, names.length - keep)) {
+        try {
+            fs.rmSync(path.join(dir, n), { force: true });
+            removed++;
+        }
+        catch { }
+    }
+    return removed;
+}
 function transcriptErrorLine(e) {
     return `transcript: failed to create file: ${e.message}`;
 }
@@ -27,6 +58,9 @@ export class Transcript {
             const safeName = String(sessionName)
                 .replace(/[\\/:*?"<>|\u0000-\u001f]/g, '_')
                 .trim() || 'session';
+            // Rotation BEFORE the create: the new file then has the newest stamp,
+            // so the current run's transcript is never a deletion candidate.
+            rotateTranscripts(dir);
             this.file = path.join(dir, `${safeName}-${stamp}.jsonl`);
             this.stream = fs.createWriteStream(this.file, { flags: 'a' });
             // Write errors (disk full, file deleted, etc.) arrive as an 'error'

package/dist/tui/edit.js

@@ -74,9 +74,12 @@ export function del(s) {
 export function deleteWordLeft(s) {
     const chars = charsOf(s);
     let i = s.cursor;
-    while (i > 0 && /\s/.test(chars[i - 1]))
+    // A NEWLINE is a hard boundary: at the start of a line the key does
+    // nothing instead of eating the break and the previous line's word
+    // (deleteWordRight and wordLeft already stop at a newline).
+    while (i > 0 && chars[i - 1] !== NL && /\s/.test(chars[i - 1]))
         i--;
-    while (i > 0 && !/\s/.test(chars[i - 1]))
+    while (i > 0 && chars[i - 1] !== NL && !/\s/.test(chars[i - 1]))
         i--;
     chars.splice(i, s.cursor - i);
     return { ...s, buf: chars.join(''), cursor: i };
@@ -137,9 +140,11 @@ export function moveEnd(s) {
 export function wordLeft(s) {
     const chars = charsOf(s);
     let i = s.cursor;
-    while (i > 0 && /\s/.test(chars[i - 1]))
+    // Stop at a newline (mirrors deleteWordLeft/deleteWordRight): the cursor
+    // must not jump to the previous LINE, only to the previous word.
+    while (i > 0 && chars[i - 1] !== NL && /\s/.test(chars[i - 1]))
         i--;
-    while (i > 0 && !/\s/.test(chars[i - 1]))
+    while (i > 0 && chars[i - 1] !== NL && !/\s/.test(chars[i - 1]))
         i--;
     return i === s.cursor ? s : { ...s, cursor: i };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.80.4",
+  "version": "2.80.8",
   "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": {