# Programming Languages and Frameworks Supported by code-review-graph: Complete Parser & Enrichment Guide

> Explore supported programming languages and frameworks for code-review-graph. Our comprehensive guide details parsing and enrichment for 40+ languages and popular frameworks like Spring, Express, and FastAPI.

- Repository: [Tirth Kanani/code-review-graph](https://github.com/tirth8205/code-review-graph)
- Tags: api-reference
- Published: 2026-08-07

---

**code-review-graph supports 40+ programming languages via Tree-sitter grammars and detects framework entry points for Python (FastAPI, Flask, Celery), Java (Spring), JavaScript/TypeScript (Express, NestJS), and Android/Kotlin through decorator pattern matching.**

The code-review-graph repository automatically parses source files and enriches execution-flow graphs with framework-specific semantics. Understanding which programming languages and frameworks supported by code-review-graph are available ensures you can leverage its full static analysis capabilities across polyglot codebases. The system combines extension-based language detection in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py) with decorator pattern matching in [`code_review_graph/flows.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/flows.py) to build semantically rich code graphs.

## Language Support via Tree-sitter in parser.py

The core language detection logic resides in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py) (lines 13-83), which maps file extensions to Tree-sitter grammars. When `CodeParser.detect_language()` encounters a file, it first checks the extension against an internal mapping table before falling back to shebang analysis.

### Supported Programming Languages and Extensions

The parser recognizes over 40 languages covering web, systems, mobile, and data science ecosystems:

- **Python**: `.py`, `.ipynb` (Jupyter notebooks)
- **JavaScript/TypeScript**: `.js`, `.jsx`, `.mjs`, `.ts`, `.tsx`, `.astro`, `.vue`, `.svelte`
- **Systems languages**: `.go`, `.rs` (Rust), `.c`, `.h`, `.cpp`, `.cc`, `.cxx`, `.hpp`, `.hh`, `.zig`
- **JVM ecosystem**: `.java`, `.kt` (Kotlin), `.scala`, `.dart`, `.groovy` (implied by standard patterns)
- **Mobile**: `.swift`, `.m` (Objective-C)
- **Web/Scripting**: `.php`, `.rb` (Ruby), `.pl`, `.pm`, `.t` (Perl), `.lua`, `.luau`
- **Data/Config**: `.r`, `.jl` (Julia), `.sql`, `.tf`, `.hcl`, `.yml`, `.yaml`, `.properties`, `.nix`
- **Enterprise**: `.cs` (C#), `.vb` (VB.NET), `.ps1`, `.psm1`, `.psd1` (PowerShell)
- **Specialized**: `.sol` (Solidity), `.gd` (GDScript), `.res`, `.resi` (ReScript), `.sv`, `.svh`, `.v`, `.vh` (Verilog), `.ex`, `.exs` (Elixir)
- **Shell**: `.sh`, `.bash`, `.zsh`, `.ksh`

### Shebang Detection for Extensionless Files

For files without extensions, the parser falls back to shebang probing using the `SHEBANG_INTERPRETER_TO_LANGUAGE` table in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py). For example, a script beginning with `#!/usr/bin/env python` resolves to the **python** language, while `#!/bin/bash` maps to **bash**.

## Framework Detection and Entry Point Enrichment

Beyond parsing, code-review-graph identifies framework-specific entry points in [`code_review_graph/flows.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/flows.py) (lines 27-72). The `detect_entry_points()` function scans function decorators against regex patterns to mark HTTP handlers, background tasks, and event listeners.

### Python Web and Task Frameworks

The detector recognizes patterns for **FastAPI**, **Flask**, **Starlette**, and **Sanic** through route decorators like `app.get`, `router.post`, and `blueprint.route`. It also identifies **Celery** tasks via the regex `(celery\.)?(task|shared_task|periodic_task)`, **Click** CLI commands through `click.command|group`, and **Pydantic** validators via `(field|model)_(serializer|validator)`.

Additional Python support includes **Django** signals (`receiver`), Django REST (`api_view`), **pytest** fixtures (`pytest.fixture|mark`), and SQLAlchemy event listeners (`(event\.)?listens_for`).

### Java Spring and Enterprise Patterns

For Java applications, the parser matches **Spring** annotations including `(Get|Post|Put|Delete|Patch|RequestMapping)Mapping`, `Scheduled`, `EventListener`, `Bean`, `Configuration`, and `KafkaListener`. **Temporal** workflow patterns like `WorkflowMethod` and `ActivityMethod` are also supported.

### JavaScript, TypeScript, and Mobile Frameworks

JS/TS detection covers **Express**, **Koa**, and **Hono** through patterns like `(app|router).(get|post|put|delete|patch|use|all)`. **Angular** and **NestJS** are recognized via `Component|Injectable|Controller|Module|Guard|Pipe` and GraphQL patterns (`Subscribe|Mutation|Query|Resolver`).

Android and **Kotlin** support includes `@Override`, `@OnLifecycleEvent`, `@Composable`, `HiltViewModel`, `AndroidEntryPoint`, and `Inject`.

### AI and Agent Frameworks

Emerging AI frameworks like **LangChain** and **pydantic-ai** are recognized through `tool|tool_plain|system_prompt|result_validator` decorator patterns, enabling semantic analysis of AI agent codepaths.

### Middleware and Exception Handling

The system detects **FastAPI** and **Starlette** middleware through `middleware|exception_handler|on_exception` patterns, ensuring async request/response flows are properly captured in the graph.

## Practical Implementation Examples

### Detecting a File's Language

```python
from code_review_graph.parser import CodeParser
from pathlib import Path

parser = CodeParser()

# Shebang-based detection for extensionless scripts

lang = parser.detect_language(Path("my_script"))

# → "python" (if the script starts with `#!/usr/bin/env python`)

# Extension-based lookup

lang = parser.detect_language(Path("app.py"))

# → "python"

```

### Building Graphs with Framework Entry Points

```python
from code_review_graph.graph import GraphStore, parse_repo
from code_review_graph.flows import detect_entry_points

# Parse a repository (tree-sitter parsers are selected automatically)

store = GraphStore()
parse_repo(Path("/path/to/repo"), store)

# Find all entry points, including those annotated with framework decorators

entries = detect_entry_points(store)          # default: exclude test nodes

print([e.qualified_name for e in entries])

# Example output:

#   ['app.py::main', 'src/api.py::get_user', 'src/tasks.py::process_data']

```

### Extending Language Support

Create a [`languages.toml`](https://github.com/tirth8205/code-review-graph/blob/main/languages.toml) file in the repository root to add custom languages:

```toml
[[languages]]
name = "mydsl"
extensions = [".mydsl"]
class_node_types = ["class_declaration"]
function_node_types = ["function_declaration"]
import_node_types = ["import_statement"]
call_node_types = ["call_expression"]

```

When `CodeParser` is instantiated with `repo_root=Path(".")`, it automatically loads the custom mapping:

```python
parser = CodeParser(repo_root=Path("."))
parser.detect_language(Path("example.mydsl"))   # → "mydsl"

```

## Summary

- **40+ languages** are supported through Tree-sitter grammars mapped in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py) (lines 13-83), covering Python, JavaScript, Go, Rust, Java, and specialized languages like Solidity and Verilog.
- **Shebang detection** provides fallback language identification for extensionless executable scripts using the `SHEBANG_INTERPRETER_TO_LANGUAGE` table.
- **Framework enrichment** occurs in [`code_review_graph/flows.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/flows.py) (lines 27-72), where `detect_entry_points()` identifies HTTP handlers, background tasks, and event listeners via decorator regex matching.
- **Extensible architecture** allows custom language definitions via [`languages.toml`](https://github.com/tirth8205/code-review-graph/blob/main/languages.toml), enabling analysis of domain-specific languages without modifying core source code.
- **Polyglot framework support** spans Python web stacks (FastAPI, Flask), Java Spring, JS/TS ecosystems (Express, NestJS), mobile frameworks (Android/Kotlin), and emerging AI tools (LangChain).

## Frequently Asked Questions

### How does code-review-graph handle files without extensions?

The `detect_language()` method in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py) falls back to shebang analysis when no extension is present. It reads the first line of the file and matches it against the `SHEBANG_INTERPRETER_TO_LANGUAGE` dictionary to determine the language (e.g., `#!/usr/bin/env python3` resolves to **python**). If no shebang is found, the method returns `None` and the file is excluded from graph construction.

### Can I add support for a custom programming language not in the default list?

Yes, create a [`languages.toml`](https://github.com/tirth8205/code-review-graph/blob/main/languages.toml) file in your repository root defining the language name, file extensions, and Tree-sitter node types for classes, functions, imports, and calls. When you instantiate `CodeParser` with `repo_root=Path(".")`, it automatically loads this configuration and treats the specified extensions as your custom language without requiring modifications to the core library.

### Which Python web frameworks are recognized as entry points?

The system recognizes **FastAPI**, **Flask**, **Starlette**, and **Sanic** through route decorators (`app.get`, `router.post`, `blueprint.route`), **Celery** tasks, **Click** CLI commands, **Django** signals and REST views, and **Pydantic** validators. The `detect_entry_points()` function matches these using compiled regex patterns in [`code_review_graph/flows.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/flows.py), marking matched functions as framework entry points in the execution graph.

### Does code-review-graph support infrastructure-as-code and configuration files?

Yes, the parser handles **Terraform** and **HCL** (`.tf`, `.hcl`), **SQL** (`.sql`), **YAML** (`.yml`, `.yaml`), **Properties** files, and **Nix** expressions (`.nix`). These are mapped to their respective Tree-sitter grammars in [`code_review_graph/parser.py`](https://github.com/tirth8205/code-review-graph/blob/main/code_review_graph/parser.py), allowing the graph builder to include configuration and schema definitions alongside application code.