brainincorp 0.0.1 → 0.2.0

package/README.md

@@ -1,3 +1,17 @@
 # brainincorp
 
-reserved. coming soon. https://brainincorp.com
+A brain that lives on your machine. Read and written by your LLM.
+
+```bash
+npx brainincorp init
+```
+
+Walks you through:
+
+- installing `uv` if missing
+- choosing where your brain lives (default `~/.braincorp/brain`)
+- cloning the `brain-mcp` server to `~/.braincorp/brain-mcp`
+- wiring it into Claude Code, Codex CLI, and Cursor (whichever you have)
+- seeding the brain with a starter `docs/` tree
+
+Open a fresh session in your client and ask it to list your brain.

package/bin/brainincorp.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+import { intro, outro, text, select, multiselect, confirm, spinner, note, cancel, isCancel } from "@clack/prompts";
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const cmd = process.argv[2] ?? "init";
+if (cmd !== "init") {
+  console.error(`unknown command: ${cmd}. usage: brainincorp init`);
+  process.exit(1);
+}
+
+const HOME = homedir();
+const BRAINCORP_DIR = join(HOME, ".braincorp");
+const MCP_DIR = join(BRAINCORP_DIR, "brain-mcp");
+const MCP_REPO = "https://github.com/brainincorp/brain-mcp.git";
+
+function has(bin) {
+  return spawnSync("which", [bin], { stdio: "ignore" }).status === 0;
+}
+function run(cmdline, opts = {}) {
+  return execSync(cmdline, { stdio: "inherit", ...opts });
+}
+function runQuiet(cmdline, opts = {}) {
+  return execSync(cmdline, { stdio: ["ignore", "pipe", "pipe"], ...opts }).toString();
+}
+function bail(reason) {
+  cancel(reason);
+  process.exit(1);
+}
+function isEmpty(dir) {
+  try { return readdirSync(dir).length === 0; } catch { return true; }
+}
+
+intro("brainincorp — install a brain on this machine");
+
+// ─── PREREQS ──────────────────────────────────────────────────────────────
+if (!has("git")) bail("git is required. install it and re-run.");
+
+if (!has("uv")) {
+  const ok = await confirm({
+    message: "uv (python runner the MCP needs) is not installed. install it now?",
+    initialValue: true,
+  });
+  if (isCancel(ok) || !ok) bail("uv is required: curl -LsSf https://astral.sh/uv/install.sh | sh");
+  const s = spinner();
+  s.start("installing uv");
+  run("curl -LsSf https://astral.sh/uv/install.sh | sh", { stdio: "ignore" });
+  s.stop("uv installed");
+  process.env.PATH = `${HOME}/.local/bin:${process.env.PATH}`;
+  if (!has("uv")) bail("uv installed but not on PATH. open a new shell and re-run.");
+}
+
+// ─── DECISIONS (collect all, execute later) ───────────────────────────────
+
+// 1. new or existing brain?
+const source = await select({
+  message: "your brain — new or existing GitHub repo?",
+  options: [
+    { value: "new", label: "new — create a fresh brain on GitHub" },
+    { value: "existing", label: "existing — clone one you already have" },
+    { value: "local", label: "local-only — no GitHub remote (writes will be disabled)" },
+  ],
+  initialValue: "new",
+});
+if (isCancel(source)) bail("cancelled.");
+
+let remoteUrl = null;
+let newRepoName = null;
+let newRepoVisibility = null;
+
+if (source === "existing") {
+  const urlRaw = await text({
+    message: "remote URL (ssh or https)",
+    placeholder: "git@github.com:you/your-brain.git",
+    validate: (v) => (v.trim() ? undefined : "required"),
+  });
+  if (isCancel(urlRaw)) bail("cancelled.");
+  remoteUrl = urlRaw.trim();
+} else if (source === "new") {
+  if (!has("gh")) bail("`gh` CLI required to create a new repo. install it (brew install gh) or pick 'existing'.");
+  const ghUser = runQuiet(`gh api user --jq .login`).trim();
+  const nameRaw = await text({
+    message: "new repo name (owner/repo)",
+    initialValue: `${ghUser}/brain`,
+    validate: (v) => (/^[\w.-]+\/[\w.-]+$/.test(v.trim()) ? undefined : "use owner/repo format"),
+  });
+  if (isCancel(nameRaw)) bail("cancelled.");
+  newRepoName = nameRaw.trim();
+  const vis = await select({
+    message: "visibility",
+    options: [
+      { value: "--private", label: "private" },
+      { value: "--public", label: "public" },
+    ],
+    initialValue: "--private",
+  });
+  if (isCancel(vis)) bail("cancelled.");
+  newRepoVisibility = vis;
+}
+
+// 2. where on disk?
+const defaultPath = source === "existing" && remoteUrl
+  ? join(HOME, ".braincorp", remoteUrl.split("/").pop().replace(/\.git$/, ""))
+  : join(HOME, ".braincorp", "brain");
+
+const brainPathRaw = await text({
+  message: "where on disk should it live?",
+  initialValue: defaultPath,
+  validate: (v) => (v.startsWith("/") || v.startsWith("~") ? undefined : "must be an absolute path"),
+});
+if (isCancel(brainPathRaw)) bail("cancelled.");
+const brainPath = brainPathRaw.replace(/^~/, HOME);
+
+if (existsSync(brainPath) && !isEmpty(brainPath)) {
+  bail(`${brainPath} already exists and isn't empty. pick a different path or remove it.`);
+}
+
+// 3. which clients?
+const detected = {
+  claude: has("claude"),
+  codex: has("codex"),
+  cursor: existsSync(join(HOME, ".cursor")) || has("cursor"),
+};
+const choices = [
+  { value: "claude", label: "Claude Code", hint: detected.claude ? "detected" : "not detected" },
+  { value: "codex", label: "Codex CLI", hint: detected.codex ? "detected" : "not detected" },
+  { value: "cursor", label: "Cursor", hint: detected.cursor ? "detected" : "not detected" },
+];
+const initial = Object.entries(detected).filter(([, v]) => v).map(([k]) => k);
+if (initial.length === 0) bail("no MCP clients found (claude / codex / cursor).");
+
+const targets = await multiselect({
+  message: "wire the brain into which clients?",
+  options: choices,
+  initialValues: initial,
+  required: true,
+});
+if (isCancel(targets)) bail("cancelled.");
+
+// ─── EXECUTE ──────────────────────────────────────────────────────────────
+
+// install / update the MCP server
+const s1 = spinner();
+mkdirSync(BRAINCORP_DIR, { recursive: true });
+if (existsSync(MCP_DIR)) {
+  s1.start("updating brain-mcp");
+  run(`git -C "${MCP_DIR}" pull --ff-only`, { stdio: "ignore" });
+  s1.stop("brain-mcp up to date");
+} else {
+  s1.start("cloning brain-mcp");
+  run(`git clone --depth 1 ${MCP_REPO} "${MCP_DIR}"`, { stdio: "ignore" });
+  s1.stop("brain-mcp cloned");
+}
+
+const s2 = spinner();
+s2.start("installing python deps (uv sync)");
+run(`uv --directory "${MCP_DIR}" sync`, { stdio: "ignore" });
+s2.stop("python deps ready");
+
+// materialise the brain repo
+const s3 = spinner();
+if (source === "existing") {
+  s3.start(`cloning ${remoteUrl}`);
+  run(`git clone "${remoteUrl}" "${brainPath}"`, { stdio: "ignore" });
+  s3.stop(`brain cloned to ${brainPath}`);
+} else if (source === "new") {
+  s3.start(`creating ${newRepoName} on GitHub`);
+  mkdirSync(join(brainPath, "docs"), { recursive: true });
+  writeFileSync(
+    join(brainPath, "docs", "start-here.md"),
+    `# start here\n\nthis is your brain. an LLM reads and writes it through the brainincorp MCP.\n\n## what lives where\n\n- \`docs/decisions/\` — choices you've made and why\n- \`docs/projects/\` — what you're working on\n- \`docs/knowledge/\` — durable facts, references, learnings\n- \`docs/contacts/\` — people and orgs\n\nadd files freely. the LLM will find them.\n`
+  );
+  writeFileSync(join(brainPath, ".gitignore"), ".DS_Store\n");
+  run(`git -C "${brainPath}" init -q -b main`, { stdio: "ignore" });
+  run(`git -C "${brainPath}" add -A`, { stdio: "ignore" });
+  run(`git -C "${brainPath}" commit -q -m "init: brain seeded by brainincorp"`, { stdio: "ignore" });
+  run(`gh repo create ${newRepoName} ${newRepoVisibility} --source="${brainPath}" --remote=origin --push`, { stdio: "ignore" });
+  s3.stop(`pushed to https://github.com/${newRepoName}`);
+} else {
+  // local-only
+  s3.start("seeding local brain");
+  mkdirSync(join(brainPath, "docs"), { recursive: true });
+  writeFileSync(
+    join(brainPath, "docs", "start-here.md"),
+    `# start here\n\nthis is your brain. an LLM reads and writes it through the brainincorp MCP.\n`
+  );
+  writeFileSync(join(brainPath, ".gitignore"), ".DS_Store\n");
+  run(`git -C "${brainPath}" init -q -b main`, { stdio: "ignore" });
+  run(`git -C "${brainPath}" add -A`, { stdio: "ignore" });
+  run(`git -C "${brainPath}" commit -q -m "init: brain seeded by brainincorp"`, { stdio: "ignore" });
+  s3.stop(`seeded ${brainPath} (no remote)`);
+}
+
+// wire clients
+const launcher = join(MCP_DIR, "brain-mcp.sh");
+spawnSync("chmod", ["+x", launcher]);
+
+const installers = {
+  claude: () => {
+    try { runQuiet(`claude mcp remove brain --scope user 2>/dev/null`); } catch {}
+    run(`claude mcp add brain --scope user -e BRAIN_REPO="${brainPath}" -- "${launcher}"`, { stdio: "ignore" });
+  },
+  codex: () => {
+    try { runQuiet(`codex mcp remove brain 2>/dev/null`); } catch {}
+    run(`codex mcp add brain --env BRAIN_REPO="${brainPath}" -- "${launcher}"`, { stdio: "ignore" });
+  },
+  cursor: () => {
+    const cfgPath = join(HOME, ".cursor", "mcp.json");
+    mkdirSync(join(HOME, ".cursor"), { recursive: true });
+    const cfg = existsSync(cfgPath) ? JSON.parse(readFileSync(cfgPath, "utf8")) : {};
+    cfg.mcpServers = cfg.mcpServers ?? {};
+    cfg.mcpServers.brain = { command: launcher, env: { BRAIN_REPO: brainPath } };
+    writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
+  },
+};
+for (const t of targets) {
+  const s = spinner();
+  s.start(`wiring ${t}`);
+  try {
+    installers[t]();
+    s.stop(`${t} wired`);
+  } catch (err) {
+    s.stop(`${t} failed: ${err.message}`);
+  }
+}
+
+// Tell Claude (the most common client) to prefer brain_* over Bash for the brain.
+if (targets.includes("claude")) {
+  const claudeMdPath = join(HOME, ".claude", "CLAUDE.md");
+  const marker = "<!-- brainincorp:auto -->";
+  const block = `\n${marker}\n## Brain\n\nA \`brain\` MCP server is installed (BRAIN_REPO=${brainPath}). When the user mentions "the brain", their notes, or asks to recall/save knowledge, prefer the brain tools — \`brain_search\`, \`brain_read\`, \`brain_list\`, \`brain_write\` — over Bash/Read/Write. The brain's vector index, retrieval log, and write validation only fire through these tools.\n<!-- /brainincorp:auto -->\n`;
+  mkdirSync(join(HOME, ".claude"), { recursive: true });
+  const cur = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, "utf8") : "";
+  if (!cur.includes(marker)) {
+    writeFileSync(claudeMdPath, cur + block);
+    note("added brain hint to ~/.claude/CLAUDE.md");
+  }
+}
+
+outro(`done. open a fresh ${targets[0]} session and ask: "list my brain"`);

package/package.json

@@ -1,9 +1,35 @@
 {
   "name": "brainincorp",
-  "version": "0.0.1",
-  "description": "reserved. your brain. lives in your repo.",
-  "bin": { "brainincorp": "./cli.js" },
+  "version": "0.2.0",
+  "description": "Set up a brain on your machine — a policy-aware MCP server wired into Claude Code, Codex, and Cursor. Your brain lives in your git repo.",
+  "type": "module",
+  "bin": {
+    "brainincorp": "./bin/brainincorp.mjs"
+  },
+  "files": [
+    "bin",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/brainincorp/cli.git"
+  },
   "homepage": "https://brainincorp.com",
-  "author": "brainincorp"
+  "bugs": "https://github.com/brainincorp/cli/issues",
+  "keywords": [
+    "mcp",
+    "brain",
+    "claude-code",
+    "codex",
+    "cursor",
+    "knowledge-base",
+    "agent"
+  ],
+  "dependencies": {
+    "@clack/prompts": "^0.10.0"
+  }
 }

package/cli.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.log("brainincorp — coming soon. https://brainincorp.com");