See the structure
your IDE doesn't show you.
CodeGraph parses JavaScript and TypeScript repositories into a queryable symbol graph. Built on graph theory, not AI guesswork. Every relationship is real. Every result is deterministic.
Everything your codebase wants to tell you
Six distinct analytical lenses on the same underlying graph. Each one answers a question your IDE can't.
Impact Analysis
Change one function. Know exactly what breaks.
BFS backward-traversal from any symbol surfaces every affected node, at every depth across the entire repository — before you touch a line.
Cycle Detection
Find circular dependencies before they find you.
Tarjan's SCC algorithm identifies every circular group — across file imports, call chains, inheritance, implementation, and instantiation.
Call Path Explorer
Trace any execution path in your codebase.
DFS with backtracking finds the exact call chain between any two symbols, or confirms definitively that no path exists.
Structural Health Index
A score that shows its work.
Six independently weighted structural metrics produce a 0–100 health index. Every sub-score is exposed — not a black box.
Dependency Ordering
Know what initializes before what.
Kahn's topological sort produces a valid initialization order for any symbol's dependency subgraph — and detects when cycles make it impossible.
Full Symbol Graph
Every relationship, mapped.
8 symbol kinds, 7 relationship types, cross-file resolution with tsconfig path alias support. The graph reflects what your code actually does.
How it works
From a GitHub URL to a queryable code graph — five deterministic steps, no runtime required.
Submit a GitHub URL
Paste any public JavaScript or TypeScript repository URL. CodeGraph clones it and captures the exact commit SHA for reproducible deep-linking.
Parse the AST
Babel parses every source file into an abstract syntax tree. A two-pass traversal first extracts all named symbols, then maps every structural relationship between them.
Build the Graph
Nodes and edges are indexed into five maps — by ID, by kind, by source, and by target — enabling O(1) lookup in every direction across the entire codebase.
Run the Analyzers
Tarjan's SCC, Kahn's topological sort, BFS traversal, and DFS path-finding run on the complete in-memory graph. Structural health is computed across six independent metrics.
Explore
The full symbol graph, health index, impact and dependency analysis, cycle reports, and dependency ordering are persisted and ready to query — instantly.
Built on computer science, not guesswork
Every analysis in CodeGraph is backed by a classical graph algorithm. No inference, no approximation — just deterministic results.
Tarjan's SCC
O(V + E)
“Where are the cycles?”
Strongly connected components algorithm identifies every circular dependency group. Runs across 5 relationship projections — file imports, symbol calls, inheritance, implementation, and instantiation.
Kahn's Algorithm
O(V + E)
“What's the initialization order?”
Topological sort with cycle detection built in. Produces a dependency-first ordering for any symbol's subgraph, and when ordering is impossible, isOrderable: false tells you exactly why.
Bidirectional BFS
O(V + E)
“What does this break?”
Forward BFS for dependency traversal, backward BFS for impact analysis. Both return every affected node with its exact depth from the source — not just a list, but a map.
Iterative DFS
O(V + E)
“Is there a path?”
Depth-first search with explicit path reconstruction. Finds any call chain between two symbols, or confirms no path exists. No recursion — iterative stack to handle arbitrarily deep graphs.
Real developer situations
CodeGraph answers the structural questions that come up every week — the ones your IDE doesn't have a button for.
"I don't know where to start."
Find the most connected file in the repository. Understand the core dependency structure. Know what imports what before you touch a single line of code.
"I'm afraid to change this."
Run impact analysis on any function. See every caller, every dependent file, every affected symbol — depth by depth — before you make the change.
"Is this codebase healthy?"
Check the structural health index. Identify coupling hotspots. Surface all circular dependencies and over-connected files before they become technical debt.
Ready to map your codebase?
Paste a GitHub URL. CodeGraph handles the rest — no setup, no config, no runtime required.
Start Indexing