robodev 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robodev",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "CLI for Robodev Starbase — create, auth, link, and deploy file-based APIs",
   "type": "module",
   "license": "MIT",
@@ -21,7 +21,9 @@
     "access": "public"
   },
   "scripts": {
-    "robodev": "tsx src/index.ts"
+    "robodev": "tsx src/index.ts",
+    "generate:templates": "tsx src/generate-templates.ts",
+    "prepack": "tsx src/generate-templates.ts"
   },
   "dependencies": {
     "tsx": "^4.20.5"

package/src/emit-starter.ts

@@ -0,0 +1,183 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export type Starter = { id: string; title: string; description: string };
+
+export type PackageVersions = {
+  robodev: string;
+  sdk: string;
+  client: string;
+};
+
+export type EmitContext = {
+  name: string;
+  packageName: string;
+  title: string;
+  versions: PackageVersions;
+};
+
+const SKIP_DIRS = new Set(["node_modules", ".robodev", ".git"]);
+
+type DepMap = Record<string, string>;
+
+type PackageJson = {
+  name?: string;
+  dependencies?: DepMap;
+  devDependencies?: DepMap;
+  optionalDependencies?: DepMap;
+  [key: string]: unknown;
+};
+
+export function cliRoot(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), "..");
+}
+
+export async function resolveStarterTree(): Promise<{
+  catalogPath: string;
+  treeRoot: string;
+  catalogLabel: string;
+}> {
+  const workspaceCatalog = join(cliRoot(), "..", "starters", "catalog.json");
+  if (await pathExists(workspaceCatalog)) {
+    return {
+      catalogPath: workspaceCatalog,
+      treeRoot: join(cliRoot(), "..", "starters"),
+      catalogLabel: "starters/catalog.json",
+    };
+  }
+  return {
+    catalogPath: join(cliRoot(), "templates", "catalog.json"),
+    treeRoot: join(cliRoot(), "templates"),
+    catalogLabel: "templates/catalog.json",
+  };
+}
+
+export async function loadCatalog(): Promise<Starter[]> {
+  const { catalogPath, treeRoot, catalogLabel } = await resolveStarterTree();
+  return loadCatalogFrom(treeRoot, catalogPath, catalogLabel);
+}
+
+export async function loadCatalogFrom(
+  treeRoot: string,
+  catalogPath: string,
+  catalogLabel: string,
+): Promise<Starter[]> {
+  let raw: { starters?: Starter[] };
+  try {
+    raw = JSON.parse(await readFile(catalogPath, "utf8")) as { starters?: Starter[] };
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(`${catalogLabel} is missing`);
+    }
+    throw error;
+  }
+  if (!Array.isArray(raw.starters)) {
+    throw new Error(`${catalogLabel} is missing a starters array`);
+  }
+  const treeLabel = catalogLabel.replace(/\/catalog\.json$/, "");
+  const starters: Starter[] = [];
+  for (const row of raw.starters) {
+    if (!(await isDirectory(join(treeRoot, row.id)))) {
+      throw new Error(`Starter "${row.id}" is missing a ${treeLabel}/${row.id} directory`);
+    }
+    starters.push(row);
+  }
+  return starters;
+}
+
+export async function loadPackageVersions(): Promise<PackageVersions> {
+  const root = cliRoot();
+  const repo = join(root, "..");
+  const robodev = await readPackageVersion(join(root, "package.json"));
+  return {
+    robodev,
+    sdk: await readPackageVersion(join(repo, "robodev-sdk", "package.json"), robodev),
+    client: await readPackageVersion(join(repo, "robodev-client", "package.json"), robodev),
+  };
+}
+
+/** Copies a starter tree and applies package + display rewrites used by create and prepack. */
+export async function emitStarter(src: string, dest: string, ctx: EmitContext): Promise<void> {
+  await mkdir(dest, { recursive: true });
+  const entries = await readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      await emitStarter(join(src, entry.name), join(dest, entry.name), ctx);
+      continue;
+    }
+    if (!entry.isFile() || entry.name === ".env") continue;
+    const content = await readFile(join(src, entry.name), "utf8");
+    const next =
+      entry.name === "package.json"
+        ? rewritePackageJson(content, ctx)
+        : rewriteDisplay(content, ctx);
+    await writeFile(join(dest, entry.name), next);
+  }
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function readPackageVersion(path: string, fallback?: string): Promise<string> {
+  try {
+    const pkg = JSON.parse(await readFile(path, "utf8")) as { version?: string };
+    if (typeof pkg.version === "string" && pkg.version) return pkg.version;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT" || fallback === undefined) {
+      throw error;
+    }
+  }
+  if (fallback !== undefined) return fallback;
+  throw new Error(`Missing version in ${path}`);
+}
+
+function rewritePackageJson(raw: string, ctx: EmitContext): string {
+  const pkg = JSON.parse(raw) as PackageJson;
+  pkg.name = ctx.packageName;
+
+  const pins: Record<string, string> = {
+    robodev: `^${ctx.versions.robodev}`,
+    "@robodev-ai/sdk": `^${ctx.versions.sdk}`,
+    "@robodev-ai/client": `^${ctx.versions.client}`,
+  };
+  for (const section of ["dependencies", "devDependencies", "optionalDependencies"] as const) {
+    const deps = pkg[section];
+    if (!deps) continue;
+    for (const [name, pin] of Object.entries(pins)) {
+      if (deps[name] === "workspace:*") deps[name] = pin;
+    }
+  }
+
+  const moved = pkg.dependencies?.robodev;
+  if (pkg.dependencies) delete pkg.dependencies.robodev;
+  pkg.devDependencies = pkg.devDependencies ?? {};
+  pkg.devDependencies.robodev = pkg.devDependencies.robodev ?? moved ?? pins.robodev;
+
+  return `${JSON.stringify(pkg, null, 2)}\n`;
+}
+
+function rewriteDisplay(content: string, ctx: EmitContext): string {
+  let next = content.replace(/<title>[^<]*<\/title>/g, `<title>${ctx.name}</title>`);
+  next = next.replace(/^# .+$/m, `# ${ctx.name}`);
+  next = next.replaceAll(`<h1>{"${ctx.title}"}</h1>`, `<h1>{"${ctx.name}"}</h1>`);
+  next = next.replaceAll(`<h1>${ctx.title}</h1>`, `<h1>${ctx.name}</h1>`);
+  return next.replaceAll("{{NAME}}", ctx.name).replaceAll("{{PACKAGE_NAME}}", ctx.packageName);
+}

package/src/generate-templates.ts

@@ -0,0 +1,31 @@
+import { copyFile, mkdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { emitStarter, loadCatalogFrom, loadPackageVersions, cliRoot } from "./emit-starter.js";
+
+const startersRoot = join(cliRoot(), "..", "starters");
+const templatesRoot = join(cliRoot(), "templates");
+const catalogLabel = "starters/catalog.json";
+
+async function main(): Promise<void> {
+  const catalogPath = join(startersRoot, "catalog.json");
+  const starters = await loadCatalogFrom(startersRoot, catalogPath, catalogLabel);
+  const versions = await loadPackageVersions();
+
+  await rm(templatesRoot, { recursive: true, force: true });
+  await mkdir(templatesRoot, { recursive: true });
+  await copyFile(catalogPath, join(templatesRoot, "catalog.json"));
+
+  for (const starter of starters) {
+    await emitStarter(join(startersRoot, starter.id), join(templatesRoot, starter.id), {
+      name: "{{NAME}}",
+      packageName: "{{PACKAGE_NAME}}",
+      title: starter.title,
+      versions,
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/src/index.ts

@@ -1,12 +1,11 @@
 import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
-import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { basename, dirname, join, relative, resolve } from "node:path";
+import { basename, join, relative, resolve } from "node:path";
 import { execFile, spawn } from "node:child_process";
 import { promisify } from "node:util";
-import { fileURLToPath } from "node:url";
 import { ApiError, authed, publicRequest } from "./api.js";
 import {
   clearCredentials,
@@ -18,6 +17,13 @@ import {
   writeViteApiUrl,
 } from "./config.js";
 import { waitUntilLive } from "./wait-until-live.js";
+import {
+  emitStarter,
+  loadCatalog,
+  loadPackageVersions,
+  resolveStarterTree,
+  type Starter,
+} from "./emit-starter.js";
 
 const execFileAsync = promisify(execFile);
 
@@ -301,46 +307,10 @@ async function runDeploy(forceFlag: boolean, root = process.cwd()): Promise<void
   }
 }
 
-type Starter = { id: string; title: string; description: string };
-
-function cliRoot(): string {
-  return join(dirname(fileURLToPath(import.meta.url)), "..");
-}
-
-function templateRoot(id: string): string {
-  return join(cliRoot(), "templates", id);
-}
-
 function validIdsMessage(starters: Starter[]): string {
   return `Valid ids: ${starters.map((starter) => starter.id).join(", ")}`;
 }
 
-async function isDirectory(path: string): Promise<boolean> {
-  try {
-    return (await stat(path)).isDirectory();
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-    throw error;
-  }
-}
-
-async function loadCatalog(): Promise<Starter[]> {
-  const raw = JSON.parse(await readFile(join(cliRoot(), "templates", "catalog.json"), "utf8")) as {
-    starters?: Starter[];
-  };
-  if (!Array.isArray(raw.starters)) {
-    throw new Error("templates/catalog.json is missing a starters array");
-  }
-  const starters: Starter[] = [];
-  for (const row of raw.starters) {
-    if (!(await isDirectory(templateRoot(row.id)))) {
-      throw new Error(`Starter "${row.id}" is missing a templates/${row.id} directory`);
-    }
-    starters.push(row);
-  }
-  return starters;
-}
-
 function parseCreateArgs(args: string[]): { path?: string; starterId?: string } {
   let path: string | undefined;
   let starterId: string | undefined;
@@ -436,24 +406,6 @@ async function assertCreatable(root: string): Promise<void> {
   }
 }
 
-async function copyTemplate(from: string, to: string, vars: Record<string, string>): Promise<void> {
-  await mkdir(to, { recursive: true });
-  const entries = await readdir(from, { withFileTypes: true });
-  for (const entry of entries) {
-    const src = join(from, entry.name);
-    const dest = join(to, entry.name);
-    if (entry.isDirectory()) {
-      await copyTemplate(src, dest, vars);
-      continue;
-    }
-    let content = await readFile(src, "utf8");
-    for (const [key, value] of Object.entries(vars)) {
-      content = content.replaceAll(`{{${key}}}`, value);
-    }
-    await writeFile(dest, content);
-  }
-}
-
 async function npmInstall(root: string): Promise<void> {
   console.log("Installing npm packages…");
   await new Promise<void>((resolve, reject) => {
@@ -482,9 +434,12 @@ async function runCreate(args: string[]): Promise<void> {
     body: JSON.stringify({ name }),
   });
 
-  await copyTemplate(templateRoot(starter.id), root, {
-    NAME: name,
-    PACKAGE_NAME: packageNameFromPath(root),
+  const { treeRoot } = await resolveStarterTree();
+  await emitStarter(join(treeRoot, starter.id), root, {
+    name,
+    packageName: packageNameFromPath(root),
+    title: starter.title,
+    versions: await loadPackageVersions(),
   });
   await writeLink(
     {

package/templates/auth-chat/package.json

@@ -1,5 +1,6 @@
 {
   "name": "{{PACKAGE_NAME}}",
+  "version": "0.1.0",
   "private": true,
   "type": "module",
   "scripts": {
@@ -10,15 +11,15 @@
   "dependencies": {
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "@robodev-ai/sdk": "^0.3.0",
+    "@robodev-ai/sdk": "^0.4.0",
     "@robodev-ai/client": "^0.1.0"
   },
   "devDependencies": {
     "@types/react": "^18.3.24",
     "@types/react-dom": "^18.3.7",
     "@vitejs/plugin-react": "^4.7.0",
-    "robodev": "^0.3.0",
     "typescript": "^5.9.2",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "robodev": "^0.5.0"
   }
 }

package/templates/auth-chat/src/main.tsx

@@ -159,7 +159,7 @@ function App() {
   if (!api) {
     return (
       <main>
-        <h1>Auth chat</h1>
+        <h1>{{NAME}}</h1>
         <p className="error">Missing VITE_API_URL. Run `robodev create` or `robodev link`.</p>
       </main>
     );
@@ -169,7 +169,7 @@ function App() {
     return (
       <main className="narrow">
         <p className="eyebrow">Robodev Auth</p>
-        <h1>Auth chat</h1>
+        <h1>{{NAME}}</h1>
         <p className="lede">
           Sign in with email or Google. Protected APIs live at {apiUrl}. Unauthenticated GET
           /messages: {unauthStatus ?? "checking…"}.

package/templates/space/package.json

@@ -1,5 +1,6 @@
 {
   "name": "{{PACKAGE_NAME}}",
+  "version": "0.1.0",
   "private": true,
   "type": "module",
   "scripts": {
@@ -10,15 +11,15 @@
   "dependencies": {
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "@robodev-ai/sdk": "^0.3.0",
+    "@robodev-ai/sdk": "^0.4.0",
     "@robodev-ai/client": "^0.1.0"
   },
   "devDependencies": {
     "@types/react": "^18.3.24",
     "@types/react-dom": "^18.3.7",
     "@vitejs/plugin-react": "^4.7.0",
-    "robodev": "^0.3.0",
     "typescript": "^5.9.2",
-    "vite": "^6.3.5"
+    "vite": "^6.3.5",
+    "robodev": "^0.5.0"
   }
 }