Lar

Skill

Segurança

repo-scan

affaan-m/ECC

Analisa repositórios de código-fonte em C++, Android, iOS e Web para classificar arquivos, detectar bibliotecas de terceiros incorporadas e gerar avaliações práticas em quatro níveis por módulo, com relatórios HTML interativos.

...Expandir tudo

Tempo atualizado 1 de Outubro de 2026

# ios # monorepo # cpp # android # web # code audit # dependency detection # third party libraries

repo-scan

Todo ecossistema tem seu próprio gerenciador de dependências, mas nenhuma ferramenta analisa C++, Android, iOS e Web para indicar: quanto código é realmente seu, o que é de terceiros e o que é peso morto.

Quando usar

Ao assumir uma grande base de código legada e precisar de uma visão geral da estrutura
Antes de uma grande refatoração — identifique o que é essencial, o que é duplicado e o que é obsoleto
Auditar dependências de terceiros incorporadas diretamente no código-fonte (não declaradas em gerenciadores de pacotes)
Ao preparar registros de decisões de arquitetura para a reorganização do monorepo

Instalação

# Fetch only the pinned commit for reproducibility
mkdir -p ~/.claude/skills/repo-scan
git init repo-scan
cd repo-scan
git remote add origin https://github.com/haibindev/repo-scan.git
git fetch --depth 1 origin 2742664
git checkout --detach FETCH_HEAD
cp -r . ~/.claude/skills/repo-scan

Analise o código-fonte antes de instalar qualquer skill de agente.

Recursos essenciais

Recurso	Descrição
Varredura entre pilhas	C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) em uma única passagem
Classificação de arquivos	Todos os arquivos marcados como código de projeto, de terceiros ou artefato de compilação
Detecção de bibliotecas	Mais de 50 bibliotecas conhecidas (FFmpeg, Boost, OpenSSL…) com extração da versão
Veredictos em quatro níveis	Ativo essencial / Extrair e mesclar / Recompilar / Descontinuado
Relatórios em HTML	Páginas interativas com tema escuro e navegação detalhada
Suporte a monorepo	Análise hierárquica com relatórios de resumo e de subprojetos

Níveis de profundidade de análise

Nível	Arquivos lidos	Caso de uso
`fast`	1-2 por módulo	Inventário rápido de diretórios grandes
`standard`	2-5 por módulo	Auditoria padrão com verificações completas de dependências e arquitetura
`deep`	5 a 10 por módulo	Adiciona segurança de threads, gerenciamento de memória e consistência da API
`full`	Todos os arquivos	Revisão abrangente pré-fusão

Como funciona

Classifique a superfície do repositório: enumere os arquivos e, em seguida, marque cada um como código do projeto, código de terceiros incorporado ou artefato de compilação.
Detectar bibliotecas incorporadas: inspecionar nomes de diretórios, cabeçalhos, arquivos de licença e marcadores de versão para identificar dependências incluídas e versões prováveis.
Avalie cada módulo: agrupe os arquivos por módulo ou subsistema e, em seguida, atribua uma das quatro classificações com base na propriedade, duplicação e custo de manutenção.
Destaque os riscos estruturais: identifique artefatos inúteis, wrappers duplicados, código de fornecedores desatualizado e módulos que devem ser extraídos, recompilados ou descontinuados.
Gerar o relatório: retornar um resumo conciso, além da saída HTML interativa com detalhamento por módulo, para que a auditoria possa ser revisada de forma assíncrona.

Exemplos

Em um monorepo de C++ com 50.000 arquivos:

Encontrou o FFmpeg 2.x (versão de 2015) ainda em produção
Descobriu o mesmo wrapper de SDK duplicado 3 vezes
Identificados 636 MB de artefatos de compilação Debug/ipch/obj confirmados
Classificado: 3 MB de código do projeto contra 596 MB de código de terceiros

Melhores práticas

Comece com standard análises detalhadas para auditorias iniciais
Use fast para monorepos com mais de 100 módulos a fim de obter um inventário rápido
Execute deep de forma incremental nos módulos sinalizados para refatoração
Analise a análise entre módulos para detecção de duplicatas nos subprojetos

Links

Repositório no GitHub

Ver no GitHub

---
name: repo-scan
description: Scans source code repositories across C++, Android, iOS, and Web to classify files, detect embedded third-party libraries, and produce actionable four-level verdicts per module with interactive HTML reports.
---

# repo-scan

> Every ecosystem has its own dependency manager, but no tool looks across C++, Android, iOS, and Web to tell you: how much code is actually yours, what's third-party, and what's dead weight.

## When to Use

- Taking over a large legacy codebase and need a structural overview
- Before major refactoring — identify what's core, what's duplicate, what's dead
- Auditing third-party dependencies embedded directly in source (not declared in package managers)
- Preparing architecture decision records for monorepo reorganization

## Installation

```bash
# Fetch only the pinned commit for reproducibility
mkdir -p ~/.claude/skills/repo-scan
git init repo-scan
cd repo-scan
git remote add origin https://github.com/haibindev/repo-scan.git
git fetch --depth 1 origin 2742664
git checkout --detach FETCH_HEAD
cp -r . ~/.claude/skills/repo-scan
```

> Review the source before installing any agent skill.

## Core Capabilities

| Capability | Description |
|---|---|
| **Cross-stack scanning** | C/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) in one pass |
| **File classification** | Every file tagged as project code, third-party, or build artifact |
| **Library detection** | 50+ known libraries (FFmpeg, Boost, OpenSSL…) with version extraction |
| **Four-level verdicts** | Core Asset / Extract & Merge / Rebuild / Deprecate |
| **HTML reports** | Interactive dark-theme pages with drill-down navigation |
| **Monorepo support** | Hierarchical scanning with summary + sub-project reports |

## Analysis Depth Levels

| Level | Files Read | Use Case |
|---|---|---|
| `fast` | 1-2 per module | Quick inventory of huge directories |
| `standard` | 2-5 per module | Default audit with full dependency + architecture checks |
| `deep` | 5-10 per module | Adds thread safety, memory management, API consistency |
| `full` | All files | Pre-merge comprehensive review |

## How It Works

1. **Classify the repo surface**: enumerate files, then tag each as project code, embedded third-party code, or build artifact.
2. **Detect embedded libraries**: inspect directory names, headers, license files, and version markers to identify bundled dependencies and likely versions.
3. **Score each module**: group files by module or subsystem, then assign one of the four verdicts based on ownership, duplication, and maintenance cost.
4. **Highlight structural risks**: call out dead-weight artifacts, duplicated wrappers, outdated vendored code, and modules that should be extracted, rebuilt, or deprecated.
5. **Produce the report**: return a concise summary plus the interactive HTML output with per-module drill-down so the audit can be reviewed asynchronously.

## Examples

On a 50,000-file C++ monorepo:
- Found FFmpeg 2.x (2015 vintage) still in production
- Discovered the same SDK wrapper duplicated 3 times
- Identified 636 MB of committed Debug/ipch/obj build artifacts
- Classified: 3 MB project code vs 596 MB third-party

## Best Practices

- Start with `standard` depth for first-time audits
- Use `fast` for monorepos with 100+ modules to get a quick inventory
- Run `deep` incrementally on modules flagged for refactoring
- Review the cross-module analysis for duplicate detection across sub-projects

## Links

- [GitHub Repository](https://github.com/haibindev/repo-scan)