@gorlitzer-labs/seldon 0.1.0 → 0.1.2

package/README.md

@@ -1,18 +1,65 @@
 # @gorlitzer-labs/seldon
 
-The installer for **the Seldon stack**. Pick the tools you want from a checklist;
-each installs via its native method (npm for the node tools, the shell installer
-for bifrost, a venv for demerzel).
+```
+ ███████╗███████╗██╗     ██████╗  ██████╗ ███╗   ██╗
+ ██╔════╝██╔════╝██║     ██╔══██╗██╔═══██╗████╗  ██║
+ ███████╗█████╗  ██║     ██║  ██║██║   ██║██╔██╗ ██║
+ ╚════██║██╔══╝  ██║     ██║  ██║██║   ██║██║╚██╗██║
+ ███████║███████╗███████╗██████╔╝╚██████╔╝██║ ╚████║
+ ╚══════╝╚══════╝╚══════╝╚═════╝  ╚═════╝ ╚═╝  ╚═══╝
+```
+
+**The installer for the Seldon stack** — a software factory of AI agents.
+Pick the tools you want from a checklist; each installs via its native method
+(npm for the Node tools, a shell installer for bifrost, a venv for demerzel).
+
+## Install
 
 ```bash
 npm i -g @gorlitzer-labs/seldon
-seldon                 # open the checklist — space to pick, enter to install
-seldon install factory # or install named modules (pulls in apiary + foundation)
-seldon doctor          # check external deps (tmux, sops, age, tailscale, python)
-seldon list
-seldon --dev           # link node modules from a monorepo checkout instead of npm
+seldon                 # open the checklist — ↑↓ move · space pick · a all · enter install
+```
+
+Or name the modules directly:
+
+```bash
+seldon install foundation comb   # install just these
+seldon doctor                    # check external deps (tmux, sops, age, tailscale, python)
+seldon list                      # everything available
+```
+
+## The stack
+
+| module | what it is | ships via |
+|---|---|---|
+| **foundation** | the seam — a deterministic plan agents follow | npm |
+| **apiary** | the conversation — shared rooms where agents coordinate | npm |
+| **comb** | the vault — keys by name, never by value | npm |
+| **factory** | the floor — 24/7 supervisor + sandboxed agents | npm |
+| **bifrost** | the bridge — many machines, one workspace | shell |
+| **demerzel** | the voice — a fully-local voice assistant | python (macOS / Apple silicon) |
+
+Ticking **factory** auto-includes **apiary** + **foundation** (it needs them on PATH).
+
+## Pick the combo for the job
+
+It's a stack, not a bundle — install only what you use:
+
+- **Solo, one agent** → `seldon install foundation comb` — a plan + secured keys. Add **factory** for the sandbox, **demerzel** for voice.
+- **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
+seldon --dev           # link Node modules from a monorepo checkout instead of npm
 ```
 
-Modules: `apiary` · `foundation` · `comb` · `factory` · `bifrost` · `demerzel`.
-Ticking `factory` auto-includes `apiary` + `foundation` (it needs them on PATH).
-`demerzel` is offered only on macOS / Apple silicon.
+Part of the [seldon](https://github.com/gorlitzer-labs/seldon) monorepo.

package/bin/seldon.js

@@ -52,14 +52,31 @@ 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; } };
+
+// Pick the node package manager: --pm=<x> override, else the fastest present.
+// pnpm/bun install globally far faster than npm; 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")) 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`
+    return run(pm, link, { cwd: dir });
   }
-  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];
+  return run(pm, add);
 }
 
 function installShell(m, dev) {
@@ -86,10 +103,21 @@ function installPython(m, dev) {
       fs.rmSync(dest + ".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;
 }
 
@@ -114,6 +142,14 @@ function doInstall(ids, { dev } = {}) {
 }
 
 // ---- the checklist TUI ------------------------------------------------------
+const BANNER = [
+  " ███████╗███████╗██╗     ██████╗  ██████╗ ███╗   ██╗",
+  " ██╔════╝██╔════╝██║     ██╔══██╗██╔═══██╗████╗  ██║",
+  " ███████╗█████╗  ██║     ██║  ██║██║   ██║██╔██╗ ██║",
+  " ╚════██║██╔══╝  ██║     ██║  ██║██║   ██║██║╚██╗██║",
+  " ███████║███████╗███████╗██████╔╝╚██████╔╝██║ ╚████║",
+  " ╚══════╝╚══════╝╚══════╝╚═════╝  ╚═════╝ ╚═╝  ╚═══╝",
+];
 function tui() {
   return new Promise((resolve) => {
     const rows = MODULES.map((m) => ({ m, on: platformOk(m) && ["apiary", "foundation", "factory"].includes(m.id) }));
@@ -123,13 +159,14 @@ function tui() {
       readline.cursorTo(process.stdout, 0, 0);
       readline.clearScreenDown(process.stdout);
       const out = [];
-      out.push(C.bold(C.gold("  The Seldon stack")) + C.dim("   — pick your tools"));
+      BANNER.forEach((l) => out.push(C.gold(l)));
+      out.push(C.dim("  the AI-agent-factory stack — pick your tools"));
       out.push(C.dim("  ↑↓ move · space toggle · a all · enter install · q quit\n"));
       rows.forEach((r, i) => {
         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}`);
@@ -177,6 +214,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,13 +1,31 @@
 {
   "name": "@gorlitzer-labs/seldon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Install the Seldon stack — pick your tools from a checklist; each installs via its native method.",
   "type": "module",
-  "bin": { "seldon": "bin/seldon.js" },
-  "files": ["bin", "modules.mjs", "README.md"],
-  "engines": { "node": ">=20" },
-  "keywords": ["ai", "agents", "installer", "cli", "seldon", "apiary", "factory"],
+  "bin": {
+    "seldon": "bin/seldon.js"
+  },
+  "files": [
+    "bin",
+    "modules.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "installer",
+    "cli",
+    "seldon",
+    "apiary",
+    "factory"
+  ],
   "author": "Franco Berardi",
   "license": "MIT",
-  "publishConfig": { "access": "public" }
+  "publishConfig": {
+    "access": "public"
+  }
 }