ucode-agent 1.33.0 → 1.35.0

package/package.json

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

@@ -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

@@ -765,6 +765,36 @@ async function streamed(request, opts, id) {
  * "path", then "content", then either the next file or the end. Splitting on
  * that shape and escaping the stray quotes gets every file back.
  */
+/**
+ * Which calls can be rebuilt out of broken JSON.
+ *
+ * All three carry file contents — hundreds of lines of HTML, CSS and
+ * JavaScript escaped into a JSON string — which is the one argument shape a
+ * model gets wrong often enough to matter. Everything else is short enough
+ * that a parse failure is a real mistake, worth reporting rather than guessing
+ * around.
+ */
+const SALVAGEABLE = new Set(['write_file', 'batch_write', 'create_app']);
+
+/**
+ * The plain string arguments sitting beside a files array, read off the raw
+ * text when the object as a whole will not parse.
+ *
+ * Only the keys create_app needs, and only from before the files begin, so a
+ * "name" belonging to something nested inside a file cannot be mistaken for
+ * the app's own.
+ */
+function scalarArgs(text) {
+  const at = text.search(/"files"\s*:/);
+  const head = at > 0 ? text.slice(0, at) : text;
+  const out = {};
+  for (const key of ['folder', 'name', 'description', 'template', 'design']) {
+    const hit = new RegExp(`"${key}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`).exec(head);
+    if (hit) out[key] = hit[1].replace(/\\(["\\/])/g, '$1');
+  }
+  return out;
+}
+
 export function salvageWrites(text) {
   const heads = [...text.matchAll(/"path"\s*:\s*"((?:[^"\\]|\\.)*)"\s*,\s*"content"\s*:\s*"/g)];
   if (!heads.length) return null;
@@ -837,9 +867,17 @@ export function readCall({ id, name, raw, cutOff = false }) {
         }
       } catch { /* beyond general repair — try the file-write shape next */ }
 
-      const salvaged = (name === 'write_file' || name === 'batch_write') ? salvageWrites(text) : null;
+      const salvaged = SALVAGEABLE.has(name) ? salvageWrites(text) : null;
       if (salvaged) {
-        call.args = name === 'write_file' ? salvaged[0] : { files: salvaged };
+        if (name === 'write_file') call.args = salvaged[0];
+        // create_app carries the app in the same { path, content } shape, with
+        // a few plain strings beside it. Losing the entire call because one of
+        // several hundred lines of HTML held a raw newline is how a build ends
+        // with no files at all — which is what it did: refused three times,
+        // the folder never created, the turn over in sixty-six seconds having
+        // produced nothing. The scalars are read back off the same text.
+        else if (name === 'create_app') call.args = { ...scalarArgs(text), files: salvaged };
+        else call.args = { files: salvaged };
         call.repaired = true;
         return call;
       }

package/src/tools/browser.js

@@ -179,6 +179,98 @@ 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 — the button that
+  // submits, before any other. Taking simply the first button in the document
+  // finds the theme toggle in the header, clicks it, and reports a working app
+  // as dead because switching to dark mode adds no elements.
+  const candidates = [
+    page.locator('form button[type="submit"], form input[type="submit"], button[type="submit"], input[type="submit"]'),
+    page.locator('form button:not([disabled])'),
+    page.locator('button:not([disabled]), [role="button"]'),
+  ];
+
+  const pressed = new Set();
+  for (const group of candidates) {
+    const count = Math.min(await group.count().catch(() => 0), 3);
+    for (let i = 0; i < count; i++) {
+      const button = group.nth(i);
+      const label = (await button.innerText().catch(() => '') || '').trim().replace(/\s+/g, ' ').slice(0, 24);
+      if (pressed.has(label || `#${i}`)) continue;
+      pressed.add(label || `#${i}`);
+
+      const ok = await button.click({ timeout: 2_000 }).then(() => true).catch(() => false);
+      if (!ok) continue;
+      await page.waitForTimeout(300);
+      tried.push(`clicked ${label ? `"${label}"` : 'a button'}`);
+
+      after = await snapshot().catch(() => after);
+      if (moved(before, after)) return { tried, worked: true };
+    }
+  }
+
+  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 +309,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 +339,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 +369,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/scaffold.js

@@ -131,6 +131,48 @@ const TOKEN_FILE = { 'plain-html': 'styles.css' };
  * 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;
@@ -318,7 +360,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   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 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
   // back — and only the ones this call did not already write over. A read is
@@ -335,6 +378,13 @@ export async function createApp({ folder, name, description, template = 'plain-h
     `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. ' +