{
  "markdown": "# Codixing\n\n[![CI](https://github.com/ferax564/codixing/actions/workflows/ci.yml/badge.svg)](https://github.com/ferax564/codixing/actions/workflows/ci.yml)\n[![codecov](https://codecov.io/gh/ferax564/codixing/graph/badge.svg)](https://codecov.io/gh/ferax564/codixing)\n\n**Website: [codixing.com](https://codixing.com)** · **[Docs](https://codixing.com/docs)**\n\nCode retrieval engine that saves your AI agent 73% of its token budget. Replaces grep with ranked, AST-aware search — so models spend tokens reasoning, not reading.\n\n## Install\n\n```sh\ncurl --proto '=https' --proto-redir '=https' -fsSLo /tmp/codixing-install.sh https://codixing.com/install.sh\nsh /tmp/codixing-install.sh\n```\n\nInstalls `codixing` and `codixing-mcp` by default (lean install) on\nLinux x86_64 or Apple Silicon macOS. Set `CODIXING_COMPONENTS=all` for the full\nsuite (`codixing-lsp` + `codixing-server` too), or list names explicitly\n(`CODIXING_COMPONENTS=codixing,codixing-mcp,codixing-lsp,codixing-server`).\nIt uses `/usr/local/bin` when writable and otherwise falls back to\n`$HOME/.local/bin`. Set `CODIXING_INSTALL_DIR` for another destination or\n`CODIXING_VERSION=X.Y.Z` to pin a release. Windows x86_64 binaries are on the\n[releases page](https://github.com/ferax564/codixing/releases), and the MCP\nserver is also available through `npx -y codixing-mcp`.\n\n### Claude Code plugin (optional)\n\n```bash\nclaude plugin marketplace add ferax564/codixing\nclaude plugin install codixing@codixing\n```\n\nAdds 5 slash commands: `/codixing-setup`, `/codixing-explore`, `/codixing-review`, `/codixing-preflight`, `/codixing-release`.\n\n### MCP server (optional — for Cursor, Windsurf, Continue.dev, Codex)\n\nAdd to your project's `.mcp.json`:\n\n```json\n{\n  \"mcpServers\": {\n    \"codixing\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"codixing-mcp\", \"--root\", \".\", \"--profile\", \"minimal\", \"--no-daemon-fork\"]\n    }\n  }\n}\n```\n\nOr for OpenAI Codex CLI: `codex mcp add codixing -- npx -y codixing-mcp --root . --profile minimal --no-daemon-fork`\n\nFor large repositories, run `codixing init .` before starting the MCP client. When\nusing Codex configuration, set `startup_timeout_sec = 120` so the first `npx`\ndownload or index load is not cut off by the default startup timeout.\nCodixing skips individual source files over 2 MiB by default so generated or\nminified bundles cannot dominate parsing memory; override this with\n`--max-file-bytes N` (or `0` for no limit).\nIndexing uses at most `min(available CPUs, 8)` workers by default on\nnon-Windows platforms and `min(available CPUs, 4)` on Windows; `--threads N`\nis an explicit tuning override. For one-shot searches on a large index,\n`--strategy instant` and `--strategy exact` use a lean lexical read profile\nthat skips graph, vector, and reranker loading. `auto` and the other strategies\nretain the full read profile because they may need those artifacts.\nAuxiliary\nconcept and learned-vocabulary artifacts are evidence-ranked and bounded: at\nmost 32 vocabulary terms are paired per file, 12 expansions are retained per\nterm, and concept clusters retain at most 32 symbols / 16 files. Their v2 files\nintern repeated paths and names, and every sync invalidates them before a bounded\nrebuild so large-repo searches never use stale semantic mappings.\nOnce initialized, MCP watcher updates stay proportional to the edited files:\nchanges accumulate in an unpublished copy-on-write generation and publish after\n2 seconds idle, 30 seconds maximum, or 256 paths. Existing readers keep their\ncomplete old snapshot, interrupted batches replay automatically, and a true\nno-op sync does not create another generation.\n\n---\n\n## Why Not Just Grep?\n\nAI coding agents use `grep`, `find`, and `cat` for code navigation. These tools return **everything, always** — a single `rg b2Vec2` on a real codebase returns 2,240 hits (225 KB), burning context before any reasoning happens.\n\nCodixing returns the top 20 results in 1.3 KB — same signal, **99% less waste**.\n\n### The cost of noise\n\nTested on 6 real-world repos (tokio, ripgrep, axum, django, fastapi, react — 9,493 files):\n\n| Metric | grep/cat/find | Codixing | Savings |\n|--------|---------------|----------|---------|\n| Tool calls per session | 58 | 26 | **55% fewer** |\n| Output tokens | ~84,600 | ~22,900 | **73% fewer** |\n| Est. cost (Opus @ $15/M) | $1.27 | $0.34 | **$0.93/session** |\n\nAt 50 agent sessions/day, that's **$1,400/month** back in your pocket — and the agent finds the right code more often.\n\n### What you get\n\n| Capability | grep/rg | Codixing |\n|-----------|---------|----------|\n| Bounded, ranked output | No | Yes (BM25 + PageRank) |\n| Symbol definitions (not just mentions) | No | Yes (AST-parsed symbol table) |\n| Dependency graph queries | No | Yes (transitive imports, call graph) |\n| Natural language search | No | Yes (BM25 + optional embeddings) |\n| Token budget management | No | Yes (auto-truncation) |\n\n### Agent golden path\n\nIf you are wiring Codixing into an AI agent, start with these tools instead of\nexposing the whole surface at once:\n\n| Task | Use this first | MCP profile | Why |\n|------|----------------|-------------|-----|\n| Find relevant code from a concept | `code_search` / `codixing search` | Minimal | Ranked, token-bounded retrieval for natural language and code terms |\n| Jump to a known definition | `find_symbol` / `codixing symbols` | Minimal | Definitions only, not every textual mention |\n| Get a compact architecture map | `get_repo_map` / `codixing graph --map` | Minimal | A bounded orientation pass before deeper traversal |\n| Check blast radius before editing | `search_usages --complete` or `predict_impact` / `codixing impact` | Reviewer | Deterministic bounded scan instead of top-K guesses; follow `next_offset` pages |\n| Understand a feature | `feature_hub` or `get_context_for_task` | Reviewer | One call combines search, dependencies, dependents, and tests |\n| Inspect exact text | `grep_code` / `codixing grep` | Reviewer | Literal/regex scan for strings, errors, TODOs, and generated names |\n| Focus on current work | `focus_map` / `codixing graph --map` | Reviewer | Graph-ranked context biased toward changed or seed files |\n\nMinimal is the startup default. Call `set_mcp_profile` with `reviewer` before\nusing the read-only specialist rows above. Use `search_tools` and\n`get_tool_schema` when an agent needs to discover a narrower capability. A\nminimal/reviewer server cannot upgrade itself into a write-capable profile\nunless it was started explicitly with `--allow-profile-escalation`.\n\n---\n\n## Getting Started\n\n### 60-second setup\n\n```bash\n# 1. Install\ncurl --proto '=https' --proto-redir '=https' -fsSLo /tmp/codixing-install.sh https://codixing.com/install.sh\nsh /tmp/codixing-install.sh\n\n# 2. Index your project\ncodixing init .\n# ✓ Indexed 2,847 files, 14,203 chunks, 8,891 symbols in 1.2s\n\n# 3. Search\ncodixing search \"authentication handler\"\n# ► src/auth/handler.rs:42  [score: 0.94]\n#   pub fn handle_auth_request(req: Request) -> Result<Token>\n```\n\nThat's it. Your agent now uses ranked search instead of grep.\n\n`codixing init` is safe to rerun. It builds a complete index generation beside\nthe active one, validates it, and atomically switches readers only when the new\ngeneration is ready. An interrupted, failed, or out-of-space rebuild leaves the\nprevious index searchable; a successful switch removes the superseded data.\nLong-lived read-only engines detect the generation switch and reopen the whole\nnew snapshot without observing a mixture of old and new artifacts.\nPlan for temporary free space approximately equal to one additional index while\na rebuild is running. `codixing doctor` reports the active generation and any\nabandoned staging generations that could not yet be reclaimed.\n\n### CLI commands\n\n```bash\n# Search (natural language or symbol names)\ncodixing search \"error handling middleware\"\n\n# Symbol lookup (definitions only, not mentions)\ncodixing symbols Engine\n\n# Dependency graph\ncodixing callers src/engine.rs    # who imports this file?\ncodixing callees src/engine.rs    # what does this file import?\n\n# Keep index fresh (re-indexes only changed files)\ncodixing sync\n\n# Architecture map\ncodixing graph --map --token-budget 4000\n```\n\n### Hybrid search (optional)\n\n`codixing init` builds BM25 + symbol graph by default. For natural-language queries\n(\"how does the auth flow work?\"), opt into semantic embeddings with `--embed`:\n\n```bash\ncodixing init . --embed --model bge-small-en    # one-time, ~2 min on a medium repo\ncodixing search \"how does auth work\" --strategy fast\n```\n\nONNX-based embedding models (`bge-small-en`, `bge-base-en`, etc.) require ONNX\nRuntime (`pip install onnxruntime`, or download from the\n[onnxruntime releases](https://github.com/microsoft/onnxruntime/releases)). Set\n`ORT_DYLIB_PATH` to the exact absolute path of `libonnxruntime.so`,\n`libonnxruntime.dylib`, or `onnxruntime.dll` before running Codixing. Run\n`codixing doctor` to verify the path. The static `model2vec` model and BM25-only\ninstalls do not need ONNX Runtime.\n\n---\n\n## CLI Commands\n\nThe most common commands (run `codixing --help` for the full list):\n\n```bash\ncodixing search \"query\"          # Ranked code search\ncodixing grep \"pattern\"          # Literal/regex text scan (path:line:col:text)\ncodixing symbols Widget          # Find symbol definitions\ncodixing usages add_chunk        # Find call sites and imports\ncodixing callers src/engine.rs   # Who imports this file\ncodixing callees src/engine.rs   # What this file imports\ncodixing graph --map             # Architecture overview\ncodixing graph --communities     # Louvain community detection\ncodixing graph --surprises 10    # Top N surprising edges\ncodixing graph --html graph.html # Interactive HTML dashboard\ncodixing graph --html g.html --diff-base main  # Dashboard + diff-impact overlay\ncodixing path src/a.rs src/b.rs  # Shortest import chain\ncodixing impact src/engine.rs    # Blast radius (compact by default; --full for all)\ncodixing api src/engine.rs       # Public API surface\ncodixing types Engine            # Type relationships\ncodixing examples add_chunk      # Usage examples from tests + callers\ncodixing context src/engine.rs   # Cross-file context assembly\ncodixing ask \"task: inspect auth\" # Recommended agent entrypoint; punctuation-safe\ncodixing agent-context-pack \"task\" # Stable JSON context pack for agents\ncodixing symbols Widget --defs-only  # Definitions only (no Import rows)\ncodixing search IndexStore --strategy goto  # Definition-first symbol jump\ncodixing init --dry-run .         # Inventory + disk estimate before writing an index\ncodixing doctor --check-update    # Free space, lock owner, ONNX hints, optional release check\ncodixing doctor --fix-path       # PATH binary version gate + install hints\ncodixing bench-tokens            # Prove token savings vs grep+read\ncodixing init .                  # Index a project\ncodixing sync                    # Incremental re-index\ncodixing import github issues.json  # Import GitHub issues/PRs as searchable context\ncodixing import adr docs/adr/    # Import architecture decision records\ncodixing import jira export.csv  # Import Jira issues (CSV or JSON)\ncodixing import linear issues.json  # Import Linear issues (CSV or JSON)\ncodixing search \"auth bug\" --source jira    # Search only imported context\ncodixing audit                   # Find stale files\n```\n\nFull reference: [codixing.com/docs](https://codixing.com/docs)\n\n### MCP server (optional)\n\nFor editors with MCP support, the `codixing-mcp` binary exposes a generated,\nprofile-gated JSON-RPC 2.0 catalog.\nIt starts in the narrow read-only `minimal` profile by default; use\n`--profile reviewer` for the broader read-only analysis surface, `--profile editor` or\n`--allow-write-tools` for non-destructive write helpers, and `--profile dangerous`\nonly when destructive file and shell tools are intentional. Agents can call\n`get_mcp_profile` and `set_mcp_profile` to inspect or switch within the server's\nstartup safety ceiling. Minimal/reviewer startup remains read-only by default;\n`--allow-profile-escalation` is required to permit runtime write-profile upgrades.\nSuccessful switches emit `notifications/tools/list_changed` so clients can\nrefresh `tools/list`.\n\n| Category | Representative tools |\n|----------|-------|\n| **Search** | code_search, find_symbol, grep_code, search_usages, read_symbol, find_similar, stitch_context |\n| **Graph** | get_repo_map, focus_map, get_references, get_transitive_deps, symbol_callers, symbol_callees, predict_impact, find_orphans, explain |\n| **Files** | read_file, write_file, edit_file, delete_file, apply_patch, list_files, outline_file |\n| **Analysis** | agent_context_pack, find_tests, find_source_for_test, get_complexity, review_context, rename_symbol, run_tests, get_context_for_task, check_staleness, generate_onboarding, audit_freshness |\n| **Git** | git_diff, get_hotspots, search_changes, get_blame |\n| **Session** | remember, recall, forget, get_session_summary, session_status, session_reset_focus |\n| **Meta** | index_status, search_tools, get_tool_schema, get_mcp_profile, set_mcp_profile, enrich_docs |\n\n### Daemon mode\n\nDaemon mode loads the engine once and serves calls over a Unix socket (or named pipe on Windows) — **4-5x faster**.\nThe daemon auto-starts on first connection and self-terminates after 30 minutes idle:\n\n```bash\ncodixing-mcp --root /path/to/project          # auto-starts daemon\ncodixing-mcp --root /path/to/project --daemon  # explicit daemon start\ncodixing-mcp --root /path/to/project --no-daemon-fork  # disable auto-start\n```\n\nThe daemon auto-updates the index after a short debounce on file saves, then\npersists the refreshed index before serving the new state.\n\n---\n\n## LSP Server\n\n`codixing-lsp` brings code intelligence to any LSP-capable editor — VS Code, Neovim, Emacs, Sublime Text, JetBrains.\n\n**Capabilities:** Hover, Go-to-definition, References, Call hierarchy (incoming/outgoing), Workspace symbols, Document symbols, Live reindex on save, Cyclomatic complexity diagnostics, Code actions, Inlay hints, Completions, Signature help, Rename refactoring, Semantic tokens.\n\n```bash\ncodixing-lsp --root /path/to/project\n```\n\n**Neovim:**\n```lua\n{ cmd = { \"codixing-lsp\", \"--root\", vim.fn.getcwd() } }\n```\n\n**Emacs (eglot):**\n```elisp\n(add-to-list 'eglot-server-programs\n  '((rust-mode python-mode) . (\"codixing-lsp\" \"--root\" \"/your/project\")))\n```\n\n---\n\n## VS Code / Cursor Extension\n\nThe `editors/vscode/` directory contains a TypeScript extension with: Index Workspace, Sync Index, Search, Show Repo Map, Start Daemon, Register MCP Server.\n\n```bash\ncd editors/vscode && npm install && npm run compile\n# Then F5 in VS Code to launch the Extension Development Host\n```\n\n**Pre-built VSIX:** Download `codixing.vsix` from the [releases page](https://github.com/ferax564/codixing/releases) and install:\n\n```bash\ncode --install-extension codixing.vsix\n```\n\n---\n\n## Performance\n\n| Metric | BM25-only | Hybrid (BgeSmallEn) |\n|--------|-----------|---------------------|\n| Init (138 files) | **0.21s** | 120s (one-time) |\n| MCP cold start | **24ms** | 107ms |\n| Search latency | 30-42ms | 36-40ms |\n| Top-1 accuracy | 7/10 | **10/10** |\n\n**Retrieval accuracy** (OpenClaw, 20 curated file-localization queries, 2026-04-28):\n\n| Tool | Recall@10 | MRR | Notes |\n|------|----------:|----:|-------|\n| Codixing | **0.802** | **0.827** | `symbols`, `usages`, `search`, and `cross-imports` routed by query type |\n| codebase-memory-mcp v0.6.0 | 0.374 | 0.243 | Local CLI benchmark; semantic tool was not exposed by the downloaded build |\n| grep | 0.191 | 0.168 | Baseline recursive text scan |\n\nRaw results: [external_competitor_benchmark.md](benchmarks/results/external_competitor_benchmark.md). To reproduce the full table, set `CODEBASE_MEMORY_MCP=/path/to/codebase-memory-mcp` for a local v0.6.0 binary, then run [run_external_competitors.sh](benchmarks/run_external_competitors.sh).\n\n**Large codebase** (368K LoC, 7,607 files): Init 7.9s, search 94ms, 99% token reduction vs grep.\n\n**Linux kernel** (63K C/H files, 30M+ lines, 84K-node dependency graph): 1.57s cold-start search, 0.79s warm via the MCP daemon path. Zero-deserialization mmap for instant startup. Note: fresh-process CLI invocations on a 2GB+ hybrid index pay startup cost on every call — prefer the MCP daemon or a BM25-only index (`codixing init .` without `--embed`) for the CLI path.\n\n**SWE-bench Lite** (300 tasks, 12 repos): Recall@5 = 74.3% (vs grep 41.3%).\n\nSee [benchmarks/](benchmarks/) for detailed methodology and reproduction scripts.\n\n---\n\n## Key Features\n\n- **Broad language and document support** — Tree-sitter AST for Rust, Python, JavaScript/TypeScript/TSX, Go, Java, C, C++, C#, Ruby, Swift, Kotlin, Scala, Zig, PHP, Bash, and Matlab; line-based parsing for config/diagram formats (YAML, TOML, Dockerfile, Makefile, Mermaid, XML); structured doc parsers for Markdown, HTML, reStructuredText, AsciiDoc, and plain text\n- **Documentation indexing** — indexes Markdown, HTML, reStructuredText (`.rst`), AsciiDoc (`.adoc`), and plain text (`.txt` + bare `README`/`LICENSE`/`AUTHORS`/`CHANGELOG`) alongside code with section-aware chunking, CHANGELOG-aware version-section splitting, breadcrumb metadata, and doc-to-code graph linking; use `--docs-only` to restrict results to docs or `--code-only` to exclude them\n- **Hybrid search** — BM25 + optional vector embeddings, fused with Reciprocal Rank Fusion\n- **Symbol-level call graph** — Function-to-function call edges extracted from AST, including Rust trait dispatch, Python class inheritance, and TypeScript interface implementations\n- **Dependency graph** — Import + call extraction, PageRank scoring, Personalized PageRank for focus-aware maps, Louvain community detection, shortest path queries, surprise/anomaly edge scoring\n- **Interactive graph dashboard** — `codixing graph --html` generates a self-contained HTML dashboard (no CDN, no framework): force-directed layout, color-by layer/language/directory, a node detail panel (PageRank, language, callers/callees), named architectural layers with show/hide, a deterministic guided tour of the codebase, a client-side path finder, fuzzy search-to-focus, surprise/anomaly edges, and a `--diff-base <ref>` diff-impact overlay that highlights changed files and their blast radius\n- **Graph exports for external tools** — `codixing graph --graphml` (Gephi/yEd), `--cypher` (Neo4j), `--obsidian` (markdown vault with one note per community) for downstream analysis and knowledge-base integration\n- **Git hooks** — `codixing hook install` wires post-commit hooks for automatic index sync after every commit; `codixing hook status` / `uninstall` manage the lifecycle\n- **Caller cascade** — `codixing callers <file> --depth N` walks the import graph N hops to surface the full transitive caller cascade\n- **TOML output filter pipeline** — Project-local `.codixing/filter_rules.toml` compresses MCP tool output for token-tight agent loops, with tee recovery to disk for full output when agents need it\n- **Edge confidence** — Every dependency edge tagged Verified/High/Medium/Low based on extraction method (AST-resolved, call extraction, doc reference, external)\n- **Ranked cross-imports** — PageRank + git recency scoring for relevance-ranked graph queries across directory boundaries\n- **Memory relations** — `memory_relate` tool creates typed edges between agent memory entries, enabling associative recall across sessions\n- **Feature hub** — One-call feature exploration combining search + callers + callees + tests for unified understanding\n- **Change impact analysis** — `codixing impact` computes blast radius: direct dependents, transitive dependents, and affected tests for any file\n- **Semantic concept graph** — Vocabulary gap bridging via behavioral signatures; embedding-free `--semantic` strategy matches code by what it does, not just what it's named\n- **API surface analysis** — `codixing api` lists public symbols with visibility tracking (pub, pub(crate), export, etc.)\n- **Type-aware search** — `codixing types` shows type relationships: implements, extends, returns, contains\n- **Usage example mining** — `codixing examples` finds real usage from tests, callers, and doc blocks\n- **Cross-file context assembly** — `codixing context` follows import chains and callees to assemble understanding context\n- **Agent context pack** — `codixing ask` / `agent-context-pack` and MCP `agent_context_pack` compile a versioned JSON pack with repo orientation, must-read evidence handles, related symbols, likely tests, docs, risks, and recommended next tools; `ask` infers workflow mode from the task and pins symbol definitions ahead of tests/usages\n- **Definition-first search** — identifier queries auto-select `goto` when a primary definition is indexed; chunk-level definition boost ranks `struct Foo` above tests/usages of `Foo`\n- **Compact impact + hard-budget maps** — `impact` defaults to top-N blast radius; repo maps never overshoot `--token-budget` and accept focus seeds\n- **Token-savings harness** — `codixing bench-tokens` measures Codixing vs naive grep+read token cost for release claims\n- **External-context import** — `codixing import <github|adr|jira|linear> <path>` and the MCP `import_external` tool ingest GitHub issues/PRs (from `gh issue list --json …` or the REST API), architecture decision records, and Jira/Linear issue exports (CSV or JSON, auto-detected) as first-class searchable documents. Imported context is chunked like docs, linked to the code symbols it mentions (doc→code graph edges, so `callers`/`impact` surface the tickets discussing a file), and tagged so `codixing search --source github` (or `--source jira` / `linear` / `adr` / `external`) scopes results. Fully local — no SaaS connector or API key. Re-importing a source replaces it; imports survive `sync` (a full `init` rebuilds from disk, so re-run imports after)\n- **Query-personalized PageRank** — Query-time graph boost seeds PageRank from query-relevant nodes for context-aware ranking\n- **Learned query reformulation** — Project-specific vocabulary expansion learns from codebase patterns with deterministic evidence-ranked caps (32 terms/file, 12 expansions/term), compact string-interned persistence, and sync-safe freshness\n- **CLI + MCP** — Full CLI surface for direct use (run `codixing --help`) plus a profile-gated MCP catalog for editor integration (search, graph traversal, file operations, code review, git analysis, session memory, federation discovery)\n- **File freshness audit** — `audit_freshness` tool identifies stale and orphaned files across releases\n- **Preflight gates** — Plugin enforces existence scanning before proposing new features\n- **TypeScript import resolution** — Resolve `.js` → `.ts` imports with node16/bundler moduleResolution support, enabling 0.8+ R@10 on cross-package code discovery\n- **BM25-first embedding workflow** — Plain `codixing init .` creates the fast lexical/graph index. `init --embed` builds vectors and waits for a durable checkpoint; `init --embed --defer-embeddings` intentionally returns BM25-only and `codixing embed` adds vectors later without re-indexing source\n- **Model2Vec with code-aware preprocessing** — Static embeddings via `potion-base-8M` (no ONNX needed, instant init). CamelCase/snake_case splitting before tokenization reduces subword fragments by 50-70%, achieving MRR 1.000 on concept queries\n- **Jina Code Int8** — `jina-embeddings-v2-base-code` int8-quantized for ARM64 (768 dims, 8ms/query, nDCG@10 0.949). Set `JINA_CODE_INT8_ONNX` env var to the model path\n- **Embedding speed measurement** — New `bench-embed` CLI subcommand for profiling embedding performance across custom models\n- **Health diagnostics** — `codixing doctor` reports binary/version, PATH binary drift (`--fix-path`), free disk, writer-lock owner, ONNX/semantic recommendations (`--check-update` for newer releases), index metadata health, git staleness, daemon endpoint status, and index disk usage in human or JSON form; `init --dry-run` inventories files before indexing\n- **Daemon mode** — Engine stays in memory, auto-starts on first connection, Unix socket (macOS/Linux) or named pipe (Windows) IPC, file watcher for live index updates, 30-min idle timeout\n- **Field-weighted BM25** — Configurable per-field boosting (entity_names 3×, signature 2×, scope_chain 1.5×, content 1×)\n- **Search pipeline** — Composable search stages (definition boost, test demotion, path match, graph boost, recency boost, graph semantic propagation via GraphPropagationStage, file-level dedup via FileDedupStage, truncation) with seven strategies, including file-trigram exact-match and embedding-free semantic matching\n- **Multi-query RRF fusion** — Auto-generates query reformulations for natural-language queries (3+ words) and fuses results via Reciprocal Rank Fusion; also available via explicit `queries` parameter on `code_search`\n- **Git recency signal** — Mildly boosts recently modified files (+10% linear decay over 180 days) via lazy-loaded git log timestamps\n- **Overlapping chunks** — Bridge chunks at AST-aware chunk boundaries capture cross-function context; configurable `overlap_ratio` (default 0.0)\n- **File path boosting** — Detects explicit file paths and backtick code references in queries and boosts matching results (2.5×)\n- **Kernel-scale performance** — Tested on the Linux kernel (63K C/H files, 30M+ lines, 84K-node graph): 1.57s cold-start search, 0.79s warm via the MCP daemon. Mmap symbols, compact chunk metadata (11× smaller), and one lazy file-level trigram artifact serve both grep and exact search. Exact lookup streams candidate paths in bounded batches and hydrates only selected Tantivy chunks; fresh indexes no longer persist a duplicate chunk-level trigram corpus\n- **Trigram pre-filtering** — File-level trigram inverted index (Russ Cox/trigrep technique) skips files before disk I/O; **110× faster** literal grep at 1K files, **52× faster** at 10K files; persistent bitcode storage, regex HIR walking with OR-branch support, parallel rayon verification\n- **LSP rename + semantic tokens** — Cross-file rename refactoring with conflict detection; semantic highlighting for Rust, Python, TypeScript, Go\n- **Optional RustQueue embedding primitives** — Feature-gated, file-grouped job and bounded-channel worker implementation for embedding experiments; the supported CLI durability path is `codixing embed` with generation checkpoints\n- **Streaming embeddings** — Fixed-window batch processing (256 chunks) with progress reporting; incremental vector reuse via content hashing\n- **Federation auto-discovery** — Auto-detects Cargo, npm, pnpm, Go workspaces, git submodules, and nested projects; lazy federation keeps a bounded stable resident set and searches overflow projects through short-lived read-only engines instead of churning the whole cache\n- **Read-only concurrent access** — CLI analysis/search commands and federated project members open the index without probing or owning the Tantivy writer lock, so reads start immediately alongside sync/indexing; explicit `--strategy instant` and `--strategy exact` additionally skip graph, vector, and reranker loading for lean one-shot large-index reads; periodic reload detects writer updates automatically\n- **Changed-file checkpoints** — Incremental updates hard-link immutable artifacts into an unpublished generation, retain a mmap-backed symbol overlay and tombstoned file-trigram updates while edits arrive, then atomically publish once per 2 s idle / 30 s maximum / 256-path batch. A durable path journal recovers interrupted work; unsupported hard-link filesystems fail before copying more than 64 MiB instead of silently duplicating a multi-GB index\n- **Incremental embedding** — `sync` skips re-embedding unchanged chunks (content hash comparison)\n- **Cosmetic-edit embedding reuse** — `sync` computes a deterministic per-file *signature fingerprint* (symbol signatures, imports, exports) from the AST; when a file's content changed but its fingerprint did not (a comment/whitespace/internal-logic edit), it refreshes BM25/symbols but reuses the cached embedding vectors instead of recomputing them. Conservative: any file without a stable fingerprint re-embeds\n- **Progress notifications** — Long-running MCP tools emit `notifications/progress` with streaming partial results so agents see live status\n- **Windows support** — Named pipe daemon, brute-force vector fallback when usearch (POSIX-only) is unavailable\n- **GitHub Action** — Bounded dependency-impact analysis on PRs, with changed-file and comment-size ceilings for very large diffs\n- **Token budgets** — All output respects token limits; adaptive truncation at score cliffs\n- **Cross-repo federation** — Unified search across multiple indexed projects with CLI management and workspace auto-discovery (`codixing federation init/add/remove/list/search/discover`)\n- **Cross-package import graph** — `cross-imports` command finds files in one directory that import from another via single O(E) graph walk\n- **HTTP API server** — REST endpoints (search, symbols, grep, hotspots, complexity, outline, graph) with SSE streaming (`crates/server/`)\n- **Self-contained binaries** — No JVM, Docker, external database, or hosted API key. CLI, MCP, LSP, and HTTP server binaries are released for Linux, Apple Silicon macOS, and Windows x86_64\n\n---\n\n## Supported Languages\n\n| Tier | Languages |\n|------|-----------|\n| **Tier 1** (full AST + graph) | Rust, Python, TypeScript, TSX, JavaScript, Go, Java, C, C++, C# |\n| **Tier 2** (full AST + graph) | Ruby, Swift, Kotlin, Scala |\n| **Tier 3** (full AST + graph) | Zig, PHP, Bash, Matlab |\n| **Config** (symbol extraction) | YAML, TOML, Dockerfile, Makefile |\n| **Diagram / Markup** (symbol extraction) | Mermaid, XML/Draw.io |\n| **Docs** (section-aware chunking) | Markdown, HTML, reStructuredText (`.rst`), AsciiDoc (`.adoc`, `.asciidoc`), plain text (`.txt` + bare `README`/`LICENSE`/`AUTHORS`/`CHANGELOG`) |\n\n---\n\n## Architecture\n\n```\n┌──────────────────────────────────────────────────────────────────┐\n│                        Codixing Engine                            │\n│                                                                   │\n│  Tree-sitter  →  cAST Chunker  →  Tantivy (BM25)                │\n│  AST Parser      (18 langs)       + Code Tokenizer               │\n│                                                                   │\n│  Symbol Table (DashMap)    Code Graph (petgraph + PageRank)      │\n│                                                                   │\n│  Retriever: BM25 · Hybrid (RRF) · Thorough (MMR) · Explore      │\n│  + Exact (trigram) · Graph boost · Definition 3.5× · Session     │\n│  SearchPipeline: composable stages, 7 strategies                  │\n│                                                                   │\n│  API: CLI · profile-gated MCP · LSP · HTTP                       │\n│       Daemon (Unix socket / Windows named pipe) · File Watcher   │\n└──────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Development\n\n```bash\ncargo build --workspace\ncargo test --workspace        # run the workspace test suite\ncargo clippy --workspace -- -D warnings\ncargo fmt --check\n```\n\n---\n\n## License\n\nLicensed under the [Apache License, Version 2.0](LICENSE). See [LICENSE](LICENSE) for the full text.\n",
  "bytes": 31326,
  "sha": "5b6285da7434fb1bb8dee527138bcac5c4016fbf5ad8e7723c69258094e6e9b6",
  "repo_slug": "ferax564/codixing",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_ferax564_codixing_codixing_e7cc7fb5/readme"
}