ucode-agent 1.6.0 → 1.7.0

package/src/core/tests.js

@@ -0,0 +1,86 @@
+/**
+ * tests.js — running the tests a change actually affects.
+ *
+ * A project's whole suite is too slow to run after every edit, and running
+ * nothing means the model learns a change was wrong from the user rather than
+ * from the code. Both vitest and jest can be asked which tests reach a given
+ * file and run only those, which is usually a second or two.
+ *
+ * Nothing is installed to make this work. If the project has no test runner,
+ * or has one that cannot answer "which tests cover this file", the checks
+ * stay as they were: this adds a signal where one is available, and is silent
+ * where it is not.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+const has = (deps, name) => Boolean(deps[name]);
+
+/** A file that is itself a test, and so is its own related test. */
+export const isTestFile = (rel) =>
+  /(?:^|[\\/])(?:__tests__|tests?)[\\/]/.test(rel) || /\.(?:test|spec)\.[cm]?[jt]sx?$/i.test(rel) ||
+  /(?:^|[\\/])test_[^\\/]+\.py$/i.test(rel) || /_test\.py$/i.test(rel);
+
+/**
+ * Which runner this project uses, read from its package.json. Only runners
+ * that can select tests by the file they cover are worth naming here.
+ */
+export async function testRunnerFor(dir) {
+  const raw = await fs.readFile(path.join(dir, 'package.json'), 'utf8').catch(() => null);
+  if (raw) {
+    let pkg;
+    try { pkg = JSON.parse(raw); } catch { pkg = null; }
+    if (pkg) {
+      const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) };
+      const script = String(pkg.scripts?.test ?? '');
+      if (has(deps, 'vitest') || /\bvitest\b/.test(script)) return 'vitest';
+      if (has(deps, 'jest') || /\bjest\b/.test(script)) return 'jest';
+    }
+  }
+  const py = await Promise.all(
+    ['pytest.ini', 'pyproject.toml', 'setup.cfg', 'tox.ini'].map((f) =>
+      fs.access(path.join(dir, f)).then(() => true, () => false))
+  );
+  return py.some(Boolean) ? 'pytest' : null;
+}
+
+/** Quote a path for a shell, and use forward slashes so Windows agrees. */
+const arg = (p) => `"${p.replace(/\\/g, '/')}"`;
+
+/**
+ * The command that runs only the tests reaching these files, or null when
+ * this runner cannot narrow it down.
+ *
+ * pytest has no "which tests cover this file", so it gets the test files from
+ * among those changed — enough to catch a test edited into failing, and
+ * honest about being less than the others.
+ */
+export function relatedCommand(runner, files) {
+  const list = files.filter(Boolean);
+  if (!list.length) return null;
+
+  if (runner === 'vitest') {
+    return `npx --no-install vitest related --run --passWithNoTests ${list.map(arg).join(' ')}`;
+  }
+  if (runner === 'jest') {
+    return `npx --no-install jest --findRelatedTests --passWithNoTests --silent ${list.map(arg).join(' ')}`;
+  }
+  if (runner === 'pytest') {
+    const tests = list.filter(isTestFile);
+    if (!tests.length) return null;
+    return `python -m pytest -q ${tests.map(arg).join(' ')}`;
+  }
+  return null;
+}
+
+/** The failing part of a test run, kept to what a model can act on. */
+export function summariseFailures(runner, output, limit = 40) {
+  const lines = String(output ?? '').split('\n');
+  const interesting = lines.filter((l) =>
+    /^\s*(?:✗|×|✕|FAIL|●|E\s|_{3,}|AssertionError|Expected|Received|at\s)/.test(l) ||
+    /\b\d+ failed\b/i.test(l) || /^FAILED /.test(l)
+  );
+  const kept = (interesting.length ? interesting : lines.filter((l) => l.trim())).slice(0, limit);
+  return kept.join('\n');
+}

package/src/tools/blocks.js

@@ -0,0 +1,117 @@
+/**
+ * blocks.js — pieces of an app that are already right.
+ *
+ * A model writing a table from scratch writes a passable one: no empty state,
+ * no sort, numbers left-aligned, and nothing that works on a phone. It is not
+ * that it cannot do better, it is that doing better costs steps and attention
+ * that belong to the thing being built.
+ *
+ * These are the parts every app needs, written once and carefully: a shell, a
+ * page header, an empty state, a table, a row of stats. They are copied into
+ * the app as ordinary source files for the model to edit, not imported from a
+ * library it cannot change.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ToolFailure } from '../core/failure.js';
+import { resolveIn, guard, result } from './shared.js';
+
+const BLOCKS = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates', 'blocks');
+
+/** What each block is for, and what it needs to be handed. */
+export const CATALOGUE = {
+  'app-shell': {
+    what: 'The frame every page sits in: sidebar on desktop, the same nav behind a button on a phone.',
+    exports: 'AppShell',
+    use: '<AppShell title="Stride" nav={[{ href: "/", label: "Home" }]} current="/">…</AppShell>',
+  },
+  'page-header': {
+    what: 'The top of a page: title, a line about it, and the actions available here.',
+    exports: 'PageHeader',
+    use: '<PageHeader title="Invoices" description="Everything you have billed." actions={<Button>New</Button>} />',
+  },
+  'empty-state': {
+    what: 'What a list looks like before anything is in it, with the one action that fills it.',
+    exports: 'EmptyState',
+    use: '<EmptyState title="No invoices yet" description="They will appear here." actionLabel="New invoice" />',
+  },
+  'data-table': {
+    what: 'A table you can search and sort, with an empty state and numbers aligned right.',
+    exports: 'DataTable, Column',
+    use: '<DataTable rows={rows} columns={[{ key: "name", header: "Name" }, { key: "total", header: "Total", numeric: true }]} />',
+  },
+  'stat-cards': {
+    what: 'The row of numbers at the top of a dashboard, each with what it is measured against.',
+    exports: 'StatCards, Stat',
+    use: '<StatCards stats={[{ label: "Revenue", value: "£12,400", change: 8 }]} />',
+  },
+};
+
+export const BLOCK_NAMES = Object.keys(CATALOGUE);
+
+const listing = () =>
+  BLOCK_NAMES.map((name) => `  ${name} — ${CATALOGUE[name].what}`).join('\n');
+
+/**
+ * Copy a block into an app, or list what there is. The file lands in
+ * src/components/blocks/ and is the app's to edit from then on.
+ */
+export async function addBlock({ name, folder = '.' }) {
+  const wanted = String(name ?? '').trim();
+
+  if (!wanted) {
+    return result(
+      `Blocks you can add, with add_block({ name, folder }):\n\n${listing()}\n\n` +
+      'Each one is copied into the app as a source file you can then edit.',
+      `${BLOCK_NAMES.length} blocks`
+    );
+  }
+
+  if (!CATALOGUE[wanted]) {
+    throw new ToolFailure({
+      kind: 'no_such_block',
+      attempted: `adding the "${wanted}" block`,
+      failed: `There is no block called "${wanted}".`,
+      fix: `Pick one of: ${BLOCK_NAMES.join(', ')}. Call add_block with no name to see what each is for.`,
+    });
+  }
+
+  const target = resolveIn(folder || '.', 'add_block', 'folder');
+  await guard(target, `add the ${wanted} block to ${target.abs}`);
+
+  const source = await fs.readFile(path.join(BLOCKS, `${wanted}.tsx`), 'utf8').catch(() => null);
+  if (source === null) {
+    throw new ToolFailure({
+      kind: 'block_missing',
+      attempted: `adding the "${wanted}" block`,
+      failed: `The ${wanted} block is listed but its file is not installed.`,
+      fix: 'Write the component by hand, or reinstall ucode.',
+    });
+  }
+
+  const rel = path.join('src', 'components', 'blocks', `${wanted}.tsx`);
+  const dest = path.join(target.abs, rel);
+
+  if (await fs.stat(dest).catch(() => null)) {
+    return result(
+      `${rel} is already in ${target.show}; it has been left as it is so your edits survive.\n` +
+      `Import: import { ${CATALOGUE[wanted].exports.split(',')[0].trim()} } from "@/components/blocks/${wanted}";`,
+      'already there'
+    );
+  }
+
+  await fs.mkdir(path.dirname(dest), { recursive: true });
+  await fs.writeFile(dest, source, 'utf8');
+
+  const first = CATALOGUE[wanted].exports.split(',')[0].trim();
+  return result(
+    `Added ${rel} to ${target.show}.\n\n` +
+    `import { ${CATALOGUE[wanted].exports} } from "@/components/blocks/${wanted}";\n\n` +
+    `${CATALOGUE[wanted].use}\n\n` +
+    `It is an ordinary file now — edit it to suit the app rather than working around it. ` +
+    `It uses the shadcn components already in the starter, so nothing needs installing.`,
+    `${first} added`
+  );
+}

package/src/tools/cache.js

@@ -0,0 +1,105 @@
+/**
+ * cache.js — the starter's packages, installed once and reused.
+ *
+ * A new app's `npm install` is a minute of the model waiting on the network
+ * for a tree it has installed a hundred times before. The first install of a
+ * starter is kept in ~/.ucode/cache, keyed by the lockfile, and every app
+ * after that gets it as hard links: the same files on disk under a new name,
+ * so it costs no extra space and finishes in seconds.
+ *
+ * Hard links rather than a junction or a symlink, because Turbopack refuses a
+ * node_modules that points outside the project. Anything that cannot be linked
+ * — another drive, a filesystem without links — is copied instead, and if even
+ * that fails the normal install runs as before.
+ *
+ * A cache entry is only used once its marker file is there, which is written
+ * last: a half-written cache from an interrupted copy is ignored, not used.
+ *
+ * The key is the *starter's* lockfile, never the app's. npm rewrites an app's
+ * package-lock.json as it installs, so keying on that would file the cache
+ * under one name and look it up under another — a cache that never hits and
+ * never says why.
+ */
+
+import { promises as fs } from 'node:fs';
+import { createHash } from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+const MARKER = '.ucode-complete';
+
+/** Written into node_modules by build tools; never worth carrying between apps. */
+const NOT_WORTH_KEEPING = new Set(['.cache', '.vite', '.turbo']);
+
+export const cacheRoot = (home = os.homedir()) => path.join(home, '.ucode', 'cache');
+
+/** Where this starter's install lives, given its lockfile text. */
+export function slotFor(template, lockText, home) {
+  const hash = createHash('sha1').update(String(lockText ?? '')).digest('hex').slice(0, 12);
+  return path.join(cacheRoot(home), `${template}-${hash}`);
+}
+
+/**
+ * Copy a tree as hard links, falling back to real copies where linking fails.
+ * `skip` names top-level entries to leave behind.
+ */
+export async function linkTree(from, to, skip = null) {
+  let files = 0;
+  const walk = async (src, dst, top) => {
+    await fs.mkdir(dst, { recursive: true });
+    for (const entry of await fs.readdir(src, { withFileTypes: true })) {
+      if (top && skip?.has(entry.name)) continue;
+      const a = path.join(src, entry.name);
+      const b = path.join(dst, entry.name);
+      if (entry.isDirectory()) {
+        await walk(a, b, false);
+      } else if (entry.isSymbolicLink()) {
+        const target = await fs.readlink(a).catch(() => null);
+        if (target) await fs.symlink(target, b).catch(() => fs.copyFile(a, b).catch(() => {}));
+      } else {
+        await fs.link(a, b).catch(() => fs.copyFile(a, b));
+        files++;
+      }
+    }
+  };
+  await walk(from, to, true);
+  return files;
+}
+
+/**
+ * Put the cached packages into the app, if this starter has been installed
+ * before. Returns how many files were linked, or 0 when there is no cache.
+ */
+export async function restore(appDir, template, lockText, { home } = {}) {
+  if (!lockText) return 0;
+  const slot = slotFor(template, lockText, home);
+  if (!(await fs.stat(path.join(slot, MARKER)).catch(() => null))) return 0;
+  const target = path.join(appDir, 'node_modules');
+  if (await fs.stat(target).catch(() => null)) return 0; // already installed
+  try {
+    return await linkTree(path.join(slot, 'node_modules'), target);
+  } catch {
+    await fs.rm(target, { recursive: true, force: true }).catch(() => {});
+    return 0; // a partial restore is worse than none: let npm do it
+  }
+}
+
+/**
+ * Keep this app's node_modules as the cache for its starter, so the next app
+ * starts from it. Runs after a successful install and never throws.
+ */
+export async function populate(appDir, template, lockText, { home } = {}) {
+  try {
+    if (!lockText) return false;
+    const slot = slotFor(template, lockText, home);
+    if (await fs.stat(path.join(slot, MARKER)).catch(() => null)) return false;
+    const from = path.join(appDir, 'node_modules');
+    if (!(await fs.stat(from).catch(() => null))) return false;
+    await fs.rm(slot, { recursive: true, force: true }).catch(() => {});
+    await linkTree(from, path.join(slot, 'node_modules'), NOT_WORTH_KEEPING);
+    await fs.writeFile(path.join(slot, MARKER), `${template}\n${new Date().toISOString()}\n`);
+    return true;
+  } catch {
+    return false; // the cache is an optimisation; never let it break a build
+  }
+}