Cheat sheet

A single-page reference for the common CLDK calls. Construct one analysis object with a per-language factory, then query it. For background and walkthroughs, see What is CLDK?, Core concepts, and the Quickstart.

Install

pip install cldk

Reachability queries use networkx. It is a CLDK dependency; install it explicitly if you query graphs directly:

pip install cldk networkx

Construct

Use the per-language factory for the language you want: CLDK.java(...), CLDK.python(...), CLDK.typescript(...), or CLDK.c(project_path). The analysis level determines how much is computed.

Java

from cldk import CLDK
from cldk.analysis import AnalysisLevel

# Default level is symbol_table. Use call_graph for callers/callees/reachability.
analysis = CLDK.java(
    project_path="commons-cli",
    analysis_level=AnalysisLevel.call_graph,
)
print(len(analysis.get_classes()), "classes")  # -> 23 classes

Python

from cldk import CLDK
from cldk.analysis import AnalysisLevel

analysis = CLDK.python(
    project_path="my_pkg",
    analysis_level=AnalysisLevel.call_graph,
)
print(len(analysis.get_classes()), "classes")

TypeScript

from cldk import CLDK
from cldk.analysis import AnalysisLevel

analysis = CLDK.typescript(
    project_path="my_app",
    analysis_level=AnalysisLevel.call_graph,
)
print(len(analysis.get_classes()), "classes")

Old entry point is deprecated

The legacy form CLDK(language="java").analysis(project_path=...) still works but is deprecated; it forwards to the factories above. Prefer CLDK.java(...) / CLDK.python(...) / CLDK.typescript(...) / CLDK.c(...). from cldk import CLDK is unchanged.

Argument	Value	Notes
factory	CLDK.java / CLDK.python / CLDK.typescript / CLDK.c	Selects the language facade.
project_path	path to checkout	The project to analyze.
analysis_level	AnalysisLevel.symbol_table (default) / AnalysisLevel.call_graph	Call graph, callers, callees, and reachability need call_graph.
target_files	list of paths (optional)	Restrict analysis to these files.
eager	bool (default False)	Force regeneration of cached analysis.
backend	config object (optional)	Selects the backend by type (see below). Omit for the default codeanalyzer backend.

Select a backend

The backend is chosen by the type of the backend= config object, imported from cldk.analysis.commons.backend_config. Omit backend= for the default in-process codeanalyzer backend. cache_dir, use_codeql, and use_ray now live inside these configs.

from cldk import CLDK
from cldk.analysis.commons.backend_config import (
    CodeAnalyzerConfig,
    PyCodeAnalyzerConfig,
    Neo4jConnectionConfig,
)

# Default codeanalyzer backend, with an explicit cache root (optional).
analysis = CLDK.java(
    project_path="commons-cli",
    backend=CodeAnalyzerConfig(cache_dir="/tmp/cache"),
)

# Python codeanalyzer backend with call-graph knobs.
analysis = CLDK.python(
    project_path="my_pkg",
    backend=PyCodeAnalyzerConfig(use_codeql=True, use_ray=False),
)

# Read-only Neo4j backend (Java / Python / TypeScript); the graph is populated out of band.
analysis = CLDK.typescript(
    backend=Neo4jConnectionConfig(uri="bolt://localhost:7687", username="neo4j", password="neo4j", application_name="my_project"),
)

Config type	Backend	Notes
(omit) / CodeAnalyzerConfig	In-process codeanalyzer	Default for Java/TypeScript. cache_dir only.
PyCodeAnalyzerConfig	In-process codeanalyzer (Python)	Default for Python. Adds use_codeql / use_ray.
Neo4jConnectionConfig(uri=...)	Read-only Neo4j/Cypher	Java, Python, and TypeScript. project_path is optional; the graph is loaded out of band — see Analysis at scale.

Caching & removed arguments

Caching is on by default for Java/TS. Artifacts live under a unified, language-keyed cache_dir (default <project>/.codeanalyzer, with each language under <cache_dir>/<language>/). The old analysis_backend_path argument is removed (the binary ships with the packaged codeanalyzer-*; for the TypeScript backend, override the binary via the $CODEANALYZER_TS_BIN environment variable), and analysis_json_path is removed (folded into cache_dir).

Symbol table

The layer available at every analysis level: every class, method, and field, typed and queryable.

Method	Returns	Description
get_symbol_table()	Dict[str, JCompilationUnit | PyModule]	The entire project, indexed by file.
get_classes()	Dict[str, JType | PyClass]	Every class or type, keyed by qualified name.
get_methods()	Dict	Every method (Java).
get_method(qualified_class_name, qualified_method_name)	JCallable | PyCallable | None	A single method; .code holds its source body.

m = analysis.get_method(
    "org.apache.commons.cli.OptionBuilder", "create(java.lang.String)"
)
print(m.code)  # -> source body of OptionBuilder.create(java.lang.String)

Java additionally provides class-relationship queries: get_sub_classes(cls), get_extended_classes(cls), and get_implemented_interfaces(cls), along with get_all_crud_operations() and get_all_comments().

Call graph & reachability

Build at the right level

These methods need analysis_level=AnalysisLevel.call_graph. The default symbol_table level does not populate call edges.

Method	Returns	Notes
get_call_graph()	networkx.DiGraph	Edges point caller → callee.
get_call_graph_json()	str	Same graph, serialized.
get_callers(target_class_name, target_method_declaration)	Dict	Methods that call this method.
get_callees(source_class_name, source_method_declaration)	Dict	Methods that this method calls.
get_class_call_graph(qualified_class_name, method_signature=None)	graph	Call graph scoped to one class (Java).

cg = analysis.get_call_graph()          # -> networkx.DiGraph
callers = analysis.get_callers(
    "org.apache.commons.cli.Options", "addOption(org.apache.commons.cli.Option)"
)  # -> Dict of call sites

Reachability is a networkx query over the call graph:

import networkx as nx

cg = analysis.get_call_graph()
print(nx.has_path(cg, src, sink))                 # reachable? -> True / False
# nx.shortest_path(cg, src, sink)                 # one path
# list(nx.all_simple_paths(cg, src, sink))        # every path

Models

The typed objects returned by each language’s analysis API.

Language	Models
Java	JType, JCallable, JCompilationUnit, JField, JComment, JCRUDOperation
Python	PyModule, PyClass, PyCallable, PyImport, PyComment

Gotchas

Common mistakes

• Call-graph level is required. get_call_graph, get_callers, get_callees, and reachability need analysis_level=AnalysisLevel.call_graph. The default symbol_table won’t have call edges.
• Analysis is project-based. Always pass project_path=... to the factory (e.g. CLDK.java(project_path=...)); point it at the project root. (The exception is the Neo4j backend, where the graph is populated out of band and project_path is optional.)

Next steps

Common tasks Copy-paste snippets for each call above.

cocoa Build a Code Context Agent plugin on these methods.

Python API reference Every method on the Python SDK analysis APIs.