ucode-agent 1.31.0 → 1.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.31.0",
+  "version": "1.33.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -16,7 +16,7 @@
   "scripts": {
     "start": "node ucode.js",
     "test": "node test/run.js",
-    "prepublishOnly": "node test/run.js"
+    "prepublishOnly": "node scripts/no-bundled-key.js && node test/run.js"
   },
   "repository": {
     "type": "git",
@@ -26,9 +26,6 @@
     "url": "https://github.com/sppideey/ucode-agent/issues"
   },
   "homepage": "https://github.com/sppideey/ucode-agent#readme",
-  "publishConfig": {
-    "access": "public"
-  },
   "engines": {
     "node": ">=22"
   },
@@ -56,5 +53,8 @@
   },
   "devDependencies": {
     "typescript": "^5.9.3"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/src/core/loop.js

@@ -556,6 +556,34 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     'already contains it. Do not re-check work the checks have already reported on.',
     'Fast is not sloppy: it is the same work with the waiting taken out.',
     '',
+    'DESIGN IT BEFORE YOU TYPE IT. Fast means fewer round trips. It does not mean a',
+    'default theme, and an app that goes out in the palette its starter came with is',
+    'not a fast build, it is an undesigned one. There is no design pass after the',
+    'create_app call, because there is no after — so the decisions happen before it.',
+    '',
+    'Three of them, and you hold them for the whole build:',
+    '  - A TONE, one word you commit to: clinical, warm, editorial, technical,',
+    '    playful, industrial, calm, dense. "Modern and clean" is not a tone.',
+    '  - An ACCENT that is not the one the starter shipped with.',
+    '  - ONE memorable thing this app has that other apps do not: a colour, a type',
+    '    move, a texture, one interaction. Exactly one. It is the difference between',
+    '    a design and a theme.',
+    'Name the tone and the accent in your opening line, so they are settled before any',
+    'file exists: "I will build Tide - a tasks app in one HTML file, calm, warm grey',
+    'with a single amber accent." That is not narrating a plan, that is the decision.',
+    '',
+    'Then the tokens are the first thing in the file, in the same call as everything',
+    'else: the type scale, the space scale, neutrals that carry a hue, the accent and',
+    'its semantics. Nothing after that uses a raw value. IN next-shadcn THAT MEANS',
+    'globals.css IS RE-TINTED IN THAT SAME create_app CALL. Shipping the palette the',
+    'starter came with is the commonest way a build looks generated, and it is the',
+    'first thing anyone notices. A blocked-out page in the colours this app chose',
+    'beats a finished page in the ones it was handed.',
+    '',
+    'add_block gives you structure, never a look. A block arrives with no opinion',
+    'about this app and is yours to tint the moment it lands. Assembling blocks and',
+    'shipping them as they came is the quick way to something nobody designed.',
+    '',
     'Never repeat the request back. Not as a summary, not as a restatement, not as',
     'a list of what was asked for. They wrote it and it is on the screen above you.',
     'Do not narrate your planning either - which files you will make, what order you',
@@ -665,6 +693,11 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '  reports - errors, layout that overflows a phone, the review points worth fixing -',
     '  in one pass, then look once more. A clean second look means it is done: report',
     '  back instead of polishing in circles. Never call an interface finished unlooked at.',
+    '- ANYTHING THAT NEEDS A SERVER IS LEFT RUNNING. If the app has a dev server -',
+    '  Next.js, Vite, anything with an npm run dev - start it and leave it up when you',
+    '  finish. ucode opens it in the browser for the user as soon as it is ready, so a',
+    '  build that ends with the server stopped ends with nothing to look at. A one-page',
+    '  app with no server needs none of this: the file is the app.',
     '  name, handles keys and returns the live link. Build locally first.',
     '- Nothing you run has a keyboard. Pass the non-interactive flag to anything that',
     '  would ask a question, or it fails instead of waiting: create-next-app --yes,',
@@ -1540,15 +1573,19 @@ export class Agent {
 
   /** A dev server came up during this turn: open it in the browser, once. */
   /**
-   * Open the running app in a browser — only when asked.
+   * Open the running app in a browser as soon as a dev server is up.
+   *
+   * This was turned off once, on the grounds that a window seizing the screen
+   * mid-thought is startling and worse during a demo. It only fires at the end
+   * of a finished turn, though, not mid-thought — and the thing the user asked
+   * for is a running app, not a URL they then have to go and click. Being
+   * handed a link to the thing you asked to be built is the last step of the
+   * job left undone.
    *
-   * This used to happen on its own whenever a dev server came up. Something
-   * seizing the screen mid-thought is startling at the best of times, and
-   * during a demo it is worse. UCODE_OPEN=1 brings the old behaviour back for
-   * anyone who liked it; otherwise the URL is on screen to click.
+   * UCODE_OPEN=0 turns it off for anyone who wants the link and nothing else.
    */
   openWhenReady(since) {
-    if (!this.full || process.env.UCODE_OPEN !== '1') return;
+    if (!this.full || process.env.UCODE_OPEN === '0') return;
     const server = serversReadySince(since).at(-1);
     if (!server || (this.opened ??= new Set()).has(server.url)) return;
     this.opened.add(server.url);

package/src/core/provider.js

@@ -107,6 +107,18 @@ export const FALLBACKS = [
 
 /** The next model to try after `id`, skipping any already tried this round. */
 export function fallbackFor(id, tried = new Set()) {
+  // Off unless UCODE_FALLBACK=1. A build that starts on one model and finishes
+  // on another finishes to a different standard, and the swap lands exactly
+  // when the user is least placed to work out why the output changed —
+  // mid-build, behind a note that scrolls past. Which model to run is the one
+  // decision they made before starting; it is not one to take back for them.
+  //
+  // Every caller already reads "no fallback" as "wait, then try this one
+  // again": failover waits a minute and returns to the same model, the
+  // stuck-detector simply does not switch, and a worker retries its own. That
+  // is why this can be a single gate rather than four.
+  if (process.env.UCODE_FALLBACK !== '1') return null;
+
   const start = Math.max(0, FALLBACKS.indexOf(id));
   for (let i = 1; i <= FALLBACKS.length; i++) {
     const next = FALLBACKS[(start + i) % FALLBACKS.length];

package/src/tools/index.js

@@ -85,7 +85,11 @@ export const tools = [
       'Start a new app AND write it, in one call. Pass "files" with the whole app and this ' +
       'is the only call the build needs: the starter lands, your files are written over it, ' +
       'and the result comes back with everything. Two starters. "plain-html" (the default): ' +
-      'one index.html, one stylesheet, one ES module — nothing to install, nothing to build, ' +
+      'one index.html, one stylesheet, one ES module — nothing to install, nothing to build, ' +
+      'and the stylesheet is a design system already: a palette, a spacing scale, radii, ' +
+      'motion timings, focus rings and a breakpoint. Re-tint those tokens to suit the app ' +
+      'and compose every rule from them. Replacing it with raw pixel values is what an ' +
+      'undesigned page is made of. ' +
       'opens straight in a browser, and its three files come back inside this result so there ' +
       'is never a reason to read them. Use it for anything that is one page: a tasks app, a ' +
       'toy, a game, a visualisation, a calculator, a timer. "next-shadcn": Next.js 16, ' +

package/src/tools/scaffold.js

@@ -108,6 +108,46 @@ async function copyTree(from, to, fill) {
  * globals.css and layout.tsx. Apps stop looking like the same default blue.
  * Returns the preset used, or null when the starter has none.
  */
+/**
+ * The file in each starter that carries the design, not just some of the rules.
+ *
+ * next-shadcn has globals.css, which applyDesign re-tints. plain-html has one
+ * stylesheet and it is the whole design system: the palette, a spacing scale,
+ * radii, motion timings, focus rings, a reduced-motion rule and a breakpoint.
+ */
+const TOKEN_FILE = { 'plain-html': 'styles.css' };
+
+/**
+ * Put the starter's token block back when the app wrote over it without one.
+ *
+ * The stylesheet in plain-html is a design, not a placeholder — but `files`
+ * lands straight on top of the starter, so a model passing its own styles.css
+ * replaces the scale, the palette and the timings with whatever it typed. What
+ * comes back is hand-rolled CSS with no system behind it, and an app built on
+ * raw pixel values has uneven spacing everywhere for the rest of its life.
+ *
+ * A replacement that declares its own custom properties is left alone: that is
+ * a model doing the job properly, and second-guessing it would be worse. Only
+ * a stylesheet with no :root variables at all gets the starter's block put
+ * back above it, where every rule underneath can reach it.
+ */
+async function keepDesignTokens(appDir, template, written, starterCss) {
+  const rel = TOKEN_FILE[template];
+  if (!rel || !starterCss) return null;
+
+  const abs = path.join(appDir, rel);
+  if (!written.has(abs)) return null;                 // never overwritten
+
+  const now = await fs.readFile(abs, 'utf8').catch(() => null);
+  if (now === null || /:root\s*\{[^}]*--/.test(now)) return null;
+
+  const block = /:root\s*\{[\s\S]*?\n\}/.exec(starterCss);
+  if (!block) return null;
+
+  await fs.writeFile(abs, `${block[0]}\n\n${now}`, 'utf8');
+  return rel;
+}
+
 export async function applyDesign(appDir, design) {
   const dir = path.join(appDir, 'presets');
   const names = (await fs.readdir(dir).catch(() => [])).filter((f) => f.endsWith('.json'));
@@ -242,7 +282,13 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // Next.js serves static files from public/; a plain page has no such place
   // and an empty folder in a three-file app is clutter.
   if (template !== 'plain-html') await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
-  const look = await applyDesign(target.abs, design);
+  const look = await applyDesign(target.abs, design);
+
+  // Read before the app's own files land on top of it, so the tokens can be
+  // put back if the replacement arrives without any.
+  const starterCss = TOKEN_FILE[template]
+    ? await fs.readFile(path.join(target.abs, TOKEN_FILE[template]), 'utf8').catch(() => null)
+    : null;
 
   // The starter has been installed on this machine before: hard-link that
   // tree in, which is seconds where npm is a minute. Otherwise install as
@@ -271,7 +317,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // one, and round trips are nearly all of the time a build takes.
   const mine = given;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
-  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
+  const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
+  const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
 
   // The starter's own files, in full, so there is never a reason to read them
   // back — and only the ones this call did not already write over. A read is
@@ -287,7 +334,14 @@ export async function createApp({ folder, name, description, template = 'plain-h
   const out = result(
     `Created ${target.show} from the ${template} starter — ${copied.length} files, already known to build.\n` +
       (look ? `Design: the ${look.name} preset (${look.summary}), font ${look.fonts?.sans ?? 'Geist'}.\n` : '') +
-      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
+      (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
+      (keptTokens
+        ? `\nYour ${keptTokens} arrived with no :root block, so the starter's was kept above it — ` +
+          'the palette, the spacing scale (--s1 to --s5), the radius and the motion timings. ' +
+          'Build the rest of the stylesheet out of those variables: spacing that comes from a ' +
+          'scale is the difference between a designed page and an arranged one. Re-tint the ' +
+          'values to suit this app; do not go back to raw pixels.\n'
+        : '') +
       (linked
         ? `Its packages are already in place (${linked.toLocaleString()} files, linked from the starter cache) — ` +
           'nothing to install: build and run straight away.\n'