affaan-m/ECC

repo-scan

Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.

91CollectingRuns scriptsNetwork accessReads files
See how to use itView GitHub source
npx skills add https://github.com/affaan-m/ECC --skill "skills/repo-scan"

Quick start

Start using it in three steps

Install it or open the source, trigger it with a clear task, then follow the source workflow.

1

Install the Skill

npx skills add https://github.com/affaan-m/ECC --skill "skills/repo-scan"
2

Describe the task

Use repo-scan to help me with: [describe your task]. Before you begin, tell me what input you need, the steps you will follow, and the expected output.

3

Follow the workflow

5 key workflow steps, examples, and cautions are distilled below.

Continue to the workflow

Direct answers

Answers to review before you install

What is repo-scan?

Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.

Who should use repo-scan?

It is relevant to workflows involving Engineering, Research.

How do you install repo-scan?

SkillSignal detected this source-specific command: npx skills add https://github.com/affaan-m/ECC --skill "skills/repo-scan". Inspect the repository and command before running it.

Which Agent platforms does it support?

The upstream source does not declare a dedicated Agent platform.

What permissions or risks should you review?

Static analysis detected exec-script, network, read-files signals. Review the cited source lines before installing; these signals are not a security audit.

What are the current evidence limits?

This page combines upstream documentation with deterministic repository, quality, and static-risk signals. It is not described as a manual test or security review.

SkillSignal brief

Decide whether it fits your work first

Cross-stack source code asset audit — classifies every file, detects embedded third-party libraries, and delivers actionable four-level verdicts per module with interactive HTML reports.

Useful in these contexts

Not yet included in a workflow collection

Core capabilities

EngineeringResearch

Distilled from the source

Understand this Skill in one minute

About 2 min · 9 sections

When it is worth using

  1. Taking over a large legacy codebase and need a structural overview

  2. Before major refactoring — identify what's core, what's duplicate, what's dead

  3. Auditing third-party dependencies embedded directly in source (not declared in package managers)

  4. Preparing architecture decision records for monorepo reorganization

Core workflow

  1. 1

    Classify the repo surface: enumerate files, then tag each as project code, embedded third-party code, or build artifact.

  2. 2

    Detect embedded libraries: inspect directory names, headers, license files, and version markers to identify bundled dependencies and likely versions.

  3. 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. 4

    Highlight structural risks: call out dead-weight artifacts, duplicated wrappers, outdated vendored code, and modules that should be extracted, rebuilt, or deprecated.

  5. 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 and typical usage

  1. Found FFmpeg 2.x (2015 vintage) still in production

  2. Discovered the same SDK wrapper duplicated 3 times

  3. Identified 636 MB of committed Debug/ipch/obj build artifacts

Repository stars
234,327
Repository forks
35,711
Quality
91/100
Source repository last pushed

Quality breakdown

Based on traceable docs and repository signals; stars are not treated as quality.

91/100
Documentation24/30
Specificity25/25
Maintenance20/20
Trust signals22/25

Compare before choosing

Related Agent Skills and source variants

These links are selected from shared tasks, functions, stacks, platforms, and same-name variants. Compare the source owner, documentation, permissions, and maintenance signals.

repo-scan by affaan-m

クロススタックのソースコード資産監査——各ファイルを分類し、埋め込まれたサードパーティライブラリを検出し、各モジュールに対してインタラクティブなHTMLレポートとともに実用的な4段階の判定を提供する。

repo-scan by affaan-m

跨栈源代码资产审计——对每个文件进行分类,检测嵌入的第三方库,并为每个模块提供可操作的四级判定结果,附带交互式HTML报告。

ab-testing by coreyhaines31

When the user wants to plan, design, or implement an A/B test or experiment, or build a growth experimentation program. Also use when the user mentions "A/B test," "split test," "experiment," "test this change," "variant copy," "multivariate test," "hypothesis," "should I test this," "which version is better," "test two versions," "statistical significance," "how long should I run this test," "growth experiments," "experiment velocity," "experiment backlog," "ICE score," "experimentation program

design-review by event4u-app

Use when the user says "review the design", "check the UI", or wants a comprehensive UI/UX review. Uses a 7-phase methodology covering interaction, responsiveness, accessibility, and more.

dask by k-dense-ai

Distributed computing for larger-than-RAM pandas/NumPy workflows. Use when you need to scale existing pandas/NumPy code beyond memory or across clusters. Best for parallel file processing, distributed ML, integration with existing pandas code. For out-of-core analytics on single machine use vaex; for in-memory speed use polars.

View original Skill.mdThis page is parsed directly from the repository SKILL.md without editorial rewriting. Collected: Jul 28, 2026 · about 2 min

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

# 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

CapabilityDescription
Cross-stack scanningC/C++, Java/Android, iOS (OC/Swift), Web (TS/JS/Vue) in one pass
File classificationEvery file tagged as project code, third-party, or build artifact
Library detection50+ known libraries (FFmpeg, Boost, OpenSSL…) with version extraction
Four-level verdictsCore Asset / Extract & Merge / Rebuild / Deprecate
HTML reportsInteractive dark-theme pages with drill-down navigation
Monorepo supportHierarchical scanning with summary + sub-project reports

Analysis Depth Levels

LevelFiles ReadUse Case
fast1-2 per moduleQuick inventory of huge directories
standard2-5 per moduleDefault audit with full dependency + architecture checks
deep5-10 per moduleAdds thread safety, memory management, API consistency
fullAll filesPre-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

Source repo
affaan-m/ECC
Skill path
skills/repo-scan/SKILL.md
Commit SHA
4e973d3eaf92
Repository license
MIT
Data collected