@gorlitzer-labs/seldon 0.1.1 → 0.1.3

package/README.md

@@ -49,6 +49,13 @@ It's a stack, not a bundle — install only what you use:
 - **A team of agents** → add **apiary** (shared rooms) + **factory** (the supervisor).
 - **Across machines / from your phone** → add **bifrost**.
 
+## Package managers
+
+Node tools install via **pnpm** or **bun** if present (much faster than npm), else npm —
+override with `seldon install --pm=pnpm|bun|npm`. demerzel (Python) always installs into
+its **own isolated venv** — never your system/active Python — using **uv** if available,
+else `python3 -m venv` + pip.
+
 ## From a checkout
 
 ```bash

package/bin/seldon.js

@@ -52,14 +52,44 @@ function run(cmd, args, opts = {}) {
   return r.status === 0;
 }
 
+// Is a command on PATH? (used to pick the fastest package manager)
+const has = (bin) => { try { execSync(`command -v ${bin}`, { stdio: "ignore" }); return true; } catch { return false; } };
+
+// pnpm can only `add -g` when a global bin dir is configured (else ERR_PNPM_NO_GLOBAL_BIN_DIR).
+const pnpmGlobalReady = () => {
+  if (process.env.PNPM_HOME) return true;
+  try {
+    const d = execSync("pnpm config get global-bin-dir", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    return !!d && d !== "undefined" && d !== "null";
+  } catch { return false; }
+};
+
+// Pick the node package manager: --pm=<x> override, else the fastest that can
+// actually global-install; npm is the universal fallback.
+function nodePM() {
+  const ov = (process.argv.find((a) => a.startsWith("--pm=")) || "").split("=")[1];
+  if (ov) return ov;
+  if (has("pnpm") && pnpmGlobalReady()) return "pnpm";
+  if (has("bun")) return "bun";
+  return "npm";
+}
+
 function installNpm(m, dev) {
+  const pm = nodePM();
   if (dev && IN_CHECKOUT) {
     const dir = path.join(REPO_ROOT, m.dir);
     const pj = JSON.parse(fs.readFileSync(path.join(dir, "package.json")));
-    if (pj.scripts?.build) run("npm", ["--prefix", dir, "run", "build"]);
-    return run("npm", ["link"], { cwd: dir });
+    if (pj.scripts?.build) run(pm, ["run", "build"], { cwd: dir });
+    const link = pm === "pnpm" ? ["link", "--global"] : ["link"]; // bun/npm: `link`
+    if (run(pm, link, { cwd: dir })) return true;
+    if (pm !== "npm") { console.log(C.dim("  falling back to npm link…")); return run("npm", ["link"], { cwd: dir }); }
+    return false;
   }
-  return run("npm", ["install", "-g", m.pkg]);
+  // pnpm/bun: `add -g` · npm: `install -g` — a global CLI, no project touched
+  const add = pm === "npm" ? ["install", "-g", m.pkg] : ["add", "-g", m.pkg];
+  if (run(pm, add)) return true;
+  if (pm !== "npm") { console.log(C.dim(`  ${pm} failed — falling back to npm…`)); return run("npm", ["install", "-g", m.pkg]); }
+  return false;
 }
 
 function installShell(m, dev) {
@@ -80,16 +110,32 @@ function installPython(m, dev) {
   if (!(dev && IN_CHECKOUT)) {
     console.log(C.dim(`  fetching ${m.id} into ${dest}`));
     fs.mkdirSync(path.dirname(dest), { recursive: true });
-    if (!fs.existsSync(path.join(dest, ".git"))) {
-      if (!run("git", ["clone", "--depth", "1", `https://github.com/${MONOREPO}.git`, dest + ".tmp"])) return false;
-      fs.renameSync(path.join(dest + ".tmp", m.dir), dest);
-      fs.rmSync(dest + ".tmp", { recursive: true, force: true });
+    if (fs.existsSync(path.join(dest, ".git"))) {
+      run("git", ["-C", dest, "pull", "--ff-only"]);   // already cloned → update in place
+    } else {
+      const tmp = dest + ".tmp";
+      fs.rmSync(tmp, { recursive: true, force: true });                 // clear any stale tmp
+      if (!run("git", ["clone", "--depth", "1", `https://github.com/${MONOREPO}.git`, tmp])) return false;
+      fs.rmSync(dest, { recursive: true, force: true });                // dest must not exist before rename (fixes ENOTEMPTY)
+      fs.renameSync(path.join(tmp, m.dir), dest);
+      fs.rmSync(tmp, { recursive: true, force: true });
     }
   }
+  // Always a DEDICATED venv under the module dir — we never install into the
+  // user's system/global/active Python. uv (if present) is faster and can even
+  // fetch its own CPython, so it doesn't touch their interpreter at all; plain
+  // venv+pip is the isolated fallback. No `--system`, no active-env writes.
   const venv = path.join(dest, ".venv");
-  run("python3", ["-m", "venv", venv]);
-  const ok = run(path.join(venv, "bin", "pip"), ["install", "-r", path.join(dest, "requirements.txt")]);
-  if (ok) console.log(C.dim(`  run it: ${path.join(dest, m.bin)}  (venv at ${venv})`));
+  const req = path.join(dest, "requirements.txt");
+  let ok;
+  if (has("uv")) {
+    if (!run("uv", ["venv", venv])) return false;
+    ok = run("uv", ["pip", "install", "--python", path.join(venv, "bin", "python"), "-r", req]);
+  } else {
+    run("python3", ["-m", "venv", venv]);
+    ok = run(path.join(venv, "bin", "pip"), ["install", "-r", req]);
+  }
+  if (ok) console.log(C.dim(`  run it: ${path.join(dest, m.bin)}  (isolated venv at ${venv})`));
   return ok;
 }
 
@@ -138,7 +184,7 @@ function tui() {
         const sel = r.on ? C.green("[x]") : "[ ]";
         const cursor = i === cur ? C.gold("❯") : " ";
         const okp = !platformOk(r.m);
-        const name = (i === cur ? C.bold(r.m.id) : r.m.id).padEnd(11);
+        const name = i === cur ? C.bold(r.m.id.padEnd(11)) : r.m.id.padEnd(11);
         const deps = r.m.needs.map((d) => (depOk(d) ? d : C.red(d))).join(" ");
         const platNote = okp ? C.red(" (unsupported OS)") : "";
         out.push(`  ${cursor} ${sel} ${name} ${C.dim(methodTag(r.m).padEnd(7))} ${C.dim(r.m.blurb)}${platNote}`);
@@ -186,6 +232,11 @@ ${C.bold("seldon")} — install the Seldon stack, pick what you use.
   ${C.bold("seldon doctor")} [ids…]   check external deps (tmux, sops, age, tailscale, python…)
   ${C.bold("seldon list")}            list the modules
   ${C.bold("seldon --dev")}           link node modules from this checkout instead of npm
+  ${C.bold("seldon install --pm=pnpm")}  force the node package manager (pnpm|bun|npm; auto-detected)
+
+  ${C.dim("node tools install via pnpm/bun if present (faster), else npm.")}
+  ${C.dim("python (demerzel) installs into its own isolated venv — never your system Python;")}
+  ${C.dim("uses uv if present, else python3 -m venv + pip.")}
 
   modules: ${MODULES.map((m) => m.id).join(", ")}
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gorlitzer-labs/seldon",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Install the Seldon stack — pick your tools from a checklist; each installs via its native method.",
   "type": "module",
   "bin": {