ucode-agent 1.5.0 → 1.6.0

package/README.md

@@ -125,6 +125,55 @@ components, light/dark mode, toasts and a considered theme, already known to
 build. The copy takes under a second, and its install runs in the background
 while the model writes the first components.
 
+**Built to be fast, and measured.** A traced build of a small Next.js app went
+from 17 minutes and 116 model steps to about 6 minutes and 25 steps, by fixing
+where the time actually went:
+
+- Edits return the file as it now stands, so the model does not re-read it.
+- Files written more than a few steps ago stop being re-sent in full; the
+  conversation stays small, so every step answers faster.
+- A file-write whose JSON is malformed — a missing comma, an unescaped quote in
+  the code, raw line breaks — is repaired instead of thrown away with all its
+  output.
+- Every write is parsed on the spot, so a syntax error comes back in the same
+  step rather than a minute later from a failed build.
+- A failed build that is missing a component or package says exactly which
+  command fixes it.
+- The starter is the shadcn models already know (Radix), so the code they write
+  compiles the first time.
+
+`UCODE_TRACE=1` writes every model call and tool, with its duration, to
+`~/.ucode/trace.jsonl`.
+
+**Deploy in one line.** Say "deploy it", or type `/deploy [folder]`, and the app
+goes live on Vercel. ucode picks a short project name that fits the app and is
+free (`food-iq`, else `food-iq-app`…), copies the app's `.env` keys to Vercel as
+encrypted variables, refuses code with a secret written into it (and says how to
+move it to a server route), and gives you the link. Deploying again updates the
+same link. Needs a token from vercel.com/account/tokens in `~/.ucode/.env` as
+`VERCEL_TOKEN=...`.
+
+**A look for every app.** `create_app` takes a design preset — ocean, grove,
+sunset, graphite, violet or citrus — each a full light and dark palette with its
+own font, so apps stop looking like the same default blue.
+
+**It notices when it is going round in circles.** The same failing edit, an edit
+that changes nothing, or a build failing on the same errors three times gets a
+firm, specific note; if that does not work, the turn moves to another model.
+
+**It never dies at the daily limit.** When the free daily limit runs out mid-build,
+ucode counts down to the reset and carries on by itself.
+
+**You can see it working.** The status row shows the current step with a light
+sweeping across it, the step count and the time, and each answer ends with
+`✓ Done in 6m 12s · 25 steps`. When a dev server comes up, the app opens in your
+browser (`UCODE_OPEN=0` turns that off).
+
+**`/stats` and `ucode doctor`.** `/stats` shows the session's time, steps, tokens,
+files and builds. `ucode doctor` (or `/doctor`) checks Node, npm, git, the API
+key and today's free requests left, the browser, the Vercel token and the
+version, with the fix for anything wrong.
+
 **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
@@ -141,7 +190,10 @@ to download — at 375px and 1440px. It reports console errors, failed requests,
 content that spills off a phone screen, broken images and unlabeled controls,
 saves screenshots to `.ucode/screenshots`, and has Nemotron Nano Omni review them
 the way a designer would. The model fixes what it finds before calling the app
-done.
+done. Both widths load at once, and the designer review — the slow part — runs
+on the first look at an app in each request and is skipped, not waited on, when
+the vision model is busy. The look after the fixes re-runs only the fast checks:
+a few seconds.
 
 **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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -45,8 +45,10 @@
   "author": "om dixit",
   "license": "ISC",
   "dependencies": {
+    "@babel/parser": "^7.29.8",
     "chalk": "^6.0.0",
     "dotenv": "^17.4.2",
+    "jsonrepair": "^3.15.0",
     "marked": "^15.0.12",
     "marked-terminal": "^7.3.0",
     "openai": "^7.4.0",

package/skills/ui-ux/SKILL.md

@@ -286,8 +286,8 @@ because it was first to hand means you were not deciding.
 Run it (`npm run dev` starts in the background and returns the URL), then call
 `look_at_app` with that URL. It opens the app in a real browser at 375px and
 1440px, reports console errors, failed requests, overflow, broken images and
-unlabeled controls, and returns a designer's review of the screenshots. Fix what
-it finds and look again. Then check:
+unlabeled controls, and the first look returns a designer's review of the
+screenshots. Fix what it finds in one pass and look once more. Then check:
 
 1. **375px wide** — no horizontal scroll, nothing overlapping or clipped. If you
    wrote no responsive rules at all, you have not done this.

package/src/core/doctor.js

@@ -0,0 +1,122 @@
+/**
+ * doctor.js — `ucode doctor` and /doctor: is everything ucode needs working?
+ *
+ * Every check runs at once and each has a short deadline, so the whole report
+ * takes a few seconds. A problem comes with the one thing that fixes it.
+ * Secret values are never printed — only whether they are there and accepted.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { theme, dim, blue } from '../ui/theme.js';
+import { VERSION } from './version.js';
+import { DEFAULT_MODEL, ENV_FILE } from './provider.js';
+import { newer } from './updater.js';
+
+const DEADLINE = 6000;
+const timed = (ms = DEADLINE) => AbortSignal.timeout(ms);
+
+function version(cmd) {
+  const r = spawnSync(cmd, ['--version'], { encoding: 'utf8', shell: process.platform === 'win32', timeout: 5000 });
+  return r.status === 0 ? String(r.stdout).trim().split('\n')[0] : null;
+}
+
+async function checkKey() {
+  const key = process.env.UCODE_API_KEY || process.env.OPENROUTER_API_KEY;
+  if (!key) return { ok: false, name: 'API key', detail: 'not set', fix: `Add UCODE_API_KEY=... to ${ENV_FILE}` };
+  try {
+    const r = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${key}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model: DEFAULT_MODEL, messages: [{ role: 'user', content: 'ok' }], max_tokens: 1 }),
+      signal: timed(),
+    });
+    if (r.status === 401 || r.status === 403) return { ok: false, name: 'API key', detail: 'rejected', fix: 'Check the key for typos, or make a new one' };
+    const body = await r.json().catch(() => ({}));
+    const meta = body?.error?.metadata?.headers ?? {};
+    const left = r.headers.get('x-ratelimit-remaining') ?? meta['X-RateLimit-Remaining'];
+    const reset = Number(r.headers.get('x-ratelimit-reset') ?? meta['X-RateLimit-Reset']);
+    if (r.status === 429 && /per[- ]day|daily/i.test(`${body?.error?.message} ${body?.error?.metadata?.limit_source}`)) {
+      const at = Number.isFinite(reset) ? new Date(reset).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : 'tomorrow';
+      return { ok: false, name: 'Requests today', detail: 'daily free limit used up', fix: `It resets at ${at}; adding credit raises the limit` };
+    }
+    return { ok: true, name: 'API key', detail: left != null ? `works · ${left} free requests left today` : 'works' };
+  } catch (err) {
+    return { ok: false, name: 'API key', detail: `could not check (${err.name === 'TimeoutError' ? 'no answer' : err.message})`, fix: 'Check your internet connection' };
+  }
+}
+
+async function checkVercel() {
+  const token = process.env.VERCEL_TOKEN;
+  if (!token) return { ok: null, name: 'Vercel', detail: 'no token — /deploy needs one', fix: `vercel.com/account/tokens → Create Token, then add VERCEL_TOKEN=... to ${ENV_FILE}` };
+  try {
+    const r = await fetch('https://api.vercel.com/v2/user', { headers: { Authorization: `Bearer ${token}` }, signal: timed() });
+    if (!r.ok) return { ok: false, name: 'Vercel', detail: 'token rejected', fix: 'Make a new token at vercel.com/account/tokens' };
+    const j = await r.json();
+    return { ok: true, name: 'Vercel', detail: `ready to deploy as ${j.user?.username ?? 'you'}` };
+  } catch {
+    return { ok: false, name: 'Vercel', detail: 'could not reach Vercel', fix: 'Check your internet connection' };
+  }
+}
+
+async function checkBrowser() {
+  try {
+    const { chromium } = await import('playwright-core');
+    for (const channel of ['msedge', 'chrome']) {
+      try {
+        const b = await chromium.launch({ channel, headless: true, timeout: 8000 });
+        await b.close();
+        return { ok: true, name: 'Browser', detail: `${channel === 'msedge' ? 'Edge' : 'Chrome'} — look_at_app can see your apps` };
+      } catch { /* try the next one */ }
+    }
+  } catch { /* playwright-core missing */ }
+  return { ok: false, name: 'Browser', detail: 'no Edge or Chrome found', fix: 'Install Google Chrome or Microsoft Edge' };
+}
+
+async function checkVersion() {
+  try {
+    const r = await fetch('https://registry.npmjs.org/ucode-agent/latest', { signal: timed() });
+    const latest = (await r.json()).version;
+    return newer(latest, VERSION)
+      ? { ok: null, name: 'ucode', detail: `${VERSION} · ${latest} is out`, fix: 'It updates itself on the next start, or: npm install -g ucode-agent' }
+      : { ok: true, name: 'ucode', detail: `${VERSION} · up to date` };
+  } catch {
+    return { ok: true, name: 'ucode', detail: VERSION };
+  }
+}
+
+function checkTools() {
+  const [major] = process.versions.node.split('.').map(Number);
+  const out = [
+    major >= 22
+      ? { ok: true, name: 'Node', detail: process.versions.node }
+      : { ok: false, name: 'Node', detail: process.versions.node, fix: 'Install Node 22 or newer from nodejs.org' },
+  ];
+  const npm = version('npm');
+  out.push(npm ? { ok: true, name: 'npm', detail: npm } : { ok: false, name: 'npm', detail: 'not found', fix: 'Reinstall Node, which includes npm' });
+  const git = version('git');
+  out.push(git ? { ok: true, name: 'git', detail: git.replace(/^git version /, '') } : { ok: null, name: 'git', detail: 'not found', fix: 'Optional — install git to keep history of your apps' });
+  const cache = path.join(os.homedir(), '.ucode', 'cache');
+  if (existsSync(cache)) out.push({ ok: true, name: 'Starter cache', detail: `${readdirSync(cache).length} ready` });
+  return out;
+}
+
+/** Run every check; returns the lines to print. */
+export async function runDoctor() {
+  const results = [
+    ...checkTools(),
+    ...(await Promise.all([checkKey(), checkVercel(), checkBrowser(), checkVersion()])),
+  ];
+  const width = Math.max(...results.map((r) => r.name.length));
+  const lines = ['', `  ${blue('ucode doctor')}`];
+  for (const r of results) {
+    const mark = r.ok === true ? theme.ok('✓') : r.ok === false ? theme.error('✗') : theme.warn('!');
+    lines.push(`  ${mark} ${r.name.padEnd(width)}  ${r.detail}`);
+    if (r.fix && r.ok !== true) lines.push(`    ${' '.repeat(width)}  ${dim(`→ ${r.fix}`)}`);
+  }
+  const bad = results.filter((r) => r.ok === false).length;
+  lines.push('', bad ? `  ${bad} thing${bad === 1 ? '' : 's'} to fix` : `  ${theme.ok('All good')}`, '');
+  return lines;
+}