pantrybase 0.0.0-stage → 0.2.0

package/dist/cli.js

@@ -0,0 +1,441 @@
+import {
+  Embedder,
+  MODEL_ID,
+  dataPaths,
+  homeDir,
+  log,
+  modelsDir,
+  openContext,
+  packageRoot,
+  packageVersion,
+  reconcile,
+  resolveProjectRoot,
+  searchRecipes,
+  startUiServer
+} from "./chunk-QUWSBZ2V.js";
+
+// src/cli.ts
+import { spawn } from "child_process";
+
+// src/install/install.ts
+import fs from "fs";
+import path from "path";
+
+// src/install/run.ts
+import { spawnSync } from "child_process";
+function run(cmd, args, opts = {}) {
+  const r = spawnSync(cmd, args, {
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+    encoding: "utf8",
+    timeout: opts.timeoutMs ?? 10 * 6e4,
+    maxBuffer: 64 * 1024 * 1024
+  });
+  return {
+    ok: r.status === 0 && !r.error,
+    code: r.status,
+    stdout: r.stdout ?? "",
+    stderr: r.error ? String(r.error) : r.stderr ?? ""
+  };
+}
+function tail(s, n = 400) {
+  const t = s.trim();
+  return t.length > n ? `\u2026${t.slice(-n)}` : t;
+}
+
+// src/install/claude.ts
+var PLUGIN_ID = "pantrybase@pantrybase";
+var MARKETPLACE = "pantrybase";
+function json(args) {
+  const r = run("claude", args, { timeoutMs: 6e4 });
+  if (!r.ok) return void 0;
+  try {
+    return JSON.parse(r.stdout);
+  } catch {
+    return void 0;
+  }
+}
+function claudeVersion() {
+  const r = run("claude", ["--version"], { timeoutMs: 2e4 });
+  return r.ok ? r.stdout.trim() : null;
+}
+function registeredPlugin() {
+  return json(["plugin", "list", "--json"])?.find((p) => p.id === PLUGIN_ID);
+}
+function registeredMarketplace() {
+  return json(["plugin", "marketplace", "list", "--json"])?.find(
+    (m) => m.name === MARKETPLACE
+  );
+}
+function registerPlugin(stableRoot) {
+  const steps = [];
+  if (!claudeVersion()) {
+    return [
+      {
+        step: "claude CLI",
+        ok: false,
+        detail: "`claude` not found on PATH; install Claude Code, then re-run `pantrybase install`"
+      }
+    ];
+  }
+  const market = registeredMarketplace();
+  if (market && (market.path ?? market.installLocation) !== stableRoot) {
+    run("claude", ["plugin", "marketplace", "remove", MARKETPLACE], { timeoutMs: 6e4 });
+  }
+  const again = market && (market.path ?? market.installLocation) === stableRoot;
+  const m = again ? run("claude", ["plugin", "marketplace", "update", MARKETPLACE], { timeoutMs: 12e4 }) : run("claude", ["plugin", "marketplace", "add", stableRoot], { timeoutMs: 12e4 });
+  steps.push({
+    step: again ? "marketplace update" : "marketplace add",
+    ok: m.ok,
+    detail: m.ok ? stableRoot : tail(m.stderr || m.stdout)
+  });
+  if (!m.ok) return steps;
+  const installed = registeredPlugin();
+  const p = installed ? run("claude", ["plugin", "update", PLUGIN_ID, "--scope", "user"], { timeoutMs: 12e4 }) : run("claude", ["plugin", "install", PLUGIN_ID, "--scope", "user"], { timeoutMs: 12e4 });
+  steps.push({
+    step: installed ? "plugin update" : "plugin install",
+    ok: p.ok,
+    detail: p.ok ? `${PLUGIN_ID} (user scope)` : tail(p.stderr || p.stdout)
+  });
+  return steps;
+}
+function unregisterPlugin() {
+  const steps = [];
+  if (registeredPlugin()) {
+    const u = run("claude", ["plugin", "uninstall", PLUGIN_ID, "--scope", "user"], {
+      timeoutMs: 12e4
+    });
+    steps.push({
+      step: "plugin uninstall",
+      ok: u.ok,
+      detail: u.ok ? PLUGIN_ID : tail(u.stderr || u.stdout)
+    });
+  }
+  if (registeredMarketplace()) {
+    const r = run("claude", ["plugin", "marketplace", "remove", MARKETPLACE], {
+      timeoutMs: 6e4
+    });
+    steps.push({
+      step: "marketplace remove",
+      ok: r.ok,
+      detail: r.ok ? MARKETPLACE : tail(r.stderr || r.stdout)
+    });
+  }
+  return steps;
+}
+
+// src/install/install.ts
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+function installRecord() {
+  return readJson(path.join(homeDir(), "install.json"));
+}
+function materialize(from) {
+  const home = homeDir();
+  const tmp = path.join(home, "tmp");
+  const pluginDir = path.join(home, "plugin");
+  fs.mkdirSync(tmp, { recursive: true });
+  fs.mkdirSync(pluginDir, { recursive: true });
+  const steps = [];
+  const isDev = fs.existsSync(path.join(from, "src")) && fs.existsSync(path.join(from, "node_modules", ".bin", "tsup"));
+  for (const old of fs.readdirSync(tmp)) if (old.endsWith(".tgz")) fs.rmSync(path.join(tmp, old));
+  const pack = run(
+    "npm",
+    ["pack", from, "--pack-destination", tmp, "--json", ...isDev ? [] : ["--ignore-scripts"]],
+    {
+      cwd: from
+    }
+  );
+  if (!pack.ok) throw new Error(`npm pack failed: ${tail(pack.stderr || pack.stdout)}`);
+  const packed = JSON.parse(pack.stdout.slice(pack.stdout.indexOf("[")))[0];
+  if (!packed) throw new Error("npm pack produced no tarball");
+  steps.push({
+    step: "pack",
+    ok: true,
+    detail: `${packed.filename}${isDev ? " (built from source)" : ""}`
+  });
+  fs.writeFileSync(
+    path.join(pluginDir, "package.json"),
+    `${JSON.stringify({ private: true, dependencies: { pantrybase: `file:../tmp/${packed.filename}` } }, null, 2)}
+`
+  );
+  fs.rmSync(path.join(pluginDir, "node_modules", "pantrybase"), { recursive: true, force: true });
+  fs.rmSync(path.join(pluginDir, "package-lock.json"), { force: true });
+  const inst = run("npm", ["install", "--omit=dev", "--no-audit", "--no-fund"], { cwd: pluginDir });
+  if (!inst.ok) throw new Error(`npm install failed: ${tail(inst.stderr || inst.stdout)}`);
+  const stableRoot = path.join(pluginDir, "node_modules", "pantrybase");
+  const fresh = path.join(from, "dist", "server.js");
+  const installed = path.join(stableRoot, "dist", "server.js");
+  if (isDev && fs.existsSync(fresh) && fs.readFileSync(fresh, "utf8") !== fs.readFileSync(installed, "utf8")) {
+    throw new Error(`installed copy at ${stableRoot} does not match the freshly built package`);
+  }
+  steps.push({ step: "install dependencies", ok: true, detail: stableRoot });
+  return { stableRoot, version: packed.version, steps };
+}
+function smokeTest(stableRoot, node = process.execPath) {
+  const native = run(
+    node,
+    [
+      "-e",
+      `const r=require('node:module').createRequire(${JSON.stringify(path.join(stableRoot, "package.json"))});const D=r('better-sqlite3');const v=r('sqlite-vec');const db=new D(':memory:');v.load(db);db.exec("create virtual table t using fts5(x, tokenize='trigram')");const s=r('sharp');console.log(JSON.stringify({sqlite:db.prepare('select sqlite_version() v').get().v,vec:db.prepare('select vec_version() v').get().v,vips:s.versions.vips}))`
+    ],
+    { timeoutMs: 6e4 }
+  );
+  const probe = run(node, [path.join(stableRoot, "dist", "server.js"), "--probe"], {
+    timeoutMs: 6e4
+  });
+  let tools = 0;
+  try {
+    tools = JSON.parse(probe.stdout).tools.length;
+  } catch {
+  }
+  return [
+    {
+      step: "native modules",
+      ok: native.ok,
+      detail: native.ok ? native.stdout.trim() : tail(native.stderr)
+    },
+    {
+      step: "MCP server probe",
+      ok: probe.ok && tools > 0,
+      detail: probe.ok ? `${tools} tools` : tail(probe.stderr)
+    }
+  ];
+}
+function modelCached() {
+  return fs.existsSync(path.join(modelsDir(), ...MODEL_ID.split("/")));
+}
+function warmModel(stableRoot, node = process.execPath) {
+  if (modelCached()) return { step: "embedding model", ok: true, detail: `${MODEL_ID} (cached)` };
+  const r = run(node, [path.join(stableRoot, "dist", "cli.js"), "warm-model"], {
+    timeoutMs: 20 * 6e4
+  });
+  return {
+    step: "embedding model",
+    ok: r.ok,
+    detail: r.ok ? `${MODEL_ID} downloaded` : tail(r.stderr || r.stdout)
+  };
+}
+function install(opts = {}) {
+  const from = path.resolve(opts.from ?? packageRoot);
+  const home = homeDir();
+  const node = process.execPath;
+  const { stableRoot, version, steps } = materialize(from);
+  fs.writeFileSync(path.join(home, "node-path"), node);
+  fs.writeFileSync(path.join(home, "root-path"), stableRoot);
+  steps.push({ step: "pin node", ok: true, detail: `${node} (${process.version})` });
+  steps.push(...smokeTest(stableRoot, node));
+  if (opts.model !== false) steps.push(warmModel(stableRoot, node));
+  let registered = false;
+  if (opts.register !== false) {
+    const reg = registerPlugin(stableRoot);
+    steps.push(...reg);
+    registered = reg.length > 0 && reg.every((s) => s.ok);
+  }
+  const record = {
+    version,
+    node,
+    stableRoot,
+    from,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    registered
+  };
+  fs.writeFileSync(path.join(home, "install.json"), `${JSON.stringify(record, null, 2)}
+`);
+  return { ok: steps.every((s) => s.ok), steps };
+}
+function uninstall(opts = {}) {
+  const home = homeDir();
+  const steps = unregisterPlugin();
+  for (const f of ["plugin", "tmp", "node-path", "root-path", "install.json", "compile-cache"]) {
+    fs.rmSync(path.join(home, f), { recursive: true, force: true });
+  }
+  steps.push({ step: "remove stable copy", ok: true, detail: path.join(home, "plugin") });
+  if (opts.purge) {
+    fs.rmSync(modelsDir(), { recursive: true, force: true });
+    steps.push({ step: "remove model cache", ok: true, detail: modelsDir() });
+  }
+  return steps;
+}
+function doctor(projectRoot, dataDir) {
+  const rec = installRecord();
+  const out = [];
+  const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
+  out.push({
+    step: "node",
+    ok: major > 22 || major === 22 && minor >= 12,
+    detail: `${process.version} at ${process.execPath}${rec && rec.node !== process.execPath ? ` (pinned: ${rec.node})` : ""}`
+  });
+  out.push({
+    step: "installed copy",
+    ok: !!rec && fs.existsSync(path.join(rec.stableRoot, "dist", "server.js")),
+    detail: rec ? `${rec.version} at ${rec.stableRoot}` : "not installed \u2014 run `npx pantrybase install`"
+  });
+  if (rec)
+    out.push(...smokeTest(rec.stableRoot, fs.existsSync(rec.node) ? rec.node : process.execPath));
+  out.push({
+    step: "embedding model",
+    ok: modelCached(),
+    detail: modelCached() ? `${MODEL_ID} in ${modelsDir()}` : "not downloaded yet (first search will fetch ~34 MB)"
+  });
+  const cv = claudeVersion();
+  out.push({ step: "claude CLI", ok: !!cv, detail: cv ?? "not found on PATH" });
+  if (cv) {
+    const p = registeredPlugin();
+    const m = registeredMarketplace();
+    out.push({
+      step: "plugin registered",
+      ok: !!p?.enabled,
+      detail: p ? `${PLUGIN_ID} ${p.version ?? ""} ${p.enabled ? "enabled" : "DISABLED"}, read from ${p.readFromFolder ?? m?.path ?? "?"}` : "not installed \u2014 run `npx pantrybase install`"
+    });
+  }
+  const recipes = fs.existsSync(path.join(dataDir, "recipes")) ? fs.readdirSync(path.join(dataDir, "recipes")).filter((f) => f.endsWith(".md")).length : 0;
+  out.push({
+    step: "project data",
+    ok: true,
+    detail: fs.existsSync(dataDir) ? `${dataDir} (${recipes} recipes)` : `none yet in ${projectRoot}; created on first use`
+  });
+  return out;
+}
+
+// src/cli.ts
+var pkg = { version: packageVersion() };
+var USAGE = `pantrybase ${pkg.version}
+
+Setup
+  pantrybase install [--no-model] [--no-register]
+                                  install the Claude Code plugin (stable copy in ~/.pantrybase,
+                                  native modules checked, embedding model downloaded, plugin
+                                  registered at user scope)
+  pantrybase uninstall [--purge]  remove the plugin (--purge also deletes the model cache;
+                                  recipes in ./pantrybase are never touched)
+  pantrybase doctor               check node, native modules, model, plugin registration
+
+Recipes (in ./pantrybase of the current directory)
+  pantrybase rebuild [--full] [--reembed]
+                                  re-index recipes/*.md (--full re-parses every file,
+                                  --reembed recomputes embeddings)
+  pantrybase embed                embed pending chunks now
+  pantrybase search <query\u2026>      quick search from the terminal
+  pantrybase ui [--port N] [--open]
+                                  serve the web UI on 127.0.0.1 (default port 7433)
+  pantrybase stats                counts and paths
+  pantrybase version
+`;
+function printSteps(steps) {
+  for (const s of steps) console.log(`${s.ok ? "\u2714" : "\u2718"} ${s.step.padEnd(22)} ${s.detail}`);
+  return steps.every((s) => s.ok);
+}
+async function main(argv) {
+  const [cmd, ...rest] = argv;
+  switch (cmd) {
+    case "install": {
+      console.log(`Installing pantrybase ${pkg.version}\u2026`);
+      const r = install({
+        model: !rest.includes("--no-model"),
+        register: !rest.includes("--no-register")
+      });
+      printSteps(r.steps);
+      console.log(
+        r.ok ? "\nDone. Start a new Claude Code session (or run /reload-plugins) and try /pantrybase:ingest or /pantrybase:cook." : "\nSome steps failed \u2014 see above, then run `pantrybase doctor`."
+      );
+      return r.ok ? 0 : 1;
+    }
+    case "uninstall": {
+      const ok = printSteps(uninstall({ purge: rest.includes("--purge") }));
+      return ok ? 0 : 1;
+    }
+    case "doctor": {
+      const root = resolveProjectRoot();
+      return printSteps(doctor(root, dataPaths(root).data)) ? 0 : 1;
+    }
+    case "warm-model": {
+      await new Embedder().load();
+      return 0;
+    }
+    case "rebuild": {
+      const ctx = openContext(void 0, { reconcile: false });
+      const r = reconcile(ctx, {
+        full: rest.includes("--full"),
+        reembed: rest.includes("--reembed")
+      });
+      console.log(JSON.stringify(r, null, 2));
+      await ctx.embedQueue.run();
+      ctx.close();
+      return r.errors.length ? 1 : 0;
+    }
+    case "embed": {
+      const ctx = openContext();
+      await ctx.embedQueue.run();
+      console.log(JSON.stringify(ctx.store.stats(), null, 2));
+      ctx.close();
+      return 0;
+    }
+    case "search": {
+      const ctx = openContext();
+      if (ctx.embedder) await ctx.embedder.load();
+      await ctx.embedQueue.run();
+      const res = await searchRecipes(ctx, { query: rest.join(" "), limit: 10 });
+      for (const r of res.results) {
+        console.log(
+          `${(r.score ?? 0).toFixed(4)}  ${r.slug}  \u2014 ${r.title}  [${r.matched.join(",")}]`
+        );
+      }
+      console.log(
+        `(${res.results.length} results, vector ${res.vector_used ? "used" : "not used"})`
+      );
+      ctx.close();
+      return 0;
+    }
+    case "ui": {
+      const portArg = rest.indexOf("--port");
+      const ctx = openContext();
+      const ui = await startUiServer(ctx, {
+        port: portArg >= 0 ? Number(rest[portArg + 1]) : void 0,
+        version: pkg.version
+      });
+      console.log(`pantrybase UI: ${ui.url}  (data: ${ctx.paths.data}) \u2014 Ctrl-C to stop`);
+      if (rest.includes("--open")) {
+        const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+        spawn(opener, [ui.url], { stdio: "ignore", detached: true }).unref();
+      }
+      await new Promise(() => {
+      });
+      return 0;
+    }
+    case "stats": {
+      const ctx = openContext();
+      console.log(JSON.stringify({ ...ctx.store.stats(), data_dir: ctx.paths.data }, null, 2));
+      ctx.close();
+      return 0;
+    }
+    case "version":
+    case "--version":
+    case "-v":
+      console.log(pkg.version);
+      return 0;
+    case void 0:
+    case "-h":
+    case "--help":
+    case "help":
+      console.log(USAGE);
+      return 0;
+    default:
+      log(`unknown command: ${cmd}`);
+      console.log(USAGE);
+      return 1;
+  }
+}
+main(process.argv.slice(2)).then(
+  (code) => process.exit(code),
+  (e) => {
+    log("fatal:", e instanceof Error ? e.message : e);
+    process.exit(1);
+  }
+);
+//# sourceMappingURL=cli.js.map