d365fo-agent-developer 0.6.0__tar.gz

d365fo_agent_developer-0.6.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Bru
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

d365fo_agent_developer-0.6.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: d365fo-agent-developer
+Version: 0.6.0
+Summary: Local D365 F&O knowledge toolkit: corpus indexing (SQLite FTS5), deterministic generation, and an MCP server that grounds coding agents (Claude Code, Codex) in real AOT facts.
+Author-email: David Bru <dbru@fiveforty.fr>
+License: MIT
+Project-URL: Homepage, https://github.com/dbru540/d365fo-agent
+Project-URL: Repository, https://github.com/dbru540/d365fo-agent
+Project-URL: Issues, https://github.com/dbru540/d365fo-agent/issues
+Keywords: dynamics-365,d365fo,x++,aot,mcp,model-context-protocol,claude,claude-code,codex,ai,code-generation,rag
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: graph
+Requires-Dist: graphify; extra == "graph"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Dynamic: license-file
+
+# d365fo-agent — D365 F&O X++ knowledge for Claude Code & Codex
+
+A local **MCP server** that gives an AI coding agent (Claude Code, Codex, any MCP host) a grounded
+**knowledge base of Dynamics 365 Finance & Operations X++** — so you can develop for D365 quickly
+**without re-feeding a whole repo for analysis every time**.
+
+It grounds the agent in real AOT facts: it verifies that a class/table/EDT/enum/entity actually
+exists (anti-hallucination), searches the corpus, walks extension/security relationships, serves an
+X++ engineering methodology, validates generated XML against learned per-type structure, scaffolds
+or deterministically generates artifacts, and (on a Windows D365 host) compiles with the real X++
+compiler.
+
+- **Pure Python standard library** — zero runtime dependencies, runs anywhere Python 3.11+ runs.
+- **Vendor-neutral** — Claude Code, Codex, Gemini CLI, or any MCP-speaking client over stdio.
+- The standard D365 corpus is the same for everyone, so it is indexed **once** and used as a
+  portable knowledge base; your own custom code is **optional**.
+
+## Install
+
+```bash
+pip install d365fo-agent-developer
+# or, isolated:  pipx install d365fo-agent-developer
+```
+
+This installs two commands: `d365fo-mcp` (the server) and `d365fo-agent` (the CLI).
+
+## Get the knowledge base (once)
+
+Pick one. Both produce a local index at `~/.d365fo-agent/d365fo.db` that the server uses by default.
+
+**A. Download the prebuilt standard-D365 index** (fastest, no D365 install needed):
+
+```bash
+d365fo-agent fetch-knowledge          # downloads + caches the standard knowledge index
+```
+
+**B. Build it from your own D365 dev box** (no download; uses metadata you already have):
+
+```bash
+d365fo-agent build-index \
+  --db ~/.d365fo-agent/d365fo.db \
+  --packages-root "C:/AOSService/PackagesLocalDirectory" \
+  --rebuild
+```
+
+> The methodology, default lint rules, and a default learned type-profile ship **inside** the
+> package, so validation and guidance work out of the box even before the index is built.
+
+## Wire it into your agent
+
+**Claude Code** — add to `.mcp.json` (project) or `~/.claude.json` (global):
+
+```json
+{
+  "mcpServers": {
+    "d365fo": { "command": "d365fo-mcp", "args": [] }
+  }
+}
+```
+
+…or one command: `claude mcp add d365fo d365fo-mcp`
+
+**Codex** — add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.d365fo]
+command = "d365fo-mcp"
+args = []
+```
+
+With no `--db`, the server uses the cached knowledge index automatically. That's it — ask the agent
+to build something for D365 and it will verify elements, follow the methodology, and validate its
+output instead of guessing.
+
+## Add your custom code (optional)
+
+Point the server at your D365 source repo so your **custom** classes/tables/EDTs/enums/extensions
+are indexed too, and so the rich tools can read real signatures and clone real examples:
+
+```toml
+[mcp_servers.d365fo]
+command = "d365fo-mcp"
+args = ["--repo-root", "C:/path/to/your/D365Repo",
+        "--rules", "C:/path/to/your/rules.json",
+        "--packages-root", "C:/AOSService/PackagesLocalDirectory"]
+```
+
+| Capability | Knowledge index only | + a PackagesLocalDirectory / repo |
+|---|---|---|
+| Verify an element exists, search, relations, methodology, validation, scaffolding by template | ✅ | ✅ |
+| Read a real signature, clone a real example (`get_signature`, `find_similar_examples`, `scaffold_object`) | needs source files | ✅ |
+| Compile with the real X++ compiler (`compile_model`) | — | ✅ (Windows D365 host) |
+
+## What the agent gets (MCP tools)
+
+`element_exists`, `find_element`, `search_corpus`, `get_signature`, `get_extension_chain`,
+`get_security_links`, `get_entity_exposure`, `find_similar_examples`, `scaffold_object`,
+`find_references`, `find_reverse_references`, `analyze_spec`, `generate_from_spec`, `validate_xml`,
+`lint_artifact`, `derive_entity`, `wire_security`, `compile_model`, `get_methodology`, `index_stats`.
+
+See [docs/mcp-server.md](docs/mcp-server.md) for the verify-driven workflow and
+[docs/x++-methodology.md](docs/x++-methodology.md) for the behavioural contract.
+
+## Maintainer: publish the knowledge index
+
+The wheel stays tiny; the ~100 MB standard index is distributed as a downloadable asset.
+
+```bash
+# 1. Build a STANDARD-only index from a PackagesLocalDirectory (no custom repo)
+d365fo-agent build-index --db d365fo-standard.db --packages-root <PLD> --rebuild
+# 2. (optional) learn type profiles to ship as the default
+d365fo-agent build-type-profiles --db d365fo-standard.db --packages-root <PLD> \
+  --out src/d365fo_agent/data/aot-type-profiles.json
+# 3. Compress and attach to a GitHub release
+python -c "import gzip,shutil; shutil.copyfileobj(open('d365fo-standard.db','rb'), gzip.open('d365fo-standard.db.gz','wb'))"
+# 4. Point users at it: set DEFAULT_KNOWLEDGE_URL in knowledge_fetch.py (or pass --url)
+```
+
+> **Note:** the index holds factual AOT metadata (element names, types, packages, labels,
+> relations) — not Microsoft source. Confirm your redistribution position before publishing a
+> prebuilt standard index; option **B** above lets each user build their own with zero redistribution.
+
+To publish the package itself: `python -m build` then `python -m twine upload dist/*` (PyPI account
+required).
+
+## Develop / contribute
+
+```bash
+pip install -e ".[dev]"
+PYTHONPATH=src python -m unittest discover -s tests   # full test suite
+ruff check src/d365fo_agent tests
+```
+
+Docs: [Architecture](docs/architecture.md) · [MCP Server](docs/mcp-server.md) ·
+[X++ Methodology](docs/x++-methodology.md) · [Specification Contract](docs/specification-contract.md) ·
+[Metadata Schema](docs/metadata-schema.md) · [Tool Catalog](docs/tool-catalog.md)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

d365fo_agent_developer-0.6.0/README.md

@@ -0,0 +1,140 @@
+# d365fo-agent — D365 F&O X++ knowledge for Claude Code & Codex
+
+A local **MCP server** that gives an AI coding agent (Claude Code, Codex, any MCP host) a grounded
+**knowledge base of Dynamics 365 Finance & Operations X++** — so you can develop for D365 quickly
+**without re-feeding a whole repo for analysis every time**.
+
+It grounds the agent in real AOT facts: it verifies that a class/table/EDT/enum/entity actually
+exists (anti-hallucination), searches the corpus, walks extension/security relationships, serves an
+X++ engineering methodology, validates generated XML against learned per-type structure, scaffolds
+or deterministically generates artifacts, and (on a Windows D365 host) compiles with the real X++
+compiler.
+
+- **Pure Python standard library** — zero runtime dependencies, runs anywhere Python 3.11+ runs.
+- **Vendor-neutral** — Claude Code, Codex, Gemini CLI, or any MCP-speaking client over stdio.
+- The standard D365 corpus is the same for everyone, so it is indexed **once** and used as a
+  portable knowledge base; your own custom code is **optional**.
+
+## Install
+
+```bash
+pip install d365fo-agent-developer
+# or, isolated:  pipx install d365fo-agent-developer
+```
+
+This installs two commands: `d365fo-mcp` (the server) and `d365fo-agent` (the CLI).
+
+## Get the knowledge base (once)
+
+Pick one. Both produce a local index at `~/.d365fo-agent/d365fo.db` that the server uses by default.
+
+**A. Download the prebuilt standard-D365 index** (fastest, no D365 install needed):
+
+```bash
+d365fo-agent fetch-knowledge          # downloads + caches the standard knowledge index
+```
+
+**B. Build it from your own D365 dev box** (no download; uses metadata you already have):
+
+```bash
+d365fo-agent build-index \
+  --db ~/.d365fo-agent/d365fo.db \
+  --packages-root "C:/AOSService/PackagesLocalDirectory" \
+  --rebuild
+```
+
+> The methodology, default lint rules, and a default learned type-profile ship **inside** the
+> package, so validation and guidance work out of the box even before the index is built.
+
+## Wire it into your agent
+
+**Claude Code** — add to `.mcp.json` (project) or `~/.claude.json` (global):
+
+```json
+{
+  "mcpServers": {
+    "d365fo": { "command": "d365fo-mcp", "args": [] }
+  }
+}
+```
+
+…or one command: `claude mcp add d365fo d365fo-mcp`
+
+**Codex** — add to `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.d365fo]
+command = "d365fo-mcp"
+args = []
+```
+
+With no `--db`, the server uses the cached knowledge index automatically. That's it — ask the agent
+to build something for D365 and it will verify elements, follow the methodology, and validate its
+output instead of guessing.
+
+## Add your custom code (optional)
+
+Point the server at your D365 source repo so your **custom** classes/tables/EDTs/enums/extensions
+are indexed too, and so the rich tools can read real signatures and clone real examples:
+
+```toml
+[mcp_servers.d365fo]
+command = "d365fo-mcp"
+args = ["--repo-root", "C:/path/to/your/D365Repo",
+        "--rules", "C:/path/to/your/rules.json",
+        "--packages-root", "C:/AOSService/PackagesLocalDirectory"]
+```
+
+| Capability | Knowledge index only | + a PackagesLocalDirectory / repo |
+|---|---|---|
+| Verify an element exists, search, relations, methodology, validation, scaffolding by template | ✅ | ✅ |
+| Read a real signature, clone a real example (`get_signature`, `find_similar_examples`, `scaffold_object`) | needs source files | ✅ |
+| Compile with the real X++ compiler (`compile_model`) | — | ✅ (Windows D365 host) |
+
+## What the agent gets (MCP tools)
+
+`element_exists`, `find_element`, `search_corpus`, `get_signature`, `get_extension_chain`,
+`get_security_links`, `get_entity_exposure`, `find_similar_examples`, `scaffold_object`,
+`find_references`, `find_reverse_references`, `analyze_spec`, `generate_from_spec`, `validate_xml`,
+`lint_artifact`, `derive_entity`, `wire_security`, `compile_model`, `get_methodology`, `index_stats`.
+
+See [docs/mcp-server.md](docs/mcp-server.md) for the verify-driven workflow and
+[docs/x++-methodology.md](docs/x++-methodology.md) for the behavioural contract.
+
+## Maintainer: publish the knowledge index
+
+The wheel stays tiny; the ~100 MB standard index is distributed as a downloadable asset.
+
+```bash
+# 1. Build a STANDARD-only index from a PackagesLocalDirectory (no custom repo)
+d365fo-agent build-index --db d365fo-standard.db --packages-root <PLD> --rebuild
+# 2. (optional) learn type profiles to ship as the default
+d365fo-agent build-type-profiles --db d365fo-standard.db --packages-root <PLD> \
+  --out src/d365fo_agent/data/aot-type-profiles.json
+# 3. Compress and attach to a GitHub release
+python -c "import gzip,shutil; shutil.copyfileobj(open('d365fo-standard.db','rb'), gzip.open('d365fo-standard.db.gz','wb'))"
+# 4. Point users at it: set DEFAULT_KNOWLEDGE_URL in knowledge_fetch.py (or pass --url)
+```
+
+> **Note:** the index holds factual AOT metadata (element names, types, packages, labels,
+> relations) — not Microsoft source. Confirm your redistribution position before publishing a
+> prebuilt standard index; option **B** above lets each user build their own with zero redistribution.
+
+To publish the package itself: `python -m build` then `python -m twine upload dist/*` (PyPI account
+required).
+
+## Develop / contribute
+
+```bash
+pip install -e ".[dev]"
+PYTHONPATH=src python -m unittest discover -s tests   # full test suite
+ruff check src/d365fo_agent tests
+```
+
+Docs: [Architecture](docs/architecture.md) · [MCP Server](docs/mcp-server.md) ·
+[X++ Methodology](docs/x++-methodology.md) · [Specification Contract](docs/specification-contract.md) ·
+[Metadata Schema](docs/metadata-schema.md) · [Tool Catalog](docs/tool-catalog.md)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

d365fo_agent_developer-0.6.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "d365fo-agent-developer"
+version = "0.6.0"
+description = "Local D365 F&O knowledge toolkit: corpus indexing (SQLite FTS5), deterministic generation, and an MCP server that grounds coding agents (Claude Code, Codex) in real AOT facts."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "David Bru", email = "dbru@fiveforty.fr" }]
+keywords = [
+    "dynamics-365", "d365fo", "x++", "aot", "mcp", "model-context-protocol",
+    "claude", "claude-code", "codex", "ai", "code-generation", "rag",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Software Development :: Build Tools",
+]
+# Standard library only — nothing to install at runtime, which keeps the MCP server portable.
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/dbru540/d365fo-agent"
+Repository = "https://github.com/dbru540/d365fo-agent"
+Issues = "https://github.com/dbru540/d365fo-agent/issues"
+
+[project.optional-dependencies]
+# The graph-building engine is the ONLY external dependency, and only the
+# `run-graphify-staging` command needs it. Everything else (indexing, generation,
+# MCP server, validation) is Python standard library only.
+graph = ["graphify"]
+dev = ["pytest", "ruff", "build"]
+
+[project.scripts]
+d365fo-agent = "d365fo_agent.cli:main"
+d365fo-mcp = "d365fo_agent.mcp_server:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+# Methodology, default lint rules, and a default learned type-profile ship inside the package so
+# the server works after a plain `pip install` (no source tree needed).
+d365fo_agent = ["data/*"]

d365fo_agent_developer-0.6.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

d365fo_agent_developer-0.6.0/src/d365fo_agent/__init__.py

@@ -0,0 +1,2 @@
+"""Local tooling for D365 F&O corpus curation and metadata extraction."""
+

d365fo_agent_developer-0.6.0/src/d365fo_agent/aot_relations.py

@@ -0,0 +1,147 @@
+"""Extract AOT table relations — the D365 equivalent of foreign keys.
+
+AX business tables define no SQL foreign keys; the relational graph lives in the AOT
+metadata: every ``AxTable`` (and ``AxTableExtension``) XML carries a ``<Relations>`` block
+with the related table, the relationship type (Association/Composition), both cardinalities,
+and the EXACT join fields (``<AxTableRelationConstraintField>``: Field ↔ RelatedField, plus
+fixed-value constraints). This module walks one or more corpus roots (PackagesLocalDirectory
+and/or editable source trees), parses those blocks, and stores them next to the SQL data
+model so ``find_relations``/``get_sql_model`` can explain table relationships with the same
+authority a foreign key would. Standard library only.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Iterator
+
+_XSI_TYPE = "{http://www.w3.org/2001/XMLSchema-instance}type"
+# Mirrors index_store._NON_AOT_DIRS: build outputs that contain compiled XML copies.
+_SKIP_DIRS = {"bin", "Descriptor", "Resources", "XppMetadata", "AdditionalFiles", "obj"}
+
+_SCHEMA = """
+CREATE TABLE IF NOT EXISTS aot_relations(
+    table_name TEXT, relation_name TEXT, related_table TEXT,
+    relationship_type TEXT, cardinality TEXT, related_cardinality TEXT,
+    edt_relation INTEGER, source_element TEXT,
+    PRIMARY KEY(table_name, relation_name, source_element));
+CREATE TABLE IF NOT EXISTS aot_relation_fields(
+    table_name TEXT, relation_name TEXT, kind TEXT,
+    field TEXT, related_field TEXT, fixed_value TEXT, source_edt TEXT);
+CREATE INDEX IF NOT EXISTS ix_aot_rel_table ON aot_relations(table_name);
+CREATE INDEX IF NOT EXISTS ix_aot_rel_related ON aot_relations(related_table);
+"""
+
+
+def _text(node: ET.Element | None) -> str | None:
+    return node.text.strip() if node is not None and node.text else None
+
+
+def _iter_table_files(root: Path) -> Iterator[tuple[Path, str]]:
+    """Yield (xml_path, element_kind) for every AxTable/AxTableExtension under a corpus root."""
+    for kind in ("AxTable", "AxTableExtension"):
+        for type_dir in root.rglob(kind):
+            if not type_dir.is_dir() or type_dir.name != kind:
+                continue
+            if any(part in _SKIP_DIRS for part in type_dir.relative_to(root).parts):
+                continue
+            for xml_file in type_dir.glob("*.xml"):
+                yield xml_file, kind
+
+
+def parse_table_relations(xml_path: Path, kind: str) -> tuple[str, str, list[dict[str, object]]]:
+    """Parse one AxTable/AxTableExtension XML. Returns (table_name, source_element, relations).
+
+    For an extension ``CustTable.MyModel``, the relations belong to ``CustTable``.
+    """
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    element_name = _text(root.find("Name")) or xml_path.stem
+    table_name = element_name.split(".")[0] if kind == "AxTableExtension" else element_name
+
+    relations: list[dict[str, object]] = []
+    for rel in root.iter("AxTableRelation"):
+        constraints: list[dict[str, object]] = []
+        for constraint in rel.iter("AxTableRelationConstraint"):
+            ctype = (constraint.get(_XSI_TYPE) or "AxTableRelationConstraintField")
+            constraints.append({
+                "kind": ctype.replace("AxTableRelationConstraint", "").lower() or "field",
+                "field": _text(constraint.find("Field")),
+                "related_field": _text(constraint.find("RelatedField")),
+                "fixed_value": _text(constraint.find("Value")),
+                "source_edt": _text(constraint.find("SourceEDT")),
+            })
+        relations.append({
+            "name": _text(rel.find("Name")),
+            "related_table": _text(rel.find("RelatedTable")),
+            "relationship_type": _text(rel.find("RelationshipType")),
+            "cardinality": _text(rel.find("Cardinality")),
+            "related_cardinality": _text(rel.find("RelatedTableCardinality")),
+            "edt_relation": 1 if _text(rel.find("EDTRelation")) == "Yes" else 0,
+            "constraints": constraints,
+        })
+    return table_name, element_name, relations
+
+
+def extract_aot_relations(
+    roots: "list[str | Path]",
+    db_path: str | Path,
+    *,
+    progress: "callable[[str, int], None] | None" = None,
+) -> dict[str, int]:
+    """Walk every AxTable/AxTableExtension under ``roots`` and persist their relations."""
+    conn = sqlite3.connect(Path(db_path))
+    conn.executescript("DELETE FROM aot_relations; DELETE FROM aot_relation_fields;"
+                       if conn.execute("SELECT 1 FROM sqlite_master WHERE name='aot_relations'").fetchone()
+                       else "SELECT 1;")
+    conn.executescript(_SCHEMA)
+
+    files = relations_count = 0
+    rel_rows: list[tuple] = []
+    field_rows: list[tuple] = []
+    for root in roots:
+        root = Path(root)
+        for xml_file, kind in _iter_table_files(root):
+            try:
+                table, element, relations = parse_table_relations(xml_file, kind)
+            except OSError:
+                # Windows MAX_PATH: deep AOT paths exceed 260 chars — retry extended-length.
+                try:
+                    table, element, relations = parse_table_relations(
+                        Path("\\\\?\\" + str(xml_file.resolve())), kind)
+                except (OSError, ET.ParseError):
+                    continue
+            except ET.ParseError:
+                continue
+            files += 1
+            for rel in relations:
+                if not rel["related_table"]:
+                    continue
+                relations_count += 1
+                rel_rows.append((table, rel["name"], rel["related_table"],
+                                 rel["relationship_type"], rel["cardinality"],
+                                 rel["related_cardinality"], rel["edt_relation"], element))
+                for c in rel["constraints"]:
+                    field_rows.append((table, rel["name"], c["kind"], c["field"],
+                                       c["related_field"], c["fixed_value"], c["source_edt"]))
+            if len(rel_rows) >= 5000:
+                conn.executemany("INSERT OR REPLACE INTO aot_relations VALUES(?,?,?,?,?,?,?,?)", rel_rows)
+                conn.executemany("INSERT INTO aot_relation_fields VALUES(?,?,?,?,?,?,?)", field_rows)
+                conn.commit()
+                rel_rows, field_rows = [], []
+                if progress:
+                    progress(str(root), relations_count)
+    conn.executemany("INSERT OR REPLACE INTO aot_relations VALUES(?,?,?,?,?,?,?,?)", rel_rows)
+    conn.executemany("INSERT INTO aot_relation_fields VALUES(?,?,?,?,?,?,?)", field_rows)
+    conn.commit()
+    stats = {
+        "files_parsed": files,
+        "relations": conn.execute("SELECT COUNT(*) FROM aot_relations").fetchone()[0],
+        "constraint_fields": conn.execute("SELECT COUNT(*) FROM aot_relation_fields").fetchone()[0],
+        "tables_with_relations": conn.execute(
+            "SELECT COUNT(DISTINCT table_name) FROM aot_relations").fetchone()[0],
+    }
+    conn.close()
+    return stats