ucode-agent 1.44.0 → 1.47.0

package/README.md

@@ -1,8 +1,8 @@
 # ucode
 
 A coding agent that lives in your terminal. It reads your code, edits it, runs
-your commands, and keeps every conversation on disk. It runs on NVIDIA and
-Cohere models, all of them free.
+your commands, and keeps every conversation on disk. It runs on NVIDIA,
+Cohere and Nex AGI models, all of them free.
 
 It opens on a quiet screen — the name, the place to type, and the version in the
 corner:
@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.44.0
+                                                                           v1.46.0
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box
@@ -87,8 +87,8 @@ Needs Node 22 or newer.
 
 ## The models
 
-Five, and no picker full of names nobody recognises. NVIDIA and Cohere both
-serve capable models free, and both handle tool calling
+Six, and no picker full of names nobody recognises. NVIDIA, Cohere and Nex AGI
+all serve capable models free, and all handle tool calling
 properly, which is the thing an agent actually depends on.
 
 | Model | Context | For |
@@ -98,6 +98,7 @@ properly, which is the thing an agent actually depends on.
 | Nemotron 3 Super | 262k | strong all-rounder, quick to start |
 | Nemotron 3 Nano Omni | 256k | small, fast, reasoning tuned |
 | **North Mini Code** ★ | 256k | the default — built for code and interface work, quick to answer |
+| Nex N2.5 Pro | 262k | new agentic coder, on trial — can stall on big builds |
 
 `/model` shows them and switches. `ucode -m cohere/north-mini-code:free`
 starts on one.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ucode-agent",
-  "version": "1.44.0",
-  "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
+  "version": "1.47.0",
+  "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA, Cohere and Nex AGI models.",
   "type": "module",
   "main": "ucode.js",
   "bin": {
@@ -38,7 +38,8 @@
     "llm",
     "nvidia",
     "nemotron",
-    "cohere"
+    "cohere",
+    "nex-agi"
   ],
   "author": "om dixit",
   "license": "ISC",
@@ -53,6 +54,7 @@
     "playwright-core": "^1.63.0"
   },
   "devDependencies": {
+    "@types/node": "^26.5.1",
     "typescript": "^5.9.3"
   },
   "publishConfig": {

package/src/core/csscheck.js

@@ -0,0 +1,77 @@
+/**
+ * csscheck.js — a custom property that was never defined.
+ *
+ * `padding: var(--space-md)` where nothing ever declared `--space-md` does not
+ * warn, does not fall back and does not appear in the console. The browser
+ * throws the whole declaration away at parse time, so the padding is simply
+ * not there — and the page still renders, still looks deliberate, and is
+ * wrong in a way that reads as a design choice rather than a bug.
+ *
+ * It came out of a build here: a stylesheet that declared --space-xs, --space,
+ * --space-sm, --space-lg and --space-xl, then used --space-md four times.
+ * Nothing in the checks looked at CSS, so nothing said a word.
+ *
+ * The check is one whole app at a time rather than one file at a time,
+ * because the definition and the use are routinely in different files: a
+ * single-page app keeps its tokens in styles.css and reaches for them from an
+ * inline <style>, and reporting that as undefined would be worse than not
+ * looking. Whatever is passed in is the world; a name defined anywhere in it
+ * counts as defined everywhere.
+ */
+
+/** Definitions: `--name:` at the start of a declaration. */
+const DEFINED = /(?:^|[;{\s])(--[A-Za-z0-9_-]+)\s*:/g;
+/** Uses: `var(--name)` — and whether a fallback follows the name. */
+const USED = /var\(\s*(--[A-Za-z0-9_-]+)\s*([,)])/g;
+/** A name handed to CSS from script is defined, just not in a stylesheet. */
+const FROM_JS = /setProperty\(\s*['"`](--[A-Za-z0-9_-]+)/g;
+/** Inline styles in a page are part of that page's CSS. */
+const STYLE_TAGS = /<style\b[^>]*>([\s\S]*?)<\/style\s*>/gi;
+
+/** Comments hold examples and dead rules; neither defines anything. */
+const uncommented = (css) => css.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, ' '));
+
+/** The CSS in a source file: a stylesheet whole, a page's <style> blocks only. */
+function cssOf(rel, text) {
+  if (!/\.html?$/i.test(rel)) return uncommented(text);
+  // Everything outside a <style> is blanked rather than dropped, so a line
+  // number in the result is still a line number in the file.
+  let out = text.replace(/[^\n]/g, ' ');
+  for (const m of text.matchAll(STYLE_TAGS)) {
+    const at = m.index + m[0].indexOf(m[1]);
+    out = out.slice(0, at) + uncommented(m[1]) + out.slice(at + m[1].length);
+  }
+  return out;
+}
+
+/**
+ * Every `var(--x)` in `sources` with no `--x` defined anywhere in them and no
+ * fallback of its own.
+ *
+ * @param {{rel: string, text: string}[]} sources every file of one app that
+ *   holds CSS — stylesheets, pages with inline <style>, and any script that
+ *   sets a property, which defines names without declaring them.
+ * @returns {{rel: string, line: number, name: string}[]}
+ */
+export function checkCss(sources = []) {
+  const files = sources.map(({ rel, text }) => ({ rel, css: cssOf(rel, String(text ?? '')) }));
+
+  const defined = new Set();
+  for (const { css } of files) for (const m of css.matchAll(DEFINED)) defined.add(m[1]);
+  for (const { text } of sources) for (const m of String(text ?? '').matchAll(FROM_JS)) defined.add(m[1]);
+
+  const problems = [];
+  const seen = new Set();
+  for (const { rel, css } of files) {
+    for (const m of css.matchAll(USED)) {
+      const [, name, next] = m;
+      if (next === ',') continue;            // it carries its own fallback
+      if (defined.has(name)) continue;
+      const key = `${rel}:${name}`;
+      if (seen.has(key)) continue;           // once per name per file, not once per use
+      seen.add(key);
+      problems.push({ rel, name, line: css.slice(0, m.index).split('\n').length });
+    }
+  }
+  return problems;
+}

package/src/core/history.js

@@ -100,7 +100,12 @@ export async function save(session, { home = HOME } = {}) {
   const temp = `${target}.${process.pid}.tmp`;
 
   try {
-    await fs.writeFile(temp, JSON.stringify(session, null, 2), 'utf8');
+    // Compact, not pretty. The whole file is rewritten after every tool
+    // result, and on a long build with file contents in it the indentation was
+    // roughly half of what got written each time — for a file read by programs,
+    // not by people. `node -e "console.log(require('./x.json').messages)"` or
+    // /resume reads it either way.
+    await fs.writeFile(temp, JSON.stringify(session), 'utf8');
     await fs.rename(temp, target);
   } catch (err) {
     await fs.rm(temp, { force: true }).catch(() => {});

package/src/core/jslogic.js

@@ -0,0 +1,69 @@
+/**
+ * jslogic.js — the logic mistakes, in the system prompt, every turn.
+ *
+ * Skills are disclosed progressively and that is right for almost everything:
+ * a body loads when the work matches it. This does not, because the failures
+ * below do not announce themselves. They arrive in the middle of a build
+ * nobody called "a JavaScript task" — an empty state that stops coming back,
+ * a listener attached to a row that has since been replaced — and by the time
+ * the work looks like it needs a guide, the guide is being read too late.
+ *
+ * So it is always on, and the price of that is length: every word here is
+ * re-read by the provider on every step of every build. It is kept to the
+ * mistakes that have actually shipped from here, in the shortest form that
+ * still says what to do instead. Anything a parser could catch belongs in a
+ * check — see htmlcheck.js — not in this list. Nothing general about
+ * JavaScript belongs here at all: the model already knows it, and a paragraph
+ * confirming what it knows costs the same as one it does not.
+ *
+ * The vanilla section is drawn from builds that came out of ucode looking
+ * finished and were not. The framework section is the same failures one level
+ * up.
+ */
+
+export const JS_LOGIC = `## The logic mistakes that ship looking finished
+
+Every one of these renders. None of them throws where you can see it. Check
+each against what you are writing, before you write it.
+
+In a page:
+
+- **Empty is a state, not a starting position.** A render function that clears
+  its container decides what zero items looks like, in that same function.
+  Markup sitting in index.html, or one render call at start-up, survives the
+  first paint and then never comes back: add an item, delete it, and the list
+  is blank for good.
+- **User text goes in with textContent.** Into innerHTML, a task named
+  \`<img src=x onerror=alert(1)>\` runs, and one reading \`5 < 6\` silently eats
+  the rest of the row. Build rows with createElement and set .textContent.
+- **Every var(--x) needs a --x in :root.** An undefined custom property does
+  not fall back and does not warn — the browser discards the whole declaration,
+  so the padding is simply missing. Use only names you defined.
+- **One listener on the container, not one per row.** Re-rendering throws the
+  rows away and their listeners with them. Listen on the list and read
+  event.target.closest('[data-id]').
+- **An id that goes through the DOM comes back a string.** dataset.id is
+  "1738", never 1738, so === against a numeric id is always false. Make ids
+  strings when you create them.
+- **Saved is not loaded.** Writing localStorage is half of it: read it as the
+  page boots, before the first render, and confirm a refresh keeps the state.
+- **A missing element kills every line after it.** getElementById returns null
+  for a typo, .addEventListener on it throws, and the rest of the module never
+  runs — so every later handler in that file is silently never attached. One
+  typo, and nothing on the page works.
+
+In React or Next, the same failures one level up:
+
+- **Setting state does not change the variable you are holding.** Two
+  setCount(count + 1) in one handler add one. Pass a function when the next
+  value depends on the last.
+- **State is replaced, never edited.** items.push(x) then setItems(items) is
+  the same reference, so nothing re-renders.
+- **Hooks run every render, in order** — never inside an if, a loop, or after
+  an early return.
+- **An effect that sets what it depends on is a loop**, and one with no
+  dependency array runs after every render.
+- **key={index} is not identity.** On a list that reorders or filters, it moves
+  state onto the wrong row.
+- **"use client" is per file, at the top.** State, an event handler or a
+  browser API in a server file fails at build, not at run.`;