ucode-agent 1.41.1 → 1.43.0

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.41.0
+                                                                           v1.43.0
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.41.1",
+  "version": "1.43.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -16,7 +16,8 @@
   "scripts": {
     "start": "node ucode.js",
     "test": "node test/run.js",
-    "prepublishOnly": "node scripts/no-bundled-key.js && node test/run.js"
+    "prepublishOnly": "node scripts/no-bundled-key.js && node test/run.js",
+    "hooks": "node scripts/install-hooks.js"
   },
   "repository": {
     "type": "git",

package/skills/build-app/DIGEST.md

@@ -108,6 +108,18 @@ first time; then the server route with the real integration; then the core
 loop UI wired to it; then every state — empty, loading, success, error,
 invalid input; then polish: motion, responsive, copy, title and metadata.
 
+## 5b. Tests, where there is a runner
+
+`next-shadcn` ships vitest and one passing test, so `npm test` works from
+the first minute — add cases for the core loop as you build it, not after, and
+ucode will run the ones that touch whatever you change. Assert behaviour: that
+adding an item puts it in the list, that the total is right, that an empty
+input is refused.
+
+`plain-html` has no runner and installs nothing, by design. Its test is the
+browser check: ucode opens the app, types into the first field, presses Enter
+and clicks the button that submits. Make sure that path is the one that works.
+
 ## 6. Prove it works, then report
 
 `npm run build` type-checks and lints — a build that fails is not done. Start

package/src/core/loop.js

@@ -13,7 +13,7 @@
 
 import path from 'node:path';
 import os from 'node:os';
-import { appendFileSync } from 'node:fs';
+import { appendFileSync, existsSync } from 'node:fs';
 import { readFile, access, mkdir } from 'node:fs/promises';
 import { testRunnerFor, relatedCommand, summariseFailures } from './tests.js';
 import { LogWatch } from './livelog.js';
@@ -1348,6 +1348,7 @@ export class Agent {
       if (streaming) this.ui.streamEnd({ asNarration: narrating, closing });
       else if (reply.text && narrating && isLabel(reply.text)) this.ui.narrate(reply.text);
       else if (reply.text) this.ui.assistant(reply.text, { closing });
+      if (closing && reply.text) this.checkClaims(reply.text);
 
       if (reply.toolCalls.length === 0) {
         // The answer stopped at the provider's output cap rather than at the
@@ -1697,6 +1698,34 @@ export class Agent {
     this.push({ role: 'tool', toolCallId: call.id, name: call.name, content: out.content + this.stuckNote(call, { out }) });
   }
 
+  /**
+   * Files the closing message points at, checked rather than taken on trust.
+   *
+   * A build told the user it had removed two folders it had not removed. The
+   * same habit sends someone to open a file that was never written. Saying a
+   * thing is done when it is not is the one failure that costs the reader
+   * their time rather than the writer's, and it is cheap to check: a path the
+   * reply names in backticks either exists or it does not.
+   *
+   * Only paths with a file extension, only inside the project, and only a note
+   * on screen — the turn is over by now, so this is for the person reading it,
+   * not another round with the model.
+   */
+  checkClaims(text) {
+    const named = [...String(text).matchAll(/`([\w./-]+\.[a-z]{1,5})`/gi)].map((m) => m[1]);
+    const root = path.resolve(this.cwd);
+
+    const missing = [...new Set(named)].filter((f) => {
+      const abs = path.resolve(root, f);
+      return abs.startsWith(root) && !existsSync(abs);
+    });
+
+    if (missing.length) {
+      const is = missing.length === 1 ? 'is' : 'are';
+      this.ui.note(`mentions ${missing.join(', ')} — ${is} not on disk`);
+    }
+  }
+
   /** Show a tool failure, hand it to the model, and say if it was bad arguments. */
   reportFailure(call, err) {
     if (!(err instanceof ToolFailure)) throw err;

package/src/tools/browser.js

@@ -269,7 +269,25 @@ async function useTheApp(page) {
   }
 
   if (!tried.length) return null;
-  return { tried, worked: moved(before, after) };
+  if (!moved(before, after)) return { tried, worked: false };
+
+  // It worked. Did any of it last?
+  //
+  // An app that writes to localStorage and never reads it back looks perfect
+  // for as long as you stay on the page, and loses everything the moment
+  // anyone refreshes. Only asked when the app actually stored something —
+  // otherwise no persistence was intended, and reporting its absence would be
+  // inventing a requirement nobody asked for.
+  if (after.stored > before.stored) {
+    try {
+      await page.reload({ waitUntil: 'load', timeout: 20_000 });
+      await page.waitForTimeout(400);
+      const reloaded = await snapshot();
+      if (reloaded.text <= before.text) return { tried, worked: true, lost: true };
+    } catch { /* a reload that will not happen is not evidence of anything */ }
+  }
+
+  return { tried, worked: true };
 }
 
 /**
@@ -415,8 +433,16 @@ export async function lookAtApp({ url, paths = ['/'] }) {
           '  everything else on this page is decoration until it works.',
         );
         problems++;
+      } else if (used?.lost) {
+        lines.push(
+          `- It works until you refresh. I ${used.tried.join(', then ')}, the page`,
+          '  responded, and it wrote to localStorage — but after a reload it was back to',
+          '  empty. Something is being saved and never read back at start-up. Load the',
+          '  stored state when the page boots, and check it survives a refresh.',
+        );
+        problems++;
       } else if (used) {
-        lines.push(`- Core loop works: I ${used.tried.join(', then ')}, and the page responded.`);
+        lines.push(`- Core loop works: I ${used.tried.join(', then ')}, the page responded, and it survived a reload.`);
       }
     }
     if (errors.length) { lines.push('- Console errors:', ...[...new Set(errors)].slice(0, 6).map((e) => `  - ${e}`)); problems++; }

package/src/tools/shell.js

@@ -183,6 +183,25 @@ export function serversReadySince(since = 0) {
   return readyServers.filter((s) => s.at >= since);
 }
 
+/**
+ * Shut down every dev server this session started.
+ *
+ * killTree existed and nothing ever called it, so a server outlived the
+ * session that started it — every build left one behind. Twenty-four builds
+ * in one afternoon left seventy-three node processes running, the oldest for
+ * three and a half hours, holding ports the next run then could not use.
+ *
+ * Best effort and never throws: a process that has already gone is the
+ * outcome we wanted anyway.
+ */
+export function stopServers() {
+  const stopped = readyServers.splice(0, readyServers.length);
+  for (const s of stopped) {
+    try { killTree(s.pid); } catch { /* already gone */ }
+  }
+  return stopped.length;
+}
+
 /** Every server started this session, for reading what they have logged. */
 export function runningServers() {
   return readyServers.slice();

package/src/ui/screen.js

@@ -594,7 +594,7 @@ export class Screen {
   narrate(text) {
     const line = asLabel(text);
     if (!line) return;
-    this.push(dim(`  ⋮ ${clip(line, this.width() - 6)}`));
+    this.push(`${dim('⋮')} ${dim(clip(line, this.width() - 4))}`);
     this.updateSpinner(line);
   }
 

package/src/ui/theme.js

@@ -155,7 +155,68 @@ export const boxRow = (content, width, paint = blue) =>
 
 /** The string with its colour codes stripped — what the terminal actually shows. */
 export const bare = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
-export const visLen = (s) => bare(s).length;
+
+/**
+ * How many columns one character occupies.
+ *
+ * Not every character is one cell wide, and counting them as though they were
+ * is how a box tears: the right border of a row holding CJK or an emoji lands
+ * one or two columns early, and every frame after it looks broken. It cost us
+ * a crooked credit line in the header for months — and any app whose name the
+ * model writes in Japanese would have done the same to the transcript.
+ *
+ * Three widths. Combining marks and the variation selectors hang off the
+ * character before them and take no room of their own. The wide ranges — CJK,
+ * Hangul, kana, fullwidth forms, and the emoji planes — are drawn two cells
+ * wide by every terminal worth supporting. Everything else is one.
+ *
+ * Ranges rather than a dependency: this is the whole of what a terminal needs,
+ * and a table of every Unicode width would be a megabyte to get the last
+ * fraction of a percent right.
+ */
+export function charWidth(code) {
+  // Zero: combining marks, joiners, variation selectors.
+  if ((code >= 0x0300 && code <= 0x036f)
+    || (code >= 0x200b && code <= 0x200f)
+    || (code >= 0xfe00 && code <= 0xfe0f)
+    || (code >= 0xe0100 && code <= 0xe01ef)
+    || code === 0x200d) return 0;
+
+  // Two: the wide and fullwidth blocks, and the emoji planes.
+  if ((code >= 0x1100 && code <= 0x115f)
+    || (code >= 0x2e80 && code <= 0x303e)
+    || (code >= 0x3041 && code <= 0x33ff)
+    || (code >= 0x3400 && code <= 0x4dbf)
+    || (code >= 0x4e00 && code <= 0x9fff)
+    || (code >= 0xa000 && code <= 0xa4cf)
+    || (code >= 0xac00 && code <= 0xd7a3)
+    || (code >= 0xf900 && code <= 0xfaff)
+    || (code >= 0xfe30 && code <= 0xfe6f)
+    || (code >= 0xff00 && code <= 0xff60)
+    || (code >= 0xffe0 && code <= 0xffe6)
+    || (code >= 0x1f300 && code <= 0x1f64f)
+    || (code >= 0x1f680 && code <= 0x1f6ff)
+    || (code >= 0x1f900 && code <= 0x1f9ff)
+    || (code >= 0x20000 && code <= 0x3fffd)) return 2;
+
+  return 1;
+}
+
+/** The columns a string takes up once its colour codes are discounted. */
+export function visLen(s) {
+  const text = bare(s);
+  let cells = 0;
+  for (let i = 0; i < text.length;) {
+    const cp = text.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    i += ch.length;
+    // A variation selector turns the character before it into an emoji, and
+    // an emoji is two cells wide however narrow its text form was.
+    if (text.codePointAt(i) === 0xfe0f) { cells += 2; i += 1; continue; }
+    cells += charWidth(cp);
+  }
+  return cells;
+}
 
 /** The first `width` visible characters, with escape sequences left intact. */
 export function sliceVis(s, width) {
@@ -166,9 +227,17 @@ export function sliceVis(s, width) {
       const m = /^\x1b\[[0-9;]*m/.exec(s.slice(i));
       if (m) { out += m[0]; i += m[0].length - 1; continue; }
     }
-    if (seen >= width) break;
-    out += s[i];
-    seen++;
+    // A wide character that would straddle the edge is left off entirely:
+    // half of one is a replacement glyph in most terminals and a torn border
+    // in the rest.
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const selector = s.codePointAt(i + ch.length) === 0xfe0f;
+    const w = selector ? 2 : charWidth(cp);
+    if (seen + w > width) break;
+    out += selector ? ch + String.fromCodePoint(0xfe0f) : ch;
+    i += (selector ? ch.length + 1 : ch.length) - 1;
+    seen += w;
   }
   return out;
 }
@@ -229,8 +298,11 @@ export function wrapAnsi(text, width) {
       }
     }
     if (text[i] === ' ') { lastSpace = line.length; lastSpaceSeen = seen; }
-    line += text[i];
-    seen++;
+    const cp = text.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    line += ch;
+    i += ch.length - 1;
+    seen += charWidth(cp);
     if (seen >= width) {
       // Break at a word boundary unless that would leave a stub behind.
       if (lastSpace > 0 && lastSpaceSeen > width * 0.4) flush(lastSpace);
@@ -348,12 +420,16 @@ export function planRows(items) {
   const done = list.filter((i) => i?.done).length;
   const current = list.findIndex((i) => !i?.done);
 
-  const rows = [`  ${progressBar(done, list.length)}  ${sky(`${done}/${list.length}`)}`];
+  // One left edge for the whole transcript: markers in column zero, every
+  // piece of content at column two. The plan used to sit at two and four, so
+  // three different margins ran down the page and the eye had no line to
+  // follow.
+  const rows = [`${progressBar(done, list.length)}  ${sky(`${done}/${list.length}`)}`];
   list.forEach((item, i) => {
     const text = clip(String(item?.text ?? '').trim(), 64);
-    if (item?.done) rows.push(`    ${theme.ok('✓')} ${dim(text)}`);
-    else if (i === current) rows.push(`    ${blue('▸')} ${chalk.white(text)}`);
-    else rows.push(`    ${dim('○')} ${dim(text)}`);
+    if (item?.done) rows.push(`  ${theme.ok('✓')} ${dim(text)}`);
+    else if (i === current) rows.push(`  ${blue('▸')} ${chalk.white(text)}`);
+    else rows.push(`  ${dim('○')} ${dim(text)}`);
   });
   return rows;
 }

package/templates/next-shadcn/TEMPLATE.md

@@ -73,6 +73,31 @@ useEffect(() => { localStorage.setItem("bill", bill); }, [bill]);
 // next-themes — there is no "next-themes/dist/types". Import from "next-themes".
 ```
 
+## Where a file goes
+
+Routing is folder-based and it is **not** flexible: a page is only a route if
+it sits at `src/app/<segment>/page.tsx`. A `page.tsx` anywhere else is an
+ordinary file that nothing ever renders.
+
+```
+src/
+  app/
+    layout.tsx            the shell, already written
+    page.tsx              /
+    globals.css           the design tokens — re-tint these
+    expenses/page.tsx     /expenses
+    api/expenses/route.ts GET/POST /api/expenses
+  components/
+    expenses/list.tsx     feature components, one per file
+    ui/                   the 33 shadcn primitives, already here
+  lib/
+    store.ts              data, schemas, anything the server owns
+```
+
+Wrong, and it silently does nothing: `expenses/page.tsx` at the project root,
+or `components/` beside `src/` instead of inside it. The app builds, the
+route 404s, and nothing tells you why.
+
 ## Conventions
 
 - Components are named exports — `export function BillInput()` — imported with

package/templates/next-shadcn/package.json

@@ -6,7 +6,8 @@
     "dev": "next dev",
     "build": "next build",
     "start": "next start",
-    "lint": "eslint"
+    "lint": "eslint",
+    "test": "vitest run"
   },
   "dependencies": {
     "class-variance-authority": "^0.7.1",
@@ -34,6 +35,7 @@
     "eslint": "^9",
     "eslint-config-next": "16.3.4",
     "tailwindcss": "^4",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^3.2.4"
   }
 }

package/templates/next-shadcn/src/lib/store.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+
+/**
+ * The starter ships one passing test so there is a runner to add to rather
+ * than a decision to make. `npm test` works from the first minute, and
+ * ucode runs the tests that touch whatever it just changed — which only finds
+ * anything if tests exist.
+ *
+ * Delete this once there is something real to assert.
+ */
+describe('__APP_NAME__', () => {
+  it('has a test runner wired up', () => {
+    expect(true).toBe(true);
+  });
+});

package/ucode.js

@@ -145,6 +145,16 @@ async function main() {
     await agent.persist().catch(() => {});
     agent.ui.close();
     process.exitCode = 1;
+  } finally {
+    // Take the dev servers down with the session that started them, however it
+    // ended. killTree was written for this and nothing ever called it, so every
+    // build left its server running: twenty-four builds in an afternoon left
+    // seventy-three node processes alive, the oldest for three and a half
+    // hours, holding the ports the next run wanted.
+    try {
+      const { stopServers } = await import('./src/tools/shell.js');
+      stopServers();
+    } catch { /* nothing started, or already gone */ }
   }
 }