DEV Community: Flamekit

FlameKit CLI Tool for Analyzing Git History and Finding High-Risk Bug-Prone Files

Flamekit — Tue, 02 Jun 2026 14:45:15 +0000

Find where your codebase burns.

flamekit analyzes your git history to identify the most dangerous files in your codebase — files that change frequently and cause the most bugs, ranked by risk.

The Problem

Every developer has faced this:

"This codebase keeps breaking. But where do I start fixing it?"

Finding high-risk areas manually means reading thousands of commits — nobody does that.

flamekit does it in milliseconds.

How It Works

flamekit calculates a Flame Score for every file in your repository:

Flame Score = Churn × Bug Fixes

Churn → how many times the file was changed
Bug Fixes → how many commits touched this file with fix/bug/hotfix keywords

High Flame Score = dangerous file that needs your attention.

Why flamekit

Tool	Cost	Setup	Works Offline	CLI
CodeScene	$300/month	Complex	❌	❌
SonarQube	Free/Paid	Server needed	❌	❌
GitLens	Free/Paid	VS Code only	✅	❌
flamekit	Free	Zero config	✅	✅

Demo :=

Docs: https://github.com/mrhujaifa/flamekit

Installation

Option 1 — Go Install (Recommended)

go install github.com/mrhujaifa/flamekit@latest

Option 2 — Manual Download (No Go required)

macOS / Linux

macOS (Apple Silicon)

curl -sSL https://github.com/mrhujaifa/flamekit/releases/latest/download/flamekit_Darwin_arm64.tar.gz | tar -xz
sudo mv flamekit /usr/local/bin/

macOS (Intel)

curl -sSL https://github.com/mrhujaifa/flamekit/releases/latest/download/flamekit_Darwin_x86_64.tar.gz | tar -xz
sudo mv flamekit /usr/local/bin/

Linux

curl -sSL https://github.com/mrhujaifa/flamekit/releases/latest/download/flamekit_Linux_x86_64.tar.gz | tar -xz
sudo mv flamekit /usr/local/bin/

Windows

1. Go to Releases
2. Download `flamekit_Windows_x86_64.zip`
3. Extract and add `flamekit.exe` to your PATH

Verify installation:

$ flamekit --version

Usage

flamekit works with any git repository — Go, JavaScript, Python, Java, or any language.

cd your-project
$ flamekit analyze

Commands

flamekit analyze

Scan your entire codebase and display a flame map — files ranked by risk level.

$ flamekit analyze

flamekit — Codebase Risk Analysis
Analyzing git history to find dangerous files

Files scanned: 17  |  Commits analyzed via git history

─────────────────────────────────────────────────────────────────
RISK    FILE                                     SCORE
─────────────────────────────────────────────────────────────────
HIGH    internal/app/app.go                         45 ██████████
MED     internal/auth/middleware.go                 12 ████░░░░░░
LOW     utils/helpers.go                             1 █░░░░░░░░░
─────────────────────────────────────────────────────────────────
Total:   High: 1   Med: 1   Low: 15

! Action needed: Run `flamekit suggest` to see refactor priorities

flamekit suggest

Get a prioritized list of files to refactor — ranked by maximum impact, with effort estimates and ownership data.

Top 5 suggestions (default)

flamekit suggest

Custom limit

flamekit suggest --limit 10

Show all risky files

flamekit suggest --all

Analyze specific repository

flamekit suggest --path /path/to/repo

Example output:

Analyzing repository...

FLAMEKIT — Refactoring Suggestions
Files ranked by impact — fix these first

──────────────────────────────────────────────────────────────────────

#1  internal/app/app.go

──────────────────────────────────────────────────────────────────────

Metrics        Flame: 45  Changes: 120  Bug Fixes: 23
Last changed   2 days ago  ⚠ Recently modified
Last bug       2 days ago  ✕ Active bug area
Best person    Rahim (78% ownership)

Est. effort    ~3-4 hours
Risk reduction ~40% fewer bugs
Priority score 90/100

→ Modified 120 times with 23 bug fixes — highly unstable.
  Core logic likely needs redesign.

Next steps:

$ flamekit file internal/app/app.go
$ flamekit impact internal/app/app.go

#2  internal/auth/middleware.go

──────────────────────────────────────────────────────────────────────

Metrics        Flame: 12  Changes: 67  Bug Fixes: 8
Last changed   5 days ago
Last bug       5 days ago  ⚠ Recent bug
Best person    Karim (65% ownership)

Est. effort    ~1-2 hours
Risk reduction ~25% fewer bugs
Priority score 24/100

→ Only 67 changes but 8 bug fixes — every touch breaks something.
  Fragile logic, handle with care.

Next steps:

$ flamekit file internal/auth/middleware.go
$ flamekit impact internal/auth/middleware.go

──────────────────────────────────────────────────────────────────────

Total ROI if all fixed:  ~6 hours work → ~65% bug reduction

──────────────────────────────────────────────────────────────────────

Run `flamekit suggest --all` to see all risky files

Flags

Flag	Short	Default	Description
--limit	-l	5	Number of suggestions to show (1-100)
--path	-p	.	Path to git repository
--all	—	false	Show all risky files without limit

flamekit health

Analyze your project's overall health score, trend, and velocity risk — all from git history.

Current directory

flamekit health

Specific repository

flamekit health --path /path/to/repo

Example output:

FLAMEKIT — Project Health Report
Behavioral analysis from git history · 100% local & private

─────────────────────────────────────────────────────────────────

Health Score   58/100  █████░░░░░  ⚠ WARNING

─────────────────────────────────────────────────────────────────
TREND  (last 4 months)
─────────────────────────────────────────────────────────────────

3 months ago    82  ████████░░
2 months ago    71  ███████░░░  ↓ -11
Last month      63  ██████░░░░  ↓ -8
Now             58  █████░░░░░  ↓ -5

! Declining 8 points/month on average
! Predicted next month: 50/100 ⚠ Approaching CRITICAL

─────────────────────────────────────────────────────────────────
VELOCITY RISK (last 30 days)
─────────────────────────────────────────────────────────────────

Bug rate:            35%
Trend:               ↑ Increasing
Risk threshold:      CRITICAL in ~6 weeks

! Recommendation: Freeze new features, focus on stability

─────────────────────────────────────────────────────────────────
STABILITY INDEX
─────────────────────────────────────────────────────────────────

Files analyzed:      142
Dangerous files:     3
Watch list:          50
Healthy files:       89

Top destabilizers:

internal/auth/middleware.go   → Flame: 45
services/payment/handler.go   → Flame: 32
internal/user/service.go      → Flame: 18

─────────────────────────────────────────────────────────────────

Run `flamekit suggest` to see refactoring priorities

Flags

Flag	Short	Default	Description
--path	-p	.	Path to git repository

Health Score Levels

Score	Status	Meaning
80-100	✓ HEALTHY	Low risk, codebase is stable
60-79	⚠ WARNING	Some risk areas, monitor closely
40-59	⚠ DECLINING	Health dropping, action needed
0-39	✕ CRITICAL	High risk, immediate action required

Roadmap

Command	Status	Description
flamekit analyze	✅ Available	Codebase flame map
flamekit suggest	✅ Available	Refactoring priorities
flamekit health	✅ Available	Project health score 0-100
flamekit file	🔨 In Progress	Single file deep dive
flamekit coupling	📋 Planned	Hidden dependency detection
flamekit who	📋 Planned	Knowledge ownership map
flamekit impact	📋 Planned	Blast radius before touching a file
flamekit predict	📋 Planned	30-day bug probability forecast
flamekit onboard	📋 Planned	New developer codebase guide
flamekit debt	📋 Planned	Technical debt estimator
flamekit bus-factor	📋 Planned	Team knowledge risk analysis
flamekit guardian	🤖 AI Feature	Real-time change safety net
flamekit explain	🤖 AI Feature	AI-powered risk explanation

Who Is flamekit For

Junior Developers

Understand a new codebase in minutes, not weeks.

Senior Developers

Make data-driven refactoring decisions.

Tech Leads

Identify team knowledge silos and technical debt.

Code Reviewers

Get historical context before reviewing a PR.

Open Source Contributors

Find where help is needed most.

Supported Languages

flamekit analyzes any git repository regardless of language.

File filtering supports:

.go .js .jsx .ts .tsx .py .java .rs .c .cpp .rb .php .swift .kt .vue .svelte

Contributing

Contributions are welcome!

Please feel free to submit a Pull Request.


bash
# Fork the repository

# Create your feature branch
git checkout -b feat/amazing-feature

# Commit your changes
git commit -m 'feat: add amazing feature'

# Push to the branch
git push origin feat/amazing-feature


⭐ If flamekit helped you, please consider giving it a star.

FlameKit: An Open Source CLI for Codebase Risk Analysis

Flamekit — Mon, 01 Jun 2026 14:27:28 +0000

FlameKit: Analyze Git History to Find Technical Debt, Risky Files, and Refactoring Priorities

⭐ GitHub Repository: https://github.com/mrhujaifa/flamekit

If you've ever wondered which files in your codebase are most likely to break next, FlameKit helps answer that question using your Git history.

Modern software projects don't fail because of a single bug.

Most codebases slowly become harder to maintain due to hidden technical debt, unstable files, and repeated bug fixes. The challenge is identifying those high-risk areas before they become major problems.

That's why I built FlameKit — an open-source Git history analysis CLI that helps developers discover risky files, prioritize refactoring, and measure codebase health directly from commit history.

What is FlameKit?

FlameKit is a lightweight command-line tool that analyzes Git history and identifies files that are most likely causing instability in your project.

Instead of looking only at source code, FlameKit studies how your codebase has behaved over time.

It helps answer questions like:

Which files change most frequently?
Which files receive the most bug fixes?
Where is technical debt accumulating?
What should be refactored first?
Is overall project health improving or declining?

The tool works completely offline and requires zero configuration.

Why Git History Matters

Every commit tells a story.

Over months and years, Git collects valuable information about:

Code churn
Bug-prone files
Maintenance hotspots
Team ownership patterns
Stability trends

Unfortunately, most teams never use this data effectively.

FlameKit transforms raw Git history into actionable engineering insights.

How FlameKit Calculates Risk

At the core of FlameKit is a metric called the Flame Score.

Flame Score = Churn × Bug Fixes

Where:

Churn = Number of times a file changed
Bug Fixes = Number of bug-related commits touching that file

Files with higher Flame Scores are more likely to introduce regressions, require maintenance, cause production issues, and slow development velocity.

Codebase Risk Analysis

flamekit analyze

Example output:

RISK    FILE                                SCORE
HIGH    internal/app/app.go                   45
MED     internal/auth/middleware.go           12
LOW     utils/helpers.go                       1

This instantly highlights the most dangerous files in your repository.

Refactoring Suggestions Based on Data

flamekit suggest

FlameKit ranks files by impact and shows:

Flame Score
Change frequency
Bug fix count
Ownership information
Estimated refactoring effort
Potential risk reduction

This helps engineering teams make smarter refactoring decisions.

Project Health Monitoring

flamekit health

The report includes:

Health score (0-100)
Stability trend
Velocity risk
Dangerous files
Future risk indicators

Engineering managers and tech leads can quickly understand whether a codebase is becoming healthier or more fragile over time.

Why Use FlameKit Instead of Traditional Tools?

Many code quality tools focus on static analysis.

FlameKit focuses on behavioral analysis.

Instead of asking:

What does the code look like?

FlameKit asks:

How has this code behaved over time?

This historical perspective reveals patterns that traditional linters and static analyzers often miss.

Benefits

✅ Works with any Git repository

✅ Supports multiple programming languages

✅ Runs completely locally

✅ No server required

✅ Zero configuration

✅ Fast CLI experience

✅ Open source

Current Features

flamekit analyze — Codebase risk analysis
flamekit suggest — Refactoring priorities
flamekit health — Project health score

Upcoming Features

flamekit file <path>
flamekit impact <file>
flamekit coupling
flamekit who
flamekit predict
flamekit debt
flamekit bus-factor

AI-powered roadmap:

flamekit guardian
flamekit explain <file>

Who Should Use FlameKit?

Junior Developers

Understand unfamiliar codebases faster.

Senior Engineers

Prioritize refactoring using historical data.

Tech Leads

Identify technical debt and risky project areas.

Open Source Contributors

Discover where contributions can have the highest impact.

Engineering Managers

Track codebase health and maintainability trends.

Support the Project

FlameKit is completely open source and actively evolving.

⭐ GitHub: https://github.com/mrhujaifa/flamekit

If you found FlameKit useful, please consider giving the repository a star. It helps the project reach more developers and motivates future development.

Feedback, bug reports, feature requests, and contributions are always welcome.

Final Thoughts

Git history contains years of engineering knowledge, but most teams never leverage it.

FlameKit aims to change that.

By transforming commit history into actionable insights, developers can identify risky files, reduce technical debt, improve codebase health, and make smarter engineering decisions.

If you've ever wondered:

Which part of this codebase should we fix first?

FlameKit is designed to answer exactly that question.

⭐ If this project looks useful to you, consider starring the repository on GitHub and sharing your thoughts.