ucode-agent 1.6.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",
@@ -53,5 +53,8 @@
     "marked-terminal": "^7.3.0",
     "openai": "^7.4.0",
     "playwright-core": "^1.63.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
   }
 }

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

package/src/core/login.js

@@ -0,0 +1,59 @@
+/**
+ * login.js — putting the API key somewhere ucode will always find it.
+ *
+ * A key in a project's .env is a key you set up again in the next folder, and
+ * on the next machine. This writes it once to ~/.ucode/.env, which every
+ * project on the machine reads, so setting ucode up somewhere new — a borrowed
+ * laptop, a machine you are demonstrating on — is one command.
+ *
+ * The file is written with owner-only permissions, and the existing contents
+ * are kept: a key is replaced in place rather than by rewriting the file.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { ENV_FILE } from './provider.js';
+
+const NAME = 'OPENROUTER_API_KEY';
+
+/** A plausible OpenRouter key, so a typo is caught here and not mid-answer. */
+export function looksLikeKey(key) {
+  return typeof key === 'string' && /^sk-[A-Za-z0-9_-]{20,}$/.test(key.trim());
+}
+
+/** Put `key` in the machine-wide env file, keeping whatever else is in it. */
+export function withKey(existing, key) {
+  const line = `${NAME}=${key}`;
+  const lines = String(existing ?? '').split('\n');
+  let replaced = false;
+  const out = lines.map((l) => {
+    if (new RegExp(`^\\s*(?:export\\s+)?${NAME}\\s*=`).test(l)) {
+      replaced = true;
+      return line;
+    }
+    return l;
+  });
+  if (!replaced) {
+    if (out.length && out[out.length - 1].trim() !== '') out.push('');
+    out.splice(out.length - 1, 0, line);
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n');
+}
+
+export async function saveKey(key) {
+  const trimmed = String(key ?? '').trim();
+
+  if (!trimmed) {
+    return `  Usage: ucode login <key>\n\n  Get one free at https://openrouter.ai/keys\n  It is saved to ${ENV_FILE} and used by every project on this machine.`;
+  }
+  if (!looksLikeKey(trimmed)) {
+    return `  That does not look like an OpenRouter key — they start with "sk-".\n  Get one at https://openrouter.ai/keys`;
+  }
+
+  const existing = await fs.readFile(ENV_FILE, 'utf8').catch(() => '');
+  await fs.mkdir(path.dirname(ENV_FILE), { recursive: true });
+  await fs.writeFile(ENV_FILE, withKey(existing, trimmed), { encoding: 'utf8', mode: 0o600 });
+  await fs.chmod(ENV_FILE, 0o600).catch(() => {});
+
+  return `  Key saved to ${ENV_FILE}\n  Every project on this machine will use it. Run ucode anywhere to start.`;
+}