ucode-agent 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.5.0",
+  "version": "1.7.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,11 +45,16 @@
   "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",
     "playwright-core": "^1.63.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
   }
 }

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;
+}

package/src/core/livelog.js

@@ -0,0 +1,113 @@
+/**
+ * livelog.js — errors from the running app, without being asked.
+ *
+ * A dev server reports a broken import or a thrown render the moment it
+ * happens, into a log nobody is reading. The model finds out much later, from
+ * a build, or from the user saying the page is blank. This reads what the
+ * server has written since the last look and hands back anything that is
+ * actually an error.
+ *
+ * Only new bytes are read, so a server running for an hour costs one small
+ * read. Errors a dev server repeats on every request are reported once, not
+ * once per refresh.
+ */
+
+import { promises as fs } from 'node:fs';
+
+/** Lines that mean something is broken. */
+const ERROR = /(?:^|\s)(?:⨯|✘|ERROR|Error:|TypeError:|ReferenceError:|SyntaxError:|RangeError:)|Failed to compile|Module not found|Cannot find module|Unhandled(?:Promise)?Rejection|ERR_[A-Z_]+|error TS\d+/;
+
+/** Lines that look alarming but are not: warnings, notices, and the ready banner. */
+const NOT_AN_ERROR = /\b(?:warn|warning|deprecat|notice|experimental|✓|ready in|compiled successfully|No errors? found)\b/i;
+
+/** Whatever colour a terminal put on it is not part of the message. */
+const stripAnsi = (s) => s.replace(/\[[0-9;]*[A-Za-z]/g, '');
+
+/**
+ * The error blocks in a chunk of log. An error's first line is the message and
+ * the indented lines under it are its stack, which is where the file is named,
+ * so they come along.
+ */
+export function errorsIn(text) {
+  const lines = stripAnsi(String(text ?? '')).split('\n');
+  const found = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!ERROR.test(line) || NOT_AN_ERROR.test(line)) continue;
+    const block = [line.trimEnd()];
+    // Take the indented continuation, which holds the file and line number.
+    for (let j = i + 1; j < lines.length && block.length < 8; j++) {
+      if (!/^\s+\S/.test(lines[j])) break;
+      block.push(lines[j].trimEnd());
+      i = j;
+    }
+    found.push(block.join('\n').trim());
+  }
+  return found;
+}
+
+/**
+ * What is worth telling the model about, given what it has already been told.
+ * A dev server prints the same failure on every request; it is news once.
+ */
+export function freshErrors(errors, alreadySeen) {
+  const out = [];
+  for (const e of errors) {
+    const key = e.split('\n')[0].replace(/\d+/g, '#').slice(0, 200);
+    if (alreadySeen.has(key)) continue;
+    alreadySeen.add(key);
+    out.push(e);
+  }
+  return out;
+}
+
+/**
+ * Watches each server log from wherever it was last read.
+ *
+ * A log that is deleted or replaced starts again from nothing rather than
+ * throwing; a server's log going away is not worth failing a turn over.
+ */
+export class LogWatch {
+  constructor() {
+    this.at = new Map();   // log path -> bytes already read
+    this.seen = new Set(); // error signatures already reported
+  }
+
+  /** New error text across these logs, or null when everything is quiet. */
+  async since(servers) {
+    const blocks = [];
+    for (const server of servers) {
+      if (!server?.log) continue;
+      const from = this.at.get(server.log) ?? 0;
+      let text = '';
+      try {
+        const { size } = await fs.stat(server.log);
+        if (size < from) { this.at.set(server.log, 0); continue; } // truncated: start over
+        if (size === from) continue;
+        const handle = await fs.open(server.log, 'r');
+        try {
+          const length = Math.min(size - from, 200_000);
+          const buffer = Buffer.alloc(length);
+          await handle.read(buffer, 0, length, size - length);
+          text = buffer.toString('utf8');
+        } finally {
+          await handle.close();
+        }
+        this.at.set(server.log, size);
+      } catch {
+        continue; // the log went away; nothing to report
+      }
+
+      const fresh = freshErrors(errorsIn(text), this.seen);
+      if (fresh.length) blocks.push({ server, errors: fresh });
+    }
+
+    if (!blocks.length) return null;
+
+    return blocks
+      .map(({ server, errors }) =>
+        `The app running at ${server.url ?? server.command ?? 'the dev server'} reported this:\n` +
+        errors.slice(0, 5).join('\n\n'))
+      .join('\n\n');
+  }
+}