ucode-agent 1.2.0 → 1.4.0

package/README.md

@@ -19,7 +19,7 @@ corner:
   ╭──────────────────────────────────────────────────────────────────────────────╮
   │ › Ask anything…                                                              │
   │                                                                              │
-  │ ◆ Build · Nemotron 3 Ultra                                                0% │
+  │ ◆ Build · North Mini Code                                                 0% │
   ╰──────────────────────────────────────────────────────────────────────────────╯
 
 
@@ -44,7 +44,7 @@ the input, so your own words are easy to find in a long session:
 ╭──────────────────────────────────────────────────────────────────────────────────╮
 │ › now add a dark mode toggle                                                     │
 │                                                                                  │
-│ ◆ Build · Nemotron 3 Ultra                                                    4% │
+│ ◆ Build · North Mini Code                                                     4% │
 ╰──────────────────────────────────────────────────────────────────────────────────╯
 ```
 
@@ -88,30 +88,75 @@ properly, which is the thing an agent actually depends on.
 
 | Model | Context | For |
 | --- | --- | --- |
-| **Nemotron 3 Ultra** ★ | 1M | the default — deepest reasoning, slowest to first token |
+| Nemotron 3 Ultra | 1M | deepest reasoning, slowest to first token |
 | Nemotron 3.5 Lightning | 1M | the same enormous window, answers much sooner |
 | Nemotron 3 Super | 262k | strong all-rounder, quick to start |
 | Nemotron 3 Nano Omni | 256k | small, fast, reasoning tuned |
-| **North Mini Code** ★ | 256k | code and UI specialist — reach for it on frontend work |
+| **North Mini Code** ★ | 256k | the default — built for code and interface work, quick to answer |
 
 `/model` shows them and switches. `ucode -m cohere/north-mini-code:free`
 starts on one.
 
-Ultra is the default because the work this is for — read a codebase, hold it in
-mind, change several files consistently — is what a million-token window and a
-long think are for. When the wait stops being worth it, switch.
+North Mini Code is the default: it is built for code and interfaces, which is most
+of what ucode is asked to do, and it answers far sooner than the big reasoning
+models. Switch to Ultra when a problem needs the million-token window more than
+the speed.
+
+**A busy model never stops a build.** Free endpoints are shared, and "too many
+requests" is routine. ucode waits it out with growing pauses, and if the model
+stays busy it carries on with the next one — North Mini Code, then Nemotron 3.5
+Lightning, Super, Ultra — from exactly where it was, and tells you it switched.
+If every model is busy at once it waits a minute and goes round again. Your
+chosen model gets another go a few minutes later.
 
 ## What it does
 
-**Twelve tools.** `read_file`, `read_files`, `write_file`, `batch_write`, `edit_file`,
-`multi_edit`, `list_dir`, `glob`, `grep`, `run_command`, `run_commands`,
-`web_search`. Read-only calls run in parallel; anything that writes runs on its
-own, in order.
+**Fourteen tools.** `read_file`, `read_files`, `write_file`, `batch_write`,
+`edit_file`, `multi_edit`, `edit_files`, `list_dir`, `glob`, `grep`,
+`run_command`, `run_commands`, `look_at_app`, `web_search`. Read-only calls run in parallel,
+and start the moment the model finishes writing them — while the rest of its
+reply is still arriving. Anything that writes runs on its own, in order.
+
+**Parallel workers.** When a build splits into parts that touch different files
+— the API route, the upload component, the results view — the model hands them
+to up to three workers that build at the same time, each line in the transcript
+tagged with the worker's name. File writes take turns so two never collide.
+
+**Installs that start early.** The moment a `package.json` with dependencies is
+written, its install starts in the background while the rest of the app is
+still being written. An install the model asks for later waits for that one
+instead of running twice, and anything run in that folder waits for it too.
+
+**It looks at what it built.** `look_at_app` opens the running app in a real
+browser — the Edge or Chrome already on your machine, so there is nothing extra
+to download — at 375px and 1440px. It reports console errors, failed requests,
+content that spills off a phone screen, broken images and unlabeled controls,
+saves screenshots to `.ucode/screenshots`, and has Nemotron Nano Omni review them
+the way a designer would. The model fixes what it finds before calling the app
+done.
+
+**Errors fixed before you see them.** When the model says it is done, ucode
+type-checks every file it changed — `tsc --noEmit` for TypeScript projects,
+a syntax check for JavaScript and Python — and hands any errors back to fix,
+up to three rounds.
+
+**A plan you can see.** For longer jobs the model keeps a short checklist, shown
+as one line: `plan 2/5  ✓ Scaffold · ✓ Upload · ▸ Score dial · ○ Findings · ○ Polish`.
+
+**It knows the project before it asks.** Each turn starts with a map of every
+file and the names each code file exports, so the model goes straight to the
+right file instead of searching for it.
+
+**Project memory.** `UCODE.md` in a project — and `~/.ucode/UCODE.md` for how you
+like to work everywhere — is read at the start of every turn. `/remember <note>`
+adds a line to it.
 
 **Edits that never guess.** `edit_file` matches exactly once or it fails, and
-when it fails it says *why* — the text is there but the indentation differs, or
-its first line appears at line 40 and the rest does not. A wrong edit reported
-as a success is the most expensive thing an agent can do.
+when it fails it says *why*. It tolerates what does not matter — tabs against
+spaces, a different indent depth, Windows line endings — and re-indents the
+replacement to fit the file, but a match found twice is still refused.
+`edit_files` changes several files in one call, and writes none of them if any
+edit fails.
 
 **Diffs with real line numbers.** Removed lines are numbered where they were,
 added lines where they now are. Numbers you can jump to, not decoration.
@@ -125,7 +170,12 @@ them; the chip inside the input box says which is live.
 
 **Sessions.** Everything is on disk under `~/.ucode/sessions`, saved after every
 step. `/resume` lists them with what each one was actually about, the ones from
-this folder first.
+this folder first. Press `d` twice on one to delete it — the list stays open, so
+clearing out several is quick — or `/session delete 2,5`.
+
+**It updates itself.** Each launch checks npm in the background and, if there is
+a newer version, installs it while you work. The next launch is the new one.
+Set `UCODE_NO_UPDATE=1` to turn that off.
 
 **A context window that folds rather than forgets.** Past 75% the oldest turns
 are summarised instead of dropped, never cutting between a tool call and its
@@ -178,7 +228,9 @@ Everything after the frontmatter is the instruction.
 | `/help` | the list |
 | `/model` | show the models and switch — `/models` does the same |
 | `/resume` | pick up an earlier conversation — `/session`, `/sessions` too |
+| `/session delete 2,5` | delete saved conversations by number (or `d d` in the list) |
 | `/new` | save this one and start fresh |
+| `/remember <note>` | add a standing note to this project's `UCODE.md` |
 | `/skills` | what it knows how to do, and what is loaded |
 | `/search <query>` | look something up on the web |
 | `/copy` | last reply to the clipboard |
@@ -209,10 +261,13 @@ ucode [options]
 | `~/.ucode/.env` | `UCODE_API_KEY`, and `TAVILY_API_KEY` for web search |
 | `~/.ucode/sessions/` | one JSON per conversation |
 | `.ucode/skills/` | skills belonging to a project |
+| `UCODE.md` | project memory, read every turn |
+| `~/.ucode/UCODE.md` | your own standing instructions, for every project |
 
-Environment overrides: `UCODE_MODEL`, `UCODE_MAX_CONTEXT_TOKENS`,
+Environment overrides: `UCODE_MODEL`, `UCODE_WORKER_MODEL` (a faster model for
+parallel workers), `UCODE_WORKER_STEPS`, `UCODE_MAX_CONTEXT_TOKENS`,
 `UCODE_MAX_STEPS`, `UCODE_MAX_TOOL_OUTPUT`, `UCODE_REQUEST_TIMEOUT_MS`,
-`UCODE_BASE_URL`.
+`UCODE_BASE_URL`, `UCODE_NO_UPDATE`.
 
 Web search needs a Tavily key — free, 1000 searches a month, no card. Without
 one, ucode answers from what it knows and says that it could not check.
@@ -226,6 +281,7 @@ src/core/provider.js  the only file that knows which provider answers
 src/core/history.js   sessions on disk
 src/core/window.js    folding a long conversation to fit
 src/core/skills.js    loading skills, and deciding which load themselves
+src/core/context.js   the project map and project memory
 src/core/failure.js   one error shape: what, why, what next
 src/tools/            the eleven tools, plus their shared plumbing
 src/ui/screen.js      the full-screen interface

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -48,6 +48,7 @@
     "dotenv": "^17.4.2",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
-    "openai": "^7.4.0"
+    "openai": "^7.4.0",
+    "playwright-core": "^1.63.0"
   }
 }

package/skills/build-app/SKILL.md

@@ -141,8 +141,10 @@ Use `batch_write` for the skeleton — one call, every file.
 - `npm run build` — it type-checks and lints; a build that fails is not done.
 - Start it: `npm run dev` goes to the background on its own and comes back with
   the URL once ready. Do not start it twice.
-- Exercise it: `curl` the API route with real input, load the page, check the
-  core loop end to end. A clean build proves it compiles, not that it works.
+- Exercise it: `curl` the API route with real input, then `look_at_app` on every
+  page — it loads them in a real browser at phone and desktop width and reports
+  errors, overflow and a visual review. A clean build proves it compiles, not
+  that it works.
 - Fix what you find and check again.
 
 ## 7. Definition of done

package/skills/ui-ux/SKILL.md

@@ -283,7 +283,11 @@ because it was first to hand means you were not deciding.
 
 ## 9. Look at it, then report
 
-Run it (`npm run dev` starts in the background and returns the URL) and check:
+Run it (`npm run dev` starts in the background and returns the URL), then call
+`look_at_app` with that URL. It opens the app in a real browser at 375px and
+1440px, reports console errors, failed requests, overflow, broken images and
+unlabeled controls, and returns a designer's review of the screenshots. Fix what
+it finds and look again. Then check:
 
 1. **375px wide** — no horizontal scroll, nothing overlapping or clipped. If you
    wrote no responsive rules at all, you have not done this.

package/src/core/context.js

@@ -0,0 +1,151 @@
+/**
+ * context.js — what the model knows about the project before it asks.
+ *
+ * Two things go into the system prompt at the start of every turn:
+ *
+ *   the project map   every file, and the names each code file exports, so the
+ *                     model can go straight to the right file instead of
+ *                     spending round trips on list_dir and grep to find it
+ *
+ *   project memory    UCODE.md — the stack, the commands, the conventions, the
+ *                     preferences — written once, remembered every session
+ */
+
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { walk } from '../tools/shared.js';
+
+export const MEMORY_FILE = 'UCODE.md';
+export const GLOBAL_MEMORY = path.join(os.homedir(), '.ucode', MEMORY_FILE);
+
+const MAP_FILES = 400;
+const MAP_CHARS = 8_000;
+const MEMORY_CHARS = 6_000;
+const SYMBOL_BYTES = 120_000;
+const SYMBOLS_PER_FILE = 8;
+
+const CODE = /\.(?:[cm]?[jt]sx?|py|go|rs|vue|svelte)$/i;
+
+// Files the map never needs to name.
+const NOISE = /(^|\/)(?:package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb|.*\.map|.*\.min\.[jc]ss?|\.DS_Store|next-env\.d\.ts)$/i;
+
+/** Parsed symbols, kept per file until the file's mtime changes. */
+const symbolCache = new Map();
+
+function symbolsIn(file, text) {
+  const found = [];
+  const add = (name) => { if (name && !found.includes(name)) found.push(name); };
+
+  if (/\.py$/i.test(file)) {
+    for (const m of text.matchAll(/^(?:async\s+)?(?:def|class)\s+([A-Za-z_]\w*)/gm)) add(m[1]);
+  } else if (/\.go$/i.test(file)) {
+    for (const m of text.matchAll(/^func\s+(?:\([^)]*\)\s*)?([A-Z]\w*)/gm)) add(m[1]);
+    for (const m of text.matchAll(/^type\s+([A-Z]\w*)/gm)) add(m[1]);
+  } else if (/\.rs$/i.test(file)) {
+    for (const m of text.matchAll(/^pub\s+(?:async\s+)?(?:fn|struct|enum|trait)\s+(\w+)/gm)) add(m[1]);
+  } else {
+    for (const m of text.matchAll(/export\s+(?:default\s+)?(?:async\s+)?(?:function\*?|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][\w$]*)/g)) add(m[1]);
+    if (/export\s+default\s+(?:async\s+)?function\s*\(/.test(text)) add('default');
+    for (const m of text.matchAll(/export\s*\{([^}]+)\}/g)) {
+      for (const part of m[1].split(',')) add(part.trim().split(/\s+as\s+/).pop());
+    }
+  }
+
+  return found.slice(0, SYMBOLS_PER_FILE);
+}
+
+async function symbolsFor(root, rel) {
+  const abs = path.join(root, rel);
+  try {
+    const stat = await fs.stat(abs);
+    if (stat.size > SYMBOL_BYTES) return [];
+    const cached = symbolCache.get(abs);
+    if (cached && cached.mtime === stat.mtimeMs) return cached.symbols;
+    const symbols = symbolsIn(rel, await fs.readFile(abs, 'utf8'));
+    symbolCache.set(abs, { mtime: stat.mtimeMs, symbols });
+    return symbols;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * A compact outline of the project: directories, their files, and what each
+ * code file exports. Bounded, so a large repository costs a fixed amount of
+ * context rather than all of it.
+ */
+export async function projectMap(root) {
+  const all = (await walk(root, { limit: MAP_FILES * 3 })).filter((f) => !NOISE.test(f));
+  if (all.length === 0) return '(the folder is empty — this is a new project)';
+
+  const files = all.slice(0, MAP_FILES).sort();
+  const symbols = await Promise.all(
+    files.map((f) => (CODE.test(f) ? symbolsFor(root, f) : Promise.resolve([])))
+  );
+
+  const byDir = new Map();
+  files.forEach((f, i) => {
+    const dir = path.posix.dirname(f);
+    const name = path.posix.basename(f);
+    const line = symbols[i].length ? `${name} · ${symbols[i].join(', ')}` : name;
+    if (!byDir.has(dir)) byDir.set(dir, []);
+    byDir.get(dir).push(line);
+  });
+
+  const out = [];
+  let size = 0;
+  let shown = 0;
+  for (const [dir, entries] of byDir) {
+    const block = [dir === '.' ? './' : `${dir}/`, ...entries.map((e) => `  ${e}`)].join('\n');
+    if (size + block.length > MAP_CHARS) {
+      out.push(`… ${files.length - shown} more files not shown`);
+      break;
+    }
+    out.push(block);
+    size += block.length;
+    shown += entries.length;
+  }
+  if (all.length > MAP_FILES) out.push(`… the project has ${all.length}+ files; the rest are not listed`);
+
+  return out.join('\n');
+}
+
+async function readCapped(file) {
+  try {
+    const text = (await fs.readFile(file, 'utf8')).trim();
+    if (!text) return '';
+    return text.length > MEMORY_CHARS ? `${text.slice(0, MEMORY_CHARS)}\n… (cut)` : text;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Standing instructions: ~/.ucode/UCODE.md for how you like to work anywhere,
+ * then <project>/UCODE.md for this project. The project file comes second so
+ * it wins where the two disagree.
+ */
+export async function loadMemory(root) {
+  const personal = await readCapped(GLOBAL_MEMORY);
+  const project = await readCapped(path.join(root, MEMORY_FILE));
+  const parts = [];
+  if (personal) parts.push(`From ~/.ucode/${MEMORY_FILE} (applies everywhere):\n${personal}`);
+  if (project) parts.push(`From ./${MEMORY_FILE} (this project):\n${project}`);
+  return parts.join('\n\n');
+}
+
+/** Append one note to this project's UCODE.md, creating it if needed. */
+export async function remember(root, note) {
+  const file = path.join(root, MEMORY_FILE);
+  let existing = '';
+  try {
+    existing = await fs.readFile(file, 'utf8');
+  } catch {
+    existing = `# Project memory\n\nucode reads this at the start of every session in this folder.\n\n`;
+  }
+  const line = `- ${String(note).trim().replace(/\s+/g, ' ')}\n`;
+  const sep = existing.endsWith('\n') ? '' : '\n';
+  await fs.writeFile(file, existing + sep + line, 'utf8');
+  return file;
+}