@kurajs/cli 0.0.3 → 0.0.5

package/dist/cli.js

@@ -6,10 +6,10 @@
 //     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 { transformers } from "@kurajs/transformers";
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
+import { spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
 function arg(name, def) {
     const i = process.argv.indexOf(`--${name}`);
@@ -73,6 +73,12 @@ async function cmdIndex() {
         const localeTag = locales.size ? ` (+${variants.length} variants across ${locales.size} locales)` : "";
         console.log(`kura index: embedding ${DOCS.length} docs${localeTag} (model ${model})…`);
         const t0 = Date.now();
+        // Lazy import: only the embed path needs the ML stack, so --no-embed sites never load it
+        // (and never install @kurajs/transformers — it's an optional peer).
+        const { transformers } = await import("@kurajs/transformers").catch(() => {
+            console.error("kura index: embedding needs @kurajs/transformers — install it, or use --no-embed.");
+            return process.exit(1);
+        });
         const bytes = await buildIndex({ entries: allEntries, embedder: transformers({ model }) });
         const b64 = Buffer.from(bytes).toString("base64");
         fs.writeFileSync(indexTs, stamp +
@@ -111,13 +117,108 @@ async function cmdIndex() {
     const tag = locales.size ? ` across ${locales.size + 1} locales` : "";
     console.log(`kura index: rendered ${ok}/${total} docs via MDX${tag} -> app/_mdx.ts`);
 }
-const cmd = process.argv[2];
-if (cmd === "index") {
-    await cmdIndex();
+// One Kura surface over June: dev / build / deploy each freeze content (june gen) + the search
+// index/MDX (kura index), then hand off to the `june` bin — which loads its own TS source and
+// owns the dev watch supervisor. Users only ever type `kura`.
+const flag = (name) => process.argv.includes(`--${name}`);
+// Forward extra args to june, dropping the kura-only flags (--no-embed, --model <v>).
+function passthrough() {
+    const out = [];
+    const a = process.argv.slice(3);
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] === "--no-embed")
+            continue;
+        if (a[i] === "--model") {
+            i++;
+            continue;
+        }
+        out.push(a[i]);
+    }
+    return out;
 }
-else {
-    console.log("Kura CLI\n" +
-        "  kura index [--model <hf-model>]   build & freeze the docs search index + MDX\n" +
-        "  kura index --no-embed             MDX only, no search index (runtime search is lexical)");
-    process.exit(cmd ? 1 : 0);
+// Find the `june` bin shim, walking up so it works both in a standalone app (local node_modules)
+// and a workspace member (the bin is hoisted to the root node_modules/.bin).
+function findJuneBin(cwd) {
+    const name = process.platform === "win32" ? "june.cmd" : "june";
+    let dir = cwd;
+    for (;;) {
+        const p = path.join(dir, "node_modules", ".bin", name);
+        if (fs.existsSync(p))
+            return p;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+// Run the app's `june` bin (it handles TS loading + the dev watcher); resolve with its exit code.
+function runJune(cwd, args) {
+    const bin = findJuneBin(cwd);
+    if (!bin) {
+        console.error("kura: couldn't find the `june` bin — is @junejs/cli installed?");
+        return Promise.resolve(1);
+    }
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { stdio: "inherit" });
+        child.on("error", (e) => {
+            console.error(`kura: couldn't run june (${e.message}).`);
+            resolve(1);
+        });
+        child.on("exit", (code) => resolve(code ?? 0));
+    });
+}
+// Run `kura index` in a SHORT-LIVED child so the embedder's native runtime (onnxruntime) is
+// loaded and torn down in its own process — keeping the long-running dev/build/deploy parent
+// ML-free (and dodging ORT's noisy teardown on some platforms).
+function runKuraIndex(cwd) {
+    const args = [process.argv[1], "index"];
+    if (flag("no-embed"))
+        args.push("--no-embed");
+    const model = arg("model");
+    if (model)
+        args.push("--model", model);
+    return new Promise((resolve) => {
+        const child = spawn(process.execPath, args, { stdio: "inherit", cwd });
+        child.on("error", (e) => { console.error(`kura: index failed (${e.message}).`); resolve(1); });
+        child.on("exit", (code) => resolve(code ?? 0));
+    });
+}
+async function freeze(cwd) {
+    let code = await runJune(cwd, ["gen"]); // june gen → app/_content.ts
+    if (code)
+        process.exit(code);
+    code = await runKuraIndex(cwd); // kura index → app/_index.ts + _mdx.ts (own process)
+    if (code)
+        process.exit(code);
+}
+const cmd = process.argv[2];
+const cwd = process.cwd();
+switch (cmd) {
+    case "index":
+        await cmdIndex();
+        break;
+    case "dev":
+        await freeze(cwd);
+        process.exit(await runJune(cwd, ["dev", ...passthrough()]));
+        break;
+    case "build":
+        await freeze(cwd);
+        process.exit(await runJune(cwd, ["build", ...passthrough()]));
+        break;
+    case "deploy": {
+        await freeze(cwd);
+        const dargs = ["deploy"];
+        for (const f of ["dry-run", "prod", "skip-migrate", "allow-destructive"])
+            if (flag(f))
+                dargs.push(`--${f}`);
+        process.exit(await runJune(cwd, dargs));
+        break;
+    }
+    default:
+        console.log("Kura CLI\n" +
+            "  kura dev [--no-embed]       freeze content + index, then run the dev server\n" +
+            "  kura build [--no-embed]     freeze + build the Worker bundle\n" +
+            "  kura deploy [--no-embed]    freeze + deploy to Cloudflare ([--dry-run] [--prod])\n" +
+            "  kura index [--no-embed] [--model <hf-model>]   (re)build the search index + MDX only");
+        process.exit(cmd ? 1 : 0);
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@kurajs/cli",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "type": "module",
-  "description": "Kura CLI — build the docs search index (kura index).",
+  "description": "Kura CLI — dev, build, deploy, and index a Kura docs app (one surface over June).",
   "bin": {
     "kura": "dist/cli.js"
   },
@@ -15,14 +15,19 @@
   "license": "MIT",
   "dependencies": {
     "@kurajs/core": "^0.0.1",
-    "@kurajs/docs": "^0.0.3",
-    "@kurajs/transformers": "^0.0.1"
+    "@kurajs/docs": "^0.0.3"
   },
   "peerDependencies": {
-    "@huggingface/transformers": ">=3"
+    "@junejs/cli": "^0.0.25",
+    "@kurajs/transformers": "^0.0.1"
+  },
+  "peerDependenciesMeta": {
+    "@kurajs/transformers": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@huggingface/transformers": "3.8.1",
+    "@kurajs/transformers": "*",
     "typescript": "^5.7.0"
   },
   "author": "Lawrence Lin",