ucode-agent 1.36.0 → 1.38.0

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.29.0
+                                                                           v1.36.0
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box
@@ -107,12 +107,14 @@ of what ucode is asked to do, and it answers far sooner than the big reasoning
 models. Switch to Ultra when a problem needs the million-token window more than
 the speed.
 
-**A busy model never stops a build.** Free endpoints are shared, and "too many
-requests" is routine. ucode waits it out with growing pauses, and if the model
-stays busy it carries on with the next one — North Mini Code, then Nemotron 3.5
-Lightning, Super, Ultra — from exactly where it was, and tells you it switched.
-If every model is busy at once it waits a minute and goes round again. Your
-chosen model gets another go a few minutes later.
+**The model you chose is the model you keep.** Free endpoints are shared and
+"too many requests" is routine, so ucode waits it out with growing pauses and
+comes back to the same model. It does not quietly hand your build to a
+different one: a build that starts on one model and finishes on another
+finishes to a different standard, and the swap lands exactly when you are least
+placed to work out why the output changed. Set `UCODE_FALLBACK=1` if you would
+rather it moved down the list — North Mini Code, Nemotron 3.5 Lightning, Super,
+Ultra — when a model stays busy.
 
 ## What it does
 
@@ -211,6 +213,13 @@ same link. Needs a token from vercel.com/account/tokens in `~/.ucode/.env` as
 sunset, graphite, violet or citrus — each a full light and dark palette with its
 own font, so apps stop looking like the same default blue.
 
+**Every turn can be taken back.** `/undo` puts back every file the last turn
+changed — a rewritten file returns byte for byte, a file that did not exist
+before is removed again. Each write keeps the original the first time that turn
+touches it, so what comes back is the state before the turn rather than before
+the last of six edits to the same file. An agent that writes to your disk on
+its own should be able to take it back, whether or not the project has git.
+
 **It notices when it is going round in circles.** The same failing edit, an edit
 that changes nothing, or a build failing on the same errors three times gets a
 firm, specific note; if that does not work, the turn moves to another model.
@@ -238,13 +247,23 @@ written, its install starts in the background while the rest of the app is
 still being written. An install the model asks for later waits for that one
 instead of running twice, and anything run in that folder waits for it too.
 
-**It looks at what it built.** `look_at_app` opens the running app in a real
-browser — the Edge or Chrome already on your machine, so there is nothing extra
-to download — at 375px and 1440px. It reports console errors, failed requests,
-content that spills off a phone screen, broken images and unlabeled controls,
-saves screenshots to `.ucode/screenshots`, and has Nemotron Nano Omni review them
-the way a designer would. The model fixes what it finds before calling the app
-done. Both widths load at once, and the designer review — the slow part — runs
+**It opens what it built and uses it.** Every app build ends with a look — not
+when the model remembers to ask for one, but as part of the same pass that
+type-checks. It opens the app in a real browser (the Edge or Chrome already on
+your machine, so there is nothing extra to download) at 375px and 1440px, and
+serves the folder itself when there is no dev server to point at, which is how
+a three-file app gets checked at all.
+
+Then it uses the app. It types into the first field, presses Enter, and clicks
+the button that submits — and if the page gains no elements, changes no text
+and stores nothing, that is reported as the thing to fix before anything else.
+A page that renders and has no working behaviour passes a type check, a syntax
+check and a screenshot; the only way to find out is to press something.
+
+It also reports console errors, failed requests, content that spills off a
+phone screen, broken images and unlabeled controls, saves screenshots to
+`.ucode/screenshots`, and has Nemotron Nano Omni review them the way a designer
+would. The model fixes what it finds before calling the app done. Both widths load at once, and the designer review — the slow part — runs
 on the first look at an app in each request and is skipped, not waited on, when
 the vision model is busy. The look after the fixes re-runs only the fast checks:
 a few seconds.
@@ -355,6 +374,11 @@ Everything after the frontmatter is the instruction.
 | `/session delete 2,5` | delete saved conversations by number (or `d d` in the list) |
 | `/new` | save this one and start fresh |
 | `/remember <note>` | add a standing note to this project's `UCODE.md` |
+| `/undo` | put back every file the last turn changed |
+| `/look [url]` | open the running app and report what is on the page |
+| `/deploy [folder]` | put the app online and get its link |
+| `/stats` | time, steps and tokens this session |
+| `/doctor` | check that everything ucode needs is working |
 | `/skills` | what it knows how to do, and what is loaded |
 | `/search <query>` | look something up on the web |
 | `/copy` | last reply to the clipboard |

package/package.json

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

@@ -19,6 +19,7 @@ import { testRunnerFor, relatedCommand, summariseFailures } from './tests.js';
 import { LogWatch } from './livelog.js';
 import { checkHtml } from './htmlcheck.js';
 import { runningServers } from '../tools/shell.js';
+import { unprefixOwnFolder } from './relink.js';
 import { beginTurn, undoTurn, changedCount } from './undo.js';
 import { spawn } from 'node:child_process';
 
@@ -1912,6 +1913,17 @@ export class Agent {
     if (!changed.length) return null;
 
     const root = path.resolve(this.cwd);
+
+    // A page that links to its own folder, whoever wrote it. create_app fixes
+    // the files it is handed, but an app written across several calls — a
+    // scaffold, then two edits — reintroduces the prefix on the next write,
+    // and nothing was watching after the first one. The page then loads no
+    // stylesheet and no script, which is the difference between an app and a
+    // wall of unstyled markup, so it is corrected wherever it turns up.
+    const relinked = await unprefixOwnFolder(root, changed);
+    if (relinked.length) {
+      this.ui.toolCall(`Fixing self-referencing links in ${relinked.join(', ')}`);
+    }
     const tsRoots = new Set();
     const singles = [];
     const problems = [];

package/src/core/relink.js

@@ -0,0 +1,62 @@
+/**
+ * relink.js — taking an app's own folder back out of its own links.
+ *
+ * create_app wants paths relative to the project root — "tide/index.html" —
+ * because that is where every file tool works from. The model then carries the
+ * same prefix into the markup and writes `<link href="tide/styles.css">` inside
+ * tide/index.html, where it resolves to tide/tide/styles.css and 404s. The page
+ * comes up as bare markup: no stylesheet, no script, dead buttons. It is the
+ * commonest way a finished build looks like nothing was built.
+ *
+ * It lived inside create_app first, which covered only the files that call was
+ * handed. An app written across a scaffold and two edits put the prefix back on
+ * the next write and nothing was watching, so it runs over every changed page
+ * now, on every turn, wherever the page came from.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+/** Relative href/src only — absolute paths, URLs, data: and anchors are left alone. */
+const ASSET_REF = /\b(href|src)=("|')(?!https?:|\/\/|\/|data:|#|mailto:|tel:)([^"']+)\2/g;
+
+/**
+ * Strip a page's own folder from its relative links.
+ *
+ * `files` are paths relative to `root`. A page at "tide/index.html" has "tide/"
+ * taken off its links, because inside that folder the prefix is always wrong.
+ * A page sitting directly in the root has no folder to strip and is skipped.
+ *
+ * Returns the pages it changed, for reporting. Never throws: a file that cannot
+ * be read is a file that is left exactly as it is.
+ */
+export async function unprefixOwnFolder(root, files) {
+  const fixed = [];
+
+  for (const rel of files) {
+    if (!/\.html?$/i.test(rel)) continue;
+
+    const abs = path.resolve(root, rel);
+    const folder = path.basename(path.dirname(abs));
+    if (!folder || path.dirname(abs) === path.resolve(root)) continue;
+
+    const text = await fs.readFile(abs, 'utf8').catch(() => null);
+    if (text === null) continue;
+
+    const prefix = `${folder}/`;
+    let hits = 0;
+    const next = text.replace(ASSET_REF, (all, attr, quote, value) => {
+      if (!value.startsWith(prefix)) return all;
+      hits++;
+      return `${attr}=${quote}${value.slice(prefix.length)}${quote}`;
+    });
+
+    if (!hits) continue;
+    try {
+      await fs.writeFile(abs, next, 'utf8');
+      fixed.push(`${rel} (${hits})`);
+    } catch { /* unwritable: leave it, and say nothing that is not true */ }
+  }
+
+  return fixed;
+}

package/src/tools/files.js

@@ -298,7 +298,7 @@ async function put(target, content, { diffMax = 16 } = {}) {
 
   try {
     await fs.mkdir(path.dirname(target.abs), { recursive: true });
-    await remember(target.abs);
+    await remember(target.abs);
     await fs.writeFile(target.abs, content, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -454,12 +454,13 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
       fix: 'edit_file replaces existing text. Use write_file to create a file.',
     });
   }
+  // An edit whose two halves are the same asks for the file to stay as it is,
+  // which it will. Refusing that was a hard failure, and the model answered it
+  // by sending the same edit again — the stuck detector carries a special case
+  // for exactly this loop. Saying "already done" ends it in one step.
   if (old_string === new_string) {
-    throw new ToolFailure({
-      kind: 'bad_args', attempted,
-      failed: `${prefix}old_string and new_string are identical, so the edit would change nothing.`,
-      fix: 'Set new_string to the text you actually want there.',
-    });
+    const found = text.indexOf(old_string);
+    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, loose: false };
   }
 
   // Models write \n. A file checked out on Windows is often \r\n, and then an
@@ -557,7 +558,7 @@ export async function editFile({ path: p, old_string, new_string }) {
   });
 
   try {
-    await remember(target.abs);
+    await remember(target.abs);
     await fs.writeFile(target.abs, text, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -631,7 +632,7 @@ export async function multiEdit({ path: p, edits }) {
   }
 
   try {
-    await remember(target.abs);
+    await remember(target.abs);
     await fs.writeFile(target.abs, text, 'utf8');
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
@@ -720,7 +721,7 @@ export async function editFiles({ files }) {
 
   for (const { target, text } of planned) {
     try {
-      await remember(target.abs);
+      await remember(target.abs);
     await fs.writeFile(target.abs, text, 'utf8');
     } catch (err) {
       throw fsFailure(err, `editing ${target.show}`, target.show);

package/src/tools/scaffold.js

@@ -108,88 +108,88 @@ async function copyTree(from, to, fill) {
  * globals.css and layout.tsx. Apps stop looking like the same default blue.
  * Returns the preset used, or null when the starter has none.
  */
-/**
- * The file in each starter that carries the design, not just some of the rules.
- *
- * next-shadcn has globals.css, which applyDesign re-tints. plain-html has one
- * stylesheet and it is the whole design system: the palette, a spacing scale,
- * radii, motion timings, focus rings, a reduced-motion rule and a breakpoint.
- */
-const TOKEN_FILE = { 'plain-html': 'styles.css' };
-
-/**
- * Put the starter's token block back when the app wrote over it without one.
- *
- * The stylesheet in plain-html is a design, not a placeholder — but `files`
- * lands straight on top of the starter, so a model passing its own styles.css
- * replaces the scale, the palette and the timings with whatever it typed. What
- * comes back is hand-rolled CSS with no system behind it, and an app built on
- * raw pixel values has uneven spacing everywhere for the rest of its life.
- *
- * A replacement that declares its own custom properties is left alone: that is
- * a model doing the job properly, and second-guessing it would be worse. Only
- * a stylesheet with no :root variables at all gets the starter's block put
- * back above it, where every rule underneath can reach it.
- */
-const ASSET_REF = /\b(href|src)=("|')(?!https?:|\/\/|\/|data:|#|mailto:|tel:)([^"']+)\2/g;
-
-/**
- * Take the app's own folder back out of its own links.
- *
- * create_app wants paths relative to the project root — "todo/index.html" —
- * because that is where every other file tool works from. The model then
- * carries the same prefix into the markup and writes
- * <link href="todo/styles.css"> inside todo/index.html, where it resolves to
- * todo/todo/styles.css and 404s. The page comes up as bare markup with no
- * stylesheet and no script: no design, no behaviour, nothing in the console
- * but two failed requests.
- *
- * It is the tool's own convention leaking into the file, so the tool takes it
- * back out. Only a leading "<folder>/" on a relative reference, which inside
- * that folder is always wrong — absolute paths, URLs, data: and anchors are
- * left exactly as they are.
- */
-async function unprefixOwnFolder(appDir, written) {
-  const prefix = `${path.basename(appDir)}/`;
-  const fixed = [];
-
-  for (const abs of written) {
-    if (!/\.html?$/i.test(abs)) continue;
-    const text = await fs.readFile(abs, 'utf8').catch(() => null);
-    if (text === null) continue;
-
-    let hits = 0;
-    const next = text.replace(ASSET_REF, (all, attr, quote, value) => {
-      if (!value.startsWith(prefix)) return all;
-      hits++;
-      return `${attr}=${quote}${value.slice(prefix.length)}${quote}`;
-    });
-
-    if (hits) {
-      await fs.writeFile(abs, next, 'utf8');
-      fixed.push(`${path.relative(appDir, abs).split(path.sep).join('/')} (${hits})`);
-    }
-  }
-  return fixed;
-}
-
-async function keepDesignTokens(appDir, template, written, starterCss) {
-  const rel = TOKEN_FILE[template];
-  if (!rel || !starterCss) return null;
-
-  const abs = path.join(appDir, rel);
-  if (!written.has(abs)) return null;                 // never overwritten
-
-  const now = await fs.readFile(abs, 'utf8').catch(() => null);
-  if (now === null || /:root\s*\{[^}]*--/.test(now)) return null;
-
-  const block = /:root\s*\{[\s\S]*?\n\}/.exec(starterCss);
-  if (!block) return null;
-
-  await fs.writeFile(abs, `${block[0]}\n\n${now}`, 'utf8');
-  return rel;
-}
-
+/**
+ * The file in each starter that carries the design, not just some of the rules.
+ *
+ * next-shadcn has globals.css, which applyDesign re-tints. plain-html has one
+ * stylesheet and it is the whole design system: the palette, a spacing scale,
+ * radii, motion timings, focus rings, a reduced-motion rule and a breakpoint.
+ */
+const TOKEN_FILE = { 'plain-html': 'styles.css' };
+
+/**
+ * Put the starter's token block back when the app wrote over it without one.
+ *
+ * The stylesheet in plain-html is a design, not a placeholder — but `files`
+ * lands straight on top of the starter, so a model passing its own styles.css
+ * replaces the scale, the palette and the timings with whatever it typed. What
+ * comes back is hand-rolled CSS with no system behind it, and an app built on
+ * raw pixel values has uneven spacing everywhere for the rest of its life.
+ *
+ * A replacement that declares its own custom properties is left alone: that is
+ * a model doing the job properly, and second-guessing it would be worse. Only
+ * a stylesheet with no :root variables at all gets the starter's block put
+ * back above it, where every rule underneath can reach it.
+ */
+const ASSET_REF = /\b(href|src)=("|')(?!https?:|\/\/|\/|data:|#|mailto:|tel:)([^"']+)\2/g;
+
+/**
+ * Take the app's own folder back out of its own links.
+ *
+ * create_app wants paths relative to the project root — "todo/index.html" —
+ * because that is where every other file tool works from. The model then
+ * carries the same prefix into the markup and writes
+ * <link href="todo/styles.css"> inside todo/index.html, where it resolves to
+ * todo/todo/styles.css and 404s. The page comes up as bare markup with no
+ * stylesheet and no script: no design, no behaviour, nothing in the console
+ * but two failed requests.
+ *
+ * It is the tool's own convention leaking into the file, so the tool takes it
+ * back out. Only a leading "<folder>/" on a relative reference, which inside
+ * that folder is always wrong — absolute paths, URLs, data: and anchors are
+ * left exactly as they are.
+ */
+async function unprefixOwnFolder(appDir, written) {
+  const prefix = `${path.basename(appDir)}/`;
+  const fixed = [];
+
+  for (const abs of written) {
+    if (!/\.html?$/i.test(abs)) continue;
+    const text = await fs.readFile(abs, 'utf8').catch(() => null);
+    if (text === null) continue;
+
+    let hits = 0;
+    const next = text.replace(ASSET_REF, (all, attr, quote, value) => {
+      if (!value.startsWith(prefix)) return all;
+      hits++;
+      return `${attr}=${quote}${value.slice(prefix.length)}${quote}`;
+    });
+
+    if (hits) {
+      await fs.writeFile(abs, next, 'utf8');
+      fixed.push(`${path.relative(appDir, abs).split(path.sep).join('/')} (${hits})`);
+    }
+  }
+  return fixed;
+}
+
+async function keepDesignTokens(appDir, template, written, starterCss) {
+  const rel = TOKEN_FILE[template];
+  if (!rel || !starterCss) return null;
+
+  const abs = path.join(appDir, rel);
+  if (!written.has(abs)) return null;                 // never overwritten
+
+  const now = await fs.readFile(abs, 'utf8').catch(() => null);
+  if (now === null || /:root\s*\{[^}]*--/.test(now)) return null;
+
+  const block = /:root\s*\{[\s\S]*?\n\}/.exec(starterCss);
+  if (!block) return null;
+
+  await fs.writeFile(abs, `${block[0]}\n\n${now}`, 'utf8');
+  return rel;
+}
+
 export async function applyDesign(appDir, design) {
   const dir = path.join(appDir, 'presets');
   const names = (await fs.readdir(dir).catch(() => [])).filter((f) => f.endsWith('.json'));
@@ -304,12 +304,21 @@ export async function createApp({ folder, name, description, template = 'plain-h
   } catch {
     existing = [];
   }
-  if (existing.length) {
+  // A folder with something already in it, and the whole app passed in
+  // alongside: that is the second attempt at a build that half happened.
+  // Refusing it is how a Next.js build spent two calls being told no and then
+  // started over from nothing. The starter is already on disk — take the files
+  // and write them into it.
+  //
+  // With no files it is still a refusal, because then there is nothing to do
+  // but copy a starter over work that is already there.
+  const adopt = existing.length > 0 && given.length > 0;
+  if (existing.length && !adopt) {
     throw new ToolFailure({
       kind: 'not_empty',
       attempted,
       failed: `${target.show} already has ${existing.length} item(s) in it: ${existing.slice(0, 5).join(', ')}.`,
-      fix: 'Pick a new folder name. If this folder is the app from an earlier attempt, work in it instead of creating it again.',
+      fix: 'Pick a new folder name, or pass the app in "files" to write it into the folder that is already there.',
     });
   }
 
@@ -320,23 +329,23 @@ export async function createApp({ folder, name, description, template = 'plain-h
     __APP_DESCRIPTION__: plain(description) || display,
   };
 
-  const copied = await copyTree(path.join(TEMPLATES, template), target.abs, fill);
+  const copied = adopt ? [] : await copyTree(path.join(TEMPLATES, template), target.abs, fill);
   // Next.js serves static files from public/; a plain page has no such place
   // and an empty folder in a three-file app is clutter.
-  if (template !== 'plain-html') await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
-  const look = await applyDesign(target.abs, design);
-
-  // Read before the app's own files land on top of it, so the tokens can be
-  // put back if the replacement arrives without any.
-  const starterCss = TOKEN_FILE[template]
-    ? await fs.readFile(path.join(target.abs, TOKEN_FILE[template]), 'utf8').catch(() => null)
+  if (!adopt && template !== 'plain-html') await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
+  const look = await applyDesign(target.abs, design);
+
+  // Read before the app's own files land on top of it, so the tokens can be
+  // put back if the replacement arrives without any.
+  const starterCss = TOKEN_FILE[template]
+    ? await fs.readFile(path.join(target.abs, TOKEN_FILE[template]), 'utf8').catch(() => null)
     : null;
 
   // The starter has been installed on this machine before: hard-link that
   // tree in, which is seconds where npm is a minute. Otherwise install as
   // usual, and keep the result so the next app is instant.
   let linked = 0;
-  const needsInstall = template !== 'plain-html';
+  const needsInstall = !adopt && template !== 'plain-html';
   if (install && needsInstall) {
     // Keyed on the starter's lockfile, which is the same for every app made
     // from it — the app's own is rewritten by npm as it installs.
@@ -359,8 +368,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // one, and round trips are nearly all of the time a build takes.
   const mine = given;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
-  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
-  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
+  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
+  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
   const relinked = await unprefixOwnFolder(target.abs, written);
 
   // The starter's own files, in full, so there is never a reason to read them
@@ -377,20 +386,20 @@ export async function createApp({ folder, name, description, template = 'plain-h
   const out = result(
     `Created ${target.show} from the ${template} starter — ${copied.length} files, already known to build.\n` +
       (look ? `Design: the ${look.name} preset (${look.summary}), font ${look.fonts?.sans ?? 'Geist'}.\n` : '') +
-      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
-      (relinked.length
-        ? `\nFixed in ${relinked.join(', ')}: links that began with "${path.basename(target.abs)}/". ` +
-          'Paths in "files" are relative to the project root, but a link inside a page is ' +
-          'relative to that page — so "index.html" beside "styles.css" links to it as ' +
-          '"styles.css", never "app/styles.css". Written that way the stylesheet and the ' +
-          'script 404 and the page comes up as bare markup.\n'
-        : '') +
-      (keptTokens
-        ? `\nYour ${keptTokens} arrived with no :root block, so the starter's was kept above it — ` +
-          'the palette, the spacing scale (--s1 to --s5), the radius and the motion timings. ' +
-          'Build the rest of the stylesheet out of those variables: spacing that comes from a ' +
-          'scale is the difference between a designed page and an arranged one. Re-tint the ' +
-          'values to suit this app; do not go back to raw pixels.\n'
+      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
+      (relinked.length
+        ? `\nFixed in ${relinked.join(', ')}: links that began with "${path.basename(target.abs)}/". ` +
+          'Paths in "files" are relative to the project root, but a link inside a page is ' +
+          'relative to that page — so "index.html" beside "styles.css" links to it as ' +
+          '"styles.css", never "app/styles.css". Written that way the stylesheet and the ' +
+          'script 404 and the page comes up as bare markup.\n'
+        : '') +
+      (keptTokens
+        ? `\nYour ${keptTokens} arrived with no :root block, so the starter's was kept above it — ` +
+          'the palette, the spacing scale (--s1 to --s5), the radius and the motion timings. ' +
+          'Build the rest of the stylesheet out of those variables: spacing that comes from a ' +
+          'scale is the difference between a designed page and an arranged one. Re-tint the ' +
+          'values to suit this app; do not go back to raw pixels.\n'
         : '') +
       (linked
         ? `Its packages are already in place (${linked.toLocaleString()} files, linked from the starter cache) — ` +