@cruxhive/cli 0.3.0

package/bin/cruxhive.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+
+const { init }    = require("../lib/init");
+const { sync }    = require("../lib/sync");
+const { health }  = require("../lib/health");
+const { ui }      = require("../lib/ui");
+const { index }   = require("../lib/index");
+const { propose } = require("../lib/propose");
+const { review }  = require("../lib/review");
+
+const [, , cmd, ...args] = process.argv;
+
+const commands = { init, sync, health, ui, index, propose, review };
+
+if (!cmd || cmd === "--help" || cmd === "-h") {
+  console.log(`cruxhive v${require("../package.json").version}
+
+Usage: cruxhive <command>
+
+Commands:
+  init      Bootstrap CruxHive in the current project
+  index     Index .llm/ markdown files into the local knowledge base
+  propose   Propose a new knowledge entry for human review
+  review    Interactively approve or reject pending proposals
+  sync      Sync org-layer context from the configured remote
+  health    Show knowledge base health summary
+  ui        Open the approval queue dashboard (localhost:3847)
+
+Options:
+  --help    Show this help message
+`);
+  process.exit(0);
+}
+
+const fn = commands[cmd];
+if (!fn) {
+  console.error(`Unknown command: ${cmd}\nRun cruxhive --help for usage.`);
+  process.exit(1);
+}
+
+fn(args).catch((err) => {
+  console.error(`\nError: ${err.message}`);
+  process.exit(1);
+});

package/lib/health.js

@@ -0,0 +1,130 @@
+"use strict";
+
+const { existsSync, readdirSync, readFileSync, statSync } = require("fs");
+const { join } = require("path");
+
+function countFiles(dir) {
+  if (!existsSync(dir)) return 0;
+  try {
+    return readdirSync(dir).filter((f) => f.endsWith(".md")).length;
+  } catch {
+    return 0;
+  }
+}
+
+function staleCheck(filePath, maxDays = 90) {
+  if (!existsSync(filePath)) return null;
+  const mtime = statSync(filePath).mtimeMs;
+  const ageDays = (Date.now() - mtime) / 86400000;
+  return ageDays > maxDays ? Math.floor(ageDays) : null;
+}
+
+function parseFrontmatter(content) {
+  const m = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return {};
+  const obj = {};
+  for (const line of m[1].split("\n")) {
+    const [k, ...rest] = line.split(":");
+    if (k && rest.length) obj[k.trim()] = rest.join(":").trim();
+  }
+  return obj;
+}
+
+function badge(ok) {
+  return ok ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m";
+}
+
+function fmt(label, value, note = "") {
+  const pad = " ".repeat(Math.max(0, 14 - label.length));
+  const n = note ? `  \x1b[90m${note}\x1b[0m` : "";
+  console.log(`  ${label}${pad}${value}${n}`);
+}
+
+async function health(_args) {
+  const cwd = process.cwd();
+  const date = new Date().toISOString().split("T")[0];
+  const project = cwd.split("/").pop();
+
+  console.log(`\n\x1b[1mcruxhive health\x1b[0m — ${date} · ${project}`);
+  console.log("  " + "─".repeat(44));
+
+  const contextExists = existsSync(join(cwd, ".llm", "CONTEXT.md"));
+  const mcpConfigured = (() => {
+    const p = join(cwd, ".mcp.json");
+    if (!existsSync(p)) return false;
+    try {
+      const cfg = JSON.parse(readFileSync(p, "utf8"));
+      return !!(cfg.mcpServers?.cruxhive);
+    } catch {
+      return false;
+    }
+  })();
+
+  const plansDir = join(cwd, ".llm", "plans");
+  const memoryDir = join(cwd, ".llm", "memory");
+  const contextDir = join(cwd, ".llm", "context");
+
+  const planCount = countFiles(plansDir) - (existsSync(join(plansDir, "active.md")) ? 1 : 0);
+  const memCount = countFiles(memoryDir);
+  const contextCount = countFiles(contextDir);
+
+  // Count all entries across .llm/ tree
+  let totalEntries = 0;
+  let constraintCount = 0;
+  let pendingCount = 0;
+  let stalePaths = [];
+
+  const scanDir = (dir) => {
+    if (!existsSync(dir)) return;
+    for (const f of readdirSync(dir)) {
+      if (!f.endsWith(".md")) continue;
+      const p = join(dir, f);
+      try {
+        const content = readFileSync(p, "utf8");
+        const fm = parseFrontmatter(content);
+        if (fm.type) {
+          totalEntries++;
+          if (fm.type === "constraint") constraintCount++;
+          if (!fm.approved_by || fm.approved_by === "~") pendingCount++;
+        }
+        const stale = staleCheck(p, 90);
+        if (stale) stalePaths.push({ path: f, days: stale });
+      } catch {}
+    }
+  };
+
+  scanDir(memoryDir);
+  scanDir(contextDir);
+  scanDir(plansDir);
+
+  // Output
+  fmt("CONTEXT.md", `${badge(contextExists)} ${contextExists ? "present" : "missing"}`,
+    contextExists ? "" : "run: cruxhive init");
+  fmt("MCP server", `${badge(mcpConfigured)} ${mcpConfigured ? "configured" : "not wired"}`,
+    mcpConfigured ? "" : "run: cruxhive init");
+
+  console.log("  " + "─".repeat(44));
+
+  fmt("Plans", planCount.toString());
+  fmt("Memory files", memCount.toString());
+  fmt("Context files", contextCount.toString());
+  if (totalEntries > 0) {
+    fmt("Typed entries", totalEntries.toString(), `${constraintCount} constraints`);
+  }
+  if (pendingCount > 0) {
+    fmt("Pending approval", pendingCount.toString(), "\x1b[33mapproval needed\x1b[0m");
+  }
+  if (stalePaths.length > 0) {
+    fmt("Stale (>90d)", stalePaths.length.toString(), stalePaths.map((s) => s.path).join(", "));
+  }
+
+  console.log("  " + "─".repeat(44));
+
+  if (!contextExists || !mcpConfigured) {
+    console.log("\n  Run \x1b[36mcruxhive init\x1b[0m to finish setup.\n");
+  } else {
+    console.log("\n  \x1b[32m✓ Ready.\x1b[0m MCP tools: context_radar, context_next_slice, context_write_plan\n");
+  }
+}
+
+module.exports = { health };

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+
+function ok(msg)  { console.log(`  \x1b[32m✓\x1b[0m  ${msg}`); }
+function err(msg) { console.log(`  \x1b[31m✗\x1b[0m  ${msg}`); }
+
+async function index(_args) {
+  const cwd = process.cwd();
+  console.log(`\n\x1b[1mcruxhive index\x1b[0m`);
+
+  const r = spawnSync("cruxhive-index", [], { cwd, stdio: "inherit" });
+  if (r.error) {
+    err("cruxhive-index not found — run: pip install cruxhive-mcp");
+    process.exit(1);
+  }
+  if (r.status !== 0) process.exit(r.status);
+}
+
+module.exports = { index };

package/lib/init.js

@@ -0,0 +1,179 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { mkdirSync, writeFileSync, existsSync, readFileSync } = require("fs");
+const { join } = require("path");
+const { createInterface } = require("readline");
+
+const CONTEXT_TEMPLATE = (projectName, date) => `---
+type: fact
+scope: project
+topic: project-context
+valid_at: ${date}
+confidence: high
+source: human
+---
+
+# ${projectName} — Context
+
+> One sentence describing what this project is and does.
+
+**Stack**: [your stack here]
+
+## Always read first
+
+\`.llm/plans/active.md\` — current sprint focus.
+
+## Repository layout
+
+| Path | Contents |
+|---|---|
+| \`src/\` | Source code |
+
+## Conventions
+
+- Add your team's key conventions here
+- Each rule should explain WHY, not just WHAT
+
+## Three-tier context model (CruxHive)
+
+| Tier | Location | Contents |
+|---|---|---|
+| **Org** | Shared remote | Cross-project facts, guardrails, architecture decisions |
+| **Project** | \`.llm/\` (this repo) | Plans, audits, context — project-specific |
+| **Personal** | \`~/.cruxhive/personal/\` | Developer preferences — never shared |
+`;
+
+const MCP_ENTRY = {
+  command: "uvx",
+  args: ["cruxhive-mcp"],
+  type: "stdio",
+};
+
+function ok(msg)   { console.log(`  \x1b[32m✓\x1b[0m  ${msg}`); }
+function info(msg) { console.log(`  \x1b[36m·\x1b[0m  ${msg}`); }
+function warn(msg) { console.log(`  \x1b[33m!\x1b[0m  ${msg}`); }
+function step(msg) { console.log(`\n\x1b[1m${msg}\x1b[0m`); }
+
+function hasBin(name) {
+  return spawnSync(name, ["--version"], { stdio: "pipe" }).status === 0;
+}
+
+function installMcp() {
+  if (hasBin("uv")) {
+    const r = spawnSync("uv", ["pip", "install", "cruxhive-mcp"], { stdio: "inherit" });
+    if (r.status !== 0) throw new Error("uv pip install cruxhive-mcp failed");
+    return "uv";
+  }
+  if (hasBin("pip3") || hasBin("pip")) {
+    const pip = hasBin("pip3") ? "pip3" : "pip";
+    const r = spawnSync(pip, ["install", "cruxhive-mcp"], { stdio: "inherit" });
+    if (r.status !== 0) throw new Error(`${pip} install cruxhive-mcp failed`);
+    return pip;
+  }
+  throw new Error(
+    "Neither uv nor pip found. Install uv (https://docs.astral.sh/uv/) or pip first."
+  );
+}
+
+function wireMcp(cwd) {
+  const mcpPath = join(cwd, ".mcp.json");
+  let cfg = existsSync(mcpPath)
+    ? JSON.parse(readFileSync(mcpPath, "utf8"))
+    : { mcpServers: {} };
+
+  if (!cfg.mcpServers) cfg.mcpServers = {};
+
+  if (cfg.mcpServers.cruxhive) {
+    info(".mcp.json already has cruxhive entry");
+    return;
+  }
+
+  cfg.mcpServers.cruxhive = MCP_ENTRY;
+  writeFileSync(mcpPath, JSON.stringify(cfg, null, 2) + "\n");
+  ok("cruxhive-mcp registered in .mcp.json");
+}
+
+function wireClaudeMd(cwd) {
+  const claudePath = join(cwd, "CLAUDE.md");
+  const contextPath = ".llm/CONTEXT.md";
+
+  if (existsSync(claudePath)) {
+    const content = readFileSync(claudePath, "utf8");
+    if (content.includes("CONTEXT.md")) {
+      info("CLAUDE.md already references CONTEXT.md");
+      return;
+    }
+    writeFileSync(claudePath, content.trimEnd() + "\n\n<!-- CruxHive canonical context: .llm/CONTEXT.md -->\n");
+    ok("CLAUDE.md patched with CONTEXT.md reference");
+  } else {
+    const target = contextPath;
+    // Create a thin symlink — requires filesystem support
+    try {
+      require("fs").symlinkSync(target, claudePath);
+      ok("CLAUDE.md → .llm/CONTEXT.md (symlink)");
+    } catch {
+      warn("Could not create CLAUDE.md symlink — copy .llm/CONTEXT.md to CLAUDE.md manually");
+    }
+  }
+}
+
+async function init(args) {
+  const cwd = process.cwd();
+  const date = new Date().toISOString().split("T")[0];
+  const projectName = cwd.split("/").pop();
+
+  console.log(`\n\x1b[1mCruxHive init\x1b[0m — ${projectName}`);
+
+  // ─── .llm/ structure ─────────────────────────────────────────────────────
+  step("1/4  Creating .llm/ structure");
+
+  const dirs = [".llm", ".llm/plans", ".llm/context", ".llm/memory"];
+  for (const dir of dirs) {
+    mkdirSync(join(cwd, dir), { recursive: true });
+  }
+  ok("directories: .llm/ .llm/plans/ .llm/context/ .llm/memory/");
+
+  const contextPath = join(cwd, ".llm", "CONTEXT.md");
+  if (!existsSync(contextPath)) {
+    writeFileSync(contextPath, CONTEXT_TEMPLATE(projectName, date));
+    ok(".llm/CONTEXT.md created");
+  } else {
+    info(".llm/CONTEXT.md already exists — skipped");
+  }
+
+  const activePath = join(cwd, ".llm", "plans", "active.md");
+  if (!existsSync(activePath)) {
+    writeFileSync(activePath, `# Active Plans\n\n_No active plans yet._\n`);
+    ok(".llm/plans/active.md created");
+  } else {
+    info(".llm/plans/active.md already exists — skipped");
+  }
+
+  // ─── install cruxhive-mcp ─────────────────────────────────────────────────
+  step("2/4  Installing cruxhive-mcp");
+  const installer = installMcp();
+  ok(`cruxhive-mcp installed via ${installer}`);
+
+  // ─── wire .mcp.json ───────────────────────────────────────────────────────
+  step("3/4  Wiring .mcp.json");
+  wireMcp(cwd);
+
+  // ─── wire AI tool context files ───────────────────────────────────────────
+  step("4/4  Wiring AI tools");
+  wireClaudeMd(cwd);
+
+  // ─── done ─────────────────────────────────────────────────────────────────
+  console.log(`
+\x1b[32m✓ CruxHive initialized in ${projectName}\x1b[0m
+
+Next steps:
+  1. Edit \x1b[36m.llm/CONTEXT.md\x1b[0m — describe your project, stack, and conventions
+  2. Reload your AI tool — the cruxhive-mcp server is now available
+  3. Run \x1b[36mcruxhive health\x1b[0m to see knowledge base status
+
+MCP tools now available: context_radar, context_next_slice, context_write_plan, context_sync_memory
+`);
+}
+
+module.exports = { init };

package/lib/propose.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { createInterface } = require("readline");
+const { execSync } = require("child_process");
+const { writeFileSync, unlinkSync, readFileSync } = require("fs");
+const { tmpdir } = require("os");
+const { join } = require("path");
+
+const TYPES = ["fact", "decision", "plan", "pattern", "constraint", "research", "outcome"];
+
+function prompt(rl, question) {
+  return new Promise((res) => rl.question(question, res));
+}
+
+async function selectType(rl) {
+  console.log("\n  Type:");
+  TYPES.forEach((t, i) => console.log(`    ${i + 1}. ${t}`));
+  const ans = await prompt(rl, "  Choose [1-7]: ");
+  const idx = parseInt(ans, 10) - 1;
+  return TYPES[idx] || null;
+}
+
+function openEditor(initial) {
+  const tmp = join(tmpdir(), `cruxhive-propose-${Date.now()}.md`);
+  writeFileSync(tmp, initial, "utf8");
+  const editor = process.env.EDITOR || process.env.VISUAL || "nano";
+  spawnSync(editor, [tmp], { stdio: "inherit" });
+  const content = readFileSync(tmp, "utf8").trim();
+  unlinkSync(tmp);
+  return content;
+}
+
+async function propose(_args) {
+  const cwd = process.cwd();
+  console.log(`\n\x1b[1mcruxhive propose\x1b[0m — add a knowledge entry`);
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  const type = await selectType(rl);
+  if (!type) {
+    console.log("  Invalid selection.");
+    rl.close();
+    return;
+  }
+
+  const topic = (await prompt(rl, `\n  Topic (1-3 words): `)).trim();
+  if (!topic) { rl.close(); return; }
+
+  const scope = (await prompt(rl, `  Scope [project]: `)).trim() || "project";
+  rl.close();
+
+  console.log(`\n  Opening editor for content…`);
+  const placeholder = `<!-- Describe the ${type}: what, why, and any relevant context -->\n`;
+  const content = openEditor(placeholder);
+
+  if (!content || content === placeholder.trim()) {
+    console.log("  \x1b[33m!\x1b[0m  Empty content — proposal cancelled.");
+    return;
+  }
+
+  const r = spawnSync(
+    "cruxhive-propose",
+    [type, topic, scope],
+    { cwd, stdio: ["pipe", "inherit", "inherit"], input: content }
+  );
+
+  if (r.error) {
+    console.log("  \x1b[31m✗\x1b[0m  cruxhive-propose not found — run: pip install cruxhive-mcp");
+    process.exit(1);
+  }
+  if (r.status !== 0) process.exit(r.status);
+}
+
+module.exports = { propose };

package/lib/review.js

@@ -0,0 +1,80 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { createInterface } = require("readline");
+
+function prompt(rl, question) {
+  return new Promise((res) => rl.question(question, res));
+}
+
+function badge(type) {
+  const colors = {
+    fact: "\x1b[34m", constraint: "\x1b[31m", decision: "\x1b[32m",
+    pattern: "\x1b[33m", plan: "\x1b[35m", research: "\x1b[36m", outcome: "\x1b[32m",
+  };
+  const c = colors[type] || "\x1b[90m";
+  return `${c}[${type || "?"}]\x1b[0m`;
+}
+
+async function review(_args) {
+  const cwd = process.cwd();
+  console.log(`\n\x1b[1mcruxhive review\x1b[0m — pending proposals\n`);
+
+  const r = spawnSync("cruxhive-review", [], { cwd, stdio: ["inherit", "pipe", "inherit"] });
+  if (r.error) {
+    console.log("  \x1b[31m✗\x1b[0m  cruxhive-review not found — run: pip install cruxhive-mcp");
+    process.exit(1);
+  }
+
+  let pending;
+  try {
+    pending = JSON.parse(r.stdout.toString());
+  } catch {
+    console.log("  No pending proposals or index not built. Run: cruxhive index");
+    return;
+  }
+
+  if (pending.error) {
+    console.log(`  \x1b[31m✗\x1b[0m  ${pending.error}`);
+    return;
+  }
+
+  if (!pending.length) {
+    console.log("  \x1b[32m✓\x1b[0m  No pending proposals — knowledge base is fully reviewed.");
+    return;
+  }
+
+  console.log(`  ${pending.length} pending proposal(s)\n`);
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  let approved = 0, rejected = 0, skipped = 0;
+
+  for (const p of pending) {
+    const preview = (p.preview || "").trim().slice(0, 120);
+    console.log(`  ${badge(p.type)} \x1b[1m${p.path}\x1b[0m`);
+    console.log(`  topic: ${p.topic || "—"}  ·  proposed: ${p.valid_at || "?"}`);
+    if (preview) console.log(`  \x1b[90m${preview}…\x1b[0m`);
+
+    const ans = (await prompt(rl, `  [a]pprove / [r]eject / [s]kip: `)).trim().toLowerCase();
+
+    if (ans === "a" || ans === "approve") {
+      const approver = (await prompt(rl, `  Your name: `)).trim();
+      if (!approver) { console.log("  Skipped (no name given).\n"); skipped++; continue; }
+      const ra = spawnSync("cruxhive-approve", [p.path, approver], { cwd, stdio: "inherit" });
+      if (ra.status === 0) approved++;
+    } else if (ans === "r" || ans === "reject") {
+      const rr = spawnSync("cruxhive-reject", [p.path], { cwd, stdio: "inherit" });
+      if (rr.status === 0) rejected++;
+    } else {
+      console.log("  Skipped.");
+      skipped++;
+    }
+    console.log("");
+  }
+
+  rl.close();
+  console.log(`  Done: ${approved} approved · ${rejected} rejected · ${skipped} skipped\n`);
+}
+
+module.exports = { review };

package/lib/sync.js

@@ -0,0 +1,68 @@
+"use strict";
+
+const { spawnSync } = require("child_process");
+const { existsSync, readFileSync } = require("fs");
+const { join } = require("path");
+
+function ok(msg)   { console.log(`  \x1b[32m✓\x1b[0m  ${msg}`); }
+function warn(msg) { console.log(`  \x1b[33m!\x1b[0m  ${msg}`); }
+function err(msg)  { console.log(`  \x1b[31m✗\x1b[0m  ${msg}`); }
+
+function findSyncScript(cwd) {
+  const candidates = [
+    join(cwd, "..", "scripts", "sync-platform-memory.sh"),
+    join(cwd, "scripts", "sync-platform-memory.sh"),
+  ];
+  return candidates.find(existsSync) || null;
+}
+
+function getOrgRemote(cwd) {
+  const configPath = join(cwd, "cruxhive.config.yaml");
+  if (!existsSync(configPath)) return null;
+  const content = readFileSync(configPath, "utf8");
+  const m = content.match(/org_remote\s*:\s*(.+)/);
+  return m ? m[1].trim() : null;
+}
+
+async function sync(_args) {
+  const cwd = process.cwd();
+  console.log(`\n\x1b[1mcruxhive sync\x1b[0m`);
+
+  // Try workspace-level sync script first (mozbridge pattern)
+  const script = findSyncScript(cwd);
+  if (script) {
+    const r = spawnSync(script, [], { cwd, stdio: "inherit" });
+    if (r.status === 0) {
+      ok("Org context synced via sync-platform-memory.sh");
+    } else {
+      err("Sync script exited with non-zero status");
+    }
+    return;
+  }
+
+  // Try git-based org remote (Phase 4 pattern)
+  const remote = getOrgRemote(cwd);
+  if (remote) {
+    console.log(`  Pulling org context from: ${remote}`);
+    const r = spawnSync("git", ["pull", "--rebase", remote, "main"], {
+      cwd: join(cwd, ".llm"),
+      stdio: "inherit",
+    });
+    if (r.status === 0) {
+      ok("Org context synced from remote");
+    } else {
+      err("git pull failed — check your org_remote in cruxhive.config.yaml");
+    }
+    return;
+  }
+
+  warn("No sync source configured.");
+  console.log(`
+  Options:
+    1. Workspace sync script at ../scripts/sync-platform-memory.sh
+    2. Set org_remote in cruxhive.config.yaml for git-based org sync
+    3. Use Mozbridge for managed cloud sync (Phase 6)
+`);
+}
+
+module.exports = { sync };

package/lib/ui.js

@@ -0,0 +1,75 @@
+"use strict";
+
+const { spawnSync, spawn } = require("child_process");
+const { existsSync } = require("fs");
+
+const PORT = 3847;
+
+function ok(msg)   { console.log(`  \x1b[32m✓\x1b[0m  ${msg}`); }
+function info(msg) { console.log(`  \x1b[36m·\x1b[0m  ${msg}`); }
+function err(msg)  { console.log(`  \x1b[31m✗\x1b[0m  ${msg}`); }
+
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  spawnSync(cmd, [url], { stdio: "ignore" });
+}
+
+function checkUvicorn() {
+  const r = spawnSync("uvicorn", ["--version"], { stdio: "pipe" });
+  return r.status === 0;
+}
+
+async function ui(args) {
+  const cwd = process.cwd();
+  const serve = args.includes("--serve");
+
+  console.log(`\n\x1b[1mcruxhive ui\x1b[0m — approval dashboard`);
+
+  if (!existsSync(`${cwd}/.llm/cruxhive.db`)) {
+    console.log(`\n  \x1b[33m!\x1b[0m  Knowledge base not indexed yet.`);
+    console.log(`       Run: \x1b[36mcruxhive index\x1b[0m (or context_index MCP tool)\n`);
+  }
+
+  if (!checkUvicorn()) {
+    err("uvicorn not found — install the [ui] extra:");
+    console.log(`\n       \x1b[36mpip install "cruxhive-mcp[ui]"\x1b[0m\n`);
+    process.exit(1);
+  }
+
+  const url = `http://localhost:${PORT}`;
+  info(`Starting approval queue at ${url}`);
+
+  const proc = spawn(
+    "uvicorn",
+    [
+      "cruxhive_mcp.ui:app",
+      "--host", "0.0.0.0",
+      "--port", String(PORT),
+      "--factory",
+    ],
+    {
+      cwd,
+      stdio: "inherit",
+      env: { ...process.env, CRUXHIVE_ROOT: cwd },
+    }
+  );
+
+  proc.on("error", (e) => {
+    err(`Failed to start server: ${e.message}`);
+    process.exit(1);
+  });
+
+  // Give the server a moment to bind, then open browser
+  setTimeout(() => {
+    ok(`Server running at ${url}`);
+    openBrowser(url);
+  }, 1200);
+
+  process.on("SIGINT", () => {
+    proc.kill();
+    process.exit(0);
+  });
+}
+
+module.exports = { ui };

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@cruxhive/cli",
+  "version": "0.3.0",
+  "description": "CruxHive — team AI knowledge governance layer",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cruxhive/cruxhive"
+  },
+  "homepage": "https://cruxhive.com",
+  "keywords": ["ai", "mcp", "context", "knowledge", "claude", "cursor", "llm"],
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "cruxhive": "bin/cruxhive.js"
+  },
+  "files": [
+    "bin/",
+    "lib/"
+  ],
+  "dependencies": {}
+}