ucode-agent 1.20.1 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.20.1",
+  "version": "1.22.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/loop.js

@@ -459,6 +459,12 @@ 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.',
     '',
+    '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',
+    'will do them in, what you are about to consider. Say what you are building and',
+    'then build it.',
+    '',
     'SPEAK AS "I", NEVER "WE". You are doing this, not a committee: "I will build',
     'Tide as a single HTML file", not "we have created the file".',
     '',
@@ -1411,7 +1417,7 @@ export class Agent {
     // A build or type check that just passed already verified everything
     // changed so far; the automatic check at the end would only repeat it.
     if (call.name === 'run_command' && out.exitCode === 0 &&
-        /(?:next build|npm run build|pnpm (?:run )?build|tsc)/.test(call.args?.command ?? '')) {
+        /(?:next build|npm run build|pnpm (?:run )?build|tsc)/.test(call.args?.command ?? '')) {
       this.sinceCheck?.clear();
     }
     if (!QUIET.has(call.name)) this.ui.toolResult(out.summary);

package/src/tools/index.js

@@ -12,7 +12,6 @@ import { addBlock, BLOCK_NAMES } from './blocks.js';
 import { typeOf } from './types.js';
 import { runCommand, runCommands } from './shell.js';
 import { webSearch } from './web.js';
-import { lookAtApp } from './browser.js';
 import { createApp, TEMPLATE_NAMES, TEMPLATE_NOTES } from './scaffold.js';
 import { deploy } from './deploy.js';
 import { clip, READ_LINES } from './shared.js';
@@ -492,7 +491,14 @@ const run = {
   run_command: runCommand,
   run_commands: runCommands,
   web_search: webSearch,
-  look_at_app: lookAtApp,
+  /**
+   * Loaded when it is used, not when ucode starts.
+   *
+   * browser.js pulls in playwright-core, which costs a second of start-up on
+   * its own. Nothing reaches for the browser until someone types /look, so
+   * nobody should wait for it before the first prompt.
+   */
+  look_at_app: async (args, opts) => (await import('./browser.js')).lookAtApp(args, opts),
   create_app: createApp,
   deploy,
 };

package/src/ui/screen.js

@@ -106,6 +106,9 @@ const CHROME_BELOW = 6;
 /** How long one sentence of reasoning holds the line before the next takes it. */
 const THOUGHT_HOLD_MS = 1100;
 
+/** Reasoning that is about the request rather than about the work. */
+const RESTATEMENT = /^(?:the user|they|so the user|user)|^(?:i (?:need|should|will need) to (?:understand|figure|work out|check what))|^(?:let me (?:understand|re-?read|look at the (?:request|prompt)))|^(?:the (?:request|prompt|task) (?:is|asks|says))/i;
+
 /** The wordmark only earns its place with room for the facts column beside it. */
 const WORDMARK_NEEDS = BANNER_WIDTH + 30;
 
@@ -316,7 +319,7 @@ export class Screen {
       run.label = label;
       run.targets.push(groupTarget(label));
       this.run = run;
-      this.paintRun({ live: true });
+      this.paintRun();
     } else {
       this.push(`${narrationMark()} ${narration(asLabel(label))}`);
       this.run = {
@@ -324,7 +327,7 @@ export class Screen {
         targets: [groupTarget(label)], added: 0, removed: 0,
       };
       this.segment.set(kind, this.run);
-      this.paintRun({ live: true });
+      this.paintRun();
     }
     this.updateSpinner(label);
   }
@@ -352,19 +355,12 @@ export class Screen {
    * lines are gone. It settles to plain dim the moment the step finishes, so
    * the finished ones above stay quiet.
    */
-  paintRun({ live = this.run?.live } = {}) {
+  paintRun() {
     if (!this.run) return;
-    const text = asLabel(runLine(this.run));
-    this.run.live = live;
-    this.lines[this.run.at] = `${narrationMark()} ${live ? shimmer(text, this.tick * FRAME_MS) : narration(text)}`;
+    this.lines[this.run.at] = `${narrationMark()} ${narration(asLabel(runLine(this.run)))}`;
     this.render();
   }
 
-  /** Let the line in flight animate, one frame per tick. */
-  paintLiveRun() {
-    if (this.run?.live && this.lines[this.run.at] !== undefined) this.paintRun({ live: true });
-  }
-
   /**
    * A change, as its two numbers.
    *
@@ -395,10 +391,7 @@ export class Screen {
    * already names the step, and a change adds its numbers to that same line.
    * Only a failure earns a line of its own.
    */
-  toolResult() {
-    // The step is over: the line stops moving and joins the quiet ones above.
-    if (this.run) this.paintRun({ live: false });
-  }
+  toolResult() {}
 
   /**
    * Something went wrong, and the model is the one who can do anything about it.
@@ -569,6 +562,11 @@ export class Screen {
 
     const line = finished[1].trim();
     if (line.length < 12) return;   // "Okay." tells nobody anything
+    // Reasoning models open by restating the request to themselves — "The user
+    // wants a tasks app called Tide" — which the user wrote, is looking at, and
+    // does not need read back. Only a sentence about what is being done is
+    // worth the line.
+    if (RESTATEMENT.test(line)) { this.thought = ''; return; }
 
     this.openedWith = line;
     // Full strength: this is the model talking, and it is the thing on the page
@@ -922,8 +920,10 @@ export class Screen {
   startTimer() {
     if (this.spinTimer) return;
     this.spinTimer = setInterval(() => {
+      // Only the status row repaints on a tick. Animating a transcript line
+      // meant redrawing the whole frame twelve times a second, and the input
+      // box was being rebuilt under the user's cursor as they typed.
       this.tick++;
-      this.paintLiveRun();
       this.paintStatus();
     }, FRAME_MS);
     this.spinTimer.unref?.();

package/ucode.js

@@ -12,12 +12,22 @@ import { readFile } from 'node:fs/promises';
 import { realpathSync } from 'node:fs';
 import { pathToFileURL, fileURLToPath } from 'node:url';
 
-import { Agent } from './src/core/loop.js';
-import { setModel, modelName, MODELS, DEFAULT_MODEL, ENV_FILE } from './src/core/provider.js';
 import { VERSION } from './src/core/version.js';
-import { Plain } from './src/ui/plain.js';
 import { blue, dim, sky } from './src/ui/theme.js';
 
+/**
+ * The agent and the provider are loaded when a session actually starts.
+ *
+ * Between them they pull in the OpenAI SDK and every tool, which is most of
+ * the two and a half seconds ucode used to take before printing anything at
+ * all — including for `--version`, which needs none of it.
+ */
+const heavy = () => Promise.all([
+  import('./src/core/loop.js'),
+  import('./src/core/provider.js'),
+  import('./src/ui/plain.js'),
+]);
+
 function parseArgs(argv) {
   const args = { debug: false, model: null, cwd: process.cwd(), help: false, plan: false, version: false };
 
@@ -34,7 +44,8 @@ function parseArgs(argv) {
   return args;
 }
 
-function usage() {
+async function usage() {
+  const [, { MODELS, modelName, DEFAULT_MODEL, ENV_FILE }] = await heavy();
   const entries = Object.entries(MODELS);
   const width = Math.max(...entries.map(([, m]) => m.name.length));
   const models = entries
@@ -112,6 +123,8 @@ async function main() {
     }
   }
 
+  const [{ Agent }, { setModel }, { Plain }] = await heavy();
+
   if (args.model) {
     try {
       setModel(args.model);