Code Buster

Name: Code Buster — Download free. Repository analyzer
Availability: InStock
Rating: 5 (1 reviews)
Author: tool-bunker

Code Buster — Free Download. Repository analyzer

Code Buster is a repository-wide analysis tool that reports dependency wiring, dead code, cycles, duplication, complexity, architecture-policy violations, feature flags, security and style heuristics, quality scores, and remediation plans. Running a single command from the repository root delivers a summary of dependencies, duplication, hotspots, and possible drift. The tool helps coding agents and maintainers reuse existing components and keep the codebase structured as it grows. It complements language-specific linters by examining the entire repository rather than isolated files.

★★★★★

5.0(1 ratings)

Download Code Buster (Official links)

File size: 4.32 MB

The latest version of Code Buster is: 0.2.0

Operating system: Windows, Mac OS, Linux

Languages: English

Developer: tool-bunker

Price: $0.00 USD (Open Source (MIT))

Dependency wiring report. Code Buster maps how files and modules import and reference each other across the repository. The report reveals direct and transitive connections, making architectural boundaries visible. A change in one module can be traced to every dependent file. This output supports impact analysis before refactoring, reducing the risk of breaking internal contracts or hidden coupling between distant components. The report includes counts, direction of dependencies, and grouping by layer when the repository uses recognizable structural patterns.
Dead code detection. The dead code detector identifies files, functions, classes, constants, and exports that are no longer referenced from any reachable entry point. It accounts for dynamic imports, generated registrations, and test-only references to lower false positives. Unused code inflates maintenance surface and misleads developers during future changes. Code Buster separates confirmed unreachable code from code that is only referenced in non-production paths. The final report lists removal candidates with their last known reference location and an estimated safe-deletion score.
Cycle detection. Code Buster scans the module graph for directed cycles at file and directory levels. Cycles prevent clean layering, complicate tree-shaking, and force large rebuilds in compiled languages. The tool reports the shortest path for each cycle, the participating files, and the dependency weight that keeps the cycle closed. Grouped cycle summaries show which subsystems contain the most circular references. This output prioritizes breaking points where one or two edge removals dissolve multiple cycles at once.
Duplication analysis. The duplication engine compares token sequences, normalized identifiers, and structural hashes across the repository. It detects exact copies, near-miss duplicates, and files that drifted after fork-and-paste operations. Each duplication cluster includes the involved files, line ranges, similarity percentage, and a suggested canonical location. Code Buster measures both current duplication and drift velocity, flagging clusters that have diverged recently. The report prevents parallel bug fixes and helps consolidate logic into shared components.
Complexity hotspots. Complexity scoring covers cyclomatic complexity, nesting depth, parameter count, branch density, and cognitive load per function or method. Code Buster ranks the top hotspots with file paths, function signatures, and per-metric breakdowns. Hotspots are cross-referenced with dependency and change-frequency data, so a complex function that is rarely imported receives lower priority than one that anchors a critical subsystem. The output includes a complexity budget view that tracks which modules exceed project-defined thresholds.
Architecture-policy violations. Users can define allowed and forbidden dependency directions between directories, namespaces, or packages. Code Buster validates every import and reference against these policies and reports violations with exact source and target locations. Violations are grouped by rule so that a single policy break showing hundreds of edges can be fixed at the architectural root. The engine also detects bypasses of existing boundaries, such as direct access to internals, circumvention of a public API, or usage of a design token outside its intended scope.
Feature flag audit. The feature flag analyzer locates every flag reference, conditional branch, and runtime check tied to configurable features. It tracks whether a flag is evaluated at startup, per request, or per session, and estimates the code path length behind each branch. Code Buster reports stale flags whose references have disappeared from configuration but remain in source. The audit compares flag definitions with their usage frequency and lifetime, enabling removal of deprecated experiments without manual grep-based archaeology.
Security heuristics. Security scanning focuses on dangerous API calls, weak cryptographic defaults, unvalidated dynamic includes, path traversal patterns, and secrets accidentally hard-coded in source. Code Buster prioritizes findings by reachability: a risky call in dead code receives lower severity than one reachable from a network-facing entry point. Each finding includes a rule identifier, confidence level, and a suggested fix pattern. The security report is designed to be consumed by both developers and security reviewers during pull requests or periodic audits.
Style heuristics. Style heuristics cover repository-level conventions beyond formatter rules. These include naming consistency, file size outliers, directory nesting depth, import ordering anomalies, and comment density for exported APIs. Code Buster compares each file against the dominant style of its own directory, reducing noise from multi-team monorepos with legitimate local variations. Style findings are ranked by recurrence and bundled into one-line summaries that can be exported to code review bots or used as acceptance gates.
Quality scoring. The quality score aggregates dependency health, duplication rate, complexity distribution, policy violations, security findings, and style conformance into a single repository-wide number from 0 to 100. Each input metric carries an adjustable weight. Code Buster also produces per-directory and per-package scores, making regressions traceable to specific commits or merge requests. Historical score snapshots can be stored and compared to detect gradual degradation that individual lint results do not reveal.
Remediation plans. After every scan, Code Buster can emit a prioritized remediation plan. The plan groups related findings into actionable work items, ordered by estimated impact, effort, and risk. Each item lists affected files, the rule violated, a suggested change description, and an estimated complexity class. The plan avoids low-value cleanup when it would interfere with active feature work. It is generated as a machine-readable document so that project management tools or issue trackers can import tasks directly.
Repository-wide summary. The default command produces a summary that combines all major report categories into one condensed view. It shows total files analyzed, lines of code, dependency graph size, top duplication clusters, worst complexity hotspots, and the current quality score. The summary is designed to be read in under a minute and is the recommended starting point for new contributors or before major refactoring sessions. Summary output can be formatted for terminal, JSON, or Markdown without additional configuration.

Code Buster development began in 2024 as a Dart project. The canonical implementation is written in Dart and compiles to a native executable. The first public release candidate, version 0.2.0, passed strict analysis, the complete test suite, native compilation checks, documentation validation, self-analysis, and precision checks against multiple external repositories. The tool was created by the ToolBunker team, a small group focused on developer utilities and codebase diagnostics. Development uses self-hosting: Code Buster analyzes its own source repository during every release cycle.