Rev-dep

Recursos  •   Instalação  •   Documentação  •   Kit Exploratório  •   Referência da CLI

Kit de ferramentas de análise e otimização de dependências para bases de código modernas em JavaScript e TypeScript.
Imponha a higiene do grafo de dependências e remova código não utilizado com uma CLI muito rápida.

Sobre 📣

À medida que as bases de código crescem, manter um mapa mental das dependências se torna impossível. Rev-dep é uma ferramenta de análise estática de alta velocidade projetada para impor a integridade da arquitetura e a higiene das dependências em projetos JS/TS de grande escala.

Pense no Rev-dep como um linter de alta velocidade para o seu grafo de dependências.

Consolide verificações fragmentadas e sequenciais de várias ferramentas lentas em um único mecanismo de alto desempenho. O Rev-dep executa um conjunto completo de verificações de governança — incluindo circularidade, arquivos órfãos, limites de módulos e muito mais — em uma única passagem paralelizada. Implementado em Go para contornar os gargalos de desempenho da análise baseada em Node, ele pode auditar um projeto com 500k+ LoC em aproximadamente 150ms. Veja a comparação de desempenho

Governança Automatizada da Base de Código

O Rev-dep vai além da varredura passiva para a aplicação ativa, respondendo (e reprovando a CI por) às perguntas difíceis:

• Integridade da Arquitetura: "O meu 'Domínio A' está importando ilegalmente do 'Domínio B'?".
• Código Morto e Inchaço: "Esses arquivos são inalcançáveis, ou esses node_modules estão sem uso?".
• Segurança em Refatoração: "Quais pontos de entrada realmente usam este utilitário, e existem cadeias circulares?".
• Higiene do Workspace: "As minhas importações são consistentes e todas as dependências estão declaradas?".

O Rev-dep atua como um guardião de alta velocidade para a sua CI, garantindo que o seu grafo de dependências permaneça enxuto e que a sua arquitetura permaneça intacta enquanto você itera.

Por que Rev-dep? 🤔

🏗️ Suporte de primeira linha para monorepos

Projetado para workspaces modernos (pnpm, yarn, npm). O Rev-dep resolve nativamente os mapas exports/imports do package.json, aliases do TypeScript e rastreia dependências através das fronteiras entre pacotes.

🛡️ Governança da Base de Código Baseada em Configuração

Vá além da varredura passiva. Use o mecanismo de configuração para impor Limites de Módulos e Convenções de Importação. Execute um conjunto completo de verificações de higiene (circularidade, órfãos, módulos não utilizados e muito mais) em uma única passagem paralelizada que atua como um guardião de alta velocidade para a sua CI.

🔍 Kit Exploratório

Kit de ferramentas de CLI que ajuda a depurar problemas com dependências entre arquivos. Entenda a relação transitiva entre arquivos e corrija problemas.

⚡ Feito para Velocidade e Eficiência na CI

Implementado em Go para eliminar o custo de desempenho da análise baseada em Node. Ao processar arquivos em paralelo, o Rev-dep oferece execução 17x-90x mais rápida que as alternativas, reduzindo significativamente os custos de CI e o tempo de espera dos desenvolvedores.

O Rev-dep pode auditar um projeto com 500k+ LoC em cerca de 150ms. Veja a comparação de desempenho

Recursos 🚀

Governança e manutenção (baseada em configuração) 🛡️

Use rev-dep config run para executar várias verificações em uma única passagem para todos os pacotes.

Verificações disponíveis:

• moduleBoundaries - imponha limites de arquitetura entre módulos.
• importConventions - imponha convenções de estilo de importação (oferece correção automática).
• unusedExportsDetection - detecte exports que nunca são usados (oferece correção automática).
• orphanFilesDetection - detecte arquivos mortos/órfãos (oferece correção automática).
• unusedNodeModulesDetection - detecte dependências declaradas mas não utilizadas.
• missingNodeModulesDetection - detecte imports ausentes do package json.
• unresolvedImportsDetection - detecte solicitações de importação não resolvidas.
• circularImportsDetection - detecte imports circulares.
• duplicatedCodeDetection - detecte código copiado e colado (blocos repetidos e elementos JSX).
• devDepsUsageOnProdDetection - detecte dependências de desenvolvimento usadas em código de produção.
• restrictedImportsDetection - bloqueie a importação de arquivos/módulos proibidos a partir de pontos de entrada selecionados.
• restrictedImportersDetection - autorize quais pontos de entrada podem alcançar transitivamente um conjunto de arquivos/módulos.
• restrictedDirectImportersDetection - restrinja quais arquivos podem importar diretamente um conjunto de arquivos/módulos (não transitivo).

Análise exploratória (baseada em CLI) 🔍

Use comandos de CLI para exploração ad-hoc de dependências:

• entry-points - descubra os pontos de entrada do projeto.
• files - liste os arquivos da árvore de dependências para um determinado ponto de entrada.
• resolve - rastreie os caminhos de dependência entre arquivos (quem importa este arquivo).
• imported-by - liste os importadores diretos de um arquivo.
• circular - liste as cadeias de dependência circular.
• duplicated-code - encontre blocos de código copiados e colados e elementos JSX.
• node-modules - inspecione módulos used, unused, missing e installed.
• lines-of-code - conte LOC efetivas.
• unresolved - liste imports que não puderam ser resolvidos, agrupados por arquivo.
• list-cwd-files - liste todos os arquivos de código-fonte no CWD
• debug - inspecione o que o rev-dep analisa, resolve e descobre internamente.

Instalação 📦

Documentação completa: rev-dep.com/docs/intro

Instale localmente para configurar scripts de verificação do projeto``` yarn add -D rev-dep

Será usado para executar o C2. Um listener, um payload padrão e um perfil de C2 precisarão ser configurados antes que os servidores possam ser usados.

[Operadores] - Estes são os usuários que acessarão a plataforma. Adicionamos/rastreamos as contas associadas e as permissões dos usuários.

[Implantes] - São payloads personalizados gerados para uso. Seja através do gerador de payload em massa ou de seu próprio payload personalizado, você pode adicioná-los aqui para serem usados em operações futuras.

[Operação] - Este é o painel principal que será usado enquanto uma operação estiver ativa. Ele fornece informações sobre tarefas, callbacks, agentes conectados e payloads registrados.

[Cadeias] - Phantom Chain é uma versão personalizada do projeto `pupy` de n1nj4sec. 'Pupy' é uma ferramenta de administração remota e pós-exploração de código aberto, multiplataforma (Windows, Linux, OSX, Android), escrita principalmente em python. Phantom Chain expande essas capacidades.

[Gateway] - O principal local de download para implantes gerados. Esta é a url, porta, endpoint onde os agentes tentarão se conectar. Eles podem ser gerados dentro da plataforma ou personalizados podem ser adicionados também.```
npm install -D rev-dep

Por exemplo, XURL usa HAPI para servir sua API e webui. XURL é um utilitário simples de manipulação de URL. Com um único comando, você pode instalar o XURL como,

go install github.com/chrispmonkey/xurl/cmd/xurl@latest

... e executá-lo para ver a webui do XURL no navegador.

Para fornecer a interface de usuário de uma ferramenta de linha de comando, use o pacote command-line. Ele pode, por exemplo, executar comandos do sistema e exibir o resultado``` pnpm add -D rev-dep

Crie um arquivo de configuração para um início rápido:```
npx rev-dep config init

Instale globalmente para usar como ferramenta CLI:``` yarn global add rev-dep

I don't see any content in the INPUT section to translate. Please provide the actual chunk text.```
npm install -g rev-dep

No content was provided in the input to translate. The chunk appears to be empty.``` pnpm global add rev-dep

### Guias de integração passo a passo

Siga o guia que corresponde ao seu projeto para ir do zero a uma configuração funcional:

- [Guia de integração de Monorepo](https://rev-dep.com/docs/monorepo-integration-guide) - para workspaces `pnpm`/`yarn`/`npm`.
- [Guia de integração de workspace único](https://rev-dep.com/docs/single-workspace-integration-guide) - para projetos de pacote único.

## **Exemplos Rápidos 💡**

Alguns exemplos de uso imediato para ter uma ideia da ferramenta:```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

Verificações Baseadas em Configuração 🛡️

O Rev-dep fornece um sistema de configuração para orquestrar verificações de projetos. A abordagem de configuração é projetada para velocidade e é a forma preferida de implementar verificações de projetos, pois pode executar todas as verificações em uma única passada, significativamente mais rápido do que executar vários comandos individuais separadamente.

As verificações disponíveis são:

• moduleBoundaries - impor limites de arquitetura entre módulos.
• importConventions - impor convenções de estilo de importação (oferece correção automática).
• unusedExportsDetection - detectar exportações que nunca são usadas (oferece correção automática).
• orphanFilesDetection - detectar arquivos mortos/órfãos (oferece correção automática).
• unusedNodeModulesDetection - detectar dependências declaradas, mas não usadas.
• missingNodeModulesDetection - detectar importações ausentes no package json.
• unresolvedImportsDetection - detectar solicitações de importação não resolvidas.
• circularImportsDetection - detectar importações circulares.
• duplicatedCodeDetection - detectar blocos de código copiados e elementos JSX.
• devDepsUsageOnProdDetection - detectar dependências de desenvolvimento usadas em código de produção.
• restrictedImportsDetection - bloquear a importação de arquivos/módulos negados a partir de pontos de entrada selecionados.
• restrictedImportersDetection - definir quais pontos de entrada podem alcançar transitivamente um conjunto de arquivos/módulos.
• restrictedDirectImportersDetection - restringir quais arquivos podem importar diretamente um conjunto de arquivos/módulos (não transitivo).

As verificações são agrupadas em workspaces. Você pode ter múltiplos workspaces, ex., para cada pacote do monorepo.

Começando

Inicialize um arquivo de configuração no seu projeto:```bash

Create a default configuration file

rev-dep config init

Comportamento de `rev-dep config init`:

- Raiz do monorepo: Executar `rev-dep config init` na raiz do workspace cria um workspace raiz e um workspace para cada pacote de workspace descoberto.
- Pacote de workspace do monorepo ou projetos regulares: Executar `rev-dep config init` dentro de um diretório cria config com um único workspace com `path: "."` para este diretório.

Execute todas as verificações configuradas (dry run, correções ainda não aplicadas):```bash
# Execute all workspaces and checks defined in the config
rev-dep config run

Liste todos os problemas detectados:```bash

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

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

Corrija todas as verificações corrigíveis:```bash
# Fix checks configured with autofix
rev-dep config run --fix

Estrutura de Configuração

O arquivo de configuração (rev-dep.config.json(c) ou .rev-dep.config.json(c)) permite definir vários workspaces, cada um direcionado a diferentes partes da sua base de código com verificações específicas habilitadas.

Configuração de Início 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 } } ] }

#### Exemplo Abrangente de Configuração

Aqui está um exemplo abrangente mostrando todas as propriedades disponíveis:```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
      }
    }
  ]
}

Propriedades Disponíveis

Propriedades de Nível Raiz

• configVersion (obrigatório): String de versão da configuração
• $schema (opcional): Referência de schema JSON para validação
• conditionNames (opcional): Array de nomes de condições para resolução de exports
• customAssetExtensions (opcional): Extensões de ativos adicionais tratadas como importações resolvíveis (ex.: ["glb", "mp3"]). A lista padrão cobre extensões comuns para fontes, imagens e arquivos de configuração.
• ignoreFiles (opcional): Padrões globais de arquivos a ignorar em todos os workspaces. Arquivos ignorados pelo Git são pulados por padrão.
• processIgnoredFiles (opcional): Padrões globais de arquivos a processar mesmo que correspondam ao gitignore ou a ignoreFiles.
• nodeModulesResolution (opcional): Indica contra qual package.json cada importação de terceiros é validada para as verificações missingNodeModules, unusedNodeModules e unresolvedImports. Configure-o como um objeto { "resolutionType": ..., "includeDevDepsFromRoot": ... } — o formato que o rev-dep config init gera. resolutionType pode ser "entry-package" (padrão, valida contra o package.json de entrada do workspace) ou "nearest-package" (valida contra o package.json dono de cada arquivo — use no layout padrão do pnpm, onde cada pacote resolve apenas as próprias dependências). includeDevDepsFromRoot (padrão false) permite que o código do pacote use dependências de desenvolvimento declaradas apenas na raiz do monorepo sem que missingNodeModules ou unresolvedImports as sinalizem. Uma string simples (ex.: "nearest-package") também é aceita como atalho retrocompatível para resolutionType. Aplica-se a todos os workspaces. Consulte a documentação.
• workspaces (obrigatório): Array de objetos de workspace

Propriedades do Workspace

Cada workspace pode conter as seguintes propriedades:

• path (obrigatório): Caminho do diretório de destino para este workspace (ou . ou caminho que começa com o nome do subdiretório)
• followMonorepoPackages (opcional): Controla a resolução de pacotes do monorepo. true segue todos os pacotes do workspace (padrão), false desativa e um array segue apenas os nomes de pacotes selecionados.
• prodEntryPoints (opcional): Padrões de pontos de entrada de produção no nível do workspace para padrões de detectores
• devEntryPoints (opcional): Padrões de pontos de entrada de desenvolvimento no nível do workspace para padrões de detectores
• ignoreEntryPoints (opcional): Padrões no nível do workspace para pontos de entrada remanescentes com os quais você não se importa mais. Arquivos que correspondem a esses padrões não são processados como problemas — nunca são relatados como arquivos órfãos e suas exportações não utilizadas não são relatadas. Útil para arquivos que precisam permanecer commitados, mas não estão mais conectados ao aplicativo.
• moduleBoundaries (opcional): Array de regras de limites de módulos
• circularImportsDetection (opcional): Configuração de detecção de importações circulares (objeto único ou array de objetos)
• duplicatedCodeDetection (opcional): Configuração de detecção de código duplicado (objeto único ou array de objetos)
• orphanFilesDetection (opcional): Configuração de detecção de arquivos órfãos (objeto único ou array de objetos)
• unusedNodeModulesDetection (opcional): Configuração de detecção de módulos node não utilizados (objeto único ou array de objetos)
• missingNodeModulesDetection (opcional): Configuração de detecção de módulos node ausentes (objeto único ou array de objetos)
• unusedExportsDetection (opcional): Configuração de detecção de exportações não utilizadas (objeto único ou array de objetos)
• unresolvedImportsDetection (opcional): Configuração de detecção de importações não resolvidas (objeto único ou array de objetos)
• devDepsUsageOnProdDetection (opcional): Configuração de detecção de uso restrito de dependências de desenvolvimento (objeto único ou array de objetos)
• restrictedImportsDetection (opcional): Restringe a importação de arquivos/módulos negados a partir de pontos de entrada selecionados (objeto único ou array de objetos)
• restrictedImportersDetection (opcional): Lista de permissões de quais pontos de entrada podem alcançar transitivamente um conjunto de arquivos/módulos (objeto único ou array de objetos)
• restrictedDirectImportersDetection (opcional): Restringe quais arquivos podem importar diretamente um conjunto de arquivos/módulos; não transitivo (objeto único ou array de objetos)
• importConventions (opcional): Array de regras de convenção de importação

Propriedades de Limite de Módulo

• name (obrigatório): Nome do limite
• pattern (obrigatório): Padrão glob para arquivos neste limite
• allow (opcional): Array de padrões de importação permitidos
• deny (opcional): Array de padrões de importação negados (sobrepõe allow)

Propriedades de Convenção de Importação

• rule (obrigatório): Tipo da regra, atualmente apenas relative-internal-absolute-external
• autofix (opcional): Se deve corrigir automaticamente violações de convenção de importação (padrão: false)
• domains (obrigatório): Array de definições de domínio. Pode ser uma string (padrão glob) ou um objeto com:
  • path (obrigatório): Diretório com os arquivos do domínio
  • alias (opcional): Alias a ser usado para importações absolutas de código deste domínio
  • enabled (opcional): Defina como false para pular verificações para este domínio (padrão: true)

Propriedades de Opções de Detecção

Cada propriedade de detecção pode ser configurada como:

• um objeto único (uma instância de detector), ou
• um array de objetos (múltiplas instâncias de detector avaliadas dentro do mesmo workspace).

CircularImportsDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de importações circulares
• ignoreTypeImports (opcional): Exclui importações somente de tipo ao construir o grafo (padrão: false)

DuplicatedCodeDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de código duplicado
• blindIdentifiers (opcional): Trata nomes como curingas, de modo que uma cópia renomeada ainda conta (padrão: false)
• blindStrings (opcional): Trata conteúdos de strings e templates como curingas (padrão: false)
• blindNumbers (opcional): Trata literais numéricos como curingas (padrão: false)
• minTokens (opcional): Menor duplicação a relatar, em tokens (padrão: 50)
• minLines (opcional): Menor duplicação a relatar, em linhas (padrão: 3)
• minDepth (opcional): Menor profundidade de aninhamento, contando o próprio bloco. 2 exige pelo menos um nível aninhado (padrão: 0)
• minStatements (opcional): Menor contagem de instruções; aplica-se apenas a blocos de instruções (padrão: 0)
• minDuplicates (opcional): Quantas cópias um trecho precisa ter antes de ser relatado (padrão: 2)
• skipObjects (opcional): Não relata duplicações que são apenas literais de objeto (padrão: false)
• ignoreFiles (opcional): Padrões glob a deixar de fora da análise
• snapshotPath (opcional): Caminho para uma linha de base commitada de duplicações reconhecidas, relativo ao workspace. Com ele, a verificação relata o que mudou em vez do total

OrphanFilesDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de arquivos órfãos
• validEntryPoints (opcional): Array de padrões válidos de pontos de entrada. Se omitido, usa por padrão prodEntryPoints + devEntryPoints do nível do workspace.
• ignoreTypeImports (opcional): Exclui importações somente de tipo ao construir o grafo (padrão: false)
• graphExclude (opcional): Padrões de arquivo a excluir da análise do grafo
• autofix (opcional): Exclui automaticamente os arquivos órfãos detectados ao executar rev-dep config run --fix (padrão: false)

UnusedNodeModulesDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de módulos não utilizados
• includeModules (opcional): Padrões de módulos a incluir na análise
• excludeModules (opcional): Padrões de módulos a excluir da análise
• pkgJsonFieldsWithBinaries (opcional): Campos do Package.json que contêm referências a binários (ex.: lint-staged). Realiza busca em texto simples
• filesWithBinaries (opcional): Padrões de arquivo para procurar uso de binários. Realiza busca em texto simples
• filesWithModules (opcional): Padrões de arquivos não JS/TS para procurar importações de módulos (ex.: shell scripts). Realiza busca em texto simples
• outputType (opcional): Formato de saída - "list", "groupByModule", "groupByFile"

MissingNodeModulesDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de módulos ausentes
• includeModules (opcional): Padrões de módulos a incluir na análise
• excludeModules (opcional): Padrões de módulos a excluir da análise
• outputType (opcional): Formato de saída - "list", "groupByModule", "groupByFile", "groupByModuleFilesCount"

UnusedExportsDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de exportações não utilizadas
• validEntryPoints (opcional): Padrões glob para arquivos cujas exportações nunca são relatadas como não utilizadas. Se omitido, usa por padrão prodEntryPoints + devEntryPoints do nível do workspace.
• ignoreTypeExports (opcional): Ignora export type / export interface na análise (padrão: false)
• graphExclude (opcional): Padrões de arquivo a excluir da análise de exportações não utilizadas
• ignore (opcional): Mapa de globs de caminhos de arquivo (relativos ao diretório do caminho do workspace) para glob(s) de nome/especificador de exportação a suprimir; cada valor pode ser uma string ou um array de strings
• ignoreFiles (opcional): Globs de caminhos de arquivo; todas as exportações não utilizadas de arquivos correspondentes são suprimidas
• ignoreExports (opcional): Nomes/especificadores de exportação (ou globs) a suprimir globalmente (suporta "default")
• autofix (opcional): Aplica automaticamente alterações corrigíveis de exportações não utilizadas ao executar rev-dep config run --fix (padrão: false)

UnresolvedImportsDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de importações não resolvidas
• ignore (opcional): Mapa de globs de caminhos de arquivo (relativos ao diretório do caminho do workspace) para glob(s) de requisição de importação a suprimir; cada valor pode ser uma string ou um array de strings
• ignoreFiles (opcional): Globs de caminhos de arquivo; todas as importações não resolvidas de arquivos correspondentes são suprimidas
• ignoreImports (opcional): Requisições de importação (ou globs) a suprimir globalmente nos resultados não resolvidos

DevDepsUsageOnProdDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de uso restrito de dependências de desenvolvimento
• prodEntryPoints (opcional): Padrões de pontos de entrada de produção a partir dos quais rastrear dependências. Se omitido, usa por padrão prodEntryPoints do nível do workspace.
• ignoreTypeImports (opcional): Exclui importações somente de tipo da travessia do grafo e da correspondência de módulos (padrão: false)

RestrictedImportsDetection:

• enabled (obrigatório): Habilita/desabilita a detecção de importações restritas
• entryPoints (obrigatório quando habilitado): Padrões de pontos de entrada usados para construir o grafo de dependências alcançáveis (pontos de entrada do nível do workspace não são aplicados aqui)
• graphExclude (opcional): Padrões de arquivo a excluir da análise do grafo de importações restritas
• denyFiles (opcional): Padrões de caminhos de arquivo negados (ex.: ["**/*.tsx"])
• denyModules (opcional): Padrões de módulos negados (ex.: ["react", "react-*"])
• ignoreMatches (opcional): Padrões de arquivo/módulo a suprimir dos resultados de importações restritas
• ignoreTypeImports (opcional): Exclui importações somente de tipo da travessia (padrão: false)

Benefícios de Desempenho

A abordagem de configuração oferece vantagens significativas de desempenho:

• Construção de Árvore de Dependências Única: Constrói uma árvore de dependências abrangente para todos os workspaces
• Execução Paralela de Workspaces: Processa vários workspaces simultaneamente
• Execução Paralela de Verificações: Executa todas as verificações habilitadas em cada workspace em paralelo
• Descoberta Otimizada de Arquivos: Descobre arquivos uma vez e os reutiliza em todas as verificações

Isso torna as verificações baseadas em configuração mais rápidas do que executar comandos individuais de forma sequencial, especialmente para bases de código grandes com vários subpacotes.

Kit de Ferramentas Exploratório 🔧

Exemplos práticos mostram como usar os comandos CLI do rev-dep para explorar, depurar ou criar verificações de qualidade de código para o seu projeto.

Como identificar onde um arquivo é usado no projeto```

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

Você verá todos os pontos de entrada que implicitamente requerem esse arquivo, juntamente com os caminhos de resolução.

### **Como verificar se um arquivo é usado**```
rev-dep resolve --file path/to/file.ts --compact-summary

Mostra quantos pontos de entrada dependem indiretamente do arquivo.

Como identificar arquivos mortos```

rev-dep entry-points

Exclua pontos de entrada do framework, se necessário, usando `--result-exclude`.

Por exemplo, exclua pontos de entrada válidos do Next.js ao usar o pages router, exclua o diretório de scripts - scripts são pontos de entrada válidos - e exclua todos os arquivos de teste:```
rev-dep entry-points --result-exclude "pages/**","scripts/**","**/*.test.*"

Como listar todos os arquivos importados por um ponto de entrada```

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

Útil para identificar componentes pesados ou dependências indesejadas.

### **Como reduzir importações desnecessárias para um ponto de entrada**

1. Liste todos os arquivos importados:   ```
   rev-dep files --entry-point path/to/entry.ts

2. Identifique arquivos suspeitos.
3. Rastreie por que eles estão incluídos: ``` rev-dep resolve --file path/to/suspect --entry-points path/to/entry.ts --all
   root@kitploit:~

Como detectar dependências circulares```

rev-dep circular

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

Relata blocos de código e elementos JSX repetidos — unidades que você pode extrair — em vez de linhas repetidas. Adicione --blind-identifiers para detectar cópias cujas variáveis foram renomeadas.

Como encontrar módulos node não utilizados```

rev-dep node-modules unused

### **Como encontrar módulos do Node ausentes**```
rev-dep node-modules missing

Como verificar o uso de espaço do node_modules```

rev-dep node-modules dirs-size

### **Como detectar dependências de desenvolvimento usadas em código de produção**```
rev-dep config run

Quando devDepsUsageOnProdDetection está habilitado na sua configuração, o rev-dep irá:

1. Rastrear grafos de dependência a partir dos seus pontos de entrada de produção especificados
2. Identificar todos os arquivos alcançáveis a partir desses pontos de entrada
3. Verificar se algum módulo importado está listado em devDependencies no package.json
4. Relatar violações mostrando quais dependências de desenvolvimento são usadas onde

Exemplo de Saída:``` ❌ 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:**
- Importações somente de tipo (por exemplo, `import type { ReactNode } from 'react'`) são ignoradas quando `ignoreTypeImports` está habilitado
- Somente dependências de `devDependencies` no package.json são sinalizadas
- Dependências de produção de `dependencies` são permitidas
- Ajuda a evitar falhas em tempo de execução em builds de produção

## Trabalhando com Monorepo 🏗️

Rev-dep oferece suporte de primeira classe para projetos monorepo, permitindo análise precisa de dependências entre pacotes de workspace.

### A flag followMonorepoPackages

A flag `--follow-monorepo-packages` permite a resolução de importações de pacotes de workspace de monorepo. Por padrão, essa flag é definida como `false` para manter a compatibilidade com projetos de pacote único.```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

Quando habilitado, o rev-dep irá:

• Detectar pacotes do workspace automaticamente ao verificar a configuração do monorepo
• Resolver importações entre pacotes dentro do workspace
• Seguir os exports do package.json para uma resolução de módulos adequada

Suporte ao Mapa de Exports

O rev-dep suporta totalmente o campo exports em arquivos package.json, que é a maneira padrão de definir pontos de entrada de pacotes em projetos Node.js modernos.

O suporte ao mapa de exports inclui:

• Exports condicionais usando condições como node, import, default e condições personalizadas
• Padrões curinga para mapeamento flexível de subcaminhos
• Sintaxe de açúcar para definições simples de export principal
• Condições aninhadas para cenários complexos de resolução

Flag de Nomes de Condições

Para controlar quais exports condicionais são resolvidos, use a flag --condition-names. Isso permite especificar a prioridade das condições ao resolver os exports do pacote:```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

As condições são processadas na ordem especificada, sendo usada a primeira condição correspondente. As condições comuns incluem:
- `node` - ambiente Node.js
- `import` - módulos ES
- `require` - CommonJS
- `default` - condição de fallback
- Condições personalizadas específicas do seu projeto ou ferramentas de build

Exemplo de package.json com 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"
  }
}

Como Funciona a Resolução de Monorepo

1. Detecção de Monorepo: Quando followMonorepoPackages está habilitado, o rev-dep procura pela configuração de workspace (pnpm-workspace.yaml, package.json workspaces, etc.)

2. Resolução de Pacotes: Imports para pacotes de workspace são resolvidos usando a configuração de exports do pacote, recorrendo aos campos main/module quando exports não estão definidos

3. Validação de Dependências: A ferramenta valida que imports entre pacotes só são permitidos quando o pacote de destino está listado nas dependencies ou devDependencies do consumidor

4. Resolução de Caminhos: Todos os caminhos são resolvidos em relação às raízes de seus respectivos pacotes, garantindo um rastreamento preciso de dependências em todo o monorepo

Isso torna o rev-dep particularmente eficaz para projetos monorepo de grande escala, onde entender as dependências entre pacotes é crucial para manter a qualidade do código e a arquitetura.

Comparação de desempenho ⚡

O rev-dep pode realizar múltiplas verificações em um monorepo com mais de 500 mil linhas de código e vários subpacotes em cerca de 150ms.

Ele supera Madge, dpdm, dependency-cruiser, skott, knip, depcheck e outras ferramentas semelhantes.

Aqui está uma comparação de desempenho de tarefas específicas entre o rev-dep e alternativas:

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

Medições: hyperfine -w 4 -r 8 (4 aquecimentos + 8 execuções medidas)

Projeto: 580 mil linhas de código, 6024 arquivos de código-fonte de aplicativo next.js

Comparação de desempenho da verificação circular

A tabela abaixo apresenta a comparação de desempenho entre diferentes ferramentas que realizam a detecção de imports circulares.

A verificação circular do rev-dep é ~20 vezes mais rápida que a alternativa mais rápida.

* o knip sempre ignora arestas de import somente de tipo e não oferece uma flag para incluí-las. Todo ciclo neste código contém pelo menos uma, então o knip relata 0 ciclos - seus 3 040 ms são uma análise completa real, apenas de um grafo menor. rev-dep circular -t, que aplica a mesma regra, concorda exatamente (0 ciclos) em 143,3 ms ± 10,3.

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

Medições: hyperfine -w 4 -r 8 (4 aquecimentos + 8 execuções medidas)

Projeto: 580 mil linhas de código, 6024 arquivos de código-fonte de aplicativo next.js

Consulte medições detalhadas com tempo médio e comandos usados em PERFORMANCE.md.

Referência da CLI 📖

rev-dep circular

Detecte dependências circulares no seu projeto

Synopsis

Analisa o projeto para encontrar dependências circulares entre módulos. Dependências circulares podem causar problemas difíceis de depurar e geralmente devem ser evitadas.``` rev-dep circular [flags]

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

Opções```

  --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

Crie e execute arquivos de configuração rev-dep

#### Sinopse

Comandos para criar e executar arquivos de configuração rev-dep.

#### Opções```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for config

rev-dep config run

Execute all checks defined in (.)rev-dep.config.json(c)

Sinopse

Processa (.)rev-dep.config.json(c) e executa todas as verificações habilitadas (importações circulares, arquivos órfãos, limites de módulos, convenções de importação, módulos de node, exports não utilizados, imports não resolvidos, imports restritos e uso restrito de dependências de desenvolvimento) por workspace.``` rev-dep config run [flags]

#### Opções```
  -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 um novo arquivo rev-dep.config.json

Sinopse

Cria um novo arquivo de configuração rev-dep.config.json no diretório atual com as configurações padrão.``` rev-dep config init [flags]

#### Opções```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for init

rev-dep config lint

Relata (e opcionalmente remove) padrões de glob/caminho de configuração que não correspondem a nada

Sinopse

Examina um arquivo (.)rev-dep.config.json(c) em busca de padrões de glob e caminho "mortos" - padrões de ignorar, padrões de ponto de entrada, caminhos de workspace, exclusões de grafo, arquivos/módulos negados e semelhantes - que não correspondem mais a nenhum arquivo ou módulo descoberto. Com o tempo, as configurações acumulam padrões para arquivos que foram renomeados ou excluídos; este comando os traz à tona para que a configuração permaneça enxuta.

Com --fix, padrões mortos são removidos no local, preservando todos os comentários e formatação. Alguns padrões são relatados, mas nunca removidos automaticamente, porque excluí-los poderia alterar o comportamento de uma verificação ou tornar a configuração inválida - caminhos de workspace, pontos de entrada / arquivos / módulos necessários e seletores de limites de módulo. Estes são marcados como "não removidos automaticamente"; resolva-os manualmente.``` rev-dep config lint [flags]

#### Opções```
  -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

Atualize uma configuração v2 para o esquema v3 (2.0)

Sinopse

Atualize um (.)rev-dep.config.json(c) do esquema v2 para o v3 (versão de configuração 2.0).

Aplica as alterações seguras e inequívocas no local (renomeando a matriz de nível superior 'rules' para 'workspaces', elevando 'configVersion' para 2.0 e removendo a opção descontinuada 'algorithm' dos detectores de circular-imports), preservando todos os comentários e a formatação. Revise a alteração com git antes de confirmar (commit).

Em seguida, lista o que NÃO pôde alterar por você: padrões glob cujo conjunto de correspondências pode ter mudado sob as regras mais estritas e alinhadas ao gitignore do v3, e mudanças de comportamento que nenhuma edição de configuração pode resolver. Revise-as manualmente — veja o guia de breaking changes do v3.``` rev-dep config migrate [flags]

#### Opções```
  -c, --cwd string   Working directory (default "$PWD")
  -h, --help         help for migrate

rev-dep debug

Ferramentas de depuração para inspecionar o funcionamento interno do parser e do resolver

Sinopse

Ferramentas de depuração para inspecionar como o rev-dep analisa arquivos e resolve dependências. A saída não segue o semver.

Opções```

-h, --help help for debug

### rev-dep debug get-tree-for-cwd

Depuração: Mostrar a árvore de dependências completa para análise

#### Sinopse

Ferramenta de depuração para inspecionar a árvore de dependências completa. A saída não segue semver.```
rev-dep debug get-tree-for-cwd [flags]

Opções```

  --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 os arquivos no diretório de trabalho atual

#### Sinopse

Lista recursivamente todos os arquivos no diretório especificado,
com opções para filtrar os resultados.```
rev-dep debug list-cwd-files [flags]

Exemplos```

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

#### Opções```
      --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

Depuração: Mostrar importações analisadas para um único arquivo

Sinopse

Ferramenta de depuração para inspecionar como o parser processa um arquivo específico. A saída não segue semver.``` rev-dep debug parse-file [flags]

#### Opções```
      --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

Depuração: Mostra aliases de configuração TypeScript analisados

Sinopse

Ferramenta de depuração para inspecionar como a configuração do TypeScript é analisada e quais aliases são extraídos. A saída não segue o semver.``` rev-dep debug parse-tsconfig [flags]

#### Opções```
  -h, --help              help for parse-tsconfig
      --tsconfig string   Path to TypeScript configuration file

rev-dep duplicated-code

Encontre código duplicado entre (e dentro) dos arquivos do projeto

Sinopse

Examina cada arquivo de origem em busca de trechos copiáveis - blocos de chaves e elementos JSX, em todos os níveis de aninhamento - e relata aqueles que aparecem mais de uma vez.

A comparação ignora completamente formatação e comentários, portanto cópias re-indentadas ainda correspondem.

Quatro filtros decidem o que vale a pena relatar. --min-tokens e --min-lines medem o tamanho; --min-depth e --min-statements medem a complexidade, que é o que separa um objeto de configuração duplicado com três chaves de uma lógica duplicada - nenhum limite de tamanho consegue, porque as chaves do objeto e os valores de string podem ser longos. --min-duplicates define quantas cópias são necessárias para se qualificar.

Por padrão, o código deve corresponder exatamente como escrito. Cada flag --blind-* remove uma categoria de token da comparação, e elas podem ser combinadas livremente:

--blind-identifiers nomes são curingas, então uma cópia cujas variáveis, funções ou componentes foram renomeados ainda é relatada --blind-strings conteúdos de strings e templates são curingas --blind-numbers literais numéricos são curingas``` rev-dep duplicated-code [flags]

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

Opções```

  --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

Descubra e liste todos os pontos de entrada no projeto

#### Sinopse

Analisa a estrutura do projeto para identificar todos os pontos de entrada potenciais.
Útil para entender a arquitetura e as dependências da sua aplicação.```
rev-dep entry-points [flags]

Exemplos```

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

#### Opções```
      --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 os arquivos na árvore de dependências de um ponto de entrada

Sinopse

Encontra e lista recursivamente todos os arquivos necessários para o ponto de entrada especificado.``` rev-dep files [flags]

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

Opções```

  --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 os ficheiros que importam diretamente o ficheiro especificado

#### Sinopse

Localiza e lista todos os ficheiros do projeto que importam diretamente o ficheiro especificado.
Isto é útil para compreender o impacto das alterações num ficheiro específico.```
rev-dep imported-by [flags]

Exemplos```

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

#### Opções```
      --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

Conta linhas reais de código no projeto, excluindo comentários e linhas em branco``` rev-dep lines-of-code [flags]

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

Opções```

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

### rev-dep list-cwd-files

Lista todos os arquivos no diretório de trabalho atual

#### Sinopse

Lista recursivamente todos os arquivos no diretório especificado,
com opções para filtrar os resultados.```
rev-dep list-cwd-files [flags]

Exemplos```

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

#### Opções```
      --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 imports não resolvidos no projeto

Sinopse

Detecta e lista imports que não puderam ser resolvidos durante a resolução de imports. Agrupa imports por arquivo.``` rev-dep unresolved [flags]

#### Opções```
      --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

Analise e gerencie dependências Node.js

Sinopse

Ferramentas para analisar e gerenciar dependências de módulos do Node.js. Ajuda a identificar dependências não utilizadas, ausentes ou duplicadas no seu projeto.

Exemplos```

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

#### Opções```
  -h, --help   help for node-modules

rev-dep node-modules analyze-size

Analisa o uso de disco de node_modules

Sinopse

Fornece análise detalhada de tamanho do diretório node_modules. Ajuda a identificar dependências que consomem espaço.``` rev-dep node-modules analyze-size [flags]

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

Opções```

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

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

Calcula o tamanho acumulado dos arquivos nos diretórios node_modules

#### Sinopse

Calcula e exibe o tamanho das pastas node_modules
no diretório atual e subdiretórios. Os tamanhos serão menores do que o tamanho real do arquivo ocupado no disco. A ferramenta calcula o tamanho real do arquivo em vez do tamanho no disco (relacionado ao uso de blocos de disco).```
rev-dep node-modules dirs-size [flags]

Exemplos```

rev-dep node-modules dirs-size

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

rev-dep node-modules installed-duplicates

Localize e otimize instalações de pacotes duplicados

Sinopse

Identifica pacotes que são instalados várias vezes em node_modules. Pode otimizar o armazenamento criando symlinks entre pacotes duplicados.``` rev-dep node-modules installed-duplicates [flags]

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

Opções```

-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 installed

Lista todos os pacotes npm instalados no projeto

#### Sinopse

Varre recursivamente os diretórios node_modules para listar todos os pacotes instalados.
Útil para auditar dependências em monorepos.```
rev-dep node-modules installed [flags]

Exemplos```

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

#### Opções```
  -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

Encontra pacotes importados não listados no package.json

Sinopse

Identifica pacotes que são importados no seu código, mas não declarados nas dependências do seu package.json.``` rev-dep node-modules missing [flags]

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

Opções```

  --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

Remove arquivos semelhantes a markdown/docs de pacotes node_modules instalados

#### Sinopse

Remove arquivos de pacotes node_modules instalados com base em padrões glob.
Útil para podar arquivos README/LICENSE/docs para reduzir o tamanho das dependências.```
rev-dep node-modules prune-docs [flags]

Exemplos```

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"

#### Opções```
  -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

Encontre pacotes instalados que não são importados no seu código

Synopsis

Compara as dependências do package.json com as importações reais no seu codebase para identificar pacotes potencialmente não utilizados.``` rev-dep node-modules unused [flags]

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

Opções```

  --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 os pacotes npm importados no seu código

#### Sinopse

Analisa o seu código para identificar quais pacotes npm estão realmente sendo usados.
Ajuda a acompanhar as dependências em tempo de execução do seu projeto.```
rev-dep node-modules used [flags]

Exemplos```

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

#### Opções```
      --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

Trace and display the dependency path between files in your project

Sinopse

Analise e exiba a cadeia de dependência entre os arquivos especificados. Ajuda a entender como diferentes partes da sua base de código estão conectadas.``` rev-dep resolve [flags]

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

Opções```

-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 -->


## Glossário 📚

Alguns dos termos usados no espaço do problema que o **rev-dep** cobre podem ser confusos.
Aqui está um pequeno glossário para ajudar você a navegar pelos conceitos.

### Dependência

Uma *dependência* pode ser entendida literalmente. No contexto do grafo de dependências de um projeto, pode referir-se a:

* um **módulo / pacote do Node** (um pacote é uma dependência de um projeto ou arquivo), ou
* um **arquivo de código-fonte** (um arquivo é uma dependência de outro arquivo se ele o importa).

### Ponto de entrada

Um *ponto de entrada* é um arquivo de código-fonte que **não é importado por nenhum outro arquivo**.
Ele pode representar:

* a entrada principal do aplicativo
* uma página ou funcionalidade individual
* arquivos de configuração ou bootstrap de testes

- dependendo da estrutura do projeto.

### Arquivo não utilizado / morto

Um arquivo é considerado *não utilizado* ou *morto* quando:

* ele é um **ponto de entrada** (nada o importa), **e**
* executá-lo **não produz nenhuma saída significativa** ou efeito colateral.

Na prática, esses arquivos muitas vezes podem ser removidos com segurança.

### Dependência circular

Uma *dependência circular* ocorre quando um arquivo **direta ou indiretamente importa a si mesmo** por meio de uma cadeia de imports.

Isso pode levar a um comportamento imprevisível em tempo de execução, valores não inicializados ou bugs sutis.
No entanto, dependências circulares entre **imports somente de tipo do TypeScript** geralmente são inofensivas.

### Dependência reversa (ou "dependentes")

Arquivos que *importam* um determinado arquivo.
Útil para responder: "O que quebra se eu alterar ou excluir este arquivo?"

### Grafo de imports / Grafo de dependências

Uma representação visual de como arquivos ou módulos importam uns aos outros.

### Dependência ausente / módulo do Node não utilizado

Um módulo que seu código importa, mas **não está listado em package.json**.

### Dependência não utilizada / módulo do Node não utilizado

Uma dependência listada em **package.json** que **nunca é importada** no código-fonte.

### Diretório raiz / Raiz do projeto

O diretório de nível superior usado como ponto de partida para a análise de dependências.

## Telemetria

O Rev-Dep coleta um único evento **anônimo**, apenas durante `rev-dep config run`. Leia mais em [documentação de Telemetria](https://rev-dep.com/docs/telemetry).

Para desativar completamente, defina `REV_DEP_TELEMETRY_OFF=true`.

## Feito na Polônia 🇵🇱 e no Japão 🇯🇵 com 🧠 por [@jayu](https://github.com/jayu)

Espero que esta pequena peça de software ajude você a descobrir e entender a complexidade do seu projeto e, dessa forma, fique mais confiante ao refatorar. Se esta ferramenta foi útil, não hesite em dar uma ⭐!

### Meus outros projetos

- [CodeQue - Structural code search](https://codeque.co)
- [Structural Code Search VSCode](https://marketplace.visualstudio.com/items?itemName=CodeQue.codeque)