code-nexus

ElixirNexus release checklist — pre-push checks, version bump, git tag, Docker Hub build and push. Use when cutting a new release (e.g. v1.3.4), shipping Docker images, or verifying a release is production-ready.

ElixirNexus polyglot parser/extractor architecture — Sourceror for Elixir, Tree-sitter (via Rust NIF) for JS/TS/Python/Go/Rust/Java/Ruby/Kotlin/Swift. Use when adding support for a new language, debugging missing entities/calls in extracted output, or understanding the chunking pipeline.

Elixir code style, naming conventions, and idiomatic patterns. Use when writing any Elixir code, reviewing style, choosing between approaches, or when asked about naming, pipe operators, pattern matching, error tuples, or functional design principles.

GenServer patterns for stateful processes in OTP. Use when implementing a GenServer, designing stateful process behavior, choosing between call/cast/info, handling process lifecycle, or debugging a GenServer. Also covers handle_continue, terminate, and client API wrapping.

Task and Task.Supervisor patterns for concurrent work in Elixir. Use when running work concurrently, processing collections in parallel with Task.async_stream, firing background jobs without awaiting, or handling task timeouts and failures.

ExUnit testing patterns for Elixir, including async strategy, Mox for behaviour mocking, test tags, database sandbox isolation, and performance benchmarking. Use when writing tests, setting up Mox mocks, choosing async: true or false, or structuring test modules.

OTP Supervisor strategies and supervision tree design. Use when setting up a supervision tree, choosing a restart strategy (one_for_one, one_for_all, rest_for_one), configuring child specs, handling restart intensity, or designing fault-tolerant process hierarchies.

ElixirNexus search subsystem architecture — hybrid query path, RRF fusion, graph re-ranking, entity resolution, callers/callees, dead-code detection, impact analysis. Use when modifying search behavior, adding a new query tool, or debugging why a search returns unexpected results.

ElixirNexus QdrantClient patterns — collection switching, the Process.put concurrent-read-safe trick, lazy create-on-reindex, hybrid search query shape, and per-project collection naming. Use when modifying Qdrant interaction, debugging "collection not found" errors, or understanding why search bypasses the GenServer.

First-look workflow for an unfamiliar codebase via the code-nexus MCP server. The right tool order to orient yourself in 30 seconds. Use when you've just landed in a new project and need to know its shape before answering anything specific.

Recipe for safely changing a function — `analyze_impact` → `find_all_callers` → review each caller. Covers the `depth` parameter, when to widen it, and how to read the impact tree. Use before any non-trivial rename or signature change.

Query patterns for `search_code` — when natural language wins over exact names, when to fall back to grep, and how to phrase intent-based queries. Use before reaching for grep/find on an indexed codebase.

ElixirNexus indexing pipeline architecture — Broadway pipeline, DirtyTracker SHA256 incremental indexing, Indexer GenServer, and auto-reindex flow. Use when modifying indexing behavior, understanding how files are tracked, adding new language support, or debugging indexing failures.

Broadway data pipeline patterns for concurrent, fault-tolerant message processing. Use when building a processing pipeline with producers, processors, and batchers, configuring back-pressure and concurrency, handling errors and retries, or partitioning messages for ordered processing.

ETS (Erlang Term Storage) patterns for in-process shared memory. Use when implementing a cache, shared in-memory storage, lookup table, or high-throughput read store. Covers table types, concurrency options, ownership, and common operations including foldl, match, and select.

Elixir Registry for dynamic process discovery and local pub/sub. Use when registering named processes dynamically, looking up processes by key, dispatching messages to multiple registered processes, or implementing local pub/sub without external infrastructure.

Telemetry instrumentation and observability patterns for Elixir. Use when adding metrics, tracing, or monitoring to Elixir code, attaching handlers to telemetry events, implementing span events, or integrating with Phoenix/Ecto telemetry.

ElixirNexus ETS cache architecture — CacheOwner process, ChunkCache and GraphCache design, table ownership semantics, and access patterns. Use when modifying cache behavior, adding new cached data, debugging ETS table errors, or understanding why cache tables survive GenServer crashes.

ElixirNexus FileWatcher patterns — debounce, multi-directory watching, deletion vs modification handling, and integration with DirtyTracker. Use when modifying file watching behavior, adding new watched directories, understanding the debounce mechanism, or debugging file change events.

ElixirNexus MCP server patterns — deftool DSL, key normalization, transport configuration, and numeric coercion. Use when adding or modifying MCP tools, debugging tool discovery, changing transport (stdio vs HTTP), or handling MCP protocol quirks with ex_mcp.

ElixirNexus Rustler NIF build workflow for the tree-sitter parser. Use when modifying Rust NIF source, rebuilding the NIF locally or for Docker, understanding skip_compilation? and load_from patterns, or debugging NIF loading failures.

Phoenix LiveView patterns for real-time server-rendered UIs. Use when building LiveView components, handling events, managing URL state with handle_params, subscribing to PubSub in LiveView, using push_event for JavaScript interop, or implementing lifecycle hooks with on_mount and attach_hook.