ucode-agent 1.42.0 → 1.44.0

package/README.md

@@ -27,7 +27,7 @@ corner:
          add a dark mode toggle that remembers the choice
 
 
-                                                                           v1.42.0
+                                                                           v1.44.0
 ```
 
 A light crosses the wordmark once as it opens, and the three lines under the box

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucode-agent",
-  "version": "1.42.0",
+  "version": "1.44.0",
   "description": "ucode - a terminal coding agent that reads, edits and runs your code, on NVIDIA and Cohere models.",
   "type": "module",
   "main": "ucode.js",

package/src/tools/index.js

@@ -95,7 +95,11 @@ export const tools = [
       'toy, a game, a visualisation, a calculator, a timer. "next-shadcn": Next.js 16, ' +
       'TypeScript, Tailwind 4 and shadcn with 33 components — only when the app genuinely ' +
       'needs routes, a database or many screens, because it costs an install and a build. ' +
-      'This is how every Next.js app begins - never run create-next-app or shadcn init.',
+      'This is how every Next.js app begins - never run create-next-app or shadcn init. ' +
+      'In "next-shadcn" every path in "files" goes under src/: a page is a route only at ' +
+      '<app>/src/app/page.tsx or <app>/src/app/<segment>/page.tsx, an API handler only at ' +
+      '<app>/src/app/api/<name>/route.ts, and components at <app>/src/components/<feature>/. ' +
+      'A page.tsx written anywhere else is an ordinary file the router never serves.',
     parameters: {
       type: 'object',
       properties: {

package/src/tools/scaffold.js

@@ -173,6 +173,60 @@ async function unprefixOwnFolder(appDir, written) {
   return fixed;
 }
 
+/**
+ * Files that legitimately sit at the root of a Next.js project.
+ *
+ * Everything else a model writes there is app code that has missed src/.
+ */
+const NEXT_ROOT = /^(?:package(?:-lock)?\.json|next\.config\.[mc]?[jt]s|tsconfig\.json|postcss\.config\.[mc]?js|eslint\.config\.[mc]?js|components\.json|README\.md|TEMPLATE\.md|\.gitignore|next-env\.d\.ts)$/i;
+
+/**
+ * Put Next.js files where Next.js looks for them.
+ *
+ * Routing is folder-based and unforgiving: a page is a route only at
+ * src/app/<segment>/page.tsx. A traced build wrote page.tsx at the project
+ * root and api/expenses/route.ts beside it — the build passed, every route
+ * 404ed, and nothing said why.
+ *
+ * The guide has the tree in it, and the guide cannot help: it comes back
+ * inside the create_app result, and the model chooses these paths in the call
+ * that produces that result. It is reading the map after it has parked. So the
+ * paths are corrected on the way in, and the result says what moved and why,
+ * which is the copy that arrives in time to matter for the next file.
+ *
+ * Only for next-shadcn, only for files under the app folder, and never for the
+ * config files that genuinely belong at the root.
+ */
+function placeForNext(files, folder) {
+  const moved = [];
+
+  const out = files.map((f) => {
+    const rel = String(f.path ?? '').split('\\').join('/');
+    const prefix = `${folder}/`;
+    if (!rel.startsWith(prefix)) return f;
+
+    const inside = rel.slice(prefix.length);
+    if (!inside || inside.startsWith('src/') || inside.startsWith('public/')) return f;
+    if (NEXT_ROOT.test(inside)) return f;
+
+    // app/... is the right tree written one level too high; everything else
+    // that is app code belongs under src/ as it stands.
+    const under = inside.startsWith('app/') ? `src/${inside}` : `src/app/${inside}`;
+    const isRoute = /(?:^|\/)(?:page|layout|loading|error|not-found)\.[jt]sx?$/.test(inside)
+      || /(?:^|\/)route\.[jt]s$/.test(inside);
+    const isCode = /^(?:components|lib|hooks|styles|utils)\//.test(inside);
+
+    if (!isRoute && !isCode) return f;
+    const to = isCode ? `${prefix}src/${inside}` : `${prefix}${under}`;
+    if (to === rel) return f;
+
+    moved.push(`${inside} -> ${to.slice(prefix.length)}`);
+    return { ...f, path: to };
+  });
+
+  return { files: out, moved };
+}
+
 async function keepDesignTokens(appDir, template, written, starterCss) {
   const rel = TOKEN_FILE[template];
   if (!rel || !starterCss) return null;
@@ -366,7 +420,9 @@ export async function createApp({ folder, name, description, template = 'plain-h
 
   // The app's own files, written in this same call. Two round trips become
   // one, and round trips are nearly all of the time a build takes.
-  const mine = given;
+  // Next.js only: paths that have missed src/ are corrected before they land.
+  const placed = template === 'next-shadcn' ? placeForNext(given, path.basename(target.abs)) : { files: given, moved: [] };
+  const mine = placed.files;
   const wrote = mine.length ? await batchWrite({ files: mine }) : null;
   const written = new Set(mine.map((f) => resolveIn(f.path, 'create_app', 'files').abs));
   const keptTokens = await keepDesignTokens(target.abs, template, written, starterCss);
@@ -387,6 +443,13 @@ export async function createApp({ folder, name, description, template = 'plain-h
     `Created ${target.show} from the ${template} starter — ${copied.length} files, already known to build.\n` +
       (look ? `Design: the ${look.name} preset (${look.summary}), font ${look.fonts?.sans ?? 'Geist'}.\n` : '') +
       (wrote ? `\nYour ${mine.length} file${mine.length === 1 ? '' : 's'}:\n${wrote.content}\n` : '') +
+      (placed.moved.length
+        ? `\nMoved into place: ${placed.moved.join(', ')}. In Next.js a page is only a route at `
+          + 'src/app/<segment>/page.tsx, an API handler only at src/app/api/<name>/route.ts, and '
+          + 'components and libraries live under src/. A file written outside src/ builds fine and '
+          + 'is never served, which is the hardest kind of wrong to notice. Write the rest there '
+          + 'directly.\n'
+        : '') +
       (relinked.length
         ? `\nFixed in ${relinked.join(', ')}: links that began with "${path.basename(target.abs)}/". ` +
           'Paths in "files" are relative to the project root, but a link inside a page is ' +

package/src/tools/shell.js

@@ -183,6 +183,25 @@ export function serversReadySince(since = 0) {
   return readyServers.filter((s) => s.at >= since);
 }
 
+/**
+ * Shut down every dev server this session started.
+ *
+ * killTree existed and nothing ever called it, so a server outlived the
+ * session that started it — every build left one behind. Twenty-four builds
+ * in one afternoon left seventy-three node processes running, the oldest for
+ * three and a half hours, holding ports the next run then could not use.
+ *
+ * Best effort and never throws: a process that has already gone is the
+ * outcome we wanted anyway.
+ */
+export function stopServers() {
+  const stopped = readyServers.splice(0, readyServers.length);
+  for (const s of stopped) {
+    try { killTree(s.pid); } catch { /* already gone */ }
+  }
+  return stopped.length;
+}
+
 /** Every server started this session, for reading what they have logged. */
 export function runningServers() {
   return readyServers.slice();

package/ucode.js

@@ -145,6 +145,16 @@ async function main() {
     await agent.persist().catch(() => {});
     agent.ui.close();
     process.exitCode = 1;
+  } finally {
+    // Take the dev servers down with the session that started them, however it
+    // ended. killTree was written for this and nothing ever called it, so every
+    // build left its server running: twenty-four builds in an afternoon left
+    // seventy-three node processes alive, the oldest for three and a half
+    // hours, holding the ports the next run wanted.
+    try {
+      const { stopServers } = await import('./src/tools/shell.js');
+      stopServers();
+    } catch { /* nothing started, or already gone */ }
   }
 }