@zuvia-software-solutions/code-mapper 1.4.0

package/hooks/claude/pre-tool-use.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Code Mapper PreToolUse hook for Claude Code
+# Intercepts Grep/Glob/Bash searches and augments with graph context.
+# Receives JSON on stdin with { tool_name, tool_input, cwd, ... }
+# Returns JSON with additionalContext for graph-enriched results.
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // empty' 2>/dev/null)
+CWD=$(echo "$INPUT" | jq -r '.cwd // empty' 2>/dev/null)
+
+# Extract search pattern based on tool type
+PATTERN=""
+
+case "$TOOL_NAME" in
+  Grep)
+    PATTERN=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    ;;
+  Glob)
+    # Glob patterns are file paths, not search terms — extract meaningful part
+    RAW=$(echo "$INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null)
+    # Strip glob syntax to get the meaningful name (e.g., "**/*.ts" → skip, "auth*.ts" → "auth")
+    PATTERN=$(echo "$RAW" | sed -n 's/.*[*\/]\([a-zA-Z][a-zA-Z0-9_-]*\).*/\1/p')
+    ;;
+  Bash)
+    CMD=$(echo "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)
+    # Only augment grep/rg commands
+    if echo "$CMD" | grep -qE '\brg\b|\bgrep\b'; then
+      # Extract pattern from rg/grep
+      if echo "$CMD" | grep -qE '\brg\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\brg\s\+\(--[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      elif echo "$CMD" | grep -qE '\bgrep\b'; then
+        PATTERN=$(echo "$CMD" | sed -n "s/.*\bgrep\s\+\(-[^ ]*\s\+\)*['\"]\\?\([^'\";\| >]*\\).*/\2/p")
+      fi
+    fi
+    ;;
+  *)
+    # Not a search tool — skip
+    exit 0
+    ;;
+esac
+
+# Skip if pattern too short or empty
+if [ -z "$PATTERN" ] || [ ${#PATTERN} -lt 3 ]; then
+  exit 0
+fi
+
+# Check if we're in a Code Mapper-indexed repo
+dir="${CWD:-$PWD}"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.code-mapper" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Run code-mapper augment — must be fast (<500ms target)
+# augment writes to stderr (KuzuDB captures stdout at OS level), so capture stderr and discard stdout
+RESULT=$(cd "$CWD" && npx -y code-mapper augment "$PATTERN" 2>&1 1>/dev/null)
+
+if [ -n "$RESULT" ]; then
+  ESCAPED=$(echo "$RESULT" | jq -Rs .)
+  jq -n --argjson ctx "$ESCAPED" '{
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: $ctx
+    }
+  }'
+else
+  exit 0
+fi

package/hooks/claude/session-start.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Code Mapper SessionStart hook for Claude Code
+# Fires on session startup. Stdout is injected into Claude's context.
+# Checks if the current directory has a Code Mapper index.
+
+dir="$PWD"
+found=false
+for i in 1 2 3 4 5; do
+  if [ -d "$dir/.code-mapper" ]; then
+    found=true
+    break
+  fi
+  parent="$(dirname "$dir")"
+  [ "$parent" = "$dir" ] && break
+  dir="$parent"
+done
+
+if [ "$found" = false ]; then
+  exit 0
+fi
+
+# Inject Code Mapper context — this stdout goes directly into Claude's context
+cat << 'EOF'
+## Code Mapper Code Intelligence
+
+This codebase is indexed by Code Mapper, providing a knowledge graph with execution flows, relationships, and semantic search.
+
+**Available MCP Tools:**
+- `query` — Process-grouped code intelligence (execution flows related to a concept)
+- `context` — 360-degree symbol view (categorized refs, process participation)
+- `impact` — Blast radius analysis (what breaks if you change a symbol)
+- `detect_changes` — Git-diff impact analysis (what do your changes affect)
+- `rename` — Multi-file coordinated rename with confidence tags
+- `cypher` — Raw graph queries
+- `list_repos` — Discover indexed repos
+
+**Quick Start:** READ `code-mapper://repo/{name}/context` for codebase overview, then use `query` to find execution flows.
+
+**Resources:** `code-mapper://repo/{name}/context` (overview), `/processes` (execution flows), `/schema` (for Cypher)
+EOF
+
+exit 0

package/models/mlx-embedder.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""
+MLX-accelerated code embedder for Apple Silicon.
+
+Runs as a persistent subprocess — reads JSON batches from stdin,
+outputs embeddings to stdout. Node.js parent communicates via IPC.
+
+Protocol:
+  Input (one JSON per line):  {"texts": [...], "task": "nl2code", "type": "query"|"passage", "dims": 256}
+  Output (one JSON per line): {"embeddings": [[...], [...]], "ms": 42}
+
+  Special commands:
+  {"cmd": "ping"}  -> {"status": "ready", "model": "jina-code-1.5b", "device": "gpu"}
+  {"cmd": "quit"}  -> exits
+
+Optimizations:
+  - Length-tiered batching: short texts in large batches, long texts in small batches
+  - Sorted by length within tiers to minimize padding waste
+  - Results returned in original input order
+"""
+
+import sys
+import os
+import json
+import time
+
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+try:
+    import mlx.core as mx
+    from tokenizers import Tokenizer
+except ImportError:
+    print(json.dumps({"error": "MLX not installed. Run: pip3 install mlx tokenizers huggingface_hub"}), flush=True)
+    sys.exit(1)
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+MODEL_DIR = os.path.join(SCRIPT_DIR, "jina-code-1.5b-mlx")
+HF_REPO = "jinaai/jina-code-embeddings-1.5b-mlx"
+
+def ensure_model():
+    """Download the model if not present."""
+    safetensors = os.path.join(MODEL_DIR, "model.safetensors")
+    if os.path.exists(safetensors):
+        return
+
+    print(json.dumps({"status": "downloading", "model": HF_REPO}), flush=True)
+    try:
+        from huggingface_hub import snapshot_download
+        snapshot_download(HF_REPO, local_dir=MODEL_DIR)
+    except Exception as e:
+        print(json.dumps({"error": f"Model download failed: {e}"}), flush=True)
+        sys.exit(1)
+
+# Length-tiered batch sizes — shorter texts can batch more efficiently
+# Char thresholds and max batch sizes per tier
+TIERS = [
+    (500,   128),  # very short (signatures, interfaces)
+    (2000,  64),   # short (small functions)
+    (8000,  24),   # medium (typical functions)
+    (32000, 8),    # long (large functions, classes)
+    (999999, 4),   # very long (entire files)
+]
+
+def load_model():
+    sys.path.insert(0, MODEL_DIR)
+    from model import JinaCodeEmbeddingModel
+
+    with open(os.path.join(MODEL_DIR, "config.json")) as f:
+        config = json.load(f)
+
+    model = JinaCodeEmbeddingModel(config)
+    weights = mx.load(os.path.join(MODEL_DIR, "model.safetensors"))
+    model.load_weights(list(weights.items()))
+    mx.eval(model.parameters())
+
+    tokenizer = Tokenizer.from_file(os.path.join(MODEL_DIR, "tokenizer.json"))
+
+    return model, tokenizer
+
+
+def get_batch_size_for_length(char_len):
+    for threshold, batch_size in TIERS:
+        if char_len <= threshold:
+            return batch_size
+    return 4
+
+
+def embed_tiered(model, tokenizer, texts, task="nl2code", prompt_type="passage", truncate_dim=256):
+    """Embed texts with length-tiered batching for optimal throughput.
+    Returns embeddings in the ORIGINAL input order."""
+    if not texts:
+        return []
+
+    # Create index-text pairs, sort by length
+    indexed = sorted(enumerate(texts), key=lambda x: len(x[1]))
+
+    # Process in length-tiered batches
+    all_embeddings = [None] * len(texts)
+    i = 0
+
+    while i < len(indexed):
+        # Determine batch size based on the length of the longest text in this batch
+        char_len = len(indexed[min(i + 1, len(indexed) - 1)][1])  # peek at a representative
+        batch_size = get_batch_size_for_length(char_len)
+
+        batch_indices = []
+        batch_texts = []
+
+        # Fill batch with texts of similar length
+        while len(batch_texts) < batch_size and i < len(indexed):
+            orig_idx, text = indexed[i]
+            batch_indices.append(orig_idx)
+            batch_texts.append(text)
+            i += 1
+
+        # Run inference
+        embeddings = model.encode(
+            batch_texts,
+            tokenizer,
+            task=task,
+            prompt_type=prompt_type,
+            truncate_dim=truncate_dim,
+        )
+        mx.eval(embeddings)
+
+        # Store results at original indices
+        emb_list = embeddings.tolist()
+        for j, orig_idx in enumerate(batch_indices):
+            all_embeddings[orig_idx] = emb_list[j]
+
+    return all_embeddings
+
+
+def main():
+    ensure_model()
+    t0 = time.time()
+    model, tokenizer = load_model()
+    load_ms = int((time.time() - t0) * 1000)
+
+    print(json.dumps({
+        "status": "ready",
+        "model": "jina-code-1.5b-mlx",
+        "device": str(mx.default_device()),
+        "load_ms": load_ms,
+    }), flush=True)
+
+    for line in sys.stdin:
+        line = line.strip()
+        if not line:
+            continue
+
+        try:
+            req = json.loads(line)
+        except json.JSONDecodeError:
+            print(json.dumps({"error": "Invalid JSON"}), flush=True)
+            continue
+
+        if "cmd" in req:
+            if req["cmd"] == "ping":
+                print(json.dumps({"status": "ready"}), flush=True)
+            elif req["cmd"] == "quit":
+                break
+            continue
+
+        texts = req.get("texts", [])
+        task = req.get("task", "nl2code")
+        prompt_type = req.get("type", "passage")
+        dims = req.get("dims", 256)
+
+        t0 = time.time()
+        try:
+            embeddings = embed_tiered(model, tokenizer, texts, task, prompt_type, dims)
+            elapsed_ms = int((time.time() - t0) * 1000)
+
+            print(json.dumps({
+                "embeddings": embeddings,
+                "count": len(embeddings),
+                "dims": dims,
+                "ms": elapsed_ms,
+            }), flush=True)
+        except Exception as e:
+            print(json.dumps({"error": str(e)}), flush=True)
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -0,0 +1,100 @@
+{
+  "name": "@zuvia-software-solutions/code-mapper",
+  "version": "1.4.0",
+  "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
+  "author": "Abhigyan Patwari",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "homepage": "https://github.com/abhigyanpatwari/Code Mapper#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abhigyanpatwari/Code Mapper.git",
+    "directory": "code-mapper"
+  },
+  "bugs": {
+    "url": "https://github.com/abhigyanpatwari/Code Mapper/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "code-intelligence",
+    "knowledge-graph",
+    "cursor",
+    "claude",
+    "ai-agent",
+    "code-mapper",
+    "static-analysis",
+    "codebase-indexing"
+  ],
+  "type": "module",
+  "bin": {
+    "code-mapper": "dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "hooks",
+    "scripts",
+    "skills",
+    "vendor",
+    "models/mlx-embedder.py"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/cli/index.ts",
+    "test": "vitest run test/unit",
+    "test:integration": "vitest run test/integration",
+    "test:all": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "npm run build",
+    "postinstall": "node scripts/patch-tree-sitter-swift.cjs"
+  },
+  "dependencies": {
+    "@huggingface/transformers": "^3.8.1",
+    "@ladybugdb/core": "^0.15.1",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.0.0",
+    "cors": "^2.8.5",
+    "express": "^4.19.2",
+    "glob": "^11.0.0",
+    "graphology": "^0.25.4",
+    "graphology-indices": "^0.17.0",
+    "graphology-utils": "^2.3.0",
+    "ignore": "^7.0.5",
+    "lru-cache": "^11.0.0",
+    "mnemonist": "^0.39.0",
+    "pandemonium": "^2.4.0",
+    "tree-sitter": "^0.21.0",
+    "tree-sitter-c": "^0.21.0",
+    "tree-sitter-c-sharp": "^0.21.0",
+    "tree-sitter-cpp": "^0.22.0",
+    "tree-sitter-go": "^0.21.0",
+    "tree-sitter-java": "^0.21.0",
+    "tree-sitter-javascript": "^0.21.0",
+    "tree-sitter-php": "^0.23.12",
+    "tree-sitter-python": "^0.21.0",
+    "tree-sitter-ruby": "^0.23.1",
+    "tree-sitter-rust": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.0",
+    "uuid": "^13.0.0"
+  },
+  "optionalDependencies": {
+    "tree-sitter-kotlin": "^0.3.8",
+    "tree-sitter-swift": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.0.0",
+    "@types/uuid": "^10.0.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260317.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "tsx": "^4.0.0",
+    "typescript": "^5.4.5",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/scripts/patch-tree-sitter-swift.cjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/**
+ * WORKAROUND: tree-sitter-swift@0.6.0 binding.gyp build failure
+ *
+ * Background:
+ *   tree-sitter-swift@0.6.0's binding.gyp contains an "actions" array that
+ *   invokes `tree-sitter generate` to regenerate parser.c from grammar.js.
+ *   This is intended for grammar developers, but the published npm package
+ *   already ships pre-generated parser files (parser.c, scanner.c), so the
+ *   actions are unnecessary for consumers. Since consumers don't have
+ *   tree-sitter-cli installed, the actions always fail during `npm install`.
+ *
+ * Why we can't just upgrade:
+ *   tree-sitter-swift@0.7.1 fixes this (removes postinstall, ships prebuilds),
+ *   but it requires tree-sitter@^0.22.1. The upstream project pins tree-sitter
+ *   to ^0.21.0 and all other grammar packages depend on that version.
+ *   Upgrading tree-sitter would be a separate breaking change.
+ *
+ * How this workaround works:
+ *   1. tree-sitter-swift's own postinstall fails (npm warns but continues)
+ *   2. This script runs as code-mapper's postinstall
+ *   3. It removes the "actions" array from binding.gyp
+ *   4. It rebuilds the native binding with the cleaned binding.gyp
+ *
+ * TODO: Remove this script when tree-sitter is upgraded to ^0.22.x,
+ *       which allows using tree-sitter-swift@0.7.1+ directly.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const swiftDir = path.join(__dirname, '..', 'node_modules', 'tree-sitter-swift');
+const bindingPath = path.join(swiftDir, 'binding.gyp');
+
+try {
+  if (!fs.existsSync(bindingPath)) {
+    process.exit(0);
+  }
+
+  const content = fs.readFileSync(bindingPath, 'utf8');
+  let needsRebuild = false;
+
+  if (content.includes('"actions"')) {
+    // Strip Python-style comments (#) before JSON parsing
+    const cleaned = content.replace(/#[^\n]*/g, '');
+    const gyp = JSON.parse(cleaned);
+
+    if (gyp.targets && gyp.targets[0] && gyp.targets[0].actions) {
+      delete gyp.targets[0].actions;
+      fs.writeFileSync(bindingPath, JSON.stringify(gyp, null, 2) + '\n');
+      console.log('[tree-sitter-swift] Patched binding.gyp (removed actions array)');
+      needsRebuild = true;
+    }
+  }
+
+  // Check if native binding exists
+  const bindingNode = path.join(swiftDir, 'build', 'Release', 'tree_sitter_swift_binding.node');
+  if (!fs.existsSync(bindingNode)) {
+    needsRebuild = true;
+  }
+
+  if (needsRebuild) {
+    console.log('[tree-sitter-swift] Rebuilding native binding...');
+    execSync('npx node-gyp rebuild', {
+      cwd: swiftDir,
+      stdio: 'pipe',
+      timeout: 120000,
+    });
+    console.log('[tree-sitter-swift] Native binding built successfully');
+  }
+} catch (err) {
+  console.warn('[tree-sitter-swift] Could not build native binding:', err.message);
+  console.warn('[tree-sitter-swift] You may need to manually run: cd node_modules/tree-sitter-swift && npx node-gyp rebuild');
+}