ucode-agent 1.38.0 → 1.40.0

package/package.json

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

@@ -103,6 +103,9 @@ const SILENT = new Set(['update_plan']);
 const MAX_FIX_ROUNDS = 3;
 
 /** Files worth checking after they change. */
+/** A file with a page in it — something a browser can be pointed at. */
+const PAGE = /\.(?:html?|tsx|jsx)$/i;
+
 const CHECKABLE = /\.(?:[cm]?[jt]sx?|py|html?)$/i;
 
 /** Where TypeScript keeps what it learned, so the next check is a quick one. */
@@ -1082,6 +1085,8 @@ export class Agent {
     // /undo can put the whole turn back.
     beginTurn();
     this.lookedThisTurn = false;
+    this.reads = new Map();
+    this.declines = 0;
     forgetReviews(); // a new request: its apps get a fresh design review
     const images = await this.attachImages(input);
     this.push(images.length
@@ -1641,7 +1646,14 @@ export class Agent {
     // changed so far; the automatic check at the end would only repeat it.
     if (call.name === 'run_command' && out.exitCode === 0 &&
         /(?:next build|npm run build|pnpm (?:run )?build|tsc)/.test(call.args?.command ?? '')) {
+      // The pages stay. A build proves the project compiles, which is not the
+      // same claim as the page working — and clearing everything here meant a
+      // Next.js app, where a passing `npm run build` is part of every turn,
+      // never reached the look at all. That is the one check that opens the
+      // thing and presses its buttons, skipped on the whole framework.
+      const pages = [...(this.sinceCheck ?? [])].filter((f) => PAGE.test(f));
       this.sinceCheck?.clear();
+      for (const p of pages) this.sinceCheck?.add(p);
     }
     if (!QUIET.has(call.name)) this.ui.toolResult(out.summary);
     // The change as its two numbers, not as a copy of the file. The diff rows
@@ -1670,11 +1682,32 @@ export class Agent {
     // user made, and anything that actually failed, still shows.
     if (err instanceof Declined) this.ui.toolFailed('declined');
     else if (err.kind !== 'bad_args') this.ui.toolFailed(`${err.kind}: ${err.failed}`);
+
+    // Declines that keep coming are not decisions, they are a wall.
+    //
+    // A traced build ran 250 steps and 32 minutes before dying on the step
+    // limit because every command it tried was declined — a piped session
+    // cannot answer "go ahead? [y/N]", so the answer is always no. The model
+    // read each refusal as being about that command, picked a different one,
+    // and was refused again. Nothing ever told it the refusals were the room
+    // rather than the request.
+    //
+    // Two are a person saying no to two things. The third is the wall, and it
+    // is worth naming, because the way out is to finish without commands
+    // rather than to keep hunting for one that is allowed.
+    this.declines = err instanceof Declined ? (this.declines ?? 0) + 1 : 0;
     this.push({
       role: 'tool',
       toolCallId: call.id,
       name: call.name,
-      content: err.forModel() + (err instanceof Declined ? '' : this.stuckNote(call, { err })),
+      content: err.forModel()
+        + (err instanceof Declined ? '' : this.stuckNote(call, { err }))
+        + (this.declines >= 3
+          ? '\n\nThat is the third command declined in a row. They are not being refused one by one — '
+            + 'nothing can be run in this session at all, and the next one will be declined too. '
+            + 'Stop trying to run things: finish the work with the files you have, and say plainly '
+            + 'in your reply which steps someone will need to run themselves.'
+          : ''),
     });
     return err.kind === 'bad_args';
   }
@@ -1705,6 +1738,34 @@ export class Agent {
       });
     }
 
+    // Reading the same unchanged file over and over.
+    //
+    // A traced build of a one-page app spent 53 of its 80 tool calls on
+    // read_file, most of them the same handful of files again and again — six
+    // seconds and a few thousand tokens each, for text that was already in the
+    // conversation. The prompt has asked it not to since 1.27; asking is not
+    // working, so the third read of a file nothing has written to since says
+    // so instead of sending the file a third time.
+    //
+    // Two reads are left alone: the first is the work, and the second is
+    // usually a fair re-check after an edit. Only the third is a loop. And it
+    // is keyed on the file being untouched since — the moment anything writes
+    // to it, the count starts again and a real re-read goes through.
+    if (call.name === 'read_file' && call.args?.path) {
+      const key = String(call.args.path);
+      const seen = (this.reads ??= new Map()).get(key) ?? 0;
+      if (seen >= 2 && !this.sinceCheck?.has(key)) {
+        this.reads.set(key, seen + 1);
+        return {
+          content: `You have already read ${key} ${seen} times this turn and nothing has written to it since, ` +
+          'so its contents are unchanged and already above. Use what is there. If you need a part ' +
+          'you have lost, say which and read the files you still need together in one read_files.',
+          summary: 'unchanged since you last read it',
+        };
+      }
+      this.reads.set(key, seen + 1);
+    }
+
     if (call.name === 'load_skill') return this.loadSkill(call.args?.name);
     if (call.name === 'update_plan') return this.updatePlan(call.args?.items);
     if (call.name === 'delegate') return this.delegate(call.args?.tasks);
@@ -2008,10 +2069,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;
   }
@@ -2031,7 +2097,7 @@ export class Agent {
   async lookOnceThisTurn(root, changed) {
     if (this.lookedThisTurn) return null;
 
-    const pages = [...changed].filter((f) => /\.(?:html?|tsx|jsx)$/i.test(f));
+    const pages = [...changed].filter((f) => PAGE.test(f));
     if (!pages.length) return null;
     this.lookedThisTurn = true;
 
@@ -2051,7 +2117,12 @@ export class Agent {
       const html = pages.find((f) => /\.html?$/i.test(f));
       if (!html) return null;
       return await withStaticServer(path.dirname(path.resolve(root, html)), look);
-    } catch {
+    } catch (err) {
+      // Say so, quietly, rather than skipping in silence. A browser that will
+      // not start is a reason to carry on without the look — but a check that
+      // stops running and never mentions it is worse than one that was never
+      // written, because everything downstream still believes it ran.
+      this.ui.note(`could not open the app to check it: ${String(err?.failed ?? err?.message ?? err).split('\n')[0]}`);
       return 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];