Skip to content

Rewrite codefang in Rust (supersede Go implementation) - #20

Merged
dmytrogajewski merged 158 commits into
mainfrom
merge/rust-rewrite-into-main
Jul 7, 2026
Merged

dmytrogajewski merged 158 commits into
mainfrom
merge/rust-rewrite-into-main

Conversation

@dmytrogajewski

Copy link
Copy Markdown
Contributor

Summary

Lands the full Rust rewrite of codefang onto main, superseding the Go implementation.

The rewrite is an independent history (no common ancestor with main). This PR is an integration branch: origin/main is merged into the rewrite tip using -s ours, so main is recorded as a parent while the resulting tree is the rewrite wholesale — the Go tree (cmd/, internal/, go.mod, …) is not carried over.

After merge, main's tree will be identical to the feature/rust-rewrite tip (3cbb66e).

What changes

  • Go implementation removed; replaced by a Rust workspace (Cargo, crates/, bins/).
  • Rust workspace CI (fmt + clippy + test); Go pipeline dropped.
  • .uastmap DSL, dev server, LSP, and web playground removed.

Heads-up for reviewers

🤖 Generated with Claude Code

dmytrogajewski and others added 30 commits January 26, 2026 02:39
Comprehensive code analysis platform with:
- codefang: CLI for static analysis and git history mining
- uast: Universal AST parser supporting 60+ languages via Tree-sitter

Features:
- Burndown charts, coupling analysis, developer stats
- Complexity, cohesion, halstead, sentiment, typos analyzers
- UAST-powered cross-language static analysis
- Pluggable analyzer architecture
- Web UI for UAST mapping development

Spiritual successor to src-d/hercules, rebuilt with modern tooling.
- Rename 38 stuttering type names across 13 packages (e.g. burndown.BurndownShard -> burndown.Shard)
- Rename file_history package to filehistory (underscore in package name)
- Remove deprecated golint from ci.yml, linting handled by golangci-lint in lint.yml
- Fix Go version matrix: remove nonexistent 1.25, keep 1.24 to match go.mod
- Upgrade actions/setup-go@v4 to @v5 across ci.yml for consistency with lint.yml
- Align lint.yml scope to ./cmd/... ./pkg/... matching Makefile
- Re-enable revive stutter check in .golangci.yml (all stuttering fixed)
- Remove stale file_history underscore exclusion from .golangci.yml
CGO_ENABLED=0 is incompatible with -race flag. Match Makefile: CGO_ENABLED=1.
Add mutex to serialize access to the package-level nodeTextBuffer
variable in ParseMapping. Concurrent calls from parallel tests were
racing on the shared global.
fix: resolve golint stuttering errors and unify CI linter config
The CI was failing because libgit2 is required for git2go bindings.
This adds:
- Submodule checkout for vendored libgit2
- Build dependencies installation (cmake, libssl-dev, libz-dev)
- Libgit2 build caching based on CMakeLists.txt hash
- Proper CGO environment variables for tests and linting
feat(git): switch to libgit2 via shim
drwatsno and others added 20 commits June 10, 2026 20:57
…nguage-detection parity fixes

- text: rust port of the 6 SerializeTextFn renderers (sentiment, shotness,
  burndown, couples, devs, file-history) in handlers/history_text.rs over
  the existing cf-terminal helpers; ANSI colors unconditional (Go honors
  only NO_COLOR), Go fmt width = rune count, terminal helpers = bytes.
  18/18 text cells green (byte-exact where Go is byte-stable, differential
  oracle where Go is content-nondeterministic: shotness everywhere,
  couples tie order, sentiment@ioq3).
- static flags: --include-vendored/--include-generated thread the shared
  path-policy options into the static/complexity walk; --per-file emits
  Go's JSONFileEntry enrichment (one entry per analyzed file, function-free
  included, 'No functions found'/score 1). All three flag cells + the base
  regression green on hercules.
- language detection parity (found via ndjson/timeseries cells):
  * cf-langpath gains the enry MODELINE strategy (vim/emacs, first+last 5
    lines) — extensionless cons build files (ioq3 Construct/Conscript-*)
    are Perl via '-*- mode: perl -*-'.
  * .h heuristic kept exactly at src-d/enry v2.1.0 (the version go.mod
    pins): no Always(C) rule, no __cplusplus alternatives — verified 0
    diffs over the 1412-file ioq3 import tree against a v2.1.0 probe.
  * devs walk: the per-commit language map is keyed by BLOB HASH with
    last-change-wins overwrites (Go LanguagesDetectionAnalyzer.Languages),
    so same-content files share one language; same-hash modifies produce
    0/0/0 line-stat entries that still create per-language keys.
- couples: oversized changesets emit zero-hash ndjson TCs (Go's early
  return never sets CommitHash) and are dropped from commit_stats — fixes
  couples ndjson/timeseries@ioq3.
- sentiment: comments_by_commit records an entry for EVERY consumed commit
  (spilled commits get comment_count 0) — fixes timeseries@kubernetes.

Oracle: full ndjson/timeseries/text sweep green across hercules, ioq3,
kubernetes (30 ndjson/timeseries + 18 text + 12 text-error + 3 flag cells).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…-commit window)

Go's run.go --head loads EXACTLY the single HEAD commit for the whole
history phase; these four walks ignored the flag and walked the full
history (limit 0). Invisible on the per-analyzer cells (the matrix pairs
--head only with devs, which routes to its closed form at the handler) but
fatal for the combined '*' selection on kubernetes: render_combined
dispatched imports/typos/anomaly over all 135k commits and the cell timed
out with empty output. With the fix the star cell completes in ~6m and the
unified model matches Go (oracle-gated).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…g parity)

clap errors on a duplicated flag ('--limit 50 --limit 50' → usage error,
empty stdout, rc=1) while cobra's pflag silently keeps the last value.
Self-override the scalar helpers (bool/tristate/str/int) so repeats parse
last-wins. Fixes flag:history/devs--limit:50@hercules (Rust emitted 0
bytes); oracle-verified, single-occurrence behavior unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The plot format writes index.html + per-analyzer <id>.html + report.json
into --output with empty stdout, so the stdout oracle never saw it. Adds:

- oracle file mode (run_invocation_files): triggered by '--format plot'
  with no caller --output; both binaries run into fresh temp dirs, file
  SETS must match, and per-file bytes follow the measured-variance
  discipline — byte-stable Go files demand byte equality, files whose
  variance is fully explained by the go-echarts random 12-char chart ids
  (measured: the canonicalization is trusted only when it makes all Go
  runs agree) compare canonically, and Go-content-nondeterministic files
  fall back to the structural contract. Rust determinism (raw bytes,
  two runs) is required throughout.
- matrix plot family: 19 cells on the first tier repo (7 static + 10
  history analyzers + static/* and * set pages).
- run_matrix: the empty-stdout EXPECTED_EMPTY probe is skipped for plot
  cells (their stdout is empty BY CONTRACT; the files are the contract).

The cells fail honestly while the Rust plot port is in flight (verified:
'file set mismatch' — Rust writes no files yet).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…f-plotpage)

Port of the Go plot HTML pipeline:

- cf-plotpage crate: theme, go-echarts v2.6.7 option model with byte-exact
  JSONNotEscaped serialization (top-level keys byte-sorted, nested structs
  in Go declaration order with omitempty semantics), chart builders,
  components with BOTH Go escapers (html/template vs text/template tables),
  the 15 page templates carried as post-template literal bytes, embedded
  logo asset, Page/MultiPageRenderer (per-analyzer pages + index.html).
  Chart element ids are DETERMINISTIC 12-char [A-Za-z] tokens (Go's are
  random per run; the differential gate canonicalizes both sides).
- cf-gojson: additive SetEscapeHTML(false) counterpart
  (Encoder::with_html_escaping) for the go-echarts embedded JSON.
- cf-commands: plot routing in run_subcommand — the exact
  '--output flag is required when --format plot' precheck, the static-only
  plot path (pages -> index -> report.json: indented, atomic temp+rename,
  Go file modes), PLOT_ANALYZERS registry, and the static/complexity
  sections pilot (top-20 bar / scatter+marklines / distribution pie) over
  a new aggregated RAW report value shared with report.json.

Verified on hercules: report.json + index.html byte-identical to Go;
static-complexity.html byte-identical after chart-id normalization; Rust
output deterministic across runs; the plot:static/complexity@hercules
matrix cell passes the new file-output oracle (which failed before the
port — the gate discriminates).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Ports each analyzer's plot.go chart sections + the aggregated raw report
builder its pages and report.json consume (reusing the existing analyzer
math): clones (clone-types pie), cohesion (histogram / distribution pie /
per-directory box plot with Go stats.Percentile interpolation), comments
(liquid gauge, top-20 bar via pdqsort, coverage pie), halstead (top-12
effort bar, 3-series risk scatter, volume pie; the Go volume-assessment
Medium branch is unreachable and stays so), imports (top-20 bar,
categories pie, dependency-risk table), composition (report.json only —
Go registers no sections). cf-plotpage gains BoxPlot/Liquid chart kinds
and YAxis min/max. Page order for literal multi-id selections now follows
the CLI selection order (Go AnalyzerNamesByID), via expand_selection_ids.

Oracle: all 7 static plot cells + the static/* set cell + a literal
subset cell PASS on hercules; comments/halstead report.json byte-stable
and byte-identical, the Go-content-nondeterministic surfaces (clone-pair
order, cohesion ties, imports order) covered by the gate's measured
fallback. cf-commands lib tests: 81 passed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ot flow

Completes the --format plot port:

- cf-plotpage: TreeMap/Radar/HeatMap chart kinds with go-echarts Validate
  semantics, visualMap, multi-Y-axes, palette overrides, and the remaining
  SingleSeries fields at exact go-echarts declaration positions.
- 10 plot-section modules (plot_sections/history_*.rs) porting each Go
  store_reader/plot.go — including devs' six-tab dashboard composites and
  burndown's UTC calendar-year aggregation — over the existing
  byte-verified walks (shotness raw report, imports usage counts, couples
  sparse top-K coupling store, burndown dense aggregate, anomaly
  cross-analyzer enrichment gated on co-selection).
- history_plot.rs orchestrator: page-per-flag rendering, history-style
  report.json ({analyzer_ids, pages}), and Go's mixed-run sequence
  (static phase, history phase overwrites report.json, rebuild_index
  title-sorted) for the '*' selection.
- oracle: chart-id canonicalization now also covers the
  getElementById('<id>') site — without it every chart-bearing page
  silently downgraded to the weaker structural contract.

Semantic forks mirrored from Go (documented in the modules): sentiment's
store path drops LowSentimentPeriods; devs --head carries languages +
line stats only under forced first-parent; couples' plot pipeline takes
collectUnfiltered (lastCommit freed) and its dev-coupling heatmap never
renders on run pipelines.

Gate: all 19 plot matrix cells PASS (7 static + 10 history + static/* +
'*'); cf-commands lib tests 81 passed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
… + 12 warnings)

Workflow-audited every unlinked .rs file and dead-code warning (per-crate
investigation, adversarial verification of each wire/delete verdict,
per-group application, final workspace gate). Outcomes:

WIRED (compile-checked, consumers cited):
- cf-observability: all 14 modules linked (otel 0.24 + prometheus 0.17
  pins — no exporter exists for later otel lines; the two
  .with_boundaries() sites deferred to an SDK View with notes), plus a
  runtime-feature-gated cf-commands observability bracket porting
  run.go initObservability — compiled out of default builds, so shipped
  binary bytes are unchanged.
- cf-budget: model/solver/static_solver linked with cf-units/cf-framework
  bridges; derive_knobs zero-fills CoordinatorConfig mirroring Go's
  partial struct literal (the non-zero default() would have diverged).

DELETED (superseded scaffolds; zero workspace references, verified):
- cf-analyzers-common: all 15 stand-in modules (semantics live in the
  per-analyzer crates); crate-level allow(dead_code) blanket dropped.
- cf-halstead: 5 streaming-pipeline stand-ins + the shim they justified;
  cf-analyzer-burndown: report/path_interner; cf-reportutil: value.rs;
  cf-typos: 4 glue modules; cf-uast-node: the gojson shim (tomap now
  uses cf-gojson directly) + 3 unused classifier fns.
- cf-govader: entire workspace-excluded crate (superseded by
  cf-sentiment::vader + its data); DESIGN.md references updated.

WARNING FIXES: cf-complexity is_decision_point test-gated with Go
citation; cf-langpath Frequencies.tokens_total dropped; unused imports
in cf-shotness/cf-gitlib; cf-commands static_halstead/static_imports
orphans removed.

Gate: cargo build --workspace --all-targets warning-free (only the two
pre-existing golden-harness manifest notes); 2294 workspace tests pass
(the previously-failing cf-complexity else-if test now passes); oracle
smoke green incl. static/halstead + plot cells; unlinked-file scan:
0 of 463 files remain unlinked.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
… groups)

Workflow-driven idiomatic refactor with the byte-identity gate as DoD,
covering: cf-analyze/cf-renderer/cf-plotpage/cf-metrics, the report-format
serializers (cf-gojson/cf-goyaml/cf-gosort/cf-reportutil/cf-safeconv/
cf-textutil), analyzers-c (cf-devs/cf-couples/cf-shotness/cf-anomaly),
infra (cf-framework/cf-streaming/cf-pipeline/cf-plumbing/
cf-analyzers-plumbing, cf-cache/cf-checkpoint/cf-persist/cf-storage/
cf-spillstore/cf-config), the alg crates, langpath
(cf-langpath/cf-pathfilter/cf-pathpolicy/cf-terminal), and misc
(cf-observability/cf-mcp/cf-budget/cf-analyzers-common).

What changed:
- thiserror for hand-rolled error enums with byte-identical Display
  strings (part of the CLI contract); let-else and range-contains
  rewrites; const fn / #[must_use] / Self hygiene; needless &mut
  relaxations; sort_by_key(Reverse) over manual comparators; type
  aliases replacing boxed-hook type soup in cf-analyze; PageShell param
  struct replacing an 8-arg signature in cf-plotpage; magic-number
  constant renames; stale README/docs corrected.
- Provenance reframe across ~140 files: pure Go-port lineage comments
  deleted; load-bearing rationale reworded to stand alone as the
  report/CLI compatibility contract (pinned by rust/tests/compat);
  deliberate keeps: go-echarts upstream citations that decide JSON field
  order, live Go-toolchain oracle tests in cf-goyaml, reference-test
  citations.
- Frozen surfaces (serializer algorithms, pdqsort, ftoa, RFC3339, tick
  math) untouched beyond provably identical predicate rewrites.

Gates: workspace build zero warnings; 163 test binaries green; oracle
spot cells (devs, couples, composition + per-group cells during the
workflow) all PASS.

Note: five groups (cf-commands, uast crates, analyzers-a/b, git crates)
plus analyzers-d hit session limits mid-run twice and their partial
edits were reverted to HEAD — they remain unrefactored and follow in a
second batch.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
… groups)

Completes the workspace-wide refactor: cf-commands; the uast crates
(cf-uast/-node/-mapping/-spec/-lsp); analyzers-a (complexity/halstead/
cohesion/comments/clones); analyzers-b (imports/composition/quality/
typos); git (gitlib/godiff/identity/sigutil); analyzers-d (sentiment/
file-history/analyzer-burndown/burndown-core); plus the residue reframe
of cf-alg-stats/cf-meminfo/cf-analyze stragglers lost to the batch-1
crash recovery.

Highlights: thiserror across the remaining hand-rolled error enums
(PipelineError/RegistrationError/FormatError in cf-commands, the uast
Parse/Dsl/Match errors with #[source] preserved) with every Display
string byte-identical; the blanket allow(clippy::all)/allow(dead_code)
in handlers/history.rs removed and the surfaced lints fixed; deny-level
approx_constant in the frozen halstead float math replaced with a
justified module allow; curated pedantic passes (let-else, use_self,
sort_by_key, clone_from, or-patterns, must_use/const fn) across all six
groups; to_map hex encoding via fmt::Write.

Provenance reframe: ~1369 Go-port mentions and ~295 .go file:line
citations removed in cf-commands alone; load-bearing quirks reworded as
report/CLI compatibility contract pinned by rust/tests/compat. Kept by
policy: cobra (the CLI surface contract), reference-test citations,
go-echarts upstream field-order citations, measured-nondeterminism
notes ('the reference binary').

Final gate: workspace build zero warnings (full 78-crate recompile);
2288/2288 tests; smoke matrix clean run 174 cells -> 173 green + the
known cohesion[json] sampling flake (PASS at n-go 7); residue grep now
zero outside deliberate reference-test citations. The sentiment
average_sentiment 1-ulp oracle flake was proven pre-existing (identical
bytes from the unrefactored crate; reference sums float32 in random map
order).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…-analyzer runs

Multi-analyzer runs ('*', sets) previously executed every analyzer as an
independent walk: the five parse-heavy history analyzers (imports,
quality, sentiment, shotness, typos) each re-parsed the same changed
blobs commit-by-commit, serially — sum-of-walks wall time.

- uast_walk.rs: one parallel walk over the commit window computing each
  commit's tree diff ONCE and parsing each (file, blob-hash) at most
  once into a per-commit cache whose outcomes preserve the gate
  distinctions analyzers branch on (Skipped / Failed-with-blob /
  Parsed). The five walks' per-commit closure bodies are extracted into
  product functions shared by BOTH the direct single-analyzer walks and
  the shared walk — byte identity by shared code, not re-verification.
  Results are memoized process-wide, which also dedupes the hidden
  re-walks (anomaly's quality/sentiment store enrichment).
- run_concurrent (cap 4, ordered results) overlaps the remaining
  independent analyzers in render_combined, run_pipeline, the static
  plot phase (7 single-threaded walks now concurrent), and the history
  plot phase; pages/envelopes are still written in the deterministic
  order. cf-plotpage Renderable gains a Send bound.

Gates: zero-warning build; 81 lib tests; oracle PASS on the five
history json cells, history/* and * set cells, and the '*' plot
file-set cell. kubernetes '--analyzers * --format plot --limit 200':
5m11s -> 1m48s wall (~2.9x).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…base

The project is now Rust-only. Removed the entire Go implementation and its
build/tooling:
- Go source: cmd/, internal/, pkg/, go.mod, go.sum (726 .go files)
- Go-dev tooling: tools/ (codegen), tests/ (e2e), scripts/, examples/
- Go build/packaging/CI: Makefile, Dockerfile, entrypoint.sh, action.yml,
  .golangci.yml, .github/workflows/{ci,lint,action-test}.yml

Kept, deliberately:
- rust/ — the implementation and its workspace.
- build/bin/{codefang,uast} — the prebuilt Go binaries are retained as the
  FROZEN ORACLE for the differential parity gate (rust/tests/compat). The
  gate still runs against the recorded reference behavior; it can no longer
  be rebuilt from source, which is the intended tradeoff.
- specs/, third_party/libgit2 (Rust git2 dependency), docs site
  (docs/mkdocs.yml/site/web), dev/ ops configs, and generic project files
  (LICENSE, README, CHANGELOG, governance, THIRD_PARTY_NOTICES, cspell).

Verified post-removal: cargo build --release -p codefang clean; the
differential oracle still passes (history/devs, static/complexity rc 0)
driven by the frozen build/bin/codefang. The cf-pathfilter build script
and cf-goyaml differential tests use the SYSTEM go toolchain + global
module cache (upstream enry/yaml.v3), not this repo's deleted source, so
they are unaffected.

1067 tracked files removed (~560k lines).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…t-only

Workflow-driven docs overhaul (9 crate-doc groups + a docs-site group),
gated by doctests + the byte-identity smoke matrix.

Runnable / test-backed:
- 256 doctests now pass (up from ~76): 7 text/ignore/no_run fences
  converted to runnable doctests (tempdir/fixture rewrites where needed),
  183 doctests/unit tests added pinning previously-untested documented
  contracts across the workspace.
- New rust/tests/doc-examples crate: a harness that extracts every CLI
  example from README + docs and executes it against the real binary on
  the hercules fixture, asserting success (markdown_examples_run).

Bugs fixed (12): broken intra-doc links (non-existent/private items in
cf-uast*, cf-anomaly, cf-couples, cf-shotness, cf-analyze); a README
example with an undefined binding (cf-storage); a doctest using a
re-export path (cf-analyze); and stale CLI docs -- a documented
"codefang mcp serve" subcommand that does not exist (MCP lives in the
cf-mcp crate), and the dropped short "-f" format flag (only --format
exists); plus the sentiment lexicon regen block (deleted Go tools/lexgen
-> vendored cf-sentiment-lexicons/data/*.tsv + build.rs).

Project docs (Rust-only): README rewritten (cargo build, the two
binaries, how the frozen-oracle parity gate works); the 3 ADRs updated
(ADR-0003 libgit2-via-cgo marked superseded -> Rust git2 / vendored
third_party/libgit2 via build.rs); mkdocs nav 0 dangling.

Gate: workspace build zero warnings; 256 doctests + 2463 release tests +
the doc-example harness all green; smoke matrix parity contract intact.

Recovery note: the docs-site agent deleted build/ (the gitignored frozen
oracle binaries) while removing Go references; rebuilt build/bin/codefang
and uast from the Go source in git history (141262f) against the vendored
libgit2, re-verified the oracle, then re-removed the Go source.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
…ayout)

The `rust/` nesting only existed because the Go implementation used to own
the repo root; with Go gone, the workspace now follows the standard Rust
convention (rust-analyzer / ripgrep / wasmtime / cargo): the workspace
Cargo.toml at the repo root, member crates under crates/, binaries under
bins/, integration tests under tests/, target/ at root.

Moves (git mv, ~898 files): rust/Cargo.toml -> Cargo.toml, rust/Cargo.lock,
rust/rust-toolchain.toml, rust/crates -> crates, rust/bins -> bins,
rust/tests -> tests; rust/target -> target on disk (gitignored cache).

Path references updated across 142 tracked files: the differential harness
(oracle.py RU_DIR, parity_gate.sh, cli_surface/selftest/extract_surface
RU_DIR/RU_BIN, mutation_self_test ROOT), the doc-examples repo_root() walk
(now pops two levels, not three), and the cosmetic `rust/tests/compat`
provenance notes in crate docs (-> tests/compat). The frozen oracle stays
at build/bin; GO_DIR unchanged.

Incidental cleanup: removed the orphaned rust/cf-persist (a stray
duplicate of crates/cf-persist, never a workspace member) and the stale
rust/README.md "scaffold" note; merged rust/.gitignore (/target etc.)
into the root .gitignore.

The Rust build is unaffected by the move (git2 self-vendors libgit2; the
third_party/libgit2 mentions are explanatory comments, not a path dep).

Verified from the new root: cargo build clean; 256 doctests +
doc-examples harness + oracle cells (history/devs, static/complexity) all
green; parity contract intact.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
SPEC uastmap-rust-macros 8.6 (the deferred post-parity optimization). The
lowering walker paid per-mapped-node overhead that is constant after init:
- find_mapping_rule cloned a full Rule (String name/pattern, Vec roles,
  Vec children, Option<BTreeMap> props) and re-ran resolve_inheritance on
  every mapped node;
- the capture/prop path called pattern_matcher.compile_and_cache per node
  (a mutex lock + HashMap<String> lookup) just to fetch an already-compiled
  query.

Now resolved once per language at init: InitState holds
Vec<ResolvedRule { rule, query: Option<Arc<Query>> }> (inheritance merged
up front, each non-empty pattern compiled to an Arc<Query>); the lowering
borrows &[ResolvedRule] and reads the pre-compiled query directly. The
per-node Rule clone and the per-node query-cache mutex/hashmap lookup are
gone from the hot path.

Byte-identical by construction (same rules, same queries, same match
semantics; CURSOR_THRESHOLD alias handling untouched). Compile-failure
parity preserved: a pattern that previously failed lazily now stores
None at init and falls through identically (init never newly errors).

Verified: cargo build zero warnings; cf-uast + cf-uast-mapping tests +
doctests green; a 31-cell adversarial byte-identity sweep all PASS — the
5 UAST history analyzers x {hercules,ioq3,kubernetes}, the 7 static UAST
analyzers x {hercules,ioq3}, uast-parse corpus cells, and the star plot.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
The repo is Rust-only now, but the CI on main was still Go-based
(go test ./..., golangci-lint, Docker action self-test). Replace ci.yml
with a Rust pipeline — submodule checkout for the vendored libgit2,
the toolchain pinned by rust-toolchain.toml, then cargo fmt/clippy/test.
The branch already deletes the Go lint.yml and action-test.yml, so the
merge retires the whole Go CI surface.

Also gitignore the compat-harness run artifacts under tests/compat/results/.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
…yground

Analysis runs entirely off the native cf-uast-mappings tables (the mapping
system of record), so the legacy `.uastmap` DSL text and the tooling that
edited it had no remaining consumer. Removed:

  * crates/cf-uast-uastmaps — the 68 embedded `.uastmap` files + embed crate
  * crates/cf-uast-lsp      — the `.uastmap`/query-DSL language server
  * bins/uast `server` + `lsp` subcommands and src/server.rs
  * web/                    — the Vite/React parse/query/mapping playground
  * cf-uast DSL-text methods (get_embedded_mappings*/get_mapping) + MappingInfo
  * cf-uast-mappings equality_gate + cf-uast-mapping DSL-corpus vocab test
    (both validated the now-complete DSL->native cutover)
  * deps: tiny_http, tokio (uast)

uast drops from 11 to 9 subcommands — a deliberate divergence from the frozen
Go oracle's CLI surface. The cli-surface parity gate records it via an
INTENTIONALLY_REMOVED allowlist and stays GREEN; the report-output oracle is
untouched. Docs (cli-reference, architecture/uast) updated.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The tree had never been run through the pinned rustfmt (1.94.0); `cargo fmt
--all --check` flagged ~1.1k diff sites across 263 files. Apply `cargo fmt
--all` workspace-wide — purely cosmetic (indentation, import ordering, line
wrapping); no logic, string literals, embedded data, or comment contents
changed, so report bytes and the parity gates are unaffected.

CI: the Format-check step is now a hard gate (the tree is rustfmt-clean).
Clippy stays advisory until its pre-existing debt is cleared.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
The Rust rewrite is an independent history that supersedes the Go
implementation. This merge records origin/main as a parent so the
rewrite can land on main via PR, while keeping the rewrite's tree
wholesale (the Go tree is not carried over).
@cursor

cursor Bot commented Jul 7, 2026

Copy link
Copy Markdown

Bugbot is not enabled for your account, so this pull request was not reviewed.

Enable Bugbot in the Cursor dashboard to get automatic reviews on future PRs.

- Track the vendored enry *.tsv tables that cf-langpath embeds via
  include_str!; the blanket *.tsv ignore rule kept them out of the repo
  so the Test job failed to compile cf-langpath on CI.
- Drop $-prefixed command lines in README.md and site/index.md console
  blocks to satisfy markdownlint MD014 (no output shown).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
@cursor

cursor Bot commented Jul 7, 2026

Copy link
Copy Markdown

Bugbot is not enabled for your account, so this pull request was not reviewed.

Enable Bugbot in the Cursor dashboard to get automatic reviews on future PRs.

The Test job failed compiling cf-uast because crates/cf-uast/vendor/ (the
tree-sitter grammar sources compiled by build.rs) was excluded by a stale
Go-era 'vendor' ignore rule; anchor that rule to /vendor.

Also un-ignore the *.tsv data the build and tests consume but the blanket
*.tsv rule dropped: cf-sentiment-lexicons/data (build.rs lexicon tables +
32 language lexicons) and cf-gojson/tests/oracle_data fixtures.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
@cursor

cursor Bot commented Jul 7, 2026

Copy link
Copy Markdown

Bugbot is not enabled for your account, so this pull request was not reviewed.

Enable Bugbot in the Cursor dashboard to get automatic reviews on future PRs.

ensure_built() shelled out to `cargo build` in repo_root()/rust — a path
left over from when the crates lived under rust/ during the migration. That
dir no longer exists, so the fallback build failed and markdown_examples_run
panicked with 'codefang binary should build'. Build from the workspace root.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
@cursor

cursor Bot commented Jul 7, 2026

Copy link
Copy Markdown

Bugbot is not enabled for your account, so this pull request was not reviewed.

Enable Bugbot in the Cursor dashboard to get automatic reviews on future PRs.

@dmytrogajewski
dmytrogajewski merged commit b99c300 into main Jul 7, 2026
7 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants