ucode-agent 1.54.0 → 1.57.0

package/src/core/skills.js

@@ -172,7 +172,7 @@ export function autoLoadFor(skills, text) {
 export function skillMessage(skill, { automatic = false, short = false } = {}) {
   const digest = short && skill.digest ? skill.digest : null;
   const why = automatic
-    ? `The "${skill.name}" skill was loaded automatically because this request is the kind it covers.`
+    ? `The "${skill.name}" skill was loaded automatically because the request that follows is the kind it covers.`
     : `The "${skill.name}" skill was loaded for this task.`;
   return {
     role: 'system',

package/src/core/window.js

@@ -87,10 +87,12 @@ function cutPoint(messages, budget) {
  * @param {Array} messages
  * @param {object} o
  * @param {number} o.limit          token budget
- * @param {Function} o.summarize    async (older) => string
+ * @param {Function} o.summarize    async (older, previousSummary) => string
+ * @param {boolean}  [o.force]      fold even below the threshold — the provider
+ *                                  has already said the request is too big
  */
-export async function fold(messages, { limit, summarize }) {
-  if (!tooBig(messages, limit)) return { messages, folded: false };
+export async function fold(messages, { limit, summarize, force = false }) {
+  if (!force && !tooBig(messages, limit)) return { messages, folded: false };
 
   // Half the size that triggered the fold, so there is room to work before
   // the next one. Sized off the same absolute rule, or a fold on a
@@ -103,7 +105,10 @@ export async function fold(messages, { limit, summarize }) {
   // Nothing old enough to fold — the tail on its own is already oversized.
   if (older.length === 0) return { messages, folded: false };
 
-  const summary = await summarize(older);
+  // A second fold must not summarize the first summary as if it were chat:
+  // it is handed over as the prior summary, to be merged rather than retold.
+  const previous = older.find((m) => m.folded)?.summary ?? null;
+  const summary = await summarize(older.filter((m) => !m.folded), previous);
 
   return {
     folded: true,
@@ -117,19 +122,87 @@ export async function fold(messages, { limit, summarize }) {
           `were folded away to stay inside the context window.\n\n${summary}\n\n` +
           'Treat all of that as settled context. Everything after this point is verbatim.',
         folded: true,
+        summary,
       },
       ...recent,
     ],
   };
 }
 
-/** What the summarizer is asked to do. */
-export const SUMMARY_PROMPT =
-  'Summarize this conversation so another engineer could pick it up mid-task with ' +
-  'nothing else to go on. Keep, in this order: (1) what the user is trying to achieve, ' +
-  '(2) which files were read or changed and what is in them, (3) decisions taken and the ' +
-  'reasoning, (4) commands run and what they printed, (5) what is still unfinished. ' +
-  'Name exact paths, functions and error messages. No preamble, no commentary.';
+/**
+ * What the summarizer is asked to do: opencode's anchored summary (MIT, see
+ * THIRD_PARTY_NOTICES.md). Fixed sections mean nothing gets dropped because
+ * the summarizer found it dull — the next step and the files that matter
+ * always have a place — and a second fold merges into the first instead of
+ * summarizing a summary.
+ */
+export const SUMMARY_PROMPT = `You summarize a coding session so another coding agent can continue the work with nothing else to go on.
+
+Output exactly the Markdown structure shown inside <template> and keep the section order unchanged. Do not include the <template> tags in your response.
+<template>
+## Objective
+- [one or two brief sentences describing what the user is trying to accomplish]
+
+## Important Details
+- [constraints/preferences, decisions and why, important facts/assumptions, exact context needed to continue, or "(none)"]
+
+## Work State
+### Completed
+- [finished work, verified facts, or changes made; otherwise "(none)"]
+
+### Active
+- [current work, partial changes, or investigation state; otherwise "(none)"]
+
+### Blocked
+- [blockers, failing commands, or unknowns; otherwise "(none)"]
+
+## Next Move
+1. [immediate concrete action, or "(none)"]
+2. [next action if known, or "(none)"]
+
+## Relevant Files
+- [file or directory path: why it matters, or "(none)"]
+</template>
+
+Rules:
+- Keep every section, even when empty.
+- Use terse bullets, not prose paragraphs.
+- Preserve exact file paths, symbols, commands, error strings, URLs, and identifiers when known.
+- Do not mention the summary process or that context was compacted.`;
+
+const MERGE = `The <prior-summary> summarizes everything that happened before the <conversation>. Construct a new summary that combines both. The <prior-summary> is discarded after this: anything you do not carry into the new summary is lost.
+
+When combining:
+- Carry forward objectives, constraints, user directives, decisions, and parallel workstreams from the <prior-summary> even when the <conversation> does not mention them. Drop only what is finished and no longer needed.
+- The <conversation> is more recent than the <prior-summary>. Where they conflict, the conversation wins: state the corrected fact and drop the old claim.
+- Add new progress, decisions, constraints, and context from the conversation.
+- Move completed work from "Active" to "Completed".
+- If a blocker has been resolved, update the summary to reflect that while keeping any details still needed to continue the work.
+- Update "Objective" and "Next Move" to reflect the current work state.`;
+
+/** The summarizer's user message: the conversation, and the summary it extends if there is one. */
+export function summaryRequest(conversation, previous = null) {
+  // File contents are in there too. One carrying "</conversation>" must not
+  // close the section early and speak to the summarizer as if it were us.
+  const fence = (s) => String(s).replace(/<\/?(?:conversation|prior-summary)>/gi, '');
+  conversation = fence(conversation);
+  if (previous) previous = fence(previous);
+  const parts = [`Here is the conversation so far:
+
+<conversation>
+${conversation}
+</conversation>`];
+  if (previous) {
+    parts.push(`Here is the summary of the conversation before the <conversation> above:
+
+<prior-summary>
+${previous}
+</prior-summary>`, MERGE);
+  } else {
+    parts.push('Create a new anchored summary from the conversation history in the <conversation> tags above so another coding agent can continue the work.');
+  }
+  return parts.join('\n\n');
+}
 
 /**
  * Flatten the messages being folded into plain text for the summarizer.

package/src/tools/files.js

@@ -7,18 +7,39 @@
  * coding agent can do, because everything after it is built on a lie.
  */
 
-import { promises as fs } from 'node:fs';
+import { promises as fs, existsSync } from 'node:fs';
 import { remember } from '../core/undo.js';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
 import {
   resolveIn, guard, result, fsFailure, looksBinary, toLines, bytes,
   changedRegion, renderDiff, renderNewFile, READ_LINES, MAX_FILE_OUTPUT,
-  noteFile, writeTracked, assertUnchanged,
+  noteFile, writeTracked, assertUnchanged, getRoot,
 } from './shared.js';
 import { packageJsonWritten } from './shell.js';
+import { fuzzyReplace } from './fuzzy.js';
 import { parse as parseSource } from '@babel/parser';
 
+/**
+ * Up to three names beside a missing file that look like what was meant —
+ * "App.jsx" for "app.jsx", "index.html" for "index.htm". Named in the refusal
+ * (as opencode's read tool does), the next step is the right read instead of
+ * a list_dir to find out.
+ */
+async function lookalikes(target) {
+  const dir = path.dirname(target.abs);
+  const base = path.basename(target.abs).toLowerCase();
+  const shown = path.dirname(target.show);
+  try {
+    return (await fs.readdir(dir))
+      .filter((n) => n.toLowerCase().includes(base) || (n.length > 2 && base.includes(n.toLowerCase())))
+      .slice(0, 3)
+      .map((n) => (shown === '.' ? n : `${shown}/${n}`));
+  } catch {
+    return [];
+  }
+}
+
 export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   const target = resolveIn(p, 'read_file');
   await guard(target, `read ${target.abs}`);
@@ -28,7 +49,12 @@ export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   try {
     stat = await fs.stat(target.abs);
   } catch (err) {
-    throw fsFailure(err, attempted, target.show);
+    const failure = fsFailure(err, attempted, target.show);
+    // Outside the project the user said yes to one path, not to a listing of
+    // the folder around it — so no lookalikes there.
+    const near = err?.code === 'ENOENT' && target.inside ? await lookalikes(target) : [];
+    if (near.length) failure.fix = `Did you mean ${near.join(', ')}? ${failure.fix}`;
+    throw failure;
   }
 
   if (stat.isDirectory()) {
@@ -170,6 +196,44 @@ const brokenNote = (show, problem) => {
     `a structure you have lost track of.`;
 };
 
+/**
+ * A module in a page with no build step that imports a stylesheet or an image.
+ *
+ * A bundler would take it; a browser refuses the whole module ("Failed to
+ * load module script ... MIME type text/css"), so none of the app's script
+ * runs and every button is dead. The syntax is fine, so nothing else notices
+ * until the page is opened — a live build shipped exactly this as done.
+ */
+const ASSET_IMPORT = /^[ \t]*import\s+(?:[\w$*{}\s,]+?\s+from\s+)?['"]([^'"]+\.(?:css|scss|sass|less|svg|png|jpe?g|gif|webp))['"](?!\s*(?:with|assert)\s*\{)/m;
+
+export function assetImport(abs, text) {
+  if (!/\.m?js$/i.test(abs)) return null;
+  // An import quoted inside a block comment is not an import.
+  const hit = ASSET_IMPORT.exec(String(text).replace(/\/\*[\s\S]*?\*\//g, ''));
+  if (!hit) return null;
+  // Anything with a package.json above it, up to the project root, may well be
+  // bundled. path.relative, not a string prefix: "ucode2" starts with "ucode",
+  // and Windows paths differ in case from one shell to the next.
+  const top = getRoot();
+  const within = (dir) => {
+    const rel = path.relative(top, dir);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+  };
+  for (let dir = path.dirname(abs); ; dir = path.dirname(dir)) {
+    if (existsSync(path.join(dir, 'package.json'))) return null;
+    if (!within(dir) || path.relative(top, dir) === '' || path.dirname(dir) === dir) break;
+  }
+  return `imports ${hit[1]}, which a page with no build step cannot do: the browser refuses the ` +
+    'whole module, so none of its script runs. Remove that import and load it from the page ' +
+    'instead — <link rel="stylesheet" href="…"> for a stylesheet, an <img> or a plain URL for an image.';
+}
+
+/** The note for that, appended to a write's result like a parse problem is. */
+const pageNote = (target, text) => {
+  const problem = assetImport(target.abs, text);
+  return problem ? `\n\n⚠ ${target.show} ${problem}` : '';
+};
+
 /** A file this short comes back whole after an edit; longer ones show the part around the change. */
 const SHOW_WHOLE = 250;
 const AROUND = 15;
@@ -323,6 +387,7 @@ async function put(target, content, { diffMax = 16 } = {}) {
     lineCount,
     diff,
     problem: syntaxProblem(target.abs, content),
+    note: pageNote(target, content),
     line: `${existed ? 'Overwrote' : 'Created'} ${target.show} ` +
       `(${lineCount} lines, ${bytes(Buffer.byteLength(content))})`,
   };
@@ -342,7 +407,7 @@ export async function writeFile({ path: p, content }) {
 
   const written = await put(target, content);
   const out = result(
-    `${written.line}.${parseNote(target.show, written.problem)}`,
+    `${written.line}.${parseNote(target.show, written.problem)}${written.note}`,
     `${written.existed ? 'overwrote' : 'created'} · ${written.lineCount} lines${written.problem ? ' · does not parse' : ''}`
   );
   out.diff = written.diff;
@@ -388,7 +453,7 @@ export async function batchWrite({ files }) {
     // would bury the reply under three hundred lines of gutter.
     const written = await put(target, content, { diffMax: 6 });
     if (!written.existed) created++;
-    lines.push(written.line + parseNote(target.show, written.problem));
+    lines.push(written.line + parseNote(target.show, written.problem) + written.note);
     if (written.problem) broken++;
     diff.push(`~${target.show}`, ...written.diff);
   }
@@ -444,7 +509,7 @@ function explainMiss(original, oldString, show) {
 }
 
 /** Apply one replacement to a string, or explain precisely why it cannot. */
-function replaceOnce(text, { old_string, new_string }, { show, attempted, label = '' }) {
+function replaceOnce(text, { old_string, new_string, replace_all }, { show, attempted, label = '' }) {
   const prefix = label ? `${label}: ` : '';
 
   if (typeof old_string !== 'string' || typeof new_string !== 'string') {
@@ -467,7 +532,7 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
   // for exactly this loop. Saying "already done" ends it in one step.
   if (old_string === new_string) {
     const found = text.indexOf(old_string);
-    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, loose: false };
+    return { text, at: found < 0 ? 1 : toLines(text.slice(0, found)).length, how: '', count: 0 };
   }
 
   // Models write \n. A file checked out on Windows is often \r\n, and then an
@@ -486,21 +551,45 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
     detail: { hits },
   });
 
+  // replace_all is for renames: every copy changes, and many copies is the point.
+  const all = replace_all === true || replace_all === 'true';
   const hits = text.split(oldText).length - 1;
-  if (hits > 1) throw ambiguous(hits);
-  if (hits === 1) {
+  if (hits > 1 && !all) throw ambiguous(hits);
+  if (hits >= 1) {
     const at = text.slice(0, text.indexOf(oldText)).split(/\r?\n/).length;
-    return { text: text.replace(oldText, () => newText), at, loose: false };
+    const out = all ? text.split(oldText).join(newText) : text.replace(oldText, () => newText);
+    return { text: out, at, how: '', count: hits };
   }
 
   // No exact match. The commonest reason by far is whitespace — tabs against
   // spaces, a different indent depth, trailing spaces — with every word right.
   // Match line by line ignoring that, and re-indent the replacement to fit.
   // Still unique or nothing: a loose match found twice is refused like any other.
-  const loose = looseReplace(text, old_string, new_string);
-  if (loose?.count === 1) return { text: loose.text, at: loose.at, loose: true };
+  const loose = all ? null : looseReplace(text, old_string, new_string);
+  if (loose?.count === 1) {
+    return { text: loose.text, at: loose.at, how: 'ignoring whitespace and re-indented to fit', count: 1 };
+  }
   if (loose?.count > 1) throw ambiguous(loose.count, ' once whitespace is ignored');
 
+  // Still nothing. The remaining slips — a middle line remembered slightly
+  // wrong, escapes written out, a blank line at either end — each have a
+  // matcher of their own (fuzzy.js). They are given the edit in the file's
+  // own line endings, and only the matched span changes: the rest of a file
+  // with mixed endings keeps every one it had.
+  const fuzzy = fuzzyReplace(text, oldText, newText, { all });
+  if (fuzzy?.ambiguous) throw ambiguous('several', ' once matched loosely');
+  if (fuzzy?.wide) {
+    throw new ToolFailure({
+      kind: 'no_match', attempted,
+      failed: `${prefix}old_string only matches ${show} loosely, across far more text than it contains. Refusing to replace that much.`,
+      fix: `Read ${show} again and copy the exact text you mean to replace.`,
+    });
+  }
+  if (fuzzy) {
+    const at = text.slice(0, fuzzy.index).split('\n').length;
+    return { text: fuzzy.text, at, how: fuzzy.how, count: fuzzy.count };
+  }
+
   const { failed, fix } = explainMiss(text, old_string, show);
   throw new ToolFailure({ kind: 'no_match', attempted, failed: prefix + failed, fix });
 }
@@ -548,7 +637,7 @@ function looseReplace(text, oldString, newString) {
   return { count: 1, text: out.join(eol), at: start + 1 };
 }
 
-export async function editFile({ path: p, old_string, new_string }) {
+export async function editFile({ path: p, old_string, new_string, replace_all }) {
   const target = resolveIn(p, 'edit_file');
   const attempted = `editing ${target.show}`;
   await guard(target, `edit ${target.abs}`);
@@ -560,7 +649,7 @@ export async function editFile({ path: p, old_string, new_string }) {
     throw fsFailure(err, attempted, target.show);
   }
 
-  const { text, at, loose } = replaceOnce(original, { old_string, new_string }, {
+  const { text, at, how, count } = replaceOnce(original, { old_string, new_string, replace_all }, {
     show: target.show, attempted,
   });
 
@@ -574,14 +663,18 @@ export async function editFile({ path: p, old_string, new_string }) {
 
   const delta = toLines(text).length - toLines(original).length;
   const change = delta === 0 ? 'same line count' : `${delta > 0 ? '+' : ''}${delta} lines`;
-  const how = loose ? ', matched ignoring whitespace and re-indented to fit' : '';
+  const where = count > 1
+    ? `${count} occurrences in ${target.show}, the first at line ${at}`
+    : `one occurrence in ${target.show} at line ${at}`;
+  const matched = how ? `, matched ${how}` : '';
 
   const span = toLines(new_string).length;
   const out = result(
-    `Replaced one occurrence in ${target.show} at line ${at} (${change}${how}).` +
-      parseNote(target.show, syntaxProblem(target.abs, text)) +
+    `Replaced ${where} (${change}${matched}).` +
+      parseNote(target.show, syntaxProblem(target.abs, text)) + pageNote(target, text) +
       nowReads(target.show, text, at, span),
-    `1 change at line ${at} · ${change}${loose ? ' · whitespace-tolerant' : ''}${syntaxProblem(target.abs, text) ? ' · does not parse' : ''}`,
+    `${count > 1 ? `${count} changes from line` : '1 change at line'} ${at} · ${change}` +
+      `${how ? ' · whitespace-tolerant' : ''}${syntaxProblem(target.abs, text) ? ' · does not parse' : ''}`,
     MAX_FILE_OUTPUT
   );
   // The replacement is diffed on its own and offset to where it landed, so
@@ -651,7 +744,7 @@ export async function multiEdit({ path: p, edits }) {
 
   const out = result(
     `Applied ${edits.length} edits to ${target.show} (${change}).` +
-      parseNote(target.show, syntaxProblem(target.abs, text)) +
+      parseNote(target.show, syntaxProblem(target.abs, text)) + pageNote(target, text) +
       nowReads(target.show, text, 1, toLines(text).length),
     `${edits.length} edits · ${change}`,
     MAX_FILE_OUTPUT
@@ -741,7 +834,7 @@ export async function editFiles({ files }) {
     planned.map((p) => {
       const problem = syntaxProblem(p.target.abs, p.text);
       return `Edited ${p.target.show} (${p.count} change${p.count === 1 ? '' : 's'})` +
-        parseNote(p.target.show, problem);
+        parseNote(p.target.show, problem) + pageNote(p.target, p.text);
     }).join('\n'),
     `${planned.length} files · ${edits} edits`
   );