Repotoire vs ESLint
ESLint is the industry-standard linter for JavaScript and TypeScript. Repotoire is a graph-powered analysis tool that finds cross-file architectural issues. They solve different problems — and work best together.
Feature Comparison
| Feature | Repotoire | ESLint |
|---|---|---|
| Analysis approach | Graph-powered cross-file analysis | Per-file rule-based linting |
| Languages | 9 (Python, TS/JS, Rust, Go, Java, C#, C, C++) | JavaScript / TypeScript (via parser) |
| Rules / Detectors | 106 pure Rust detectors | 250+ built-in rules, thousands via plugins |
| Cross-file analysis | Yes (graph algorithms across entire codebase) | No (per-file only) |
| Architectural analysis | Yes (circular deps, god classes, bottlenecks, coupling) | No |
| Code style / formatting | No (not a formatter) | Yes (with stylistic plugins) |
| Auto-fix | AI-powered fix suggestions | Deterministic auto-fix (--fix) |
| Plugin ecosystem | Built-in detectors | Massive (React, Vue, accessibility, import rules, etc.) |
| Configuration | repotoire.toml / .repotoirerc.json | eslint.config.js (flat config) |
| Setup | Single binary, zero config | npm install, config file required |
| Performance | ~1.4s incremental, parallel Rust | Fast per-file, slower on large codebases |
| CI/CD integration | GitHub Action, SARIF output | Universal (any CI, formatters, SARIF via plugin) |
| Pricing | Free CLI, Pro plans coming | Free and open source |
Different Tools, Different Jobs
ESLint operates per-file.It parses each JavaScript or TypeScript file individually, applies rules to the AST, and reports violations. It's excellent at catching code style issues, potential bugs, unused variables, and enforcing team conventions. With its plugin ecosystem, you can add React hooks rules, accessibility checks, import ordering, and thousands of other checks.
Repotoire operates across files.It builds a knowledge graph of your entire codebase — every function, class, module, and their relationships — then runs graph algorithms to find structural problems. Circular dependencies between modules, god classes with too many responsibilities, architectural bottlenecks that concentrate risk, hidden coupling revealed by git co-change patterns. These are issues that per-file analysis structurally cannot detect.
What ESLint Catches That Repotoire Doesn't
- •Code style and formatting (semicolons, indentation, naming conventions)
- •Framework-specific rules (React hooks order, Vue template syntax, accessibility)
- •Import ordering and organization
- •Deterministic auto-fix for hundreds of rules
- •Highly customizable per-rule configuration
What Repotoire Catches That ESLint Can't
- ✓Circular dependencies detected via Tarjan's strongly connected components
- ✓God classes identified through fan-in/fan-out graph metrics
- ✓Architectural bottlenecks via PageRank and betweenness centrality
- ✓Hidden coupling from git co-change temporal analysis
- ✓Community misplacement via Louvain clustering
- ✓Single points of failure (articulation points in the call graph)
- ✓Cross-language analysis (same tool for Python, Rust, Go, Java, and more)
Using Both Together
Repotoire and ESLint are complementary tools. A recommended setup for JavaScript/TypeScript projects:
ESLint (on every save)
Code style, per-file bugs, React hooks rules, import ordering, accessibility. Runs in your editor with instant feedback.
Repotoire (in CI or pre-commit)
Architectural health, circular dependencies, coupling analysis, bottleneck detection. Runs on the full codebase to catch structural drift.
# Example CI pipeline
- name: Lint (ESLint)
run: npx eslint .
- name: Architecture check (Repotoire)
uses: Zach-hammad/repotoire-action@v1
with:
fail-on: highSetup
Repotoire
# Install cargo binstall repotoire # Analyze (zero config) repotoire analyze .
No configuration file needed. Works on any supported language immediately.
ESLint
# Install npm init @eslint/config@latest # Lint npx eslint .
Requires a config file. Highly configurable with plugins, presets, and overrides.
Verdict
This isn't an either/or choice. ESLint is the best tool for JavaScript/TypeScript per-file linting — it has an unmatched plugin ecosystem and deep framework integration. Repotoire is the best tool for understanding your codebase's architecture across all files and languages.
Use ESLint to keep individual files clean. Use Repotoire to keep your architecture healthy. Together, they cover both the micro (code style, per-file bugs) and macro (structure, dependencies, coupling) dimensions of code quality.
See what ESLint can't see
Run Repotoire alongside ESLint and discover the architectural issues hiding in your codebase.
cargo binstall repotoire && repotoire analyze .