ucode-agent 1.37.0 → 1.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.37.0",
+  "version": "1.39.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 = [];
@@ -1996,10 +2008,15 @@ export class Agent {
     // nothing on exactly the builds that needed it, and this is the only one
     // that opens the page, presses its buttons and finds out whether any of it
     // actually works.
-    if (!problems.length) {
-      const seen = await this.lookOnceThisTurn(root, changed);
-      if (seen) problems.push(seen);
-    }
+    // Whatever else is wrong. It used to wait until everything else was clean,
+    // which meant the one check that opens the page and presses its buttons
+    // was skipped on exactly the builds going badly — and a type error and a
+    // dead button are two separate things to fix, so finding them in one pass
+    // costs a round trip less than finding them in two. The visual review
+    // inside the look still stands itself down on a page that is broken;
+    // reviewing the typography of an error overlay helps nobody.
+    const seen = await this.lookOnceThisTurn(root, changed);
+    if (seen) problems.push(seen);
 
     return problems.length ? problems.join('\n\n') : null;
   }

package/src/core/provider.js

@@ -795,6 +795,69 @@ function scalarArgs(text) {
   return out;
 }
 
+/**
+ * Rebuild the edits out of a broken edit_file or edit_files call.
+ *
+ * The same problem as a broken write, one level down: an edit carries two
+ * slabs of somebody's source as escaped JSON strings, and one stray character
+ * loses the call. edit_files failed this way three times in a row in a traced
+ * build, at the end of a turn, which is a turn that ends having undone nothing
+ * and fixed nothing.
+ *
+ * Safer than it sounds. Every edit is applied by replaceOnce, which requires
+ * old_string to appear exactly once and refuses otherwise — so an edit
+ * recovered wrongly does not corrupt a file, it fails to match and says so.
+ * The risk of guessing is a clear error; the cost of not guessing is the whole
+ * call. Truncated replies are still refused upstream, where half a string
+ * would mean half a file.
+ *
+ * Each edit is attributed to the nearest "path" before it, which is how
+ * edit_files nests them; edit_file has exactly one of each.
+ */
+export function salvageEdits(text) {
+  const heads = [...text.matchAll(/"old_string"\s*:\s*"/g)];
+  if (!heads.length) return null;
+
+  const paths = [...text.matchAll(/"path"\s*:\s*"((?:[^"\\]|\\.)*)"/g)];
+  const NEW = '"new_string"';
+  const out = [];
+
+  for (let i = 0; i < heads.length; i++) {
+    const oldFrom = heads[i].index + heads[i][0].length;
+    const newKey = text.indexOf(NEW, oldFrom);
+    if (newKey < 0) return null;
+
+    const opens = /^\s*:\s*"/.exec(text.slice(newKey + NEW.length));
+    if (!opens) return null;
+    const newFrom = newKey + NEW.length + opens[0].length;
+
+    // The value runs until whatever structure comes next — the following edit,
+    // or the following file — and the trailing JSON punctuation comes off.
+    const nextEdit = i + 1 < heads.length ? heads[i + 1].index : text.length;
+    const nextPath = paths.find((m) => m.index > newFrom)?.index ?? text.length;
+    const strip = (v) => v.replace(/"[\s,{}[\]]*$/, '');
+
+    const old_string = unescapeLoose(strip(text.slice(oldFrom, newKey)));
+    const new_string = unescapeLoose(strip(text.slice(newFrom, Math.min(nextEdit, nextPath))));
+    const owner = paths.filter((m) => m.index < heads[i].index).pop();
+
+    if (!owner || !old_string) return null;
+    out.push({ path: unescapeLoose(owner[1]), old_string, new_string });
+  }
+
+  return out.length ? out : null;
+}
+
+/** The same edits, grouped under their file, which is edit_files' own shape. */
+export function groupEdits(edits) {
+  const byPath = new Map();
+  for (const { path, old_string, new_string } of edits) {
+    if (!byPath.has(path)) byPath.set(path, []);
+    byPath.get(path).push({ old_string, new_string });
+  }
+  return [...byPath].map(([path, list]) => ({ path, edits: list }));
+}
+
 export function salvageWrites(text) {
   const heads = [...text.matchAll(/"path"\s*:\s*"((?:[^"\\]|\\.)*)"\s*,\s*"content"\s*:\s*"/g)];
   if (!heads.length) return null;
@@ -867,6 +930,18 @@ export function readCall({ id, name, raw, cutOff = false }) {
         }
       } catch { /* beyond general repair — try the file-write shape next */ }
 
+      if (name === 'edit_file' || name === 'edit_files' || name === 'multi_edit') {
+        const edits = salvageEdits(text);
+        if (edits) {
+          if (name === 'edit_file') call.args = edits[0];
+          else if (name === 'multi_edit') {
+            call.args = { path: edits[0].path, edits: edits.map(({ old_string, new_string }) => ({ old_string, new_string })) };
+          } else call.args = { files: groupEdits(edits) };
+          call.repaired = true;
+          return call;
+        }
+      }
+
       const salvaged = SALVAGEABLE.has(name) ? salvageWrites(text) : null;
       if (salvaged) {
         if (name === 'write_file') call.args = salvaged[0];

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