ucode-agent 1.32.0 → 1.34.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.32.0",
+  "version": "1.34.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,7 @@
   "scripts": {
     "start": "node ucode.js",
     "test": "node test/run.js",
-    "prepublishOnly": "node test/run.js"
+    "prepublishOnly": "node scripts/no-bundled-key.js && node test/run.js"
   },
   "repository": {
     "type": "git",
@@ -26,9 +26,6 @@
     "url": "https://github.com/sppideey/ucode-agent/issues"
   },
   "homepage": "https://github.com/sppideey/ucode-agent#readme",
-  "publishConfig": {
-    "access": "public"
-  },
   "engines": {
     "node": ">=22"
   },
@@ -56,5 +53,8 @@
   },
   "devDependencies": {
     "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/core/loop.js

@@ -1931,7 +1931,12 @@ export class Agent {
     }
 
     const check = async (label, command, cwd) => {
-      this.ui.toolCall(label);
+      // The spinner only, never a transcript line. This pass runs after the
+      // model has finished speaking, so a step logged here is the last thing
+      // left on screen — the session ends on "Checking tasker/app.js" instead
+      // of on the answer, and it reads as though something was still going
+      // when it stopped. A check that passes has nothing to say, and one that
+      // fails goes back to the model, which says it in words.
       this.ui.startSpinner(label);
       const { out, err } = await this.execute({
         id: 'check', name: 'run_command',

package/src/core/provider.js

@@ -107,6 +107,18 @@ export const FALLBACKS = [
 
 /** The next model to try after `id`, skipping any already tried this round. */
 export function fallbackFor(id, tried = new Set()) {
+  // Off unless UCODE_FALLBACK=1. A build that starts on one model and finishes
+  // on another finishes to a different standard, and the swap lands exactly
+  // when the user is least placed to work out why the output changed —
+  // mid-build, behind a note that scrolls past. Which model to run is the one
+  // decision they made before starting; it is not one to take back for them.
+  //
+  // Every caller already reads "no fallback" as "wait, then try this one
+  // again": failover waits a minute and returns to the same model, the
+  // stuck-detector simply does not switch, and a worker retries its own. That
+  // is why this can be a single gate rather than four.
+  if (process.env.UCODE_FALLBACK !== '1') return null;
+
   const start = Math.max(0, FALLBACKS.indexOf(id));
   for (let i = 1; i <= FALLBACKS.length; i++) {
     const next = FALLBACKS[(start + i) % FALLBACKS.length];

package/src/tools/browser.js

@@ -179,6 +179,81 @@ export function forgetReviews() {
   reviews.clear();
 }
 
+
+/**
+ * Text typed into the app while checking it. Distinctive enough to recognise
+ * in a screenshot, and obviously not something a user wrote.
+ */
+const PROBE_TEXT = 'ucode check';
+
+/** Did anything at all happen on the page? */
+const moved = (a, b) => a.nodes !== b.nodes || a.text !== b.text || a.stored !== b.stored;
+
+/**
+ * Use the app, rather than only looking at it.
+ *
+ * Everything else here is an inspection: overflow, labels, broken images,
+ * console errors on load. All of it passes on an app whose Add button does
+ * nothing, because a page with dead JavaScript still renders, still has good
+ * contrast and still has no console errors — it simply does not work. Nothing
+ * in the harness ever pressed anything, so the model was never told, and never
+ * fixed it.
+ *
+ * So: type into the first text field, press Enter, and if that changed nothing,
+ * click the first button. Then look at whether the page has more nodes, more
+ * text, or more in localStorage than it did. Any of those moving means the core
+ * loop is wired up. None of them moving, on a page that has controls to press,
+ * means it is not.
+ *
+ * Real keyboard and mouse input through the driver, never synthetic DOM events:
+ * an implicit form submit does not fire for a dispatched event, which would
+ * report a working form as dead.
+ *
+ * A page with nothing to press — a landing page, a chart, a page of prose — is
+ * not exercised and not judged. Returning null there is the difference between
+ * a check and a false accusation.
+ */
+async function useTheApp(page) {
+  const snapshot = () => page.evaluate(() => ({
+    nodes: document.body.querySelectorAll('*').length,
+    text: document.body.innerText.replace(/\s+/g, ' ').trim().length,
+    stored: (() => { try { return JSON.stringify(localStorage).length; } catch { return 0; } })(),
+  }));
+
+  const before = await snapshot().catch(() => null);
+  if (!before) return null;
+  const tried = [];
+
+  // A field and the Enter key: the core loop of most one-page apps.
+  const field = page.locator('input[type="text"], input[type="search"], input:not([type]), textarea').first();
+  if (await field.count().catch(() => 0)) {
+    const ok = await field.fill(PROBE_TEXT, { timeout: 2_000 }).then(() => true).catch(() => false);
+    if (ok) {
+      await field.press('Enter', { timeout: 2_000 }).catch(() => {});
+      await page.waitForTimeout(300);
+      tried.push('typed into the first field and pressed Enter');
+    }
+  }
+
+  let after = await snapshot().catch(() => before);
+  if (tried.length && moved(before, after)) return { tried, worked: true };
+
+  // Nothing moved, so try the other half of the same pattern.
+  const button = page.locator('button:not([disabled]), input[type="submit"], [role="button"]').first();
+  if (await button.count().catch(() => 0)) {
+    const label = (await button.innerText().catch(() => '') || '').trim().replace(/\s+/g, ' ').slice(0, 24);
+    const ok = await button.click({ timeout: 2_000 }).then(() => true).catch(() => false);
+    if (ok) {
+      await page.waitForTimeout(300);
+      tried.push(`clicked ${label ? `"${label}"` : 'the first button'}`);
+      after = await snapshot().catch(() => after);
+    }
+  }
+
+  if (!tried.length) return null;
+  return { tried, worked: moved(before, after) };
+}
+
 export async function lookAtApp({ url, paths = ['/'] }) {
   const base = String(url ?? '').trim().replace(/\/+$/, '');
   if (!LOCAL.test(`${base}/`)) {
@@ -217,6 +292,7 @@ export async function lookAtApp({ url, paths = ['/'] }) {
 
     const target = `${base}${pagePath}`;
     let loadError = null;
+    let used = null;
     try {
       // 'load', not 'networkidle': a dev server holds a hot-reload
       // connection open and polls, so the network may never go quiet and
@@ -246,6 +322,12 @@ export async function lookAtApp({ url, paths = ['/'] }) {
         });
         await fs.writeFile(file, buffer);
         shot = { label: `${pagePath} at ${size.width}px (${size.name})`, dataUrl: `data:image/jpeg;base64,${buffer.toString('base64')}` };
+
+        // Once per look, not once per width: pressing the same button four
+        // times says nothing the first press did not, and costs four seconds.
+        if (size.name === 'desktop' && pagePath === pages[0]) {
+          used = await useTheApp(page).catch(() => null);
+        }
       }
     } catch (err) {
       loadError = `the page broke while being checked: ${String(err.message).split('\n')[0]}`;
@@ -270,11 +352,25 @@ export async function lookAtApp({ url, paths = ['/'] }) {
       if (facts?.noAlt) lines.push(`- ${facts.noAlt} image(s) without alt text.`);
       if (facts?.tiny) lines.push(`- ${facts.tiny} tap target(s) smaller than 32px on a phone.`);
       if (facts?.smallText) lines.push(`- ${facts.smallText} text element(s) under 12px.`);
+      if (used && !used.worked) {
+        lines.push(
+          `- NOTHING HAPPENS WHEN YOU USE IT. I ${used.tried.join(', then ')} — and the page`,
+          '  gained no elements, changed no text and stored nothing. The markup and the styling',
+          '  are there; the behaviour is not wired to them. Find the listener that was never',
+          '  attached, or the handler that throws before it does anything, and fix that first:',
+          '  everything else on this page is decoration until it works.',
+        );
+        problems++;
+      } else if (used) {
+        lines.push(`- Core loop works: I ${used.tried.join(', then ')}, and the page responded.`);
+      }
     }
     if (errors.length) { lines.push('- Console errors:', ...[...new Set(errors)].slice(0, 6).map((e) => `  - ${e}`)); problems++; }
     if (failed.length) { lines.push('- Failed requests:', ...[...new Set(failed)].slice(0, 6).map((f) => `  - ${f}`)); problems++; }
     if (lines.length === 2 && !loadError) lines.push('- No errors, no overflow, nothing unlabeled.');
-    const broken = Boolean(loadError || errors.length || facts?.empty);
+    // A dead core loop counts as broken: a screenshot of an app that does not
+    // work is not worth a paragraph on its typography.
+    const broken = Boolean(loadError || errors.length || facts?.empty || (used && !used.worked));
     return { section: lines.join('\n'), shot, problems, broken };
   })));
 

package/src/tools/index.js

@@ -85,7 +85,11 @@ export const tools = [
       'Start a new app AND write it, in one call. Pass "files" with the whole app and this ' +
       'is the only call the build needs: the starter lands, your files are written over it, ' +
       'and the result comes back with everything. Two starters. "plain-html" (the default): ' +
-      'one index.html, one stylesheet, one ES module — nothing to install, nothing to build, ' +
+      'one index.html, one stylesheet, one ES module — nothing to install, nothing to build, ' +
+      'and the stylesheet is a design system already: a palette, a spacing scale, radii, ' +
+      'motion timings, focus rings and a breakpoint. Re-tint those tokens to suit the app ' +
+      'and compose every rule from them. Replacing it with raw pixel values is what an ' +
+      'undesigned page is made of. ' +
       'opens straight in a browser, and its three files come back inside this result so there ' +
       'is never a reason to read them. Use it for anything that is one page: a tasks app, a ' +
       'toy, a game, a visualisation, a calculator, a timer. "next-shadcn": Next.js 16, ' +

package/src/tools/scaffold.js

@@ -108,6 +108,46 @@ 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.
+ */
+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'));
@@ -242,7 +282,13 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // 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);
+  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
@@ -271,7 +317,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 written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
+  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
 
   // The starter's own files, in full, so there is never a reason to read them
   // back — and only the ones this call did not already write over. A read is
@@ -287,7 +334,14 @@ 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` : '') +
+      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\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) — ` +
           'nothing to install: build and run straight away.\n'