ucode-agent 1.62.5 → 1.62.7

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.62.5
+                                                                           v1.62.7
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box
@@ -376,7 +376,7 @@ Everything after the frontmatter is the instruction.
 | `/clear` | clear the screen, keep the conversation |
 | `/exit` | save and quit |
 
-`ctrl+b` plan/build · `esc` stops a running turn · `ctrl+d` quits ·
+`ctrl+b` plan/build · click `+ file` (or `ctrl+o`) to add a picture or file · `esc` stops a running turn · `ctrl+d` quits ·
 `↑ ↓` scroll the conversation, or walk history once you are typing ·
 `tab` completes a command
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.62.5",
+  "version": "1.62.7",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on Google Gemini models.",
   "type": "module",
   "main": "ucode.js",

package/src/core/attach.js

@@ -0,0 +1,118 @@
+/**
+ * attach.js — the "+ file" button: choosing reference files and turning them
+ * into something the model can use.
+ *
+ * The chooser is the computer's own (Finder on macOS, the Open dialog on
+ * Windows, zenity on Linux), so a sketch on the Desktop or a brief in
+ * Downloads is two clicks away. Where there is none, the caller falls back to
+ * a list of the project's files.
+ *
+ * Images go to the model as pictures; text files ride on the request as
+ * reference, under their own name. Anything else is refused with a reason.
+ */
+
+import { execFile } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const IMAGE = { png: 'png', jpg: 'jpeg', jpeg: 'jpeg', gif: 'gif', webp: 'webp' };
+
+/** Bigger than this and a picture is refused rather than sent. */
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+
+/** Bigger than this and a text file is refused: it would crowd out the conversation. */
+export const MAX_TEXT_BYTES = 100 * 1024;
+
+/** Folders never listed in the fallback picker. */
+const SKIP = new Set(['node_modules', '.git', '.next', '.ucode', 'dist', 'build', '.turbo', '.vercel']);
+
+/** The native "choose a file" command for this platform, or null when there is none to try. */
+function chooserFor(platform) {
+  if (platform === 'darwin') {
+    return ['osascript', ['-e', 'POSIX path of (choose file with prompt "Add a file for ucode")']];
+  }
+  if (platform === 'win32') {
+    const script =
+      'Add-Type -AssemblyName System.Windows.Forms;' +
+      '$d = New-Object System.Windows.Forms.OpenFileDialog;' +
+      '$d.Title = "Add a file for ucode";' +
+      'if ($d.ShowDialog() -eq "OK") { [Console]::Out.Write($d.FileName) }';
+    return ['powershell.exe', ['-NoProfile', '-STA', '-Command', script]];
+  }
+  return ['zenity', ['--file-selection', '--title=Add a file for ucode']];
+}
+
+/**
+ * Ask the user for a file with the system's own dialog.
+ * Resolves to a path, null when they cancelled, or undefined when there is no dialog here.
+ */
+export function chooseFile({ platform = process.platform, run = execFile } = {}) {
+  const [cmd, args] = chooserFor(platform);
+  return new Promise((resolve) => {
+    run(cmd, args, { timeout: 10 * 60_000, windowsHide: false }, (err, stdout) => {
+      const picked = String(stdout ?? '').trim();
+      if (picked) return resolve(picked);
+      // The program could not start (ENOENT, EACCES: a string code) means no
+      // dialog here; a non-zero exit from one that ran is a cancel.
+      resolve(typeof err?.code === 'string' ? undefined : null);
+    });
+  });
+}
+
+/** Files under `root` for the fallback picker, nearest first, at most `limit`. */
+export async function projectFiles(root, limit = 200) {
+  const found = [];
+  const queue = [''];
+  while (queue.length && found.length < limit) {
+    const dir = queue.shift();
+    const entries = await fs.readdir(path.join(root, dir), { withFileTypes: true }).catch(() => []);
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const rel = path.join(dir, e.name);
+      if (e.isDirectory()) { if (!SKIP.has(e.name) && !e.name.startsWith('.')) queue.push(rel); }
+      else if (e.isFile() && found.length < limit) found.push(rel);
+    }
+  }
+  return found;
+}
+
+/**
+ * Read chosen files into what a request carries.
+ * Returns { images: [dataUrl], text: string to append to the request, notes: [line for the user] }.
+ */
+export async function loadAttachments(files) {
+  const images = [];
+  const blocks = [];
+  const notes = [];
+
+  for (const file of files) {
+    const name = path.basename(file);
+    let buf;
+    try {
+      buf = await fs.readFile(file);
+    } catch {
+      notes.push(`could not read ${name} — skipped`);
+      continue;
+    }
+
+    const kind = IMAGE[path.extname(name).slice(1).toLowerCase()];
+    if (kind) {
+      if (buf.length > MAX_IMAGE_BYTES) { notes.push(`${name} is over 10 MB — skipped`); continue; }
+      images.push(`data:image/${kind};base64,${buf.toString('base64')}`);
+      notes.push(`attached ${name}`);
+      continue;
+    }
+
+    if (buf.subarray(0, 8192).includes(0)) {
+      notes.push(`${name} is not a picture or a text file — skipped`);
+      continue;
+    }
+    if (buf.length > MAX_TEXT_BYTES) { notes.push(`${name} is over 100 KB of text — skipped`); continue; }
+    const text = buf.toString('utf8').trimEnd();
+    // A fence longer than any run of backticks inside, so the file cannot close it early.
+    const fence = '`'.repeat(Math.max(3, ...(text.match(/`+/g) ?? []).map((run) => run.length + 1)));
+    blocks.push(`Reference file ${name}, attached by the user:\n${fence}\n${text}\n${fence}`);
+    notes.push(`attached ${name}`);
+  }
+
+  return { images, text: blocks.length ? `\n\n${blocks.join('\n\n')}` : '', notes };
+}

package/src/core/loop.js

@@ -52,7 +52,8 @@ import { serversReadySince } from '../tools/shell.js';
 import { formatDuration } from '../ui/activity.js';
 import { MAX_FILE_OUTPUT } from '../tools/shared.js';
 import { openInBrowser } from './opener.js';
-import { withScope } from './scope.js';
+import { withScope, isNoise } from './scope.js';
+import { chooseFile, projectFiles, loadAttachments } from './attach.js';
 import { runDoctor } from './doctor.js';
 import { JS_LOGIC } from './jslogic.js';
 import { deploy } from '../tools/deploy.js';
@@ -593,6 +594,11 @@ function systemPrompt({ cwd, skills, mode, check, map, memory }) {
     '',
     '## How to work',
     '',
+    'BUILD ONLY WHEN ASKED. Make or change an app only when the message asks for one.',
+    'A greeting, a question, a single word, or anything unclear gets a short plain',
+    'answer - or one question back about what they would like - never an app. "What',
+    'can you do?" is answered in words; "make a quiz app" is built.',
+    '',
     'AN APP THAT IS AWKWARD TO USE IS NOT FINISHED. Before you call it done, look at',
     'what you built as someone using it for the first time: is the button inside its',
     'field or sitting on top of it, is there room to breathe between things, does the',
@@ -1021,6 +1027,7 @@ export class Agent {
         }
       };
       this.ui.onModeChange = () => this.showHeader({ clear: false });
+      this.ui.onAttach = () => { this.attachFile().catch(() => {}); };
     }
 
     for (const problem of this.skills.problems ?? []) {
@@ -1124,6 +1131,15 @@ export class Agent {
         continue;
       }
 
+      // "+" on its own is the "+ file" button typed — the way to it on Windows,
+      // where the terminal sends no clicks. Other symbols alone are not a request:
+      // a live "+" was built into a calculator nobody asked for.
+      if (input === '+' && this.ui.addAttachment) { await this.attachFile(); continue; }
+      if (isNoise(input)) {
+        this.ui.note('Say what you would like to build or ask. To add a picture or file, type + or press ctrl+o.');
+        continue;
+      }
+
       try {
         await this.turn(input);
       } catch (err) {
@@ -1232,12 +1248,18 @@ export class Agent {
     forgetReviews(); // a new request: its apps get a fresh design review
     setRequest(input); // create_app checks this before choosing a starter
     const images = await this.attachImages(input);
+    // Files added with the "+ file" button: pictures go as pictures, text as reference.
+    const added = await loadAttachments(this.ui.takeAttachments?.() ?? []);
+    for (const line of added.notes) this.ui.note(line);
+    images.push(...added.images);
     // The skill goes in ahead of the request, so the request is the last
     // thing the model reads. After it, a page of house rules was what the
     // model answered: asked for a dark mode toggle on its second turn, a live
     // run re-read two files and repeated its first turn's summary instead.
     this.autoLoad(input);
-    const request = images.length ? { role: 'user', content: input, images } : { role: 'user', content: input };
+    const request = images.length
+      ? { role: 'user', content: input + added.text, images }
+      : { role: 'user', content: input + added.text };
     this.push(request);
 
     if (!this.session.title || this.session.title === 'Untitled') {
@@ -1251,7 +1273,7 @@ export class Agent {
     // Nothing to look up in an empty folder, so those tools do not go out with
     // the request. Decided per turn: the moment there is code, they are back.
     this.fresh = !hasCode(this.map);
-    request.content = withScope(input, { fresh: this.fresh });
+    request.content = withScope(input) + added.text;
     this.wantsWeb = WANTS_WEB.test(input);
     await this.persist();
 
@@ -1784,6 +1806,27 @@ export class Agent {
     if (this.openInBrowser(server.url)) this.ui.note(`Opened ${server.url} in your browser`);
   }
 
+  /**
+   * The "+ file" button: choose a file with the computer's own dialog — or,
+   * where there is none, from the project's files — to go with the next message.
+   */
+  async attachFile() {
+    if (this.attaching) return; // a second click while the dialog is open
+    this.attaching = true;
+    try {
+      let file = await chooseFile();
+      if (file === undefined) {
+        const files = await projectFiles(this.cwd);
+        if (!files.length) { this.ui.note('no files in this folder to add'); return; }
+        const index = await this.ui.pick(files, { hint: 'enter to add · esc to cancel' });
+        file = Number.isInteger(index) ? path.join(this.cwd, files[index]) : null;
+      }
+      if (file) this.ui.addAttachment(path.resolve(this.cwd, file));
+    } finally {
+      this.attaching = false;
+    }
+  }
+
   /** Show a URL or a page in the project in the desktop browser (see opener.js). UCODE_OPEN=0 turns it off. */
   openInBrowser(target) {
     if (!this.full || process.env.UCODE_OPEN === '0') return false;
@@ -3005,7 +3048,7 @@ ${out.content}` });
     }
     this.ui.blank();
     this.ui.write(dim('  /models, /session and /sessions do the same as /model and /resume.'));
-    this.ui.write(dim('  ctrl+b swaps plan and build · esc stops a running turn · ctrl+d quits'));
+    this.ui.write(dim('  ctrl+b swaps plan and build · + file (or ctrl+o) adds a picture or file · esc stops a running turn · ctrl+d quits'));
     this.ui.blank();
   }
 

package/src/core/scope.js

@@ -13,11 +13,30 @@ export const SCOPE_NOTE =
   'for - no extra views or tools such as timers, calendars, kanban boards, analytics, stats or an ' +
   'editor for making your own, unless the request names them.)';
 
-/** A request that may be for a new app. Loose on purpose: the note it adds says "if". */
-export const BUILD_ASK =
-  /\b(?:make|build|create|design|code|write|generate|develop)\b|\bi\s+(?:want|need)\b|\b(?:app|game|website|site|page|tracker|calculator|quiz)\b/i;
+/**
+ * A request for something to be built: a making word, then a thing to make.
+ *
+ * It used to fire on any message in an empty folder, and on a bare "app" or
+ * "make". A user who typed "+" in their home folder got the note, and the
+ * model took it as a request and built a calculator nobody asked for.
+ */
+const MAKE = String.raw`\b(?:make|build|create|design|generate|develop|code)\b`;
+const THING = String.raw`\b(?:apps?|games?|website|site|page|tracker|calculator|quiz|tool|dashboard|list|timer|stopwatch|clock|form|portfolio|planner|converter|board|tic[- ]?tac[- ]?toe|snake|sudoku)\b`;
+const BUILDS = [
+  new RegExp(`${MAKE}\\s+(?:me\\s+|us\\s+)?(?:an?|some|my|our)\\s`, 'i'),   // make a stopwatch, build me a …
+  new RegExp(`${MAKE}[^.?!\\n]{0,60}?${THING}`, 'i'),                           // make tic tac toe, create the quiz page
+  /\bi\s+(?:want|need)\s+(?:a|an)\s+\S+/i,                                    // i want a homework tracker
+];
+/** Asking, not telling: "what can you make?", "how does it work". */
+const QUESTION = /\?\s*$|^\s*(?:what|how|why|when|where|who|which|can|could|does|do|is|are|should|would)\b/i;
 
-/** The request as the model sees it: one in an empty folder, or shaped like a build, carries the note. */
-export function withScope(input, { fresh = false } = {}) {
-  return fresh || BUILD_ASK.test(input) ? `${input}\n\n${SCOPE_NOTE}` : input;
+/** Does this message ask for something to be built? Never for a question. */
+export const asksToBuild = (input) => !QUESTION.test(input) && BUILDS.some((re) => re.test(input));
+
+/** The request as the model sees it: one that asks for an app carries the note. */
+export function withScope(input) {
+  return asksToBuild(input) ? `${input}\n\n${SCOPE_NOTE}` : input;
 }
+
+/** A message with no letters or digits in it ("+", "?", "...") — nothing to answer or build. */
+export const isNoise = (input) => !/[\p{L}\p{N}]/u.test(String(input ?? ''));

package/src/tools/scaffold.js

@@ -67,6 +67,24 @@ export function normaliseFiles(files) {
   });
 }
 
+/**
+ * Every file passed to create_app belongs in the app's folder.
+ *
+ * Traced: a build from a sketch passed "index.html", "style.css" and
+ * "main.js" with no folder. They landed beside the app, the folder kept the
+ * blank starter, and nothing was checked or handed over. A path already under
+ * the folder, absolute, or reaching out with .. is left as it was.
+ */
+export function intoFolder(files, folder) {
+  const prefix = `${folder}/`;
+  return files.map((f) => {
+    if (!f || typeof f.path !== 'string') return f;
+    const p = path.posix.normalize(f.path.replace(/\\/g, '/'));
+    if (path.isAbsolute(p) || p.startsWith('..') || p.startsWith(prefix)) return f;
+    return { ...f, path: prefix + p };
+  });
+}
+
 /** What each starter is for, so the choice is made on purpose. */
 export const TEMPLATE_NOTES = {
   'next-shadcn': 'Next.js, TypeScript, Tailwind and shadcn/ui. For anything with routes, data or many components.',
@@ -431,7 +449,8 @@ export async function createApp({ folder, name, description, template = 'plain-h
   // The app's own files, written in this same call. Two round trips become
   // one, and round trips are nearly all of the time a build takes.
   // Next.js only: paths that have missed src/ are corrected before they land.
-  const placed = template === 'next-shadcn' ? placeForNext(given, path.basename(target.abs)) : { files: given, moved: [] };
+  const inFolder = intoFolder(given, target.show);
+  const placed = template === 'next-shadcn' ? placeForNext(inFolder, path.basename(target.abs)) : { files: inFolder, moved: [] };
   const mine = placed.files;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
   const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));

package/src/ui/screen.js

@@ -40,7 +40,7 @@ import {
   theme, blue, sky, deep, dim, edge, ADDED, REMOVED, BANNER, BANNER_WIDTH, SPINNER,
   boxTop, boxBottom, boxRow, visLen, padVis, clip, wrapAnsi,
   shortenPath, asLabel, ensureColour, planLine, bare, narration, narrationMark, groupKind, groupLabel, groupTarget, runLine, planRows, tidyReply, trimAnswer,
-  bannerPaint, RAIL, modeChip, asNarrationLine } from './theme.js';
+  bannerPaint, RAIL, modeChip, ADD_CHIP, asNarrationLine } from './theme.js';
 import { FRAME_MS, spinnerGlyph, formatDuration, doneLine, workingLine, bannerSweep, SWEEP_MS } from './activity.js';
 import { gitBranch } from '../core/git.js';
 import { renderer, render } from './markdown.js';
@@ -209,6 +209,12 @@ export class Screen {
     // the chip is clickable wherever the terminal forwards clicks.
     this.mode = 'build';
     this.chipTo = 0;
+    // The "+ file" button: its columns on the status row, and the files it has
+    // added so far, which go with the next message. Ctrl+O does the same.
+    this.plusFrom = 0;
+    this.plusTo = 0;
+    this.attachments = [];
+    this.onAttach = null;
     this.onInterrupt = null;
     this.onModeChange = null;
     this.spinTimer = null;
@@ -802,7 +808,7 @@ export class Screen {
       ['dir', value(shortenPath(this.facts.cwd ?? this.cwd, room - 10))],
       branch && ['branch', value(branch)],
       VERSION && ['version', value(this.facts.update ? `${VERSION} → ${this.facts.update} next start` : VERSION)],
-      ['keys', value('/help · esc interrupts · ctrl+b plan')],
+      ['keys', value('/help · esc interrupts · ctrl+b plan · ctrl+o file')],
     ].filter(Boolean).slice(0, BANNER.length - 1);
 
     while (facts.length < BANNER.length - 1) facts.push(['', '']);
@@ -980,7 +986,7 @@ export class Screen {
   statusRow(width = this.width()) {
     const inner = width - 2;             // the space between the two borders
     const chip = this.modeChip();
-    const left = ` ${chip}  ${chalk.white(this.model || '—')}`;
+    const left = ` ${chip}  ${ADD_CHIP}  ${chalk.white(this.model || '—')}`;
 
     // How long the turn has taken, back in the box beside the other two facts
     // about the session. It is not on the live line: that line says what is
@@ -993,9 +999,13 @@ export class Screen {
 
     // Where a click on the bottom row still counts as hitting the mode chip.
     this.chipTo = 2 + visLen(chip);
+    this.plusFrom = this.chipTo + 3;                     // after the two spaces
+    this.plusTo = this.plusFrom + visLen(ADD_CHIP) - 1;
 
     const between = Math.max(1, inner - visLen(left) - visLen(right));
-    const middle = this.flashText ? dim(clip(this.flashText, between - 2)) : '';
+    const files = this.attachments.map((f) => path.basename(f)).join(', ');
+    const middle = this.flashText ? dim(clip(this.flashText, between - 2))
+      : files ? sky(clip(`+ ${files}`, between - 2)) : '';
 
     const tail = middle ? `${middle}   ` : '';
     const pad = Math.max(1, inner - visLen(left) - visLen(tail) - visLen(right));
@@ -1417,11 +1427,29 @@ export class Screen {
     if (this.welcoming()) {
       const g = this.welcomeGeometry();
       const statusRow = g.boxTop + g.inputRows + 3;          // 1-based
-      if (row === statusRow && col > g.left + 1 && col <= g.left + this.chipTo) this.toggleMode();
+      if (row !== statusRow) return;
+      if (col > g.left + 1 && col <= g.left + this.chipTo) this.toggleMode();
+      else if (col >= g.left + this.plusFrom && col <= g.left + this.plusTo) this.onAttach?.();
       return;
     }
-    // The mode chip, at the left of the bottom row.
-    if (row === this.rows - 1 && col >= 2 && col <= this.chipTo) this.toggleMode();
+    // The mode chip and the "+ file" button, at the left of the bottom row.
+    if (row !== this.rows - 1) return;
+    if (col >= 2 && col <= this.chipTo) this.toggleMode();
+    else if (col >= this.plusFrom && col <= this.plusTo) this.onAttach?.();
+  }
+
+  /** A file chosen with "+ file", to go with the next message. */
+  addAttachment(file) {
+    if (!this.attachments.includes(file)) this.attachments.push(file);
+    this.render();
+  }
+
+  /** The files for the message being sent; the button starts empty again. */
+  takeAttachments() {
+    const files = this.attachments;
+    this.attachments = [];
+    this.render();
+    return files;
   }
 
   onKey(key) {
@@ -1453,7 +1481,10 @@ export class Screen {
           this.history.unshift(text);
           // Answers to a y/N or a numbered pick are not messages, so they are
           // not echoed: the prompt reports its own outcome.
-          if (!this.pendingPrompt) this.userMessage(text);
+          if (!this.pendingPrompt) {
+            this.userMessage(text);
+            for (const f of this.attachments) this.push(dim(`  + ${path.basename(f)}`));
+          }
         }
         this.render();
         this.submit(text);
@@ -1481,7 +1512,12 @@ export class Screen {
         this.toggleMode();
         return;
 
-      case '\x15':  // ctrl+u — clear the line
+      case '\x0f':  // ctrl+o — the "+ file" button, for terminals that send no clicks
+        this.onAttach?.();
+        return;
+
+      case '\x15':  // ctrl+u — clear the line; on an empty line, the attached files
+        if (!this.buffer) this.attachments = [];
         this.buffer = this.buffer.slice(this.cursor);
         this.cursor = 0;
         break;

package/src/ui/theme.js

@@ -127,6 +127,9 @@ export const PLAN_CHIP = chalk.bgHex('#24344f').hex('#8fbcff').bold;
 export const modeChip = (mode) =>
   mode === 'plan' ? PLAN_CHIP(' PLAN ') : BUILD_CHIP(' BUILD ');
 
+/** The "+ file" button beside the mode chip, in the quieter of the two chip styles. */
+export const ADD_CHIP = PLAN_CHIP(' + file ');
+
 /** The spinner. Braille dots, because they animate in place without jitter. */
 export const SPINNER = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];