diffwiki-core 0.14.0 → 0.15.0

package/dist/index.js

@@ -1,10 +1,14 @@
 import {
   rankDocs,
   tokenize
-} from "./chunk-FTUF6IXS.js";
+} from "./chunk-TK2373AM.js";
 import {
-  runProcess
-} from "./chunk-EEETAETA.js";
+  parseArticle,
+  parseFrontmatter,
+  runProcess,
+  serializeArticle,
+  stripFrontmatter
+} from "./chunk-6MW6KSS4.js";
 import {
   ArticleNotFoundError,
   CollectionAlreadyAddedError,
@@ -43,28 +47,72 @@ import {
   removeCollection,
   resolveHome,
   resolveLogLevel,
+  templatesDir,
   unregisterCollection,
   upsertPlugin,
   writePluginRegistry,
   writeRegistry
-} from "./chunk-7V2DIQNL.js";
+} from "./chunk-TXM4OGBA.js";
 
-// src/config.ts
+// src/templates.ts
 import fs from "fs/promises";
+import path from "path";
+async function seedTemplates(srcDir) {
+  const dir = templatesDir();
+  await fs.mkdir(dir, { recursive: true });
+  const files = (await fs.readdir(srcDir)).filter((f) => f.endsWith(".md")).sort();
+  const seeded = [];
+  const skipped = [];
+  for (const file of files) {
+    const dest = path.join(dir, file);
+    try {
+      await fs.access(dest);
+      skipped.push(file);
+      continue;
+    } catch {
+    }
+    await fs.copyFile(path.join(srcDir, file), dest);
+    seeded.push(file);
+  }
+  return { seeded, skipped, dir };
+}
+async function listTemplateShapes(srcDir) {
+  const files = await fs.readdir(srcDir);
+  return files.filter((f) => f.endsWith("-template.md")).map((f) => f.replace(/-template\.md$/, "")).sort();
+}
+async function listTemplates(srcDir) {
+  const files = (await fs.readdir(srcDir)).filter((f) => f.endsWith("-template.md")).sort();
+  const out = [];
+  for (const file of files) {
+    let data = {};
+    try {
+      ({ data } = parseFrontmatter(await fs.readFile(path.join(srcDir, file), "utf8")));
+    } catch {
+    }
+    const shape = typeof data.shape === "string" && data.shape ? data.shape : file.replace(/-template\.md$/, "");
+    const purpose = typeof data.purpose === "string" ? data.purpose : "";
+    const budget = Array.isArray(data.budget) && data.budget.length === 2 ? [Number(data.budget[0]), Number(data.budget[1])] : void 0;
+    out.push({ shape, purpose, budget, file });
+  }
+  return out;
+}
+
+// src/config.ts
+import fs2 from "fs/promises";
 function isMissing(err) {
   return err?.code === "ENOENT";
 }
 async function readConfig() {
   try {
-    return JSON.parse(await fs.readFile(configPath(), "utf8"));
+    return JSON.parse(await fs2.readFile(configPath(), "utf8"));
   } catch (err) {
     if (isMissing(err)) return {};
     throw err;
   }
 }
 async function writeConfig(config) {
-  await fs.mkdir(resolveHome(), { recursive: true });
-  await fs.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
+  await fs2.mkdir(resolveHome(), { recursive: true });
+  await fs2.writeFile(configPath(), `${JSON.stringify(config, null, 2)}
 `, "utf8");
 }
 async function setConfigValue(key, value) {
@@ -106,77 +154,12 @@ function slugifyPath(input) {
   return segs.length > 0 ? segs.join("/") : "untitled";
 }
 
-// src/frontmatter.ts
-import matter from "gray-matter";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-var YAML_ENGINE = {
-  parse: (input) => {
-    const data = parseYaml(input);
-    return data && typeof data === "object" ? data : {};
-  },
-  stringify: (data) => stringifyYaml(data)
-};
-var MATTER_OPTS = { engines: { yaml: YAML_ENGINE } };
-function coerceAudience(value) {
-  return value === "private" || value === "system" ? value : "public";
-}
-function coerceStatus(value) {
-  return value === "draft" || value === "deprecated" ? value : "published";
-}
-function parseFallback(raw) {
-  const fenceRe = /^---[ \t]*\n([\s\S]*?)\n---[ \t]*\n/;
-  const fenceMatch = fenceRe.exec(raw);
-  let title = "";
-  let audience = "public";
-  let status = "published";
-  let body;
-  const clean = (s) => s.trim().replace(/^["']|["']$/g, "");
-  if (fenceMatch) {
-    const inner = fenceMatch[1];
-    const titleMatch = /^title:\s*(.+)$/m.exec(inner);
-    if (titleMatch) {
-      title = clean(titleMatch[1]);
-    }
-    const audienceMatch = /^audience:\s*(.+)$/m.exec(inner);
-    if (audienceMatch) {
-      audience = coerceAudience(clean(audienceMatch[1]));
-    }
-    const statusMatch = /^status:\s*(.+)$/m.exec(inner);
-    if (statusMatch) {
-      status = coerceStatus(clean(statusMatch[1]));
-    }
-    body = raw.slice(fenceMatch[0].length);
-  } else {
-    body = raw;
-  }
-  return { title, tags: [], audience, status, body: body.replace(/^\n+/, "") };
-}
-function parseArticle(raw) {
-  try {
-    const { data, content } = matter(raw, MATTER_OPTS);
-    const title = typeof data.title === "string" ? data.title : "";
-    const tags = Array.isArray(data.tags) ? data.tags.map((t) => String(t)) : [];
-    const created = typeof data.created === "string" ? data.created : void 0;
-    const audience = coerceAudience(data.audience);
-    const status = coerceStatus(data.status);
-    return { title, tags, created, audience, status, body: content.replace(/^\n+/, "") };
-  } catch {
-    return parseFallback(raw);
-  }
-}
-function serializeArticle(article) {
-  const front = { title: article.title, tags: article.tags };
-  if (article.audience === "private" || article.audience === "system") front.audience = article.audience;
-  if (article.status === "draft" || article.status === "deprecated") front.status = article.status;
-  return matter.stringify(article.body, front, MATTER_OPTS);
-}
-
 // src/articles.ts
-import fs2 from "fs/promises";
-import path from "path";
+import fs3 from "fs/promises";
+import path2 from "path";
 async function fireHook(event, collection, relPath) {
   try {
-    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-AVD3G5AX.js");
+    const { emitPluginEvent: emitPluginEvent2 } = await import("./events-K3MKWACA.js");
     await emitPluginEvent2(event, collection, relPath);
   } catch {
   }
@@ -218,24 +201,24 @@ function ensureMdPath(file) {
 async function createArticle(opts) {
   const { collection, title } = parseAddTarget(opts.target);
   const { name, dir } = await resolveCollectionDir(collection);
-  const filePath = path.join(dir, `${slugifyPath(title)}.md`);
+  const filePath = path2.join(dir, `${slugifyPath(title)}.md`);
   const body = opts.body ?? `# ${title}
 `;
-  await fs2.mkdir(path.dirname(filePath), { recursive: true });
-  await fs2.writeFile(
+  await fs3.mkdir(path2.dirname(filePath), { recursive: true });
+  await fs3.writeFile(
     filePath,
     serializeArticle({ title, tags: opts.tags, body, audience: opts.audience, status: opts.status }),
     "utf8"
   );
-  void fireHook("article-created", name, path.relative(dir, filePath));
+  void fireHook("article-created", name, path2.relative(dir, filePath));
   return { title, tags: opts.tags, path: filePath, collection: name };
 }
 async function loadArticle(target) {
   const { collection, file } = parsePathTarget(target);
   const { dir } = await resolveCollectionDir(collection);
-  const filePath = path.join(dir, ensureMdPath(file));
+  const filePath = path2.join(dir, ensureMdPath(file));
   try {
-    return { filePath, dir, raw: await fs2.readFile(filePath, "utf8"), collection };
+    return { filePath, dir, raw: await fs3.readFile(filePath, "utf8"), collection };
   } catch (err) {
     if (err.code === "ENOENT") throw new ArticleNotFoundError(target);
     throw err;
@@ -244,7 +227,7 @@ async function loadArticle(target) {
 async function updateArticleBody(target, body) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
-  await fs2.writeFile(
+  await fs3.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -255,14 +238,14 @@ async function updateArticleBody(target, body) {
     }),
     "utf8"
   );
-  void fireHook("article-updated", collection, path.relative(dir, filePath));
+  void fireHook("article-updated", collection, path2.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function mutateTags(target, fn) {
   const { filePath, dir, raw, collection } = await loadArticle(target);
   const parsed = parseArticle(raw);
   const tags = fn(parsed.tags);
-  await fs2.writeFile(
+  await fs3.writeFile(
     filePath,
     serializeArticle({
       title: parsed.title,
@@ -273,7 +256,7 @@ async function mutateTags(target, fn) {
     }),
     "utf8"
   );
-  void fireHook("article-updated", collection, path.relative(dir, filePath));
+  void fireHook("article-updated", collection, path2.relative(dir, filePath));
   return { title: parsed.title, tags, path: filePath, collection };
 }
 function addTags(target, tags) {
@@ -291,31 +274,31 @@ async function setArticleMeta(target, meta) {
   const parsed = parseArticle(raw);
   const audience = meta.audience ?? parsed.audience;
   const status = meta.status ?? parsed.status;
-  await fs2.writeFile(
+  await fs3.writeFile(
     filePath,
     serializeArticle({ title: parsed.title, tags: parsed.tags, audience, status, body: parsed.body }),
     "utf8"
   );
-  void fireHook("article-updated", collection, path.relative(dir, filePath));
+  void fireHook("article-updated", collection, path2.relative(dir, filePath));
   return { title: parsed.title, tags: parsed.tags, path: filePath, collection };
 }
 async function removeArticle(target) {
   const { filePath, dir, collection } = await loadArticle(target);
-  await fs2.rm(filePath);
-  void fireHook("article-removed", collection, path.relative(dir, filePath));
+  await fs3.rm(filePath);
+  void fireHook("article-removed", collection, path2.relative(dir, filePath));
   return filePath;
 }
 
 // src/repo.ts
-import fs4 from "fs/promises";
-import path3 from "path";
+import fs5 from "fs/promises";
+import path4 from "path";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 
 // src/git.ts
-import fs3 from "fs/promises";
-import path2 from "path";
+import fs4 from "fs/promises";
+import path3 from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
@@ -340,8 +323,8 @@ async function isLinkedWorktree(cwd) {
   const gitDir = await git(cwd, ["rev-parse", "--absolute-git-dir"]);
   const commonDir = await git(cwd, ["rev-parse", "--git-common-dir"]);
   if (!gitDir || !commonDir) return false;
-  const commonAbs = path2.isAbsolute(commonDir) ? commonDir : path2.resolve(cwd, commonDir);
-  return path2.resolve(gitDir) !== path2.resolve(commonAbs);
+  const commonAbs = path3.isAbsolute(commonDir) ? commonDir : path3.resolve(cwd, commonDir);
+  return path3.resolve(gitDir) !== path3.resolve(commonAbs);
 }
 async function repoRemoteName(cwd) {
   const url = await git(cwd, ["remote", "get-url", "origin"]);
@@ -383,8 +366,8 @@ var timestampCache = /* @__PURE__ */ new Map();
 async function fileTimestamps(absPath) {
   const cached2 = timestampCache.get(absPath);
   if (cached2) return cached2;
-  const dir = path2.dirname(absPath);
-  const base = path2.basename(absPath);
+  const dir = path3.dirname(absPath);
+  const base = path3.basename(absPath);
   const [addLog, lastLog] = await Promise.all([
     git(dir, ["log", "--follow", "--diff-filter=A", "--format=%aI", "--", base]),
     git(dir, ["log", "-1", "--format=%aI", "--", base])
@@ -395,7 +378,7 @@ async function fileTimestamps(absPath) {
   let updated = gitUpdated;
   if (!created || !updated) {
     try {
-      const st = await fs3.stat(absPath);
+      const st = await fs4.stat(absPath);
       if (!updated) updated = st.mtime.toISOString();
       if (!created) created = isEpochish(st.birthtime) ? st.mtime.toISOString() : st.birthtime.toISOString();
     } catch {
@@ -412,18 +395,18 @@ var REPO_CONFIG_FILE = "diffwiki.yaml";
 async function detectRepoName(cwd) {
   try {
     const { stdout } = await execFileAsync2("git", ["rev-parse", "--show-toplevel"], { cwd });
-    return path3.basename(stdout.trim());
+    return path4.basename(stdout.trim());
   } catch {
-    return path3.basename(path3.resolve(cwd));
+    return path4.basename(path4.resolve(cwd));
   }
 }
 async function readRepoConfig(cwd) {
   try {
-    const raw = await fs4.readFile(path3.join(cwd, REPO_CONFIG_FILE), "utf8");
-    const parsed = parseYaml2(raw) ?? {};
+    const raw = await fs5.readFile(path4.join(cwd, REPO_CONFIG_FILE), "utf8");
+    const parsed = parseYaml(raw) ?? {};
     if (!parsed.path) return void 0;
     return {
-      collection: parsed.collection ?? path3.basename(path3.resolve(cwd)),
+      collection: parsed.collection ?? path4.basename(path4.resolve(cwd)),
       path: parsed.path
     };
   } catch (err) {
@@ -432,9 +415,9 @@ async function readRepoConfig(cwd) {
   }
 }
 async function initRepoWiki(opts) {
-  const cwd = path3.resolve(opts.cwd);
+  const cwd = path4.resolve(opts.cwd);
   const wikiPath = opts.wikiPath ?? "wiki";
-  const absWiki = path3.join(cwd, wikiPath);
+  const absWiki = path4.join(cwd, wikiPath);
   let name = opts.collection ?? await detectRepoName(cwd);
   const existing = await findCollection(name);
   if (existing && existing.path !== absWiki) {
@@ -449,9 +432,9 @@ async function initRepoWiki(opts) {
       n += 1;
     }
   }
-  await fs4.mkdir(absWiki, { recursive: true });
+  await fs5.mkdir(absWiki, { recursive: true });
   const config = { collection: name, path: wikiPath };
-  await fs4.writeFile(path3.join(cwd, REPO_CONFIG_FILE), stringifyYaml2(config), "utf8");
+  await fs5.writeFile(path4.join(cwd, REPO_CONFIG_FILE), stringifyYaml(config), "utf8");
   const entry = {
     name,
     type: "repo",
@@ -462,15 +445,15 @@ async function initRepoWiki(opts) {
   return entry;
 }
 async function addExternalCollection(opts) {
-  const cwd = path3.resolve(opts.cwd);
+  const cwd = path4.resolve(opts.cwd);
   const root = await ensureGitRepo(cwd);
   if (await isLinkedWorktree(cwd)) throw new WorktreeNotAllowedError(root);
   const id = await repoId(root) ?? `path:${root}`;
   const already = await findCollectionById(id);
   if (already) throw new CollectionAlreadyAddedError(already.name);
   const docsRel = opts.docsDir ?? "docs";
-  const contentDir = path3.join(root, docsRel);
-  let name = await repoRemoteName(root) ?? path3.basename(root);
+  const contentDir = path4.join(root, docsRel);
+  let name = await repoRemoteName(root) ?? path4.basename(root);
   if (await findCollection(name)) {
     let n = 2;
     while (await findCollection(`${name}-${n}`)) n += 1;
@@ -489,14 +472,14 @@ async function addExternalCollection(opts) {
   return entry;
 }
 async function resolveCwdCollection(cwd) {
-  const abs = path3.resolve(cwd);
+  const abs = path4.resolve(cwd);
   const root = await gitToplevel(abs);
   if (root) {
     const id = await repoId(root) ?? `path:${root}`;
     const byId = await findCollectionById(id);
     if (byId) return byId;
   }
-  const within = (base) => abs === base || abs.startsWith(base + path3.sep);
+  const within = (base) => abs === base || abs.startsWith(base + path4.sep);
   const all = await listCollections();
   let best;
   let bestLen = -1;
@@ -520,10 +503,10 @@ async function collectionGitStatus(entry) {
 }
 
 // src/project.ts
-import fs5 from "fs/promises";
+import fs6 from "fs/promises";
 import os from "os";
-import path4 from "path";
-import { parse as parseYaml3 } from "yaml";
+import path5 from "path";
+import { parse as parseYaml2, parseDocument } from "yaml";
 var PROJECT_CONFIG_FILE = "diffwiki.yaml";
 function normaliseSite(raw) {
   if (!raw || typeof raw !== "object") return void 0;
@@ -577,12 +560,12 @@ function normaliseContext(raw) {
 async function readProjectConfig(dir) {
   let raw;
   try {
-    raw = await fs5.readFile(path4.join(dir, PROJECT_CONFIG_FILE), "utf8");
+    raw = await fs6.readFile(path5.join(dir, PROJECT_CONFIG_FILE), "utf8");
   } catch (err) {
     if (err.code === "ENOENT") return void 0;
     throw err;
   }
-  const parsed = parseYaml3(raw) ?? {};
+  const parsed = parseYaml2(raw) ?? {};
   const collections = [];
   if (Array.isArray(parsed.collections)) {
     for (const c of parsed.collections) {
@@ -598,7 +581,7 @@ async function readProjectConfig(dir) {
     }
     collections.sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
   } else if (typeof parsed.path === "string") {
-    const name = typeof parsed.collection === "string" ? parsed.collection : path4.basename(path4.resolve(dir));
+    const name = typeof parsed.collection === "string" ? parsed.collection : path5.basename(path5.resolve(dir));
     collections.push({ name, path: parsed.path });
   }
   const site = normaliseSite(parsed.site);
@@ -608,15 +591,28 @@ async function readProjectConfig(dir) {
 async function readContextCollections(dir) {
   return (await readProjectConfig(dir))?.context?.collections ?? [];
 }
+async function setContextCollections(dir, collections) {
+  const file = path5.join(dir, PROJECT_CONFIG_FILE);
+  let raw = "";
+  try {
+    raw = await fs6.readFile(file, "utf8");
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const doc = parseDocument(raw);
+  doc.setIn(["context", "collections"], collections);
+  await fs6.writeFile(file, doc.toString(), "utf8");
+  return file;
+}
 async function resolveProjectCollections(dir) {
   const config = await readProjectConfig(dir);
   if (!config) return [];
-  const root = path4.resolve(dir);
+  const root = path5.resolve(dir);
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   return config.collections.map((c) => ({
     name: c.name,
     type: "repo",
-    path: path4.resolve(root, c.path),
+    path: path5.resolve(root, c.path),
     createdAt
   }));
 }
@@ -626,11 +622,11 @@ async function readSiteConfig(dir) {
 async function seedProjectHome(dir) {
   const entries = await resolveProjectCollections(dir);
   if (entries.length === 0) {
-    throw new Error(`No collections to render from diffwiki.yaml in ${path4.resolve(dir)}`);
+    throw new Error(`No collections to render from diffwiki.yaml in ${path5.resolve(dir)}`);
   }
-  const home = await fs5.mkdtemp(path4.join(os.tmpdir(), "diffwiki-project-"));
-  await fs5.writeFile(
-    path4.join(home, "registry.json"),
+  const home = await fs6.mkdtemp(path5.join(os.tmpdir(), "diffwiki-project-"));
+  await fs6.writeFile(
+    path5.join(home, "registry.json"),
     `${JSON.stringify({ version: 1, collections: entries }, null, 2)}
 `,
     "utf8"
@@ -639,8 +635,8 @@ async function seedProjectHome(dir) {
 }
 
 // src/browse.ts
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path6 from "path";
 var INDEX_RE = /^(index|readme)\.mdx?$/i;
 function buildArticleTree(relPaths) {
   const root = {};
@@ -684,7 +680,7 @@ function buildArticleTree(relPaths) {
 async function collectRelPaths(dir, rel = "") {
   let dirents;
   try {
-    dirents = await fs6.readdir(dir, { withFileTypes: true });
+    dirents = await fs7.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -693,7 +689,7 @@ async function collectRelPaths(dir, rel = "") {
     if (d.name.startsWith(".")) continue;
     const childRel = rel ? `${rel}/${d.name}` : d.name;
     if (d.isDirectory()) {
-      out.push(...await collectRelPaths(path5.join(dir, d.name), childRel));
+      out.push(...await collectRelPaths(path6.join(dir, d.name), childRel));
     } else if (/\.(mdx?)$/.test(d.name)) {
       out.push(childRel);
     }
@@ -702,7 +698,7 @@ async function collectRelPaths(dir, rel = "") {
 }
 async function readdirSafe(dir) {
   try {
-    return await fs6.readdir(dir);
+    return await fs7.readdir(dir);
   } catch {
     return [];
   }
@@ -720,7 +716,7 @@ var CHEAP_META_BYTES = 8192;
 async function cheapMeta(absPath) {
   let handle;
   try {
-    handle = await fs6.open(absPath, "r");
+    handle = await fs7.open(absPath, "r");
     const buf = Buffer.alloc(CHEAP_META_BYTES);
     const { bytesRead } = await handle.read(buf, 0, CHEAP_META_BYTES, 0);
     const snippet = buf.subarray(0, bytesRead).toString("utf8");
@@ -754,10 +750,10 @@ async function enrichTitles(nodes, collDir) {
         let status = node.status;
         let order = node.order;
         if (node.slug) {
-          const dir = path5.join(collDir, node.slug);
+          const dir = path6.join(collDir, node.slug);
           const idx = pickIndexFile(await readdirSafe(dir));
           if (idx) {
-            const meta = await cheapMeta(path5.join(dir, idx));
+            const meta = await cheapMeta(path6.join(dir, idx));
             title = meta.title ?? title;
             audience = meta.audience ?? audience;
             status = meta.status ?? status;
@@ -767,7 +763,7 @@ async function enrichTitles(nodes, collDir) {
         return { ...node, title, audience, status, order, children };
       }
       for (const ext of [".mdx", ".md"]) {
-        const meta = await cheapMeta(path5.join(collDir, `${node.slug}${ext}`));
+        const meta = await cheapMeta(path6.join(collDir, `${node.slug}${ext}`));
         if (meta.title || meta.audience || meta.status || meta.order != null) {
           return {
             ...node,
@@ -786,49 +782,49 @@ async function enrichTitles(nodes, collDir) {
 async function collectionMeta(collDir) {
   const idx = pickIndexFile(await readdirSafe(collDir));
   if (!idx) return {};
-  const meta = await cheapMeta(path5.join(collDir, idx));
+  const meta = await cheapMeta(path6.join(collDir, idx));
   return { title: meta.title, audience: meta.audience, status: meta.status };
 }
 async function listArticleTree(coll) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
   const rels = await collectRelPaths(entry.path);
-  return enrichTitles(buildArticleTree(rels), path5.resolve(entry.path));
+  return enrichTitles(buildArticleTree(rels), path6.resolve(entry.path));
 }
 async function readArticle(coll, slug) {
   const entry = await findCollection(coll);
   if (!entry) throw new CollectionNotFoundError(coll);
-  const collDir = path5.resolve(entry.path);
+  const collDir = path6.resolve(entry.path);
   const normalized = slug.replace(/\\/g, "/");
   if (normalized.split("/").some((s) => s === "..")) {
     throw new InvalidTargetError(slug, "path traversal detected");
   }
   const safeSlug = normalized.split("/").filter((s) => s !== "" && s !== ".").join("/");
-  const inJail = (p) => p === collDir || p.startsWith(collDir + path5.sep);
+  const inJail = (p) => p === collDir || p.startsWith(collDir + path6.sep);
   let abs;
   let isIndex = false;
   for (const rel of safeSlug ? [`${safeSlug}.mdx`, `${safeSlug}.md`] : []) {
-    const candidate = path5.resolve(collDir, rel);
+    const candidate = path6.resolve(collDir, rel);
     if (!inJail(candidate)) throw new InvalidTargetError(slug, "path traversal detected");
     try {
-      await fs6.access(candidate);
+      await fs7.access(candidate);
       abs = candidate;
       break;
     } catch {
     }
   }
   if (!abs) {
-    const dir = path5.resolve(collDir, safeSlug);
+    const dir = path6.resolve(collDir, safeSlug);
     if (inJail(dir)) {
       const idx = pickIndexFile(await readdirSafe(dir));
       if (idx) {
-        abs = path5.join(dir, idx);
+        abs = path6.join(dir, idx);
         isIndex = true;
       }
     }
   }
   if (!abs) throw new ArticleNotFoundError(`${coll}/${safeSlug}`);
-  const parsed = parseArticle(await fs6.readFile(abs, "utf8"));
+  const parsed = parseArticle(await fs7.readFile(abs, "utf8"));
   const title = parsed.title?.trim() || (safeSlug ? safeSlug.split("/").pop() ?? safeSlug : coll);
   return {
     coll,
@@ -844,7 +840,7 @@ async function readArticle(coll, slug) {
 }
 
 // src/render.ts
-import path6 from "path";
+import path7 from "path";
 import { unified } from "unified";
 import remarkParse from "remark-parse";
 import remarkGfm from "remark-gfm";
@@ -861,7 +857,7 @@ function isNonRelativeHref(href) {
   return /^[a-z][a-z0-9+.-]*:/i.test(href);
 }
 function rehypeRewriteLinks(ctx) {
-  const slugDir = ctx.isIndex ? ctx.slug || "." : path6.posix.dirname(ctx.slug || ".");
+  const slugDir = ctx.isIndex ? ctx.slug || "." : path7.posix.dirname(ctx.slug || ".");
   return (tree) => {
     visit(tree, "element", (node) => {
       if (node.tagName !== "a") return;
@@ -871,8 +867,8 @@ function rehypeRewriteLinks(ctx) {
       const suffix = suffixMatch ? suffixMatch[0] : "";
       const pathPart = suffix ? raw.slice(0, raw.length - suffix.length) : raw;
       if (pathPart === "") return;
-      const joined = path6.posix.join(slugDir === "." ? "" : slugDir, pathPart);
-      const normalized = path6.posix.normalize(joined);
+      const joined = path7.posix.join(slugDir === "." ? "" : slugDir, pathPart);
+      const normalized = path7.posix.normalize(joined);
       const toRoute = (p) => p.replace(/\.(mdx?)$/i, "").replace(/(^|\/)(index|readme)$/i, "$1").replace(/\/+$/, "").replace(/^\/+/, "");
       if (normalized.startsWith("../")) {
         const sibling = normalized.slice(3);
@@ -1272,19 +1268,19 @@ function resolveCollectionSelection(all, sel = {}) {
 }
 
 // src/query.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 var log2 = getLogger("query");
 async function collectMarkdownFiles(dir) {
   let entries;
   try {
-    entries = await fs7.readdir(dir, { withFileTypes: true });
+    entries = await fs8.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const files = [];
   for (const entry of entries) {
-    const full = path7.join(dir, entry.name);
+    const full = path8.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await collectMarkdownFiles(full));
     } else if (entry.isFile() && /\.mdx?$/.test(entry.name)) {
@@ -1311,12 +1307,12 @@ async function nativeSearch(term, collections, collection, hideSystem = false) {
   const docs = [];
   for (const entry of targets) {
     for (const full of await collectMarkdownFiles(entry.path)) {
-      const fallbackTitle = path7.basename(full).replace(/\.mdx?$/, "");
+      const fallbackTitle = path8.basename(full).replace(/\.mdx?$/, "");
       let title = fallbackTitle;
       let tags = [];
       let body = "";
       try {
-        const parsed = parseArticle(await fs7.readFile(full, "utf8"));
+        const parsed = parseArticle(await fs8.readFile(full, "utf8"));
         if (hideSystem && parsed.audience === "system") continue;
         if (parsed.title) title = parsed.title;
         tags = parsed.tags;
@@ -1374,7 +1370,7 @@ async function dropSystemHits(hits) {
   const kept = [];
   for (const hit of hits) {
     try {
-      if (parseArticle(await fs7.readFile(hit.path, "utf8")).audience === "system") continue;
+      if (parseArticle(await fs8.readFile(hit.path, "utf8")).audience === "system") continue;
     } catch {
     }
     kept.push(hit);
@@ -1390,6 +1386,7 @@ async function search(term, opts) {
   const showSystem = opts?.showSystem ?? await showSystemEnabled();
   const hideSystem = !showSystem && wanted.length === 0;
   const searchable = hideSystem ? collections.filter((c) => c.audience !== "system") : collections;
+  const systemCollections = new Set(collections.filter((c) => c.audience === "system").map((c) => c.name));
   const filterHits = (hits) => wanted.length > 0 ? hits.filter((h) => wanted.includes(h.collection)) : hits;
   const engine = opts?.engine ?? await resolveDefaultEngine();
   log2.debug(`resolved search engine "${engine}"`);
@@ -1407,7 +1404,7 @@ async function search(term, opts) {
   try {
     const providerOpts = { ...opts, collection: wanted.length === 1 ? wanted[0] : void 0 };
     const raw = filterHits(await provider.handleSearch(term, searchable, providerOpts));
-    const hits = hideSystem ? await dropSystemHits(raw) : raw;
+    const hits = hideSystem ? await dropSystemHits(raw.filter((h) => !systemCollections.has(h.collection))) : raw;
     return { hits, engine, fellBackToNative: false };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -1421,13 +1418,13 @@ async function query(term, opts) {
 }
 
 // src/search.ts
-import fs8 from "fs/promises";
-import path8 from "path";
+import fs9 from "fs/promises";
+import path9 from "path";
 var isStatic2 = () => process.env.DIFFWIKI_STATIC === "1";
 async function readArticleParts(collDir, slug) {
   for (const ext of [".mdx", ".md"]) {
     try {
-      const parsed = parseArticle(await fs8.readFile(path8.join(collDir, `${slug}${ext}`), "utf8"));
+      const parsed = parseArticle(await fs9.readFile(path9.join(collDir, `${slug}${ext}`), "utf8"));
       return { tags: parsed.tags, body: parsed.body };
     } catch {
     }
@@ -1463,7 +1460,7 @@ async function buildSearchIndex(collection) {
   for (const e of entries) {
     try {
       const collEntry = await findCollection(e.name);
-      const collDir = path8.resolve(collEntry?.path ?? e.path);
+      const collDir = path9.resolve(collEntry?.path ?? e.path);
       if (collEntry?.audience === "system") continue;
       if (isStatic2()) {
         const cm = await collectionMeta(collDir);
@@ -1477,15 +1474,15 @@ async function buildSearchIndex(collection) {
 }
 
 // src/doctor.ts
-import fs10 from "fs/promises";
+import fs11 from "fs/promises";
 
 // src/plugins/manager.ts
-import fs9 from "fs/promises";
+import fs10 from "fs/promises";
 import os2 from "os";
-import path9 from "path";
+import path10 from "path";
 async function readPackageJson(file) {
   try {
-    return JSON.parse(await fs9.readFile(file, "utf8"));
+    return JSON.parse(await fs10.readFile(file, "utf8"));
   } catch {
     return null;
   }
@@ -1501,7 +1498,7 @@ function binOf(manifest) {
 async function pluginManifestDirs(nodeModules) {
   let entries;
   try {
-    entries = await fs9.readdir(nodeModules);
+    entries = await fs10.readdir(nodeModules);
   } catch {
     return [];
   }
@@ -1511,44 +1508,44 @@ async function pluginManifestDirs(nodeModules) {
     if (entry.startsWith("@")) {
       let scoped;
       try {
-        scoped = await fs9.readdir(path9.join(nodeModules, entry));
+        scoped = await fs10.readdir(path10.join(nodeModules, entry));
       } catch {
         continue;
       }
       for (const pkg of scoped) {
         if (pkg.startsWith(".")) continue;
-        dirs.push(path9.join(nodeModules, entry, pkg));
+        dirs.push(path10.join(nodeModules, entry, pkg));
       }
     } else {
-      dirs.push(path9.join(nodeModules, entry));
+      dirs.push(path10.join(nodeModules, entry));
     }
   }
   return dirs;
 }
 async function ensurePluginRoot() {
   const dir = pluginsDir();
-  await fs9.mkdir(dir, { recursive: true });
-  const pkgPath = path9.join(dir, "package.json");
+  await fs10.mkdir(dir, { recursive: true });
+  const pkgPath = path10.join(dir, "package.json");
   if (await readPackageJson(pkgPath) === null) {
     const pkg = { name: "diffwiki-plugins", private: true, version: "0.0.0" };
-    await fs9.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
+    await fs10.writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf8");
   }
   return dir;
 }
 async function asSearchPackage(pkgDir) {
-  const manifest = await readPackageJson(path9.join(pkgDir, "package.json"));
+  const manifest = await readPackageJson(path10.join(pkgDir, "package.json"));
   if (!manifest?.name || manifest.diffwiki?.kind !== "search") return null;
   const bin = binOf(manifest);
   if (!bin) return null;
-  return { name: manifest.name, version: manifest.version, binAbs: path9.resolve(pkgDir, bin) };
+  return { name: manifest.name, version: manifest.version, binAbs: path10.resolve(pkgDir, bin) };
 }
 async function packageNameFromSpec(spec) {
   const looksLikePath = spec.startsWith(".") || spec.startsWith("/") || spec.startsWith("~") || spec.startsWith("file:");
   if (looksLikePath) {
     const raw = spec.startsWith("file:") ? spec.slice("file:".length) : spec;
-    const abs = path9.resolve(raw.replace(/^~(?=$|\/)/, os2.homedir()));
-    return (await readPackageJson(path9.join(abs, "package.json")))?.name ?? null;
+    const abs = path10.resolve(raw.replace(/^~(?=$|\/)/, os2.homedir()));
+    return (await readPackageJson(path10.join(abs, "package.json")))?.name ?? null;
   }
   if (/^(git\+|git:|https?:|ssh:)/.test(spec)) return null;
   if (spec.startsWith("@")) {
@@ -1559,10 +1556,10 @@ async function packageNameFromSpec(spec) {
   return at <= 0 ? spec : spec.slice(0, at);
 }
 async function resolveSearchPackage(dir, name) {
-  return asSearchPackage(path9.join(dir, "node_modules", ...name.split("/")));
+  return asSearchPackage(path10.join(dir, "node_modules", ...name.split("/")));
 }
 async function discoverSearchPackage(dir) {
-  const nodeModules = path9.join(dir, "node_modules");
+  const nodeModules = path10.join(dir, "node_modules");
   for (const pkgDir of await pluginManifestDirs(nodeModules)) {
     const found = await asSearchPackage(pkgDir);
     if (found) return found;
@@ -1659,6 +1656,14 @@ async function registerPlugin(name, command) {
   await runSetup(command, name);
   return record;
 }
+async function repairPlugins() {
+  const enabled = (await readPluginRegistry()).plugins.filter((p) => p.enabled && p.kind === "search");
+  const out = [];
+  for (const p of enabled) {
+    out.push({ name: p.name, setup: await runSetup(p.command, p.name) });
+  }
+  return out;
+}
 async function removePlugin(name) {
   const record = (await readPluginRegistry()).plugins.find((p) => p.name === name);
   if (!record) throw new PluginError(`plugin "${name}" is not registered`);
@@ -1692,7 +1697,7 @@ async function listPlugins() {
 // src/doctor.ts
 async function exists(target) {
   try {
-    await fs10.access(target);
+    await fs11.access(target);
     return true;
   } catch {
     return false;
@@ -1798,15 +1803,14 @@ async function appendPluginDiagnostics(out, config) {
 }
 
 // src/lint.ts
-import fs11 from "fs/promises";
-import path10 from "path";
+import fs12 from "fs/promises";
+import path11 from "path";
 var BUDGETS = {
   recipe: { min: 300, max: 1e3 },
   "recipe-steps": { min: 500, max: 1500 },
   guide: { min: 1500, max: 5e3 },
-  "system-design": { min: 2e3, max: 6e3 },
-  "component-design": { min: 1e3, max: 3e3 },
-  // Fallback for a bare `architecture` tag when system vs component isn't declared.
+  reference: { min: 300, max: 2e3 },
+  // Generic fallback budget for a bare `architecture` tag (no dedicated template).
   architecture: { min: 1e3, max: 6e3 }
 };
 function estimateTokens(body) {
@@ -1815,8 +1819,7 @@ function estimateTokens(body) {
 function inferShape(tags, body) {
   const t = new Set(tags.map((x) => x.toLowerCase()));
   if (t.has("guide")) return "guide";
-  if (t.has("component-design") || t.has("component")) return "component-design";
-  if (t.has("system-design") || t.has("system")) return "system-design";
+  if (t.has("reference")) return "reference";
   if (t.has("architecture")) return "architecture";
   if (/^###\s+Step\b/im.test(body)) return "recipe-steps";
   return "recipe";
@@ -1887,13 +1890,13 @@ function lintArticle(article) {
 async function walkMarkdown(dir) {
   let entries;
   try {
-    entries = await fs11.readdir(dir, { withFileTypes: true });
+    entries = await fs12.readdir(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   const out = [];
   for (const e of entries) {
-    const full = path10.join(dir, e.name);
+    const full = path11.join(dir, e.name);
     if (e.isDirectory()) out.push(...await walkMarkdown(full));
     else if (e.isFile() && /\.mdx?$/.test(e.name) && !/-template\.mdx?$/.test(e.name)) out.push(full);
   }
@@ -1923,11 +1926,11 @@ async function lintCollections(scope) {
   let warnCount = 0;
   for (const coll of collections) {
     for (const full of await walkMarkdown(coll.path)) {
-      const rel = path10.relative(coll.path, full);
+      const rel = path11.relative(coll.path, full);
       const label = `${coll.name}/${rel}`;
       let findings = [];
       try {
-        const parsed = parseArticle(await fs11.readFile(full, "utf8"));
+        const parsed = parseArticle(await fs12.readFile(full, "utf8"));
         findings = lintArticle(parsed);
       } catch (err) {
         findings = [{ level: "error", rule: "parse", message: `could not parse: ${err.message}` }];
@@ -2040,11 +2043,14 @@ export {
   listEnabledPlugins,
   listPlugins,
   listSearchModes,
+  listTemplateShapes,
+  listTemplates,
   loadSearchProvider,
   localGraph,
   nativeSearch,
   parseAddTarget,
   parseArticle,
+  parseFrontmatter,
   parsePathTarget,
   pluginsDir,
   pluginsRegistryPath,
@@ -2066,6 +2072,7 @@ export {
   removePlugin,
   removeTags,
   renderArticle,
+  repairPlugins,
   repoId,
   repoRemoteName,
   resolveCollectionSelection,
@@ -2079,13 +2086,17 @@ export {
   resolveProjectCollections,
   search,
   seedProjectHome,
+  seedTemplates,
   serializeArticle,
   setArticleMeta,
   setConfigValue,
+  setContextCollections,
   setTags,
   showSystemEnabled,
   slugify,
   slugifyPath,
+  stripFrontmatter,
+  templatesDir,
   toTreeNodes,
   tokenize,
   unregisterCollection,