@mayurdluffy/cbm-cli 1.0.7

package/lib/binary.js

@@ -0,0 +1,133 @@
+const { execSync, spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const readline = require("readline");
+const { C, log } = require("./logger");
+const {
+  isWindows,
+  getHomeDir,
+  findBinary,
+  binaryExists,
+  getLocalBinDir,
+  getCacheDir,
+  getConfigDir,
+} = require("./system");
+
+function getBinaryVersion() {
+  try {
+    return execSync("codebase-memory-mcp --version", { encoding: "utf8" })
+      .trim()
+      .split("\n")[0]
+      .replace(/^codebase-memory-mcp\s+/, "");
+  } catch {
+    return "unknown";
+  }
+}
+
+async function ensureBinary(onMissing) {
+  if (binaryExists()) return;
+
+  log.warn("codebase-memory-mcp not found");
+  console.log(
+    `  ${C.cyan}codebase-memory-mcp${C.reset} is required but not installed.`,
+  );
+  console.log(`  It will be installed to: ${C.bold}${getLocalBinDir()}${C.reset}`);
+  console.log("");
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  const answer = await new Promise((resolve) => {
+    rl.question(`  Auto-install now? [Y/n]: `, resolve);
+  });
+  rl.close();
+
+  if (answer.toLowerCase() === "n") {
+    log.error("Installation cancelled.");
+    log.info(`Run manually: ${C.cyan}cbm install${C.reset}`);
+    process.exit(1);
+  }
+
+  if (onMissing) {
+    await onMissing();
+  }
+}
+
+function killServer() {
+  try {
+    if (isWindows()) {
+      execSync("taskkill /F /IM codebase-memory-mcp.exe 2>nul", {
+        stdio: "ignore",
+      });
+    } else {
+      execSync('pkill -f "codebase-memory-mcp" 2>/dev/null || true', {
+        stdio: "ignore",
+      });
+    }
+  } catch {}
+}
+
+function isServerRunning() {
+  try {
+    if (isWindows()) {
+      execSync("tasklist | findstr codebase-memory-mcp", { stdio: "ignore" });
+      return true;
+    } else {
+      execSync('pgrep -f "codebase-memory-mcp" > /dev/null 2>&1', {
+        stdio: "ignore",
+      });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+}
+
+async function installBinary() {
+  log.info("Downloading installer...");
+  const installUrl =
+    "https://raw.githubusercontent.com/DeusData/codebase-memory-mcp/main/install.sh";
+  const tempInstall = path.join(os.tmpdir(), `cbm_install_${Date.now()}.sh`);
+
+  try {
+    const response = await fetch(installUrl);
+    if (!response.ok) throw new Error("Download failed");
+    fs.writeFileSync(tempInstall, await response.text());
+
+    const result = spawn("bash", [tempInstall], { stdio: "inherit" });
+    await new Promise((resolve, reject) => {
+      result.on("close", (code) => {
+        fs.unlinkSync(tempInstall);
+        if (code === 0) resolve();
+        else reject(new Error(`Installer exited with code ${code}`));
+      });
+    });
+
+    if (binaryExists()) {
+      const version = getBinaryVersion();
+      log.ok(`Installed: ${C.cyan}${version}${C.reset}`);
+    } else {
+      log.error("Installed but not on PATH");
+      log.info(`Add: ${C.cyan}export PATH="$HOME/.local/bin:$PATH"${C.reset}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    log.error(`Installation failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  findBinary,
+  binaryExists,
+  getBinaryVersion,
+  ensureBinary,
+  killServer,
+  isServerRunning,
+  installBinary,
+  getLocalBinDir,
+  getCacheDir,
+  getConfigDir,
+};

package/lib/commands.js

@@ -0,0 +1,498 @@
+const { execSync, spawn } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+
+const { C, log } = require("./logger");
+const { SCRIPT_VERSION, AGENTS, NUM_AGENTS } = require("./constants");
+const { showBanner, formatBox, selectAgents } = require("./ui");
+const {
+  binaryExists,
+  getBinaryVersion,
+  ensureBinary,
+  killServer,
+  isServerRunning,
+  installBinary,
+} = require("./binary");
+const {
+  createWrapper,
+  createAgentConfig,
+  createGlobalConfig,
+} = require("./agents");
+const {
+  updateGitignore,
+  updateGitattributes,
+  cleanupTempFiles,
+  getArtifactInfo,
+} = require("./git");
+const { getHomeDir } = require("./system");
+
+async function cmdInstall(options = {}) {
+  showBanner();
+  log.step("Installing codebase-memory-mcp...");
+
+  if (binaryExists()) {
+    const current = getBinaryVersion();
+    log.warn(`Already installed: ${C.cyan}${current}${C.reset}`);
+    if (!options.yes && process.stdin.isTTY) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      const answer = await new Promise((resolve) =>
+        rl.question("  Reinstall/Update? [y/N]: ", resolve),
+      );
+      rl.close();
+      if (answer.toLowerCase() !== "y") {
+        log.info("Skipping installation.");
+        return;
+      }
+    }
+  }
+
+  await installBinary();
+
+  console.log("");
+  log.info("Which coding agents do you use?");
+  const selected = await selectAgents(
+    "Configure which coding agents globally?",
+    options,
+  );
+
+  if (selected.length > 0) {
+    log.step("Creating global agent configs...");
+    for (const num of selected) {
+      createGlobalConfig(AGENTS[num - 1]);
+    }
+  }
+
+  log.step("Enabling auto-index...");
+  try {
+    execSync("codebase-memory-mcp config set auto_index true", {
+      stdio: "ignore",
+    });
+    log.ok("Auto-index enabled");
+  } catch {
+    log.warn("Could not enable auto-index");
+  }
+
+  console.log("");
+  formatBox([`✅  Installation complete!`]);
+  console.log("");
+  log.info(`Next: ${C.cyan}cd your-project && cbm build${C.reset}`);
+}
+
+async function cmdBuild(options = {}) {
+  showBanner();
+  await ensureBinary(() => cmdInstall(options));
+
+  const projectDir = process.cwd();
+  const projectName = path.basename(projectDir);
+
+  log.step(`Building shareable graph for: ${C.bold}${projectName}${C.reset}`);
+  console.log("");
+
+  fs.mkdirSync(path.join(projectDir, ".codebase-memory"), { recursive: true });
+  createWrapper(path.join(projectDir, ".codebase-memory"));
+  log.ok(`Created wrapper: ${C.cyan}.codebase-memory/cbm-server.sh${C.reset}`);
+
+  console.log("");
+  log.info("Which agents should use this project's graph?");
+  const selected = await selectAgents(
+    "Configure which agents for this project?",
+    options,
+  );
+
+  if (selected.length > 0) {
+    log.step("Creating agent configs...");
+    for (const num of selected) {
+      createAgentConfig(num - 1, projectDir);
+    }
+  }
+
+  updateGitignore(projectDir);
+  updateGitattributes(projectDir);
+
+  log.step("Stopping any running server...");
+  killServer();
+  log.ok("Server stopped");
+
+  log.step(`Indexing ${C.bold}${projectName}${C.reset}...`);
+  const env = {
+    ...process.env,
+    CBM_CACHE_DIR: path.join(projectDir, ".codebase-memory"),
+  };
+
+  try {
+    execSync(
+      `codebase-memory-mcp cli index_repository --repo-path "${projectDir}" --persistence true`,
+      { env, stdio: "inherit" },
+    );
+    log.ok("Indexed successfully");
+  } catch (err) {
+    log.error("Indexing failed");
+    process.exit(1);
+  }
+
+  cleanupTempFiles(path.join(projectDir, ".codebase-memory"));
+
+  const artifact = getArtifactInfo(projectDir);
+  if (artifact.exists) {
+    log.ok(`Artifact: ${C.cyan}graph.db.zst${C.reset} (${artifact.size} MB)`);
+  } else {
+    log.warn("graph.db.zst not found. Check server logs.");
+  }
+
+  log.step("Ensuring auto-index is enabled...");
+  try {
+    execSync("codebase-memory-mcp config set auto_index true", {
+      stdio: "ignore",
+    });
+    log.ok("Auto-index enabled");
+  } catch {
+    log.warn("Could not verify auto-index status");
+  }
+
+  const names =
+    selected.length > 0
+      ? selected.map((n) => AGENTS[n - 1].name).join(", ")
+      : "none configured";
+
+  console.log("");
+  formatBox([`🚀  ${C.bold}${projectName}${C.reset} graph is ready to share!`]);
+  console.log("");
+  console.log(
+    `  ${C.cyan}Artifact:${C.reset}  ${path.join(projectDir, ".codebase-memory", "graph.db.zst")}`,
+  );
+  console.log(`  ${C.cyan}Agents:${C.reset}    ${names}`);
+  console.log("");
+  console.log(`  ${C.bold}Next:${C.reset}`);
+  console.log(
+    `    ${C.yellow}1.${C.reset} ${C.cyan}git add .codebase-memory/graph.db.zst${C.reset}`,
+  );
+  console.log(
+    `    ${C.yellow}2.${C.reset} ${C.cyan}git commit -m "Add shareable codebase graph"${C.reset}`,
+  );
+  console.log(
+    `    ${C.yellow}3.${C.reset} Teammates run ${C.cyan}cbm use${C.reset} → no indexing needed`,
+  );
+  console.log("");
+}
+
+async function cmdUse(options = {}) {
+  await ensureBinary(() => cmdInstall(options));
+
+  const projectDir = process.cwd();
+  const projectName = path.basename(projectDir);
+  const zstPath = path.join(projectDir, ".codebase-memory", "graph.db.zst");
+
+  if (!fs.existsSync(zstPath)) {
+    log.error("No graph.db.zst found");
+    log.info(`Run: ${C.cyan}cbm build${C.reset}`);
+    process.exit(1);
+  }
+
+  log.step(`Using shared graph for: ${C.bold}${projectName}${C.reset}`);
+  console.log("");
+
+  if (
+    !fs.existsSync(path.join(projectDir, ".codebase-memory", "cbm-server.sh"))
+  ) {
+    createWrapper(path.join(projectDir, ".codebase-memory"));
+    log.ok(
+      `Created wrapper: ${C.cyan}.codebase-memory/cbm-server.sh${C.reset}`,
+    );
+  }
+
+  console.log("");
+  log.info("Which agents should use this project's graph?");
+  const selected = await selectAgents(
+    "Configure which agents for this project?",
+    options,
+  );
+
+  if (selected.length > 0) {
+    log.step("Creating agent configs...");
+    for (const num of selected) {
+      createAgentConfig(num - 1, projectDir);
+    }
+  }
+
+  const artifact = getArtifactInfo(projectDir);
+  const names =
+    selected.length > 0
+      ? selected.map((n) => AGENTS[n - 1].name).join(", ")
+      : "none configured";
+
+  console.log("");
+  formatBox([
+    `✅  ${C.bold}${projectName}${C.reset} graph ready! No indexing needed.`,
+  ]);
+  console.log("");
+  console.log(
+    `  ${C.cyan}Artifact:${C.reset}  ${zstPath} (${artifact.size} MB)`,
+  );
+  console.log(`  ${C.cyan}Agents:${C.reset}    ${names}`);
+  console.log(`  ${C.cyan}Status:${C.reset}    Ready to use`);
+  console.log("");
+  console.log(
+    `  ${C.bold}Next:${C.reset} Restart your agent and start coding!`,
+  );
+  console.log("");
+}
+
+async function cmdReindex(options = {}) {
+  await ensureBinary(() => cmdInstall(options));
+
+  const projectDir = process.cwd();
+  const projectName = path.basename(projectDir);
+
+  if (!fs.existsSync(path.join(projectDir, ".codebase-memory"))) {
+    log.error("No .codebase-memory/ found");
+    log.info(`Run: ${C.cyan}cbm build${C.reset}`);
+    process.exit(1);
+  }
+
+  log.step(`Re-indexing ${C.bold}${projectName}${C.reset}...`);
+
+  killServer();
+
+  const env = {
+    ...process.env,
+    CBM_CACHE_DIR: path.join(projectDir, ".codebase-memory"),
+  };
+
+  try {
+    execSync(
+      `codebase-memory-mcp cli index_repository --repo-path "${projectDir}" --persistence true`,
+      { env, stdio: "inherit" },
+    );
+    log.ok(`${projectName} re-indexed`);
+
+    cleanupTempFiles(path.join(projectDir, ".codebase-memory"));
+
+    const artifact = getArtifactInfo(projectDir);
+    log.ok(`Artifact: ${C.cyan}graph.db.zst${C.reset} (${artifact.size} MB)`);
+  } catch {
+    log.error("Re-index failed");
+    process.exit(1);
+  }
+}
+
+function cmdStatus(options = {}) {
+  showBanner();
+  const projectDir = process.cwd();
+  const projectName = path.basename(projectDir);
+
+  console.log(
+    `  ${C.bold}Project:${C.reset}  ${C.cyan}${projectName}${C.reset}`,
+  );
+  console.log(`  ${C.bold}Path:${C.reset}     ${C.dim}${projectDir}${C.reset}`);
+  console.log("");
+
+  const artifact = getArtifactInfo(projectDir);
+  if (artifact.exists) {
+    log.ok(
+      `Shareable artifact: ${C.cyan}graph.db.zst${C.reset} (${artifact.size} MB)`,
+    );
+  } else {
+    log.warn("No graph.db.zst found");
+  }
+
+  const found = [];
+  for (let i = 0; i < NUM_AGENTS; i++) {
+    const agentConfigPath = path.join(projectDir, AGENTS[i].config);
+    if (fs.existsSync(agentConfigPath)) {
+      found.push(AGENTS[i].name);
+    }
+    if (AGENTS[i].name === "Aider") {
+      if (fs.existsSync(path.join(projectDir, "CONVENTIONS.md"))) {
+        found.push("Aider (CONVENTIONS.md)");
+      }
+      if (fs.existsSync(path.join(projectDir, "cbm-aider"))) {
+        found.push("Aider (cbm-aider wrapper)");
+      }
+    }
+  }
+
+  if (found.length > 0) {
+    log.ok(`Agent configs: ${C.cyan}${found.join(", ")}${C.reset}`);
+  } else {
+    log.warn("No agent configs found");
+  }
+
+  if (isServerRunning()) {
+    log.ok(`Server: ${C.green}running${C.reset}`);
+  } else {
+    log.info(`Server: ${C.cyan}idle${C.reset} (starts on agent connect)`);
+  }
+}
+
+async function cmdUpdate(options = {}) {
+  await ensureBinary(() => cmdInstall(options));
+
+  const oldVersion = getBinaryVersion();
+  log.info(`Current: ${C.cyan}${oldVersion}${C.reset}`);
+
+  await cmdInstall(options);
+
+  const newVersion = getBinaryVersion();
+  if (oldVersion !== newVersion) {
+    log.ok(
+      `Updated: ${C.cyan}${oldVersion}${C.reset} → ${C.cyan}${newVersion}${C.reset}`,
+    );
+  } else {
+    log.ok(`Already latest: ${C.cyan}${newVersion}${C.reset}`);
+  }
+}
+
+function cmdVersion(options = {}) {
+  showBanner();
+  const lines = [`cbm version ${SCRIPT_VERSION}`];
+  if (binaryExists()) {
+    lines.push(`codebase-memory-mcp version ${getBinaryVersion()}`);
+  } else {
+    lines.push(`codebase-memory-mcp not installed`);
+  }
+  formatBox(lines);
+  if (!binaryExists()) {
+    console.log("");
+    log.info(`Run: ${C.cyan}cbm install${C.reset}`);
+  }
+}
+
+function cmdKill(options = {}) {
+  log.step("Killing codebase-memory-mcp server...");
+  killServer();
+  log.ok("Server killed");
+}
+
+function cmdUninstall(options = {}) {
+  log.step("Uninstalling codebase-memory-mcp...");
+
+  cmdKill();
+
+  const binPath = path.join(
+    getHomeDir(),
+    ".local",
+    "bin",
+    "codebase-memory-mcp",
+  );
+  const cacheDir = path.join(getHomeDir(), ".cache", "codebase-memory-mcp");
+  const configDir = path.join(getHomeDir(), ".config", "codebase-memory-mcp");
+
+  if (fs.existsSync(binPath)) {
+    fs.unlinkSync(binPath);
+    log.ok(`Removed: ${C.cyan}${binPath}${C.reset}`);
+  }
+  if (fs.existsSync(cacheDir)) {
+    fs.rmSync(cacheDir, { recursive: true });
+    log.ok(`Removed: ${C.cyan}${cacheDir}${C.reset}`);
+  }
+  if (fs.existsSync(configDir)) {
+    fs.rmSync(configDir, { recursive: true });
+    log.ok(`Removed: ${C.cyan}${configDir}${C.reset}`);
+  }
+
+  console.log("");
+  formatBox([`🗑️  codebase-memory-mcp uninstalled successfully`]);
+  console.log("");
+  log.info(`Reinstall: ${C.cyan}cbm install${C.reset}`);
+}
+
+function cmdHelp(options = {}) {
+  showBanner();
+  console.log(`  ${C.bold}Usage:${C.reset} ${C.cyan}cbm [command]${C.reset}`);
+  console.log("");
+  console.log(`  ${C.bold}Setup:${C.reset}`);
+  console.log(
+    `    ${C.green}install${C.reset} ${C.dim}(i)${C.reset}      Install codebase-memory-mcp + select agents`,
+  );
+  console.log(
+    `    ${C.green}update${C.reset} ${C.dim}(up)${C.reset}      Update to latest version`,
+  );
+  console.log(`    ${C.green}uninstall${C.reset}    Remove from system`);
+  console.log(
+    `    ${C.green}version${C.reset} ${C.dim}(-V, -v)${C.reset}  Show version info`,
+  );
+  console.log(
+    `    ${C.green}kill${C.reset} ${C.dim}(k)${C.reset}         Stop running server`,
+  );
+  console.log(
+    `    ${C.green}help${C.reset} ${C.dim}(-h, --help)${C.reset}  Show help`,
+  );
+  console.log("");
+  console.log(`  ${C.bold}Project:${C.reset}`);
+  console.log(
+    `    ${C.green}build${C.reset} ${C.dim}(b)${C.reset}        Index + create shareable graph + select agents`,
+  );
+  console.log(
+    `    ${C.green}use${C.reset} ${C.dim}(u)${C.reset}          Use shared graph (no indexing needed)`,
+  );
+  console.log(
+    `    ${C.green}re-index${C.reset} ${C.dim}(ri)${C.reset}    Force re-index + fresh artifact`,
+  );
+  console.log(
+    `    ${C.green}status${C.reset} ${C.dim}(s)${C.reset}       Show project graph status`,
+  );
+  console.log("");
+  console.log(`  ${C.bold}Options:${C.reset}`);
+  console.log(`    ${C.dim}--version, -V, -v  Show version${C.reset}`);
+  console.log(`    ${C.dim}--help, -h         Show help${C.reset}`);
+  console.log(`    ${C.dim}--yes, -y          Skip prompts${C.reset}`);
+  console.log(
+    `    ${C.dim}--agents, -a       Specify agents (comma-separated)${C.reset}`,
+  );
+  console.log("");
+  console.log(`  ${C.bold}Raw CLI:${C.reset}`);
+  console.log(
+    `    ${C.green}cbm <cmd>${C.reset}    Any codebase-memory-mcp CLI command`,
+  );
+  console.log(
+    `    ${C.dim}Example: cbm cli search_graph '{"name_pattern": ".*"}'${C.reset}`,
+  );
+  console.log("");
+  console.log(`  ${C.bold}Supported Agents:${C.reset}`);
+  console.log(
+    `    ${C.dim}Claude Code, Codex CLI, Gemini CLI, Zed, OpenCode,${C.reset}`,
+  );
+  console.log(
+    `    ${C.dim}Antigravity, Aider, KiloCode, VS Code, OpenClaw, Kiro${C.reset}`,
+  );
+  console.log("");
+  console.log(`  ${C.yellow}Notes:${C.reset}`);
+  console.log(
+    `    ${C.dim}• Aider: No native MCP config — use ./cbm-aider wrapper${C.reset}`,
+  );
+  console.log(
+    `    ${C.dim}• Antigravity: Shares Gemini CLI config file${C.reset}`,
+  );
+  console.log("");
+  console.log(`  ${C.yellow}Workflow:${C.reset}`);
+  console.log(
+    `    ${C.cyan}cbm install${C.reset} → select agents → ${C.cyan}cbm build${C.reset} → select agents → ${C.cyan}git push${C.reset}`,
+  );
+  console.log("");
+  console.log(`  ${C.dim}cbm v${SCRIPT_VERSION}${C.reset}`);
+  console.log("");
+}
+
+async function passThrough(args, options = {}) {
+  await ensureBinary(() => cmdInstall(options));
+  const child = spawn("codebase-memory-mcp", args, { stdio: "inherit" });
+  child.on("close", (code) => process.exit(code || 0));
+}
+
+module.exports = {
+  cmdInstall,
+  cmdBuild,
+  cmdUse,
+  cmdReindex,
+  cmdStatus,
+  cmdUpdate,
+  cmdVersion,
+  cmdKill,
+  cmdUninstall,
+  cmdHelp,
+  passThrough,
+};