causari 0.3.0__tar.gz

causari-0.3.0/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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.

causari-0.3.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: causari
+Version: 0.3.0
+Summary: AI-written code has no author. It has causes. Causari measures how many lines from AI-tagged commits are still alive in any git repo and records the prompt, model and files behind every agent edit.
+Author-email: Crovia Trust <info@croviatrust.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://causari.dev
+Project-URL: Method, https://causari.dev/method
+Project-URL: Source, https://github.com/croviatrust/causari
+Project-URL: Issues, https://github.com/croviatrust/causari/issues
+Project-URL: Changelog, https://github.com/croviatrust/causari/blob/main/CHANGELOG.md
+Keywords: ai,provenance,git,agents,mcp,audit,survival
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ∵ causari
+
+**AI-written code has no author. It has causes. Causari records them.**
+
+`re audit` reads plain git history, finds the commits that carry
+machine-readable AI authorship (`Co-Authored-By` trailers, bot authors, agent
+markers) and asks `git blame` how many of their lines are still at HEAD. A
+count, not a grade. The same binary records the prompt, model and files behind
+every agent edit into a local, append-only ledger.
+
+```sh
+pipx run causari audit              # the repo you are in
+pipx run causari audit vercel/next.js
+pip install causari && re audit     # `re` is the short alias every example uses
+```
+
+This package is a launcher, not the program. It holds no binary and does
+nothing at `pip install`. On first run it downloads the release archive for
+your platform from
+`https://github.com/croviatrust/causari/releases/download/v<version>/`,
+checks its SHA-256 against the release's `SHA256SUMS.txt`, unpacks `causari`
+and `re` into `~/.cache/causari/<version>/<target>/` (`$XDG_CACHE_HOME` or
+`%LOCALAPPDATA%` when set) and replaces itself with it (`execv`; a child
+process on Windows). Exit code passes through. Standard library only; no
+telemetry.
+
+Prebuilt binaries exist for Linux (x86_64, aarch64), macOS (x86_64, Apple
+silicon) and Windows (x86_64). Elsewhere, `cargo install causari --locked`.
+
+| Variable | Effect |
+|---|---|
+| `CAUSARI_VERSION` | run another release than the package version |
+| `CAUSARI_BINARY` | path to a binary you already have; nothing is downloaded |
+| `CAUSARI_DOWNLOAD_BASE` | mirror of the release directory (same layout, same `SHA256SUMS.txt`) |
+
+Site and method: [causari.dev](https://causari.dev) ·
+[causari.dev/method](https://causari.dev/method). Source, other installers and
+the full command reference: [github.com/croviatrust/causari](https://github.com/croviatrust/causari).
+Apache-2.0.

causari-0.3.0/README.md

@@ -0,0 +1,39 @@
+# ∵ causari
+
+**AI-written code has no author. It has causes. Causari records them.**
+
+`re audit` reads plain git history, finds the commits that carry
+machine-readable AI authorship (`Co-Authored-By` trailers, bot authors, agent
+markers) and asks `git blame` how many of their lines are still at HEAD. A
+count, not a grade. The same binary records the prompt, model and files behind
+every agent edit into a local, append-only ledger.
+
+```sh
+pipx run causari audit              # the repo you are in
+pipx run causari audit vercel/next.js
+pip install causari && re audit     # `re` is the short alias every example uses
+```
+
+This package is a launcher, not the program. It holds no binary and does
+nothing at `pip install`. On first run it downloads the release archive for
+your platform from
+`https://github.com/croviatrust/causari/releases/download/v<version>/`,
+checks its SHA-256 against the release's `SHA256SUMS.txt`, unpacks `causari`
+and `re` into `~/.cache/causari/<version>/<target>/` (`$XDG_CACHE_HOME` or
+`%LOCALAPPDATA%` when set) and replaces itself with it (`execv`; a child
+process on Windows). Exit code passes through. Standard library only; no
+telemetry.
+
+Prebuilt binaries exist for Linux (x86_64, aarch64), macOS (x86_64, Apple
+silicon) and Windows (x86_64). Elsewhere, `cargo install causari --locked`.
+
+| Variable | Effect |
+|---|---|
+| `CAUSARI_VERSION` | run another release than the package version |
+| `CAUSARI_BINARY` | path to a binary you already have; nothing is downloaded |
+| `CAUSARI_DOWNLOAD_BASE` | mirror of the release directory (same layout, same `SHA256SUMS.txt`) |
+
+Site and method: [causari.dev](https://causari.dev) ·
+[causari.dev/method](https://causari.dev/method). Source, other installers and
+the full command reference: [github.com/croviatrust/causari](https://github.com/croviatrust/causari).
+Apache-2.0.

causari-0.3.0/causari.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: causari
+Version: 0.3.0
+Summary: AI-written code has no author. It has causes. Causari measures how many lines from AI-tagged commits are still alive in any git repo and records the prompt, model and files behind every agent edit.
+Author-email: Crovia Trust <info@croviatrust.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://causari.dev
+Project-URL: Method, https://causari.dev/method
+Project-URL: Source, https://github.com/croviatrust/causari
+Project-URL: Issues, https://github.com/croviatrust/causari/issues
+Project-URL: Changelog, https://github.com/croviatrust/causari/blob/main/CHANGELOG.md
+Keywords: ai,provenance,git,agents,mcp,audit,survival
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ∵ causari
+
+**AI-written code has no author. It has causes. Causari records them.**
+
+`re audit` reads plain git history, finds the commits that carry
+machine-readable AI authorship (`Co-Authored-By` trailers, bot authors, agent
+markers) and asks `git blame` how many of their lines are still at HEAD. A
+count, not a grade. The same binary records the prompt, model and files behind
+every agent edit into a local, append-only ledger.
+
+```sh
+pipx run causari audit              # the repo you are in
+pipx run causari audit vercel/next.js
+pip install causari && re audit     # `re` is the short alias every example uses
+```
+
+This package is a launcher, not the program. It holds no binary and does
+nothing at `pip install`. On first run it downloads the release archive for
+your platform from
+`https://github.com/croviatrust/causari/releases/download/v<version>/`,
+checks its SHA-256 against the release's `SHA256SUMS.txt`, unpacks `causari`
+and `re` into `~/.cache/causari/<version>/<target>/` (`$XDG_CACHE_HOME` or
+`%LOCALAPPDATA%` when set) and replaces itself with it (`execv`; a child
+process on Windows). Exit code passes through. Standard library only; no
+telemetry.
+
+Prebuilt binaries exist for Linux (x86_64, aarch64), macOS (x86_64, Apple
+silicon) and Windows (x86_64). Elsewhere, `cargo install causari --locked`.
+
+| Variable | Effect |
+|---|---|
+| `CAUSARI_VERSION` | run another release than the package version |
+| `CAUSARI_BINARY` | path to a binary you already have; nothing is downloaded |
+| `CAUSARI_DOWNLOAD_BASE` | mirror of the release directory (same layout, same `SHA256SUMS.txt`) |
+
+Site and method: [causari.dev](https://causari.dev) ·
+[causari.dev/method](https://causari.dev/method). Source, other installers and
+the full command reference: [github.com/croviatrust/causari](https://github.com/croviatrust/causari).
+Apache-2.0.

causari-0.3.0/causari.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+causari.egg-info/PKG-INFO
+causari.egg-info/SOURCES.txt
+causari.egg-info/dependency_links.txt
+causari.egg-info/entry_points.txt
+causari.egg-info/top_level.txt
+causari_shim/__init__.py
+tests/test_shim.py

causari-0.3.0/causari.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

causari-0.3.0/causari.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+causari = causari_shim:main_causari
+re = causari_shim:main_re

causari-0.3.0/causari.egg-info/top_level.txt

@@ -0,0 +1 @@
+causari_shim

causari-0.3.0/causari_shim/__init__.py

@@ -0,0 +1,245 @@
+"""Thin launcher for the causari release binaries.
+
+On first run it downloads the archive for this platform from the GitHub
+release that matches the installed package version, checks its SHA-256
+against the release's SHA256SUMS.txt, unpacks ``causari`` and ``re`` into a
+per-version cache and replaces itself with the requested one. Nothing
+happens at ``pip install``: no network, no build step. Standard library only.
+
+Environment:
+  CAUSARI_VERSION        release to run (default: this package's version)
+  CAUSARI_BINARY         path to an existing binary; skips the download
+  CAUSARI_DOWNLOAD_BASE  where releases live (default: GitHub releases)
+  XDG_CACHE_HOME / LOCALAPPDATA  cache root (default: ~/.cache)
+"""
+
+from __future__ import annotations
+
+import hashlib
+import io
+import os
+import platform
+import re
+import shutil
+import stat
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.error
+import urllib.request
+import zipfile
+from pathlib import Path
+from typing import Callable, Dict, Mapping, Optional
+
+REPO = "croviatrust/causari"
+DEFAULT_BASE = f"https://github.com/{REPO}/releases/download"
+TIMEOUT_S = 60
+
+TARGETS = {
+    ("linux", "x86_64"): "x86_64-unknown-linux-gnu",
+    ("linux", "aarch64"): "aarch64-unknown-linux-gnu",
+    ("darwin", "x86_64"): "x86_64-apple-darwin",
+    ("darwin", "aarch64"): "aarch64-apple-darwin",
+    ("windows", "x86_64"): "x86_64-pc-windows-msvc",
+}
+
+
+class ShimError(Exception):
+    """A failure the user can act on; printed as one line, exit 1."""
+
+
+def log(msg: str) -> None:
+    sys.stderr.write(f"causari: {msg}\n")
+    sys.stderr.flush()
+
+
+# ---------------------------------------------------------------- platform
+
+
+def package_version() -> str:
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+
+        return version("causari")
+    except PackageNotFoundError:
+        pass
+    except Exception:  # noqa: BLE001 - metadata backends vary; fall through
+        pass
+    # Source checkout without an installed distribution (tests, development).
+    pyproject = Path(__file__).resolve().parent.parent / "pyproject.toml"
+    m = re.search(r'^version = "([^"]+)"', pyproject.read_text(encoding="utf-8"), re.M)
+    if not m:
+        raise ShimError("cannot determine the causari version: package not installed and no pyproject.toml")
+    return m.group(1)
+
+
+def resolve_version(env: Mapping[str, str]) -> str:
+    v = (env.get("CAUSARI_VERSION") or package_version()).strip()
+    return v[1:] if v.startswith("v") else v
+
+
+def target(system: Optional[str] = None, machine: Optional[str] = None) -> str:
+    system = (system or platform.system()).lower()
+    machine = (machine or platform.machine()).lower()
+    machine = {"amd64": "x86_64", "x64": "x86_64", "arm64": "aarch64"}.get(machine, machine)
+    t = TARGETS.get((system, machine))
+    if not t:
+        raise ShimError(
+            f"no prebuilt binary for {system}/{machine}. Releases cover Linux (x86_64, aarch64), "
+            "macOS (x86_64, Apple silicon) and Windows (x86_64). Build from source instead: "
+            "cargo install causari --locked"
+        )
+    return t
+
+
+def asset_name(version: str, tgt: str) -> str:
+    ext = "zip" if tgt.endswith("-windows-msvc") else "tar.gz"
+    return f"causari-v{version}-{tgt}.{ext}"
+
+
+def exe_name(name: str, tgt: str) -> str:
+    return f"{name}.exe" if tgt.endswith("-windows-msvc") else name
+
+
+def cache_root(env: Mapping[str, str], system: Optional[str] = None) -> Path:
+    if env.get("XDG_CACHE_HOME"):
+        return Path(env["XDG_CACHE_HOME"])
+    system = (system or platform.system()).lower()
+    if system == "windows" and env.get("LOCALAPPDATA"):
+        return Path(env["LOCALAPPDATA"])
+    return Path.home() / ".cache"
+
+
+def cache_dir(version: str, tgt: str, env: Mapping[str, str], system: Optional[str] = None) -> Path:
+    return cache_root(env, system) / "causari" / version / tgt
+
+
+# ---------------------------------------------------------------- download
+
+
+def fetch(url: str) -> bytes:
+    req = urllib.request.Request(url, headers={"User-Agent": f"causari-pypi-shim/{package_version()}", "Accept": "*/*"})
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT_S) as resp:  # follows redirects
+            return resp.read()
+    except urllib.error.HTTPError as e:
+        raise ShimError(f"HTTP {e.code} fetching {url}") from e
+    except (urllib.error.URLError, OSError) as e:
+        raise ShimError(f"{e} fetching {url}") from e
+
+
+def expected_sum(sums_text: str, asset: str) -> str:
+    """One line per file, ``<hex>  <name>`` or ``<hex> *<name>`` (sha256sum format)."""
+    for raw in sums_text.splitlines():
+        m = re.match(r"^([0-9a-fA-F]{64})\s+\*?(.+)$", raw.strip())
+        if m and m.group(2).strip() == asset:
+            return m.group(1).lower()
+    raise ShimError(f"no checksum for {asset} in SHA256SUMS.txt; refusing to run an unverified download")
+
+
+def extract(asset: str, data: bytes, wanted: list) -> Dict[str, bytes]:
+    """Return the wanted files (matched on base name) from a .tar.gz or .zip."""
+    out: Dict[str, bytes] = {}
+    if asset.endswith(".zip"):
+        with zipfile.ZipFile(io.BytesIO(data)) as zf:
+            for info in zf.infolist():
+                base = Path(info.filename).name
+                if base in wanted and not info.is_dir() and base not in out:
+                    out[base] = zf.read(info)
+    else:
+        with tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") as tf:
+            for member in tf:
+                base = Path(member.name).name
+                if base in wanted and member.isfile() and base not in out:
+                    f = tf.extractfile(member)
+                    if f is not None:
+                        out[base] = f.read()
+    missing = [w for w in wanted if w not in out]
+    if missing:
+        raise ShimError(f"archive {asset} does not contain {', '.join(missing)}")
+    return out
+
+
+# ---------------------------------------------------------------- install
+
+
+def ensure_binary(
+    name: str,
+    env: Optional[Mapping[str, str]] = None,
+    fetcher: Callable[[str], bytes] = fetch,
+    system: Optional[str] = None,
+    machine: Optional[str] = None,
+) -> Path:
+    env = os.environ if env is None else env
+    if env.get("CAUSARI_BINARY"):
+        p = Path(env["CAUSARI_BINARY"])
+        if not p.is_file():
+            raise ShimError(f"CAUSARI_BINARY={p} does not exist")
+        return p
+
+    version = resolve_version(env)
+    tgt = target(system, machine)
+    directory = cache_dir(version, tgt, env, system)
+    wanted = [exe_name(n, tgt) for n in ("causari", "re")]
+    binary = directory / exe_name(name, tgt)
+    if binary.is_file():
+        return binary
+
+    base = (env.get("CAUSARI_DOWNLOAD_BASE") or DEFAULT_BASE).rstrip("/")
+    asset = asset_name(version, tgt)
+    log(f"first run: downloading causari v{version} ({tgt}) from {base}/v{version}/")
+    sums = fetcher(f"{base}/v{version}/SHA256SUMS.txt").decode("utf-8", errors="replace")
+    expected = expected_sum(sums, asset)
+    archive = fetcher(f"{base}/v{version}/{asset}")
+    actual = hashlib.sha256(archive).hexdigest()
+    if actual != expected:
+        raise ShimError(f"sha256 mismatch for {asset}: expected {expected}, got {actual}; refusing to run it")
+    files = extract(asset, archive, wanted)
+
+    # Unpack next to the final directory, then rename: a concurrent first run
+    # either wins the rename or finds the winner's files in place.
+    directory.parent.mkdir(parents=True, exist_ok=True)
+    tmp = Path(tempfile.mkdtemp(prefix=f".{tgt}-", dir=directory.parent))
+    try:
+        for file, content in files.items():
+            p = tmp / file
+            p.write_bytes(content)
+            p.chmod(p.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        try:
+            os.rename(tmp, directory)
+        except OSError:
+            if not binary.is_file():
+                raise
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+    log(f"sha256 verified ({actual}); cached in {directory}")
+    return binary
+
+
+# ---------------------------------------------------------------- run
+
+
+def run(name: str, args: Optional[list] = None) -> int:
+    args = sys.argv[1:] if args is None else args
+    try:
+        binary = ensure_binary(name)
+    except ShimError as e:
+        log(str(e))
+        return 1
+    if os.name == "posix":
+        os.execv(str(binary), [str(binary), *args])  # does not return
+    # Windows has no exec that replaces the process: run as a child and
+    # relay its exit code; Ctrl-C reaches the child through the console.
+    try:
+        return subprocess.call([str(binary), *args])
+    except KeyboardInterrupt:
+        return 130
+
+
+def main_causari() -> None:
+    sys.exit(run("causari"))
+
+
+def main_re() -> None:
+    sys.exit(run("re"))

causari-0.3.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "causari"
+version = "0.3.0"
+description = "AI-written code has no author. It has causes. Causari measures how many lines from AI-tagged commits are still alive in any git repo and records the prompt, model and files behind every agent edit."
+readme = "README.md"
+license = "Apache-2.0"
+license-files = ["LICENSE"]
+authors = [{ name = "Crovia Trust", email = "info@croviatrust.com" }]
+requires-python = ">=3.9"
+dependencies = []
+keywords = ["ai", "provenance", "git", "agents", "mcp", "audit", "survival"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Rust",
+  "Topic :: Software Development :: Version Control :: Git",
+  "Topic :: Software Development :: Quality Assurance",
+]
+
+[project.urls]
+Homepage = "https://causari.dev"
+Method = "https://causari.dev/method"
+Source = "https://github.com/croviatrust/causari"
+Issues = "https://github.com/croviatrust/causari/issues"
+Changelog = "https://github.com/croviatrust/causari/blob/main/CHANGELOG.md"
+
+[project.scripts]
+causari = "causari_shim:main_causari"
+re = "causari_shim:main_re"
+
+[tool.setuptools]
+packages = ["causari_shim"]

causari-0.3.0/setup.cfg

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

causari-0.3.0/tests/test_shim.py

@@ -0,0 +1,219 @@
+"""Unit tests for the PyPI launcher. No network: every download goes through
+a fake fetcher that serves an in-memory release."""
+
+from __future__ import annotations
+
+import hashlib
+import io
+import os
+import stat
+import sys
+import tarfile
+import tempfile
+import unittest
+import zipfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+import causari_shim as shim  # noqa: E402
+
+VERSION = "9.9.9"
+LINUX = "x86_64-unknown-linux-gnu"
+WINDOWS = "x86_64-pc-windows-msvc"
+
+
+def fake_tar(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as tf:
+        for name, content in files.items():
+            info = tarfile.TarInfo(name)
+            info.size = len(content)
+            info.mode = 0o755
+            tf.addfile(info, io.BytesIO(content))
+    return buf.getvalue()
+
+
+def fake_zip(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as zf:
+        for name, content in files.items():
+            zf.writestr(name, content)
+    return buf.getvalue()
+
+
+class Release:
+    """An in-memory release directory served by ``fetch``."""
+
+    def __init__(self, asset: str, archive: bytes, sums: str | None = None) -> None:
+        self.asset = asset
+        self.archive = archive
+        self.sums = sums if sums is not None else f"{hashlib.sha256(archive).hexdigest()}  {asset}\n"
+        self.requests: list = []
+
+    def fetch(self, url: str) -> bytes:
+        self.requests.append(url)
+        if url.endswith("/SHA256SUMS.txt"):
+            return self.sums.encode()
+        if url.endswith("/" + self.asset):
+            return self.archive
+        raise shim.ShimError(f"HTTP 404 fetching {url}")
+
+
+def refuse(url: str) -> bytes:
+    raise AssertionError(f"network access attempted: {url}")
+
+
+class ShimTests(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = tempfile.TemporaryDirectory()
+        self.env = {"XDG_CACHE_HOME": self.tmp.name, "CAUSARI_VERSION": VERSION}
+        self.linux_asset = shim.asset_name(VERSION, LINUX)
+        self.linux_bins = {"causari": b"#!/bin/sh\necho causari\n", "re": b"#!/bin/sh\necho re\n"}
+        self.logged: list = []
+        self._log = shim.log
+        shim.log = self.logged.append
+
+    def tearDown(self) -> None:
+        shim.log = self._log
+        self.tmp.cleanup()
+
+    def cache(self, tgt: str) -> Path:
+        return Path(self.tmp.name) / "causari" / VERSION / tgt
+
+    # --- platform ------------------------------------------------------
+
+    def test_targets(self) -> None:
+        self.assertEqual(shim.target("Linux", "x86_64"), LINUX)
+        self.assertEqual(shim.target("Linux", "aarch64"), "aarch64-unknown-linux-gnu")
+        self.assertEqual(shim.target("Darwin", "arm64"), "aarch64-apple-darwin")
+        self.assertEqual(shim.target("Darwin", "x86_64"), "x86_64-apple-darwin")
+        self.assertEqual(shim.target("Windows", "AMD64"), WINDOWS)
+
+    def test_unsupported_platform_names_itself_and_the_source_build(self) -> None:
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.target("FreeBSD", "x86_64")
+        self.assertIn("freebsd/x86_64", str(cm.exception))
+        self.assertIn("cargo install causari --locked", str(cm.exception))
+        with self.assertRaises(shim.ShimError):
+            shim.target("Windows", "ARM64")
+
+    def test_version_env_strips_v(self) -> None:
+        self.assertEqual(shim.resolve_version({"CAUSARI_VERSION": "v1.2.3"}), "1.2.3")
+        self.assertEqual(shim.resolve_version({"CAUSARI_VERSION": "1.2.3"}), "1.2.3")
+        self.assertRegex(shim.resolve_version({}), r"^\d+\.\d+\.\d+$")
+
+    def test_asset_names(self) -> None:
+        self.assertEqual(shim.asset_name("0.2.0", LINUX), "causari-v0.2.0-x86_64-unknown-linux-gnu.tar.gz")
+        self.assertEqual(shim.asset_name("0.2.0", WINDOWS), "causari-v0.2.0-x86_64-pc-windows-msvc.zip")
+
+    def test_cache_root(self) -> None:
+        self.assertEqual(shim.cache_root({"XDG_CACHE_HOME": "/x"}), Path("/x"))
+        self.assertEqual(shim.cache_root({"LOCALAPPDATA": r"C:\L"}, "Windows"), Path(r"C:\L"))
+        self.assertEqual(shim.cache_root({"LOCALAPPDATA": r"C:\L"}, "Linux"), Path.home() / ".cache")
+
+    # --- checksums ------------------------------------------------------
+
+    def test_expected_sum_parses_sha256sum_formats(self) -> None:
+        h = "a" * 64
+        self.assertEqual(shim.expected_sum(f"{h}  x.tar.gz\n", "x.tar.gz"), h)
+        self.assertEqual(shim.expected_sum(f"{h} *x.tar.gz\r\n", "x.tar.gz"), h)
+        self.assertEqual(shim.expected_sum(f"{'b' * 64}  y.tar.gz\n{h}  x.tar.gz\n", "x.tar.gz"), h)
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.expected_sum(f"{h}  y.tar.gz\n", "x.tar.gz")
+        self.assertIn("no checksum for x.tar.gz", str(cm.exception))
+
+    def test_checksum_mismatch_refuses_and_caches_nothing(self) -> None:
+        archive = fake_tar(self.linux_bins)
+        tampered = Release(self.linux_asset, archive, sums=f"{'0' * 64}  {self.linux_asset}\n")
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.ensure_binary("re", self.env, tampered.fetch, "Linux", "x86_64")
+        self.assertIn("sha256 mismatch", str(cm.exception))
+        self.assertFalse(self.cache(LINUX).exists())
+        self.assertFalse(any(p.is_dir() for p in self.cache(LINUX).parent.glob(".*")) if self.cache(LINUX).parent.exists() else False)
+
+    def test_missing_asset_in_sums_refuses(self) -> None:
+        archive = fake_tar(self.linux_bins)
+        rel = Release(self.linux_asset, archive, sums=f"{'0' * 64}  other.tar.gz\n")
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.ensure_binary("re", self.env, rel.fetch, "Linux", "x86_64")
+        self.assertIn("no checksum for", str(cm.exception))
+        self.assertEqual(len(rel.requests), 1, "the archive is not fetched without a checksum to hold it to")
+
+    # --- install --------------------------------------------------------
+
+    def test_first_run_downloads_verifies_and_caches_both_names(self) -> None:
+        rel = Release(self.linux_asset, fake_tar(self.linux_bins))
+        binary = shim.ensure_binary("re", self.env, rel.fetch, "Linux", "x86_64")
+        self.assertEqual(binary, self.cache(LINUX) / "re")
+        self.assertEqual(binary.read_bytes(), self.linux_bins["re"])
+        self.assertEqual((self.cache(LINUX) / "causari").read_bytes(), self.linux_bins["causari"])
+        self.assertTrue(binary.stat().st_mode & stat.S_IXUSR)
+        self.assertEqual(
+            rel.requests,
+            [
+                f"{shim.DEFAULT_BASE}/v{VERSION}/SHA256SUMS.txt",
+                f"{shim.DEFAULT_BASE}/v{VERSION}/{self.linux_asset}",
+            ],
+        )
+        self.assertEqual([p.name for p in self.cache(LINUX).parent.iterdir()], [LINUX], "no temp dir left behind")
+        self.assertTrue(any(m.startswith("first run: downloading") for m in self.logged), self.logged)
+        self.assertTrue(any(m.startswith("sha256 verified") for m in self.logged), self.logged)
+
+    def test_cache_hit_makes_no_request(self) -> None:
+        d = self.cache(LINUX)
+        d.mkdir(parents=True)
+        (d / "causari").write_bytes(b"cached")
+        binary = shim.ensure_binary("causari", self.env, refuse, "Linux", "x86_64")
+        self.assertEqual(binary, d / "causari")
+
+    def test_download_base_override(self) -> None:
+        env = dict(self.env, CAUSARI_DOWNLOAD_BASE="https://mirror.example/causari/")
+        rel = Release(self.linux_asset, fake_tar(self.linux_bins))
+        shim.ensure_binary("re", env, rel.fetch, "Linux", "x86_64")
+        self.assertTrue(all(u.startswith(f"https://mirror.example/causari/v{VERSION}/") for u in rel.requests), rel.requests)
+
+    def test_windows_zip_yields_exe_names(self) -> None:
+        asset = shim.asset_name(VERSION, WINDOWS)
+        rel = Release(asset, fake_zip({"causari.exe": b"MZcausari", "re.exe": b"MZre"}))
+        binary = shim.ensure_binary("re", self.env, rel.fetch, "Windows", "AMD64")
+        self.assertEqual(binary, self.cache(WINDOWS) / "re.exe")
+        self.assertEqual(binary.read_bytes(), b"MZre")
+
+    def test_archive_missing_a_binary_is_refused(self) -> None:
+        rel = Release(self.linux_asset, fake_tar({"re": b"only re"}))
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.ensure_binary("re", self.env, rel.fetch, "Linux", "x86_64")
+        self.assertIn("does not contain causari", str(cm.exception))
+        self.assertFalse(self.cache(LINUX).exists())
+
+    def test_archive_with_directory_prefix_is_accepted(self) -> None:
+        rel = Release(self.linux_asset, fake_tar({"causari-v9/causari": b"c", "causari-v9/re": b"r"}))
+        binary = shim.ensure_binary("re", self.env, rel.fetch, "Linux", "x86_64")
+        self.assertEqual(binary.read_bytes(), b"r")
+
+    def test_causari_binary_env_skips_download(self) -> None:
+        own = Path(self.tmp.name) / "my-re"
+        own.write_bytes(b"mine")
+        env = dict(self.env, CAUSARI_BINARY=str(own))
+        self.assertEqual(shim.ensure_binary("re", env, refuse, "Linux", "x86_64"), own)
+        env["CAUSARI_BINARY"] = str(Path(self.tmp.name) / "missing")
+        with self.assertRaises(shim.ShimError) as cm:
+            shim.ensure_binary("re", env, refuse, "Linux", "x86_64")
+        self.assertIn("does not exist", str(cm.exception))
+
+    # --- run ------------------------------------------------------------
+
+    def test_run_reports_shim_errors_with_exit_1(self) -> None:
+        env = dict(self.env, CAUSARI_BINARY=str(Path(self.tmp.name) / "missing"))
+        old = dict(os.environ)
+        os.environ.update(env)
+        try:
+            self.assertEqual(shim.run("re", ["--version"]), 1)
+        finally:
+            os.environ.clear()
+            os.environ.update(old)
+
+
+if __name__ == "__main__":
+    unittest.main()