ucode-agent 1.1.0 → 1.3.0

package/src/core/provider.js

@@ -55,28 +55,28 @@ dotenv.config({ path: join(PACKAGE_ROOT, '.env'), quiet: true });
  */
 export const MODELS = {
   'nvidia/nemotron-3-ultra-550b-a55b:free': {
-    name: 'Nemotron 3 Ultra (free)',
+    name: 'Nemotron 3 Ultra',
     context: 1_000_000,
     star: true,
     note: 'deepest reasoning, 1M context — the default',
   },
   'nvidia/nemotron-3.5-lightning:free': {
-    name: 'Nemotron 3.5 Lightning (free)',
+    name: 'Nemotron 3.5 Lightning',
     context: 1_000_000,
     note: 'same huge window, answers much sooner',
   },
   'nvidia/nemotron-3-super-120b-a12b:free': {
-    name: 'Nemotron 3 Super (free)',
+    name: 'Nemotron 3 Super',
     context: 262_144,
     note: 'strong all-rounder, quick to first token',
   },
   'nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free': {
-    name: 'Nemotron 3 Nano Omni (free)',
+    name: 'Nemotron 3 Nano Omni',
     context: 256_000,
     note: 'small and fast, reasoning tuned',
   },
   'cohere/north-mini-code:free': {
-    name: 'North Mini Code (free)',
+    name: 'North Mini Code',
     context: 256_000,
     star: true,
     note: 'code and UI specialist — reach for it on frontend work',
@@ -121,7 +121,7 @@ export function setModel(id) {
   return current;
 }
 
-/** The short name for a model id: "Nemotron 3 Ultra (free)". */
+/** The short name for a model id: "Nemotron 3 Ultra". */
 export function modelName(id = current) {
   return MODELS[id]?.name ?? id;
 }
@@ -179,16 +179,18 @@ export function estimateConversation(messages) {
  * of first-run convenience is worth handing out a live credential.
  */
 function apiKey() {
-  const key = (process.env.OPENROUTER_API_KEY ?? '').trim();
+  // UCODE_API_KEY is the documented name. The provider's own variable name is
+  // still read, so a key set up for another tool keeps working here.
+  const key = (process.env.UCODE_API_KEY || process.env.OPENROUTER_API_KEY || '').trim();
   if (!key) {
     throw new Failure({
       kind: 'no_api_key',
-      attempted: 'connecting to OpenRouter',
-      failed: 'OPENROUTER_API_KEY is not set in the environment or in any .env file.',
+      attempted: 'connecting to the model',
+      failed: 'No API key is set - UCODE_API_KEY is missing from the environment and from every .env file.',
       fix:
-        `Put OPENROUTER_API_KEY=your-key in ${ENV_FILE} — that applies to every ` +
+        `Put UCODE_API_KEY=your-key in ${ENV_FILE} — that applies to every ` +
         'project on this machine — or in a .env file beside your code. ' +
-        'Keys are free at https://openrouter.ai/keys',
+        'Free keys: https://openrouter.ai/keys',
     });
   }
   return key;
@@ -349,10 +351,10 @@ export function explain(err, id) {
     return new Failure({
       kind: 'invalid_api_key',
       attempted,
-      failed: `OpenRouter rejected the API key (HTTP ${status ?? 401}).`,
+      failed: `The API key was rejected (HTTP ${status ?? 401}).`,
       fix:
-        'Check OPENROUTER_API_KEY for a typo or trailing space, and confirm the key ' +
-        'is still active at https://openrouter.ai/keys',
+        'Check UCODE_API_KEY in ~/.ucode/.env for a typo or trailing space, and ' +
+        'confirm the key is still active in your account.',
       cause: err,
     });
   }
@@ -380,8 +382,8 @@ export function explain(err, id) {
         ? `The free daily request cap for ${modelName(id)} is used up.`
         : `Too many requests for ${modelName(id)} just now${wait ? ` — clear in ${wait}` : ''}.`,
       fix: daily
-        ? 'Free caps reset each day. /model switches to another one, or add credit at ' +
-          'https://openrouter.ai/credits to lift the ceiling.'
+        ? 'Free caps reset each day. /model switches to another one, or add credit to ' +
+          'your account to lift the ceiling.'
         : 'ucode waits these out on its own. Free endpoints are shared, so it usually ' +
           'clears in seconds; /model moves to a quieter one.',
       detail: { retryAfter, daily },
@@ -406,7 +408,7 @@ export function explain(err, id) {
     return new Failure({
       kind: 'bad_model',
       attempted,
-      failed: `OpenRouter has no model "${id}" available to this key.`,
+      failed: `No model "${id}" is available to this key.`,
       fix: `Run /model. ucode ships with: ${Object.keys(MODELS).join(', ')}`,
       cause: err,
     });
@@ -435,7 +437,7 @@ export function explain(err, id) {
       attempted,
       failed: noTools
         ? `${modelName(id)} cannot call tools, which ucode needs for every task.`
-        : `OpenRouter rejected the request as malformed (HTTP 400): ${detail}`,
+        : `The request was rejected as malformed (HTTP 400): ${detail}`,
       fix: noTools
         ? 'Run /model and pick another one.'
         : 'Usually an oversized conversation. /new starts a fresh one.',
@@ -497,7 +499,7 @@ export function explain(err, id) {
     return new Failure({
       kind: 'network',
       attempted,
-      failed: `The connection to OpenRouter dropped: ${raw}`,
+      failed: `The connection to the model dropped: ${raw}`,
       fix:
         'ucode retries this by itself. If it keeps happening, check your connection, ' +
         'VPN and any corporate proxy (HTTPS_PROXY) — or /model to a lighter one, since ' +
@@ -628,6 +630,8 @@ async function streamed(request, opts, id) {
   let finishReason = 'stop';
   let usage = null;
   const partial = new Map();
+  const handed = new Set();
+  let highest = -1;
 
   for await (const chunk of stream) {
     if (opts.signal?.aborted) break;
@@ -654,6 +658,20 @@ async function streamed(request, opts, id) {
     // A tool call's name and arguments arrive across several chunks, keyed by
     // index, so they are stitched back together here.
     for (const call of delta.tool_calls ?? []) {
+      // Calls arrive one after another, so the first chunk of call N means
+      // every call before it is complete. Those are handed over at once, and
+      // the caller can start running them while the rest are still being
+      // written — the reply streaming and the tools working overlap.
+      if (opts.onToolCall && call.index > highest) {
+        for (const [index, slot] of partial) {
+          if (index < call.index && !handed.has(index)) {
+            handed.add(index);
+            opts.onToolCall(readCall({ id: slot.id || `call_${index}`, name: slot.name, raw: slot.args }));
+          }
+        }
+        highest = call.index;
+      }
+
       const slot = partial.get(call.index) ?? { id: '', name: '', args: '' };
       if (call.id) slot.id = call.id;
       if (call.function?.name) slot.name += call.function.name;
@@ -663,9 +681,8 @@ async function streamed(request, opts, id) {
   }
 
   const toolCalls = [];
-  let n = 0;
-  for (const slot of partial.values()) {
-    toolCalls.push(readCall({ id: slot.id || `call_${n++}`, name: slot.name, raw: slot.args }));
+  for (const [index, slot] of partial) {
+    toolCalls.push(readCall({ id: slot.id || `call_${index}`, name: slot.name, raw: slot.args }));
   }
 
   return {

package/src/core/version.js

@@ -0,0 +1,16 @@
+/**
+ * version.js — the version, read from package.json rather than typed twice.
+ *
+ * package.json always ships in an npm package, so this is right wherever ucode
+ * is installed, and it can never drift from what `npm publish` released.
+ */
+
+import { readFileSync } from 'node:fs';
+
+export const VERSION = (() => {
+  try {
+    return JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+  } catch {
+    return '';
+  }
+})();

package/src/tools/files.js

@@ -14,6 +14,7 @@ import {
   resolveIn, guard, result, fsFailure, looksBinary, toLines, bytes,
   changedRegion, renderDiff, renderNewFile, READ_LINES, MAX_FILE_OUTPUT,
 } from './shared.js';
+import { packageJsonWritten } from './shell.js';
 
 export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   const target = resolveIn(p, 'read_file');
@@ -84,6 +85,15 @@ export async function readFile({ path: p, offset = 1, limit = READ_LINES }) {
   );
 }
 
+/**
+ * Everything that writes a file ends here. A package.json with dependencies
+ * starts its install in the background at once, while the rest of the app is
+ * still being written.
+ */
+function written(target, content) {
+  if (path.basename(target.abs) === 'package.json') packageJsonWritten(target.abs, content);
+}
+
 /** At most this many files in one read_files call. */
 const MAX_BATCH = 20;
 
@@ -194,6 +204,7 @@ async function put(target, content, { diffMax = 16 } = {}) {
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
   }
+  written(target, content);
 
   const existed = previous !== null;
   const lineCount = content === '' ? 0 : toLines(content).length;
@@ -346,23 +357,82 @@ function replaceOnce(text, { old_string, new_string }, { show, attempted, label
     });
   }
 
-  const hits = text.split(old_string).length - 1;
+  // Models write \n. A file checked out on Windows is often \r\n, and then an
+  // otherwise perfect old_string can never match. Speak the file's dialect.
+  let oldText = old_string;
+  let newText = new_string;
+  if (text.includes('\r\n') && !oldText.includes('\r')) {
+    oldText = oldText.replace(/\r?\n/g, '\r\n');
+    newText = newText.replace(/\r?\n/g, '\r\n');
+  }
+
+  const ambiguous = (hits, how = '') => new ToolFailure({
+    kind: 'ambiguous', attempted,
+    failed: `${prefix}old_string appears ${hits} times in ${show}${how}. Refusing to guess which one you meant.`,
+    fix: 'Add surrounding lines to old_string until it matches exactly one place.',
+    detail: { hits },
+  });
 
-  if (hits === 0) {
-    const { failed, fix } = explainMiss(text, old_string, show);
-    throw new ToolFailure({ kind: 'no_match', attempted, failed: prefix + failed, fix });
+  const hits = text.split(oldText).length - 1;
+  if (hits > 1) 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 };
   }
-  if (hits > 1) {
-    throw new ToolFailure({
-      kind: 'ambiguous', attempted,
-      failed: `${prefix}old_string appears ${hits} times in ${show}. Refusing to guess which one you meant.`,
-      fix: 'Add surrounding lines to old_string until it matches exactly one place.',
-      detail: { 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 };
+  if (loose?.count > 1) throw ambiguous(loose.count, ' once whitespace is ignored');
+
+  const { failed, fix } = explainMiss(text, old_string, show);
+  throw new ToolFailure({ kind: 'no_match', attempted, failed: prefix + failed, fix });
+}
+
+/**
+ * Find old_string by its lines' content alone and swap in new_string, indented
+ * the way the file is indented at that spot. Returns { count } when it finds
+ * none or several, and { count: 1, text, at } when it finds exactly one.
+ */
+function looseReplace(text, oldString, newString) {
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  const lines = text.split(/\r?\n/);
+
+  const want = oldString.replace(/\r/g, '').split('\n');
+  while (want.length > 1 && !want[want.length - 1].trim()) want.pop();
+  while (want.length > 1 && !want[0].trim()) want.shift();
+  const target = want.map((l) => l.trim());
+  if (target.every((t) => !t)) return null;
+
+  const starts = [];
+  for (let i = 0; i + want.length <= lines.length; i++) {
+    let same = true;
+    for (let j = 0; j < want.length; j++) {
+      if (lines[i + j].trim() !== target[j]) { same = false; break; }
+    }
+    if (same) starts.push(i);
   }
+  if (starts.length !== 1) return { count: starts.length };
+
+  const start = starts[0];
+  const indent = (l) => /^[ \t]*/.exec(l)[0];
+  const first = want.findIndex((l) => l.trim());
+  const fileIndent = indent(lines[start + first]);
+  const wroteIndent = indent(want[first]);
+
+  const replacement = newString.replace(/\r/g, '').split('\n');
+  if (replacement.length > 1 && replacement[replacement.length - 1] === '') replacement.pop();
+  const reindented = replacement.map((l) => {
+    if (!l.trim()) return l.trim();
+    const body = l.startsWith(wroteIndent) ? l.slice(wroteIndent.length) : l.replace(/^[ \t]*/, '');
+    return fileIndent + body;
+  });
 
-  const at = text.slice(0, text.indexOf(old_string)).split(/\r?\n/).length;
-  return { text: text.replace(old_string, () => new_string), at };
+  const out = [...lines.slice(0, start), ...reindented, ...lines.slice(start + want.length)];
+  return { count: 1, text: out.join(eol), at: start + 1 };
 }
 
 export async function editFile({ path: p, old_string, new_string }) {
@@ -377,7 +447,7 @@ export async function editFile({ path: p, old_string, new_string }) {
     throw fsFailure(err, attempted, target.show);
   }
 
-  const { text, at } = replaceOnce(original, { old_string, new_string }, {
+  const { text, at, loose } = replaceOnce(original, { old_string, new_string }, {
     show: target.show, attempted,
   });
 
@@ -386,13 +456,15 @@ export async function editFile({ path: p, old_string, new_string }) {
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
   }
+  written(target, text);
 
   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 out = result(
-    `Replaced one occurrence in ${target.show} at line ${at} (${change}).`,
-    `1 change at line ${at} · ${change}`
+    `Replaced one occurrence in ${target.show} at line ${at} (${change}${how}).`,
+    `1 change at line ${at} · ${change}${loose ? ' · whitespace-tolerant' : ''}`
   );
   // The replacement is diffed on its own and offset to where it landed, so
   // the gutter shows the file's line numbers rather than 1, 2, 3.
@@ -453,6 +525,7 @@ export async function multiEdit({ path: p, edits }) {
   } catch (err) {
     throw fsFailure(err, attempted, target.show);
   }
+  written(target, text);
 
   const delta = toLines(text).length - toLines(original).length;
   const change = delta === 0 ? 'same line count' : `${delta > 0 ? '+' : ''}${delta} lines`;
@@ -464,3 +537,87 @@ export async function multiEdit({ path: p, edits }) {
   out.diff = diff;
   return out;
 }
+
+/**
+ * Exact replacements across several files in one call.
+ *
+ * A change that touches the route, the component and the type together is one
+ * round trip instead of three. Every edit in every file is applied to a copy
+ * in memory first; if any of them fails, nothing is written anywhere — a
+ * cross-file change that half landed leaves the project in a state that
+ * compiles nowhere.
+ */
+export async function editFiles({ files }) {
+  if (!Array.isArray(files) || files.length === 0) {
+    throw new ToolFailure({
+      kind: 'bad_args',
+      attempted: 'editing several files',
+      failed: 'The "files" argument must be a non-empty array.',
+      fix: 'Pass files as [{ path, edits: [{ old_string, new_string }, ...] }, ...].',
+    });
+  }
+
+  const planned = [];
+  const seen = new Set();
+
+  for (const [i, entry] of files.entries()) {
+    const target = resolveIn(entry?.path, 'edit_files');
+    const attempted = `editing ${target.show}`;
+
+    if (seen.has(target.abs)) {
+      throw new ToolFailure({
+        kind: 'bad_args', attempted,
+        failed: `${target.show} is listed twice.`,
+        fix: 'List each file once, with all of its edits together. Nothing was written.',
+      });
+    }
+    seen.add(target.abs);
+
+    if (!Array.isArray(entry.edits) || entry.edits.length === 0) {
+      throw new ToolFailure({
+        kind: 'bad_args', attempted,
+        failed: `File ${i + 1} (${target.show}) has no edits.`,
+        fix: 'Give every file a non-empty edits array. Nothing was written.',
+      });
+    }
+
+    await guard(target, `edit ${target.abs}`);
+
+    let original;
+    try {
+      original = await fs.readFile(target.abs, 'utf8');
+    } catch (err) {
+      throw fsFailure(err, attempted, target.show);
+    }
+
+    let text = original;
+    const diff = [`~${target.show}`];
+    for (const [j, edit] of entry.edits.entries()) {
+      const applied = replaceOnce(text, edit ?? {}, {
+        show: target.show,
+        attempted,
+        label: `${target.show}, edit ${j + 1} of ${entry.edits.length} (nothing was written)`,
+      });
+      diff.push(...renderDiff(changedRegion(edit.old_string, edit.new_string), { offset: applied.at - 1, max: 6 }));
+      text = applied.text;
+    }
+    planned.push({ target, text, diff, count: entry.edits.length });
+  }
+
+  for (const { target, text } of planned) {
+    try {
+      await fs.writeFile(target.abs, text, 'utf8');
+    } catch (err) {
+      throw fsFailure(err, `editing ${target.show}`, target.show);
+    }
+    written(target, text);
+  }
+
+  const edits = planned.reduce((n, p) => n + p.count, 0);
+  const out = result(
+    planned.map((p) => `Edited ${p.target.show} (${p.count} change${p.count === 1 ? '' : 's'})`).join('\n'),
+    `${planned.length} files · ${edits} edits`
+  );
+  out.diff = planned.flatMap((p) => p.diff);
+  return out;
+}