ucode-agent 1.41.0 → 1.42.0

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.41.0
+                                                                           v1.42.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.0",
+  "version": "1.42.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';
@@ -1105,6 +1105,7 @@ export class Agent {
     this.lookedThisTurn = false;
     this.reads = new Map();
     this.declines = 0;
+    this.apps = [];
     forgetReviews(); // a new request: its apps get a fresh design review
     const images = await this.attachImages(input);
     this.push(images.length
@@ -1347,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
@@ -1682,6 +1684,13 @@ export class Agent {
     // a designer's review, and now the app actually driven — and it was the
     // quietest line on screen, saying only that it had happened. Its verdict
     // goes on the same line, the way a change carries its two numbers.
+    // Which app folders this turn actually made, so a second one can be
+    // refused before it is built and any leftovers can be counted at the end.
+    if (call.name === 'create_app' && call.args?.folder) {
+      const made = path.resolve(this.cwd, String(call.args.folder));
+      if (!(this.apps ??= []).includes(made)) this.apps.push(made);
+    }
+
     if (call.name === 'look_at_app') {
       const found = /^(\d+) problem/.exec(out.summary ?? '');
       this.ui.runStat?.(found ? `${found[1]} to fix` : 'clean');
@@ -1689,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;
@@ -1784,6 +1821,30 @@ export class Agent {
       this.reads.set(key, seen + 1);
     }
 
+    // Starting a second app instead of fixing the first.
+    //
+    // A traced build hit a problem in todo/, abandoned it and made todo-fixed/
+    // — three create_app calls, two folders, one broken, the app typed twice.
+    // Starting over is never the cheap way out of a problem in a file, and it
+    // leaves the user to work out which folder is the real one.
+    if (call.name === 'create_app' && call.args?.folder && (this.apps ?? []).length) {
+      const wanted = path.resolve(this.cwd, String(call.args.folder));
+      const already = this.apps.filter((f) => f !== wanted);
+      if (already.length && !this.apps.includes(wanted)) {
+        const show = already.map((f) => path.basename(f)).join(', ');
+        throw new ToolFailure({
+          kind: 'already_building',
+          attempted: `creating ${call.args.folder}`,
+          failed: `You already made ${show} this turn, and it is still there.`,
+          fix:
+            `Fix ${show} instead of starting again — whatever is wrong with it is a smaller `
+            + 'job than writing the whole app a second time, and a half-finished folder left '
+            + `beside the real one is worse than either. If ${show} genuinely cannot be saved, `
+            + 'delete it first, then create this one.',
+        });
+      }
+    }
+
     if (call.name === 'load_skill') return this.loadSkill(call.args?.name);
     if (call.name === 'update_plan') return this.updatePlan(call.args?.items);
     if (call.name === 'delegate') return this.delegate(call.args?.tasks);
@@ -2082,6 +2143,23 @@ export class Agent {
     const live = await this.liveErrors();
     if (live) problems.push(live);
 
+    // Two app folders, one of them abandoned.
+    //
+    // A build hit a problem in todo/, started todo-fixed/, then said in its
+    // reply that it had removed the duplicate — and had not. Both were still
+    // on disk for the user to sort out, and the claim that they were not is
+    // the failure this whole checking pass exists to catch: saying a thing is
+    // done when it is not. So it is checked rather than believed.
+    const apps = this.apps ?? [];
+    if (apps.length > 1) {
+      const names = apps.map((f) => path.basename(f));
+      problems.push(
+        `There are ${apps.length} app folders here now: ${names.join(', ')}. Only one of them is `
+        + 'the app. Delete the ones you are not shipping — actually delete them, do not just say '
+        + 'you have — and make sure the one you keep is the one that works.',
+      );
+    }
+
     // Then look at it, in the same pass that type-checks — not when the model
     // remembers to. A check that runs only when it is asked for reports
     // nothing on exactly the builds that needed it, and this is the only one

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/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);
+  });
+});