ucode-agent 1.8.1 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.8.1",
+  "version": "1.10.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

@@ -408,6 +408,11 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     '## How to work',
     '',
+    'Say what you are about to do, in one short line, before you do it — "now the',
+    'tests", "wiring this into the loop". A line like that before a group of actions is',
+    'what makes the work readable. Keep it to a sentence: the narration is not the',
+    'answer, and three sentences of intent before every step reads as stalling.',
+    '',
     'Before you guess at an API, ask: type_of gives the exact signature from the',
     'TypeScript this project has installed, and find_symbol says where something is declared without',
     'reading five files to find it. Rename with rename_symbol rather than edit_file — a',
@@ -566,6 +571,42 @@ export class Agent {
     this.working.push(message);
   }
 
+  /**
+   * Answer every tool call a stopped turn never got to.
+   *
+   * An assistant message ends by asking for tools, and each of those asks
+   * needs an answer. Abandon them and the conversation is left mid-sentence,
+   * so the next time the model reads it the only sensible thing to do is
+   * carry on where it left off — which is exactly what the user pressed stop
+   * to prevent. Saying "this did not happen" for each one ends the sentence,
+   * and a line from the user ends the task.
+   */
+  closeInterrupted() {
+    const answered = new Set(this.working.filter((m) => m.role === 'tool').map((m) => m.toolCallId));
+    const missing = [];
+    for (const m of this.working) {
+      if (m.role !== 'assistant' || !m.toolCalls?.length) continue;
+      for (const call of m.toolCalls) {
+        if (!answered.has(call.id)) missing.push(call);
+      }
+    }
+    for (const call of missing) {
+      this.push({
+        role: 'tool',
+        toolCallId: call.id,
+        name: call.name,
+        content: 'The user stopped the turn before this ran. It did not happen, and it must not be retried.',
+      });
+    }
+    if (missing.length) {
+      this.push({
+        role: 'user',
+        content: 'I stopped that. Drop it and wait for what I ask next — do not pick it back up.',
+      });
+    }
+    return missing.length;
+  }
+
   async persist() {
     try {
       this.session.model = model();
@@ -607,6 +648,7 @@ export class Agent {
         if (this.busy && this.abort) {
           this.abort.abort();
           this.ui.stopSpinner();
+          this.ui.stopTimer?.();
           this.ui.note('interrupted');
         }
       };
@@ -849,9 +891,12 @@ export class Agent {
       trace({ kind: 'turn', ms: Date.now() - turnStarted });
       this.stats.workMs += Date.now() - turnStarted;
       this.stats.turns++;
+      if (!finished) this.closeInterrupted();
       this.busy = false;
       this.abort = null;
       this.ui.stopSpinner();
+      this.ui.stopTimer?.();
+      this.activity = null;
       this.ui.turnEnd?.({ ok: finished });
       await this.persist();
       if (this.full) this.showHeader({ clear: false });

package/src/core/updater.js

@@ -1,95 +1,152 @@
-/**
- * updater.js — staying current without anyone running npm by hand.
- *
- * On every launch ucode asks the registry, in the background, whether a newer
- * version exists. If one does, it installs it globally, detached, while you
- * work. The version you are running carries on untouched; the next launch is
- * the new one. Nothing about starting ucode waits on any of this.
- *
- * It stays out of the way in three cases: a development checkout (updating
- * would overwrite the `npm link` that points at your working copy), when
- * UCODE_NO_UPDATE is set, and when another ucode is already updating.
- */
-
-import { spawn } from 'node:child_process';
-import { existsSync, promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { VERSION } from './version.js';
-
-const PACKAGE = 'ucode-agent';
-const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
-const HOME = path.join(os.homedir(), '.ucode');
-const LOCK = path.join(HOME, 'update.lock');
-const LOG = path.join(HOME, 'update.log');
-const LOCK_TTL = 10 * 60_000;
-
-/** "1.10.0" > "1.9.3" — numeric, part by part. */
-export function newer(a, b) {
-  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
-  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
-  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
-    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
-  }
-  return false;
-}
-
-function isDevCheckout() {
-  return existsSync(path.join(PACKAGE_ROOT, '.git'));
-}
-
-async function latestVersion() {
-  const res = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`, {
-    signal: AbortSignal.timeout(5_000),
-    headers: { accept: 'application/json' },
-  });
-  if (!res.ok) return null;
-  return (await res.json())?.version ?? null;
-}
-
-async function takeLock() {
-  try {
-    const stat = await fs.stat(LOCK);
-    if (Date.now() - stat.mtimeMs < LOCK_TTL) return false;   // someone else is on it
-  } catch { /* no lock — good */ }
-  await fs.mkdir(HOME, { recursive: true });
-  await fs.writeFile(LOCK, String(process.pid));
-  return true;
-}
-
-/**
- * Check, and install if there is something newer.
- *
- * @param {object} o
- * @param {(v: string) => void} [o.onUpdated]  called when the install finishes
- */
-export async function autoUpdate({ onUpdated } = {}) {
-  try {
-    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return;
-    const latest = await latestVersion();
-    if (!latest || !newer(latest, VERSION)) return;
-    if (!(await takeLock())) return;
-
-    const log = await fs.open(LOG, 'w');
-    const child = spawn(`npm install -g ${PACKAGE}@${latest} --no-audit --no-fund`, {
-      shell: true,
-      detached: true,
-      windowsHide: true,
-      stdio: ['ignore', log.fd, log.fd],
-    });
-    await log.close();
-    child.unref();
-
-    child.on('exit', async (code) => {
-      await fs.rm(LOCK, { force: true }).catch(() => {});
-      if (code === 0) onUpdated?.(latest);
-    });
-    child.on('error', async () => {
-      await fs.rm(LOCK, { force: true }).catch(() => {});
-    });
-  } catch {
-    // An update check must never be the reason ucode misbehaves. Offline,
-    // registry down, no permission to install globally: all silently skipped.
-  }
-}
+/**
+ * updater.js — staying current without anyone running npm by hand.
+ *
+ * On every launch ucode asks the registry, in the background, whether a newer
+ * version exists. If one does, it installs it globally, detached, while you
+ * work. The version you are running carries on untouched; the next launch is
+ * the new one. Nothing about starting ucode waits on any of this.
+ *
+ * It stays out of the way in three cases: a development checkout (updating
+ * would overwrite the `npm link` that points at your working copy), when
+ * UCODE_NO_UPDATE is set, and when another ucode is already updating.
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, rmSync, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { VERSION } from './version.js';
+
+const PACKAGE = 'ucode-agent';
+const PACKAGE_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const HOME = path.join(os.homedir(), '.ucode');
+const LOCK = path.join(HOME, 'update.lock');
+const LOG = path.join(HOME, 'update.log');
+const LOCK_TTL = 10 * 60_000;
+
+/** "1.10.0" > "1.9.3" — numeric, part by part. */
+export function newer(a, b) {
+  const pa = String(a).split('.').map((n) => parseInt(n, 10) || 0);
+  const pb = String(b).split('.').map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    if ((pa[i] ?? 0) !== (pb[i] ?? 0)) return (pa[i] ?? 0) > (pb[i] ?? 0);
+  }
+  return false;
+}
+
+function isDevCheckout() {
+  return existsSync(path.join(PACKAGE_ROOT, '.git'));
+}
+
+async function latestVersion() {
+  const res = await fetch(`https://registry.npmjs.org/${PACKAGE}/latest`, {
+    signal: AbortSignal.timeout(5_000),
+    headers: { accept: 'application/json' },
+  });
+  if (!res.ok) return null;
+  return (await res.json())?.version ?? null;
+}
+
+/** Is that process still running? A lock held by a dead one is not a lock. */
+function alive(pid) {
+  if (!pid) return false;
+  try { process.kill(pid, 0); return true; } catch (err) { return err.code === 'EPERM'; }
+}
+
+/**
+ * Take the update lock, unless a live process holds it.
+ *
+ * The lock used to be dropped by the parent watching the installer exit — but
+ * the installer is detached and ucode usually leaves first, so the handler
+ * never ran and the lock sat there blocking every update until it aged out.
+ * Now the holder is checked for a pulse, so a lock left by a process that has
+ * gone is simply taken over.
+ */
+async function takeLock() {
+  try {
+    const stat = await fs.stat(LOCK);
+    const holder = parseInt(await fs.readFile(LOCK, 'utf8').catch(() => ''), 10);
+    if (alive(holder) && Date.now() - stat.mtimeMs < LOCK_TTL) return false;
+  } catch { /* no lock — good */ }
+  await fs.mkdir(HOME, { recursive: true });
+  await fs.writeFile(LOCK, String(process.pid));
+  return true;
+}
+
+export async function releaseLock() {
+  await fs.rm(LOCK, { force: true }).catch(() => {});
+}
+
+/**
+ * Install the newer version and return true once it is on disk.
+ *
+ * This one waits. It is used at startup, where waiting a few seconds once per
+ * release is the whole point: the alternative is being told an update exists
+ * and running the old one anyway.
+ */
+export async function installNow(version) {
+  if (!(await takeLock())) return false;
+  try {
+    const done = await new Promise((resolve) => {
+      const child = spawn(`npm install -g ${PACKAGE}@${version} --no-audit --no-fund --silent`, {
+        shell: true, windowsHide: true, stdio: 'ignore',
+      });
+      child.on('exit', (code) => resolve(code === 0));
+      child.on('error', () => resolve(false));
+      setTimeout(() => resolve(false), 90_000);
+    });
+    return done;
+  } finally {
+    await releaseLock();
+  }
+}
+
+/** The newest version on the registry, if it is newer than this one. */
+export async function pendingUpdate() {
+  try {
+    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return null;
+    const latest = await latestVersion();
+    return latest && newer(latest, VERSION) ? latest : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check, and install if there is something newer.
+ *
+ * @param {object} o
+ * @param {(v: string) => void} [o.onUpdated]  called when the install finishes
+ */
+export async function autoUpdate({ onUpdated } = {}) {
+  try {
+    if (process.env.UCODE_NO_UPDATE || isDevCheckout() || !VERSION) return;
+    const latest = await latestVersion();
+    if (!latest || !newer(latest, VERSION)) return;
+    if (!(await takeLock())) return;
+
+    const log = await fs.open(LOG, 'w');
+    const child = spawn(`npm install -g ${PACKAGE}@${latest} --no-audit --no-fund`, {
+      shell: true,
+      detached: true,
+      windowsHide: true,
+      stdio: ['ignore', log.fd, log.fd],
+    });
+    await log.close();
+    child.unref();
+
+    // The lock is cleared by whoever took it. This process may well be gone
+    // before npm finishes, so it cannot be left to an exit handler here.
+    child.on('exit', async (code) => {
+      await releaseLock();
+      if (code === 0) onUpdated?.(latest);
+    });
+    child.on('error', async () => { await releaseLock(); });
+    // And if this process leaves first, release it on the way out.
+    process.once('exit', () => { try { rmSync(LOCK, { force: true }); } catch {} });
+  } catch {
+    // An update check must never be the reason ucode misbehaves. Offline,
+    // registry down, no permission to install globally: all silently skipped.
+  }
+}

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, BG_ON, BG_OFF, BG_WINDOW, BG_WINDOW_OFF, onBackground } from './theme.js';
+  shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel } 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';
@@ -149,7 +149,7 @@ export class Screen {
 
   async start() {
     ensureColour(this.output);
-    this.output.write(ALT_ON + MOUSE_ON + HIDE + BG_WINDOW + BG_ON + `${ESC}[2J` + title(`ucode — ${path.basename(this.cwd)}`));
+    this.output.write(ALT_ON + MOUSE_ON + HIDE + title(`ucode — ${path.basename(this.cwd)}`));
     this.input.setRawMode?.(true);
     this.input.resume();
     this.input.setEncoding('utf8');
@@ -173,7 +173,7 @@ export class Screen {
     this.output.off?.('resize', this.onResize);
     this.input.setRawMode?.(false);
     this.input.pause();
-    this.output.write(BG_OFF + BG_WINDOW_OFF + MOUSE_OFF + ALT_OFF + SHOW);
+    this.output.write(MOUSE_OFF + ALT_OFF + SHOW);
   }
 
   close() {
@@ -246,6 +246,7 @@ export class Screen {
 
   assistant(text) {
     if (!text?.trim()) return;
+    this.endRun();
     this.add('');
     this.add(render(this.md, text));
     this.add('');
@@ -291,10 +292,31 @@ export class Screen {
   toolCall(label) {
     // U+25CF, not U+23FA: the latter carries emoji presentation, which Windows
     // Terminal draws as a white circle on a blue tile.
-    this.push(`${blue('●')} ${asLabel(label)}`);
+    const kind = groupKind(label);
+    const run = this.run;
+    // The run's own line is either the last one, or the last but one with its
+    // result underneath. Anything further down means something else was said
+    // in between, and the run is over.
+    const gap = run ? this.lines.length - 1 - run.at : Infinity;
+
+    // A second step of the same kind rewrites the line the first one wrote,
+    // rather than adding another almost-identical one beneath it.
+    if (run && run.kind === kind && gap <= 1) {
+      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();
+    } else {
+      this.push(`${narrationMark()} ${narration(asLabel(label))}`);
+      this.run = { kind, count: 1, at: this.lines.length - 1, label };
+    }
     this.updateSpinner(label);
   }
 
+  /** Anything that is not another step of the same kind ends the run. */
+  endRun() { this.run = null; }
+
   /** The checklist, when the model updates it. One line, wrapped if it must. */
   plan(items) {
     const line = planLine(items);
@@ -302,10 +324,15 @@ export class Screen {
   }
 
   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}`));
   }
 
   toolFailed(summary) {
+    // A failure is never folded away.
+    this.endRun();
     this.push(`${dim('  └ ')}${theme.error(summary)}`);
   }
 
@@ -1127,7 +1154,7 @@ export class Screen {
     // dot flickering above the input box on every keystroke.
     const out = [HIDE, HOME];
     for (let i = 0; i < this.rows; i++) {
-      out.push(BG_ON + CLEAR_LINE + onBackground(padVis(frame[i] ?? '', width)) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(CLEAR_LINE + padVis(frame[i] ?? '', width) + (i === this.rows - 1 ? '' : '\n'));
     }
 
     const [row, col] = this.caret();
@@ -1214,7 +1241,7 @@ export class Screen {
 
     const out = [HIDE, HOME];
     for (let i = 0; i < this.rows; i++) {
-      out.push(BG_ON + CLEAR_LINE + onBackground(padVis(frame[i], g.cols)) + (i === this.rows - 1 ? '' : '\n'));
+      out.push(CLEAR_LINE + padVis(frame[i], g.cols) + (i === this.rows - 1 ? '' : '\n'));
     }
     const [row, col] = this.caret();
     out.push(at(row, col) + SHOW);

package/src/ui/theme.js

@@ -278,62 +278,53 @@ export function planLine(items) {
 }
 
 /**
- * The background ucode paints behind itself.
+ * Narration: what the agent is doing, as opposed to what it has to say.
  *
- * A terminal's own background is whatever the person set it to years ago:
- * white, solarized, a photograph. The interface was drawn for a dark one, and
- * on a light terminal the dim greys it relies on turn to near-invisible smoke.
- * So ucode paints its own ground for as long as it is running, and the
- * alternate screen gives it back untouched on exit.
- *
- * Two things are needed, not one. Painting each row covers the rows ucode
- * draws; it cannot reach the margin a terminal keeps below the last line or
- * beside the last column, which stays the old colour and shows as a border of
- * the wrong shade. So the terminal is also told, once, what its own background
- * is — and told to put it back on the way out.
- */
-export const BACKGROUND = process.env.UCODE_BG || '#000000';
-
-const rgb = (hex) => {
-  const m = /^#?([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(hex.trim());
-  return m ? [parseInt(m[1], 16), parseInt(m[2], 16), parseInt(m[3], 16)] : [19, 19, 22];
-};
-
-/** Turn the background on. Everything painted after this sits on it. */
-export const BG_ON = (() => {
-  if (process.env.NO_COLOR || process.env.UCODE_BG === 'off') return '';
-  const [r, g, b] = rgb(BACKGROUND);
-  return `\x1b[48;2;${r};${g};${b}m`;
-})();
-
-/**
- * Tell the terminal what its own background is.
- *
- * Painting each row covers the rows ucode draws, and nothing else. It cannot
- * reach the margin a terminal keeps below the last line or beside the last
- * column, which stays the old colour and reads as a border in the wrong
- * shade. OSC 11 sets the window's background itself, which does reach those
- * edges. A terminal that does not know the sequence ignores it in silence,
- * and the per-row painting still covers everything ucode draws.
+ * These lines are scaffolding — "Reading screen.js", "Checking types". They
+ * are worth seeing and not worth reading, and at full strength they compete
+ * with the answer, which is the thing the user is actually here for. A
+ * terminal has no smaller size to set, so the only axis available is weight:
+ * faint, and a step down in colour. The answer stays at full strength and
+ * wins the page by contrast rather than by shouting.
  */
-export const BG_WINDOW = BG_ON ? `\x1b]11;${BACKGROUND}\x07` : '';
-
-/** Put the terminal's own background back, exactly as it was. */
-export const BG_WINDOW_OFF = BG_ON ? '\x1b]111\x07' : '';
-
-/** Hand the terminal its own colours back. */
-export const BG_OFF = BG_ON ? '\x1b[0m' : '';
-
-/**
- * Keep the background on across a line that resets it.
- *
- * chalk closes a foreground with 39 and a background with 49, and 49 means
- * "the terminal's default" — which is exactly the colour being painted over.
- * A diff line, which sets its own background, would therefore punch a hole
- * through to the terminal's ground for the rest of the line. Re-asserting the
- * background after every reset closes those holes.
- */
-export function onBackground(text) {
-  if (!BG_ON) return text;
-  return BG_ON + String(text).replace(/\x1b\[(?:0|49)m/g, (m) => m + BG_ON);
-}
+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}`;
+}

package/ucode.js

@@ -81,6 +81,31 @@ async function main() {
     return;
   }
 
+  // Update before the session starts, not after it ends.
+  //
+  // Installing in the background and taking effect "next time" means the run
+  // you are doing now — the one that might be a demo — is the old one, and you
+  // have no way to know. So if there is something newer, it goes on now and
+  // this process hands over to it. The wait is a few seconds, once per
+  // release; every other launch pays one quick question to the registry.
+  if (!args.version && process.argv[2] !== 'login' && process.argv[2] !== 'doctor') {
+    const { pendingUpdate, installNow } = await import('./src/core/updater.js');
+    const waiting = await pendingUpdate();
+    if (waiting) {
+      process.stdout.write(`  updating to v${waiting}…\n`);
+      if (await installNow(waiting)) {
+        const { spawnSync } = await import('node:child_process');
+        const run = spawnSync(process.execPath, [process.argv[1], ...process.argv.slice(2)], {
+          stdio: 'inherit',
+          env: { ...process.env, UCODE_NO_UPDATE: '1' }, // the new one must not check again
+        });
+        process.exit(run.status ?? 0);
+      }
+      // It did not take. Carry on with the version already here rather than
+      // making a failed update the reason ucode will not start.
+    }
+  }
+
   if (args.model) {
     try {
       setModel(args.model);