golden-suite 0.1.0__tar.gz

golden_suite-0.1.0/.gitignore

@@ -0,0 +1,97 @@
+# Build artifacts
+target/
+dist/
+build/
+*.egg-info/
+node_modules/
+__pycache__/
+**/.hypothesis/
+.venv/
+.uv-cache/
+
+# Web UI build output (populated by scripts/build_web.py before `hatch build`).
+# .gitkeep stays so the source tree exists in checkouts and the wheel's
+# force-include glob has something to match.
+packages/python/goldenmatch/goldenmatch/web/static/*
+!packages/python/goldenmatch/goldenmatch/web/static/.gitkeep
+
+# Playwright runtime artifacts
+packages/python/goldenmatch/web/frontend/test-results/
+packages/python/goldenmatch/web/frontend/playwright-report/
+
+# vitest browser-mode runtime output (R1 cross-JS-target WASM harnesses)
+**/.vitest-attachments/
+packages/typescript/goldenmatch/tests/spike/__screenshots__/
+
+# YAML-edit backups (web UI's POST /api/v1/rules/save writes goldenmatch.yml.bak
+# next to the file before clobbering — local-only safety net, not source).
+*.yml.bak
+
+# Steward labels — runtime-written by the inspector's review tab. Keep them
+# out of git so a contributor's labels don't ride along on PRs. If you want
+# seed labels for a demo project, commit a curated labels.seed.jsonl and
+# rename at use time.
+labels.jsonl
+
+# Generated outputs
+*_lineage.json
+*_clusters.csv
+# Allow committed test fixtures and demo project that mimic run outputs
+!packages/python/goldenmatch/tests/web/fixtures/**
+!packages/python/goldenmatch/tests/**/fixtures/**
+!packages/python/goldenmatch/web/demo/**
+
+# IDE
+.vscode/
+.idea/
+
+# Turborepo
+.turbo/
+
+# Claude Code agent worktrees (transient isolated checkouts created by
+# background subagents). Never tracked; project-level .claude settings can
+# still be committed since only the worktrees subdir is ignored.
+.claude/worktrees/
+
+# Superpowers / manual git worktrees (isolated checkouts; never tracked)
+.worktrees/
+
+# Local profiling artifacts (per CLAUDE.md convention — cProfile dumps,
+# scale-audit JSON outputs, synthetic fixtures). Documented as gitignored
+# in CLAUDE.md; this entry makes that real.
+.profile_tmp/
+packages/python/goldenmatch/bench-dataset-v1/
+
+# Local runtime state: Learning Memory DB, review queue, identity graph,
+# cross-run autoconfig memory. The engine (and the test suite) rewrites these
+# on every run, so they are never source. `.goldenmatch/memory.db` used to be
+# tracked at the repo root and re-dirtied the working tree on each run; it was
+# `git rm --cached`'d alongside this entry.
+.goldenmatch/
+
+# Compiled native acceleration ext (built from packages/rust/extensions/native
+# via scripts/build_native.py). Platform-specific abi3 artifact, never source.
+# (.pyd = the Windows in-tree build artifact; .so = Linux/macOS.)
+packages/python/goldenmatch/goldenmatch/_native*.so
+packages/python/goldenmatch/goldenmatch/_native*.pyd
+# maturin-develop drops the compiled ext next to the tracked __init__.py in
+# python/goldenmatch_native/. Ignore ONLY the artifacts, not the source dir.
+packages/rust/extensions/native/python/goldenmatch_native/*.pyd
+packages/rust/extensions/native/python/goldenmatch_native/*.so
+# GoldenCheck's counterpart (packages/rust/extensions/goldencheck-native via
+# scripts/build_goldencheck_native.py). Same rationale.
+packages/python/goldencheck/goldencheck/_native*.so
+
+# Benchmark datasets downloaded at runtime (DBLP-ACM, etc.) — not committed.
+datasets/
+# Same, for goldenflow (built from packages/rust/extensions/native-flow).
+packages/python/goldenflow/goldenflow/_native*.so
+# Same, for goldenanalysis (built from packages/rust/extensions/analysis-native
+# via scripts/build_analysis_native.py).
+packages/python/goldenanalysis/goldenanalysis/_native*.so
+
+# codebase-memory-mcp local index/snapshot (rebuilt by the SessionStart hook)
+.codebase-memory/
+
+# scratch Modal run logs (transient)
+modal_*.log

golden_suite-0.1.0/AGENTS.md

@@ -0,0 +1,151 @@
+# Integrating the Golden Suite (agent guide)
+
+You are wiring the Golden Suite into a project. This is the canonical setup — follow it
+instead of re-deriving one. If you only read one thing: **`goldenpipe` is the front door.
+Install `golden-suite`, drive `goldenpipe`, reach for individual tools only when you need
+a single capability.**
+
+`pip install golden-suite` gives you the whole suite **plus native acceleration, defaulted
+to the perf-optimized configuration** — no env vars to set. It should never silently run
+the slow pure-Python path; `golden-suite doctor` verifies that and `golden-suite optimize`
+repairs it.
+
+## The suite in one screen
+
+| Package | PyPI | What it does | Import |
+| --- | --- | --- | --- |
+| **GoldenPipe** | `goldenpipe` | Orchestrator. Chains the tools as pluggable stages. **Start here.** | `import goldenpipe as gp` |
+| **GoldenMatch** | `goldenmatch` | Entity resolution: dedupe, match across sources, golden records | `import goldenmatch as gm` |
+| **GoldenCheck** | `goldencheck` | Data validation — discovers rules from the data, no rule-writing | `import goldencheck` |
+| **GoldenFlow** | `goldenflow` | Transform / standardize / normalize messy data | `import goldenflow` |
+| **GoldenSchema** | `infermap` | Inference-driven schema mapping (import name is `infermap`) | `import infermap` |
+| **GoldenAnalysis** | `goldenanalysis` | Read-only cross-cutting metrics + reporting | `import goldenanalysis` |
+| `goldencheck-types` | `goldencheck-types` | Shared field-type contracts (transitive; you won't install directly) | — |
+| `goldensuite-mcp` | `goldensuite-mcp` | One MCP server exposing every tool (the agent front door) | — |
+
+Dependency shape (a clean DAG — **GoldenMatch is a leaf, not the root**):
+
+```
+goldencheck-types  ──►  everything (shared contracts)
+infermap (GoldenSchema) ─┐
+goldenmatch ─────────────┤
+goldencheck ─────────────┼──►  goldenpipe  ──►  golden-suite (this meta-package)
+goldenflow  ─────────────┤            └──► goldensuite-mcp (all tools, one MCP)
+goldenanalysis ──────────┘
+```
+
+## Install — pick ONE line
+
+Native acceleration is **included by default** (it's a hard dependency, not an extra).
+
+| You want... | Install |
+| --- | --- |
+| The whole suite + native, perf-optimized | `pip install golden-suite` |
+| Suite + one MCP server for agents | `pip install "golden-suite[mcp]"` |
+| Everything (suite + mcp + serving) | `pip install "golden-suite[all]"` |
+| Just entity resolution | `pip install goldenmatch` |
+| Just validation | `pip install goldencheck` |
+| Orchestrator + the three core tools only | `pip install "goldenpipe[golden-suite]"` |
+
+Supported native platforms: Linux x86_64/aarch64, macOS x86_64/arm64, Windows amd64. On a
+platform without a published wheel the install **fails loudly** (by design — the suite does
+not silently degrade to pure-Python). Those users install the individual pure-Python
+packages directly instead of `golden-suite`.
+
+## Verify + repair the setup (do this after install)
+
+```bash
+golden-suite doctor      # lists every component + whether native is ACTIVE; exits non-zero if silently slow
+golden-suite optimize    # installs any missing native kernels for this platform, then re-verifies
+```
+
+`doctor` is read-only and CI-safe (non-zero exit when a package is silently on the
+pure-Python path). Programmatic equivalents:
+
+```python
+from golden_suite import installed, native_status
+print(installed())        # {"goldenpipe": "1.2.1", "goldenmatch": "1.30.0", ...}
+print(native_status())    # per-package: native_active / silently_slow / env_mode
+```
+
+## Three ways to integrate (choose by consumer)
+
+1. **Python API** — you're inside a Python codebase. Import `goldenpipe` (or a single tool).
+2. **MCP** — the consumer is an agent/LLM. Run **one** server: `goldensuite-mcp` (or `golden-suite[mcp]`). Do **not** wire six per-package MCP servers by hand.
+3. **CLI** — one-off / shell / CI. Every package ships a Typer CLI: `goldenpipe run`, `goldenmatch dedupe`, `goldencheck scan`, etc.
+
+## Canonical quick-starts
+
+### Full pipeline (validate → transform → match), one call
+
+```python
+import goldenpipe as gp
+
+result = gp.run("customers.csv")     # zero-config
+print(result.status)                 # "success"
+print(result.check)                  # quality findings
+print(result.transform)              # what got standardized
+print(result.match)                  # deduplicated clusters
+print(result.reasoning)              # why each decision was made
+```
+
+### Just deduplicate
+
+```python
+import goldenmatch as gm
+result = gm.dedupe("customers.csv")              # zero-config
+# explicit:
+result = gm.dedupe("customers.csv", exact=["email"], fuzzy={"name": 0.85}, blocking=["zip"])
+result.golden.write_csv("deduped.csv")
+```
+
+### Match two sources
+
+```python
+result = gm.match("crm.csv", "billing.csv", fuzzy={"name": 0.85, "address": 0.80})
+```
+
+### Validate (rules discovered from the data)
+
+```python
+import goldencheck
+report = goldencheck.scan("customers.csv")
+```
+
+### Map an unknown schema to a canonical one
+
+```python
+import infermap                       # GoldenSchema
+mapping = infermap.infer("raw_export.csv")
+```
+
+### One MCP server for all of it
+
+```bash
+pip install "golden-suite[mcp]"
+goldensuite-mcp                        # every suite tool, one server
+```
+
+## Anti-patterns that cause the back-and-forth (don't do these)
+
+- **Installing `goldenmatch` and expecting the pipeline / check / transform.** GoldenMatch is
+  entity resolution only. For the end-to-end flow use `goldenpipe`.
+- **Hand-wiring each tool into a bespoke pipeline.** `goldenpipe` already registers every tool
+  as a stage (`goldencheck.scan`, `goldenflow.transform`, `goldenmatch.dedupe`,
+  `goldenmatch.identity_resolve`, `goldenanalysis.report`) via entry-points. Use it.
+- **Running six MCP servers.** One `goldensuite-mcp` exposes them all.
+- **Importing `goldenschema`.** The import name is `infermap` (PyPI/product name is GoldenSchema).
+- **Assuming native is off and setting `<PKG>_NATIVE=1` "to turn it on".** It's already on by
+  default (`auto` runs the parity-signed-off hot paths native automatically). `=1` is a
+  *require-and-force* mode that also runs components NOT yet parity-signed-off (notably
+  goldenflow) and **can change outputs** — only use it via `golden-suite optimize --strict`
+  after validating parity for your workload.
+- **Pinning tools to each other's versions.** They release independently. Let `golden-suite`
+  carry the compatible lower bounds; don't hard-pin cross-package versions in the consumer.
+
+## Notes
+
+- Python 3.11–3.13. Everything is Polars-backed.
+- Repo: `benseverndev-oss/goldenmatch` (monorepo — all suite packages live here under
+  `packages/python/<pkg>`).
+- Per-tool detail: each package has its own `AGENTS.md` and `llms.txt`.

golden_suite-0.1.0/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to golden-suite are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/); this project uses semantic
+versioning.
+
+## [0.1.0] - unreleased
+
+Initial release. A one-line, perf-optimized install and a single canonical front
+door for the whole Golden Suite.
+
+### Added
+- `pip install golden-suite` pulls the whole suite — `goldenpipe[golden-suite]`
+  (orchestrator + check/flow/match/analysis), plus `goldenmatch`, `goldencheck`,
+  `goldenflow`, `infermap` (GoldenSchema), `goldenanalysis`, `goldencheck-types`.
+- **Native acceleration on by default.** The four native (Rust/abi3) kernels
+  (`goldenmatch-native`, `goldencheck-native`, `goldenflow-native`,
+  `goldenanalysis-native`) are **hard dependencies**, not an opt-in extra, so the
+  suite defaults to the perf-optimized configuration and never silently runs the
+  slow pure-Python path. Wheels cover Linux x86_64/aarch64, macOS x86_64/arm64,
+  and Windows amd64; on an unsupported platform the install fails loudly by design.
+- `golden-suite` CLI:
+  - `doctor` — reports every component + version and whether each native kernel is
+    actually active; exits non-zero when a package is silently on the pure-Python
+    path (CI/verification-safe).
+  - `optimize` — installs any missing native kernels for the current platform, then
+    re-verifies. `--strict` additionally emits the require-native env vars
+    (`<PKG>_NATIVE=1`), with a warning that strict mode force-runs components not
+    yet parity-signed-off (notably goldenflow) and can change outputs.
+- Introspection helpers: `golden_suite.installed()` (dist -> version|None) and
+  `golden_suite.native_status()` (per-package `native_active` / `silently_slow` /
+  `env_mode`).
+- Optional extras: `[mcp]` (`goldensuite-mcp` — one server for every tool),
+  `[agent]` (GoldenPipe tui/api/agent serving surfaces), and `[all]`.
+- Integration guide for agents and humans: `AGENTS.md`, `llms.txt`, `README.md`.
+
+### Notes
+- Ships no data-processing logic of its own beyond the CLI + introspection helpers.
+- Published on the `golden-suite-v*` release tag via `publish-golden-suite.yml`
+  (distinct from the `goldensuite-mcp-v*` tag).

golden_suite-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.4
+Name: golden-suite
+Version: 0.1.0
+Summary: One-line, perf-optimized install for the entire Golden Suite — goldenmatch, goldencheck, goldenflow, goldenpipe, GoldenSchema (infermap), goldenanalysis, native acceleration on by default
+Project-URL: Homepage, https://github.com/benseverndev-oss/goldenmatch
+Project-URL: Repository, https://github.com/benseverndev-oss/goldenmatch
+Project-URL: Documentation, https://github.com/benseverndev-oss/goldenmatch/tree/main/packages/python/golden-suite#readme
+Project-URL: Issues, https://github.com/benseverndev-oss/goldenmatch/issues
+Project-URL: Changelog, https://github.com/benseverndev-oss/goldenmatch/blob/main/packages/python/golden-suite/CHANGELOG.md
+Author-email: Ben Severn <ben@bensevern.dev>
+License: MIT
+Keywords: data-quality,entity-resolution,golden-suite,meta-package,pipeline,schema-inference
+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 :: Libraries :: Python Modules
+Requires-Python: <3.14,>=3.11
+Requires-Dist: goldenanalysis-native>=0.1
+Requires-Dist: goldenanalysis>=0.3
+Requires-Dist: goldencheck-native>=0.1
+Requires-Dist: goldencheck-types>=0.1
+Requires-Dist: goldencheck>=1.4
+Requires-Dist: goldenflow-native>=0.1.1
+Requires-Dist: goldenflow>=1.3
+Requires-Dist: goldenmatch-native>=0.1.12
+Requires-Dist: goldenmatch>=2.5
+Requires-Dist: goldenpipe[golden-suite]>=1.3
+Requires-Dist: infermap>=0.5.1
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Provides-Extra: agent
+Requires-Dist: goldenpipe[agent,api,tui]>=1.3; extra == 'agent'
+Provides-Extra: all
+Requires-Dist: goldenpipe[agent,api,tui]>=1.3; extra == 'all'
+Requires-Dist: goldensuite-mcp>=0.3; extra == 'all'
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: goldensuite-mcp>=0.3; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# golden-suite
+
+One-line, perf-optimized install and single front door for the whole **Golden Suite**.
+
+```bash
+pip install golden-suite      # whole suite + native acceleration, defaulted to the fast config
+golden-suite doctor           # verify native is actually active
+```
+
+This is a thin meta-package. It pulls in every suite tool **plus the native (Rust)
+acceleration kernels, on by default**, and gives you (and your agents) one canonical entry
+point. It ships no data-processing logic of its own — just a `doctor`/`optimize` CLI and
+introspection helpers.
+
+## What you get
+
+| Tool | Does | Import |
+| --- | --- | --- |
+| **GoldenPipe** | Orchestrator — chains the tools as pluggable stages. **Start here.** | `import goldenpipe as gp` |
+| **GoldenMatch** | Entity resolution: dedupe, match, golden records | `import goldenmatch as gm` |
+| **GoldenCheck** | Data validation (rules discovered from your data) | `import goldencheck` |
+| **GoldenFlow** | Transform / standardize / normalize | `import goldenflow` |
+| **GoldenSchema** | Inference-driven schema mapping (import name: `infermap`) | `import infermap` |
+| **GoldenAnalysis** | Read-only metrics + reporting | `import goldenanalysis` |
+
+`goldenpipe` is the front door: it adapts every other tool as a stage, so most integrations
+only ever touch `goldenpipe`. `goldenmatch` is a leaf (entity resolution only), not the root.
+
+## Install options
+
+Native acceleration is included by default (a hard dependency, not an extra).
+
+| You want | Install |
+| --- | --- |
+| The whole suite + native | `pip install golden-suite` |
+| Suite + one MCP server | `pip install "golden-suite[mcp]"` |
+| Everything (suite + mcp + serving) | `pip install "golden-suite[all]"` |
+
+Native wheels cover Linux x86_64/aarch64, macOS x86_64/arm64, Windows amd64. On an
+unsupported platform the install fails loudly rather than silently degrading — install the
+individual pure-Python packages directly there.
+
+## Quick start
+
+```python
+import goldenpipe as gp
+
+result = gp.run("customers.csv")   # validate -> transform -> match, one call
+print(result.status, result.match, result.reasoning)
+```
+
+Verify + repair the perf setup:
+
+```bash
+golden-suite doctor      # every component + whether native is ACTIVE (non-zero exit if silently slow)
+golden-suite optimize    # install any missing native kernels, then re-verify
+```
+
+```python
+from golden_suite import installed, native_status
+print(installed())       # {"goldenpipe": "1.2.1", "goldenmatch": "1.30.0", ...}
+print(native_status())   # per-package native_active / silently_slow / env_mode
+```
+
+## For agents
+
+See [`AGENTS.md`](./AGENTS.md) and [`llms.txt`](./llms.txt) — the canonical integration guide,
+including the anti-patterns that cause most of the "wrong setup" back-and-forth.
+
+## License
+
+MIT. Part of the [Golden Suite monorepo](https://github.com/benseverndev-oss/goldenmatch).

golden_suite-0.1.0/README.md

@@ -0,0 +1,72 @@
+# golden-suite
+
+One-line, perf-optimized install and single front door for the whole **Golden Suite**.
+
+```bash
+pip install golden-suite      # whole suite + native acceleration, defaulted to the fast config
+golden-suite doctor           # verify native is actually active
+```
+
+This is a thin meta-package. It pulls in every suite tool **plus the native (Rust)
+acceleration kernels, on by default**, and gives you (and your agents) one canonical entry
+point. It ships no data-processing logic of its own — just a `doctor`/`optimize` CLI and
+introspection helpers.
+
+## What you get
+
+| Tool | Does | Import |
+| --- | --- | --- |
+| **GoldenPipe** | Orchestrator — chains the tools as pluggable stages. **Start here.** | `import goldenpipe as gp` |
+| **GoldenMatch** | Entity resolution: dedupe, match, golden records | `import goldenmatch as gm` |
+| **GoldenCheck** | Data validation (rules discovered from your data) | `import goldencheck` |
+| **GoldenFlow** | Transform / standardize / normalize | `import goldenflow` |
+| **GoldenSchema** | Inference-driven schema mapping (import name: `infermap`) | `import infermap` |
+| **GoldenAnalysis** | Read-only metrics + reporting | `import goldenanalysis` |
+
+`goldenpipe` is the front door: it adapts every other tool as a stage, so most integrations
+only ever touch `goldenpipe`. `goldenmatch` is a leaf (entity resolution only), not the root.
+
+## Install options
+
+Native acceleration is included by default (a hard dependency, not an extra).
+
+| You want | Install |
+| --- | --- |
+| The whole suite + native | `pip install golden-suite` |
+| Suite + one MCP server | `pip install "golden-suite[mcp]"` |
+| Everything (suite + mcp + serving) | `pip install "golden-suite[all]"` |
+
+Native wheels cover Linux x86_64/aarch64, macOS x86_64/arm64, Windows amd64. On an
+unsupported platform the install fails loudly rather than silently degrading — install the
+individual pure-Python packages directly there.
+
+## Quick start
+
+```python
+import goldenpipe as gp
+
+result = gp.run("customers.csv")   # validate -> transform -> match, one call
+print(result.status, result.match, result.reasoning)
+```
+
+Verify + repair the perf setup:
+
+```bash
+golden-suite doctor      # every component + whether native is ACTIVE (non-zero exit if silently slow)
+golden-suite optimize    # install any missing native kernels, then re-verify
+```
+
+```python
+from golden_suite import installed, native_status
+print(installed())       # {"goldenpipe": "1.2.1", "goldenmatch": "1.30.0", ...}
+print(native_status())   # per-package native_active / silently_slow / env_mode
+```
+
+## For agents
+
+See [`AGENTS.md`](./AGENTS.md) and [`llms.txt`](./llms.txt) — the canonical integration guide,
+including the anti-patterns that cause most of the "wrong setup" back-and-forth.
+
+## License
+
+MIT. Part of the [Golden Suite monorepo](https://github.com/benseverndev-oss/goldenmatch).

golden_suite-0.1.0/golden_suite/__init__.py

@@ -0,0 +1,120 @@
+"""Golden Suite meta-package.
+
+One-line, perf-optimized install and a single canonical entry point for the whole
+suite. Ships almost no logic of its own — just introspection helpers and a
+``golden-suite`` CLI (``doctor`` / ``optimize``). For real work, import the
+individual tools (or, most of the time, just ``goldenpipe`` — the orchestrator
+that adapts every other tool as a stage).
+
+    import goldenpipe as gp
+    result = gp.run("customers.csv")   # runs check -> transform -> match end to end
+
+Native acceleration is installed by default. Use :func:`installed` to see which
+components resolved, and :func:`native_status` to see whether each native kernel
+is actually active (the truth behind "am I on the fast path").
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from importlib import metadata
+
+__version__ = "0.1.0"
+
+# PyPI distribution name -> import module name. Keep in lockstep with pyproject deps.
+_COMPONENTS: dict[str, str] = {
+    "goldenpipe": "goldenpipe",
+    "goldenmatch": "goldenmatch",
+    "goldencheck": "goldencheck",
+    "goldenflow": "goldenflow",
+    "infermap": "infermap",  # GoldenSchema
+    "goldenanalysis": "goldenanalysis",
+    "goldencheck-types": "goldencheck_types",
+    "goldensuite-mcp": "goldensuite_mcp",
+}
+
+# Packages that ship an optional native (Rust/abi3) accelerator, and the pieces
+# needed to reason about it WITHOUT importing the heavy top-level package:
+#   base package -> (native distribution, standalone native import module, env var)
+# The runtime loader tries ``<pkg>._native`` (in-tree build) then
+# ``<pkg>_native._native`` (the published wheel). For a pip user only the wheel
+# path exists, so probing the standalone ``<pkg>_native`` module is both accurate
+# and lightweight (it does not pull in polars et al.).
+_NATIVE: dict[str, tuple[str, str, str]] = {
+    "goldenmatch": ("goldenmatch-native", "goldenmatch_native", "GOLDENMATCH_NATIVE"),
+    "goldencheck": ("goldencheck-native", "goldencheck_native", "GOLDENCHECK_NATIVE"),
+    "goldenflow": ("goldenflow-native", "goldenflow_native", "GOLDENFLOW_NATIVE"),
+    "goldenanalysis": (
+        "goldenanalysis-native",
+        "goldenanalysis_native",
+        "GOLDENANALYSIS_NATIVE",
+    ),
+}
+
+
+def _version_or_none(dist: str) -> str | None:
+    try:
+        return metadata.version(dist)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def installed() -> dict[str, str | None]:
+    """Return ``{distribution_name: version-or-None}`` for every suite component.
+
+    ``None`` means the component is not installed in this environment. The fastest
+    way to confirm an integration actually got the intended setup.
+    """
+    return {dist: _version_or_none(dist) for dist in _COMPONENTS}
+
+
+def _native_importable(native_module: str) -> bool:
+    """Whether the standalone native wheel (e.g. ``goldenmatch_native._native``)
+    imports cleanly — the same path the runtime loader uses under a pip install."""
+    try:
+        mod = importlib.import_module(native_module)
+    except Exception:  # noqa: BLE001 - any import/load failure => not available
+        return False
+    if getattr(mod, "_native", None) is not None:
+        return True
+    try:  # some builds expose ``_native`` only as a submodule
+        importlib.import_module(f"{native_module}._native")
+        return True
+    except Exception:  # noqa: BLE001
+        return False
+
+
+def native_status() -> dict[str, dict[str, object]]:
+    """Per-package native-acceleration status.
+
+    For each accel-capable package returns a dict with:
+      - ``base_installed``  : the base package version, or ``None``
+      - ``native_version``  : the native wheel version, or ``None``
+      - ``native_active``   : whether the native kernel imports (fast path live)
+      - ``env_mode``        : the ``<PKG>_NATIVE`` env value (``auto`` if unset)
+      - ``silently_slow``   : base installed but native NOT active AND env != "0"
+                              — i.e. the runtime is silently on the pure-Python path
+    """
+    out: dict[str, dict[str, object]] = {}
+    for pkg, (native_dist, native_module, env_var) in _NATIVE.items():
+        base_installed = _version_or_none(pkg)
+        native_version = _version_or_none(native_dist)
+        native_active = _native_importable(native_module)
+        env_mode = os.environ.get(env_var, "auto").lower()
+        silently_slow = (
+            base_installed is not None and not native_active and env_mode != "0"
+        )
+        out[pkg] = {
+            "base_installed": base_installed,
+            "native_dist": native_dist,
+            "native_version": native_version,
+            "native_active": native_active,
+            "env_var": env_var,
+            "env_mode": env_mode,
+            "silently_slow": silently_slow,
+        }
+    return out
+
+
+__all__ = ["__version__", "installed", "native_status"]

golden_suite-0.1.0/golden_suite/cli.py

@@ -0,0 +1,182 @@
+"""``golden-suite`` CLI: verify and repair the perf-optimized setup.
+
+    golden-suite doctor      # report every component + whether native is actually active
+    golden-suite optimize    # install any missing native kernels, then re-verify
+
+``doctor`` is read-only and exits non-zero when the runtime would silently run the
+slow pure-Python path — so it doubles as a CI/verification gate. ``optimize`` acts.
+"""
+
+from __future__ import annotations
+
+import json as _json
+import subprocess
+import sys
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from . import __version__, installed, native_status
+
+app = typer.Typer(
+    add_completion=False,
+    help="Verify and repair the perf-optimized Golden Suite setup.",
+    no_args_is_help=True,
+)
+_console = Console()
+_err = Console(stderr=True)
+
+
+def _components_table() -> Table:
+    table = Table(title="Golden Suite components", title_style="bold")
+    table.add_column("Package")
+    table.add_column("Version")
+    for dist, version in installed().items():
+        if version is None:
+            table.add_row(dist, "[yellow]not installed[/]")
+        else:
+            table.add_row(dist, version)
+    return table
+
+
+def _native_table(status: dict[str, dict[str, object]]) -> Table:
+    table = Table(title="Native acceleration", title_style="bold")
+    table.add_column("Package")
+    table.add_column("Native wheel")
+    table.add_column("Fast path")
+    table.add_column("Env")
+    table.add_column("Verdict")
+    for pkg, s in status.items():
+        if s["base_installed"] is None:
+            continue  # base package not installed; nothing to accelerate
+        wheel = s["native_version"] or "[yellow]missing[/]"
+        if s["native_active"]:
+            fast = "[green]native[/]"
+        else:
+            fast = "[red]pure-python[/]"
+        if s["env_mode"] == "0":
+            verdict = "[yellow]native disabled (env=0)[/]"
+        elif s["silently_slow"]:
+            verdict = "[red]SILENTLY SLOW[/]"
+        elif s["native_active"]:
+            verdict = "[green]OK[/]"
+        else:
+            verdict = "[yellow]inactive[/]"
+        table.add_row(pkg, str(wheel), fast, str(s["env_mode"]), verdict)
+    return table
+
+
+@app.command()
+def doctor(
+    as_json: bool = typer.Option(False, "--json", help="Emit machine-readable JSON."),
+    strict: bool = typer.Option(
+        True,
+        "--strict/--no-strict",
+        help="Exit non-zero if any package is silently on the pure-Python path.",
+    ),
+) -> None:
+    """Report every component and whether the native fast path is actually active."""
+    status = native_status()
+    silently_slow = [p for p, s in status.items() if s["silently_slow"]]
+    missing_base = [d for d, v in installed().items() if v is None]
+
+    if as_json:
+        _console.print_json(
+            _json.dumps(
+                {
+                    "version": __version__,
+                    "installed": installed(),
+                    "native": status,
+                    "silently_slow": silently_slow,
+                    "missing_components": missing_base,
+                }
+            )
+        )
+    else:
+        _console.print(_components_table())
+        _console.print(_native_table(status))
+        if silently_slow:
+            _err.print(
+                f"\n[red]FAIL[/]: {', '.join(silently_slow)} installed but running "
+                f"pure-Python. Run [bold]golden-suite optimize[/] to fix."
+            )
+        else:
+            _console.print("\n[green]OK[/]: native acceleration active where expected.")
+
+    if strict and silently_slow:
+        raise typer.Exit(code=1)
+
+
+@app.command()
+def optimize(
+    strict_runtime: bool = typer.Option(
+        False,
+        "--strict/--no-strict",
+        help=(
+            "Also emit require-native env vars (<PKG>_NATIVE=1). WARNING: strict "
+            "mode forces native for components NOT yet parity-signed-off (notably "
+            "goldenflow) and can change outputs. Off by default."
+        ),
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show what would be installed, do nothing."
+    ),
+) -> None:
+    """Install any missing native kernels for this platform, then re-verify."""
+    status = native_status()
+    # A package needs repair when its base is installed but the native wheel is
+    # absent or won't import on this interpreter.
+    to_install = [
+        str(s["native_dist"])
+        for s in status.values()
+        if s["base_installed"] is not None and not s["native_active"]
+    ]
+
+    if not to_install:
+        _console.print("[green]Already optimal[/]: every native kernel is active.")
+    else:
+        _console.print(
+            f"Native kernels to install: [bold]{', '.join(to_install)}[/]"
+        )
+        if dry_run:
+            _console.print("[yellow]--dry-run[/]: nothing installed.")
+        else:
+            cmd = [sys.executable, "-m", "pip", "install", "--upgrade", *to_install]
+            _console.print(f"$ {' '.join(cmd)}")
+            result = subprocess.run(cmd, check=False)
+            if result.returncode != 0:
+                _err.print(
+                    "[red]pip install failed[/]. On a platform without a published "
+                    "wheel, native cannot be enabled — see the docs for supported "
+                    "platforms."
+                )
+                raise typer.Exit(code=result.returncode)
+
+    if strict_runtime:
+        _console.print(
+            "\n[bold]Require-native env[/] (add to your shell/.env to make a missing "
+            "kernel raise instead of silently falling back):"
+        )
+        for s in status.values():
+            if s["base_installed"] is not None:
+                _console.print(f"  export {s['env_var']}=1")
+        _err.print(
+            "\n[yellow]WARNING[/]: <PKG>_NATIVE=1 forces native for components not "
+            "yet parity-signed-off (e.g. goldenflow) and MAY change outputs. Only "
+            "use it if you have validated parity for your workload."
+        )
+
+    if not dry_run:
+        _console.print()
+        doctor(as_json=False, strict=False)
+
+
+@app.command()
+def version() -> None:
+    """Print the golden-suite meta-package version."""
+    _console.print(__version__)
+
+
+if __name__ == "__main__":  # pragma: no cover
+    app()

golden_suite-0.1.0/llms.txt

@@ -0,0 +1,94 @@
+# Golden Suite
+
+> One-line, perf-optimized install and single front door for the whole Golden Suite: entity
+> resolution (GoldenMatch), data validation (GoldenCheck), transformation (GoldenFlow),
+> schema mapping (GoldenSchema/infermap), read-only analysis (GoldenAnalysis), all
+> orchestrated by GoldenPipe. Native (Rust) acceleration is included and on by default;
+> the suite never silently runs the slow pure-Python path. Ships a tiny `golden-suite` CLI
+> (doctor/optimize) plus introspection helpers.
+
+## Mental model
+- `goldenpipe` is the orchestrator and the front door. It adapts every other tool as a
+  pluggable stage. Most integrations only touch `goldenpipe`.
+- `goldenmatch` is a LEAF (entity resolution), not the root. Do not expect the pipeline,
+  validation, or transforms from it.
+- `goldensuite-mcp` is one MCP server exposing every tool — the agent front door.
+
+## Components
+- GoldenPipe (`goldenpipe`) — orchestrator; `import goldenpipe as gp`
+- GoldenMatch (`goldenmatch`) — dedupe, match, golden records; `import goldenmatch as gm`
+- GoldenCheck (`goldencheck`) — validation, rules discovered from data; `import goldencheck`
+- GoldenFlow (`goldenflow`) — transform / standardize / normalize; `import goldenflow`
+- GoldenSchema (`infermap`) — inference-driven schema mapping; `import infermap`
+- GoldenAnalysis (`goldenanalysis`) — read-only metrics + reporting; `import goldenanalysis`
+- `goldencheck-types` — shared field-type contracts (transitive)
+- `goldensuite-mcp` — one MCP server, every tool
+
+## Install
+- `pip install golden-suite` — whole suite + native acceleration, perf-optimized (Python)
+- `pip install "golden-suite[mcp]"` — suite + one MCP server (`goldensuite-mcp`)
+- `pip install "golden-suite[all]"` — suite + mcp + serving surfaces
+- Single tool instead: `pip install goldenmatch` / `goldencheck` / `goldenflow` / `infermap`
+- Orchestrator + core three: `pip install "goldenpipe[golden-suite]"`
+- Native wheels cover Linux x86_64/aarch64, macOS x86_64/arm64, Windows amd64. On an
+  unsupported platform the install fails loudly (no silent pure-Python) — install the
+  individual pure-Python packages directly there.
+
+## Verify + repair the setup
+- `golden-suite doctor` — every component + whether native is ACTIVE; non-zero exit if silently slow (CI-safe)
+- `golden-suite optimize` — install missing native kernels for this platform, then re-verify
+```python
+from golden_suite import installed, native_status
+print(installed())      # dist -> version|None for every suite component
+print(native_status())  # per-package native_active / silently_slow / env_mode
+```
+
+## Quick examples
+
+### Full pipeline (validate -> transform -> match), one call
+```python
+import goldenpipe as gp
+result = gp.run("customers.csv")
+print(result.status, result.check, result.transform, result.match, result.reasoning)
+```
+
+### Deduplicate
+```python
+import goldenmatch as gm
+result = gm.dedupe("customers.csv", exact=["email"], fuzzy={"name": 0.85}, blocking=["zip"])
+result.golden.write_csv("deduped.csv")
+```
+
+### Match two sources
+```python
+result = gm.match("crm.csv", "billing.csv", fuzzy={"name": 0.85, "address": 0.80})
+```
+
+### Validate
+```python
+import goldencheck
+report = goldencheck.scan("customers.csv")
+```
+
+### Map an unknown schema
+```python
+import infermap                       # GoldenSchema
+mapping = infermap.infer("raw_export.csv")
+```
+
+### One MCP server for everything
+```bash
+pip install "golden-suite[mcp]" && goldensuite-mcp
+```
+
+## Anti-patterns
+- Installing `goldenmatch` and expecting the pipeline/check/transform — use `goldenpipe`.
+- Hand-wiring each tool — `goldenpipe` already registers them as stages.
+- Running six MCP servers — use one `goldensuite-mcp`.
+- `import goldenschema` — the import name is `infermap`.
+- Setting `<PKG>_NATIVE=1` "to enable native" — it's already on by default; `=1` force-runs
+  non-signed-off components (goldenflow) and can change outputs. Use `optimize --strict` only
+  after validating parity.
+
+## Repo
+- Monorepo: benseverndev-oss/goldenmatch (packages/python/<pkg>). Python 3.11-3.13, Polars-backed.

golden_suite-0.1.0/pyproject.toml

@@ -0,0 +1,76 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "golden-suite"
+version = "0.1.0"
+description = "One-line, perf-optimized install for the entire Golden Suite — goldenmatch, goldencheck, goldenflow, goldenpipe, GoldenSchema (infermap), goldenanalysis, native acceleration on by default"
+readme = "README.md"
+requires-python = ">=3.11,<3.14"
+license = { text = "MIT" }
+authors = [{ name = "Ben Severn", email = "ben@bensevern.dev" }]
+keywords = ["data-quality", "entity-resolution", "pipeline", "schema-inference", "golden-suite", "meta-package"]
+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 :: Libraries :: Python Modules",
+]
+
+# `pip install golden-suite` gets the WHOLE suite AND the native acceleration
+# kernels, in one line, defaulting to the perf-optimized configuration.
+#
+# `goldenpipe` is the orchestrator (adapts every tool as a stage). The native
+# wheels are HARD dependencies on purpose: the suite should never silently run
+# the slow pure-Python path. abi3 wheels are published for the five mainstream
+# platforms (Linux x86_64/aarch64, macOS x86_64/arm64, Windows amd64); on any
+# platform without a wheel the install fails LOUDLY rather than degrading.
+# Under each package's default `auto` gate, the parity-signed-off hot paths then
+# run native automatically — no env vars to set. `golden-suite doctor` verifies
+# it; `golden-suite optimize` repairs it.
+dependencies = [
+    # --- suite (floors track the current majors) ---
+    "goldenpipe[golden-suite]>=1.3",    # orchestrator + check/flow/match/analysis
+    "goldenmatch>=2.5",                 # entity resolution: dedupe, match, golden records (2.7.0 is latest on PyPI as of this floor bump)
+    "goldencheck>=1.4",                 # data validation (rules discovered from your data)
+    "goldenflow>=1.3",                  # transform / standardize / normalize
+    "infermap>=0.5.1",                  # GoldenSchema: inference-driven schema mapping
+    "goldenanalysis>=0.3",              # read-only cross-cutting metrics + reporting
+    "goldencheck-types>=0.1",           # shared canonical field-type contracts
+    # --- native acceleration (on by default; see note above) ---
+    "goldenmatch-native>=0.1.12",       # >=0.1.12 carries perceptual + the current kernel surface
+    "goldencheck-native>=0.1",
+    "goldenflow-native>=0.1.1",
+    "goldenanalysis-native>=0.1",
+    # --- CLI (doctor / optimize) ---
+    "typer>=0.12",
+    "rich>=13.0",
+]
+
+[project.optional-dependencies]
+# One MCP server exposing every tool — the agent front door.
+mcp = ["goldensuite-mcp>=0.3"]
+# GoldenPipe serving surfaces (A2A + async transports + TUI + REST).
+agent = ["goldenpipe[tui,api,agent]>=1.3"]
+# Everything: full suite + native + MCP + serving.
+all = ["golden-suite[mcp,agent]"]
+dev = ["pytest>=8", "ruff>=0.6"]
+
+[project.scripts]
+golden-suite = "golden_suite.cli:app"
+
+[project.urls]
+Homepage = "https://github.com/benseverndev-oss/goldenmatch"
+Repository = "https://github.com/benseverndev-oss/goldenmatch"
+Documentation = "https://github.com/benseverndev-oss/goldenmatch/tree/main/packages/python/golden-suite#readme"
+Issues = "https://github.com/benseverndev-oss/goldenmatch/issues"
+Changelog = "https://github.com/benseverndev-oss/goldenmatch/blob/main/packages/python/golden-suite/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["golden_suite"]