ucode-agent 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.9.0",
+  "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, narration, narrationMark } 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';
@@ -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(`${narrationMark()} ${narration(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)}`);
   }
 

package/src/ui/theme.js

@@ -291,3 +291,40 @@ 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);