https://github.com/mague/void-stack
DSM for developers — orchestrate, audit, and analyze your entire dev stack. MCP server with 27 tools for Claude & Cursor. Built in Rust.
https://github.com/mague/void-stack
claude cli code-analysis developer-experience developer-tools devops docker mcp mcp-server open-source rust rust-cli security-audit tauri technical-debt tui
Last synced: 4 days ago
JSON representation
DSM for developers — orchestrate, audit, and analyze your entire dev stack. MCP server with 27 tools for Claude & Cursor. Built in Rust.
- Host: GitHub
- URL: https://github.com/mague/void-stack
- Owner: Mague
- License: apache-2.0
- Created: 2026-03-10T20:12:25.000Z (about 2 months ago)
- Default Branch: main
- Last Pushed: 2026-04-18T20:13:31.000Z (10 days ago)
- Last Synced: 2026-04-18T22:15:18.314Z (10 days ago)
- Topics: claude, cli, code-analysis, developer-experience, developer-tools, devops, docker, mcp, mcp-server, open-source, rust, rust-cli, security-audit, tauri, technical-debt, tui
- Language: Rust
- Homepage: https://www.void-stack.dev
- Size: 3.45 MB
- Stars: 3
- Watchers: 0
- Forks: 1
- Open Issues: 1
-
Metadata Files:
- Readme: README.es.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
Void Stack
[](https://github.com/Mague/void-stack/actions/workflows/ci.yml)
[](https://github.com/Mague/void-stack/actions/workflows/release.yml)
[](https://github.com/Mague/void-stack/releases/latest)
[](LICENSE)
[](https://www.rust-lang.org/)
[]()
[]()
**¿Tenés 10 proyectos con backends, frontends, workers y bases de datos, y no recordás cómo levantar ninguno?**
Void Stack resuelve eso. Un solo comando para arrancar todo tu stack de desarrollo — backend, frontend, base de datos, workers — en Windows, WSL o Docker. Sin recordar puertos, sin abrir 5 terminales, sin leer READMEs viejos.
```bash
void add mi-app F:\proyectos\mi-app # Detecta servicios automáticamente
void start mi-app # Levanta todo
```
Eso es todo. Void Stack escanea tu proyecto, detecta qué frameworks usás (FastAPI, Vite, Express, Django...), genera los comandos correctos, y los ejecuta. Si hay un venv de Python, lo encuentra. Si falta un `node_modules`, te avisa.
> **Alto Rendimiento** — Built with Rust. Cero overhead de runtime, inicio instantáneo, mínimo consumo de memoria.
> **Flujo Agéntico** — MCP server con 43 herramientas permite que Claude Desktop / Claude Code gestione tus servicios, analice código y audite seguridad de forma autónoma.
> **Cloud-Native Roadmap** — Deploy a Vercel, DigitalOcean y más desde la misma config (próximamente).
**[Read in English](README.md)** | **[void-stack.dev](https://void-stack.dev)**
---
## Dogfooding: Void Stack se analiza a sí mismo
Las herramientas de análisis y auditoría de Void Stack se usan para mantener la calidad de su propio código. Esto es lo que encontró `void analyze void-stack --compare` y `void audit void-stack` — y cómo usamos esos hallazgos para mejorar:
### Auditoría de seguridad
```bash
void audit void-stack
# Risk Score: 2/100
# 2 hallazgos low (uso de innerHTML — ya mitigado con DOMPurify)
```
La auditoría inicial encontró 6 issues (risk score 25/100), pero 4 eran falsos positivos — patrones regex y templates en el código de detección marcados como "secrets". Esto nos llevó a agregar filtrado inteligente (allowlist de archivos auto-referenciales, detección de metacaracteres regex, filtrado de templates), bajando los falsos positivos de 83% a 0%.
### Análisis de código
```bash
void analyze void-stack --compare
# Patrón: Layered (80% confianza)
# 214 módulos, 32.453 LOC, 37 deps externas
# Complejidad máx: 152 (i18n en/es — tablas de datos, no lógica)
# Anti-patrones: 26 (4 God Class medium, 13 Fat Controller, 8 Excessive Coupling)
```
Hallazgos que motivaron refactorizaciones:
| Hallazgo | Acción tomada |
|----------|--------------|
| God Class: `cli/main.rs` (1202 LOC, 25 fn) | Dividido en 6 módulos de comandos (~250 LOC main) |
| God Class: `mcp/server.rs` (1197 LOC, 35 fn) | Dividido en 10 módulos de tools (~340 LOC server) |
| God Class: `manager.rs` (30 fn) | Dividido en 4 submódulos (process, state, logs, url) |
| God Class + Fat Controller: `vuln_patterns.rs` (789 LOC) | Dividido en 5 módulos por categoría (injection, xss, network, crypto, config) |
| God Class: `db_models.rs` (1065 LOC) | Dividido en 7 submódulos por formato DB (python, sequelize, gorm, drift, proto, prisma) |
| God Class: `generate_dockerfile.rs` (821 LOC) | Dividido en 6 submódulos por lenguaje (python, node, rust, go, flutter) |
| God Class: `api_routes.rs` (747 LOC) | Dividido en 5 submódulos por protocolo (python, node, grpc, swagger) |
| God Class: `architecture.rs` (788 LOC) | Dividido en 4 submódulos (externals, crates, infra) |
| God Class: `classifier.rs` (759 LOC, 44 fn) | Dividido en 3 submódulos (lógica, tablas de señales, tests) |
| Fat Controller: `cli/analysis.rs` (580 LOC) | Dividido en 4 submódulos (analyze, diagram, audit, suggest) |
| CC=42: `analyze_best_practices` | Registro de linters table-driven (CC ~15) |
| CC=41: `cmd_analyze` | Extraídas 11 funciones helper (CC ~10) |
### Tracking de deuda técnica
```bash
void analyze void-stack --compare --label v0.23.6
# Patrón: Layered (80% confianza)
# Cobertura: 80.5% (último snapshot lcov)
# Deuda explícita: 34 marcadores (TODO: 11, TEMP: 10, OPTIMIZE: 6, BUG: 3, XXX: 2, FIXME: 1, HACK: 1)
# 960 tests pasando (936 core + 21 analyzer + 3 mcp)
```
Nuevo en v0.22.0: los marcadores de deuda explícita (TODO/FIXME/HACK/XXX/OPTIMIZE/BUG/TEMP/WORKAROUND) ahora se escanean de los comentarios del código y se muestran en la salida CLI, reportes markdown y la pestaña Deuda del desktop. Las funciones complejas (CC≥10) se cruzan con datos de cobertura — las funciones críticas sin cobertura reciben advertencias `[!]` en CLI e indicadores 🔴 en markdown.
---
## Motor de Contexto Híbrido — Semántico + Estructural
La mayoría de herramientas te obligan a elegir: búsqueda semántica (encontrar conceptos relacionados) O grafos estructurales (trazar cadenas de llamadas). Void Stack combina ambos. Los embeddings vectoriales encuentran *lo que está conceptualmente relacionado*. Los grafos Tree-sitter muestran *lo que estructuralmente se rompe*. El resultado: contexto quirúrgico que ninguna herramienta de enfoque único puede igualar.
| Enfoque | Consulta | Resultado |
|---|---|---|
| **Solo semántico** | "flujo de auth middleware" | Chunks conceptualmente relacionados |
| **Solo estructural** | "callers de validateToken" | Cadena de llamadas directa |
| **Híbrido (Void Stack)** | Ambos simultáneamente | Chunks relacionados + blast radius |
Void Stack indexa tu codebase localmente con embeddings BAAI/bge-small-en-v1.5 y arma un grafo de llamadas con Tree-sitter — así tu asistente de IA lee solo lo que importa en lugar de escanear cada archivo.
### Cómo funciona
```bash
# Indexá una vez (corre en background, ~30s para 250 archivos)
void index mi-proyecto
# Buscá por concepto, no por nombre de archivo
void search mi-proyecto "authentication middleware flow"
# Devuelve los 3-5 chunks más relevantes — no el archivo entero
# Re-indexado incremental guiado por git, no por timestamps
void index mi-proyecto --git-base HEAD~1 # solo archivos cambiados en el último commit
void index mi-proyecto --force # rebuild completo
# Desde Claude Desktop / Claude Code vía MCP:
# build_structural_graph mi-proyecto (Tree-sitter, 10 lenguajes)
# get_impact_radius mi-proyecto (BFS de blast-radius)
# query_graph mi-proyecto callers (quién llama a esta función)
# watch_project mi-proyecto (re-index automático al guardar)
# install_index_hook mi-proyecto (re-index en post-commit)
```
### Benchmarks (medidos sobre void-stack)
| Operación | Sin índice | Con void-stack | Reducción |
|-----------|----------:|---------------:|----------:|
| `semantic_search` (avg) | ~170 líneas / archivo | ~4 líneas / resultado | **97.5 %** |
| Entender un módulo | 5-10 lecturas de archivo | 1 consulta | **~10x** |
| Blast radius de un cambio | Manual, horas | `get_impact_radius` | **instantáneo** |
*El 97.5 % lo reporta `void stats --days 90` a lo largo de 135 operaciones `semantic_search` — 23 868 líneas de código que nunca entraron al contexto del LLM.*
### Lenguajes soportados
- **Índice semántico** (embeddings): toda extensión de código en `CODE_EXTENSIONS` — Rust, Python, JS/TS, Go, Dart, Java, PHP, C/C++, Ruby, Swift, Kotlin, Lua, Zig, Elixir, Vue, Svelte, Astro, más `md`/`proto`/`sql`/`dockerfile`.
- **Grafo estructural** (Tree-sitter): Rust, Python, JavaScript, TypeScript (+ TSX), Go, Dart, Java, PHP, C, C++.
Análisis estructural inspirado en [code-review-graph](https://github.com/tirth8205/code-review-graph) (MIT) — mapeos de nodos AST y lógica de BFS reimplementados nativamente en Rust.
---
## Interfaces
Void Stack tiene **4 interfaces** — usá la que prefieras:
| Interfaz | Descripción |
|----------|-------------|
| **CLI** (`void`) | Comandos rápidos desde terminal |
| **TUI** (`void-stack-tui`) | Dashboard interactivo: servicios, análisis, auditoría de seguridad, deuda, espacio |
| **Desktop** (`void-stack-desktop`) | App de escritorio con UI gráfica (Tauri + React) — Windows (.msi), macOS (.dmg), Linux (.deb) |
| **MCP Server** (`void-stack-mcp`) | Integración con Claude Desktop / Claude Code |
## Ejemplo completo: FastAPI + React en 30 segundos
Supongamos que tenés un proyecto con un backend FastAPI y un frontend React:
```
mi-app/
├── backend/ # FastAPI con venv
│ ├── main.py # from fastapi import FastAPI
│ └── .venv/
├── frontend/ # React con Vite
│ ├── package.json
│ └── src/
└── .env
```
```bash
# 1. Registrar el proyecto (escanea y detecta los servicios)
void add mi-app F:\proyectos\mi-app
# Void Stack detecta:
# ✓ backend → uvicorn main:app --host 0.0.0.0 --port 8000
# ✓ frontend → npm run dev
# ✓ .venv → auto-resuelve python al virtualenv
# 2. Verificar dependencias
void check mi-app
# ✅ Python 3.11 (venv detectado)
# ✅ Node 20.x (node_modules actualizado)
# ✅ .env completo vs .env.example
# 3. Levantar todo
void start mi-app
# [backend] → http://localhost:8000
# [frontend] → http://localhost:5173
# 4. O abrir el dashboard interactivo
void-tui mi-app
```
## Instalación
### Binarios (recomendado)
Descargá los binarios precompilados desde [Releases](https://github.com/mague/void-stack/releases) — sin necesidad de Rust.
| Plataforma | Archivo |
|------------|---------|
| Windows | `.msi` / `.exe` (NSIS) |
| macOS | `.dmg` |
| Linux | `.deb` / `.AppImage` |
> **Extensión Claude Desktop** — Cada release también incluye archivos `.mcpb` (uno por plataforma). Arrastrá el `.mcpb` a Claude Desktop para instalar el MCP server sin configuración.
> **Nota macOS:** Si aparece *"no se puede abrir porque no se puede verificar el desarrollador"*, ejecuta:
> ```bash
> xattr -cr /Applications/Void\ Stack.app
> ```
### Desde GitHub (Cargo)
```bash
# CLI principal (la herramienta core)
cargo install --git https://github.com/mague/void-stack void-stack-cli
# TUI Dashboard
cargo install --git https://github.com/mague/void-stack void-stack-tui
# MCP Server (para integración con Claude Desktop / Claude Code)
cargo install --git https://github.com/mague/void-stack void-stack-mcp
# Daemon gRPC (opcional, para gestión persistente)
cargo install --git https://github.com/mague/void-stack void-stack-daemon
```
**Prerequisitos:** [Rust](https://rustup.rs) + compilador Protobuf (`winget install Google.Protobuf` en Windows)
### Compilar desde código fuente
```bash
git clone https://github.com/mague/void-stack.git
cd void-stack
cargo build --release
# Binarios en target/release/
# void — CLI
# void-stack-tui — Dashboard en terminal
# void-stack-daemon — Daemon gRPC
# void-stack-mcp — MCP server para AI
```
### App de escritorio (Tauri)
```bash
cd crates/void-stack-desktop
cargo tauri build
# Genera instalador en target/release/bundle/
```
## Excluir archivos del análisis
Crea `.voidignore` en la raíz de tu proyecto para excluir paths de `void analyze`:
```
# Código generado
internal/pb/
vendor/
**/*.pb.go
**/*.pb.gw.go
# Mocks
**/mocks/
**/*_mock.go
```
Misma sintaxis que `.gitignore` (simplificada). Soporta prefijos de paths, globs `**/` y nombres de directorio.
## Features
- **Multi-servicio** — Arrancá/detené todos los servicios juntos o individualmente
- **Cross-platform** — Windows (`cmd`), macOS, WSL (`bash`), contenedores Docker, SSH (futuro)
- **Auto-detección** — Escanea directorios e identifica Python, Node, Rust, Go, Flutter, Docker
- **Comandos inteligentes** — Detecta FastAPI, Flask, Django, Vite, Next.js, Express, Air (hot-reload Go) y genera el comando correcto
- **Hooks pre-launch** — Crea venvs, instala dependencias (`pip install`, `npm install`, `go mod download`) por servicio antes de iniciar. Funciona sin configuración
- **Chequeo de dependencias** — Verifica Python, Node, CUDA, Ollama, Docker, Rust, `.env`
- **Logs en vivo** — Stdout/stderr de todos los servicios con detección automática de URLs
- **Diagramas** — Genera Mermaid y Draw.io desde la estructura del proyecto usando scanners unificados (arquitectura, rutas API con enriquecimiento Swagger/OpenAPI, separación API interna/externa, servicios gRPC/Protobuf, modelos DB con layout por proximidad FK — Prisma, Sequelize, GORM, Django, SQLAlchemy, Drift)
- **Análisis de código** — Grafos de dependencias, anti-patrones, complejidad ciclomática, cobertura
- **Best practices** — Linters nativos (react-doctor, ruff, clippy, golangci-lint, dart analyze) con scoring unificado
- **Deuda técnica** — Snapshots de métricas con comparación de tendencias
- **AI integration** — MCP server con 43 herramientas para Claude Desktop / Claude Code; sugerencias de refactorización con IA via Ollama (LLM local) con fallback elegante
- **Búsqueda semántica de código** — Indexá cualquier proyecto localmente con embeddings BAAI/bge-small-en-v1.5 (100 % offline, ~130 MB descarga única). `void search` y el tool MCP `semantic_search` devuelven solo los chunks relevantes — 97.5 % menos tokens que leer archivos directamente (medido sobre void-stack con 135 consultas).
- **Grafo de llamadas estructural** — Análisis función-por-función con Tree-sitter para Rust, Python, JS, TS, Go, Dart, Java, PHP, C y C++. Persiste en `.void-stack/structural.db`. El BFS de blast-radius (`get_impact_radius`) contesta *"¿qué se rompe si cambio este archivo?"* antes de tocar una línea.
- **Indexado incremental** — Git diff + hashing SHA-256: `--git-base HEAD~1` solo re-indexa archivos realmente cambiados desde el último commit. `watch_project` (MCP) re-indexa automáticamente al guardar con 500 ms de debounce; `install_index_hook` (MCP) instala un post-commit hook para que cada commit mantenga el índice al día.
- **Escáner de espacio** — Escanea y limpia deps del proyecto (node_modules, venv, target) y cachés globales (npm, pip, Cargo, Ollama, HuggingFace, LM Studio)
- **Desktop GUI** — App Tauri con estética cyberpunk mission-control, jerarquía visual (KPI cards, efectos glow, gradientes por severidad), servicios, logs, dependencias, diagramas, análisis, docs, seguridad, deuda técnica y espacio en disco
- **Daemon** — gRPC daemon opcional para gestión persistente
- **Auditoría de seguridad** — Vulnerabilidades en deps, secrets hardcodeados, configs inseguras, patrones de vulnerabilidad en código (inyección SQL, XSS, SSRF, y más) con filtrado inteligente de falsos positivos
- **Docker Runner** — Servicios con `target = "docker"` se ejecutan dentro de contenedores Docker. Cuatro modos: comandos docker crudos, referencias a imagen (`postgres:16` → auto `docker run`), auto-detección de Compose, y builds desde Dockerfile
- **Docker Intelligence** — Parsea Dockerfiles y docker-compose.yml, auto-genera Dockerfiles por framework (Python, Node, Rust, Go, Flutter), genera docker-compose.yml con infraestructura auto-detectada (PostgreSQL, Redis, MongoDB, etc.)
- **Infrastructure Intelligence** — Detecta recursos Terraform, manifiestos Kubernetes y charts Helm — todo integrado en diagramas de arquitectura
- **Seguridad** — Nunca lee valores de `.env`; protección centralizada de archivos sensibles
## CLI
| Comando | Descripción |
|---------|-------------|
| `void add ` | Registrar proyecto (auto-detecta servicios) |
| `void add-service -d ` | Agregar servicio manualmente |
| `void remove ` | Desregistrar proyecto |
| `void list` | Listar proyectos y servicios |
| `void scan ` | Vista previa de detección sin registrar |
| `void start [-s service]` | Iniciar todo o un servicio |
| `void stop [-s service]` | Detener todo o un servicio |
| `void status ` | Estado en vivo: PIDs, URLs, uptime |
| `void check ` | Verificar dependencias |
| `void diagram [-f mermaid\|drawio] [--print-content]` | Generar diagramas |
| `void audit [-o file]` | Auditoría de seguridad |
| `void analyze [--compare] [--cross-project] [--best-practices]` | Análisis de código |
| `void docker [--generate-dockerfile] [--generate-compose] [--save]` | Docker intelligence |
| `void suggest [--model ] [--service ] [--raw]` | Sugerencias AI de refactorización (Ollama) |
| `void read-file ` | Leer cualquier archivo del proyecto (bloquea .env, credenciales) |
| `void logs [-n lines] [--compact] [--raw]` | Ver logs filtrados de un servicio |
| `void index [--force] [--generate-voidignore] [--git-base ]` | Indexar codebase para búsqueda semántica (`--git-base HEAD~1` usa git diff) |
| `void search "" [-t top_k]` | Búsqueda semántica de código |
| `void stats [--project
] [--days ] [--json]` | Estadísticas de ahorro de tokens |
| `void claudeignore [--dry-run] [--force]` | Genera `.claudeignore` optimizado para el tech stack |
**Flags:** `--wsl` (rutas WSL), `--daemon` (conectar al daemon), `--compare` (comparar snapshots), `--cross-project` (dependencias entre proyectos), `--label ` (etiquetar snapshot)
### Tools MCP (Claude Desktop / Claude Code / OpenCode)
No son comandos CLI — los expone `void-stack-mcp`:
| Tool | Descripción |
|------|-------------|
| `watch_project` / `unwatch_project` | Auto re-indexado al detectar cambios (~500 ms debounce) |
| `install_index_hook` | Instala un `post-commit` hook que re-indexa los archivos cambiados |
| `build_structural_graph` | Grafo de llamadas Tree-sitter en 10 lenguajes — Rust, Python, JS, TS, Go, Dart, Java, PHP, C, C++ (`--features structural`) |
| `get_impact_radius` | BFS de blast-radius — qué se ve afectado al cambiar un archivo |
| `query_graph` | Callers / callees / tests / búsqueda fuzzy sobre el grafo estructural |
| `full_analysis` | Audit + arquitectura + hot-spots semánticos combinados en un reporte (quick/standard/deep) |
| `manage_suppressions` | Listar / agregar / eliminar reglas de supresión del auditor sin editar archivos |
| `setup_project` | Onboarding en un click: registrar + generar ignores + indexar + auditar + analizar |
> Análisis estructural inspirado en [code-review-graph](https://github.com/tirth8205/code-review-graph) (MIT).
## TUI Dashboard
```bash
void-tui # Todos los proyectos
void-tui my-project # Proyecto específico
void-tui --daemon # Vía daemon
```
| Tecla | Acción |
|-------|--------|
| `a` | Iniciar todos los servicios |
| `s` | Iniciar servicio seleccionado |
| `k` | Detener servicio seleccionado |
| `K` | Detener todos |
| `1`-`5` | Cambiar tab (Services/Analysis/Security/Debt/Space) |
| `R` | Ejecutar acción (analizar, auditar, escanear) en tab actual |
| `j`/`↓` | Navegar abajo |
| `l` | Toggle panel de logs |
| `Tab` | Cambiar panel |
| `r` | Refrescar estado |
| `L` | Cambiar idioma (ES/EN) |
| `?` | Ayuda |
| `q` | Salir (detiene servicios) |
**i18n:** Español (por defecto) e Inglés. Presiona `L` para cambiar.
**Tabs:** Servicios (gestionar/monitorear), Análisis (patrón de arquitectura, capas, anti-patrones, complejidad + cobertura), Seguridad (risk score, hallazgos), Deuda (marcadores TODO/FIXME/HACK), Espacio (uso de disco proyecto + global)
## Desktop (Tauri)
App de escritorio con interfaz gráfica oscura:
- **Servicios**: Cards con estado (running/stopped/failed), PID, uptime, URL (abre en navegador), controles start/stop, iconos por tecnología con glow en color de marca al estar corriendo, badges de target por SO (Windows/macOS/Linux/Docker) con detección automática de plataforma, eliminación de servicios con confirmación
- **Registros**: Visor de logs en vivo con selector de servicio y auto-scroll
- **Dependencias**: Tabla de checks con estado, versión, sugerencia de fix
- **Diagramas**: Rendering Mermaid + rendering nativo de Draw.io XML (renderizador SVG custom con DOMPurify) para arquitectura, rutas API, modelos DB
- **Análisis**: Patrones de arquitectura, anti-patrones, complejidad ciclomática, visualización de cobertura
- **Docs**: Renderiza README y archivos de documentación con estilo markdown
- **Espacio**: Escanea cachés del proyecto + globales, muestra tamaños, permite eliminar para liberar espacio
- **Seguridad**: Risk score, hallazgos de vulnerabilidad, detección de secrets, auditoría de configs
- **Deuda Técnica**: Snapshots de métricas con comparación de tendencias, detalles expandibles (god classes, funciones complejas, anti-patrones, deps circulares)
- **Docker**: Parsea y analiza artefactos Docker existentes, genera Dockerfiles y docker-compose.yml, guarda en proyecto
- **Sidebar**: Navegación entre proyectos, agregar/eliminar proyectos, explorador de archivos WSL
- **UX**: Botones de copiar en resultados, tooltips educativos, zoom en diagramas, tipografía Material Design 3
## MCP Server (AI Integration)
Permite que Claude Desktop, Claude Code u OpenCode gestionen tus proyectos directamente.
**Windows** — Agregar a `%APPDATA%\Claude\claude_desktop_config.json`:
```json
{
"mcpServers": {
"void-stack": {
"command": "void-stack-mcp.exe"
}
}
}
```
**macOS** — Agregar a `~/Library/Application Support/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"void-stack": {
"command": "/Users/TU_USUARIO/.cargo/bin/void-stack-mcp"
}
}
}
```
**Linux** — Agregar a `~/.config/Claude/claude_desktop_config.json`:
```json
{
"mcpServers": {
"void-stack": {
"command": "void-stack-mcp"
}
}
}
```
**OpenCode** (modelos gratuitos — sin API key requerida) — Agregar a `~/.config/opencode/opencode.json`:
```json
{
"mcp": {
"void-stack": {
"type": "local",
"command": ["void-stack-mcp"],
"enabled": true
}
}
}
```
> En macOS usá la ruta completa: `["~/.cargo/bin/void-stack-mcp"]`
> **Ventaja OpenCode:** Funciona con modelos gratuitos (MiniMax, Qwen, DeepSeek) — costo cero de API, integración completa con void-stack MCP.
> **Nota macOS:** Claude Desktop y OpenCode se inician con un PATH mínimo que no incluye `~/.cargo/bin`. Usá la **ruta absoluta completa** al binario. Ejecutá `which void-stack-mcp` en Terminal para obtenerla. También eliminá el atributo de cuarentena o macOS bloqueará el binario silenciosamente:
> ```bash
> xattr -d com.apple.quarantine ~/.cargo/bin/void-stack-mcp
> ```
**Tools disponibles (42):** `list_projects`, `project_status`, `start_project`, `stop_project`, `start_service`, `stop_service`, `get_logs`, `add_project`, `remove_project`, `check_dependencies`, `read_project_docs`, `read_all_docs`, `read_project_file`, `list_project_files`, `generate_diagram`, `analyze_project`, `audit_project`, `scan_directory`, `add_service`, `save_debt_snapshot`, `list_debt_snapshots`, `compare_debt`, `analyze_cross_project`, `scan_project_space`, `scan_global_space`, `docker_analyze`, `docker_generate`, `suggest_refactoring`, `generate_claudeignore`, `generate_voidignore`, `get_token_stats`, `index_project_codebase`, `semantic_search`, `get_index_stats`, `watch_project`, `unwatch_project`, `install_index_hook`, `build_structural_graph`, `get_impact_radius`, `query_graph`, `full_analysis`, `manage_suppressions`
## Detección de dependencias
| Detector | Verifica |
|----------|----------|
| Python | Binario, versión, venv, `pip check` |
| Node | Binario, frescura de `node_modules` |
| CUDA | `nvidia-smi`, driver, GPU, VRAM, PyTorch |
| Ollama | Binario, API health, modelos descargados |
| Docker | Binario, estado del daemon, compose |
| Rust | Versiones de `rustc` y `cargo` |
| Go | `go version`, presencia de `go.mod` |
| Flutter | `flutter --version`, `dart --version`, `pubspec.yaml` |
| .env | Compara `.env` vs `.env.example` |
## Análisis de código
```bash
void analyze my-app -o analysis.md
void analyze my-app --compare --label v2.0
void analyze my-app --cross-project
void analyze my-app --best-practices
void analyze my-app --bp-only # Solo linters, omite análisis de arquitectura
```
- **Patrones** — MVC, Layered, Clean/Hexagonal con confianza
- **Anti-patrones** — God Class, Dependencias Circulares, Fat Controllers, Acoplamiento Excesivo
- **Complejidad ciclomática** — Por función (Python, JS/TS, Go, Dart, Rust)
- **Cobertura** — LCOV, Cobertura, Istanbul, Go cover profiles
- **Grafos** — Diagramas Mermaid de relaciones entre módulos
- **Tendencias** — Snapshots históricos con comparación
## Diagramas
```bash
void diagram my-app # Draw.io (default)
void diagram my-app -f mermaid # Mermaid markdown
```
Detecta: arquitectura de servicios, servicios externos (por extracción de URLs del código fuente y .env), llamadas internas entre servicios (cruce de localhost por puerto), rutas API con enriquecimiento Swagger/OpenAPI (FastAPI, Flask, Express, gRPC/Protobuf), separación de APIs internas vs públicas, modelos DB (SQLAlchemy, Django, Prisma, Sequelize, GORM, Drift, mensajes Protobuf), relaciones entre crates Rust.
## Arquitectura
```
void-stack/
├── crates/
│ ├── void-stack-core/ # Librería core: modelos, config, runners, detectors, analyzers
│ ├── void-stack-proto/ # Definiciones Protobuf + cliente gRPC
│ ├── void-stack-daemon/ # Daemon con servidor gRPC (tonic)
│ ├── void-stack-tui/ # Dashboard terminal (ratatui)
│ ├── void-stack-mcp/ # MCP server para AI assistants
│ ├── void-stack-desktop/ # App Tauri v2 (React + TypeScript)
│ └── void-stack-cli/ # Interfaz CLI (clap)
├── example-void-stack.toml
└── CHANGELOG.md
```
## Configuración
### `void-stack.toml` (por proyecto)
```toml
name = "mi-fullstack-app"
description = "Full stack app"
project_type = "node"
[hooks]
install_deps = true
[[services]]
name = "backend-api"
command = "npm run dev"
target = "wsl"
working_dir = "./backend"
[[services]]
name = "web-frontend"
command = "npm run dev"
target = "windows"
working_dir = "./frontend"
[[services]]
name = "database"
command = "docker compose up postgres redis"
target = "docker"
[[services]]
name = "cache"
command = "redis:7-alpine"
target = "docker"
[services.docker]
ports = ["6379:6379"]
```
### Config global
Todos los proyectos se almacenan en una ubicación específica de la plataforma:
- **Windows:** `%LOCALAPPDATA%\void-stack\config.toml`
- **macOS:** `~/Library/Application Support/void-stack/config.toml`
- **Linux:** `~/.config/void-stack/config.toml`
Cada servicio tiene `working_dir` absoluto, soportando monorepos y layouts distribuidos.
## Seguridad
- Los **valores** de `.env` **nunca se leen ni almacenan** — solo los nombres de variables
- Archivos sensibles (`.env`, `credentials.json`, claves privadas, `secrets.*`) bloqueados del análisis y MCP
- Deny-list centralizada en `security.rs` cubre todos los paths de lectura de archivos
## Licencia
Este proyecto está licenciado bajo la [Apache License 2.0](LICENSE). Consulta el archivo LICENSE para más detalles.