[lamwassi]

Adds a Go frontend to CLDK: a new CLDK.go(...) factory, a GoAnalysis facade, a
GoAnalysisBackend ABC with two interchangeable backends (cango` subprocess and read-only
Neo4j), Go pydantic models mirroring canonical schema v2, docs, an example, and tests.

Motivation and Context

CLDK already exposes Java, Python, and TypeScript through per-language factory methods; Go was the
missing fourth language. This PR brings Go to parity with the existing frontends so the same
"disk → question about the code" workflow works on a Go module.

Go is also the SDK's first class-less, type-centric facade. A Go type is a struct or an
interface (never a class), and package-level functions are distinct from receiver methods.
Rather than force Go through a "module-as-class" hack, the public surface speaks get_types /
get_functions / get_methods_of — never get_classes. The class-named slots on the backend
(get_all_classes, get_all_methods_in_class, …) are inherited only to satisfy the shared
AnalysisBackend ABC and are never user-facing; the facade translates them to the type-centric
vocabulary so the abstraction never leaks to a caller.

Design decisions carried over from the Go-SDK planning:

• No projections.py (overview models) — out of SDK3 scope.
• GoType is a single class, not a discriminated union; kind distinguishes struct vs.
  interface.
• Go reuses the base CodeAnalyzerConfig (GoBackend = Union[CodeAnalyzerConfig, Neo4jConnectionConfig]) because cango has no backend-only knob today — the same shape as
  JavaBackend. A GoCodeAnalyzerConfig subclass is added only if cango later grows one.
• The analyzer binary ships (post-release) with the codeanalyzer-go wheel; until the first
  release is cut, the binary is resolved out-of-band via $CODEANALYZER_GO_BIN, so the version
  pin is deferred.

How Has This Been Tested?

Yes — including against a real Go corpus (the Litestream project, a 525k-node / 156k-edge
graph at enterprise scale), not just synthetic fixtures. The suite under tests/analysis/go/ and
tests/models/go/ covers:

• Facade surface — test_public_surface_has_no_class_named_method asserts the public API never
  exposes a class-named accessor; type/function/method/field navigation, call graph, callers/
  callees keyed on can:// ids, and get_source span slicing.
• Caching & levels — a shallower cache is re-run for a deeper request, a deeper cache is reused
  for a shallower one (schema is additive, L1 ⊆ L2), and the requested level is passed through to
  cango (capped at 2 — Go has no L3/L4). Level mapping goes through analyzer_level() to avoid
  the silent-default-to-1 bug a hand-rolled dict caused.
• Backend contract parity — test_go_backend_contract confirms both backends subclass the ABC,
  implement every abstract method, and match signatures, so the local and Neo4j backends answer the
  facade identically.
• Local vs. Neo4j equivalence on the real corpus — type-id sets, function-signature sets,
  call-graph edge counts, and symbol-table module counts all match across the two backends (parity
  proven by test, since the Neo4j backend does lazy per-subtree Cypher rather than an eager
  rebuild).
• UTF-8 source slicing — spans are UTF-8 byte offsets, so non-ASCII modules are sliced on
  encoded bytes and decoded back.
• Unavailable-layer semantics — the artifact/dependency/config six raise on a local L1/L2
  run (and on the current Neo4j projection) rather than returning an ambiguous empty list, mirroring
  the Java precedent where [] is reserved for "the pass ran and found nothing."

The live Neo4j tests (test_go_neo4j_live.py) run against a graph populated out of band.

Breaking Changes

None. This is purely additive. Existing Java / Python / TypeScript entry points are untouched.
The only changes to shared code are additive: "go" added to _CACHE_KEYS, a new GoBackend
union, and a new go branch in the deprecated CLDK(language).analysis(...) compat shim (which
now also returns GoAnalysis).

Types of changes

• Bug fix (non-breaking change which fixes an issue)
• New feature (non-breaking change which adds functionality)
• Breaking change (fix or feature that would cause existing functionality to change)
• Documentation update

Checklist

• I have read the Codellm-Devkit Documentation
• My code follows the repository's style guidelines
• New and existing tests pass locally
• I have added appropriate error handling
• I have added or updated documentation as needed

Additional context

New public API

from cldk import CLDK
from cldk.analysis import AnalysisLevel

analysis = CLDK.go(
    project_path="/path/to/go/module",     # directory with a go.mod
    analysis_level=AnalysisLevel.call_graph,  # L1 (symbols) or L2 (+ call graph); no L3/L4
)

analysis.get_types()                # {can:// id -> GoType}  (structs + interfaces)
analysis.get_functions()            # package-level funcs, keyed by signature
analysis.get_methods_of(type_id)    # receiver methods of a type
analysis.get_fields(type_id)
analysis.get_call_graph()           # networkx.DiGraph, nodes keyed by can:// callable id
analysis.get_callers(id) / analysis.get_callees(id)   # full edges (src/dst/prov/weight)
analysis.get_source(node_id)        # span-sliced source text

Pass a Neo4jConnectionConfig as backend= to query a pre-populated GO_-prefixed graph
read-only over Bolt — the backend is chosen by the config type, and queries lazily hit the graph so
it scales to large modules without materializing the whole program.

Files

• Facade / backends: cldk/analysis/go/ (go_analysis.py, backend.py,
  codeanalyzer/codeanalyzer.py, neo4j/neo4j_backend.py, neo4j/reconstruct.py).
• Models: cldk/models/go/ (schema v2 mirror; GoType as a single class).
• Factory + shim: cldk/core.py (CLDK.go, plus the go branch in the legacy analysis() shim).
• Shared: cldk/analysis/commons/backend_config.py ("go" cache key, GoBackend union).
• Docs / example: README.md (Go Quick Start), CLAUDE.md (language table row),
  examples/go_quickstart.py.
• Tests / fixtures: tests/analysis/go/, tests/models/go/, tests/resources/go/.

Known limitations (intentional, documented)

• cango emits analysis levels 1–2 only; slicing / CFG / CDG / DDG accessors are absent rather
  than present-and-erroring.
• The artifact/dependency/config layer is not emitted by a local L1/L2 run, so those accessors
  raise (see above).
• The codeanalyzer-go wheel is not yet released, so the version pin is deferred and the binary is
  resolved via $CODEANALYZER_GO_BIN for now.

Note: the CLAUDE.md table row mentions a --analysis-schema 2 flag; that flag was since
removed on the branch (cango now defaults to schema v2), so that part of the row is stale and
should be trimmed before merge.

[sinha108]

tests/analysis/go/test_go_analysis.py still loads tests/analysis/go/fixture_analysis.json. .gitignore excludes that file (*.json), so it isn't in this PR. On a clean checkout of e9d9669, the Go tests give 4 failed and 8 errors: every test using the go_analysis fixture, the _level_aware_run helper or _capture.

The suggestions below point those tests at the committed litestream corpus (GO_ANALYSIS) and drop the missing fixture. Apply them all at once with Commit suggestions in the Files changed tab.

Verified on a fresh clone of this PR, with cango built from codeanalyzer-go main, comparing every test's outcome before and after:

• Go tests (tests/analysis/go, tests/models/go): 67 passed / 4 failed / 8 errors / 7 skipped → 79 passed / 7 skipped. All 12 failing tests now pass, no test went from passing to anything else, and the 7 skips are the live-Neo4j tests, skipped for lack of a database both times.
• Full SDK suite: 1861 passed / 4 failed / 8 errors → 1873 passed, 0 failed, 0 errors.

Separate from this (not part of these suggestions): get_source still returns the wrong text for a method declared in a different file from its receiver type, because neither Go backend reads source_file. We'll fix that in follow-up python-sdk work after this PR merges.

[sinha108]

Thanks, all five review suggestions are in.

One more thing before merge: uv.lock is stale. This PR adds codeanalyzer-go==0.1.0rc1 to pyproject.toml but doesn't update the lockfile, so on a clean checkout of f445f85, uv lock --check fails.

The release workflow installs with uv sync --all-groups --frozen, which installs only what the lock lists. So codeanalyzer_go is never installed, and the 5 end-to-end tests in tests/analysis/go/test_go_e2e.py skip ("no codeanalyzer-go (cango) binary resolvable"). The suite still shows green, so CI wouldn't flag it.

On a fresh clone of f445f85:

Install	Go tests	Full suite
uv sync --all-extras --all-groups (refreshes the lock)	79 passed, 7 skipped	1873 passed, 411 skipped, 0 failed
uv sync --all-groups --frozen (as in release.yml)	74 passed, 12 skipped	1868 passed, 416 skipped, 0 failed

The 7 remaining skips are the live-Neo4j tests.

Fix: run uv lock and commit the updated uv.lock. The diff is 14 added lines: codeanalyzer-go in cldk's dependencies and requires-dist, plus its package entry.

[sinha108]

Thanks for the lockfile update; uv lock --check now passes. But b5785ac re-resolved the whole lockfile instead of only adding codeanalyzer-go: about 99 packages moved to newer versions, 6 were added and 7 removed. Could you narrow it to the one addition?

Why it matters

This PR adds Go support, so its lockfile change should be limited to that. A broad upgrade can have consequences we can't see from here:

• It isn't fully tested. The suite passes with the new versions, but 411 tests skip on a plain run: the live Neo4j, Java taint and graph-backend suites need external servers. Those are exactly the tests that would catch a regression from bumps such as neo4j 6.2 → 6.4, protobuf 6 → 7 (via ray), python-dateutil 2 → 3 or pydantic 2.11 → 2.14.
• Major-version jumps. protobuf, python-dateutil, pyflakes, filelock, markdown-it-py and pycparser all cross a major version.
• It's hard to trace later. If something breaks, a dependency upgrade inside a Go-support PR is hard to find and to revert on its own.

The upgrade itself is fine to do, but in its own PR, run against the live Neo4j and Java suites.

What to do

From the PR branch:

git checkout f445f85 -- uv.lock   # the lockfile from before b5785ac
uv lock                           # no --upgrade: adds only codeanalyzer-go
git diff --stat uv.lock           # expect: 1 file changed, 14 insertions(+)
uv lock --check
git commit -am "Lock codeanalyzer-go without upgrading other dependencies"
git push

The expected diff against f445f85 is these 14 added lines and nothing else:

• codeanalyzer-go in cldk's dependencies;
• codeanalyzer-go with specifier = "==0.1.0rc1" in requires-dist;
• one [[package]] name = "codeanalyzer-go" entry with its 5 wheels.

Verified

On a fresh clone of 4501222 with that lockfile, installed the way release.yml does it (uv sync --all-groups --frozen):

Check	Result
uv lock --check	passes
codeanalyzer-go installed with its cango binary	yes; other versions unchanged (e.g. pydantic 2.11.7)
Go tests (tests/analysis/go, tests/models/go)	79 passed, 7 skipped (live Neo4j)
Full suite	1873 passed, 411 skipped, 0 failed

These are the same counts as with the upgraded lockfile, so narrowing it costs nothing.