@gorlitzer-labs/seldon 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# @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).
+
+```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
+```
+
+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.

package/bin/seldon.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+// seldon — the Seldon stack installer. Pick your tools; install each via its
+// native method. Zero dependencies: a raw-terminal checklist, no build step.
+import { execSync, spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import fs from "node:fs";
+import readline from "node:readline";
+import { MODULES, byId, DEPS, RAW, MONOREPO, withRequires, platformOk } from "../modules.mjs";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+// The monorepo root when running from a checkout (tools/seldon/bin -> ../../..)
+const REPO_ROOT = path.resolve(HERE, "..", "..", "..");
+const IN_CHECKOUT = fs.existsSync(path.join(REPO_ROOT, "modules", "apiary", "package.json"));
+
+const C = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`, bold: (s) => `\x1b[1m${s}\x1b[0m`,
+  gold: (s) => `\x1b[33m${s}\x1b[0m`, green: (s) => `\x1b[32m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`, cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+};
+
+function have(dep) {
+  const probe = DEPS[dep]?.probe;
+  if (!probe) return true;
+  try { execSync(probe, { stdio: "ignore" }); return true; } catch { return false; }
+}
+const depCache = {};
+const depOk = (d) => (depCache[d] ??= have(d));
+
+// ---- doctor -----------------------------------------------------------------
+function doctorFor(ids) {
+  const needed = new Set();
+  for (const id of ids) for (const d of byId[id].needs) needed.add(d);
+  const rows = [...needed].map((d) => ({ d, ok: depOk(d), hint: DEPS[d]?.hint }));
+  return rows;
+}
+function printDoctor(ids) {
+  const rows = doctorFor(ids);
+  if (!rows.length) { console.log(C.dim("  no external deps for this selection")); return true; }
+  let allOk = true;
+  for (const r of rows) {
+    if (r.ok) console.log(`  ${C.green("✓")} ${r.d}`);
+    else { allOk = false; console.log(`  ${C.red("✗")} ${r.d}  ${C.dim("— " + r.hint)}`); }
+  }
+  return allOk;
+}
+
+// ---- install actions --------------------------------------------------------
+function run(cmd, args, opts = {}) {
+  console.log(C.dim(`  $ ${cmd} ${args.join(" ")}`));
+  const r = spawnSync(cmd, args, { stdio: "inherit", ...opts });
+  return r.status === 0;
+}
+
+function installNpm(m, dev) {
+  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 });
+  }
+  return run("npm", ["install", "-g", m.pkg]);
+}
+
+function installShell(m, dev) {
+  // bifrost: run its installer. In a checkout, run the local file; otherwise
+  // fetch it from the monorepo (the standalone repo is retired).
+  if (dev && IN_CHECKOUT) return run("bash", [path.join(REPO_ROOT, m.installer)]);
+  return run("bash", ["-c", `curl -fsSL ${RAW}/${m.installer} | bash`]);
+}
+
+function installPython(m, dev) {
+  if (!platformOk(m)) {
+    console.log(C.red(`  ${m.id} needs macOS on Apple silicon — skipping`));
+    return false;
+  }
+  const dest = dev && IN_CHECKOUT
+    ? path.join(REPO_ROOT, m.dir)
+    : path.join(process.env.HOME, ".seldon", m.id);
+  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 });
+    }
+  }
+  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})`));
+  return ok;
+}
+
+function installOne(m, dev) {
+  console.log("\n" + C.bold(`▸ ${m.id}`) + C.dim(` — ${m.title}`));
+  const fn = { npm: installNpm, shell: installShell, python: installPython }[m.method];
+  const ok = fn(m, dev);
+  console.log(ok ? C.green(`  ✓ ${m.id} installed`) : C.red(`  ✗ ${m.id} failed`));
+  return ok;
+}
+
+function doInstall(ids, { dev } = {}) {
+  ids = withRequires(ids);
+  console.log(C.bold(`\nInstalling: `) + ids.join(", ") + (dev ? C.dim("  (dev: link from checkout)") : ""));
+  console.log(C.bold("\nPreflight:"));
+  const ok = printDoctor(ids);
+  if (!ok) console.log(C.gold("\n  ⚠ some deps are missing — install them above, then the tool will work."));
+  const results = ids.map((id) => [id, installOne(byId[id], dev)]);
+  const good = results.filter(([, r]) => r).map(([i]) => i);
+  const bad = results.filter(([, r]) => !r).map(([i]) => i);
+  console.log("\n" + C.bold("Done. ") + C.green(good.join(", ") || "—") + (bad.length ? "  " + C.red("failed: " + bad.join(", ")) : ""));
+}
+
+// ---- the checklist TUI ------------------------------------------------------
+function tui() {
+  return new Promise((resolve) => {
+    const rows = MODULES.map((m) => ({ m, on: platformOk(m) && ["apiary", "foundation", "factory"].includes(m.id) }));
+    let cur = 0;
+    const methodTag = (m) => ({ npm: "npm", shell: "shell", python: "python" }[m.method]);
+    const draw = () => {
+      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"));
+      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 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}`);
+        if (i === cur) out.push(`        ${C.dim("needs: " + (deps || "nothing"))}${r.m.requires.length ? C.dim("  · pulls in: " + r.m.requires.join(", ")) : ""}`);
+      });
+      process.stdout.write(out.join("\n") + "\n");
+    };
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    draw();
+    const onKey = (str, key) => {
+      if (key.name === "up") cur = (cur - 1 + rows.length) % rows.length;
+      else if (key.name === "down") cur = (cur + 1) % rows.length;
+      else if (key.name === "space") { if (platformOk(rows[cur].m)) rows[cur].on = !rows[cur].on; }
+      else if (str === "a") { const all = rows.every((r) => r.on || !platformOk(r.m)); rows.forEach((r) => { if (platformOk(r.m)) r.on = !all; }); }
+      else if (key.name === "return") return finish(rows.filter((r) => r.on).map((r) => r.m.id));
+      else if (key.name === "q" || (key.ctrl && key.name === "c")) return finish(null);
+      draw();
+    };
+    const finish = (ids) => {
+      process.stdin.off("keypress", onKey);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      readline.cursorTo(process.stdout, 0); readline.clearScreenDown(process.stdout);
+      resolve(ids);
+    };
+    process.stdin.on("keypress", onKey);
+  });
+}
+
+// ---- cli --------------------------------------------------------------------
+function list() {
+  console.log(C.bold("\nThe Seldon stack\n"));
+  for (const m of MODULES) {
+    const plat = platformOk(m) ? "" : C.red("  (unsupported here)");
+    console.log(`  ${C.bold(m.id.padEnd(11))} ${C.dim(m.method.padEnd(7))} ${m.blurb}${plat}`);
+  }
+  console.log("");
+}
+function help() {
+  console.log(`
+${C.bold("seldon")} — install the Seldon stack, pick what you use.
+
+  ${C.bold("seldon")}                 open the checklist (space to pick, enter to install)
+  ${C.bold("seldon install")} [ids…]  install everything picked, or the named modules
+  ${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
+
+  modules: ${MODULES.map((m) => m.id).join(", ")}
+`);
+}
+
+const argv = process.argv.slice(2);
+const dev = argv.includes("--dev");
+const args = argv.filter((a) => !a.startsWith("--"));
+const cmd = args[0];
+const ids = args.slice(1).filter((id) => byId[id]);
+
+(async () => {
+  if (argv.includes("--help") || cmd === "help") return help();
+  if (cmd === "list") return list();
+  if (cmd === "doctor") { printDoctor(ids.length ? withRequires(ids) : MODULES.map((m) => m.id)); return; }
+  if (cmd === "install") {
+    if (ids.length) return doInstall(ids, { dev });
+    // install with no ids -> fall through to the picker
+  }
+  if (cmd && cmd !== "install") { help(); process.exitCode = 1; return; }
+  // interactive
+  if (!process.stdin.isTTY) { console.log(C.red("no TTY — use: seldon install <ids…>")); process.exitCode = 1; return; }
+  const picked = await tui();
+  if (!picked) { console.log(C.dim("nothing installed.")); return; }
+  if (!picked.length) { console.log(C.dim("nothing selected.")); return; }
+  doInstall(picked, { dev });
+})();

package/modules.mjs

@@ -0,0 +1,114 @@
+// The Seldon stack — the module registry the installer reads.
+// One entry per tool: how it ships, what it needs, what it pulls in.
+
+export const MONOREPO = "gorlitzer-labs/seldon";
+export const RAW = `https://raw.githubusercontent.com/${MONOREPO}/main`;
+
+/** @typedef {"npm"|"shell"|"python"} Method */
+
+export const MODULES = [
+  {
+    id: "apiary",
+    title: "the conversation",
+    blurb: "shared rooms where AI agents talk, coordinate, hand off",
+    method: "npm",
+    pkg: "@gorlitzer-labs/apiary",
+    dir: "modules/apiary",
+    bin: "apiary",
+    needs: ["node", "tmux"],           // tmux only for the terminal agents, still worth flagging
+    requires: [],
+    platforms: null,                    // any
+  },
+  {
+    id: "foundation",
+    title: "the seam",
+    blurb: "the deterministic project workflow beneath it all",
+    method: "npm",
+    pkg: "@gorlitzer-labs/foundation",
+    dir: "modules/foundation",
+    bin: "foundation",
+    needs: ["node"],
+    requires: [],
+    platforms: null,
+  },
+  {
+    id: "comb",
+    title: "the vault",
+    blurb: "keys by name; a leak audit; multi-machine secrets (SOPS + age)",
+    method: "npm",
+    pkg: "@gorlitzer-labs/comb",
+    dir: "modules/comb",
+    bin: "comb",
+    needs: ["node", "sops", "age"],
+    requires: [],
+    platforms: null,
+  },
+  {
+    id: "factory",
+    title: "the floor",
+    blurb: "the 24/7 supervisor — new · watch · board · box · realms",
+    method: "npm",
+    pkg: "@gorlitzer-labs/factory",
+    dir: "modules/factory",
+    bin: "factory",
+    needs: ["node"],
+    requires: ["apiary", "foundation"], // factory needs both on PATH
+    platforms: null,
+  },
+  {
+    id: "bifrost",
+    title: "the bridge",
+    blurb: "tmux + Tailscale; sessions survive; phone access; agent state",
+    method: "shell",
+    dir: "modules/bifrost",
+    installer: "modules/bifrost/install.sh",
+    bin: "bifrost",
+    needs: ["tmux", "tailscale"],
+    requires: [],
+    platforms: null,                    // macos / linux / termux
+  },
+  {
+    id: "demerzel",
+    title: "the voice",
+    blurb: "a fully-local voice you talk to (MLX, Apple silicon)",
+    method: "python",
+    dir: "modules/demerzel",
+    bin: "demerzel",
+    needs: ["python3"],
+    requires: [],
+    platforms: { platform: "darwin", arch: "arm64" }, // macOS + Apple silicon only
+  },
+];
+
+export const byId = Object.fromEntries(MODULES.map((m) => [m.id, m]));
+
+/** External tools we can probe, and how a user installs each (macOS-first hint). */
+export const DEPS = {
+  node:     { probe: "node --version",     hint: "install Node 20+ (nvm, or brew install node)" },
+  tmux:     { probe: "tmux -V",            hint: "brew install tmux" },
+  sops:     { probe: "sops --version",     hint: "brew install sops" },
+  age:      { probe: "age --version",      hint: "brew install age" },
+  tailscale:{ probe: "tailscale version",  hint: "brew install --cask tailscale (or tailscale.com/download)" },
+  python3:  { probe: "python3 --version",  hint: "brew install python@3.13" },
+};
+
+/** Expand a selection to include hard requires (factory -> apiary, foundation). */
+export function withRequires(ids) {
+  const out = new Set(ids);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const id of [...out]) {
+      for (const req of byId[id]?.requires ?? []) {
+        if (!out.has(req)) { out.add(req); changed = true; }
+      }
+    }
+  }
+  return MODULES.filter((m) => out.has(m.id)).map((m) => m.id);
+}
+
+export function platformOk(m) {
+  if (!m.platforms) return true;
+  const { platform, arch } = m.platforms;
+  return (!platform || process.platform === platform) && (!arch || process.arch === arch);
+}

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@gorlitzer-labs/seldon",
+  "version": "0.1.0",
+  "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"],
+  "author": "Franco Berardi",
+  "license": "MIT",
+  "publishConfig": { "access": "public" }
+}