Skip to content
Back to search

code-lens-ai

A code-intelligence MCP server for AI agents. Index a codebase once, then ask Claude / Cursor / any MCP client to understand it — with answers grounded in the real call graph, real architectural…

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/marvikomo--code-lens-ai/badge.svg)](/listings/marvikomo--code-lens-ai)

HTML

<a href="/listings/marvikomo--code-lens-ai"><img src="/api/listings/marvikomo--code-lens-ai/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

- Node.js 20+

No database, no Docker. The graph lives in `<repo>/.codelens/`.

Install + index + wire up

# Install the CLI globally
npm install -g @marvikomo/codelens-ai

# Index a repo: parses, resolves calls, detects communities, writes .codelens/
codelens index /path/to/your/repo

# (Optional) semantic + hybrid search (downloads ~161 MB embedding model once)
codelens index /path/to/your/repo --embed

# Register the MCP server with Claude Code (one-time)
codelens mcp install --scope user --repo /path/to/your/repo

# Keep it fresh: re-index after every commit, checkout, merge and rebase
codelens hooks install /path/to/your/repo

Add `.codelens/` to the repo's `.gitignore`.

Then in any Claude Code session:

Use codelens to give me an overview of this codebase.

The agent will see 9 tools (`search_code`, `get_definition`, `read_code`, `get_callers`, `get_callees`, `impact_analysis`, `get_overview`, `label_community`, `generate_wiki`) and decide which to use.

Optional: Neo4j backend

Pass `--neo4j-uri` (or set `NEO4J_URI` / `NEO4J_USER` / `NEO4J_PASSWORD`) and the same commands store the graph in Neo4j instead. You get one extra tool, `cypher`, for free-form read-only queries, and a graph that outlives the machine that built it.

codelens neo4j start                                   # bundled neo4j:5.15 via Docker
codelens index /path/to/your/repo \
  --neo4j-uri bolt://localhost:7687 --neo4j-user neo4j --neo4j-password password \
  --neo4j-clear --cluster
codelens mcp install --scope user \
  --neo4j-uri bolt://localhost:7687 --neo4j-user neo4j --neo4j-password password

Every tool produces the same answer on either backend. If `NEO4J_URI` is set in your shell but you want the local index, pass `--local`.

Day-to-day

codelens index /path/to/repo --incremental    # skip if nothing changed (local: rebuilds otherwise, ~seconds)
codelens mcp --repo /path/to/repo             # start the server by hand
codelens neo4j status|logs|stop               # only if you use the Neo4j backend

Development (from source)

git clone https://github.com/marvikomo/code-lens-aI.git
cd code-lens-aI
npm install
npm link                       # makes `codelens` resolve to this checkout
npm run dev -- index .         # or: ts-node src/cli.ts ...

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 457 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # code-lens-aI
  2. **A code-intelligence MCP server for AI agents.** Index a codebase once, then ask Claude / Cursor / any MCP client to understand it — with answers grounded in the real call graph, real architectural subsystems, and real source code, not hallucinated guesses.
  3. Built on Tree-sitter + community detection, served over MCP with no database required (Neo4j optional). **24 languages**, with JS / TS / TSX / Java parsed out of the box.
  4. > **From a real session on a ~2,000-file TypeScript monorepo (73 detected subsystems):**
  5. > *"This is exactly the right tool — it collapses what would be a long exploration into a handful of focused calls, and the community detection produces architectural insight you'd struggle to get from grep."*
  6. > 4 tool calls produced both a complete codebase tour AND a deep mental-model explanation. A naive grep/find/read exploration of the same repo: ~25–40 calls.
  7. ---
  8. ## 🌟 The three killer features
  9. ### `get_overview` — Instant architectural map (the workhorse)
  10. Without it: agent opens an unfamiliar 2,000-file monorepo and burns 10–20 `grep`/`find`/`ls` calls just to figure out what's there.
  11. With it: **one call** returns the full architectural shape of the codebase — counts, languages, and the **top architectural subsystems detected by Leiden community detection**. For each subsystem, you get:
  12. - Its **semantic label** (set by an agent in a prior session, persists across re-runs) — e.g. `auth-pipeline`, `request-routing`, `data-access`
  13. - Its **size** (how many files belong to it)
  14. - Its **spine files** (the most central by PageRank — "of these 196 files, read these 6 first")
  15. - A one-sentence **summary** of what it does, with a **freshness signal** if the description has drifted
  16. - A **heuristic-label fallback** (folder-name) for any subsystem an agent hasn't manually labeled — so you never see a bare `community-43`
  17. The PageRank-ranked spine files are the single most useful pedagogical signal. On real production codebases, PageRank correctly surfaces the foundational files in each subsystem — typically 2× more central than anything else in that community, which lines up with what an experienced contributor would point you to.
  18. When an agent has labeled a community, the `summary:` line carries it across sessions. Drifted descriptions get auto-flagged: `↳ written 14d ago; spine has shifted (3 dropped, 6 added since) — verify before relying`.
  19. **Real result:** on a ~2,000-file TypeScript monorepo, `get_overview` + 3 targeted `cypher` lookups produced the entire architectural mental model an experienced contributor would need. Without `get_overview`, you'd reverse-engineer the same layout from `package.json` files plus folder spelunking.
  20. ### `generate_wiki` — Wiki skeleton in one MCP call
  21. Without it: Claude in your IDE opens an unfamiliar codebase and burns ~30 tool calls (`cat`, `ls`, `grep`, repeated reads) just to gather the structural facts it needs to write a wiki.
  22. With it: **one call** returns a structured markdown skeleton with all the facts pre-computed:
  23. - Per-community **spine files** (top-PageRank in each architectural subsystem)
  24. - **Top functions** in each subsystem (most-called, with signatures)
  25. - **HTTP routes** table extracted from Express / Koa / etc. handlers
  26. - **Entry points** (files no other file imports — likely application starts)
  27. - **Test inventory** (files where AST patterns matched `describe`/`it`/`@Test`)
  28. - **Cross-community import edges** as a data-flow hint
  29. - **Glossary** of the top-50 most-called symbols with file:line refs
  30. Plus explicit `[AGENT FILLS]` placeholders for the prose the agent should write (per-subsystem purpose, codebase narrative). The structural 80% comes free; the agent does the synthesis 20%.
  31. **Real result:** on a 123-file LangGraph backend, tool call count to produce a wiki dropped from ~30 to ~5-8.
  32. ### `impact_analysis` — Decision-support, not a data dump
  33. Without it: "What breaks if I change `verifyJWT`?" gets you a flat list of 47 callers with no signal about which matter.
  34. With it, the **first three lines** answer the actual question:
  35. ```
  36. ## Verdict
  37. ⚠️ Risky change. 11 direct production callers across 3 communities,
  38. 8 spine callers, target is itself a spine file.
  39. > Based on visible callers in the indexed graph. May miss callers via
  40. > re-exports, factory wrappers, or dynamic dispatch.
  41. ```
  42. Then the breakdown:
  43. - **Cross-community impact** — "✅ Contained" vs "⚠️ Crosses N boundaries"
  44. - **Spine callers** — dedicated section listing callers that are themselves load-bearing files (their changes ripple)
  45. - **Test files to update** — copy-paste-friendly path list
  46. - **Production callers** grouped by architectural community, with truncation that always preserves at least one entry per community
  47. - Risk score in metadata (sortable for tooling, never headlining the prose)
  48. The verdict is honest: it always includes a caveat that callers via DI / re-export / dynamic dispatch may be missed. **No silent confidently-wrong answers.**
  49. ---
  50. ## 🔧 How it works
  51. ```
  52. Source code
  53. │
  54. ▼ Tree-sitter parse
  55. │
  56. Graph extraction (functions, classes, calls, imports, routes,
  57. state objects, anonymous handlers, test files)
  58. │
  59. ▼ community detection (in process)
  60. │
  61. Communities + PageRank + boundary degree → spine files
  62. │
  63. ▼ stored in
  64. │
  65. <repo>/.codelens/ (default) —or— Neo4j (--neo4j-uri; adds the cypher tool)
  66. │
  67. ▼ exposed via
  68. │
  69. MCP server (9 tools, +cypher on Neo4j; stdio transport)
  70. │
  71. ▼
  72. Claude Code, Cursor, Codex, any MCP client
  73. ```
  74. ### What makes it sharper than `grep` + `Read`
  75. | Capability | Native tools | code-lens-aI |
  76. |---|---|---|
  77. | "Find code by exact name" | `grep` | `search_code` (also semantic search if `--embed`) |
  78. | "Show me this function's body" | `cat`/`Read` | `get_definition` (no filesystem access required) |
  79. | "What calls X?" | `grep -r` (false positives) | `get_callers` (real CALLS edges) |
  80. | "What does X depend on?" | manual import-tracing | `get_callees` |
  81. | "What breaks if I change X?" | educated guess | `impact_analysis` with verdict + cross-community + spine |
  82. | "What architectural subsystems are here?" | manual reading | `get_overview` (Leiden communities + spine files) |
  83. | "Write me a wiki" | full-day exploration | `generate_wiki` skeleton in 1 call |
  84. ---
  85. ## 🔄 Keeping the index fresh
  86. The indexer already re-extracts only what changed (`--incremental`, diffed on
  87. content hashes). What was missing was anything to trigger it, so a graph went
  88. stale the moment you committed and the only signal was a warning at query time.
  89. ```bash
  90. codelens hooks install # in the repo you index
  91. codelens hooks status
  92. codelens hooks uninstall
  93. ```
  94. That installs `post-commit`, `post-checkout`, `post-merge` and `post-rewrite`,
  95. so commits, branch switches, `git pull` and rebases all refresh the graph.
  96. Re-indexing runs detached with its exit status discarded — it can never block
  97. or fail a git operation.
  98. Existing hooks are appended to, never replaced, and `uninstall` removes only
  99. the block it added.
  100. ---
  101. ## 🌍 Languages
  102. 24 languages. Four have hand-written extractors; the other twenty run through a
  103. config-driven walker (`src/extractor/generic.ts`) fed by one `LanguageConfig`
  104. per language, so adding a language is normally a config object rather than a new
  105. extractor.
  106. **Built in — no extra install:**
  107. | Language | Extras beyond the common shape |
  108. |---|---|
  109. | JavaScript, TypeScript, TSX | HTTP routes, exports/re-exports, anonymous handlers, state objects |
  110. | Java | Annotations-based test detection, inner classes |
  111. **Config-driven — install the grammars once:**
  112. ```bash
  113. npm run grammars:install
  114. ```
  115. Python, Go, Rust, Ruby, C#, PHP, Scala, Groovy, C, C++, Objective-C, Kotlin,
  116. Swift, Elixir, Julia, PowerShell, OCaml, Common Lisp, DreamMaker (DM), Bash.
  117. These extract the shape every language shares: types, interfaces, enums,
  118. functions, methods, properties, imports, calls, and inheritance.
  119. ### Why the grammars are a separate install
  120. Most tree-sitter grammar packages still declare a `tree-sitter@^0.21`/`^0.22`
  121. peer range even though they load correctly against 0.25. Listing them as
  122. dependencies makes a strict npm resolver fail the *entire* install, so they are
  123. opt-in. Anything missing costs you that one language: the indexer logs it once
  124. and carries on.
  125. ### Coverage is not uniform — what you actually get
  126. Every language above was verified by parsing real fixtures and asserting on the
  127. resulting graph (`src/__tests__/language-configs.test.ts`), not by assuming node
  128. type names. Known limits, stated rather than papered over:
  129. - **Ruby / Bash** emit no `IMPORTS` edges. `require` and `source` are ordinary
  130. call nodes in those grammars, so import edges would have to be invented.
  131. - **Common Lisp** extracts `defun` only. The grammar leaves `defclass` and
  132. `defmethod` as undifferentiated lists and has no call node at all.
  133. - **C#** writes base classes and interfaces in one undifferentiated `base_list`,
  134. so both are emitted as `EXTENDS`.
  135. - **Python** skips class attributes; they are indistinguishable from
  136. module-level constants without type inference.
  137. - **PowerShell** does not model inheritance — a class and its base are sibling
  138. nodes with nothing to tell them apart.
  139. - **Kotlin** has no distinct interface node, so `interface Foo` appears as a
  140. `Class`.
  141. ### Languages deliberately absent
  142. Lua, Zig, Verilog, Dart, SQL and Vue have npm grammars that **do not load**
  143. against tree-sitter 0.25 — they are NAN-era builds that fail with "Invalid
  144. language object". Svelte and Pascal fail to compile at all, and there is no npm
  145. grammar for Fortran, Terraform, Astro or Apex. Configs exist for none of them,
  146. because a config for a grammar that cannot load is a language claimed but not
  147. delivered.
  148. ---
  149. ## 🚀 Quick start
  150. ### Prerequisites
  151. - Node.js 20+
  152. No database, no Docker. The graph lives in `<repo>/.codelens/`.
  153. ### Install + index + wire up
  154. ```bash
  155. # Install the CLI globally
  156. npm install -g @marvikomo/codelens-ai
  157. # Index a repo: parses, resolves calls, detects communities, writes .codelens/
  158. codelens index /path/to/your/repo
  159. # (Optional) semantic + hybrid search (downloads ~161 MB embedding model once)
  160. codelens index /path/to/your/repo --embed
  161. # Register the MCP server with Claude Code (one-time)
  162. codelens mcp install --scope user --repo /path/to/your/repo
  163. # Keep it fresh: re-index after every commit, checkout, merge and rebase
  164. codelens hooks install /path/to/your/repo
  165. ```
  166. Add `.codelens/` to the repo's `.gitignore`.
  167. Then in any Claude Code session:
  168. ```
  169. Use codelens to give me an overview of this codebase.
  170. ```
  171. The agent will see 9 tools (`search_code`, `get_definition`, `read_code`, `get_callers`, `get_callees`, `impact_analysis`, `get_overview`, `label_community`, `generate_wiki`) and decide which to use.
  172. ### Optional: Neo4j backend
  173. Pass `--neo4j-uri` (or set `NEO4J_URI` / `NEO4J_USER` / `NEO4J_PASSWORD`) and the same
  174. commands store the graph in Neo4j instead. You get one extra tool, `cypher`, for
  175. free-form read-only queries, and a graph that outlives the machine that built it.
  176. ```bash
  177. codelens neo4j start # bundled neo4j:5.15 via Docker
  178. codelens index /path/to/your/repo \
  179. --neo4j-uri bolt://localhost:7687 --neo4j-user neo4j --neo4j-password password \
  180. --neo4j-clear --cluster
  181. codelens mcp install --scope user \
  182. --neo4j-uri bolt://localhost:7687 --neo4j-user neo4j --neo4j-password password
  183. ```
  184. Every tool produces the same answer on either backend. If `NEO4J_URI` is set in
  185. your shell but you want the local index, pass `--local`.
  186. ### Day-to-day
  187. ```bash
  188. codelens index /path/to/repo --incremental # skip if nothing changed (local: rebuilds otherwise, ~seconds)
  189. codelens mcp --repo /path/to/repo # start the server by hand
  190. codelens neo4j status|logs|stop # only if you use the Neo4j backend
  191. ```
  192. ### Development (from source)
  193. ```bash
  194. git clone https://github.com/marvikomo/code-lens-aI.git
  195. cd code-lens-aI
  196. npm install
  197. npm link # makes `codelens` resolve to this checkout
  198. npm run dev -- index . # or: ts-node src/cli.ts ...
  199. ```
  200. ---
  201. ## 📋 The 10 MCP tools
  202. Every tool's description tells the agent **exactly when to use it** — explicit `"use this FIRST when…"` nudges keep agents from reaching for `cypher` when a higher-level tool is the right answer. Real session feedback called this out as a design that "kept me from reaching for cypher when get_overview was correct."
  203. | Tool | What it answers | When agents reach for it |
  204. |---|---|---|
  205. | `get_overview` | "What is this codebase?" — counts, languages, top communities, spine files, label freshness | **Call this FIRST** on any unfamiliar repo |
  206. | `generate_wiki` | "Write a wiki" — structural skeleton with [AGENT FILLS] markers | When asked to document or write architectural docs |
  207. | `impact_analysis` | "Is it safe to change X?" — verdict-first with spine + test/prod + cross-community | Before recommending a refactor or non-trivial change |
  208. | `search_code` | "Find code that does X" — keyword (FTS), semantic (vector), or hybrid (RRF fusion) | Locate symbols by name OR concept |
  209. | `get_definition` | "Show me X's full body and signature" — **returns the body, not just a signature**, saving a `read_code` round-trip | When you know the symbol name |
  210. | `read_code` | "Read lines N-M of file Y" — direct, capped at 2000 lines | Verify a claim or read context around a known location |
  211. | `get_callers` | "Who calls X?" — graph traversal over real CALLS edges, depth-configurable | Understand reach of a function before changing it |
  212. | `get_callees` | "What does X call?" — outbound graph traversal | Trace what a function depends on |
  213. | `label_community` | "Give this architectural subsystem a name" — agent-driven labeling, stamps freshness metadata | Once per community, on first encounter |
  214. | `cypher` | Read-only Cypher escape hatch — **schema cheat-sheet inlined in the tool description** so agents query the right props on the right node kinds | When the canned tools fall short of an exact query |
  215. ---
  216. ## 🧠 Why agents actually reach for it
  217. Four design choices that came directly from real-session feedback and now define the product:
  218. **1. Spine files turn "200-file subsystem" into "read these 6 first."**
  219. PageRank + boundary-degree centrality picks out the load-bearing files in each community. The agent doesn't have to guess where to start — code-lens-aI tells it which 5–6 files every other file in the subsystem ultimately leans on. That's a pedagogical signal nothing else in the agent-coding space currently provides.
  220. **2. Persistent semantic labels — set once by an agent, used forever.**
  221. After `label_community` is called, the label rides along on every subsequent `get_overview` and `generate_wiki` call across all future sessions. A community labeled `auth-pipeline` once stays that way until the graph genuinely shifts (and we'll tell the agent when it has). No re-labeling on every session.
  222. **3. Heuristic fallback so you never see "UNLABELED."**
  223. When no agent has labeled a community yet, code-lens-aI derives a folder-name heuristic (e.g. `auth`, `api`, `services`) and marks it `(heuristic)`. Agents get a useful name immediately AND a clear signal that they could upgrade it to a semantic label.
  224. **4. Description freshness signals — no silent staleness.**
  225. Every agent-written description is timestamped + the spine snapshot is captured. Subsequent reads compute drift and flag stale descriptions: `↳ written 14d ago; spine has shifted (3 dropped, 6 added since) — verify before relying`. Agents never propagate stale claims confidently.
  226. ---
  227. ## 🛠️ CLI reference
  228. ```bash
  229. codelens <subcommand> [args]
  230. codelens <repo-path> [options] # shorthand for: codelens index <path>
  231. ```
  232. ### Subcommands
  233. ```bash
  234. codelens index <path> [options] # analyze + index a repo
  235. codelens mcp # run MCP server (stdio)
  236. codelens mcp install [options] # register MCP with Claude Code
  237. codelens neo4j start|stop|status|logs # manage bundled Neo4j container
  238. codelens help # show top-level help
  239. ```
  240. ### `codelens index` options
  241. ```bash
  242. # Output
  243. --no-json # don't emit graph JSON to stdout
  244. -o file.json # write JSON to file
  245. --ignore foo,bar # extra directory/file names to skip
  246. --stats # print summary stats to stderr
  247. # Neo4j (also reads NEO4J_URI / NEO4J_USER / NEO4J_PASSWORD / NEO4J_DATABASE env vars)
  248. --neo4j-uri <uri>
  249. --neo4j-user <name>
  250. --neo4j-password <pw>
  251. --neo4j-clear # DETACH DELETE all :CodeNode before re-indexing
  252. --incremental # re-index only changed files (git-aware), cascading to dependents
  253. # Clustering (no plugin required — computed in process)
  254. --cluster # run Leiden + PageRank + spine selection
  255. --cluster-only # skip indexing; just re-cluster
  256. --cluster-clear # wipe community props + labels first
  257. --cluster-min-size <n> # min files to materialize a :Community node (default 3)
  258. # Embeddings (opt-in; ~161MB model on first run)
  259. --embed # compute embeddings for Function/Method/Class nodes
  260. --embed-model <hf-id> # override default jinaai/jina-embeddings-v2-base-code
  261. # Semantic layers (opt-in; needs TYPESAFE_API_KEY — https://typesafe.ai)
  262. --layers # tag every File with an architectural layer via TypeSafe's Jev:
  263. # api_surface | ui | business_logic | data_access | infrastructure
  264. # | configuration | utilities | tests | unclear
  265. --layers-model <id> # override default jev-latest
  266. --layers-min-confidence <0-1> # report picks below this as low-confidence (default 0.6)
  267. # Search-only mode (no <repo-path> needed)
  268. --search "<query>"
  269. --search-mode <m> # fts | vector | hybrid (auto if omitted)
  270. --search-limit <n>
  271. ```
  272. ### `codelens mcp install` options
  273. ```bash
  274. --scope <local|user|project> # where to register (default: local)
  275. # local = this directory only
  276. # user = available in all your projects
  277. # project = shared via .mcp.json in repo
  278. --neo4j-uri <uri> # e.g. bolt://localhost:7687
  279. --neo4j-user <name>
  280. --neo4j-password <pw>
  281. --neo4j-database <name> # (optional)
  282. ```
  283. If `--neo4j-*` flags are omitted, falls back to `NEO4J_URI` / `NEO4J_USER` / `NEO4J_PASSWORD` env vars.
  284. ---
  285. ## 🎯 What's actually in the graph
  286. Every indexed codebase gets:
  287. **Node kinds:** `Repository`, `Folder`, `File`, `Class`, `Interface`, `TypeAlias`, `Enum`, `Function`, `Method`, `Property`, `Variable`, `Community`, `Unresolved`
  288. **Edge types:** `CONTAINS`, `DEFINES`, `HAS_METHOD`, `HAS_PROPERTY`, `CALLS`, `IMPORTS`, `EXTENDS`, `IMPLEMENTS`, `IN_COMMUNITY`
  289. **Properties on nodes:**
  290. - Source code: `body`, `signature`, `bodyTruncated`
  291. - Location: `path`, `startRow`, `endRow`, `startColumn`, `endColumn`, `language`
  292. - HTTP handlers: `httpMethod`, `route`, `routerObject` (for `router.post(...)` patterns)
  293. - State/factory: `builder` (for `Annotation.Root({...})`, `z.object({...})`, etc.)
  294. - Tests: `isTest`, `testFramework` (jest / vitest / bun / junit / pytest detection)
  295. - Communities: `community` int, `pagerank` float, `boundary` int, `is_core` boolean
  296. - Embeddings: `embedding` float[768] (when `--embed` was run)
  297. - Semantic layers: `layer` string, `layerConfidence` float (when `--layers` was run) — a second axis to communities: `MATCH (f:File {layer: 'data_access'}) RETURN f.path`
  298. - FTS: indexed on `name`, `signature`, `body`, `path`
  299. **What gets uniquely captured that other indexers miss:**
  300. - **Anonymous route handlers** — `router.post("/users", async (req, res) => {...})` becomes a first-class `Function` node with `httpMethod: "POST"`, `route: "/users"`, and the handler body indexed for search
  301. - **State objects** — `export const PlanAgentState = Annotation.Root({...})` becomes a `Variable` node with `builder: "Annotation.Root"` so you can find every state schema in one query
  302. - **Test files** — detected via AST pattern matching (not just file path), with framework name (`jest` / `vitest` / `bun`)
  303. - **Architectural communities** — Leiden detection on the file-import subgraph reveals real subsystems with ~80% accuracy on production codebases
  304. ---
  305. ## 🏗️ Architecture (one paragraph)
  306. The CLI walks a repo, parses each file with **Tree-sitter** (24 languages), runs language-specific extractors that emit nodes (functions, classes, etc.) and edges (calls, imports) into an in-memory `graphlib` graph. Community detection (Louvain), PageRank, boundary degree and blast radius run **in process** over the file-IMPORTS subgraph — a few thousand nodes even on a large monorepo — and per-community spine selection marks the most-central files `is_core`. The result is written to `<repo>/.codelens/` by default, or pushed to **Neo4j** when `--neo4j-uri` is given. Optionally, **`@xenova/transformers`** computes 768-dim vector embeddings for Function/Method/Class bodies (jina-base-code model, in-process, ~161 MB). At query time, the **MCP server** loads whichever store you built and exposes its tools through one `GraphStore` interface, shaping results into decision-support prose (impact_analysis), structural facts (generate_wiki), or — Neo4j only — raw rows (cypher).
  307. ---
  308. ## 📁 Project structure
  309. ```
  310. src/
  311. ├── analyser/ # repo-walking + per-file extraction orchestration
  312. ├── extractor/ # per-language tree-sitter walkers (jsts.ts, java.ts, base.ts)
  313. ├── util/ # graph data model, language detection, parser factory
  314. ├── store/ # GraphStore interface; local (.codelens/) and Neo4j backends
  315. ├── indexers/ # Neo4j bulk-write
  316. ├── clustering/ # In-process Louvain + PageRank + blast + spine
  317. ├── embeddings/ # @xenova/transformers wrapper + batch pipeline
  318. ├── search/ # FTS, vector, hybrid (RRF) implementations
  319. ├── mcp/ # MCP server + 10 tool implementations
  320. ├── cli-commands/ # subcommand handlers (neo4j docker wrapper, mcp install)
  321. └── cli.ts # entry point + subcommand dispatcher
  322. scripts/
  323. ├── mcp-smoke.ts # end-to-end MCP smoke test (10 tools)
  324. ├── mcp-impact-test.ts # impact_analysis manual harness
  325. ├── mcp-wiki-test.ts # generate_wiki manual harness
  326. └── mcp-label-test.ts # label_community manual harness
  327. ```
  328. ---
  329. ## 🤝 Contributing
  330. The project is iterating fast. Real product feedback drives the roadmap — recent shipped features (Verdict-first impact_analysis, agent-driven community labeling, generate_wiki) all came from real-use sessions in Claude Code where gaps surfaced and got planned + shipped within hours.
  331. If you find a gap: open an issue with the actual prompt + expected output. The plan files in `~/.claude/plans/` document the design rationale for each shipped capability.
  332. ---
  333. ## 📄 License
  334. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.