@kurajs/cli 0.0.6 → 0.0.7

package/dist/cli.js

@@ -6,6 +6,7 @@
 //     and never reads the filesystem (Workers-safe; mirrors June's app/_content.ts freeze).
 //     A content hash short-circuits re-embedding when nothing changed (cheap to run pre-dev).
 import { buildIndex } from "@kurajs/docs/search";
+import { parseMeta, validatePages } from "@kurajs/docs/meta";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
@@ -15,6 +16,79 @@ function arg(name, def) {
     const i = process.argv.indexOf(`--${name}`);
     return i >= 0 ? process.argv[i + 1] : def;
 }
+const LOCALE_DIR = /^[a-z]{2,3}(-[A-Za-z0-9]{2,8})*$/;
+// Walk one meta tree (default OR a single locale's mirror) → a folder-path-keyed MetaMap, STRICTLY
+// validated. `skipTopLocales` excludes top-level locale buckets (true for the default tree, false
+// inside a locale's own mirror). `wherePrefix` prefixes error locations (e.g. "ja-JP/") so a bad
+// locale meta is unambiguous. Folder paths are keyed RELATIVE to the tree root, so a locale's keys
+// line up 1:1 with the default's for per-folder overriding.
+function walkMetaTree(rootDir, skipTopLocales, wherePrefix = "") {
+    const meta = {};
+    const errors = [];
+    if (!fs.existsSync(rootDir))
+        return { meta, errors };
+    const skipped = (rel, name) => skipTopLocales && rel === "" && LOCALE_DIR.test(name);
+    const walk = (dir, rel) => {
+        const ents = fs.readdirSync(dir, { withFileTypes: true });
+        if (ents.some((e) => !e.isDirectory() && e.name === "meta.json")) {
+            const where = `${wherePrefix}${rel || "."}/meta.json`;
+            let raw;
+            try {
+                raw = JSON.parse(fs.readFileSync(path.join(dir, "meta.json"), "utf8"));
+            }
+            catch (e) {
+                errors.push(`${where}: invalid JSON — ${e.message}`);
+                raw = {};
+            }
+            const parsed = parseMeta(raw, where);
+            errors.push(...parsed.errors);
+            const children = new Set();
+            for (const c of ents) {
+                if (c.isDirectory() && !skipped(rel, c.name))
+                    children.add(c.name);
+                else if (/\.mdx?$/.test(c.name))
+                    children.add(c.name.replace(/\.mdx?$/, ""));
+            }
+            errors.push(...validatePages(parsed.meta, children, where));
+            // Root-only: every tab's pages must reference a real top-level folder.
+            if (rel === "" && parsed.meta.tabs) {
+                for (const t of parsed.meta.tabs)
+                    for (const p of t.pages)
+                        if (!children.has(p))
+                            errors.push(`${where}: tab "${t.title}" lists "${p}", which is not a top-level folder (have: ${[...children].sort().join(", ") || "none"})`);
+            }
+            meta[rel] = parsed.meta;
+        }
+        for (const e of ents) {
+            if (e.isDirectory() && !skipped(rel, e.name))
+                walk(path.join(dir, e.name), rel ? `${rel}/${e.name}` : e.name);
+        }
+    };
+    walk(rootDir, "");
+    return { meta, errors };
+}
+// Collect the default nav metadata PLUS every locale mirror's overrides. The default tree skips
+// top-level locale buckets; each `content/docs/<locale>/` is then walked as its own tree, so a
+// locale's meta.json keys match the default's by folder path (createDocs merges them per-locale).
+// A locale typically overrides only `title` (folder group label); omitted fields fall back.
+function collectMeta(cwd) {
+    const root = path.join(cwd, "content", "docs");
+    const errors = [];
+    const { meta, errors: e0 } = walkMetaTree(root, true);
+    errors.push(...e0);
+    const metaLocales = {};
+    if (fs.existsSync(root)) {
+        for (const ent of fs.readdirSync(root, { withFileTypes: true })) {
+            if (!ent.isDirectory() || !LOCALE_DIR.test(ent.name))
+                continue;
+            const { meta: lm, errors: le } = walkMetaTree(path.join(root, ent.name), false, `${ent.name}/`);
+            errors.push(...le);
+            if (Object.keys(lm).length)
+                metaLocales[ent.name] = lm;
+        }
+    }
+    return { meta, metaLocales, errors };
+}
 async function cmdIndex() {
     const cwd = process.cwd();
     const contentPath = path.join(cwd, "app", "_content.ts");
@@ -25,6 +99,27 @@ async function cmdIndex() {
     const model = arg("model", "Xenova/bge-m3");
     const indexTs = path.join(cwd, "app", "_index.ts");
     const mdxTs = path.join(cwd, "app", "_mdx.ts");
+    const metaTs = path.join(cwd, "app", "_meta.ts");
+    // Nav metadata (meta.json) — validated and frozen first, so a bad meta fails fast and cheap.
+    // META is the default tree; META_LOCALES holds each locale mirror's per-folder overrides.
+    const { meta, metaLocales, errors: metaErrors } = collectMeta(cwd);
+    if (metaErrors.length) {
+        console.error("kura index: meta.json validation failed —\n  " + metaErrors.join("\n  "));
+        process.exit(1);
+    }
+    fs.mkdirSync(path.dirname(metaTs), { recursive: true });
+    const metaContents = "// AUTO-GENERATED by `kura index` — do not edit. Frozen folder nav metadata (from meta.json).\n" +
+        `export const META = ${JSON.stringify(meta)} as const;\n` +
+        "// Per-locale overrides (content/docs/<locale>/**/meta.json), merged over META per folder.\n" +
+        `export const META_LOCALES = ${JSON.stringify(metaLocales)} as const;\n`;
+    // Write only when changed — `kura dev` re-runs index on restart, and an unconditional write would
+    // bump the mtime every time, which the dev watcher sees as an edit → infinite restart loop.
+    if (!fs.existsSync(metaTs) || fs.readFileSync(metaTs, "utf8") !== metaContents) {
+        fs.writeFileSync(metaTs, metaContents);
+    }
+    const metaCount = Object.keys(meta).length + Object.values(metaLocales).reduce((n, m) => n + Object.keys(m).length, 0);
+    if (metaCount)
+        console.log(`kura index: validated ${metaCount} meta.json file(s)`);
     const mod = (await import(pathToFileURL(contentPath).href));
     const DOCS = mod.DOCS ?? [];
     if (!DOCS.length) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kurajs/cli",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "type": "module",
   "description": "Kura CLI — dev, build, deploy, and index a Kura docs app (one surface over June).",
   "bin": {
@@ -15,7 +15,7 @@
   "license": "MIT",
   "dependencies": {
     "@kurajs/core": "^0.0.1",
-    "@kurajs/docs": "^0.0.5"
+    "@kurajs/docs": "^0.0.7"
   },
   "peerDependencies": {
     "@junejs/cli": ">=0.0.25 <0.1.0",