How healthy is your codebase?
Upload a project and get an instant static-analysis report: cyclomatic complexity, duplicate code, dependency cycles, and GraphQL schema insights. Everything runs locally — no AI, no external APIs.
Drop a .zip of your project here
or click to choose a file · JS / TS / GraphQL · up to 100 MB
Heavy folders like node_modules and .git are skipped automatically before upload.
The path must exist on the machine running this app (useful when running locally).
Analyzing project…
Parsing files, measuring complexity, hashing blocks, building graphs.
Overall health score — weighted mix of complexity, duplication, size, dependencies and nesting.
Score breakdown
Complexity distribution
Functions per cyclomatic-complexity bucket
Highest-complexity functions
Functions with cyclomatic complexity above 10 are flagged as high risk
| Function | File | Line | Complexity | Lines | Nesting |
|---|
Parse errors
These files could not be fully parsed and may be partially analyzed
Files
Click a column header to sort. Flagged files exceed at least one threshold.
| File | Lines | Functions | Avg CC | Max CC | Nesting | Risky fns | Warnings |
|---|
File dependency graph
Built from import / require statements. Drag to pan, scroll to zoom, click a node for details. normal in a cycle
Circular dependencies
External packages
Most-imported third-party modules
Duplicate code
GraphQL Schema
Type relation graph
Which type references which, through its fields. Click a node to see its fields.
Operations
Schema warnings
Types
| Type | Kind | Fields | Defined in | Notes |
|---|
Knowledge Graph
Concept graph
Nodes are code concepts (functions, classes, files, docs); colors are communities. Dashed edges were inferred rather than extracted from source. Drag to pan, scroll to zoom, click a node for details.
God nodes
The most connected concepts — everything flows through these
Relation types
Edge counts by relationship kind
Guide — what everything means
A quick tour of every metric and section in this dashboard, so you always know what you are looking at.
Health score (0–100)
A weighted mix: complexity 30%, duplication 25%, file size 20%, dependencies 15%, nesting 10%. 80 and above is healthy (green), 60–79 needs attention (yellow), below 60 is critical (red).
Cyclomatic complexity
The number of independent paths through a function — every if, loop, case, && or || adds one. Above 10 a function becomes hard to test and maintain; consider splitting it.
Complexity distribution
A histogram of all functions grouped by complexity. A healthy project has most functions in the low buckets and only a few in the red zone.
Size warnings
Functions longer than 50 lines and files longer than 300 lines get flagged — long units of code are harder to read, review and reuse.
Nesting depth
How deeply blocks (if / for / while…) are nested inside each other. More than 4 levels usually means the logic should be flattened or extracted.
Duplicate code
Code blocks are normalized and hashed; identical 5-line windows across files are reported with exact file and line locations. Copy-paste means every bug must be fixed twice.
Dependency graph & cycles
Each node is a file; each arrow is an import. Red nodes are part of a circular dependency (A needs B, B needs A) which makes code fragile and hard to refactor.
GraphQL Schema tab
Appears only when the project actually contains GraphQL: .graphql / .gql files, gql`` templates or introspection JSON. Shows types, queries, mutations, subscriptions, oversized types (more than 20 fields), missing resolvers and potential N+1 fields.
Knowledge Graph tab
Appears when the project contains a Graphify output (graphify-out/graph.json) or any JSON with nodes/edges arrays. Nodes are functions, classes and concepts; colors are community clusters; dashed edges are inferred; god nodes are the most connected concepts.
Themes & language
Pick one of 5 themes from the palette button and switch between English and Persian with the language button — both choices are remembered on this device.