ucode-agent 1.2.0 → 1.3.0

package/README.md

@@ -103,15 +103,44 @@ long think are for. When the wait stops being worth it, switch.
 
 ## 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.
+**Thirteen tools.** `read_file`, `read_files`, `write_file`, `batch_write`,
+`edit_file`, `multi_edit`, `edit_files`, `list_dir`, `glob`, `grep`,
+`run_command`, `run_commands`, `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.
+
+**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.
@@ -179,6 +208,7 @@ Everything after the frontmatter is the instruction.
 | `/model` | show the models and switch — `/models` does the same |
 | `/resume` | pick up an earlier conversation — `/session`, `/sessions` too |
 | `/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,8 +239,11 @@ 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`.
 
@@ -226,6 +259,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.3.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/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;
+}