The codeanalyzer backends

Standalone language backends parse the source, resolve the symbols, and build the call graph. There is one backend for each language, and one more for infrastructure-as-code. Together they are the codeanalyzer-* tools. Each backend writes typed JSON. The SDK reads that JSON and builds models that you can query.

flowchart LR
    SDK["CLDK Python SDK<br/>(analysis API)"] -->|invokes| CAJ["codeanalyzer-java<br/>(JVM · WALA)"]
    SDK -->|invokes| CAP["codeanalyzer-python<br/>(Jedi · defuse linker)"]
    SDK -->|invokes| CAT["codeanalyzer-ts<br/>(TS compiler)"]
    CAJ -->|canonical JSON| SDK
    CAP -->|canonical JSON| SDK
    CAT -->|canonical JSON| SDK

This split lets one analysis API cover many languages. The SDK does not parse code itself. It runs the correct backend. Then it maps the backend JSON onto typed models (JApplication, PyModule, and others).

A new backend that writes the canonical JSON makes its language available to the SDK. The SDK then needs only the Python bindings for that language. See Add a language backend.

The SDK manages the backends

The SDK runs each backend for you. 2.0 The Java backend is the optional extra cldk[java]. Its wheel carries the JAR and a bundled JVM, and the SDK runs java -jar on that JVM. Analysis level 2 and above also need a JDK 11 or later on JAVA_HOME. In CLDK 1.5.0, the SDK downloads a Temurin JDK on first use instead.

The codeanalyzer-python and codeanalyzer-typescript packages are dependencies of cldk. The SDK imports the Python backend in-process, and the backend creates a virtualenv for the dependencies of the analyzed project. You do not download a JAR, and you do not set analysis_backend_path.

These pages document the backend layer for readers who want to understand it or add to it.

This is the backend layer. For the SDKs that consume it, see the SDKs overview.

Maturity tiers

Mature production-ready  ·  Beta stable core, some features missing  ·  Medium usable through another backend

Backends

The codeanalyzer-* tools parse a language. Then they write the canonical symbol-table and call-graph schema that every frontend reads.

Language	Backend	Maturity
Java	codeanalyzer-java	Mature
Python	codeanalyzer-python	Mature
TypeScript	codeanalyzer-ts	Mature
JavaScript	via codeanalyzer-ts	Medium
IaC (Helm)	codeanalyzer-iac	Beta

Built backends

codeanalyzer-python Jedi resolves the symbols, and a defuse linker adds the level-2 call edges. It writes the canonical Py* schema.

codeanalyzer-java WALA and Javaparser. It produces symbol tables, call graphs, and the type hierarchy.

codeanalyzer-ts The TypeScript and TSX backend. It writes the canonical symbol-table and call-graph schema, with framework entrypoint detection and the level 3 and 4 dataflow graphs.

codeanalyzer-iac Beta. The infrastructure-as-code backend. It turns Helm charts into the canonical schema v2 IaC model, as JSON or a Neo4j graph.

Add a backend Help wanted. A backend for a language CLDK does not cover yet. One that writes the canonical JSON makes that language available to every SDK.