Repository navigation
Rewrite codefang in Rust (supersede Go implementation) - #20
Merged
Merged
Conversation
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.
Feature/fixlint
- 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
feat(algo): added myers algo
…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).
|
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>
|
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>
|
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>
|
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. |
This was referenced Jul 23, 2026
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
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/mainis merged into the rewrite tip using-s ours, somainis 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 thefeature/rust-rewritetip (3cbb66e).What changes
Cargo,crates/,bins/)..uastmapDSL, dev server, LSP, and web playground removed.Heads-up for reviewers
main(analyzer stabilizations, filestats, config, docs — Sentiment analyzer stabilization #7–docs: comprehensive documentation audit and enhancement #19) are superseded and their content will no longer be present onmain. This is intentional.-s oursagainst unrelated histories, so GitHub should be able to merge cleanly.🤖 Generated with Claude Code