reshape: parser/ (subtree) + graph/ + bin/axiom-graph. One repository for the whole pipeline

.gitignore

@@ -85,7 +85,7 @@ call-chain-*.csv
 # tables, and the raw per-language relations it was built from.
 graph.sqlite
 graph.sqlite-journal
-graph/
+csv/
 raw/
 client-ir/
 library-ir/
@@ -227,7 +227,7 @@ $RECYCLE.BIN/
 # checks the property beats a pattern list that tries to anticipate it.
 
 # ── Java engine test suite: per-run work dirs and the generated JDK index ─────
-test/java/.work/
+graph/test/java/.work/
 
 # Python bytecode from the test tools
 __pycache__/
@@ -236,5 +236,8 @@ __pycache__/
 # fixture harness work directories (generated per run). The plain `.work/` is the one
 # run-tests.sh itself uses; the `.work-*` variants are the fixtures'. Only the latter was
 # listed, so every run of the TypeScript suite left an untracked directory behind.
-test/typescript/.work/
-test/typescript/.work-*/
+graph/test/typescript/.work/
+graph/test/typescript/.work-*/
+
+# the one-command pipeline keeps its IR and scratch here
+.intermediate/

LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026, AxiomCode Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

README.md

@@ -127,26 +127,36 @@ receiver is a lambda parameter. Restricted to files of 1,000 lines or more, d1 r
 ## Run
 
 ```bash
-npm install && npm run build
-
-# 1. extract a relational IR from source (separate parser package)
-node <parser>/dist/index.js <src-dir> <slug> false <IR-dir>
-
-# 2. solve
-bash src/pipeline/run-souffle.sh \
-     --language java \                        # java | typescript | python
-     --client-ir <IR-dir> \
-     --library <platform-ir>[,<lib-ir>...] \  # platform library + the project's real dependencies
-     --intermediate <scratch> --output <out>
+npm install && npm run build            # builds the parser and the engine (Node ≥ 22.5)
+
+bin/axiomcode all --src <project-dir> --out <out-dir>          # source → <out-dir>/<lang>/graph.sqlite, per language found
+#                 --language java | typescript | python    restrict to one (the parser emits every language it finds)
+#                 --version V                              stamp the IR (default: the source's git commit, else v1.0.0)
+#                 --exclude-tests                          leave test code out (default: included)
+#                 --library <platform-ir>[,<lib-ir>...]    the platform library and real dependencies, when you have their IR
+#                 --debug                                  also write csv/*.csv and keep raw/
+
+bin/axiomcode parser <src-dir> <ir-dir>                                     # the two stages separately:
+bin/axiomcode engine --language java --client-ir <ir-dir>/java --out <out-dir>   #   IR is written per language, <ir-dir>/<lang>/
+bin/axiomcode test [java|typescript|python|parser|all]
 ```
 
-**Outputs — the same in every language** ([`src/bundle/SCHEMA.md`](src/bundle/SCHEMA.md))
+`bin/axiomcode` is the whole pipeline as subcommands: the parser (`parser/`) extracts a relational IR
+from the source — every language it finds, in one pass — the engine (`graph/`) solves each language
+separately, and `<out-dir>/<lang>/graph.sqlite` is the result (graphs are per language; a Java→TypeScript
+call is not an edge in either). **No
+Soufflé and no C++ compiler**: the rules compile to one self-contained executable, CI builds it for
+Linux (x86_64, arm64), macOS (arm64) and Windows on every merge to `main` and commits it under
+`binaries/<lang>/<platform>/`, so a checkout carries the engine for every platform. With `souffle`
+installed the engine compiles locally instead.
+
+**Outputs — the same in every language** ([`graph/bundle/SCHEMA.md`](graph/bundle/SCHEMA.md))
 
 ```
 <out>/
   graph.sqlite      the contract: core tables, the language's ext_* relations, and the schema as tables
 and only with --debug:
-  graph/<table>.csv the core tables as headered, tab-delimited text
+  csv/<table>.csv   the core tables as headered, tab-delimited text
   raw/              the per-language Soufflé relations, verbatim — engine-internal, not a contract
 ```
 
@@ -191,16 +201,37 @@ the omission is reported.
 ## Layout
 
 ```
-src/engine/projections/           IR → typed relations
-src/engine/containment/           ownership, type nesting
-src/engine/resolution/            type resolution, hierarchy, generics, virtual dispatch
-src/engine/expression-resolution/ call sites, callee resolution, overloads, lambdas
-src/engine/call-edge-generation/  call classes, chain edges, lambda dispatch
-src/souffle/                      relation declarations + export manifest
-src/pipeline/run-souffle.sh       fact staging, compile cache, stage↔solve loop, then the bundle stage
-src/bundle/                       the output contract: schema as data, per-language adapters, CSV + SQLite writers
+bin/axiomcode                     parser | engine | all | test — the pipeline as subcommands
+parser/                           the IR extractor (its own package; merged in with history)
+graph/                            the engine
+  <lang>/engine/projections/        IR → typed relations
+  <lang>/engine/containment/        ownership, type nesting
+  <lang>/engine/resolution/         type resolution, hierarchy, generics, virtual dispatch
+  <lang>/engine/expression-resolution/  call sites, callee resolution, overloads, lambdas
+  <lang>/engine/call-edge-generation/   call classes, chain edges, lambda dispatch
+  <lang>/souffle/                   relation declarations + export manifest
+  <lang>/templates/                 staging maps
+  pipeline/run-souffle.sh           fact staging, engine resolution (committed / compiled / fetched), stage↔solve loop, then the bundle stage
+  bundle/                           the output contract: schema as data (SCHEMA.md), per-language adapters, writers
+  test/<lang>/                      the engine's regression suites, torture harnesses, oracles (graph/test/tools: platform preflights)
+binaries/<lang>/<platform>/       CI-built engines, committed on merge (ENGINE_ID = the rules they were built from)
+```
+
+## Tests
+
+```bash
+bin/axiomcode test java              # the engine's Java suite; --oracle also scores against javac/javap ground truth
+bin/axiomcode test typescript        # --oracle scores against the TypeScript compiler
+bin/axiomcode test python            # --oracle scores against CPython bytecode and tracing
+bin/axiomcode test parser            # the parser's own suites (bin/axiomcode test = everything)
 ```
 
+Each suite parses its fixture cases with the parser in this repository (`AXIOM_PARSER` overrides),
+solves them, guards that no call site was dropped, and diffs the normalised edges against a
+golden. `--keep` retains the per-case work directories (`graph/test/<lang>/.work/<case>/out/graph.sqlite`
+is a real bundle to poke at); `--bless` regenerates goldens — review the diff. The torture
+harnesses (`graph/test/<lang>/torture/`) and the TypeScript corpus runner score real projects.
+
 ## Known limits
 
 Stated because a graph you can't trust the boundaries of isn't useful:
@@ -214,3 +245,7 @@ Stated because a graph you can't trust the boundaries of isn't useful:
 * **Function values in parameters or collections** are not tracked (fields and locals are).
 * **Reflection** is out of scope by construction, and is reported as `ambiguous_unknown` rather than
   silently omitted.
+
+## License
+
+[Functional Source License 1.1, Apache 2.0 Future License](LICENSE.md) (FSL-1.1-Apache-2.0) — Copyright 2026, AxiomCode Inc.