ucode-agent 1.54.0 → 1.57.0

package/src/tools/shared.js

@@ -408,12 +408,19 @@ export const WALK_WIDTH = 32;
  */
 const known = new Map();
 
+/**
+ * One key per file. Windows and macOS do not care about case, so "App.js" and
+ * "app.js" are the same file there — and keyed apart, ucode's own write under
+ * one spelling read as somebody else's edit under the other.
+ */
+const stampKey = (abs) => (process.platform === 'win32' || process.platform === 'darwin' ? abs.toLowerCase() : abs);
+
 /** Record a file as ucode now knows it. Never throws: a missing stamp only costs the check. */
 export async function noteFile(abs) {
   try {
-    known.set(abs, (await fs.stat(abs)).mtimeMs);
+    known.set(stampKey(abs), (await fs.stat(abs)).mtimeMs);
   } catch {
-    known.delete(abs);
+    known.delete(stampKey(abs));
   }
 }
 
@@ -431,7 +438,7 @@ export async function writeTracked(abs, data, encoding = 'utf8') {
 
 /** Forget a file, so the next write to it goes through unchallenged. */
 export function forgetFile(abs) {
-  known.delete(abs);
+  known.delete(stampKey(abs));
 }
 
 /**
@@ -444,7 +451,7 @@ export function forgetFile(abs) {
  * clobber.
  */
 export async function assertUnchanged(abs, show) {
-  const seen = known.get(abs);
+  const seen = known.get(stampKey(abs));
   if (seen === undefined) return;
 
   let now;
@@ -457,7 +464,7 @@ export async function assertUnchanged(abs, show) {
   // costs nothing and stops a same-second write reading as someone else's.
   if (Math.abs(now - seen) < 1) return;
 
-  known.delete(abs);
+  known.delete(stampKey(abs));
   throw new ToolFailure({
     kind: 'changed_on_disk',
     attempted: `overwriting ${show}`,

package/src/tools/shell.js

@@ -14,7 +14,7 @@ import { openSync, closeSync, readFileSync, mkdirSync, statSync } from 'node:fs'
 import os from 'node:os';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
-import { resolveIn, guard, result, getRoot, MAX_OUTPUT } from './shared.js';
+import { resolveIn, guard, confirm, result, getRoot, MAX_OUTPUT } from './shared.js';
 
 const DEFAULT_TIMEOUT = 120_000;
 const MAX_TIMEOUT = 600_000;
@@ -28,6 +28,19 @@ const LIVE_LINES = 200;
 const LOOKS_LIKE_SERVER =
   /(\b(?:npm|pnpm|yarn|bun)\s+(?:run\s+)?(?:dev|start|serve|preview|watch)\b|\b(?:vite|next dev|next start|nuxt dev|astro dev|webpack serve|svelte-kit dev|serve)\b|\buvicorn\b|\bgunicorn\b|\bflask run\b|\bdjango[\w-]* runserver\b|\bmanage\.py runserver\b|\brails server\b|\bhttp\.server\b|\bhttp-server\b|\blive-server\b)/i;
 
+/**
+ * Does some part of this command actually run a server? A segment that only
+ * searches for or lists one does not: `ps aux | grep http-server` was
+ * backgrounded as a server and reported as having died before it was ready.
+ */
+const INSPECTS = /^(?:grep|egrep|findstr|find|ps|echo|cat|type|tasklist|netstat|curl|wget|ls|dir|which|where|head|tail|less|more)\b/i;
+export function startsServer(command) {
+  return String(command).replace(/"[^"]*"|'[^']*'/g, '""').split(/&&|\|\||[;|&]/).some((part) => {
+    const segment = part.trim();
+    return !INSPECTS.test(segment) && LOOKS_LIKE_SERVER.test(segment);
+  });
+}
+
 /** A foreground server that was explicitly asked for still gets a short leash. */
 const SERVER_TIMEOUT = 30_000;
 
@@ -41,6 +54,17 @@ const INSTALL_TIMEOUT = 600_000;
 const LOOKS_LIKE_INSTALL =
   /(\b(?:npm|pnpm|yarn|bun)\s+(?:i|install|add|ci|create)\b|\bnpx\s+(?:create-|degit\b|shadcn)|\bpip3?\s+install\b|\bpoetry\s+(?:install|add)\b|\bcargo\s+(?:build|install|fetch)\b|\bgo\s+(?:mod\s+download|get)\b|\bbundle\s+install\b|\bcomposer\s+(?:install|require)\b|\bgit\s+clone\b)/i;
 
+/**
+ * Any kill by program name rather than by process number.
+ *
+ * `taskkill /F /IM python.exe` in a live build ended six Python processes on
+ * the machine, most of them nothing to do with the app. Every process ucode
+ * starts comes back with its PID, so the narrow kill is always available;
+ * the broad one is the user's call, and is asked about.
+ */
+const KILLS_BY_NAME =
+  /(\btaskkill\b[^|;&]*\/IM\b|\b(?:killall|pkill)\b|\b(?:Stop-Process|spps)\b[^|;&]*-(?:N(?:a(?:me?)?)?|ProcessName)\b|\bGet-Process\b[^;&]*\|\s*(?:Stop-Process|spps|kill)\b|\bwmic\b[^|;&]*\bprocess\b[^|;&]*\b(?:delete|call\s+terminate)\b|\bkill\b[^;&]*\$\(\s*pgrep\b|\bpgrep\b[^;&]*\|\s*xargs\s+(?:-\S+\s+)*kill\b)/i;
+
 /**
  * Commands that kill a whole class of process rather than one process.
  *
@@ -73,6 +97,10 @@ const KILLS_EVERYTHING =
  *   NEXT_TELEMETRY      Next skips its telemetry notice and ping
  *   NO_COLOR            output comes back as text rather than escape codes,
  *                       which the model would otherwise have to read past
+ *   PYTHONUNBUFFERED    Python writes as it goes instead of holding output
+ *                       until a buffer fills: `python -m http.server` said
+ *                       "Serving HTTP" to a log that stayed empty, and each
+ *                       start waited out the full 45 seconds as "still starting"
  */
 export function childEnv(base = process.env) {
   return {
@@ -89,6 +117,7 @@ export function childEnv(base = process.env) {
     NEXT_TELEMETRY_DISABLED: '1',
     NO_COLOR: '1',
     FORCE_COLOR: '0',
+    PYTHONUNBUFFERED: '1',
   };
 }
 
@@ -630,13 +659,34 @@ export async function runCommand({ command, cwd, timeout_ms, background }, { onO
     });
   }
 
+  if (KILLS_BY_NAME.test(command)) {
+    const attempted = `running \`${command.trim().slice(0, 80)}\``;
+    try {
+      await confirm(
+        `stop every matching process: ${command.trim().slice(0, 120)}`,
+        'That kills every process with that name on this computer, not only the ones ucode started.',
+        'command',
+      );
+    } catch (err) {
+      if (err?.kind !== 'cannot_ask') throw err;
+      throw new ToolFailure({
+        kind: 'broad_kill',
+        attempted,
+        failed: 'That kills every process with that name on this computer, not only the ones ucode ' +
+          'started, and there is nobody here to approve it.',
+        fix: 'Stop the one process by its PID: every server ucode starts reports its PID and the exact ' +
+          'command to stop it.',
+      });
+    }
+  }
+
   const workdir = cwd
     ? resolveIn(cwd, 'run_command', 'cwd')
     : { abs: getRoot(), inside: true, show: '.' };
   await guard(workdir, `run a command in ${workdir.abs}`);
 
   const env = childEnv();
-  const server = LOOKS_LIKE_SERVER.test(command);
+  const server = startsServer(command);
 
   // Anything run where a background install is still going waits for it —
   // two installs in one folder corrupt node_modules, and a build before the

package/src/ui/plain.js

@@ -186,14 +186,20 @@ export class Plain {
     for (const line of lines) this.output.write(`    ${dim(line)}\n`);
   }
 
-  assistant(text, { closing = false } = {}) {
-    const body = closing ? trimAnswer(tidyReply(text)) : tidyReply(text);
+  assistant(text, { closing = false, replay = false } = {}) {
+    const body = replay ? String(text) : (closing ? trimAnswer(tidyReply(text)) : tidyReply(text));
     const out = render(this.md, body);
     if (!out) return;
     this.stopSpinner();
     this.output.write(`\n${out}\n\n`);
   }
 
+  userMessage(text) {
+    this.stopSpinner();
+    const first = String(text ?? '').split('\n')[0] ?? '';
+    if (first.trim()) this.output.write(`\n${blue('›')} ${first}\n`);
+  }
+
   narrate(text) {
     const line = asLabel(text);
     if (!line) return;

package/src/ui/screen.js

@@ -99,6 +99,34 @@ const NEWLINE = String.fromCharCode(10);
 const at = (row, col) => `${ESC}[${row};${col}H`;
 const title = (t) => `${ESC}]0;${t}\x07`;
 
+/**
+ * Every paint is wrapped in these. Autowrap off means a row that is one cell
+ * wider than we counted loses its last cell instead of wrapping onto the next
+ * row and scrolling the whole frame up — that scroll was the glitch. The
+ * synchronized-update pair makes terminals that support it show the frame in
+ * one go; the rest ignore it.
+ */
+const PAINT_BEGIN = `${ESC}[?2026h${ESC}[?7l`;
+const PAINT_END = `${ESC}[?7h${ESC}[?2026l`;
+
+/**
+ * Text as it may be drawn: colour codes kept, everything that moves the cursor
+ * gone. A carriage return from a CRLF file sent the padding back over the
+ * line, a tab took eight cells while it was counted as one, and a clear-screen
+ * from a tool's output wiped the frame mid-paint.
+ *
+ * The SGR colour codes (\x1b[..m) are matched first and kept. An earlier
+ * version only excluded them from the CSI branch, so the bare-\x1b fallback
+ * stripped the ESC off every colour code and left "[36m" littered across
+ * coloured lines — visible only in a real terminal, never in tests, which is
+ * why the glitch survived the suite.
+ */
+function printable(text) {
+  return String(text)
+    .replace(/\t/g, '    ')
+    .replace(/\x1b\[[0-9;]*m|(\x1b(?:\[[0-?]*[ -\/]*[@-~]|\][^\x07\x1b]*(?:\x07|\x1b\\)?|[()#][0-9A-Za-z]|[\x30-\x7e])?|[\x00-\x09\x0b-\x1a\x1c-\x1f\x7f])/g, (m, bad) => (bad ? '' : m));
+}
+
 /**
  * Fixed rows below the header: the gap under it, the gap above the input box,
  * the input box's two borders, the blank row inside it, and the status row.
@@ -181,6 +209,7 @@ export class Screen {
     this.onModeChange = null;
     this.spinTimer = null;
     this.paintedBusy = false;  // whose turn the frame on screen was drawn for
+    this.paintedLines = null; // transcript length at the last paint; growth since then belongs underneath a scrolled-back view
     this.activity = null; // the turn in flight: when it began, how many steps
     this.tick = 0;        // animation frames painted, for the spinner
     this.intro = 0;       // when the launch sweep began, 0 once it is over
@@ -292,11 +321,10 @@ export class Screen {
    */
   add(text = '') {
     const width = this.width();
-    for (const raw of String(text).split('\n')) {
+    for (const raw of printable(text).split('\n')) {
       if (visLen(raw) <= width) this.lines.push(raw);
       else for (const wrapped of wrapAnsi(raw, width)) this.lines.push(wrapped);
     }
-    this.scroll = 0; // new output snaps back to the bottom
   }
 
   push(text = '') {
@@ -329,6 +357,7 @@ export class Screen {
   clearScreen() {
     this.lines = [];
     this.scroll = 0;
+    this.paintedLines = null;
     this.render();
   }
 
@@ -339,10 +368,14 @@ export class Screen {
    * the last thing left on screen, and what the whole session reads like
    * afterwards, so it is cut to eight lines — see trimAnswer.
    */
-  assistant(text, { closing = false } = {}) {
+  assistant(text, { closing = false, replay = false, silent = false } = {}) {
     if (!text?.trim()) return;
+    // A replayed answer goes back exactly as it was first shown: no tidying,
+    // no trimming, no re-read of the request. Tidy-up exists to keep a live
+    // answer short; on a resumed one it rewrites history, which is why a
+    // resumed session read like only fragments had survived.
     const tidy = tidyReply(text, 4, this.lastPrompt);
-    const body = closing ? trimAnswer(tidy) : tidy;
+    const body = replay ? String(text) : (closing ? trimAnswer(tidy) : tidy);
     if (!body.trim()) return;
     this.endRun();
     this.add('');
@@ -355,7 +388,7 @@ export class Screen {
     this.add(render(this.md, body));
 
     this.add('');
-    this.render();
+    if (!silent) this.render();
   }
 
   /**
@@ -368,10 +401,11 @@ export class Screen {
    * ladder of rules across the page: two horizontal lines per message, each as
    * loud as the input box, none of them saying anything the rail does not.
    */
-  userMessage(text) {
+  userMessage(text, { silent = false } = {}) {
     // Kept so the reply can be checked against it: an answer that opens by
     // saying the request back is repeating the line directly above it.
     this.lastPrompt = String(text ?? '');
+    this.scroll = 0; // sending something is the one thing that jumps to the bottom
     const room = Math.max(8, this.width() - 2);   // the rail and the space after it
 
     const rows = [];
@@ -385,7 +419,7 @@ export class Screen {
     for (const row of rows) this.add(`${blue(RAIL)} ${chalk.white(row)}`);
     this.add('');
     this.add('');
-    this.render();
+    if (!silent) this.render();
   }
 
   /**
@@ -1019,10 +1053,10 @@ export class Screen {
     const width = this.width();
     const liveAt = this.activityRowAt();
     this.output.write(
-      HIDE +
+      PAINT_BEGIN + HIDE +
       (liveAt ? at(liveAt, 1) + CLEAR_LINE + padVis(this.activityLine(width), width) : '') +
       at(this.rows - 1, 1) + CLEAR_LINE + boxRow(this.statusRow(width), width, this.borderPaint()) +
-      at(row, col) + SHOW
+      at(row, col) + SHOW + PAINT_END
     );
   }
 
@@ -1149,6 +1183,7 @@ export class Screen {
     }
 
     this.pendingPrompt = 'go ahead? [y/N]';
+    this.scroll = 0; // the question has to be on screen to be answered
     this.render();
 
     return this.nextLine().then((answer) => {
@@ -1273,7 +1308,8 @@ export class Screen {
     const before = this.scroll;
     this.scroll = Math.min(Math.max(0, this.scroll + delta), max);
     if (this.scroll === before && delta > 0) this.flash('already at the top');
-    this.render();
+    // One wheel notch arrives as three arrow keys in one chunk; one frame, not three.
+    this.soon();
   }
 
   /**
@@ -1511,6 +1547,20 @@ export class Screen {
     const width = this.width();
     const height = this.viewportHeight();
 
+    // Scrolled back, the view stays on what is being read while output grows
+    // underneath: every line added since the last paint extends the scroll by
+    // the same amount, so the same rows stay on screen. Snapping to the
+    // bottom on every streamed line fought the wheel sixteen times a second.
+    // A streamed reply truncates its tail and rebuilds it on every delta, so
+    // the growth since the last paint is net — but the tail sits below a
+    // scrolled-back viewport, and net growth still moves the scroll by exactly
+    // the amount that keeps the visible rows put.
+    if (this.scroll > 0 && this.paintedLines != null) {
+      const grown = this.lines.length - this.paintedLines;
+      this.scroll = Math.min(Math.max(0, this.scroll + grown), Math.max(0, this.lines.length - height));
+    }
+    this.paintedLines = this.lines.length;
+
     // The live line is the last line of the conversation, not a fixture above
     // the input box. Pinned down there it sat at the bottom of the screen while
     // the message that started it was at the top, with the empty middle of the
@@ -1539,13 +1589,13 @@ export class Screen {
     // The cursor is hidden for the duration of the paint. Without this it is
     // dragged through every line as the frame is written, which shows up as a
     // dot flickering above the input box on every keystroke.
-    const out = [HIDE, HOME];
+    const out = [PAINT_BEGIN, HIDE];
     for (let i = 0; i < this.rows; i++) {
-      out.push(CLEAR_LINE + padVis(frame[i] ?? '', width) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(at(i + 1, 1) + CLEAR_LINE + padVis(frame[i] ?? '', width));
     }
 
     const [row, col] = this.caret();
-    out.push(at(row, col) + SHOW);
+    out.push(at(row, col) + SHOW + PAINT_END);
     this.paintedBusy = this.busy();
     this.output.write(out.join(''));
   }
@@ -1637,12 +1687,12 @@ export class Screen {
       frame[this.rows - 1] = ' '.repeat(Math.max(0, g.cols - visLen(tag) - 2)) + tag;
     }
 
-    const out = [HIDE, HOME];
+    const out = [PAINT_BEGIN, HIDE];
     for (let i = 0; i < this.rows; i++) {
-      out.push(CLEAR_LINE + padVis(frame[i], g.cols) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(at(i + 1, 1) + CLEAR_LINE + padVis(frame[i], g.cols));
     }
     const [row, col] = this.caret();
-    out.push(at(row, col) + SHOW);
+    out.push(at(row, col) + SHOW + PAINT_END);
     this.paintedBusy = this.busy();
     this.output.write(out.join(''));
   }

package/src/ui/theme.js

@@ -174,6 +174,21 @@ export const bare = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
  * and a table of every Unicode width would be a megabyte to get the last
  * fraction of a percent right.
  */
+/**
+ * The emoji among the older symbol blocks — ✅ ❌ ⚡ ⭐ ⌛ and friends. They sit
+ * between box-drawing characters that are one cell, so they are listed one by
+ * one rather than as a range. Counted as one cell, a model's "✅ Done" line
+ * ran a column past the edge, wrapped, and scrolled the whole frame.
+ */
+const WIDE_SYMBOLS = new Set([
+  0x231a, 0x231b, 0x23e9, 0x23ea, 0x23eb, 0x23ec, 0x23f0, 0x23f3, 0x25fd, 0x25fe,
+  0x2614, 0x2615, 0x2648, 0x2649, 0x264a, 0x264b, 0x264c, 0x264d, 0x264e, 0x264f,
+  0x2650, 0x2651, 0x2652, 0x2653, 0x267f, 0x2693, 0x26a1, 0x26aa, 0x26ab, 0x26bd,
+  0x26be, 0x26c4, 0x26c5, 0x26ce, 0x26d4, 0x26ea, 0x26f2, 0x26f3, 0x26f5, 0x26fa,
+  0x26fd, 0x2705, 0x270a, 0x270b, 0x2728, 0x274c, 0x274e, 0x2753, 0x2754, 0x2755,
+  0x2757, 0x2795, 0x2796, 0x2797, 0x27b0, 0x27bf, 0x2b1b, 0x2b1c, 0x2b50, 0x2b55,
+]);
+
 export function charWidth(code) {
   // Zero: combining marks, joiners, variation selectors.
   if ((code >= 0x0300 && code <= 0x036f)
@@ -194,10 +209,15 @@ export function charWidth(code) {
     || (code >= 0xfe30 && code <= 0xfe6f)
     || (code >= 0xff00 && code <= 0xff60)
     || (code >= 0xffe0 && code <= 0xffe6)
+    || (code >= 0x1f000 && code <= 0x1f02f)
+    || code === 0x1f0cf
+    || (code >= 0x1f18e && code <= 0x1f2ff)
     || (code >= 0x1f300 && code <= 0x1f64f)
     || (code >= 0x1f680 && code <= 0x1f6ff)
-    || (code >= 0x1f900 && code <= 0x1f9ff)
-    || (code >= 0x20000 && code <= 0x3fffd)) return 2;
+    || (code >= 0x1f7e0 && code <= 0x1f7eb)
+    || (code >= 0x1f900 && code <= 0x1faff)
+    || (code >= 0x20000 && code <= 0x3fffd)
+    || WIDE_SYMBOLS.has(code)) return 2;
 
   return 1;
 }