ucode-agent 1.5.0 → 1.7.0

package/src/tools/rename.js

@@ -0,0 +1,157 @@
+/**
+ * rename.js — renaming a name everywhere it is that name.
+ *
+ * Most failed edits are a find-and-replace that matched too much: renaming
+ * `id` rewrites `width`, `idle` and every `id` inside a string or a comment,
+ * and the model then spends three steps undoing it. The fix is not a bigger
+ * regular expression — it is to stop treating code as text.
+ *
+ * This walks each file as code: it knows where a string, a template literal
+ * and a comment begin and end, and only renames an identifier sitting in
+ * actual code, whole, not as part of a longer word. That is short of a
+ * parser — it cannot tell two different `user` variables in two scopes apart
+ * — so it reports exactly what it changed and where, and leaves the model to
+ * read the diff. It is the difference between an edit that is usually right
+ * and one that is usually wrong.
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { ToolFailure } from '../core/failure.js';
+import { resolveIn, guard, result, walk } from './shared.js';
+
+const SOURCE = /\.(?:[cm]?[jt]sx?|py)$/i;
+const IDENT = /^[A-Za-z_$][\w$]*$/;
+const wordChar = (c) => c !== undefined && /[\w$]/.test(c);
+
+/**
+ * Rename `from` to `to` in one file's text, skipping strings and comments.
+ * Returns the new text and the 1-based lines that changed.
+ */
+export function renameIn(text, from, to) {
+  const out = [];
+  const lines = [];
+  let line = 1;
+  let i = 0;
+  const n = text.length;
+
+  // Where we are: code, or inside something that is not code.
+  let mode = 'code';
+  let quote = '';
+  // Template literals can hold ${ code }, so the nesting is tracked.
+  const templates = [];
+
+  while (i < n) {
+    const c = text[i];
+    const next = text[i + 1];
+    if (c === '\n') line++;
+
+    if (mode === 'line-comment') {
+      if (c === '\n') mode = 'code';
+      out.push(c); i++; continue;
+    }
+    if (mode === 'block-comment') {
+      if (c === '*' && next === '/') { out.push('*/'); i += 2; mode = 'code'; continue; }
+      out.push(c); i++; continue;
+    }
+    if (mode === 'string') {
+      if (c === '\\') { out.push(c, next ?? ''); i += 2; continue; }
+      if (c === quote) { mode = 'code'; quote = ''; }
+      if (c === '\n' && quote !== '`') { mode = 'code'; quote = ''; } // an unterminated quote
+      out.push(c); i++; continue;
+    }
+    if (mode === 'template') {
+      if (c === '\\') { out.push(c, next ?? ''); i += 2; continue; }
+      if (c === '`') { mode = templates.pop() ?? 'code'; out.push(c); i++; continue; }
+      if (c === '$' && next === '{') { templates.push('template'); mode = 'code'; out.push('${'); i += 2; continue; }
+      out.push(c); i++; continue;
+    }
+
+    // mode === 'code'
+    if (c === '/' && next === '/') { mode = 'line-comment'; out.push('//'); i += 2; continue; }
+    if (c === '/' && next === '*') { mode = 'block-comment'; out.push('/*'); i += 2; continue; }
+    if (c === '#') { mode = 'line-comment'; out.push(c); i++; continue; } // python
+    if (c === '"' || c === "'") { mode = 'string'; quote = c; out.push(c); i++; continue; }
+    if (c === '`') { mode = 'template'; out.push(c); i++; continue; }
+    if (c === '}' && templates.length) { mode = templates.pop(); out.push(c); i++; continue; }
+
+    if (/[A-Za-z_$]/.test(c)) {
+      let j = i;
+      while (j < n && wordChar(text[j])) j++;
+      const word = text.slice(i, j);
+      if (word === from && !wordChar(text[i - 1])) {
+        out.push(to);
+        if (lines[lines.length - 1] !== line) lines.push(line);
+      } else {
+        out.push(word);
+      }
+      i = j;
+      continue;
+    }
+
+    out.push(c);
+    i++;
+  }
+
+  return { text: out.join(''), lines };
+}
+
+/** Rename a name across every source file under a path. */
+export async function renameSymbol({ name, to, path: p = '.' }) {
+  const from = String(name ?? '').trim();
+  const into = String(to ?? '').trim();
+
+  if (!IDENT.test(from) || !IDENT.test(into)) {
+    throw new ToolFailure({
+      kind: 'bad_args',
+      attempted: `renaming ${from || '(nothing)'} to ${into || '(nothing)'}`,
+      failed: 'Both names must be plain identifiers: letters, digits, _ or $, not starting with a digit.',
+      fix: 'To change something that is not an identifier, use edit_file or multi_edit.',
+    });
+  }
+  if (from === into) {
+    throw new ToolFailure({
+      kind: 'bad_args',
+      attempted: `renaming ${from}`,
+      failed: 'The old and new names are the same.',
+      fix: 'Pass the name you want it to become.',
+    });
+  }
+
+  const target = resolveIn(p || '.', 'rename_symbol', 'path');
+  await guard(target, `rename ${from} to ${into} under ${target.abs}`);
+
+  const stat = await fs.stat(target.abs).catch(() => null);
+  const rels = stat?.isFile() ? [''] : (await walk(target.abs, {})).filter((rel) => SOURCE.test(rel));
+
+  const changed = [];
+  let total = 0;
+
+  for (const rel of rels) {
+    const abs = rel ? path.join(target.abs, rel) : target.abs;
+    const before = await fs.readFile(abs, 'utf8').catch(() => null);
+    if (before === null || !before.includes(from)) continue;
+    const { text, lines } = renameIn(before, from, into);
+    if (!lines.length || text === before) continue;
+    await fs.writeFile(abs, text, 'utf8');
+    changed.push({ rel: rel || target.show, lines });
+    total += lines.length;
+  }
+
+  if (!changed.length) {
+    return result(
+      `Nothing to rename: "${from}" does not appear as a name in any code under ${target.show}.\n` +
+      'It may only exist in strings or comments, which are deliberately left alone, or be spelled differently.',
+      'no occurrences'
+    );
+  }
+
+  const shown = changed.slice(0, 40).map((f) => `${f.rel} (${f.lines.length} line${f.lines.length === 1 ? '' : 's'}: ${f.lines.slice(0, 12).join(', ')}${f.lines.length > 12 ? '…' : ''})`);
+  const more = changed.length > shown.length ? `\n[${changed.length - shown.length} more files]` : '';
+
+  return result(
+    `Renamed ${from} to ${into} in ${changed.length} file${changed.length === 1 ? '' : 's'}:\n\n${shown.join('\n')}${more}\n\n` +
+    'Strings and comments were left alone. If the name was meant to change in one of those too, edit it directly.',
+    `${total} line${total === 1 ? '' : 's'} in ${changed.length} file${changed.length === 1 ? '' : 's'}`
+  );
+}

package/src/tools/scaffold.js

@@ -15,7 +15,8 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ToolFailure } from '../core/failure.js';
 import { resolveIn, guard, result } from './shared.js';
-import { packageJsonWritten } from './shell.js';
+import { packageJsonWritten, installIn } from './shell.js';
+import { restore, populate } from './cache.js';
 
 const TEMPLATES = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', '..', 'templates');
 
@@ -64,7 +65,65 @@ async function copyTree(from, to, fill) {
  * @param {string} [o.template]
  * @param {boolean} [o.install]   start the background install (tests turn it off)
  */
-export async function createApp({ folder, name, description, template = 'next-shadcn', install = true }) {
+/**
+ * Give the new app its look: one of the hand-picked presets in the starter's
+ * presets/ folder — a full light and dark palette and a font — written into
+ * globals.css and layout.tsx. Apps stop looking like the same default blue.
+ * Returns the preset used, or null when the starter has none.
+ */
+export async function applyDesign(appDir, design) {
+  const dir = path.join(appDir, 'presets');
+  const names = (await fs.readdir(dir).catch(() => [])).filter((f) => f.endsWith('.json'));
+  if (!names.length) return null;
+  const presets = await Promise.all(names.map(async (f) => JSON.parse(await fs.readFile(path.join(dir, f), 'utf8'))));
+  await fs.rm(dir, { recursive: true, force: true }); // the app needs the result, not the catalogue
+  const preset = presets.find((p) => p.name === design) ?? presets.find((p) => p.default) ?? presets[0];
+
+  const cssFile = path.join(appDir, 'src', 'app', 'globals.css');
+  let css = await fs.readFile(cssFile, 'utf8').catch(() => null);
+  if (css !== null) {
+    const retint = (selector, tokens) => {
+      const block = new RegExp(`(${selector}\\s*\\{)([\\s\\S]*?)(\\n\\})`);
+      css = css.replace(block, (all, open, body, close) => {
+        const seen = new Set();
+        let next = body.replace(/(\n\s*)--([\w-]+):\s*[^;]+;/g, (line, lead, key) => {
+          if (!(key in tokens)) return line;
+          seen.add(key);
+          return `${lead}--${key}: ${tokens[key]};`;
+        });
+        for (const [key, value] of Object.entries(tokens)) if (!seen.has(key)) next += `\n  --${key}: ${value};`;
+        return open + next + close;
+      });
+    };
+    retint(':root', { radius: preset.radius, ...preset.light });
+    retint('\\.dark', preset.dark);
+    await fs.writeFile(cssFile, css);
+  }
+
+  const sans = preset.fonts?.sans;
+  const layoutFile = path.join(appDir, 'src', 'app', 'layout.tsx');
+  if (sans && sans !== 'Geist') {
+    const id = sans.replace(/\s+/g, '_');
+    const layout = await fs.readFile(layoutFile, 'utf8').catch(() => null);
+    if (layout !== null) {
+      await fs.writeFile(layoutFile, layout
+        .replace('import { Geist, Geist_Mono } from "next/font/google";', `import { ${id}, Geist_Mono } from "next/font/google";`)
+        .replace('const sans = Geist({', `const sans = ${id}({`));
+    }
+  }
+
+  const guide = path.join(appDir, 'TEMPLATE.md');
+  const text = await fs.readFile(guide, 'utf8').catch(() => null);
+  if (text !== null) {
+    await fs.writeFile(guide, `${text.trimEnd()}\n\n## Design\n\nThis app uses the **${preset.name}** preset — ` +
+      `${preset.summary}. Font: ${sans ?? 'Geist'}. The palette lives in globals.css (light and dark): ` +
+      'build with the tokens (bg-primary, text-muted-foreground, border, ...) rather than raw colours, ' +
+      'so every screen stays in one look.\n');
+  }
+  return preset;
+}
+
+export async function createApp({ folder, name, description, template = 'next-shadcn', design, install = true }) {
   if (!TEMPLATE_NAMES.includes(template)) {
     throw new ToolFailure({
       kind: 'bad_args',
@@ -110,21 +169,41 @@ export async function createApp({ folder, name, description, template = 'next-sh
 
   const files = await copyTree(path.join(TEMPLATES, template), target.abs, fill);
   await fs.mkdir(path.join(target.abs, 'public'), { recursive: true });
+  const look = await applyDesign(target.abs, design);
 
+  // The starter has been installed on this machine before: hard-link that
+  // tree in, which is seconds where npm is a minute. Otherwise install as
+  // usual, and keep the result so the next app is instant.
+  let linked = 0;
   if (install) {
-    const pkg = path.join(target.abs, 'package.json');
-    packageJsonWritten(pkg, await fs.readFile(pkg, 'utf8'));
+    // Keyed on the starter's lockfile, which is the same for every app made
+    // from it — the app's own is rewritten by npm as it installs.
+    const lockText = await fs
+      .readFile(path.join(TEMPLATES, template, '_package-lock.json'), 'utf8')
+      .catch(() => null);
+    linked = await restore(target.abs, template, lockText);
+    if (!linked) {
+      const pkg = path.join(target.abs, 'package.json');
+      packageJsonWritten(pkg, await fs.readFile(pkg, 'utf8'));
+      installIn(target.abs)?.then((done) => {
+        if (done?.code === 0) populate(target.abs, template, lockText);
+      });
+    }
   }
 
   const guide = await fs.readFile(path.join(target.abs, 'TEMPLATE.md'), 'utf8').catch(() => '');
 
   return result(
     `Created ${target.show} from the ${template} starter — ${files.length} files, already known to build.\n` +
-      (install
+      (look ? `Design: the ${look.name} preset (${look.summary}), font ${look.fonts?.sans ?? 'Geist'}.\n` : '') +
+      (linked
+        ? `Its packages are already in place (${linked.toLocaleString()} files, linked from the starter cache) — ` +
+          'nothing to install: build and run straight away.\n'
+        : install
         ? `Its packages are installing in the background right now. Keep writing: any command you run in ` +
           `${target.show} waits for that install first, so there is no need to run npm install.\n`
         : '') +
       `Run this app's commands with cwd: "${target.show}" (npm run build, npm run dev).\n\n${guide}`,
-    `${files.length} files${install ? ' · installing in the background' : ''}`
+    `${files.length} files${linked ? ' · packages ready' : install ? ' · installing in the background' : ''}`
   );
 }