Why this fork

NeuroMesh is a strong local-first context engine for web codebases. This repository continues it with two goals that the baseline did not meet:

Everything the engine claims is in docs/measured.md, with what is not measured listed next to it.

What is measured

Gold sets are written from reading the source before the engine runs. Recall = the gold files the packet contains; precision = share of packet files that are gold; forbidden = a file the task must not ship.

Repositories the engine was never tuned on (2026-09-21, main):

Sets that have been tuned on (dev-class): nanoGPT / express / vit-pytorch / fastapi-template 1.000 / 0.938 · django + ultralytics 1.000 / 0.675 · Hydra + argparse configs 1.000 / 0.767 · Fastify + Next.js app router (30 q) 0.800 / 0.608 · this repository (30 real questions) 0.833 / 0.578.

Task success with a real model (DeepSeek-V4-Pro answering, GLM-5.3 judging against the real source, real verify for patch tasks):

The packet matches or beats "just open the right files" at 1.4–2.1× the success per token, and beats grep everywhere. Recall is the strength; precision (1–3 neighbour files too many) is the open front — see ROADMAP.md.

Against the baseline it was forked from

Same 112 gold tasks on 15 third-party repositories, same machine, same day (2026-09-21); NeuroMesh v0.9.0 built from the baseline-v0.9.0 tag, this fork from main. Scored per task by file name from each engine's own optimize output — raw results in docs/baseline-vs-fork-2026-09-21.txt, script in scripts/compare-baseline.sh.

Same recall where the baseline already worked (Go, Python, Django, ultralytics); three times the precision everywhere — the baseline ships four to six files for every one that is wanted. The web-stack front (Fastify + Next.js) is the one place both are weak (0.65 recall), which is why it is the current focus.

What this fork adds

In a Claude Code session

Same task, same model (Sonnet), claude -p with and without the MCP server, cost from the CLI's own usage report:

The system prompt and tool definitions are re-read every turn and dominate small repositories; the engine only shrinks the code-context share. "99% reduction" figures compare a packet with the whole repository, which no agent sends; the numbers above are what a session actually pays.

Install

Pre-built binaries for Linux x86_64, macOS (Apple Silicon) and Windows x86_64 are on the
releases page (v1.0.0 is the first).

curl -fsSL https://raw.githubusercontent.com/ParsaVictor/code-context-engine/main/install.sh | sh

irm https://raw.githubusercontent.com/ParsaVictor/code-context-engine/main/install.ps1 | iex

Or from source:

git clone https://github.com/ParsaVictor/code-context-engine
cd code-context-engine
CARGO_BUILD_JOBS=2 cargo build --release -p neuromesh-cli      # target/release/neuromesh

Then, from the root of the project you want to index:

neuromesh doctor                          # binary + workspace check
neuromesh connect --global --agent-rules  # write MCP config + agent rule (Cursor, Claude, VS Code, …)
neuromesh index                           # build the graph (seconds on most repos)

Manual MCP config (any client):

{ "mcpServers": { "neuromesh": { "command": "neuromesh", "args": ["mcp"] } } }

Per-client paths, engines and options: docs/mcp.md · docs/configuration.md.

How it works

task as written ──► seed resolution ──► graph activation ──► selection ──► folded packet
                    identifiers, files,   Calls / Imports /    required +   signatures kept,
                    config keys, string   Parameterizes /      callees +    bodies folded,
                    literals, path words  twins, pheromones    ranked fill  budget-capped

1. Index — tree-sitter (and light parsers for YAML/JSON/shell/notebooks) turns every file into nodes and edges; string literals that look like names ("/api/users", "neuromesh_record_feedback", DATABASE_URL) are indexed too.
2. Seed — the prompt's code names resolve to nodes; twins with the same name are settled by directory and body words; guesses that land in docs/tests/fixtures are dropped.
3. Activate & select — energy spreads along typed edges; seeds and the callees the prompt names get required seats; the rest is a ranked, budgeted fill.
4. Fold — bodies outside the question are folded to signatures; the agent can expand a fold on demand.
5. Learn — record_feedback reinforces the path a successful task walked, never a whole neighbourhood.

The MCP agent loop (get_context_packet → search_symbols / expand_gap → expand_fold → trace → record_feedback) is documented in docs/agent-guide.md.

Run the benchmarks

bash scripts/benchmark-holdout.sh              # every gold set, one line each (checkouts fetched, graphs cached)
bash scripts/benchmark-holdout.sh holdout-web  # one set
NM_EXPLAIN=1 bash scripts/benchmark-holdout.sh dev   # + per-task reasons in target/explain-dev.txt

Rules the project holds itself to: holdout sets are never tuned on; ratchets only move up; a mixed result is reverted and recorded, never shipped. Every finding since the fork (F1–F82) is written down with its measurement in docs/planning/stage5-findings.fa.md.

Documentation

_{Independent derivative of NeuroMesh by yoosef alipour, MIT. Baseline tag baseline-v0.9.0. See NOTICE and ATTRIBUTION.md. MIT · LICENSE}