@ulpi/codemap 0.3.7 → 0.3.9

package/README.md

@@ -363,6 +363,46 @@ Add to `~/.config/zed/settings.json`:
 }
 ```
 
+### Multi-Project Setup
+
+You can register multiple CodeMap MCP servers — one per codebase — so your AI agent can search across your frontend, backend, shared libraries, or any other project simultaneously. Each server indexes and serves its own project independently.
+
+First, index each project:
+
+```bash
+codemap init && codemap index                           # current project
+cd /path/to/frontend && codemap init && codemap index   # another project
+```
+
+Then register them as MCP servers. The current project uses `codemap serve` with no extra arguments. Other projects use `--cwd` to point to their location:
+
+#### Claude Code
+
+Add to `.mcp.json` in your project root:
+
+```json
+{
+  "mcpServers": {
+    "codemap": {
+      "command": "codemap",
+      "args": ["serve"]
+    },
+    "codemap-frontend": {
+      "command": "codemap",
+      "args": ["serve", "--cwd", "/path/to/frontend"]
+    }
+  }
+}
+```
+
+`"codemap"` serves the current project automatically. `"codemap-frontend"` serves a different codebase via `--cwd`. Add as many as you need — each gets its own set of 12 tools (`search_code`, `get_dependencies`, etc.) scoped to that project.
+
+#### Other Editors
+
+The same pattern works in any editor — add one entry with no `--cwd` for the local project, and additional entries with `--cwd` for other codebases. Use unique names (e.g. `codemap-api`, `codemap-shared`) so your AI agent can tell them apart.
+
+Your AI agent will then have access to tools like `search_code`, `get_dependencies`, and `search_symbols` across all registered projects, making it easy to trace connections across your stack.
+
 ## MCP Tools Reference
 
 | Tool | Description |

package/dist/index.js

@@ -5,7 +5,7 @@ import "./chunk-WR342MP3.js";
 import "./chunk-2OBAJYRP.js";
 
 // src/index.ts
-import path13 from "path";
+import path14 from "path";
 import { fileURLToPath } from "url";
 
 // ../../packages/intelligence/codemap-engine/dist/index.js
@@ -4250,6 +4250,19 @@ function releaseCodemapLock(projectDir, branch) {
   } catch {
   }
 }
+function isCodemapLocked(projectDir, branch) {
+  const file = lockPath(projectDir, branch);
+  const info = readLock(file);
+  if (!info) return false;
+  if (isStale(info)) {
+    try {
+      fs6.unlinkSync(file);
+    } catch {
+    }
+    return false;
+  }
+  return true;
+}
 function saveManifest(branchDir, manifest) {
   fs7.mkdirSync(branchDir, { recursive: true });
   const file = path7.join(branchDir, "manifest.json");
@@ -6164,13 +6177,14 @@ function registerStatus(program2) {
     const projectDir = program2.opts().cwd || process.cwd();
     const branch = getCurrentBranch(projectDir);
     const statsFile = codemapStatsFile(projectDir, branch, getDataDir2());
+    const indexing = isCodemapLocked(projectDir, branch);
     let stats = null;
     try {
       stats = JSON.parse(fs14.readFileSync(statsFile, "utf-8"));
     } catch {
     }
     if (opts.json) {
-      console.log(JSON.stringify({ projectDir, branch, stats }, null, 2));
+      console.log(JSON.stringify({ projectDir, branch, stats, indexing }, null, 2));
       return;
     }
     console.log(chalk6.bold("Codemap Status"));
@@ -6179,6 +6193,10 @@ function registerStatus(program2) {
     console.log(`Branch:   ${branch}`);
     console.log(`Data dir: ${getDataDir2()}`);
     console.log();
+    if (indexing) {
+      console.log(chalk6.yellow("Indexing in progress..."));
+      console.log();
+    }
     if (!stats) {
       console.log(chalk6.yellow("No index found. Run `codemap index` first."));
       return;
@@ -6869,13 +6887,10 @@ function registerCoupling(program2) {
     const projectDir = program2.opts().cwd || process.cwd();
     const branch = getCurrentBranch(projectDir);
     const graphFile = depgraphGraphFile(projectDir, branch, getDataDir2());
-    let graph;
-    try {
-      graph = loadGraph(graphFile);
-    } catch {
+    const graph = loadGraph(graphFile);
+    if (!graph) {
       console.error(chalk14.red("Dependency graph not available. Run `codemap index` first."));
       process.exit(1);
-      return;
     }
     let coupling = computeCoupling(graph);
     if (opts.module) {
@@ -6914,13 +6929,10 @@ function registerGraphStats(program2) {
   program2.command("graph-stats").description("Show aggregate dependency graph statistics").option("--json", "Output as JSON").action(async (opts) => {
     const projectDir = program2.opts().cwd || process.cwd();
     const branch = getCurrentBranch(projectDir);
-    let metrics;
-    try {
-      metrics = loadMetrics(depgraphMetricsFile(projectDir, branch, getDataDir2()));
-    } catch {
+    const metrics = loadMetrics(depgraphMetricsFile(projectDir, branch, getDataDir2()));
+    if (!metrics) {
       console.error(chalk15.red("Dependency metrics not available. Run `codemap index` first."));
       process.exit(1);
-      return;
     }
     const result = {
       totalFiles: metrics.totalFiles,
@@ -7010,9 +7022,239 @@ function registerRebuild(program2) {
   });
 }
 
+// src/commands/statusline.ts
+import chalk17 from "chalk";
+import fs18 from "fs";
+import path13 from "path";
+import { homedir as homedir3 } from "os";
+
+// src/commands/statusline-script.ts
+function buildStatuslineScript(originalCommand) {
+  const escapedCmd = originalCommand.replace(/'/g, "'\\''");
+  const originalSection = originalCommand ? `ORIGINAL_CMD='${escapedCmd}'
+echo "$SESSION_JSON" | eval "$ORIGINAL_CMD" 2>/dev/null || true` : "# (none)";
+  return `#!/bin/bash
+# CodeMap statusline for Claude Code
+# Generated by: codemap statusline
+# Do not edit \u2014 re-run \`codemap statusline\` to regenerate.
+
+set -euo pipefail
+
+# Read session JSON from stdin (Claude Code pipes it)
+SESSION_JSON=$(cat)
+
+# --- Original statusline ---
+${originalSection}
+
+# --- CodeMap status ---
+# Resolve the working directory from session JSON
+current_dir=$(echo "$SESSION_JSON" | ${jsonExtract("cwd")} 2>/dev/null || pwd)
+
+# Run codemap status --json for the project directory
+cm_json=$(codemap status --json --cwd "$current_dir" 2>/dev/null || true)
+
+if [ -z "$cm_json" ]; then
+  exit 0
+fi
+
+# Parse fields
+stats_null=$(echo "$cm_json" | ${jsonExtract("stats")} 2>/dev/null || echo "null")
+if [ "$stats_null" = "null" ] || [ -z "$stats_null" ]; then
+  echo "CM: \u2014 no index (run: codemap index)"
+  exit 0
+fi
+
+total_files=$(echo "$cm_json" | ${jsonPath("stats", "totalFiles")} 2>/dev/null || echo "0")
+total_chunks=$(echo "$cm_json" | ${jsonPath("stats", "totalChunks")} 2>/dev/null || echo "0")
+stale_files=$(echo "$cm_json" | ${jsonPath("stats", "staleFiles")} 2>/dev/null || echo "0")
+last_updated=$(echo "$cm_json" | ${jsonPath("stats", "lastUpdated")} 2>/dev/null || echo "")
+indexing=$(echo "$cm_json" | ${jsonExtract("indexing")} 2>/dev/null || echo "false")
+
+# Format chunks (e.g. 12400 \u2192 12.4k)
+format_chunks() {
+  local n=$1
+  if [ "$n" -ge 1000 ]; then
+    local k=$((n / 100))
+    local whole=$((k / 10))
+    local frac=$((k % 10))
+    echo "\${whole}.\${frac}k"
+  else
+    echo "$n"
+  fi
+}
+
+# Calculate time ago
+time_ago() {
+  local updated="$1"
+  if [ -z "$updated" ]; then
+    echo "unknown"
+    return
+  fi
+  local now
+  now=$(date +%s)
+  local then_ts
+  # macOS date -j vs GNU date
+  if date -j -f "%Y-%m-%dT%H:%M:%S" "$(echo "$updated" | cut -c1-19)" +%s >/dev/null 2>&1; then
+    then_ts=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$(echo "$updated" | cut -c1-19)" +%s 2>/dev/null || echo "$now")
+  else
+    then_ts=$(date -d "$updated" +%s 2>/dev/null || echo "$now")
+  fi
+  local diff=$(( now - then_ts ))
+  if [ "$diff" -lt 60 ]; then
+    echo "\${diff}s ago"
+  elif [ "$diff" -lt 3600 ]; then
+    echo "$(( diff / 60 ))m ago"
+  elif [ "$diff" -lt 86400 ]; then
+    echo "$(( diff / 3600 ))h ago"
+  else
+    echo "$(( diff / 86400 ))d ago"
+  fi
+}
+
+# Watcher detection
+watcher_icon="\u25CB"
+if pgrep -f "codemap watch" >/dev/null 2>&1; then
+  watcher_icon="\u25CF"
+fi
+
+# Indexing indicator
+idx_icon=""
+if [ "$indexing" = "true" ]; then
+  idx_icon=" IDX"
+fi
+
+chunks_fmt=$(format_chunks "$total_chunks")
+
+# Build status line
+line="CM: \${watcher_icon} \${total_files}f \${chunks_fmt}\u25C6"
+
+if [ "$stale_files" -gt 0 ] 2>/dev/null; then
+  line="\${line} \u26A0\${stale_files}"
+fi
+
+line="\${line}\${idx_icon} | $(time_ago "$last_updated")"
+
+echo "$line"
+`;
+}
+function jsonExtract(field) {
+  return `grep -o '"${field}"[[:space:]]*:[[:space:]]*[^,}]*' | sed 's/.*:[[:space:]]*//' | sed 's/"//g' | head -1`;
+}
+function jsonPath(parent, child) {
+  return `grep -o '"${child}"[[:space:]]*:[[:space:]]*[^,}]*' | sed 's/.*:[[:space:]]*//' | sed 's/"//g' | head -1`;
+}
+
+// src/commands/statusline.ts
+var CLAUDE_DIR = path13.join(homedir3(), ".claude");
+var SETTINGS_FILE2 = path13.join(CLAUDE_DIR, "settings.json");
+var SCRIPT_FILE = path13.join(CLAUDE_DIR, "statusline-command.sh");
+var BACKUP_FILE = path13.join(CLAUDE_DIR, "statusline-command.sh.bak");
+function readSettings() {
+  try {
+    return JSON.parse(fs18.readFileSync(SETTINGS_FILE2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeSettings(settings) {
+  fs18.mkdirSync(CLAUDE_DIR, { recursive: true });
+  fs18.writeFileSync(SETTINGS_FILE2, JSON.stringify(settings, null, 2) + "\n");
+}
+function registerStatusline(program2) {
+  program2.command("statusline").description("Install CodeMap status into Claude Code statusline").option("--uninstall", "Remove CodeMap from statusline and restore backup").action(async (opts) => {
+    if (opts.uninstall) {
+      uninstall();
+      return;
+    }
+    install();
+  });
+}
+function install() {
+  const settings = readSettings();
+  if (fs18.existsSync(SCRIPT_FILE)) {
+    try {
+      const existing = fs18.readFileSync(SCRIPT_FILE, "utf-8");
+      if (existing.includes("Generated by: codemap statusline")) {
+        console.log(chalk17.yellow("CodeMap statusline is already installed."));
+        console.log(chalk17.dim("Run `codemap statusline --uninstall` to remove, then reinstall."));
+        return;
+      }
+    } catch {
+    }
+  }
+  const originalCommand = settings.statusline_command || "";
+  if (originalCommand && originalCommand !== SCRIPT_FILE) {
+    fs18.mkdirSync(CLAUDE_DIR, { recursive: true });
+    fs18.writeFileSync(BACKUP_FILE, originalCommand);
+    console.log(chalk17.dim(`Saved original statusline command to ${BACKUP_FILE}`));
+  }
+  const script = buildStatuslineScript(originalCommand !== SCRIPT_FILE ? originalCommand : "");
+  fs18.mkdirSync(CLAUDE_DIR, { recursive: true });
+  fs18.writeFileSync(SCRIPT_FILE, script, { mode: 493 });
+  if (settings.statusline_command !== SCRIPT_FILE) {
+    settings.statusline_command = SCRIPT_FILE;
+    writeSettings(settings);
+    console.log(chalk17.dim(`Updated ${SETTINGS_FILE2}`));
+  }
+  console.log();
+  console.log(chalk17.green("CodeMap statusline installed."));
+  if (originalCommand && originalCommand !== SCRIPT_FILE) {
+    console.log(chalk17.dim("Your existing statusline is preserved \u2014 CodeMap appends to it."));
+  }
+  console.log();
+  console.log("CodeMap will append to the statusline:");
+  console.log(chalk17.cyan("  CM: \u25CF 842f 12.4k\u25C6 | 23m ago") + chalk17.dim("       \u2014 watcher running, index fresh"));
+  console.log(chalk17.cyan("  CM: \u25CB 842f 12.4k\u25C6 \u26A03 | 2h ago") + chalk17.dim("    \u2014 no watcher, 3 stale files"));
+  console.log(chalk17.cyan("  CM: \u25CB 842f 12.4k\u25C6 IDX | 5s ago") + chalk17.dim("   \u2014 indexing in progress"));
+  console.log(chalk17.cyan("  CM: \u2014 no index (run: codemap index)") + chalk17.dim("  \u2014 not yet indexed"));
+  console.log();
+  console.log(chalk17.dim("Restart Claude Code to see the statusline."));
+  console.log(chalk17.dim("Run `codemap statusline --uninstall` to remove."));
+  console.log();
+  console.log(chalk17.dim("Tip: Install codemap in multiple projects to give each Claude Code"));
+  console.log(chalk17.dim("session its own code intelligence \u2014 frontend, backend, shared libs."));
+  console.log(chalk17.dim("Run `codemap init` in any project to get started."));
+}
+function uninstall() {
+  let originalCommand = "";
+  if (fs18.existsSync(BACKUP_FILE)) {
+    try {
+      originalCommand = fs18.readFileSync(BACKUP_FILE, "utf-8").trim();
+    } catch {
+    }
+    try {
+      fs18.unlinkSync(BACKUP_FILE);
+    } catch {
+    }
+  }
+  if (fs18.existsSync(SCRIPT_FILE)) {
+    try {
+      const content = fs18.readFileSync(SCRIPT_FILE, "utf-8");
+      if (content.includes("Generated by: codemap statusline")) {
+        fs18.unlinkSync(SCRIPT_FILE);
+        console.log(chalk17.dim("Removed statusline script."));
+      }
+    } catch {
+    }
+  }
+  const settings = readSettings();
+  if (originalCommand && originalCommand !== SCRIPT_FILE) {
+    settings.statusline_command = originalCommand;
+    writeSettings(settings);
+    console.log(chalk17.dim(`Restored original statusline command.`));
+  } else if (settings.statusline_command) {
+    delete settings.statusline_command;
+    writeSettings(settings);
+    console.log(chalk17.dim("Cleared statusline_command from settings."));
+  }
+  console.log();
+  console.log(chalk17.green("CodeMap statusline removed."));
+  console.log(chalk17.dim("Restart Claude Code for changes to take effect."));
+}
+
 // src/index.ts
-var __dirname = path13.dirname(fileURLToPath(import.meta.url));
-var grammarsDir = path13.join(__dirname, "grammars");
+var __dirname = path14.dirname(fileURLToPath(import.meta.url));
+var grammarsDir = path14.join(__dirname, "grammars");
 setGrammarDir(grammarsDir);
 var program = new Command();
 program.name("codemap").description("Code intelligence CLI \u2014 hybrid search, dependency analysis, PageRank").version("0.3.5").option("--cwd <dir>", "Project directory (default: cwd)");
@@ -7033,4 +7275,5 @@ registerSummary(program);
 registerCoupling(program);
 registerGraphStats(program);
 registerRebuild(program);
+registerStatusline(program);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ulpi/codemap",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "type": "module",
   "description": "Standalone code intelligence CLI — hybrid vector + BM25 search, dependency analysis, PageRank",
   "bin": {
@@ -10,9 +10,11 @@
     ".": "./dist/index.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "scripts/postinstall.js"
   ],
   "scripts": {
+    "postinstall": "node scripts/postinstall.js",
     "build": "tsup && node --import tsx scripts/copy-grammars.ts",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",

package/scripts/postinstall.js

@@ -0,0 +1,36 @@
+// Postinstall welcome message for `npm install -g @ulpi/codemap`
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+
+console.log();
+console.log(bold("codemap") + " installed successfully.");
+console.log();
+console.log("Get started:");
+console.log(`  ${cyan("codemap init")}          ${dim("# Choose embedding provider + model")}`);
+console.log(`  ${cyan("codemap index")}         ${dim("# Index your project")}`);
+console.log(`  ${cyan("codemap search")} ${dim('"query"')}  ${dim("# Search your code")}`);
+console.log();
+console.log("Add as an MCP server to give your AI agent code intelligence:");
+console.log(`  ${cyan("codemap serve")}         ${dim("# Start MCP server (stdio)")}`);
+console.log();
+console.log("Multi-project: Index each codebase, then register one MCP server per project.");
+console.log("Your AI agent gets code intelligence across your entire stack.");
+console.log();
+console.log(`  ${dim("# Index each project once:")}`);
+console.log(`  ${dim("$")} ${cyan("codemap init")} && ${cyan("codemap index")}                  ${dim("# current project")}`);
+console.log(`  ${dim("$")} cd ~/projects/frontend && ${cyan("codemap init")} && ${cyan("codemap index")}`);
+console.log();
+console.log(`  ${dim("# .mcp.json — add to the project where you use your AI agent:")}`);
+console.log(`  ${dim("{")}`)
+console.log(`  ${dim('  "mcpServers": {')}`);
+console.log(`  ${dim('    "codemap": {')}`);
+console.log(`  ${dim('      "command": "codemap", "args": ["serve"]')}              ${dim("← this project")}`);
+console.log(`  ${dim('    },')}`);
+console.log(`  ${dim('    "codemap-frontend": {')}`);
+console.log(`  ${dim('      "command": "codemap", "args": ["serve", "--cwd",')}`);
+console.log(`  ${dim('        "/path/to/frontend"]')}                               ${dim("← another project")}`);
+console.log(`  ${dim('    }')}`);
+console.log(`  ${dim("  }")}`);
+console.log(`  ${dim("}")}`);
+console.log();