makersclaw 0.1.0

package/src/registry.mjs

@@ -0,0 +1,191 @@
+// The registry: the templates `init` lays and the items `add` installs.
+//
+// Two kinds of item. COMPONENTS are the kit (components/ui) and the parts
+// (components/parts): they come with every app, because `init` lays the
+// whole template — `add button` only restores one. BLOCKS are the bigger
+// pieces a surface is assembled from (a board, a timeline, a canvas): no
+// app has one until `add` puts it there, so the agent searches for what
+// it needs and installs just that. Everything here ships inside this
+// package, so the version you run is the version you get.
+
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { globToRegExp, readJson, walk } from "./fsutil.mjs";
+
+export const PKG_ROOT = fileURLToPath(new URL("..", import.meta.url));
+const TEMPLATES = join(PKG_ROOT, "templates");
+const BLOCKS = join(PKG_ROOT, "registry", "blocks");
+
+/** Where an installed block lives in an app: components/blocks/<name>/. */
+export const BLOCK_DIR = "components/blocks";
+
+const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const BLOCK_FILE = /^[a-z0-9]+(?:-[a-z0-9]+)*\.(?:jsx|js)$/;
+
+let pkg;
+export function packageInfo() {
+  pkg ??= readJson(join(PKG_ROOT, "package.json"));
+  return { name: pkg.name, version: pkg.version };
+}
+
+export function templateNames() {
+  if (!existsSync(TEMPLATES)) return [];
+  return readdirSync(TEMPLATES)
+    .filter((n) => existsSync(join(TEMPLATES, n, "template.json")))
+    .sort();
+}
+
+/**
+ * Every file a template lays belongs to exactly one class:
+ *   fixed    ours: pinned by hash in check/pins.json, replaced by update
+ *   docs     ours: replaced by update, not pinned (reading, not code)
+ *   starter  laid once when missing, the app's from then on
+ *   merged   package.json: our scripts and dependencies merged into the app's
+ */
+export const FILE_CLASSES = ["fixed", "docs", "starter", "merged"];
+
+export function loadTemplate(name) {
+  const dir = join(TEMPLATES, name);
+  const meta = readJson(join(dir, "template.json"));
+  if (!meta || !NAME.test(name)) return null;
+  const root = join(dir, "files");
+  const patterns = FILE_CLASSES.map((cls) => [cls, (meta.files?.[cls] ?? []).map(globToRegExp)]);
+  const files = walk(root).map((path) => {
+    const hits = patterns.filter(([, res]) => res.some((re) => re.test(path))).map(([cls]) => cls);
+    if (hits.length !== 1) {
+      throw new Error(
+        `template ${name}: ${path} is ${hits.length ? `in ${hits.join(" and ")}` : "in no class"} — template.json must name every file exactly once`,
+      );
+    }
+    return { path, class: hits[0], from: join(root, path) };
+  });
+  const components = (meta.components ?? []).map((c) => ({
+    name: c.name,
+    type: c.type ?? "component",
+    title: c.title ?? c.name,
+    description: c.description ?? "",
+    tags: c.tags ?? [],
+    useWhen: c.useWhen ?? "",
+    requires: [],
+    dependencies: {},
+    files: (c.files ?? []).map((path) => {
+      const f = files.find((x) => x.path === path);
+      if (!f || f.class !== "fixed") throw new Error(`template ${name}: component ${c.name} names ${path}, which is not a fixed file`);
+      return { from: f.from, to: path };
+    }),
+    readme: null,
+  }));
+  return { name, title: meta.title ?? name, description: meta.description ?? "", root, files, components };
+}
+
+export function loadBlocks() {
+  if (!existsSync(BLOCKS)) return [];
+  return readdirSync(BLOCKS)
+    .filter((n) => statSync(join(BLOCKS, n)).isDirectory())
+    .sort()
+    .map((folder) => {
+      const dir = join(BLOCKS, folder);
+      const meta = readJson(join(dir, "block.json"));
+      if (!meta) throw new Error(`block ${folder}: no block.json`);
+      if (meta.name !== folder || !NAME.test(folder)) throw new Error(`block ${folder}: name must be the folder's, lowercase and dashed`);
+      const files = (meta.files ?? []).map((f) => {
+        if (!BLOCK_FILE.test(f)) throw new Error(`block ${folder}: ${f} — block files are lowercase-dashed .jsx/.js at the block's root`);
+        if (!existsSync(join(dir, f))) throw new Error(`block ${folder}: ${f} is listed but missing`);
+        return { from: join(dir, f), to: `${BLOCK_DIR}/${folder}/${f}` };
+      });
+      if (!files.some((f) => f.to.endsWith("/index.js"))) throw new Error(`block ${folder}: needs index.js — what a surface imports`);
+      return {
+        name: folder,
+        type: "block",
+        title: meta.title ?? folder,
+        description: meta.description ?? "",
+        tags: meta.tags ?? [],
+        useWhen: meta.useWhen ?? "",
+        requires: meta.requires ?? [],
+        dependencies: meta.dependencies ?? {},
+        exports: meta.exports ?? [],
+        files,
+        readme: existsSync(join(dir, "README.md")) ? join(dir, "README.md") : null,
+        demo: existsSync(join(dir, "demo.jsx")) ? join(dir, "demo.jsx") : null,
+      };
+    });
+}
+
+/** Everything `add` can install for this template: its kit, then the blocks. */
+export function loadItems(template) {
+  return [...template.components, ...loadBlocks()];
+}
+
+export function readmeOf(item) {
+  return item.readme ? readFileSync(item.readme, "utf8") : null;
+}
+
+// ---- search -------------------------------------------------------------
+
+const STOP = new Set(
+  "a an the of to and or for with in on by my our i we you that this it is are be as at from into between some each all any show shows need needs want wants like one app apps thing things where which what when how can".split(" "),
+);
+
+function words(text) {
+  return String(text ?? "").toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+
+/** Close enough for matching: "stages" finds "stage", "dragging" finds "drag". */
+function stem(w) {
+  if (w.length <= 3) return w;
+  return w.replace(/(?:ing|ies|es|ed|s)$/, (m) => (m === "ies" ? "y" : "")).replace(/(.)\1$/, "$1");
+}
+
+/** Items ranked by how well they match the words: the name first, then
+ *  tags, the title, and the description and when-to-use prose. */
+export function searchItems(items, query, { type, limit = 8 } = {}) {
+  const raw = words(query);
+  const terms = [...new Set(raw.filter((w) => !STOP.has(w)).map(stem))];
+  if (terms.length === 0) return [];
+  const whole = raw.join("-");
+  return items
+    .filter((item) => !type || item.type === type)
+    .map((item) => {
+      const name = words(item.name.replace(/-/g, " ")).map(stem);
+      const tags = item.tags.flatMap((t) => words(t)).map(stem);
+      const title = words(item.title).map(stem);
+      const prose = new Set([...words(item.description), ...words(item.useWhen)].map(stem));
+      let score = whole === item.name ? 30 : 0;
+      for (const t of terms) {
+        if (name.includes(t)) score += 10;
+        if (tags.includes(t)) score += 6;
+        if (title.includes(t)) score += 3;
+        if (prose.has(t)) score += 1;
+      }
+      return { item, score };
+    })
+    .filter((m) => m.score > 0)
+    .sort((a, b) => b.score - a.score || a.item.name.localeCompare(b.item.name))
+    .slice(0, limit);
+}
+
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let prev = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const next = Math.min(row[j] + 1, row[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+      prev = row[j];
+      row[j] = next;
+    }
+  }
+  return row[b.length];
+}
+
+/** Names close to a mistyped one, for the error that names the right one. */
+export function suggest(items, name) {
+  const close = items
+    .map((i) => ({ name: i.name, d: i.name.includes(name) || name.includes(i.name) ? 0 : distance(name, i.name) }))
+    .filter((x) => x.d <= 2)
+    .sort((a, b) => a.d - b.d)
+    .map((x) => x.name);
+  if (close.length) return close.slice(0, 3);
+  return searchItems(items, name, { limit: 3 }).map((m) => m.item.name);
+}