Code graph and memory for your coding agents, in one Rust program. For Claude Code, Codex, Cursor and any MCP client.
Graphicle graph engine
The Graphicle graph engine is a native Rust port of Graphify 0.9.95 (see
NOTICE), pinned to the release tag
92741d162b2094ffc2fed58cfbd8ee823e9da62c. The application includes the extraction
pipeline, CLI, incremental updates, watcher, MCP server, hooks, assistant
installer, exports and public library API. Python is used only for development
comparisons; native operations do not fall back to the Python application.
The port was made from 0.9.77, and the eleven releases 0.9.78 to 0.9.88 were
ported for 0.1.0. Together they decode source files that are not UTF-8
(UTF-16 or UTF-32 with a byte-order mark exactly, anything else as cp1252 or
latin-1, with a warning naming the file), write graph.json on one line with
its schema and writer versions, make query, path and explain exit 3
when a name is ambiguous and 4 when nothing matches (explain --all lists
every connection, query --seed starts from given nodes), read a project's
.graphiclerc (file extensions mapped to languages), extract EJS templates,
resolve more calls (Python typed receivers, inherited self/super calls
and property reads, C# and Java receiver chains, PHP static/self/parent
calls), weight AMBIGUOUS edges in clustering (GRAPHICLE_AMBIGUOUS_SCALE)
and honour git's user-wide excludes. File extractions cached by an earlier
build are made again once (cache schema 8). Graphify Cloud's call to action
is not ported.
The three releases 0.9.89 to 0.9.91 were ported for 0.1.1. They bind member
calls whose receiver type is declared in another repository (Go, PHP,
TypeScript and JavaScript, Kotlin, Objective-C) on merge-graphs and
global add, fold a Go package type declared across files into one node,
type C# foreach variables and keep C# names that differ only by _ or case
apart, stop generic type parameters from becoming stub nodes, extract
Objective-C NS_ENUM and NS_OPTIONS, link an interface member to every
implementer, read Jinja templates as documents, install a post-merge hook,
add a Pi guard extension and send Ollama requests to /api/chat. File
extractions cached by an earlier build are made again once (cache schema 9).
The four releases 0.9.92 to 0.9.95 are ported for 0.1.7. They extract YAML
configuration as code (a node per key, with contains edges; data YAML is
declined by design), make each C# overload a node of its own with calls bound
by argument count, add type aliases and declarations (Python, Go, Rust, C++,
Kotlin, C#, Swift, Dart), keep members and declarations that differ only by
_, $, # or case apart (JavaScript and TypeScript, Python, Go, Rust),
read T-SQL procedures and GO batches, resolve Solidity inherited and super
calls, keep parallel edges in graph.json (multigraph: true), let
GRAPHICLE_BACKEND choose or turn off the LLM provider, add a post-rewrite
hook, refuse URLs with credentials or bad ports and block multicast addresses.
File extractions cached by an earlier build are made again once (cache
schema 10). CHANGELOG.md lists every change.
0.9.77 keeps an edge's stored direction wherever graph.json is read back, and adds enum and context-bound structure to several extractors. Changes in that release tag:
- Loading graph.json stamps each link's stored endpoints as
_src/_tgt, so HTML, Cypher, Neo4j and FalkorDB pushes, Obsidian canvas, the watcher's HTML refresh and the git merge driver drawcaller -> calleeeven when the node list puts the callee first (#4066). - With deduplication off (
--no-dedup,dedup=Falseinbuild,build_mergeandbuild_from_json), semantic nodes that share a file and a label keep their own ids and edges; an AST twin stays canonical. - An incremental scan of a subfolder ignores manifest entries recorded for other folders instead of reporting them as deleted or excluded (#3785).
- JavaScript members assigned onto an exported object (CommonJS or ESM) become nodes with their calls (#3778).
- PHP
$this->m()andself::m()calls whose name matches a language construct resolve within the caller's own class, never to another class or a free function. - A zero-byte file keeps its node but has no source location (#4041).
- Scala context bounds (
[T: Ordering]) record type references (#4080). - Objective-C enums (plain or behind a
typedef) become types withcase_ofmembers, without phantom nodes for anonymous or bodyless enums; Solidity enum values and PowerShell enum members switch fromcontainstocase_of. - PowerShell
$this.M()and[Type]::M()calls resolve to methods, and a member call no longer binds to a free function of the same name (#3992). - A SQL trigger
executesthe routine it calls when that routine is defined in the scanned sources; an undefined routine gets no edge. - Anonymous Rust
const _items no longer produce a_node that replaced the file node. - Astro masking ends each script with a line separator, so a trailing
//comment cannot hide the next script; byte offsets and line numbers are unchanged (#4072). - The skill runbook now runs its merge step when every semantic chunk is cached. The native executable needs no counterpart: it merges cached semantic nodes itself.
- New upstream tests pin behaviour the port already had: C++ union member
functions, C#
this?.M(), shellsourceforms as imports, cross-language JVM inheritance, Kotlin annotation class literals, Pascal valued enum literals, a cross-drive partial-extraction warning andmerge-graphs --previouskeeping removed nodes removed.
0.9.76 adds type structure for Zig tagged-union variants, C++ union
specifiers, VB.NET enum members (now case_of rather than contains) and
Pascal enumerated types, and closes a git-hook installer path escape
(CWE-22). Changes in the release tag:
hook installrefuses acore.hooksPaththat resolves outside the repository (both sides resolved, symlink-safe) and falls back to the in-repo.git/hooks; in-repo custom hook paths, linked worktrees and submodules still work.- JSON Schema files (
$schemaplus$defs,definitionsor$id) are no longer walked as config manifests. - Elixir
import/usecall scoping is per module rather than per file. - A
module.func()call to a plainly imported external Python module records acallsedge to that module; shadowed receivers and non-unique bindings fail closed. - Svelte files feed only their
<script>blocks to the AST pass, with line numbers preserved, and PHP language constructs (isset,empty,list,eval, …) no longer bind to a user method of the same name. - An unresolved base class whose only same-named definition is in another language stays unresolved.
- Dedup keeps unstamped document nodes with the same heading in different files apart; same-file twins still merge.
pathand the MCPshortest_pathtool resolve apath::symbolor raw node id exactly before fuzzy scoring, and refuse an ambiguous endpoint.- Cross-repo resolver confidence scores snap to the canonical INFERRED rubric.
- Scans skip the installed skill folders and whole-written rule/hook files (the engine's own and upstream's).
- Suggested questions are spread across signal types round-robin.
- The PyPI project-URL change has no counterpart in the port.
0.9.75 binds self/this/super member calls to the caller's own class
chain in Python, JavaScript/TypeScript, Swift and Ruby, and lifts
single-implementer interface dispatch into a language-agnostic core that also
dispatches a Swift protocol requirement to its sole conformer. It extracts Zig
error sets, PHP enum cases, Elixir defmacro/defguard definitions, Rust
macro_rules! with local invocations, Scala file-scope annotations, type-alias
right-hand sides and context bounds, resolves Elixir calls through
import/use, records bash invokes edges through non-shell interpreters
and links Dart part files and every configurable-import branch. It keeps
recursive calls through C# partial-class merges, routes path through
contains edges, rebinds the AST cache's stat index per cache root, restores
merge-graphs --previous communities by node id, keeps parallel edges in
cluster-only/label, merges Ollama num_ctx into extra_body, names the
effective graph.json in the hook guard, refuses a dedup-shrunk overwrite
without --allow-dedup-shrink, and warns once about a parsed code file with
no symbols.
0.9.74 captures Ruby paren-less self-sends, TypeScript abstract method
signatures, Scala deferred methods, C++ out-of-line member declarations as
methods, Kotlin annotation class literals, Lua colon-method calls, Erlang
local fun references and C# null-conditional calls. It resolves Rust forward
references and filters Rust prelude types (tuple-struct construction becomes a
references edge), resolves dotted wikilinks and constructor calls to
same-file annotation stubs, checks real containment in the CLI
output-directory guard, prefers a workspace package's source entry over its
built dist, detects Verilog .vh headers and keys carried incremental
hyperedges by (id, source_file).
0.9.73 extracts enum members as nodes with case_of edges to their enum in
Rust, Zig, C++ and Scala 3, and resolves Java calls to inherited methods and
super.method() to the nearest declaring ancestor (an unknown or ambiguous
ancestor still fails closed). Changes in the release tag:
- Solidity file-level free functions and their calls are extracted, and VB.NET type- and module-qualified calls resolve to the target method.
- Astro files feed only their frontmatter and
<script>blocks to the AST pass, with line numbers preserved. - The surprising-connections cross-repo bonus matches the reason it prints,
and under
--exclude-hubsa node whose only neighbours are excluded hubs stays with its hub's community. --pushto Neo4j or FalkorDB indexes each label'sidbefore the upserts.- Community labeling keeps the labels it already named when a nested retry fails to parse.
hook statusreports hooks written by an older release as out of date.- A virtual-workspace
Cargo.toml([workspace]without[package]) is skipped by design rather than reported as producing no nodes. uninstallkeeps a symlinked instructions file (CLAUDE.mdetc.) and strips only the graphicle section;installwrites through the link as before (the port prints no per-file lines, so upstream's real-target wording has no counterpart).- Semantic extraction warns once when a file exceeds the 20,000-character cap.
0.9.72 keeps docx tables in their document position and reads tracked
insertions, content controls and text boxes, reserves index in the wiki
for its catalog, counts only structural nodes in the report's community
listings, and shows the logo banner on --help (upstream's hosted-platform
link is not carried over, as with install). Changes in the release tag:
- SQL DDL before a
DO $$ … $$block is extracted. - Razor reads
@functionsblocks and Blade links@extendslayouts. - A nested definition is no longer taken for an imported module.
graph.html's Node Info panel shows each node's real fields, and member counts in the aggregated view.- The CLI refreshes installed skills that an upgrade left behind
(
GRAPHICLE_NO_AUTO_REFRESH=1turns this off).
0.9.71 extracts SQL CREATE TRIGGER statements (linked to the table they
fire on, including procedural bodies the grammar rejects) and Groovy enums,
recognises namespace-qualified R class constructors (R6::R6Class) and R6
self$/private$ calls, keeps foreign-platform manifest keys in their own
path syntax, and rewrites only the host of an x.com URL for oEmbed. 0.9.70
closed the capital-F Fortran cpp arbitrary-file-read advisory
(GHSA-pcc4-rvhr-2pr8), hardened Aider/Devin watch instructions and Terraform
secret redaction, and added cross-platform rebuild locking, C# named-tuple
filtering, JSX component call edges and nested-namespace Python import
resolution.
The port covers every application module of the pinned release; Graphify's
original Python test files are kept as development references, and fixtures,
documentation and licenses retain their original formats. The comparison
checks run Graphify's own tests against the engine and compare its results
with the pinned release. Against Graphify 0.9.88, on 13 October 2026, every
application module had a passing receipt from them; on 14 October they were
widened to run more of the upstream tests/test_*.py files. Against 0.9.91
they ran on Linux on 15 October 2026, where the modules whose checks need
nothing that host lacks have a passing receipt. Against 0.9.95, on 24 October
2026 on Linux, every check passed and every application module has a passing
receipt. The repository's docs/benchmarks.md gives their results and
limits, its docs/evidence/upstream-tests-known-differences.md lists the
upstream tests that fail against the engine, with the reason for each, and its
docs/evidence/upstream-tests-not-run.md lists the test files the checks do
not run, with the reason for each.
migration/STATUS.md, AUDIT.json
and the file ledger record the 24 October run against
0.9.95: the ledger lists every file of the pinned Graphify 0.9.95 archive with
its SHA-256 and marks each of the 96 application modules verified. The
repository's docs/evidence/ folder summarizes the 13 October qualification
against 0.9.88 and the 14 October run of the widened checks.
Build and run
From the repository root, with Rust 1.94.1 or newer:
(cd crates/graphicle-graph && cargo build --locked --release -p graphicle-graph)
crates/graphicle-graph/target/release/graphicle-graph --help
crates/graphicle-graph/target/release/graphicle-graph extract /path/to/project --code-only
crates/graphicle-graph/target/release/graphicle-graph update /path/to/project
crates/graphicle-graph/target/release/graphicle-graph watch /path/to/project
crates/graphicle-graph/target/release/graphicle-graph serve /path/to/graph.json
# or install the executable:
cargo install --locked --path crates/graphicle-graph/cli
An installed Graphicle puts this executable beside its graphicle program,
and graphicle graph <command> runs it with the same arguments:
graphicle graph update /path/to/project is
graphicle-graph update /path/to/project, and graphicle graph alone prints
the engine's help.
The executable is the workspace package cli/ (graphicle-graph). It pins
the tree-sitter 0.25.10 runtime, the one Python Graphify parses with, so
cargo install gets that runtime with or without the lock file. The library
(graphicle) keeps accepting newer runtimes for crates that embed it.
serve defaults to MCP stdio; --transport streamable-http selects HTTP with
host, port, API-key, session and path options. install and uninstall
configure supported assistant platforms. --help lists the commands that
come from Graphify 0.9.95, including labeling, query and navigation, global
graphs, merge workflows and exports; the additions below are documented here
and in the repository's README.
Features
The default Cargo features enable Chinese tokenization, the precise
JavaScript/TypeScript pass (precise-js) and the ten long-tail grammars
(grammars-extra). Three features are opt-in, so a default build stays lean:
bedrock: the Amazon Bedrock backend for semantic extraction (the AWS SDK).transcription: native Whisper transcription (whisper.cpp, which needs CMake to build, and model weights and FFmpeg to run).postgres: the libpq catalog client (extract --postgres DSN).
Without bedrock and transcription, the bedrock backend and transcription
report that the build omits them. The info operation reports the enabled
build features. External integrations still need their own credentials and
services: URL media download needs yt-dlp, and the optional Claude CLI backend
needs that program installed.
--no-default-features --features precise-js builds the core engine: no
Bedrock SDK, jieba or whisper.cpp, and the ten long-tail grammars (Verilog,
OCaml, Fortran, Julia, Objective-C, Elixir, PowerShell, Zig, DM, Common Lisp)
load from grammar packs instead of being linked. tools/build_grammar_packs.py --out DIR compiles the packs from the same pinned grammar crates, and
graphicle-graph grammars shows where each grammar comes from. Packs are found
through GRAPHICLE_GRAMMAR_DIR, ~/.graphicle-graph/grammars or grammars/
next to the binary. A pack whose grammar has different node-kind or
parse-state counts is refused. Loading a pack runs its code, so only install
packs you built or trust. A pack is checked before it is loaded: its SHA-256
must be one the binary was built with (GRAPHICLE_PACK_DIGESTS="zig=<sha256>,..."
at build time) or, when it has none, the one tools/build_grammar_packs.py
recorded in the manifest.json next to it. The manifest check catches a
corrupted or swapped pack, not a rewritten manifest;
GRAPHICLE_GRAMMAR_UNVERIFIED=1 skips it.
Beyond 0.9.95
The parity claim rests on the comparison checks: they compare graph content
with the pinned upstream reference, with the reviewed upstream fixes of
REVIEW.md applied to it, and they run
the reference's own tests against the engine (see above; the repository's
docs/benchmarks.md has their results). That page's
parity section also
records a known difference of the checked build: on gohugoio/hugo v0.167.0,
its graph after graphicle graph update differed from Graphify 0.9.88's in
the stored front matter of one Markdown page, because its YAML parser
rejected a list that the page closes at the start of a line; from 0.1.3 the
engine reads that list as YAML, and the comparison has not been run again
since. Folder, environment-variable,
command and installed-file names follow a documented translation table
(tools/naming.py), which the checks apply. The first four items below are
on by default: the first two change no output, and the next two change only
what upstream reads differently or refuses. The rest are opt-in, and the
parity claim does not cover them.
Saved query snapshots.
query,explain,path,affected,god-nodesand the MCP server save the loaded graph and its search index to.graphicle/cache/query/*.snap. Later loads read the snapshot whilegraph.jsonis unchanged (same size, modification time and inode) and the binary is the same build; anything else falls back tograph.json. Answers are identical either way.updateand watch rebuilds write the snapshot as they finish; a coldextractdoes not.GRAPHICLE_QUERY_SNAPSHOT=0turns snapshots off, andGRAPHICLE_QUERY_TIMING=1prints the phases.Syntax facts kept across runs. Cross-file resolution reads each file's imports, bindings and member calls. For Python, Java and PHP these facts are saved under
.graphicle/cache/syntax/beside the AST cache entry they belong to, so anupdateor a warm run replays them instead of parsing unchanged files again. TypeScript's come from the extractor's own parse. The graph is the same either way.Older graph files read like newer ones. A graph.json written before Graphify 0.9.92 can hold parallel links under
multigraph: false. Upstream repairs that only in its MCP server; here every reader that builds a graph from a saved graph.json does (affected,query,explain,path,merge-graphs,merge-driver, everyexportformat,benchmark,prs, the global graph and the memory library's operations), so the same links read the same whichever release wrote the file.The engine's own large graphs. The 512 MiB graph.json read cap guards against a file from elsewhere. A larger graph.json the engine writes itself is recorded in
~/.graphicle-graph/graph-stamps(its path, size, modification time and file identity), andupdate,watch,serve,query,explain,path,merge-graphs,cluster-onlyandlabelread it whatever its size while it is unchanged, unlessGRAPHICLE_MAX_GRAPH_BYTESis set. Upstream refuses it, so on a project such as kubernetes (graph.json over 512 MiB) every update after the first would fail. (The rebuild also reads back its own temporary graph without the cap, as upstream does; before, that made even the first update fail.) Over the cap, a graph.json a repository ships or another machine wrote is still refused, and global-graph inputs,prs,benchmark, the exports and the incremental merge ofextractkeep the plain cap. A graph.json over the cap that an earlier release wrote has no record either: it is refused until it is rebuilt once, withGRAPHICLE_MAX_GRAPH_BYTES=<N>GB graphicle-graph extract --force <project>(plus--code-onlywithout an LLM backend), and the error says so.Commands answered by a running server.
serve --socket PATHkeeps graphs loaded. WithGRAPHICLE_SOCKET=PATHset,query,explain,path,affected,god-nodesandretrieveask it and print exactly what they would print locally.- The socket is private to its user: mode 0600, and the peer's uid is checked. There is no other authentication, so keep the path in a directory only you can write.
- The server declines when the engine's own
GRAPHICLE_*settings (an explicit list; other programs'GRAPHICLE_*variables are never sent) orHOMEdiffer from the client's, and the command then runs locally. GRAPHICLE_SOCKET_DEBUG=1says why a command ran locally.GRAPHICLE_SOCKET_TIMEOUT(seconds, default 120) bounds a request.
Live watch.
serve <graph.json> --watch [--root DIR]keeps the graph resident, watches the project with FSEvents/inotify and applies each saved file to the in-memory graph and search index. The exact incremental rebuild of.graphicle/follows in the background and is reloaded when it lands, sograph.jsonstays the source of truth.GRAPHICLE_WATCH_TIMING=1prints the phases of every update;GRAPHICLE_PROFILE=1onextract,updateandwatchadds wall time, CPU time, cores used and memory per stage, pass and resolver on stderr.Precise call resolution.
--precise(orGRAPHICLE_PRECISE=1) onextract,update,watchandserve --watchadds call edges that name matching, the upstream default, misses:- Python: a PyCG-style points-to analysis. It covers lexical scopes,
imports (including
from m import *re-exports), parameters, returns, attributes, class hierarchy,super(), decorators and containers. - JavaScript/TypeScript: scope-resolved bindings from oxc and module
resolution through oxc_resolver (tsconfig
paths, packageexports, workspace links). It follows re-exports,this./super.methods, static calls,newand receivers typed by annotation or construction. - Any language with a SCIP index: call edges from the indexes named by
GRAPHICLE_SCIPor found at<root>/index.scip(scip-python, scip-typescript, scip-go andrust-analyzer scip, for Rust). - Dart: imports resolved to files.
Each added edge records how it was found in
resolution(points_to,super_call,oxc_binding,oxc_type,scip,dart_import) orreceiver_evidence, and every call edge gets anevidencelevel:name(name matching),binding(a resolved import, scope or points-to flow),type(the receiver's type or the class hierarchy),indexer(a SCIP index has the call) orruntime(seen in a trace named byGRAPHICLE_TRACE, the formatbench/accuracy/trace_calls.pywrites).--min-evidence LEVEL(orGRAPHICLE_MIN_EVIDENCE) onquery,explain,path,affected,retrieveandserveleaves out call edges below a level, trading recall for precision.GRAPHICLE_PRECISE_TIMING=1prints the phases.- Python: a PyCG-style points-to analysis. It covers lexical scopes,
imports (including
Documentation pages.
extract --docsextracts Markdown and reStructuredText pages without an LLM (Sphinx.txtsources too) and links their mentions of code to the single definition they name: Sphinx roles such as:func:, object directives, Markdown code spans, and reStructuredText literals shaped like code (a dotted path, a call or a CamelCase name). Bare-word literals are not linked: in Sphinx prose they are mostly parameters, settings and HTTP headers. The choice is kept forupdateandwatchin.graphicle/.graphicle_build.json(remove itsdocskey to stop). In a full extract--docsalso keeps those pages away from the LLM.HTTP routes.
extract --routesadds aroutenode per declared route (FastAPI and Flask decorators,add_api_route/add_url_rule, Djangopath()/re_path(), Express-styleapp.get("/p", handler)), ahandlesedge from each handler and anhttp_callsedge from each function that requests a literal path the route matches (test clients,requests/httpx,fetch,axios). Router mounts and supported prefix constants are followed across files; unknown prefixes stay explicit, and a route whose path comes from a variable is not found. These edges do not prove runtime reachability. Like--docs, the choice is kept forupdateandwatch(therouteskey).LLM cost estimate.
extract --dry-runreports how many files, LLM calls and input tokens a full extract would send, and the input price for--backend, without calling the LLM, writing a graph or saving--docs,--routesand--excludefor later builds (only the file-stat cache is written). Output tokens are not estimated.Agent retrieval.
retrieve "<question>" [--budget N] [--json]answers with cited source evidence (path:Lstart-Lend, what matched and why) within a token budget. Files rank by the BM25 of the whole file plus half the score of their best definitions (the name scoringqueryuses, BM25 over each definition, and one hop along call, reference and containment edges). Test files rank lower unless--include-testsis given.--json --explainadds the parts of every file's score. The same graph and question give the same answer on every run.serve --retrieval(orGRAPHICLE_RETRIEVAL=1) adds the same answer as the MCP toolretrieve_context(withinclude_tests).
Evaluation tools
bench/accuracy/oracle_eval.py scores calls edges against independent
oracles: the call edges in a SCIP index from a compiler-grade indexer, and the
calls observed while a test suite runs (trace_calls.py, recall only).
bench/accuracy/pycg_eval.py runs the PyCG micro-benchmark, and
bench/retrieval/localize.py checks whether retrieve puts a file that a
SWE-bench Lite fix changed among its first files. No results of these tools are
published with this release.
Native integration
The memory library (crates/graphicle-memory, the graphicle-memory crate)
links this engine, and its graph.* operations call it directly.
graphicle-graph --jsonl exposes the same JSON boundary without the prefix;
piped no-argument JSON lines remain supported for existing clients:
{"operation":"ids","values":["Große","src/session.py"],"parts":[["src","Session"]]}
Rust callers can use the public functions directly with borrowed graph
references and named options. Error/ErrorKind preserve typed failures and
underlying I/O, parser and provider causes. model::GraphDocument,
NodeRecord, EdgeRecord, NodeId and SourceSpan provide validated native
records and move attributes into the graph. The legacy NetworkX adapter
retains flexible IDs and metadata for compatibility. See
tests/public_api.rs.
Use dispatch_owned(request) or Graph::from_node_link_owned(document, "links")
when the parsed JSON can be consumed. The owned loading path moves attribute
maps and identifiers into the graph; borrowed callers can continue to use
dispatch(&request) and Graph::from_node_link(&document, "links").
JSON dispatch catches Rust unwinding panics. The shared JSON-lines transport bounds input and output at 64 MiB, drains oversized frames and treats closed output pipes as normal termination. These boundaries do not claim that every internal algorithm is panic-free.
Verification
The comparison suite binds every receipt to an immutable binary, the complete
Rust source set and the comparison tools. It needs the pinned Graphify 0.9.95
source that migration/FILES.json names (its archive and SHA-256), unpacked
under reference/, and a Python 3.12 environment in .reference-venv built
from tools/reference-requirements.txt and tools/comparison-requirements.txt.
From this folder:
.reference-venv/bin/python tools/verify_rust.py
.reference-venv/bin/python tools/qualify_all.py --profile release --jobs 2
.reference-venv/bin/python tools/record_qualification.py migration/qualification/run-TIMESTAMP/results.json
.reference-venv/bin/python tools/report_migration.py
verify_rust.py runs formatting, strict Clippy and the native tests of the
graph engine, the memory library and the runtime; the last two compile the
grammar pack's parser sources, which python3 ../graphicle/tools/prepare_parser_sources.py
prepares once. record_qualification.py requires a passing full suite and a
current receipt for every application module before it records completion.
HARDENING.md records the initial hardening and native
regressions, and the upstream review the
selected upstream fixes and remaining limitations, including the pinned Swift
grammar issue. Explicit oracle adaptations are hashed and recorded in
migration/upstream-review/adaptations.json, among them fixes upstream has not
merged (for example the Kotlin annotation crash on untyped class properties).
0.9.95 behaviour is the only behaviour, with no opt-out.
Notices
Original and dependency notices are retained in licenses/ and
NOTICE.md. The Python grammar is tree-sitter-python 0.25.0,
vendored in vendor/tree-sitter-python/ with one scanner fix from
tree-sitter-language-pack: its state serializer wrote one byte past its
1,024-byte buffer on a deeply indented file, and the engine aborted.