# Referencia del sistema de herramientas (/es/docs/verdent-for-vscode/advanced-features/tool-reference)
> Referencia completa del sistema de herramientas de Verdent
### Lo que aprenderás [#lo-que-aprenderás]
Referencia completa del sistema de herramientas integrado de Verdent, incluyendo operaciones con archivos, capacidades de búsqueda, ejecución de comandos y herramientas de integración.
***
## Resumen de las herramientas disponibles [#resumen-de-las-herramientas-disponibles]
Verdent for VS Code ofrece un conjunto completo de herramientas para manipular código, navegar e interactuar con servicios externos.
| Herramienta | Propósito | Capacidades clave |
| ------------ | ----------------------------- | --------------------------------------------------------------------------------------- |
| `file_read` | Leer el contenido de archivos | Admite rangos de líneas para archivos grandes, funciona con todos los formatos de texto |
| `file_edit` | Modificaciones específicas | Reemplaza coincidencias exactas de texto, varios reemplazos, conserva el formato |
| `file_write` | Crear o sobrescribir archivos | Creación/reemplazo completo de archivos, maneja contenido de texto |
| Herramienta | Propósito | Capacidades clave |
| -------------- | --------------------------------------- | ------------------------------------------------------------------------------- |
| `glob` | Búsqueda de archivos basada en patrones | Patrones glob (`**/*.ts`), patrones de exclusión, límite de resultados |
| `grep_content` | Búsqueda de contenido con contexto | Compatible con regex, líneas de contexto, opciones sin distinción de mayúsculas |
| `grep_file` | Listar archivos con coincidencias | Identifica rápidamente archivos antes de leer su contenido |
| `list_dir` | Estructura de directorios | Muestra la jerarquía, patrones de exclusión, control de profundidad |
| Herramienta | Propósito | Capacidades clave |
| ---------------- | -------------------------------- | --------------------------------------------------------------------------------------- |
| `bash` | Ejecución de comandos de shell | Configuración de tiempo de espera, descripciones de resumen, encadenamiento de comandos |
| `spawn_subagent` | Delegar en especialistas | Lanza subagentes general, explorer, verifier o code-reviewer |
| `todo_update` | Seguir el progreso de las tareas | Gestiona listas de tareas, actualiza el estado, seguimiento del progreso |
| Herramienta | Propósito | Capacidades clave |
| ------------ | -------------------------- | --------------------------------------------------------------------------------- |
| `web_search` | Búsqueda en internet | Ejecución de consultas, control del número de resultados, filtrado por actualidad |
| `web_fetch` | Obtener y analizar páginas | Recupera contenido, extrae información mediante consultas |
***
## Capacidades de las herramientas y casos de uso [#capacidades-de-las-herramientas-y-casos-de-uso]
### file\_read [#file_read]
**Capacidades:**
* Leer el contenido completo de archivos o rangos de líneas específicos
* Esencial para entender el código antes de modificarlo
* Manejo eficiente de archivos grandes mediante la especificación de rangos
**Casos de uso:**
* Leer archivos de configuración antes de editarlos
* Entender patrones de implementación existentes
* Revisar archivos de prueba para comprender la cobertura
**Ejemplo:**
```bash
# Read entire file
file_read("src/components/Button.tsx")
# Read specific range for large files
file_read("package-lock.json", start_line=1, max_lines=50)
```
***
### file\_edit [#file_edit]
**Capacidades:**
* Reemplazo preciso de texto mediante coincidencia exacta de cadenas
* Varias operaciones de reemplazo con la opción `multiple`
* Conserva la estructura y el formato del archivo
**Casos de uso:**
* Actualizar implementaciones de funciones
* Modificar valores de configuración
* Refactorizar nombres de variables en varios archivos
**Práctica recomendada:** Úsala para cambios específicos. Para reescrituras completas, usa `file_write` en su lugar.
***
### file\_write [#file_write]
**Capacidades:**
* Crear archivos nuevos desde cero
* Reemplazar por completo el contenido de archivos existentes
* Manejar cualquier formato basado en texto
**Casos de uso:**
* Generar nuevos componentes o módulos
* Crear archivos de configuración
* Escribir archivos de prueba
**Advertencia:** Sobrescribe por completo los archivos existentes. Usa `file_edit` para modificaciones parciales.
### glob [#glob]
**Capacidades:**
* Encontrar archivos que coincidan con patrones: `**/*.ts`, `src/**/*.js`
* Filtrar por ruta de directorio
* Patrones de exclusión para acotar resultados
* Controlar el número de resultados
**Casos de uso:**
* Encontrar todos los componentes de un proyecto
* Localizar archivos de prueba
* Identificar archivos de configuración en varios directorios
**Patrones de ejemplo:**
```bash
**/*.tsx # All TypeScript React files
src/**/*.test.js # All test files in src
**/config.* # All config files anywhere
```
***
### grep\_content [#grep_content]
**Capacidades:**
* Buscar contenido de archivos usando patrones regex
* Mostrar líneas de contexto antes/después de las coincidencias (opciones `-B`, `-A`)
* Búsqueda sin distinción de mayúsculas
* Filtrar por tipo de archivo mediante patrones glob
**Casos de uso:**
* Encontrar definiciones de funciones
* Localizar implementaciones de endpoints de API
* Buscar mensajes de error específicos
* Identificar patrones de seguridad
**Ejemplo:**
```bash
# Find authentication-related code
grep_content("auth.*login", glob="**/*.ts")
# Search with context
grep_content("TODO", glob="src/**", context_before=2, context_after=2)
```
***
### grep\_file [#grep_file]
**Capacidades:**
* Listar archivos que contienen coincidencias de patrón
* Más rápida que `grep_content` cuando solo necesitas las ubicaciones de los archivos
* Compatible con patrones regex
* Filtrado glob por tipos de archivo
**Casos de uso:**
* Identificar qué archivos necesitan refactorización
* Encontrar archivos que importan módulos específicos
* Localizar archivos con patrones obsoletos
**Práctica recomendada:** Usa primero `grep_file` para identificar archivos relevantes y luego `file_read` para un examen detallado.
***
### list\_dir [#list_dir]
**Capacidades:**
* Mostrar la jerarquía de directorios
* Controlar la profundidad con el parámetro `max_depth`
* Patrones de exclusión para filtrar la salida
**Casos de uso:**
* Entender la estructura del proyecto
* Verificar la organización de directorios
* Encontrar subdirectorios específicos
### bash [#bash]
**Capacidades:**
* Ejecutar comandos de shell
* Tiempo de espera máximo: 120 segundos (2 minutos, límite estricto)
* Encadenar comandos con `&&` para dependencias
* Proporcionar resúmenes descriptivos para mayor claridad
**Casos de uso:**
* Ejecutar pruebas
* Construir proyectos
* Instalar dependencias
* Operaciones de Git
* Migraciones de bases de datos
**Ejemplo:**
```bash
# Run tests
bash("npm test", timeout=60000, summary="Run Jest test suite")
# Chain dependent commands
bash("npm install && npm run build", timeout=120000)
```
**Seguridad:** Los comandos se ejecutan con los permisos del usuario. Revisa los comandos en Manual Accept Mode.
***
### spawn\_subagent [#spawn_subagent]
**Capacidades:**
* Lanzar subagentes especializados con contextos aislados
* Tipos: `explorer`, `verifier`, `code-reviewer`
* Delegar tareas complejas sin contaminar el contexto principal
* Ejecución de subagentes en paralelo para mayor eficiencia
**Casos de uso:**
* **explorer:** Buscar patrones en bases de código grandes
* **verifier:** Validar la lógica de implementación
* **code-reviewer:** Evaluación de seguridad y calidad
**Práctica recomendada:** Delega la investigación exploratoria en el subagente Explorer para preservar el contexto de la conversación principal.
***
### todo\_update [#todo_update]
**Capacidades:**
* Crear y gestionar listas de tareas
* Actualizar el estado de las tareas (pending, in\_progress, completed)
* Seguir el progreso en implementaciones complejas
**Casos de uso:**
* Desglosar funciones de varios pasos
* Seguir el progreso de la refactorización
* Gestionar tareas de migración
### web\_search [#web_search]
**Capacidades:**
* Consultar motores de búsqueda de internet
* Controlar el número de resultados
* Filtrar por actualidad (días recientes)
**Casos de uso:**
* Encontrar documentación de APIs desconocidas
* Investigar mensajes de error
* Comprobar las prácticas recomendadas actuales
***
### web\_fetch [#web_fetch]
**Capacidades:**
* Recuperar el contenido de páginas web
* Analizar contenido con consultas específicas
* Extraer información estructurada
**Casos de uso:**
* Leer páginas de documentación
* Analizar la documentación de API
* Extraer ejemplos de tutoriales
***
## Compatibilidad con formatos de archivo [#compatibilidad-con-formatos-de-archivo]
Verdent funciona con todos los formatos de archivo basados en texto a través de sus herramientas de operación con archivos.
| Categoría | Lenguajes/Extensiones |
| ------------- | --------------------------------------------------- |
| **Web** | JavaScript, TypeScript, HTML, CSS, SCSS, LESS |
| **Backend** | Python, Java, Go, Rust, C, C++, C#, Ruby, PHP, Perl |
| **Móvil** | Swift, Kotlin, Dart (Flutter), Objective-C |
| **Funcional** | Haskell, Scala, Elixir, Clojure, F# |
| **Scripting** | Bash, PowerShell, Zsh, Fish |
| **Datos** | SQL, R, Julia, MATLAB |
| Formato | Ejemplos comunes |
| -------- | ----------------------------------------------------------------- |
| **JSON** | package.json, tsconfig.json, settings.json |
| **YAML** | docker-compose.yml, GitHub Actions, configuraciones de Kubernetes |
| **TOML** | Cargo.toml, pyproject.toml |
| **XML** | pom.xml, web.xml, archivos de configuración |
| **INI** | .gitconfig, .editorconfig |
| **ENV** | archivos .env, configuración de entorno |
| **HCL** | configuración de Terraform |
| Formato | Casos de uso |
| -------------------- | -------------------------------------------- |
| **Markdown** | README.md, archivos de documentación |
| **HTML** | Plantillas, páginas web |
| **LaTeX** | Documentos científicos, artículos académicos |
| **reStructuredText** | Documentación de Python |
| **AsciiDoc** | Documentación técnica |
### Formatos de datos [#formatos-de-datos]
| Formato | Descripción |
| -------------------------- | --------------------------------------- |
| **CSV/TSV** | Archivos de datos tabulares |
| **Datos basados en texto** | Archivos de registro, volcados de datos |
| **JSON/YAML** | Intercambio de datos estructurados |
### Archivos de compilación y paquetes [#archivos-de-compilación-y-paquetes]
| Archivo | Propósito |
| -------------------- | ----------------------------- |
| **Makefile** | Automatización de compilación |
| **package.json** | Dependencias de Node.js |
| **requirements.txt** | Paquetes de Python |
| **Gemfile** | Gems de Ruby |
| **Cargo.toml** | Paquetes de Rust |
| **build.gradle** | Compilaciones de Gradle |
| Tipo de formato | Ejemplos | Editabilidad |
| ------------------------- | ---------------------------- | ------------------------ |
| **Imágenes** | PNG, JPG, GIF, SVG (binario) | No editable directamente |
| **Videos** | MP4, AVI, MOV | No editable directamente |
| **Binarios compilados** | EXE, DLL, SO | No editable directamente |
| **Archivos comprimidos** | ZIP, TAR, GZ | No editable directamente |
| **Documentos de oficina** | DOCX, XLSX, PPTX | No editable directamente |
| **PDFs** | Archivos PDF | No editable directamente |
Los archivos binarios pueden referenciarse en el código, pero no pueden modificarse a través de las herramientas de archivo.
***
## Compatibilidad con lenguajes de programación [#compatibilidad-con-lenguajes-de-programación]
Verdent ofrece compatibilidad completa con todos los lenguajes de programación y frameworks basados en texto.
| Lenguaje/Framework | Nivel de compatibilidad | Casos de uso comunes |
| ------------------ | ----------------------- | ------------------------------------------------------ |
| JavaScript | Excelente | Lógica de frontend, backends de Node.js, herramientas |
| TypeScript | Excelente | Apps web con tipado seguro, proyectos a gran escala |
| React | Excelente | UIs basadas en componentes, hooks, gestión de estado |
| Vue | Excelente | Apps web progresivas, componentes de un solo archivo |
| Angular | Excelente | Aplicaciones empresariales, integración con TypeScript |
| Svelte | Muy buena | Componentes compilados, programación reactiva |
| HTML/CSS | Excelente | Marcado, estilos, diseño responsivo |
| SCSS/LESS | Excelente | Estilos avanzados, variables, mixins |
| Lenguaje/Framework | Nivel de compatibilidad | Casos de uso comunes |
| -------------------- | ----------------------- | ------------------------------------------------------- |
| Python | Excelente | APIs, procesamiento de datos, automatización |
| Django/Flask/FastAPI | Excelente | Frameworks web, APIs REST |
| Node.js/Express | Excelente | Backends de JavaScript, microservicios |
| Java/Spring | Excelente | Aplicaciones empresariales, Spring Boot |
| Go | Excelente | Servicios de alto rendimiento, CLIs |
| Rust | Muy buena | Programación de sistemas, código crítico en rendimiento |
| C/C++ | Muy buena | Sistemas, embebidos, motores de juego |
| C# / .NET | Excelente | Apps de Windows, servicios web, Unity |
| Ruby/Rails | Muy buena | Aplicaciones web, desarrollo rápido |
| PHP | Buena | WordPress, Laravel, apps heredadas |
| Lenguaje/Framework | Nivel de compatibilidad | Casos de uso comunes |
| ------------------ | ----------------------- | ---------------------------------- |
| Swift | Excelente | Apps nativas de iOS/macOS |
| Kotlin | Excelente | Apps nativas de Android |
| Dart/Flutter | Excelente | Apps móviles multiplataforma |
| React Native | Excelente | Apps móviles basadas en JavaScript |
| Objective-C | Buena | Apps heredadas de iOS/macOS |
| Lenguaje | Nivel de compatibilidad | Casos de uso comunes |
| -------- | ----------------------- | ----------------------------------------------- |
| Python | Excelente | NumPy, Pandas, scikit-learn, TensorFlow |
| R | Muy buena | Análisis estadístico, visualización de datos |
| SQL | Excelente | Consultas de bases de datos, diseño de esquemas |
| Julia | Buena | Computación científica, análisis numérico |
| Lenguaje | Nivel de compatibilidad | Casos de uso comunes |
| -------- | ----------------------- | ------------------------------------------------- |
| C | Muy buena | Programación de sistemas, embebidos |
| C++ | Muy buena | Aplicaciones críticas en rendimiento |
| Rust | Muy buena | Programación de sistemas con seguridad de memoria |
| Go | Excelente | Sistemas concurrentes, servicios en la nube |
| Assembly | Buena | Optimización de bajo nivel, depuración |
**Calidad de la compatibilidad:** Los lenguajes comunes (JavaScript, Python, TypeScript) tienen mayor compatibilidad debido a la amplia cantidad de datos de entrenamiento. Los lenguajes menos comunes o específicos de un dominio pueden tener una calidad de compatibilidad reducida, pero siguen siendo funcionales.
***
## Límites de uso y prácticas recomendadas [#límites-de-uso-y-prácticas-recomendadas]
### Eficiencia de file\_read [#eficiencia-de-file_read]
**Prácticas recomendadas:**
* Usa rangos de líneas para archivos de más de 500 líneas y evita saturar el contexto
* Lee solo las secciones relevantes para la tarea
* Para archivos grandes, usa primero `grep_content` para identificar los números de línea relevantes
```bash
# Good: Read specific section
file_read("large-config.json", start_line=100, max_lines=50)
# Less efficient: Read entire large file
file_read("large-config.json") # May consume excessive context
```
***
### Precisión de file\_edit [#precisión-de-file_edit]
**Prácticas recomendadas:**
* Asegura coincidencias exactas de cadenas para evitar ediciones fallidas
* Para varios cambios similares, usa la opción `multiple=true`
* Verifica las rutas de los archivos antes de editar
***
### Seguridad de file\_write [#seguridad-de-file_write]
**Prácticas recomendadas:**
* Verifica dos veces las rutas para evitar sobrescrituras accidentales
* Úsala solo para archivos nuevos o reescrituras completas
* Para modificaciones, prefiere `file_edit` por seguridad
### Especificidad de los patrones glob [#especificidad-de-los-patrones-glob]
**Prácticas recomendadas:**
* Usa patrones específicos para acotar el alcance: `src/**/*.ts` en lugar de `**/*`
* Excluye directorios con patrones de exclusión: `!**/node_modules/**`
* Limita los resultados para evitar una salida abrumadora
```bash
# Good: Specific scope
glob("src/components/**/*.tsx", max_results=50)
# Less efficient: Too broad
glob("**/*") # Returns thousands of results
```
***
### Estrategia de grep [#estrategia-de-grep]
**Flujo de trabajo recomendado:**
1. Usa `grep_file` para identificar archivos relevantes
2. Lee archivos específicos con `file_read`
3. Usa `grep_content` cuando necesites el contexto circundante
**Consejos de rendimiento:**
* Los patrones regex pueden tardar más que las cadenas literales
* Las búsquedas sin distinción de mayúsculas son más lentas
* Limita las líneas de contexto (`-A`, `-B`) a lo necesario
### Prácticas recomendadas de bash [#prácticas-recomendadas-de-bash]
**Ejecución segura de comandos:**
* Proporciona resúmenes claros para las descripciones de los comandos
* Establece tiempos de espera apropiados para operaciones de larga duración
* Encadena comandos dependientes con `&&`
* Revisa con cuidado los comandos destructivos (rm, drop, truncate)
```bash
# Good: Clear summary, reasonable timeout
bash("npm run build", timeout=120000, summary="Build production bundle")
# Good: Chained dependencies
bash("npm install && npm run test", timeout=180000)
```
***
### Consideraciones de seguridad [#consideraciones-de-seguridad]
**Reglas de seguridad críticas:**
* Los comandos se ejecutan con los permisos del usuario
* Nunca ejecutes comandos no confiables
* Usa Manual Accept Mode para revisión en bases de código compartidas
* Evita comandos que expongan credenciales o datos sensibles
Revisa siempre los comandos de bash en Manual Accept Mode cuando trabajes en bases de código compartidas o entornos de producción.
### Eficiencia en la delegación a subagentes [#eficiencia-en-la-delegación-a-subagentes]
**Cuándo usar subagentes:**
* **Explorer:** Búsquedas en la base de código, preguntas de arquitectura (ahorra contexto principal)
* **Verifier:** Comprobaciones rápidas de validación (verificación aislada)
* **Code-reviewer:** Revisiones de seguridad y calidad (análisis detallado)
* **General:** Tareas complejas de varios pasos (ejecución en paralelo)
**Práctica recomendada:**
Delega tareas exploratorias y de investigación en subagentes para preservar el contexto de la conversación principal para el trabajo de desarrollo activo.
***
### Gestión del contexto [#gestión-del-contexto]
**Uso estratégico de las herramientas:**
* Lee archivos de forma estratégica: solo lo necesario
* Usa subagentes para investigación en segundo plano
* Monitorea el consumo de contexto durante sesiones largas
* Divide operaciones complejas en pasos con todo\_update
**Flujos de trabajo eficientes:**
1. **Planificación:** Usa glob/grep para identificar el alcance
2. **Lectura:** Lee solo los archivos/secciones relevantes
3. **Ejecución:** Delega en subagentes cuando sea apropiado
4. **Verificación:** Comprobaciones rápidas con el subagente Verifier
### Límites de tamaño de archivo [#límites-de-tamaño-de-archivo]
**Manejo de archivos grandes:**
Los archivos muy grandes (>10.000 líneas) deben leerse en secciones para evitar:
* Agotamiento de la ventana de contexto
* Tiempos de respuesta lentos
* Problemas de memoria
Para archivos de más de 500 líneas, usa siempre rangos de líneas con `file_read` para mantener un rendimiento óptimo.
***
### Tiempos de espera predeterminados de las herramientas [#tiempos-de-espera-predeterminados-de-las-herramientas]
**Límites de las herramientas:**
* **Tiempo de espera de Bash:** 120 segundos (2 minutos) como máximo
* **Operaciones con archivos:** Sin límites de tamaño (los archivos grandes se leen automáticamente por lotes)
* **Manejo de archivos grandes:** Los archivos >256KB devuelven solo los primeros 256KB de contenido
* **Resultados de búsqueda:** Sin límites en los resultados de `glob` o `grep_content`
* **Subagentes concurrentes:** Sin límites en la ejecución en paralelo
**Configuración de tiempo de espera:**
* Establece tiempos de espera explícitos para operaciones de larga duración
* Monitorea posibles procesos colgados
* Los comandos que superen el tiempo de espera de 2 minutos se terminarán
***
### Operaciones concurrentes [#operaciones-concurrentes]
**Ejecución en paralelo:**
Varios subagentes pueden ejecutarse en paralelo para acelerar operaciones complejas. El agente principal gestiona la coordinación automáticamente.
**Beneficios de rendimiento:**
* Reducción del tiempo total de ejecución en tareas de varios pasos
* Utilización eficiente de los recursos
* Orquestación automática de tareas
* Sin límites en el número de subagentes concurrentes
***
## Consulta también [#consulta-también]
Aprende sobre los agentes especializados
Controla la ejecución de herramientas con los modos