ucode-agent 1.34.0 → 1.35.0

package/package.json

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

@@ -238,15 +238,32 @@ async function useTheApp(page) {
   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) {
+  // 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}"` : 'the first button'}`);
+      tried.push(`clicked ${label ? `"${label}"` : 'a button'}`);
+
       after = await snapshot().catch(() => after);
+      if (moved(before, after)) return { tried, worked: true };
     }
   }
 

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. ' +