Repomix is a multi-interface tool that packs code repositories into a single AI-optimized file for consumption by large language models (LLMs) like ChatGPT, Claude, and Gemini. It operates as a CLI tool, a library, an MCP (Model Context Protocol) server, a GitHub Action, a browser extension, and a web service. The core pipeline discovers files respecting ignore patterns, reads them with binary and encoding detection, optionally compresses code via tree-sitter (removing implementation details while preserving signatures), scans for secrets with Secretlint, and generates output in XML, Markdown, JSON, or plain text formats. It also provides token counting with configurable encodings and disk-backed caching, git integration (diffs, logs, change-frequency sorting), and skill generation for Claude Agent. Architecturally, the project is modular with a clear separation between the core library (src/core/), CLI interface (src/cli/), MCP server (src/mcp/), website (website/), and browser extension (browser/). The core uses dependency injection for testability, worker threads (tinypool) for parallel file processing and metrics, and a strategy pattern for language-specific tree-sitter parsing. Configuration is loaded from JSON/JS/TS files and merged with CLI options. The codebase demonstrates strong engineering practices including comprehensive test coverage, security hardening (SSRF protection, git command sanitization, sandboxed MCP tools), and performance optimizations (token count cache, bounded concurrency, fast binary detection). The project is actively maintained with frequent releases, a large community (28k+ stars), and extensive documentation in 15 languages. While the core is well-architected, the multiple distribution channels and large dependency surface introduce maintenance overhead. Some duplication exists between the website and CLI validation logic, and the tree-sitter WASM management is fragile. Overall, it is a high-quality, production-ready tool with several reusable components.
Witchcraft is a high-performance, local-first semantic search engine built in Rust. It indexes documents using a quantized T5 encoder (Google DeepMind's XTR model) and stores dense and sparse embeddings in SQLite, enabling hybrid retrieval with no external API dependencies or vector database. The project provides multiple interfaces: a CLI (`warp`), a Python package (`witchcraft`), a Node.js native module (`warp`), and an MCP server for AI agent integration. The flagship use case is "pickbrain" — a TUI application that ingests conversation transcripts from Pi, Claude Code, Codex, and Slack, then allows the user to search and resume sessions directly from the terminal. The architecture is modular: the core library (`src/lib.rs`) handles embedding, indexing, and search; `src/embedder.rs` wraps tokenization and T5 inference with sliding-window support; `src/db.rs` manages a SQLite database with WAL, FTS5, and batch operations. Performance-critical operations use custom CPU kernels in `src/fast_ops.rs` and the separate `fbgemm-rs` crate, which provides hand-tuned AVX2/NEON bf16 matrix multiplication and int8 quantized GEMM. Embedding compression via Haar wavelets and rANS entropy coding is provided by `src/packops.rs` and `src/rans64.rs`. The project also includes benchmark tools, a quantization tool, and safety netting for platform-specific quirks (OpenVINO memory leaks, macOS thread priorities). Overall, it is a well-crafted application demonstrating deep systems engineering, though its complexity and tight coupling of some components limit broad reuse.
This repository implements an MCP (Model Context Protocol) server that exposes IDA Pro's disassembler, decompiler, debugger, and type system as a set of tools and resources consumable by LLM clients (Claude, Codex, Cursor, etc.). It operates in two distinct modes: an IDA GUI plugin that starts an MCP server on a configurable port, and a headless supervisor (`idalib-mcp`) that manages persistent worker processes for multiple databases. The architecture is a hybrid of a plugin and a standalone server, built on a custom, vendored MCP server implementation (`zeromcp`) with HTTP/SSE/stdio transports. The core API surface is defined via a decorator-based registration system (`@tool`, `@resource`, `@unsafe`, `@ext`) in `rpc.py`, which also handles output truncation middleware and JSON schema generation from TypedDicts. All IDA SDK calls are marshalled onto the main thread through a robust execution pipeline (`sync.py`) that manages timeouts, cancellation, and batch mode. The headless mode uses a supervisor/worker pattern (`idalib_supervisor.py`, `idalib_server.py`, `worker_lifecycle.py`) with health probing, idle TTL, and session management. A comprehensive compatibility layer (`compat.py`) provides version-gated shims for IDA 8.4 through 9.3. Key features include decompilation, disassembly, cross-references, memory read/write, patching, type declaration/inference, debugger control (breakpoints, step, registers), signature generation, and binary survey. Tool calls are always-on traced into the IDB as gzipped JSONL batches. The project includes an extensive test suite with a custom test framework, MCP spec regression tests, and CI running against multiple IDA versions in Docker containers. The codebase is actively maintained and demonstrates strong engineering practices, but the plugin mode is explicitly deprecated in favor of the official Hex-Rays IDA MCP Server. The heavy reliance on IDA's internal APIs and the vendored MCP server implementation represent ongoing maintenance risks. The code is well-structured with several genuinely reusable components, though some modules (e.g., `api_analysis.py`) are monolithic.