ucode-agent 1.10.0 → 1.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/loop.js

@@ -65,6 +65,32 @@ const MAX_ARG_RETRIES = 2;
 const MAX_CONTINUATIONS = 3;
 
 /** Read-only tools whose result line adds nothing — the user saw the output. */
+/**
+ * How many rows a diff adds and removes.
+ *
+ * The rows come through as "+12| text" and "-12| text", with a "~" heading
+ * for each file in a multi-file write and an undecorated note counting what
+ * was elided. Only the signs are counted.
+ */
+export function countDiff(rows = []) {
+  let added = 0;
+  let removed = 0;
+  for (const row of rows) {
+    const line = String(row ?? '');
+    if (line.startsWith('~')) continue;
+    // "… 218 more removed" / "… 508 more added" stand for rows not shown.
+    const more = /^\s*[….]+\s*(\d+)\s+more\s+(added|removed)/.exec(line);
+    if (more) {
+      if (more[2] === 'added') added += Number(more[1]);
+      else removed += Number(more[1]);
+      continue;
+    }
+    if (line.startsWith('+')) added++;
+    else if (line.startsWith('-')) removed++;
+  }
+  return { added, removed };
+}
+
 const QUIET = new Set(['read_file', 'read_files', 'list_dir', 'glob', 'grep', 'web_search', 'update_plan']);
 
 /** Tools that draw their own line, so they get no "● Doing X" line of their own. */
@@ -1320,8 +1346,10 @@ export class Agent {
       this.sinceCheck?.clear();
     }
     if (!QUIET.has(call.name)) this.ui.toolResult(out.summary);
-    if (out.diff?.length) this.ui.diff(out.diff);
-    if (out.output?.length) this.ui.commandOutput(out.output);
+    // The change as its two numbers, not as a copy of the file. The diff rows
+    // are still built by the tool — the model reads them in the result — they
+    // simply do not go on screen.
+    if (out.diff?.length) this.ui.diffStat?.(countDiff(out.diff));
     this.push({ role: 'tool', toolCallId: call.id, name: call.name, content: out.content + this.stuckNote(call, { out }) });
   }
 

package/src/ui/screen.js

@@ -39,7 +39,7 @@ import chalk from 'chalk';
 import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
-  shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel } from './theme.js';
+  shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine } from './theme.js';
 import { FRAME_MS, fitActivity, shimmer, spinnerGlyph, formatDuration, doneLine, stepPaint } from './activity.js';
 import { renderer, render, polish } from './markdown.js';
 import { VERSION } from '../core/version.js';
@@ -84,6 +84,8 @@ const TRACK = process.platform === 'win32'
 const UNTRACK = process.platform === 'win32'
   ? '' : `${ESC}[?1006l${ESC}[?1015l${ESC}[?1002l${ESC}[?1000l`;
 
+const PASTE_ON = `${ESC}[?2004h`;
+const PASTE_OFF = `${ESC}[?2004l`;
 const MOUSE_ON = `${ESC}[?1007h${TRACK}`;
 const MOUSE_OFF = `${UNTRACK}${ESC}[?1007l`;
 const HIDE = `${ESC}[?25l`;
@@ -149,7 +151,7 @@ export class Screen {
 
   async start() {
     ensureColour(this.output);
-    this.output.write(ALT_ON + MOUSE_ON + HIDE + title(`ucode — ${path.basename(this.cwd)}`));
+    this.output.write(ALT_ON + MOUSE_ON + PASTE_ON + HIDE + title(`ucode — ${path.basename(this.cwd)}`));
     this.input.setRawMode?.(true);
     this.input.resume();
     this.input.setEncoding('utf8');
@@ -173,7 +175,7 @@ export class Screen {
     this.output.off?.('resize', this.onResize);
     this.input.setRawMode?.(false);
     this.input.pause();
-    this.output.write(MOUSE_OFF + ALT_OFF + SHOW);
+    this.output.write(PASTE_OFF + MOUSE_OFF + ALT_OFF + SHOW);
   }
 
   close() {
@@ -305,11 +307,14 @@ export class Screen {
       if (gap === 1) this.lines.pop();   // its single result line, now counted
       run.count++;
       run.label = label;
-      this.lines[run.at] = `${narrationMark()} ${narration(asLabel(groupLabel(label, run.count)))}`;
-      this.render();
+      run.targets.push(groupTarget(label));
+      this.paintRun();
     } else {
       this.push(`${narrationMark()} ${narration(asLabel(label))}`);
-      this.run = { kind, count: 1, at: this.lines.length - 1, label };
+      this.run = {
+        kind, count: 1, at: this.lines.length - 1, label,
+        targets: [groupTarget(label)], added: 0, removed: 0,
+      };
     }
     this.updateSpinner(label);
   }
@@ -317,18 +322,42 @@ export class Screen {
   /** Anything that is not another step of the same kind ends the run. */
   endRun() { this.run = null; }
 
+  /** Redraw the run's single line from what it has accumulated. */
+  paintRun() {
+    if (!this.run) return;
+    this.lines[this.run.at] = `${narrationMark()} ${narration(asLabel(runLine(this.run)))}`;
+    this.render();
+  }
+
+  /**
+   * A change, as its two numbers.
+   *
+   * The diff itself used to go into the transcript. A 539-line file printed
+   * there buries the answer under a copy of something already on disk, so
+   * what is kept is the shape of the change: how much arrived, how much left.
+   */
+  diffStat({ added = 0, removed = 0 } = {}) {
+    if (!this.run) return;
+    this.run.added += added;
+    this.run.removed += removed;
+    this.paintRun();
+  }
+
   /** The checklist, when the model updates it. One line, wrapped if it must. */
   plan(items) {
     const line = planLine(items);
     if (line) this.push(line);
   }
 
-  toolResult(summary) {
-    // Inside a run, the count on the line above already says what happened;
-    // a result line per step is the noise this is meant to remove.
-    if (this.run && this.run.count > 1) return;
-    this.push(dim(`  └ ${summary}`));
-  }
+  /**
+   * What came of a step.
+   *
+   * Nothing goes underneath the bullet any more: a line of its own for every
+   * result doubles the height of the transcript to say "ok". The bullet
+   * already names the step, and a change adds its numbers to that same line.
+   * Only a failure earns a line of its own.
+   */
+  toolResult() {}
 
   toolFailed(summary) {
     // A failure is never folded away.
@@ -953,7 +982,55 @@ export class Screen {
     this.render();
   }
 
+  /**
+   * Text arriving as a paste rather than as typing.
+   *
+   * A terminal in bracketed-paste mode wraps pasted text in markers, which is
+   * the only way to tell forty lines pasted at once from forty lines typed
+   * very fast. Without it every newline in the paste reads as Enter, so a
+   * pasted block submits itself a line at a time and arrives as forty
+   * messages. Inside the markers a newline is just a character.
+   */
+  onPaste(text) {
+    const clean = String(text).replace(/\r\n?/g, '\n');
+    this.buffer = this.buffer.slice(0, this.cursor) + clean + this.buffer.slice(this.cursor);
+    this.cursor += clean.length;
+    this.render();
+  }
+
   onData(chunk) {
+    // Pasted text first: it is wrapped in markers and must not be read as
+    // keys, or its newlines submit it in pieces.
+    const paste = /\[200~([\s\S]*?)\[201~/g;
+    if (paste.test(chunk)) {
+      paste.lastIndex = 0;
+      let at = 0;
+      let m;
+      while ((m = paste.exec(chunk))) {
+        if (m.index > at) this.onData(chunk.slice(at, m.index));
+        this.onPaste(m[1]);
+        at = m.index + m[0].length;
+      }
+      if (at < chunk.length) this.onData(chunk.slice(at));
+      return;
+    }
+    // An unterminated paste: hold what has arrived and wait for the rest.
+    const open = chunk.indexOf('[200~');
+    if (open !== -1) {
+      if (open > 0) this.onData(chunk.slice(0, open));
+      this.pasting = chunk.slice(open + 6);
+      return;
+    }
+    if (this.pasting !== undefined && this.pasting !== null) {
+      const close = chunk.indexOf('[201~');
+      if (close === -1) { this.pasting += chunk; return; }
+      this.onPaste(this.pasting + chunk.slice(0, close));
+      this.pasting = null;
+      const after = chunk.slice(close + 6);
+      if (after) this.onData(after);
+      return;
+    }
+
     // UCODE_DEBUG_KEYS=1 logs every byte the terminal sends to
     // ~/.ucode/keys.log. Whether mouse reporting works at all depends on the
     // terminal forwarding it; this is how to find out.

package/src/ui/theme.js

@@ -291,40 +291,65 @@ export const narration = (text) => chalk.dim(text);
 
 /** The bullet beside a narration line: present, not loud. */
 export const narrationMark = () => chalk.dim(deep('●'));
-
-/**
- * How a run of the same kind of step reads once it is over.
- *
- * While it happens, "Running npm test" is the useful thing to show. Once
- * three of them have happened, three near-identical lines are just noise
- * between the reader and the answer, so they fold into one: "Ran 3 commands".
- * The present tense belongs to the thing happening now; the past tense to the
- * summary of what did.
- */
-const GROUPS = {
-  Running: ['Ran', 'command', 'commands'],
-  Reading: ['Read', 'file', 'files'],
-  Searching: ['Searched', 'time', 'times'],
-  Finding: ['Found', 'pattern', 'patterns'],
-  Listing: ['Listed', 'directory', 'directories'],
-  Writing: ['Wrote', 'file', 'files'],
-  Editing: ['Edited', 'file', 'files'],
-  Checking: ['Checked', 'thing', 'things'],
-  Looking: ['Looked up', 'name', 'names'],
-  Asking: ['Asked about', 'name', 'names'],
-  Mapping: ['Mapped', 'folder', 'folders'],
-  Adding: ['Added', 'block', 'blocks'],
-  Renaming: ['Renamed', 'name', 'names'],
-};
-
-/** The first word of a label, which is what decides whether two steps match. */
-export const groupKind = (label) => String(label ?? '').trim().split(/\s+/)[0] ?? '';
-
-/** One line standing in for `count` steps that all began with the same word. */
-export function groupLabel(label, count) {
-  if (count <= 1) return String(label ?? '');
-  const g = GROUPS[groupKind(label)];
-  if (!g) return `${label} (+${count - 1} more)`;
-  const [past, one, many] = g;
-  return `${past} ${count} ${count === 1 ? one : many}`;
-}
+
+/**
+ * How a run of the same kind of step reads once it is over.
+ *
+ * While it happens, "Running npm test" is the useful thing to show. Once
+ * three of them have happened, three near-identical lines are just noise
+ * between the reader and the answer, so they fold into one: "Ran 3 commands".
+ * The present tense belongs to the thing happening now; the past tense to the
+ * summary of what did.
+ */
+const GROUPS = {
+  Running: ['Ran', 'command', 'commands'],
+  Reading: ['Read', 'file', 'files'],
+  Searching: ['Searched', 'time', 'times'],
+  Finding: ['Found', 'pattern', 'patterns'],
+  Listing: ['Listed', 'directory', 'directories'],
+  Writing: ['Wrote', 'file', 'files'],
+  Editing: ['Edited', 'file', 'files'],
+  Checking: ['Checked', 'thing', 'things'],
+  Looking: ['Looked up', 'name', 'names'],
+  Asking: ['Asked about', 'name', 'names'],
+  Mapping: ['Mapped', 'folder', 'folders'],
+  Adding: ['Added', 'block', 'blocks'],
+  Renaming: ['Renamed', 'name', 'names'],
+};
+
+/** The first word of a label, which is what decides whether two steps match. */
+export const groupKind = (label) => String(label ?? '').trim().split(/\s+/)[0] ?? '';
+
+/** One line standing in for `count` steps that all began with the same word. */
+export function groupLabel(label, count) {
+  if (count <= 1) return String(label ?? '');
+  const g = GROUPS[groupKind(label)];
+  if (!g) return `${label} (+${count - 1} more)`;
+  const [past, one, many] = g;
+  return `${past} ${count} ${count === 1 ? one : many}`;
+}
+
+/** The part of a label after its opening word: the file or command it is about. */
+export const groupTarget = (label) => String(label ?? '').trim().split(/\s+/).slice(1).join(' ');
+
+/**
+ * One narration line, standing for everything that happened under it.
+ *
+ * The transcript is a record of what was done, not a copy of what was
+ * written. A 539-line file printed into it buries the answer and tells the
+ * reader nothing they could not get from the file itself, so a change is its
+ * two numbers. Several steps on one file stay one line naming that file;
+ * several files become a count.
+ */
+export function runLine({ label, count = 1, targets = [], added = 0, removed = 0 }) {
+  const counts = added || removed
+    ? ` ${chalk.hex('#3fb950')(`+${added}`)} ${chalk.hex('#f2939c')(`-${removed}`)}`
+    : '';
+  if (count <= 1) return `${label}${counts}`;
+
+  const g = GROUPS[groupKind(label)];
+  const unique = [...new Set(targets.filter(Boolean))];
+  if (g && unique.length === 1) return `${g[0]} ${unique[0]}${counts}`;
+  if (!g) return `${label} (+${count - 1} more)${counts}`;
+  return `${g[0]} ${count} ${count === 1 ? g[1] : g[2]}${counts}`;
+}