klyro 1.0.20 → 1.0.21

package/dist/tui/diff-parser.js

@@ -17,22 +17,45 @@
 export function parseUnifiedDiff(raw) {
     const out = [];
     let current = null;
+    // Candidate path from the `--- ` side: used when the `+++ ` side is
+    // /dev/null (deleted file) and therefore names no real path.
+    let fromPath = null;
     for (const line of raw.split('\n')) {
         if (line.startsWith('diff --git ')) {
             if (current)
                 out.push(current);
             current = null;
+            fromPath = null;
             continue;
         }
         if (line.startsWith('+++ ')) {
-            const path = stripDiffPrefix(line.slice(4));
-            if (path)
-                current = { path, lines: [] };
+            const toRaw = line.slice(4).trim();
+            // A new file section without a `diff --git` header must not swallow
+            // the previous file's lines — flush first.
+            if (current && current.lines.length > 0) {
+                out.push(current);
+                current = null;
+            }
+            const toPath = stripDiffPrefix(toRaw);
+            if (toPath && toPath !== '/dev/null') {
+                current = { path: toPath, lines: [] };
+            }
+            else if (fromPath && fromPath !== '/dev/null') {
+                // Deleted file: `--- a/f` / `+++ /dev/null` — keep the real path,
+                // not `/dev/null`.
+                current = { path: fromPath, lines: [] };
+            }
+            else {
+                current = null;
+            }
+            fromPath = null;
             continue;
         }
         if (line.startsWith('--- ')) {
-            // Path on the "from" side — we prefer the "to" path so the
-            // heading matches the file the user is editing.
+            // Stash the "from" path (see `+++ ` handling above) — we still
+            // prefer the "to" path so the heading matches the edited file.
+            const cand = stripDiffPrefix(line.slice(4).trim());
+            fromPath = cand || null;
             continue;
         }
         if (line.startsWith('@@')) {

package/dist/tui/markdown.js

@@ -146,7 +146,7 @@ export function highlightCodeLine(line, lang) {
     return parts;
 }
 /** Detect `file:line` / `file:line:col` references and attach OSC-8 hrefs. */
-export const FILE_LINE_RE = /((?:\.{0,2}\/)?[\w./-]+\.[a-zA-Z]+\w*):(\d+)(?::(\d+))?/g;
+export const FILE_LINE_RE = /(?<![:/\w])((?:\.{0,2}\/)?[\w./-]+\.[a-zA-Z]+\w*):(\d+)(?::(\d+))?/g;
 export function annotateFileLinks(parts) {
     const out = [];
     for (const p of parts) {

package/dist/tui/measure.js

@@ -85,8 +85,11 @@ export function blockHeight(b, termWidth) {
             return 1 + 1;
         case 'diff': {
             let n = 1; // summary
+            // Render prepends a 2-col `+ `/`- `/`  ` prefix per line (app.tsx),
+            // so measure against cw-2 — a bare-text wrap at full cw under-counts
+            // borderline lines by a row each and drifts the scroll anchor.
             for (const h of b.hunks)
-                n += 1 + h.lines.reduce((s, l) => s + wrapCount(l, cw), 0);
+                n += 1 + h.lines.reduce((s, l) => s + wrapCount(l, cw - 2), 0);
             return n + 1;
         }
         case 'plan':

package/dist/tui/scroll-model.d.ts

@@ -38,6 +38,8 @@ export type ScrollAction = {
 } | {
     type: 'CONTENT_GREW';
     lines: number;
+} | {
+    type: 'PRUNE';
 } | {
     type: 'REFLOW';
 };

package/dist/tui/scroll-model.js

@@ -65,6 +65,11 @@ export function scrollReducer(s, a, ctx) {
             }
             void maxTop;
             return { ...s, newSinceUnstick: s.newSinceUnstick + a.lines };
+        case 'PRUNE':
+            // Anchored item was compacted away: re-stick to bottom with a clean
+            // counter. Without the reset, a stale newSinceUnstick inflates the
+            // `↓ N new` badge after the re-stick.
+            return stickBottom();
         case 'REFLOW':
             return { ...s };
     }

package/dist/tui/status.d.ts

@@ -11,6 +11,9 @@ export interface StatusSnapshot {
     maxSteps: number;
     usageInput: number;
     usageOutput: number;
+    /** Prompt-cache counters (Anthropic-family): billed and context-consuming. */
+    usageCacheRead?: number;
+    usageCacheWrite?: number;
     repairs: number;
     status: 'idle' | 'running' | 'done' | 'error' | 'aborted';
     errorMessage?: string;

package/dist/verification/engine.js

@@ -7,7 +7,7 @@
  * On failure: returns { ok: false, failure } with the most recent
  * structured Failure (and the model has had up to N attempts to fix).
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { detect, summarize } from './detect.js';
 import { filteredVerifyEnv } from './registry.js';
 import { redact } from '../policy/secret-redactor.js';
@@ -84,10 +84,26 @@ export async function verify(opts) {
         const outCap = cappedOutput(MAX_VERIFY_BYTES);
         const errCap = cappedOutput(MAX_VERIFY_BYTES);
         let done = false;
+        const killTree = () => {
+            // Match run_verify/shell_exec: tree-kill so grandchildren die too.
+            // child.kill() alone only takes the /bin/sh (or cmd) wrapper.
+            if (process.platform === 'win32') {
+                try {
+                    spawnSync('taskkill', ['/F', '/T', '/PID', String(child.pid)], { windowsHide: true });
+                }
+                catch { /* already gone */ }
+            }
+            else {
+                try {
+                    child.kill('SIGKILL');
+                }
+                catch { /* noop */ }
+            }
+        };
         const timer = setTimeout(() => {
             if (done)
                 return;
-            child.kill();
+            killTree();
             done = true;
             const so = outCap.text();
             const se = errCap.text();
@@ -103,6 +119,23 @@ export async function verify(opts) {
         }, timeout);
         child.stdout.on('data', (b) => outCap.push(b));
         child.stderr.on('data', (b) => errCap.push(b));
+        // A bad cwd (or missing shell) emits 'error' with no 'close' — without
+        // this the promise never settles and the run hangs to its own timeout.
+        child.on('error', (err) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            const raw = `verify spawn failed: ${err instanceof Error ? err.message : String(err)}`;
+            emitFailed('runtime');
+            resolve({
+                ok: false,
+                exitCode: -1,
+                stdout: outCap.text(),
+                stderr: raw,
+                failure: { type: 'runtime', files: [], raw, exitCode: -1 },
+            });
+        });
         child.on('close', (code) => {
             if (done)
                 return;

package/dist/verification/scoped.js

@@ -39,13 +39,25 @@ export function findRelatedTests(cwd, editedFiles) {
         const dir = path.dirname(edited);
         for (const t of allTests) {
             const tb = path.basename(t);
+            const stripped = path.basename(t, path.extname(t)).replace(/\.test|\.spec|test_/g, '');
             // name match: foo.ts -> foo.test.ts, test_foo.py, foo_spec.ts, etc.
-            if (tb.includes(base) || base.includes(path.basename(t, path.extname(t)).replace(/\.test|\.spec|test_/g, ''))) {
+            // Substring arms need a substantive core (>=4 chars): without the
+            // floor, `a.ts` matches nearly every test basename globally, and
+            // `catalog.ts` matches unrelated `cat.test.ts`. Exact stem equality
+            // always counts (covers single-char stems like `a.ts` -> `a.test.ts`).
+            if (stripped === base ||
+                (base.length >= 4 && tb.includes(base)) ||
+                (stripped.length >= 4 && base.includes(stripped))) {
                 related.add(path.relative(cwd, t));
             }
-            // same directory prefix also counts
-            if (t.startsWith(dir) && tb.includes(base.slice(0, 4)))
+            // same-directory similarity (not a raw string prefix: `/repo/foo2/…`
+            // must not match edited dir `/repo/foo`). The 4-char slice needs a
+            // real core name behind it, same floor as above.
+            const rel = path.relative(dir, t);
+            const inDir = rel !== '' && !rel.startsWith('..') && !path.isAbsolute(rel);
+            if (inDir && base.length >= 4 && tb.toLowerCase().includes(base.slice(0, 4).toLowerCase())) {
                 related.add(path.relative(cwd, t));
+            }
         }
     }
     return [...related];
@@ -222,6 +234,7 @@ export async function syntaxCheck(cwd, file) {
         }
     }
     if (ext === '.py') {
+        let spawnFailed = false;
         const ok = await new Promise((resolve) => {
             // S2: verify commands run with filtered env; servers needing keys must use explicit config.
             const child = spawn('python', ['-m', 'py_compile', full], { cwd, shell: false, env: filteredVerifyEnv() });
@@ -236,11 +249,13 @@ export async function syntaxCheck(cwd, file) {
             } }, 5000);
             child.on('close', (code) => { if (done)
                 return; done = true; clearTimeout(t); resolve(code === 0); });
+            // A missing interpreter must not read as "syntax OK" — that false
+            // negative lets broken files pass scoped verification.
             child.on('error', () => { if (done)
-                return; done = true; clearTimeout(t); resolve(true); });
+                return; done = true; clearTimeout(t); spawnFailed = true; resolve(false); });
         });
         if (!ok)
-            return { ok: false, error: `syntax error in ${file} (py_compile)` };
+            return { ok: false, error: spawnFailed ? `python unavailable for py_compile (${file})` : `syntax error in ${file} (py_compile)` };
     }
     return { ok: true };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klyro",
-  "version": "1.0.20",
+  "version": "1.0.21",
   "description": "Klyro — autonomous coding harness CLI that streams from any OpenAI-compatible or Anthropic LLM endpoint.",
   "type": "module",
   "main": "dist/index.js",