@mayurdluffy/cbm-cli 1.0.7

package/lib/constants.js

@@ -0,0 +1,93 @@
+const path = require("path");
+const os = require("os");
+
+const SCRIPT_VERSION = require("../package.json").version;
+
+const AGENTS = [
+  {
+    name: "Claude Code",
+    config: ".mcp.json",
+    format: "json",
+    globalDir: () => path.join(os.homedir(), ".claude"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "Codex CLI",
+    config: ".codex/config.toml",
+    format: "toml",
+    globalDir: () => path.join(os.homedir(), ".codex"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "Gemini CLI",
+    config: ".gemini/settings.json",
+    format: "json",
+    globalDir: () => path.join(os.homedir(), ".gemini"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "Zed",
+    config: ".zed/settings.json",
+    format: "jsonc",
+    globalDir: () => path.join(os.homedir(), ".config", "zed"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "OpenCode",
+    config: ".opencode/opencode.json",
+    format: "opencode-json",
+    globalDir: () => path.join(os.homedir(), ".opencode"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "Antigravity",
+    config: ".gemini/settings.json",
+    format: "json",
+    globalDir: () => path.join(os.homedir(), ".gemini"),
+    supportsMcpConfig: true,
+    sharesConfigWith: "Gemini CLI",
+  },
+  {
+    name: "Aider",
+    config: ".aider.conf.yml",
+    format: "yml",
+    globalDir: () => os.homedir(),
+    supportsMcpConfig: false,
+  },
+  {
+    name: "KiloCode",
+    config: ".kilo/kilo.jsonc",
+    format: "kilo-jsonc",
+    globalDir: () => path.join(os.homedir(), ".config", "kilo"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "VS Code",
+    config: ".vscode/mcp.json",
+    format: "vscode-json",
+    globalDir: () => path.join(os.homedir(), ".vscode"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "OpenClaw",
+    config: ".openclaw/openclaw.json",
+    format: "openclaw-json",
+    globalDir: () => path.join(os.homedir(), ".openclaw"),
+    supportsMcpConfig: true,
+  },
+  {
+    name: "Kiro",
+    config: ".kiro/settings/mcp.json",
+    format: "json",
+    globalDir: () => path.join(os.homedir(), ".kiro"),
+    supportsMcpConfig: true,
+  },
+];
+
+const NUM_AGENTS = AGENTS.length;
+
+module.exports = {
+  SCRIPT_VERSION,
+  AGENTS,
+  NUM_AGENTS,
+};

package/lib/git.js

@@ -0,0 +1,67 @@
+const fs = require("fs");
+const path = require("path");
+const { C, log } = require("./logger");
+
+const GITIGNORE_ENTRY = `\n# CBM\n.codebase-memory/*\n!.codebase-memory/graph.db.zst\n!.codebase-memory/cbm-server.sh\n`;
+
+const GITATTRIBUTES_ENTRY = `\n# CBM\n.codebase-memory/graph.db.zst merge=ours\n`;
+
+function updateGitignore(projectDir) {
+  const gitignorePath = path.join(projectDir, ".gitignore");
+
+  if (fs.existsSync(gitignorePath)) {
+    const content = fs.readFileSync(gitignorePath, "utf8");
+    if (!content.includes(".codebase-memory/")) {
+      fs.appendFileSync(gitignorePath, GITIGNORE_ENTRY);
+      log.ok(`Updated ${C.cyan}.gitignore${C.reset}`);
+    } else {
+      log.ok(`${C.cyan}.gitignore${C.reset} already configured`);
+    }
+  } else {
+    fs.writeFileSync(gitignorePath, GITIGNORE_ENTRY.trimStart());
+    log.ok(`Created ${C.cyan}.gitignore${C.reset}`);
+  }
+}
+
+function updateGitattributes(projectDir) {
+  const gitattributesPath = path.join(projectDir, ".gitattributes");
+
+  if (fs.existsSync(gitattributesPath)) {
+    const content = fs.readFileSync(gitattributesPath, "utf8");
+    if (!content.includes("graph.db.zst")) {
+      fs.appendFileSync(gitattributesPath, GITATTRIBUTES_ENTRY);
+      log.ok(`Updated ${C.cyan}.gitattributes${C.reset}`);
+    }
+  } else {
+    fs.writeFileSync(gitattributesPath, GITATTRIBUTES_ENTRY.trimStart());
+    log.ok(`Created ${C.cyan}.gitattributes${C.reset}`);
+  }
+}
+
+function cleanupTempFiles(cbmDir) {
+  const tempPatterns = [".db", ".db-shm", ".db-wal", "_config.db"];
+
+  for (const file of fs.readdirSync(cbmDir)) {
+    if (tempPatterns.some((pattern) => file.endsWith(pattern))) {
+      fs.unlinkSync(path.join(cbmDir, file));
+    }
+  }
+}
+
+function getArtifactInfo(projectDir) {
+  const zstPath = path.join(projectDir, ".codebase-memory", "graph.db.zst");
+
+  if (fs.existsSync(zstPath)) {
+    const size = (fs.statSync(zstPath).size / 1024 / 1024).toFixed(2);
+    return { exists: true, path: zstPath, size };
+  }
+
+  return { exists: false, path: zstPath, size: 0 };
+}
+
+module.exports = {
+  updateGitignore,
+  updateGitattributes,
+  cleanupTempFiles,
+  getArtifactInfo,
+};

package/lib/index.js

@@ -0,0 +1,111 @@
+const { log } = require("./logger");
+const {
+  cmdInstall,
+  cmdBuild,
+  cmdUse,
+  cmdReindex,
+  cmdStatus,
+  cmdUpdate,
+  cmdVersion,
+  cmdKill,
+  cmdUninstall,
+  cmdHelp,
+  passThrough,
+} = require("./commands");
+const { parseAgentOption } = require("./ui");
+
+const COMMANDS = {
+  install: cmdInstall,
+  i: cmdInstall,
+  build: cmdBuild,
+  b: cmdBuild,
+  use: cmdUse,
+  u: cmdUse,
+  "re-index": cmdReindex,
+  reindex: cmdReindex,
+  ri: cmdReindex,
+  status: cmdStatus,
+  s: cmdStatus,
+  update: cmdUpdate,
+  up: cmdUpdate,
+  version: cmdVersion,
+  v: cmdVersion,
+  "--version": cmdVersion,
+  "-V": cmdVersion,
+  "-v": cmdVersion,
+  uninstall: cmdUninstall,
+  remove: cmdUninstall,
+  rm: cmdUninstall,
+  kill: cmdKill,
+  k: cmdKill,
+  help: cmdHelp,
+  "--help": cmdHelp,
+  "-h": cmdHelp,
+  "": cmdHelp,
+};
+
+function parseOptions(argv) {
+  const options = {
+    yes: false,
+    agents: null,
+  };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--yes" || arg === "-y") {
+      options.yes = true;
+    } else if (arg === "--agents" || arg === "-a") {
+      options.agents = argv[i + 1];
+      i++;
+    } else if (arg.startsWith("--agents=")) {
+      options.agents = arg.slice("--agents=".length);
+    }
+  }
+
+  // Validate and normalize agents option
+  if (options.agents) {
+    const parsed = parseAgentOption(options.agents);
+    if (parsed.length === 0) {
+      log.error(`Invalid --agents value: ${options.agents}`);
+      process.exit(1);
+    }
+    options.agents = parsed.join(",");
+  }
+
+  return options;
+}
+
+function stripFlags(args) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--yes" || arg === "-y") {
+      continue;
+    }
+    if (arg === "--agents" || arg === "-a") {
+      i++;
+      continue;
+    }
+    if (arg.startsWith("--agents=")) {
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+
+async function main() {
+  const rawArgs = process.argv.slice(2);
+  const options = parseOptions(rawArgs);
+  const args = stripFlags(rawArgs);
+  const command = args[0] || "help";
+  const handler = COMMANDS[command];
+
+  if (handler) {
+    await handler(options);
+  } else {
+    await passThrough(args, options);
+  }
+}
+
+module.exports = { main, COMMANDS, parseOptions, stripFlags };

package/lib/logger.js

@@ -0,0 +1,21 @@
+const C = {
+  green: "\x1b[32m",
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  cyan: "\x1b[36m",
+  magenta: "\x1b[35m",
+  blue: "\x1b[34m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  reset: "\x1b[0m",
+};
+
+const log = {
+  info: (msg) => console.log(`${C.blue}ℹ ${C.reset} ${msg}`),
+  ok: (msg) => console.log(`${C.green}✔${C.reset} ${msg}`),
+  warn: (msg) => console.log(`${C.yellow}⚠${C.reset} ${msg}`),
+  error: (msg) => console.error(`${C.red}✖${C.reset} ${msg}`),
+  step: (msg) => console.log(`${C.cyan}▸${C.reset} ${msg}`),
+};
+
+module.exports = { C, log };

package/lib/system.js

@@ -0,0 +1,49 @@
+const { execSync } = require("child_process");
+const os = require("os");
+const path = require("path");
+
+function isWindows() {
+  return process.platform === "win32";
+}
+
+function getHomeDir() {
+  return os.homedir();
+}
+
+function findBinary(name) {
+  try {
+    const cmd = isWindows() ? "where" : "which";
+    const result = execSync(`${cmd} ${name}`, { stdio: "pipe", encoding: "utf8" })
+      .trim()
+      .split("\n")[0];
+    return result || null;
+  } catch {
+    return null;
+  }
+}
+
+function binaryExists(name = "codebase-memory-mcp") {
+  return findBinary(name) !== null;
+}
+
+function getLocalBinDir() {
+  return path.join(getHomeDir(), ".local", "bin");
+}
+
+function getCacheDir() {
+  return path.join(getHomeDir(), ".cache", "codebase-memory-mcp");
+}
+
+function getConfigDir() {
+  return path.join(getHomeDir(), ".config", "codebase-memory-mcp");
+}
+
+module.exports = {
+  isWindows,
+  getHomeDir,
+  findBinary,
+  binaryExists,
+  getLocalBinDir,
+  getCacheDir,
+  getConfigDir,
+};

package/lib/ui.js

@@ -0,0 +1,190 @@
+const { C, log } = require("./logger");
+const { AGENTS, NUM_AGENTS } = require("./constants");
+
+function showBanner() {
+  console.log(`${C.magenta}`);
+  console.log("   ██████╗ ██████╗ ███╗   ███╗");
+  console.log("  ██╔════╝ ██╔══██╗████╗ ████║");
+  console.log("  ██║      ██████╔╝██╔████╔██║");
+  console.log("  ██║      ██╔══██╗██║╚██╔╝██║");
+  console.log("  ╚██████╗ ██████╔╝██║ ╚═╝ ██║");
+  console.log("   ╚═════╝ ╚═════╝ ╚═╝     ╚═╝");
+  console.log(`${C.reset}`);
+  console.log(`  ${C.bold}Codebase Memory Manager${C.reset}`);
+  console.log(
+    `  - ${C.cyan}Supercharge your agentic coding — without the token bleed${C.reset}`,
+  );
+  console.log("");
+}
+
+function formatBox(lines) {
+  const width = 60;
+  const border = `${C.green}╔${"═".repeat(width)}╗${C.reset}`;
+  const bottom = `${C.green}╚${"═".repeat(width)}╝${C.reset}`;
+
+  console.log(border);
+  for (const line of lines) {
+    const padding = width - line.replace(/\x1b\[[0-9;]*m/g, "").length;
+    console.log(`${C.green}║${C.reset} ${line}${" ".repeat(Math.max(0, padding - 1))}${C.green}║${C.reset}`);
+  }
+  console.log(bottom);
+}
+
+function parseAgentOption(value) {
+  if (!value) return [];
+  return value
+    .split(",")
+    .map((s) => parseInt(s.trim(), 10))
+    .filter((n) => Number.isInteger(n) && n >= 1 && n <= NUM_AGENTS);
+}
+
+async function selectAgents(prompt, options = {}) {
+  const explicitAgents = parseAgentOption(options.agents);
+
+  if (explicitAgents.length > 0) {
+    const names = explicitAgents.map((n) => AGENTS[n - 1].name).join(", ");
+    log.ok(`Selected: ${C.cyan}${names}${C.reset}`);
+    return explicitAgents;
+  }
+
+  if (options.yes || !process.stdin.isTTY) {
+    const all = Array.from({ length: NUM_AGENTS }, (_, i) => i + 1);
+    if (options.yes) {
+      log.ok(`Selected: ${C.cyan}all agents${C.reset}`);
+    }
+    return all;
+  }
+
+  console.log("");
+  console.log(`  ${C.bold}${prompt}${C.reset}`);
+  console.log(
+    `  ${C.dim}↑↓ navigate · space select multiple · enter confirm${C.reset}`,
+  );
+  console.log("");
+
+  const selected = new Array(NUM_AGENTS).fill(false);
+  let current = 0;
+
+  process.stdout.write("\x1B[?25l");
+
+  function draw() {
+    for (let i = 0; i < NUM_AGENTS; i++) {
+      process.stdout.write("\x1B[K");
+      const mark = selected[i]
+        ? `${C.green}●${C.reset}`
+        : `${C.dim}○${C.reset}`;
+      const name = AGENTS[i].name;
+      const note = !AGENTS[i].supportsMcpConfig
+        ? ` ${C.yellow}[manual setup]${C.reset}`
+        : "";
+      if (i === current) {
+        console.log(
+          `  ${C.cyan}❯${C.reset} ${mark} ${C.bold}${name}${C.reset}${note}`,
+        );
+      } else {
+        console.log(`    ${mark} ${C.dim}${name}${C.reset}${note}`);
+      }
+    }
+  }
+
+  draw();
+
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      process.stdout.write("\x1B[?25h");
+    }
+
+    function clearMenu() {
+      for (let i = 0; i < NUM_AGENTS + 3; i++) {
+        process.stdout.write("\x1B[1A\x1B[K");
+      }
+    }
+
+    function redraw() {
+      process.stdout.write(`\x1B[${NUM_AGENTS}A`);
+      draw();
+    }
+
+    let escapeBuffer = "";
+
+    stdin.on("data", (chunk) => {
+      for (const char of chunk) {
+        const code = char.charCodeAt(0);
+
+        if (escapeBuffer.length > 0) {
+          escapeBuffer += char;
+          if (escapeBuffer.length === 2 && char === "[") {
+            continue;
+          }
+          if (escapeBuffer.length === 3) {
+            const seq = escapeBuffer;
+            escapeBuffer = "";
+            if (seq === "\u001b[A" || seq === "\u001bOA") {
+              current = Math.max(0, current - 1);
+              redraw();
+            } else if (seq === "\u001b[B" || seq === "\u001bOB") {
+              current = Math.min(NUM_AGENTS - 1, current + 1);
+              redraw();
+            }
+          }
+          continue;
+        }
+
+        if (code === 27) {
+          escapeBuffer = char;
+          continue;
+        }
+
+        switch (code) {
+          case 3:
+            cleanup();
+            process.exit(0);
+            break;
+          case 13:
+          case 10:
+            cleanup();
+            clearMenu();
+
+            if (!selected.includes(true)) {
+              selected[current] = true;
+            }
+
+            const result = selected
+              .map((s, i) => (s ? i + 1 : null))
+              .filter(Boolean);
+            if (result.length > 0) {
+              const names = result.map((n) => AGENTS[n - 1].name).join(", ");
+              log.ok(`Selected: ${C.cyan}${names}${C.reset}`);
+            } else {
+              log.info("No agents selected");
+            }
+            resolve(result);
+            return;
+          case 32:
+            selected[current] = !selected[current];
+            redraw();
+            break;
+          case 97:
+          case 65:
+            for (let i = 0; i < NUM_AGENTS; i++) selected[i] = true;
+            redraw();
+            break;
+          case 110:
+          case 78:
+            for (let i = 0; i < NUM_AGENTS; i++) selected[i] = false;
+            redraw();
+            break;
+        }
+      }
+    });
+  });
+}
+
+module.exports = { showBanner, formatBox, selectAgents, parseAgentOption };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@mayurdluffy/cbm-cli",
+  "version": "1.0.7",
+  "description": "The ultimate manager for codebase-memory-mcp — install, build, share, and query codebase graphs with one command",
+  "main": "bin/cbm.js",
+  "bin": {
+    "cbm": "bin/cbm.js"
+  },
+  "scripts": {
+    "test": "node --test",
+    "lint": "echo 'No linter configured'",
+    "prepare": "node -e \"require('fs').chmodSync('bin/cbm.js', 0o755)\""
+  },
+  "keywords": [
+    "codebase-memory-mcp",
+    "mcp",
+    "codebase-graph",
+    "ai-coding",
+    "agentic-coding",
+    "token-savings",
+    "cli",
+    "developer-tools",
+    "claude",
+    "opencode",
+    "aider",
+    "zed",
+    "vscode"
+  ],
+  "author": "mayurdluffy <mayurdluffy@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mayurdluffy/cbm-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mayurdluffy/cbm-cli/issues"
+  },
+  "homepage": "https://github.com/mayurdluffy/cbm-cli#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md",
+    "LICENSE"
+  ]
+}