Rev-dep

Capacidades  •   Instalación  •   Documentación  •   Kit de exploración  •   Referencia de CLI

Kit de análisis y optimización de dependencias para bases de código modernas en JavaScript y TypeScript.
Aplica higiene al grafo de dependencias y elimina código no utilizado con una CLI muy rápida.

Acerca de 📣

A medida que las bases de código crecen, mantener un mapa mental de las dependencias se vuelve imposible. Rev-dep es una herramienta de análisis estático de alta velocidad diseñada para aplicar integridad arquitectónica e higiene de dependencias en proyectos JS/TS a gran escala.

Piensa en Rev-dep como un linter de alta velocidad para tu grafo de dependencias.

Consolida comprobaciones fragmentadas y secuenciales de múltiples herramientas lentas en un único motor de alto rendimiento. Rev-dep ejecuta un conjunto completo de verificaciones de gobernanza —incluyendo circularidad, archivos huérfanos, límites de módulos y más— en una única pasada paralelizada. Implementado en Go para evitar los cuellos de botella de rendimiento del análisis basado en Node, puede auditar un proyecto de más de 500k líneas de código en aproximadamente 150ms. Consulta la comparación de rendimiento

Gobernanza automatizada de la base de código

Rev-dep va más allá del escaneo pasivo para aplicar medidas activas, respondiendo (y fallando en CI) a las preguntas difíciles:

• Integridad arquitectónica: "¿Mi 'Dominio A' está importando ilegalmente desde el 'Dominio B'?".
• Código muerto y peso: "¿Estos archivos son inalcanzables, o estos node_modules no se utilizan?".
• Seguridad en la refactorización: "¿Qué puntos de entrada usan realmente esta utilidad y hay cadenas circulares?".
• Higiene del workspace: "¿Son coherentes mis importaciones y están declaradas todas las dependencias?".

Rev-dep actúa como un guardián de alta velocidad para tu CI, asegurando que tu grafo de dependencias permanezca ágil y que tu arquitectura se mantenga intacta mientras iteras.

¿Por qué Rev-dep? 🤔

🏗️ Soporte de monorepo de primera clase

Diseñado para workspaces modernos (pnpm, yarn, npm). Rev-dep resuelve de forma nativa los mapas exports/imports de package.json, los alias de TypeScript y rastrea dependencias a través de los límites de los paquetes.

🛡️ Gobernanza de la base de código basada en configuración

Ve más allá del escaneo pasivo. Usa el motor de configuración para aplicar Límites de Módulos y Convenciones de Importación. Ejecuta un conjunto completo de comprobaciones de higiene (circularidad, archivos huérfanos, módulos no utilizados y más) en una única pasada paralelizada que actúa como un guardián de alta velocidad para tu CI.

🔍 Kit de exploración

Toolkit de CLI que ayuda a depurar problemas con dependencias entre archivos. Comprende la relación transitiva entre archivos y corrige problemas.

⚡ Construido para velocidad y eficiencia en CI

Implementado en Go para eliminar el costo de rendimiento del análisis basado en Node. Al procesar archivos en paralelo, Rev-dep ofrece una ejecución de 17x a 90x más rápida que las alternativas, reduciendo significativamente los costos de CI y los tiempos de espera de los desarrolladores.

Rev-dep puede auditar un proyecto de más de 500k líneas de código en unos 150ms. Consulta la comparación de rendimiento

Capacidades 🚀

Gobernanza y mantenimiento (basado en configuración) 🛡️

Usa rev-dep config run para ejecutar múltiples comprobaciones en una sola pasada para todos los paquetes.

Comprobaciones disponibles:

• moduleBoundaries - aplicar límites de arquitectura entre módulos.
• importConventions - aplicar convenciones de estilo de importación (ofrece autofix).
• unusedExportsDetection - detectar exportaciones que nunca se usan (ofrece autofix).
• orphanFilesDetection - detectar archivos muertos/huérfanos (ofrece autofix).
• unusedNodeModulesDetection - detectar dependencias declaradas pero no utilizadas.
• missingNodeModulesDetection - detectar importaciones que faltan en package json.
• unresolvedImportsDetection - detectar solicitudes de importación sin resolver.
• circularImportsDetection - detectar importaciones circulares.
• duplicatedCodeDetection - detectar código copiado y pegado (bloques repetidos y elementos JSX).
• devDepsUsageOnProdDetection - detectar dependencias de desarrollo utilizadas en código de producción.
• restrictedImportsDetection - bloquear la importación de archivos/módulos denegados desde puntos de entrada seleccionados.

Análisis exploratorio (basado en CLI) 🔍

Usa comandos CLI para explorar dependencias ad-hoc:

• entry-points - descubre los puntos de entrada del proyecto.
• files - lista los archivos del árbol de dependencias para un punto de entrada dado.
• resolve - rastrea rutas de dependencia entre archivos (quién importa este archivo).
• imported-by - lista los importadores directos de un archivo.
• circular - lista las cadenas de dependencias circulares.
• duplicated-code - encuentra bloques de código copiados y pegados y elementos JSX.
• node-modules - inspecciona los módulos de node used, unused, missing e installed.
• lines-of-code - cuenta LOC efectivas.
• unresolved - lista las importaciones que no se pudieron resolver, agrupadas por archivo.

Instalación 📦

Documentación completa: rev-dep.com/docs/intro

Instálalo localmente para configurar los scripts de comprobación del proyecto``` yarn add -D rev-dep

No se ha proporcionado ningún contenido en el mensaje (la sección "INPUT:" está vacía). Envía el fragmento 3/205 del README para poder traducirlo al español.```
npm install -D rev-dep

No se proporcionó contenido para traducir en este chunk.``` pnpm add -D rev-dep

Crea un archivo de configuración para un inicio rápido:```
npx rev-dep config init

Instalar globalmente para usar como herramienta CLI:``` yarn global add rev-dep

The input chunk is empty — no content was provided to translate. Please supply the actual text for chunk 11/205 so I can translate it into Spanish.```
npm install -g rev-dep

``` pnpm global add rev-dep

### Guías de integración paso a paso

Sigue la guía que coincida con tu proyecto para pasar de cero a una configuración funcional:

- [Guía de integración de monorepo](https://rev-dep.com/docs/monorepo-integration-guide) - para espacios de trabajo `pnpm`/`yarn`/`npm`.
- [Guía de integración de espacio de trabajo único](https://rev-dep.com/docs/single-workspace-integration-guide) - para proyectos de paquete único.

## **Ejemplos rápidos 💡**

Algunos ejemplos de uso inmediato para hacerte una idea de la herramienta:```bash

# Detect circular imports/dependencies
rev-dep circular

# Find copy-pasted code
rev-dep duplicated-code

# Detect unused node modules
rev-dep node-modules unused

# List all entry points in the project
rev-dep entry-points

# Check which files an entry point imports
rev-dep files --entry-point src/index.ts

# Find every entry point that depends on a file
rev-dep resolve --file src/utils/math.ts

# Resolve dependency path between files
rev-dep resolve --file src/utils/math.ts --entry-point src/index.ts

Comprobaciones basadas en configuración 🛡️

Rev-dep proporciona un sistema de configuración para orquestar comprobaciones de proyectos. El enfoque de configuración está diseñado para la velocidad y es la forma preferida de implementar comprobaciones de proyectos porque puede ejecutar todas las comprobaciones en una sola pasada, significativamente más rápido que ejecutar múltiples comandos individuales por separado.

Las comprobaciones disponibles son:

• moduleBoundaries - hacer cumplir los límites de arquitectura entre módulos.
• importConventions - hacer cumplir las convenciones de estilo de importación (ofrece autofix).
• unusedExportsDetection - detectar exportaciones que nunca se utilizan (ofrece autofix).
• orphanFilesDetection - detectar archivos muertos/huérfanos (ofrece autofix).
• unusedNodeModulesDetection - detectar dependencias declaradas pero no utilizadas.
• missingNodeModulesDetection - detectar importaciones que faltan en package json.
• unresolvedImportsDetection - detectar solicitudes de importación no resueltas.
• circularImportsDetection - detectar importaciones circulares.
• duplicatedCodeDetection - detectar bloques de código copiados y elementos JSX.
• devDepsUsageOnProdDetection - detectar dependencias de desarrollo utilizadas en código de producción.
• restrictedImportsDetection - bloquear la importación de archivos/módulos denegados desde puntos de entrada seleccionados.

Las comprobaciones se agrupan en espacios de trabajo. Puedes tener múltiples espacios de trabajo, p. ej., para cada paquete del monorepo.

Primeros pasos

Inicializa un archivo de configuración en tu proyecto:```bash

Create a default configuration file

rev-dep config init

Comportamiento de `rev-dep config init`:

- Raíz del monorepo: Ejecutar `rev-dep config init` en la raíz del workspace crea un workspace raíz y un workspace para cada paquete de workspace descubierto.
- Paquete de workspace del monorepo o proyectos regulares: Ejecutar `rev-dep config init` dentro de un directorio crea una configuración con un único workspace con `path: "."` para este directorio.

Ejecutar todas las comprobaciones configuradas (ejecución de prueba, aún no se aplican correcciones):```bash
# Execute all workspaces and checks defined in the config
rev-dep config run

Listar todos los problemas detectados:```bash

Lists all detected issues, by default lists first five issues for each check

rev-dep config run --list-all-issues

Corrige todos los chequeos corregibles:```bash
# Fix checks configured with autofix
rev-dep config run --fix

Estructura de configuración

El archivo de configuración (rev-dep.config.json(c) o .rev-dep.config.json(c)) le permite definir múltiples espacios de trabajo, cada uno orientado a diferentes partes de su base de código con comprobaciones específicas habilitadas.

Configuración de inicio rápido```jsonc

{ "configVersion": "2.0", "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/2.0.schema.json?raw=true", "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false }, "workspaces": [ { "path": ".", "prodEntryPoints": ["src/main.tsx", "src/pages//*.tsx"], "devEntryPoints": ["scripts/", "**/.test."], "unusedExportsDetection": { "enabled": true, "autofix": true }, "orphanFilesDetection": { "enabled": true, "autofix": true }, "unusedNodeModulesDetection": { "enabled": true }, "circularImportsDetection": { "enabled": true }, "devDepsUsageOnProdDetection": { "enabled": true, "ignoreTypeImports": true } } ] }

#### Ejemplo Completo de Configuración

Aquí tienes un ejemplo completo que muestra todas las propiedades disponibles:```jsonc
{
  "configVersion": "1.10",
  "$schema": "https://github.com/jayu/rev-dep/blob/master/config-schema/1.10.schema.json?raw=true", // enables json autocompletion
  "conditionNames": ["import", "default"],
  "ignoreFiles": ["**/*.test.*"],
  "nodeModulesResolution": { "resolutionType": "entry-package", "includeDevDepsFromRoot": false },
  "workspaces": [
    {
      "path": ".",
      "followMonorepoPackages": true,
      "prodEntryPoints": ["src/main.tsx", "src/pages/**/*.tsx", "src/server.ts"],
      "devEntryPoints": ["scripts/**", "**/*.test.*"],
      "ignoreEntryPoints": ["src/legacy/oldDashboard.tsx"],
      "moduleBoundaries": [
        {
          "name": "ui-components",
          "pattern": "src/components/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/api/**/*"]
        },
        {
          "name": "api-layer",
          "pattern": "src/api/**/*",
          "allow": ["src/utils/**/*", "src/types/**/*"],
          "deny": ["src/components/**/*"]
        }
      ],
      "importConventions": [
        {
          "rule": "relative-internal-absolute-external",
          "autofix": true,
          "domains": [
            {
              "path": "src/features/auth",
              "alias": "@auth",
              "enabled": true
            },
            {
              "path": "src/shared/ui",
              "alias": "@ui-kit",
              "enabled": false // checks disabled for this domain, but alias is still used for absolute imports from other domains
            }
          ]
        }
      ],
      "circularImportsDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "orphanFilesDetection": {
        "enabled": true,
        "ignoreTypeImports": true,
        "graphExclude": ["**/*.test.*", "**/stories/**/*"],
        "autofix": true
      },
      "unusedNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["@myorg/**"],
        "excludeModules": ["@types/**"],
        "pkgJsonFieldsWithBinaries": ["scripts", "bin"],
        "filesWithBinaries": ["scripts/check-something.sh"],
        "filesWithModules": [".storybook/main.ts"],
        "outputType": "groupByModule"
      },
      "missingNodeModulesDetection": {
        "enabled": true,
        "includeModules": ["lodash", "axios"],
        "excludeModules": ["@types/**"],
        "outputType": "groupByFile"
      },
      "unusedExportsDetection": {
        "enabled": true,
        "autofix": true,
        "ignoreTypeExports": true,
        "graphExclude": ["**/*.stories.tsx"],
        "ignore": {
          "src/types.ts": "B*",
          "**/generated/**/*.ts": "*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreExports": ["default", "unused*"],
      },
      "unresolvedImportsDetection": {
        "enabled": true,
        "ignore": {
          "src/index.ts": "legacy-*"
        },
        "ignoreFiles": ["**/*.generated.ts"],
        "ignoreImports": ["@internal/*"]
      },
      "devDepsUsageOnProdDetection": {
        "enabled": true,
        "ignoreTypeImports": true
      },
      "restrictedImportsDetection": {
        "enabled": true,
        "entryPoints": ["src/server.ts", "src/server/**/*.ts"],
        "graphExclude": ["some-file-coupling-other-files.ts"],
        "denyFiles": ["**/*.tsx"],
        "denyModules": ["react", "react-*"],
        "ignoreMatches": ["src/server/allowed-view.tsx", "react-awsome-lib"],
        "ignoreTypeImports": true
      }
    }
  ]
}

Propiedades Disponibles

Propiedades de Nivel Raíz

• configVersion (obligatorio): Cadena con la versión de configuración
• $schema (opcional): Referencia al esquema JSON para validación
• conditionNames (opcional): Matriz de nombres de condición para la resolución de exports
• customAssetExtensions (opcional): Extensiones de asset adicionales tratadas como imports resolubles (p. ej. ["glb", "mp3"]). La lista predeterminada cubre extensiones comunes para fuentes, imágenes y archivos de configuración.
• ignoreFiles (opcional): Patrones de archivo globales a ignorar en todos los workspaces. Los archivos ignorados por Git se omiten de forma predeterminada.
• processIgnoredFiles (opcional): Patrones de archivo globales a procesar aunque coincidan con gitignore o con ignoreFiles.
• nodeModulesResolution (opcional): Define contra qué package.json se valida cada import de terceros para las comprobaciones , y . Configúralo como un objeto - la forma que genera . puede ser (predeterminado, valida contra el de entrada del workspace) o (valida contra el propietario de cada archivo; úsalo para la disposición predeterminada de pnpm, donde cada paquete resuelve solo sus propias dependencias). (predeterminado ) permite que el código de paquetes use dependencias de desarrollo declaradas solo en la raíz del monorepo sin que o las marquen. También se acepta una cadena simple (p. ej. ) como forma abreviada retrocompatible para . Aplica a todos los workspaces. Consulta la .

Propiedades del Workspace

Cada workspace puede contener las siguientes propiedades:

• path (obligatorio): Ruta del directorio objetivo para este workspace (o . o una ruta que comience con el nombre de un subdirectorio)
• followMonorepoPackages (opcional): Controla la resolución de paquetes del monorepo. true sigue todos los paquetes del workspace (predeterminado), false lo desactiva, y un array sigue solo los nombres de paquete seleccionados.
• prodEntryPoints (opcional): Patrones de puntos de entrada de producción a nivel de workspace para los valores predeterminados de los detectores
• devEntryPoints (opcional): Patrones de puntos de entrada de desarrollo a nivel de workspace para los valores predeterminados de los detectores
• ignoreEntryPoints (opcional): Patrones a nivel de workspace para puntos de entrada residuales que ya no te interesan. Los archivos que coinciden con estos patrones no se procesan como problemas: nunca se reportan como archivos huérfanos, y sus exports no utilizados no se reportan. Útil para archivos que deben permanecer en el repositorio pero ya no están conectados a la aplicación.
• moduleBoundaries (opcional): Matriz de reglas de límites de módulos
• (opcional): Configuración de detección de imports circulares (objeto único o matriz de objetos)

Propiedades de Límites de Módulos

• name (obligatorio): Nombre del límite
• pattern (obligatorio): Patrón glob para los archivos de este límite
• allow (opcional): Matriz de patrones de import permitidos
• deny (opcional): Matriz de patrones de import denegados (anula a allow)

Propiedades de Convenciones de Importación

• rule (obligatorio): Tipo de la regla; actualmente solo relative-internal-absolute-external
• autofix (opcional): Si se deben corregir automáticamente las violaciones de convenciones de importación (predeterminado: false)
• domains (obligatorio): Matriz de definiciones de dominios. Puede ser una cadena (patrón glob) o un objeto con:
  • path (obligatorio): Directorio con los archivos del dominio
  • alias (opcional): Alias que se usará para los imports absolutos de código de este dominio
  • enabled (opcional): Establécelo en false para omitir las comprobaciones de este dominio (predeterminado: true)

Propiedades de Opciones de Detección

Cada propiedad de detección se puede configurar como:

• un objeto único (una instancia de detector), o
• una matriz de objetos (múltiples instancias de detector evaluadas dentro del mismo workspace).

CircularImportsDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de imports circulares
• ignoreTypeImports (opcional): Excluye los imports solo de tipo al construir el grafo (predeterminado: false)

DuplicatedCodeDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de código duplicado
• blindIdentifiers (opcional): Trata los nombres como comodines, de modo que una copia renombrada sigue contando (predeterminado: false)
• blindStrings (opcional): Trata el contenido de cadenas y plantillas como comodines (predeterminado: false)
• blindNumbers (opcional): Trata los literales numéricos como comodines (predeterminado: false)
• minTokens (opcional): La duplicación más pequeña a reportar, en tokens (predeterminado: 50)
• minLines (opcional): La duplicación más pequeña a reportar, en líneas (predeterminado: 3)
• minDepth (opcional): La profundidad de anidamiento más pequeña, contando el propio bloque. 2 requiere al menos un nivel anidado (predeterminado: 0)
• minStatements (opcional): El número mínimo de sentencias; aplica solo a bloques de sentencias (predeterminado: 0)
• minDuplicates (opcional): Cuántas copias necesita un fragmento para ser reportado (predeterminado: 2)
• (opcional): No reportar duplicaciones que sean solo literales de objeto (predeterminado: false)

OrphanFilesDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de archivos huérfanos
• validEntryPoints (opcional): Matriz de patrones de puntos de entrada válidos. Si se omite, usa por defecto prodEntryPoints + devEntryPoints del nivel de workspace.
• ignoreTypeImports (opcional): Excluye los imports solo de tipo al construir el grafo (predeterminado: false)
• graphExclude (opcional): Patrones de archivo que se excluyen del análisis del grafo
• autofix (opcional): Elimina automáticamente los archivos huérfanos detectados al ejecutar rev-dep config run --fix (predeterminado: false)

UnusedNodeModulesDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de módulos no utilizados
• includeModules (opcional): Patrones de módulo a incluir en el análisis
• excludeModules (opcional): Patrones de módulo a excluir del análisis
• pkgJsonFieldsWithBinaries (opcional): Campos de Package.json que contienen referencias a binarios (p. ej. lint-staged). Realiza una búsqueda de texto plano
• filesWithBinaries (opcional): Patrones de archivo para buscar uso de binarios. Realiza una búsqueda de texto plano
• filesWithModules (opcional): Patrones de archivos no JS/TS para buscar imports de módulos (p. ej. scripts de shell). Realiza una búsqueda de texto plano
• outputType (opcional): Formato de salida - "list", "groupByModule", "groupByFile"

MissingNodeModulesDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de módulos faltantes
• includeModules (opcional): Patrones de módulo a incluir en el análisis
• excludeModules (opcional): Patrones de módulo a excluir del análisis
• outputType (opcional): Formato de salida - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

UnusedExportsDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de exports no utilizados
• validEntryPoints (opcional): Patrones glob para archivos cuyos exports nunca se reportan como no utilizados. Si se omite, usa por defecto prodEntryPoints + devEntryPoints del nivel de workspace.
• ignoreTypeExports (opcional): Omite export type / export interface del análisis (predeterminado: false)
• graphExclude (opcional): Patrones de archivo que se excluyen del análisis de exports no utilizados
• ignore (opcional): Mapa de globs de rutas de archivo (relativas al directorio de ruta del workspace) a glob(s) de nombre/especificador de export que se deben suprimir; cada valor puede ser una cadena o una matriz de cadenas
• ignoreFiles (opcional): Globs de rutas de archivo; se suprimen todos los exports no utilizados de los archivos coincidentes
• ignoreExports (opcional): Nombres/especificadores de export (o globs) a suprimir globalmente (soporta )

UnresolvedImportsDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de imports no resueltos
• ignore (opcional): Mapa de globs de rutas de archivo (relativas al directorio de ruta del workspace) a glob(s) de solicitud de importación que se deben suprimir; cada valor puede ser una cadena o una matriz de cadenas
• ignoreFiles (opcional): Globs de rutas de archivo; se suprimen todos los imports no resueltos de los archivos coincidentes
• ignoreImports (opcional): Solicitudes de importación (o globs) a suprimir globalmente en los resultados no resueltos

DevDepsUsageOnProdDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de uso restringido de dependencias de desarrollo
• prodEntryPoints (opcional): Patrones de puntos de entrada de producción desde los que rastrear dependencias. Si se omite, usa por defecto los prodEntryPoints del nivel de workspace.
• ignoreTypeImports (opcional): Excluye los imports solo de tipo del recorrido del grafo y la coincidencia de módulos (predeterminado: false)

RestrictedImportsDetection:

• enabled (obligatorio): Habilita/deshabilita la detección de imports restringidos
• entryPoints (obligatorio cuando está habilitado): Patrones de puntos de entrada usados para construir el grafo de dependencias alcanzable (los puntos de entrada del nivel de workspace no se aplican aquí)
• graphExclude (opcional): Patrones de archivo que se excluyen del análisis del grafo de imports restringidos
• denyFiles (opcional): Patrones de ruta de archivo denegados (p. ej. ["**/*.tsx"])
• denyModules (opcional): Patrones de módulo denegados (p. ej. ["react", "react-*"])
• ignoreMatches (opcional): Patrones de archivo/módulo a suprimir de los resultados de imports restringidos
• ignoreTypeImports (opcional): Excluye los imports solo de tipo del recorrido (predeterminado: false)

Beneficios de Rendimiento

El enfoque de configuración proporciona ventajas de rendimiento significativas:

• Construcción de un único árbol de dependencias: Construye un árbol de dependencias completo para todos los workspaces
• Ejecución paralela de workspaces: Procesa múltiples workspaces simultáneamente
• Ejecución paralela de comprobaciones: Ejecuta todas las comprobaciones habilitadas dentro de cada workspace en paralelo
• Descubrimiento optimizado de archivos: Descubre los archivos una vez y los reutiliza en todas las comprobaciones

Esto hace que las comprobaciones basadas en configuración sean más rápidas que ejecutar comandos individuales de forma secuencial, especialmente en bases de código grandes con múltiples subpaquetes.

Kit de Exploración 🔧

Ejemplos prácticos que muestran cómo usar los comandos CLI de rev-dep para explorar, depurar o crear comprobaciones de calidad de código para tu proyecto.

Cómo identificar dónde se usa un archivo en el proyecto```

rev-dep resolve --file path/to/file.ts

Verás todos los puntos de entrada que requieren implícitamente ese archivo, junto con las rutas de resolución.

### **Cómo comprobar si un archivo se utiliza**```
rev-dep resolve --file path/to/file.ts --compact-summary

Muestra cuántos puntos de entrada dependen indirectamente del archivo.

Cómo identificar archivos muertos```

rev-dep entry-points

Excluye los puntos de entrada del framework si es necesario usando `--result-exclude`.

Por ejemplo, excluye los puntos de entrada válidos de Next.js cuando se usa el enrutador de páginas, excluye el directorio de scripts (los scripts son puntos de entrada válidos) y excluye todos los archivos de prueba:```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"

Cómo listar todos los archivos importados por un punto de entrada```

rev-dep files --entry-point path/to/file.ts

Útil para identificar componentes pesados o dependencias no deseadas.

### **Cómo reducir importaciones innecesarias para un punto de entrada**

1. Lista todos los archivos importados:   ```
   rev-dep files --entry-point path/to/entry.ts

2. Identificar archivos sospechosos.
3. Rastrear por qué están incluidos: ``` rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all
   root@kitploit:~

Cómo detectar dependencias circulares```

rev-dep circular

### **Cómo detectar código duplicado**```
rev-dep duplicated-code

Informa sobre bloques de código y elementos JSX repetidos - unidades que puedes extraer - en lugar de líneas repetidas. Añade --blind-identifiers para detectar copias cuyas variables fueron renombradas.

Cómo encontrar módulos de node no utilizados```

rev-dep node-modules unused

### **Cómo encontrar los módulos de node que faltan**```
rev-dep node-modules missing

Cómo comprobar el uso de espacio de node_modules```

rev-dep node-modules dirs-size

### **Cómo detectar dependencias de desarrollo utilizadas en código de producción**```
rev-dep config run

Cuando devDepsUsageOnProdDetection está habilitado en tu configuración, rev-dep:

1. Trazará los grafos de dependencias desde tus puntos de entrada de producción especificados
2. Identificará todos los archivos alcanzables desde esos puntos de entrada
3. Comprobará si algún módulo importado está listado en devDependencies en package.json
4. Informará de las violaciones mostrando qué dependencias de desarrollo se utilizan y dónde

Salida de ejemplo:``` ❌ Restricted Dev Dependencies Usage Issues (2): lodash (dev dependency) - src/components/Button.tsx (from entry point: src/pages/index.tsx) - src/utils/helpers.ts (from entry point: src/pages/index.tsx) eslint (dev dependency) - src/config/eslint-config.js (from entry point: src/server.ts)

**Notas importantes:**
- Las importaciones de solo tipos (p. ej., `import type { ReactNode } from 'react'`) se ignoran cuando `ignoreTypeImports` está habilitado
- Solo se marcan las dependencias de `devDependencies` en package.json
- Las dependencias de producción de `dependencies` están permitidas
- Ayuda a prevenir fallos en tiempo de ejecución en builds de producción

## Trabajando con Monorepo 🏗️

Rev-dep ofrece soporte de primera clase para proyectos monorepo, permitiendo un análisis preciso de dependencias entre los paquetes del workspace.

### Indicador followMonorepoPackages

El indicador `--follow-monorepo-packages` permite la resolución de importaciones desde los paquetes del workspace del monorepo. Por defecto, este indicador está establecido en `false` para mantener la compatibilidad con proyectos de un solo paquete.```bash
# Enable monorepo package resolution
rev-dep circular --follow-monorepo-packages
rev-dep resolve --file src/utils.ts --follow-monorepo-packages
rev-dep entry-points --follow-monorepo-packages

Cuando está habilitado, rev-dep:

• Detecta paquetes del workspace automáticamente escaneando la configuración del monorepo
• Resuelve importaciones entre paquetes dentro del workspace
• Sigue los exports de package.json para una resolución de módulos adecuada

Soporte de mapa de exports

Rev-dep es totalmente compatible con el campo exports en archivos package.json, que es la forma estándar de definir los puntos de entrada de paquetes en proyectos Node.js modernos.

El soporte del mapa de exports incluye:

• Exports condicionales usando condiciones como node, import, default y condiciones personalizadas
• Patrones comodín para un mapeo flexible de subrutas
• Azúcar sintáctico para definiciones simples de export principal
• Condiciones anidadas para escenarios complejos de resolución

Indicador de nombres de condición

Para controlar qué exports condicionales se resuelven, usa el indicador --condition-names. Esto te permite especificar la prioridad de las condiciones al resolver exports de paquetes:```bash

Resolve exports for different environments

rev-dep circular --condition-names=node,import,default rev-dep resolve --file src/utils.ts --condition-names=import,node rev-dep entry-points --condition-names=default,node,import

Las condiciones se procesan en el orden especificado, utilizándose la primera condición que coincida. Las condiciones comunes incluyen:
- `node` - Entorno Node.js
- `import` - Módulos ES
- `require` - CommonJS
- `default` - Condición de respaldo
- Condiciones personalizadas específicas de tu proyecto o herramientas de compilación

Ejemplo de package.json con exports:```json
{
  "name": "@myorg/utils",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.js",
      "default": "./dist/index.js"
    },
    "./helpers": "./dist/helpers.js",
    "./types/*": "./dist/types/*.d.ts"
  }
}

Cómo funciona la resolución de monorepos

1. Detección de monorepos: Cuando followMonorepoPackages está habilitado, rev-dep busca la configuración de workspaces (pnpm-workspace.yaml, package.json workspaces, etc.)

2. Resolución de paquetes: Las importaciones a paquetes del workspace se resuelven usando la configuración de exports del paquete, recurriendo a los campos main/module cuando exports no está definido.

3. Validación de dependencias: La herramienta valida que las importaciones entre paquetes solo se permiten cuando el paquete de destino está listado en las dependencies o devDependencies del consumidor.

4. Resolución de rutas: Todas las rutas se resuelven en relación con las raíces de sus respectivos paquetes, lo que garantiza un seguimiento preciso de dependencias en todo el monorepo.

Esto hace que rev-dep sea especialmente eficaz para proyectos monorepo a gran escala donde comprender las dependencias entre paquetes es crucial para mantener la calidad del código y la arquitectura.

Comparación de rendimiento ⚡

Rev-dep puede realizar múltiples verificaciones en un monorepo de más de 500k líneas de código con varios subpaquetes en aproximadamente 150 ms.

Supera a Madge, dpdm, dependency-cruiser, skott, knip, depcheck y otras herramientas similares.

Aquí tienes una comparación de rendimiento de tareas específicas entre rev-dep y las alternativas:

Plataforma: WSL Linux Debian Intel(R) Core(TM) i9-14900KF CPU

Mediciones: hyperfine -w 4 -r 8 (4 de calentamiento + 8 ejecuciones medidas)

Proyecto: 580k líneas de código, 6024 archivos de código fuente de la app next.js

Comparación de rendimiento de la comprobación circular

La tabla siguiente presenta una comparación de rendimiento entre diferentes herramientas que realizan detección de importaciones circulares.

La comprobación circular de rev-dep es ~20 veces más rápida que la alternativa más rápida.

* knip siempre ignora las aristas de importación solo de tipos y no ofrece ninguna opción para incluirlas. Cada ciclo en este código fuente contiene al menos una, por lo que knip reporta 0 ciclos: sus 3 040 ms son un análisis completo real, solo que de un grafo más pequeño. rev-dep circular -t, que aplica la misma regla, coincide exactamente (0 ciclos) en 143.3 ms ± 10.3.

Plataforma: WSL Linux Debian Intel(R) Core(TM) i9-14900KF CPU

Mediciones: hyperfine -w 4 -r 8 (4 de calentamiento + 8 ejecuciones medidas)

Proyecto: 580k líneas de código, 6024 archivos de código fuente de la app next.js

Consulta las mediciones detalladas con el tiempo medio y los comandos utilizados en PERFORMANCE.md.

Referencia de la CLI 📖

rev-dep circular

Detecta dependencias circulares en tu proyecto

Sinopsis

Analiza el proyecto para encontrar dependencias circulares entre módulos. Las dependencias circulares pueden causar problemas difíciles de depurar y, en general, deben evitarse.``` rev-dep circular [flags]

#### Ejemplos```
rev-dep circular --ignore-types-imports

Opciones```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-c, --cwd string Working directory for the command (default "$PWD") --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for circular -t, --ignore-type-imports Exclude type imports from the analysis --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep config

Crea y ejecuta archivos de configuración de rev-dep

#### Sinopsis

Comandos para crear y ejecutar archivos de configuración de rev-dep.

#### Opciones```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for config

rev-dep config run

Ejecuta todas las comprobaciones definidas en (.)rev-dep.config.json(c)

Sinopsis

Procesa (.)rev-dep.config.json(c) y ejecuta todas las comprobaciones habilitadas (importaciones circulares, archivos huérfanos, límites de módulos, convenciones de importación, módulos de node, exportaciones no utilizadas, importaciones no resueltas, importaciones restringidas y uso restringido de dependencias de desarrollo) por espacio de trabajo.``` rev-dep config run [flags]

#### Opciones```
  -c, --cwd string                  Working directory (default "$PWD")
      --fix                         Automatically fix fixable issues
      --format string               Output format (json, issues-list)
  -h, --help                        help for run
      --lint-config                 Also lint the config after running; prints only error/warning counts and fails (non-zero exit) on any lint error. Use 'config lint' for details and --fix
      --lint-config-rules strings   Which lint rules to run with --lint-config (comma-separated). Default: all. Implies --lint-config
      --list-all-issues             List all issues instead of limiting output
      --recheck                     Run all checks again after '--fix' to validate the final state
      --update-snapshot             Rewrite every configured duplicated-code snapshot from this run, acknowledging what it found.
  -v, --verbose                     Show warnings and verbose output
      --workspaces strings          Subset of workspaces to run (comma-separated list of workspace paths)

rev-dep config init

Inicializa un nuevo archivo rev-dep.config.json

Sinopsis

Crea un nuevo archivo de configuración rev-dep.config.json en el directorio actual con la configuración predeterminada.``` rev-dep config init [flags]

#### Opciones```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for init

rev-dep config lint

Informa (y opcionalmente elimina) los patrones de glob/ruta de configuración que no coinciden con nada

Sinopsis

Escanea un (.)rev-dep.config.json(c) en busca de patrones de glob y ruta "muertos": patrones de ignorado, patrones de puntos de entrada, rutas de workspace, exclusiones de grafo, archivos/módulos denegados y similares, que ya no coinciden con ningún archivo o módulo descubierto. Con el tiempo, las configuraciones acumulan patrones para archivos que fueron renombrados o eliminados; este comando los saca a la luz para que la configuración se mantenga limpia.

Con --fix, los patrones muertos se eliminan en el propio archivo, conservando todos los comentarios y el formato. Algunos patrones se notifican pero nunca se eliminan automáticamente, porque eliminarlos podría cambiar el comportamiento de una comprobación o invalidar la configuración - rutas de workspace, puntos de entrada / archivos / módulos requeridos y selectores de límites de módulo. Estos se marcan como "no auto-eliminados"; resuélvelos a mano.``` rev-dep config lint [flags]

#### Opciones```
  -c, --cwd string      Working directory (default "$PWD")
      --fix             Remove dead patterns from the config file (preserves comments and formatting)
  -h, --help            help for lint
      --rules strings   Lint rules to run (comma-separated): orphan-file-globs, orphan-module-globs, overlapping-globs, trailing-commas, compact. Default: all. orphan-file-globs/overlapping-globs use file discovery; orphan-module-globs parses the dependency tree; trailing-commas and compact only read the config file.
  -v, --verbose         Show warnings and verbose output

rev-dep config migrate

Actualiza una configuración v2 al esquema v3 (2.0)

Sinopsis

Actualiza un (.)rev-dep.config.json(c) del esquema v2 al v3 (versión de configuración 2.0).

Aplica los cambios seguros e inequívocos directamente (renombrando la matriz 'rules' de nivel superior a 'workspaces', incrementando 'configVersion' a 2.0 y eliminando la opción descontinuada 'algorithm' de los detectores de circular-imports), conservando todos los comentarios y el formato. Revisa el cambio con git antes de hacer commit.

Luego enumera lo que NO pudo cambiar por ti: patrones glob cuyo conjunto de coincidencias puede haberse desplazado bajo las reglas más estrictas de v3, alineadas con gitignore, y cambios de comportamiento que ninguna edición de configuración puede resolver. Revísalos manualmente: consulta la guía de cambios incompatibles de v3.``` rev-dep config migrate [flags]

#### Opciones```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for migrate

rev-dep debug

Herramientas de depuración para inspeccionar el interior del analizador y del resolvedor.

Sinopsis

Herramientas de depuración para inspeccionar cómo rev-dep analiza archivos y resuelve dependencias. La salida no sigue semver.

Opciones```

-h, --help help for debug

### rev-dep debug get-tree-for-cwd
Depuración: Muestra el árbol de dependencias completo para el análisis

#### Sinopsis

Herramienta de depuración para inspeccionar el árbol de dependencias completo. La salida no sigue semver.```
rev-dep debug get-tree-for-cwd [flags]

Opciones```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  --cwd string                                                  Working directory for the command (default "$PWD")
  --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names

-h, --help help for get-tree-for-cwd -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep debug list-cwd-files

Lista todos los archivos en el directorio de trabajo actual

#### Sinopsis

Lista recursivamente todos los archivos en el directorio especificado,
con opciones para filtrar los resultados.```
rev-dep debug list-cwd-files [flags]

Ejemplos```

rev-dep debug list-cwd-files --include='.ts' --exclude='.test.ts'

#### Opciones```
      --count             Only display the count of matching files
      --cwd string        Directory to list files from (default "$PWD")
      --exclude strings   Exclude files matching these glob patterns
  -h, --help              help for list-cwd-files
      --include strings   Only include files matching these glob patterns

rev-dep debug parse-file

Depuración: Muestra las importaciones analizadas para un solo archivo

Sinopsis

Herramienta de depuración para inspeccionar cómo el analizador procesa un archivo específico. La salida no sigue semver.``` rev-dep debug parse-file [flags]

#### Opciones```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --cwd string                                                  Working directory for the command (default "$PWD")
      --file string                                                 file to parse
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for parse-file
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep debug parse-tsconfig

Depuración: Muestra los alias de configuración de TypeScript analizados

Sinopsis

Herramienta de depuración para inspeccionar cómo se analiza la configuración de TypeScript y qué alias se extraen. La salida no sigue semver.``` rev-dep debug parse-tsconfig [flags]

#### Opciones```
  -h, --help              help for parse-tsconfig
      --tsconfig string   Path to TypeScript configuration file

rev-dep duplicated-code

Encuentra código duplicado entre (y dentro de) los archivos del proyecto.

Sinopsis

Escanea cada archivo fuente en busca de fragmentos copiables: bloques de llaves y elementos JSX, en cada nivel de anidamiento, e informa los que aparecen más de una vez.

La comparación ignora por completo el formato y los comentarios, por lo que las copias reindentadas siguen coincidiendo.

Cuatro filtros deciden qué merece la pena informar. --min-tokens y --min-lines miden el tamaño; --min-depth y --min-statements miden la complejidad, que es lo que separa un objeto de configuración duplicado de tres claves de una lógica duplicada: ningún límite de tamaño puede hacerlo, porque las claves del objeto y sus valores de cadena pueden ser largos. --min-duplicates establece cuántas copias se necesitan para calificar.

Por defecto, el código debe coincidir tal como está escrito. Cada bandera --blind-* elimina una categoría de token de la comparación, y se combinan libremente:

--blind-identifiers los nombres son comodines, por lo que una copia cuyas variables, funciones o componentes fueron renombrados aún se informa --blind-strings los contenidos de cadenas y plantillas son comodines --blind-numbers los literales numéricos son comodines``` rev-dep duplicated-code [flags]

#### Ejemplos```
rev-dep duplicated-code --cwd ./src --blind-identifiers

Opciones```

  --blind-identifiers               Ignore the spelling of names, so a copy whose variables, functions or components were renamed still counts as duplication.
  --blind-numbers                   Ignore the value of numeric literals, so a copy with different constants still counts
  --blind-strings                   Ignore the text of string and template literals, so a copy with different messages or keys still counts

-c, --cwd string Working directory for the command (default "$PWD") -f, --format string Output format: "human" or "json". JSON reports every finding with its canonical hash and the byte and line range of each occurrence, for comparing against another run or another tool (default "human") -h, --help help for duplicated-code --ignore-files strings Glob patterns of files to leave out of the analysis. --json-snippets Include the source of each finding in JSON output. Off by default because snippets dominate the file size and a comparison keyed on ranges does not need them --min-depth int Smallest duplication to report, in nesting levels counting the block itself. 1 admits everything; 2 requires at least one nested level, which is what filters out flat objects and single JSX elements however long their keys or strings are --min-duplicates int How many copies a chunk needs before it is reported. Raise to 3 to ignore code that has only been copied once (default 2) --min-lines int Smallest duplication to report, in lines of the first occurrence (default 3) --min-statements int Smallest duplication to report, in statements directly inside the block. Applies only to statement blocks (function and control-flow bodies); object literals and JSX elements are expressions and are not filtered by it - use --min-depth for those --min-tokens int Smallest duplication to report, in tokens. Tokens rather than characters because the count does not change when a --blind-* flag is applied, so one number means the same amount of code whatever is being ignored (default 50) --process-ignored-files strings Glob patterns to analyse even when gitignore excludes them. --skip-objects Do not report duplications that are only object literals. --snapshot string Path to a JSON snapshot of acknowledged duplications. With it, the command reports what changed since the snapshot instead of everything that exists, and exits non-zero on any difference --update-snapshot Rewrite the --snapshot file from this run, acknowledging everything it found. Always explicit: nothing updates a snapshot on its own

### rev-dep entry-points

Descubre y lista todos los puntos de entrada del proyecto.

#### Sinopsis

Analiza la estructura del proyecto para identificar todos los posibles puntos de entrada.
Útil para comprender la arquitectura y las dependencias de tu aplicación.```
rev-dep entry-points [flags]

Ejemplos```

rev-dep entry-points --print-deps-count

#### Opciones```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the number of entry points found
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --graph-exclude strings                                       Exclude files matching these glob patterns from analysis
  -h, --help                                                        help for entry-points
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --print-deps-count                                            Show the number of dependencies for each entry point
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --result-exclude strings                                      Exclude files matching these glob patterns from results
      --result-include strings                                      Only include files matching these glob patterns in results
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep files

Lista todos los archivos en el árbol de dependencias de un punto de entrada

Sinopsis

Encuentra y lista recursivamente todos los archivos que son requeridos por el punto de entrada especificado.``` rev-dep files [flags]

#### Ejemplos```
rev-dep files --entry-point src/index.ts

Opciones```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of files in the dependency tree -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-point string Entry point file to analyze (required) --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for files -t, --ignore-type-imports Exclude type imports from the analysis --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

### rev-dep imported-by

Lista todos los archivos que importan directamente el archivo especificado

#### Sinopsis

Encuentra y lista todos los archivos del proyecto que importan directamente el archivo especificado. Esto es útil para comprender el impacto de los cambios en un archivo concreto.```
rev-dep imported-by [flags]

Ejemplos```

rev-dep imported-by --file src/utils/helpers.ts

#### Opciones```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of importing files
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -f, --file string                                                 Target file to find importers for (required)
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for imported-by
      --list-imports                                                List the import identifiers used by each file
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep lines-of-code

Cuenta las líneas de código reales del proyecto excluyendo comentarios y líneas en blanco.``` rev-dep lines-of-code [flags]

#### Ejemplos```
rev-dep lines-of-code

Opciones```

-c, --cwd string Directory to analyze (default "$PWD") -h, --help help for lines-of-code

### rev-dep list-cwd-files

Lista todos los archivos en el directorio de trabajo actual

#### Sinopsis

Lista recursivamente todos los archivos en el directorio especificado,
con opciones para filtrar resultados.```
rev-dep list-cwd-files [flags]

Ejemplos```

rev-dep list-cwd-files --include='.ts' --exclude='.test.ts'

#### Opciones```
      --count             Only display the count of matching files
      --cwd string        Directory to list files from (default "$PWD")
      --exclude strings   Exclude files matching these glob patterns
  -h, --help              help for list-cwd-files
      --include strings   Only include files matching these glob patterns

rev-dep unresolved

Lista las importaciones no resueltas en el proyecto

Sinopsis

Detecta y lista las importaciones que no se pudieron resolver durante la resolución de importaciones. Agrupa las importaciones por archivo.``` rev-dep unresolved [flags]

#### Opciones```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
      --custom-asset-extensions strings                             Additional asset extensions treated as resolvable (e.g. glb,mp3)
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
  -h, --help                                                        help for unresolved
      --ignore stringToString                                       Map of file path (relative to cwd) to exact import request to ignore (e.g. --ignore src/index.ts=some-module) (default [])
      --ignore-files strings                                        File path glob patterns to ignore in unresolved output
      --ignore-imports strings                                      Import requests to ignore globally in unresolved output
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --process-ignored-files strings                               Glob patterns to process even if they are ignored by gitignore or exclude patterns
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep node-modules

Analizar y gestionar dependencias de Node.js

Sinopsis

Herramientas para analizar y gestionar dependencias de módulos de Node.js. Ayuda a identificar dependencias no utilizadas, faltantes o duplicadas en tu proyecto.

Ejemplos```

rev-dep node-modules used -p src/index.ts rev-dep node-modules unused --exclude-modules=@types/* rev-dep node-modules missing --entry-points=src/main.ts

#### Opciones```
  -h, --help   help for node-modules

rev-dep node-modules analyze-size

Analiza el uso de disco de node_modules

Sinopsis

Proporciona un análisis detallado del tamaño del directorio node_modules. Ayuda a identificar dependencias que ocupan mucho espacio.``` rev-dep node-modules analyze-size [flags]

#### Ejemplos```
rev-dep node-modules analyze-size

Opciones```

-c, --cwd string Working directory for the command (default "$PWD") -h, --help help for analyze-size

### rev-dep node-modules dirs-size

Calcula el tamaño acumulado de archivos en los directorios node_modules

#### Sinopsis

Calcula y muestra el tamaño de las carpetas node_modules
en el directorio actual y subdirectorios. Los tamaños serán más pequeños que el tamaño real que ocupa el archivo en disco. La herramienta calcula el tamaño real del archivo en lugar del tamaño en disco (relacionado con el uso de bloques de disco).```
rev-dep node-modules dirs-size [flags]

Ejemplos```

rev-dep node-modules dirs-size

#### Opciones```
  -c, --cwd string   Working directory for the command (default "$PWD")
  -h, --help         help for dirs-size

rev-dep node-modules installed-duplicates

Encuentra y optimiza instalaciones de paquetes duplicados

Sinopsis

Identifica paquetes que se instalan varias veces en node_modules. Puede optimizar el almacenamiento creando enlaces simbólicos entre paquetes duplicados.``` rev-dep node-modules installed-duplicates [flags]

#### Ejemplos```
rev-dep node-modules installed-duplicates --optimize --size-stats

Opciones```

-c, --cwd string Working directory for the command (default "$PWD") -h, --help help for installed-duplicates --isolate Create symlinks only within the same top-level node_module directories. By default optimize creates symlinks between top-level node_module directories (eg. when workspaces are used). Needs --optimize flag to take effect --optimize Automatically create symlinks to deduplicate packages --size-stats Print node modules dirs size before and after optimization. Might take longer than optimization itself --verbose Show detailed information about each optimization

### rev-dep node-modules instalados

Lista todos los paquetes npm instalados en el proyecto

#### Sinopsis

Escanea recursivamente los directorios node_modules para listar todos los paquetes instalados.
Útil para auditar dependencias en monorepos.```
rev-dep node-modules installed [flags]

Ejemplos```

rev-dep node-modules installed --include-modules=@myorg/*

#### Opciones```
  -c, --cwd string                Working directory for the command (default "$PWD")
  -e, --exclude-modules strings   list of modules to exclude from the output
  -h, --help                      help for installed
  -i, --include-modules strings   list of modules to include in the output

rev-dep node-modules missing

Encuentra paquetes importados que no están listados en package.json

Sinopsis

Identifica paquetes que se importan en tu código pero no están declarados en las dependencias de tu package.json.``` rev-dep node-modules missing [flags]

#### Ejemplos```
rev-dep node-modules missing --entry-points=src/main.ts

Opciones```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of modules -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) to start analysis from (default: auto-detected) -e, --exclude-modules strings list of modules to exclude from the output -b, --files-with-binaries strings Additional files to search for binary usages. Use paths relative to cwd -m, --files-with-node-modules strings Additional files to search for module imports. Use paths relative to cwd --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names --group-by-file Organize output by project file path --group-by-module Organize output by npm package name --group-by-module-files-count Organize output by npm package name and show count of files using it -h, --help help for missing -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot -i, --include-modules strings list of modules to include in the output --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --pkg-fields-with-binaries strings Additional package.json fields to check for binary usages --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output --zero-exit-code Use this flag to always return zero exit code

### rev-dep node-modules prune-docs

Elimina archivos tipo markdown/docs de los paquetes node_modules instalados

#### Sinopsis

Elimina archivos de los paquetes node_modules instalados según patrones glob.
Útil para podar archivos README/LICENSE/docs y reducir el tamaño de las dependencias.```
rev-dep node-modules prune-docs [flags]

Ejemplos```

rev-dep node-modules prune-docs --defaults rev-dep node-modules prune-docs --patterns ".md,README.md,docs/**" rev-dep node-modules prune-docs --defaults --patterns ".txt"

#### Opciones```
  -c, --cwd string         Working directory for the command (default "$PWD")
      --defaults           Use default prune patterns: LICENSE, README.md, docs/**
  -h, --help               help for prune-docs
      --pattern strings    Alias for --patterns
  -p, --patterns strings   Glob patterns (relative to each package root) of files to remove, e.g. "*.md,README.md,docs/**"

rev-dep node-modules unused

Encuentra paquetes instalados que no se importan en tu código

Sinopsis

Compara las dependencias de package.json con las importaciones reales en tu código para identificar paquetes potencialmente no utilizados.``` rev-dep node-modules unused [flags]

#### Ejemplos```
rev-dep node-modules unused --exclude-modules=@types/*

Opciones```

  --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)

-n, --count Only display the count of modules -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) to start analysis from (default: auto-detected) -e, --exclude-modules strings list of modules to exclude from the output -b, --files-with-binaries strings Additional files to search for binary usages. Use paths relative to cwd -m, --files-with-node-modules strings Additional files to search for module imports. Use paths relative to cwd --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names -h, --help help for unused -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot -i, --include-modules strings list of modules to include in the output --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --pkg-fields-with-binaries strings Additional package.json fields to check for binary usages --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output --zero-exit-code Use this flag to always return zero exit code

### rev-dep node-modules usados

Lista todos los paquetes npm importados en tu código

#### Sinopsis

Analiza tu código para identificar qué paquetes npm se están utilizando realmente.
Ayuda a realizar un seguimiento de las dependencias de tiempo de ejecución de tu proyecto.```
rev-dep node-modules used [flags]

Ejemplos```

rev-dep node-modules used -p src/index.ts --group-by-module

#### Opciones```
      --condition-names strings                                     List of conditions for package.json imports resolution (e.g. node, imports, default)
  -n, --count                                                       Only display the count of modules
  -c, --cwd string                                                  Working directory for the command (default "$PWD")
  -p, --entry-points strings                                        Entry point file(s) to start analysis from (default: auto-detected)
  -e, --exclude-modules strings                                     list of modules to exclude from the output
  -b, --files-with-binaries strings                                 Additional files to search for binary usages. Use paths relative to cwd
  -m, --files-with-node-modules strings                             Additional files to search for module imports. Use paths relative to cwd
      --follow-monorepo-packages strings                            Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names
      --group-by-entry-point                                        Organize output by entry point file path
      --group-by-entry-point-modules-count                          Organize output by entry point and show count of unique modules
      --group-by-file                                               Organize output by project file path
      --group-by-module                                             Organize output by npm package name
      --group-by-module-entry-points-count                          Organize output by npm package name and show count of entry points using it
      --group-by-module-files-count                                 Organize output by npm package name and show count of files using it
      --group-by-module-show-entry-points                           Organize output by npm package name and list entry points using it
  -h, --help                                                        help for used
  -t, --ignore-type-imports                                         Exclude type imports from the analysis
      --include-dev-deps-from-root                                  Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot
  -i, --include-modules strings                                     list of modules to include in the output
      --node-modules-resolution string                              Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package")
      --pkg-fields-with-binaries strings                            Additional package.json fields to check for binary usages
      --tsconfig-json string                                        Path to tsconfig.json (default: ./tsconfig.json)
  -v, --verbose                                                     Show warnings and verbose output

rev-dep resolve

Rastrea y muestra la ruta de dependencia entre los archivos de tu proyecto

Sinopsis

Analiza y muestra la cadena de dependencia entre los archivos especificados. Ayuda a entender cómo están conectadas las diferentes partes de tu código.``` rev-dep resolve [flags]

#### Ejemplos```
rev-dep resolve -p src/index.ts -f src/utils/helpers.ts

Opciones```

-a, --all Show all possible resolution paths, not just the first one --compact-summary Display a compact summary of found paths --condition-names strings List of conditions for package.json imports resolution (e.g. node, imports, default) -c, --cwd string Working directory for the command (default "$PWD") -p, --entry-points strings Entry point file(s) or glob pattern(s) to start analysis from (default: auto-detected) -f, --file string Target file to check for dependencies --follow-monorepo-packages strings Enable resolution of imports from monorepo workspace packages. Pass without value to follow all, or pass package names --graph-exclude strings Glob patterns to exclude files from dependency analysis -h, --help help for resolve -t, --ignore-type-imports Exclude type imports from the analysis --include-dev-deps-from-root Treat the monorepo root package.json devDependencies as available to package code, so they are not reported as missing or unresolved. Mirrors config nodeModulesResolution.includeDevDepsFromRoot --module string Target node module name to check for dependencies --node-modules-resolution string Which package.json each import is validated against: 'entry-package' (the cwd package.json, default) or 'nearest-package' (each file's own nearest package.json) (default "entry-package") --process-ignored-files strings Glob patterns to process even if they are ignored by gitignore or exclude patterns --tsconfig-json string Path to tsconfig.json (default: ./tsconfig.json) -v, --verbose Show warnings and verbose output

<!-- cli-docs-end -->


## Glosario 📚

Algunos de los términos utilizados en el espacio de problemas que cubre **rev-dep** pueden resultar confusos.
Aquí tienes un pequeño glosario que te ayudará a navegar por los conceptos.

### Dependencia

Una *dependencia* puede entenderse literalmente. En el contexto del grafo de dependencias de un proyecto, puede referirse a:

* un **módulo / paquete de node** (un paquete es una dependencia de un proyecto o archivo), o
* un **archivo de código fuente** (un archivo es dependencia de otro archivo si lo importa).

### Punto de entrada

Un *punto de entrada* es un archivo fuente que **no es importado por ningún otro archivo**.
Puede representar:

* la entrada principal de la aplicación
* una página o funcionalidad individual
* archivos de arranque de configuración o de pruebas

- dependiendo de la estructura del proyecto.

### Archivo no utilizado / muerto

Un archivo se considera *no utilizado* o *muerto* cuando:

* es un **punto de entrada** (nada lo importa), **y**
* ejecutarlo **no produce ninguna salida significativa** ni efecto secundario.

En la práctica, estos archivos a menudo pueden eliminarse de forma segura.

### Dependencia circular

Una *dependencia circular* ocurre cuando un archivo **se importa a sí mismo directa o indirectamente** a través de una cadena de importaciones.

Esto puede provocar un comportamiento impredecible en tiempo de ejecución, valores no inicializados o errores sutiles.
Sin embargo, las dependencias circulares entre **importaciones de solo tipos de TypeScript** suelen ser inofensivas.

### Dependencia inversa (o "dependientes")

Archivos que *importan* un archivo determinado.
Útil para responder: "¿Qué se rompe si modifico o elimino este archivo?"

### Grafo de importación / Grafo de dependencias

Una representación visual de cómo los archivos o módulos se importan entre sí.

### Dependencia faltante / módulo de node no utilizado

Un módulo que tu código importa pero que **no está listado en package.json**.

### Dependencia no utilizada / módulo de node no utilizado

Una dependencia listada en **package.json** que **nunca se importa** en el código fuente.

### Directorio raíz / Raíz del proyecto

El directorio de nivel superior utilizado como punto de partida para el análisis de dependencias.

## Telemetría

Rev-Dep recopila un único evento **anónimo**, solo durante `rev-dep config run`. Lee más en [Documentación de Telemetría](https://rev-dep.com/docs/telemetry).

Para desactivarla por completo, establece `REV_DEP_TELEMETRY_OFF=true`.

## Hecho en 🇵🇱 y 🇯🇵 con 🧠 por [@jayu](https://github.com/jayu)

Espero que esta pequeña pieza de software te ayude a descubrir y comprender la complejidad de tu proyecto y, por tanto, te haga sentir más seguro al refactorizar. Si esta herramienta te resultó útil, no dudes en darle una ⭐.

### Mis otros proyectos

- [CodeQue - Búsqueda estructural de código](https://codeque.co)
- [Structural Code Search VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)