atomadic-forge 0.78.0__tar.gz → 0.80.0__tar.gz

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/.github/workflows/metrics-auto-regen.yml

@@ -33,7 +33,7 @@ jobs:
   regen:
     runs-on: ubuntu-latest
     timeout-minutes: 8
-    if: ${{ !contains(github.event.head_commit.message, '[skip ci]') && !contains(github.event.head_commit.message, 'chore(metrics): auto-regenerate') }}
+    if: ${{ !contains(github.event.head_commit.message || '', '[skip ci]') && !contains(github.event.head_commit.message || '', 'chore(metrics): auto-regenerate') }}
     steps:
       - uses: actions/checkout@v4
         with:

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## v0.80.0 — 2026-05-08
+
+- feat(forge): v0.80 Monadic Laws — MCB / AHLP / AIOM / IFWC-lite
+
+
+## v0.79.0 — 2026-05-08
+
+- feat(forge): replay — deterministic golden-recipe execution
+- fix(compat): replace datetime.UTC with timezone.utc for Python 3.10 compat
+- fix(ci): null-safe head_commit.message in metrics-auto-regen if condition
+- chore(metrics): sync forge_metrics.json after cli_verb_count method change
+- fix(surface): regenerate surface.json with package_version 0.78.0
+- fix(metrics): replace upward a4 import in _live_cli_verb_count with file scan
+- chore(release): sync artifacts + doc anchors for v0.78.0
+
+
 ## v0.78.0 — 2026-05-08
 
 - feat(forge): token-savings auto-ledger across every enriched verb

{atomadic_forge-0.78.0/src/atomadic_forge.egg-info → atomadic_forge-0.80.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atomadic-forge
-Version: 0.78.0
+Version: 0.80.0
 Summary: Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code.
 Author: Atomadic
 License-Expression: BUSL-1.1
@@ -225,8 +225,8 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 
 | MCP tools | **10 tools · 116 actions** |
 | CLI verbs | **59** |
-| Source files | **233** (~47K LOC) |
-| Tests | **1592 passing** across **116 test files** |
+| Source files | **242** (~48K LOC) |
+| Tests | **1608 passing** across **119 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/README.md

@@ -193,8 +193,8 @@ Full tool reference: [docs/MCP_TOOLS.md](docs/MCP_TOOLS.md) | First call: `welco
 
 | MCP tools | **10 tools · 116 actions** |
 | CLI verbs | **59** |
-| Source files | **233** (~47K LOC) |
-| Tests | **1592 passing** across **116 test files** |
+| Source files | **242** (~48K LOC) |
+| Tests | **1608 passing** across **119 test files** |
 | Lean4 formal proofs | **872 theorems** (mathematically verified core logic) |
 | Monadic tiers | **5** (a0 → a4, strict upward-only composition) |
 | Languages | Python, JS/TS, Swift, Kotlin, Go, Rust |

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/docs/CI_CD.md

@@ -46,7 +46,7 @@ jobs:
         run: |
           pip install atomadic-forge          # PyPI (preferred)
           # Or pin to an exact tag:
-          #   pip install "git+https://github.com/atomadictech/atomadic-forge@v0.77.0"
+          #   pip install "git+https://github.com/atomadictech/atomadic-forge@v0.78.0"
           # Or vendor wheels: pip install --no-index --find-links wheels/ atomadic-forge
 
       - name: Wire scan (upward-import discipline)
@@ -97,7 +97,7 @@ forge-certify:
   image: python:3.11-slim
   timeout: 10 minutes
   before_script:
-    - pip install "git+https://github.com/atomadictech/atomadic-forge@v0.77.0"
+    - pip install "git+https://github.com/atomadictech/atomadic-forge@v0.78.0"
   script:
     - forge wire src/your_package --fail-on-violations --json > wire.json
     - forge certify . --package your_package --fail-under 75 --json > certify.json
@@ -156,7 +156,7 @@ Then in **the consuming repo's** `.pre-commit-config.yaml`:
 ```yaml
 repos:
   - repo: https://github.com/atomadictech/atomadic-forge
-    rev: v0.77.0
+    rev: v0.78.0
     hooks:
       - id: forge-wire
       - id: forge-certify

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/docs/COMMANDS.md

@@ -1,6 +1,6 @@
 # Atomadic Forge — Command Reference
 
-All verbs available in the `forge` CLI as of 0.77.0
+All verbs available in the `forge` CLI as of 0.78.0
 
 > For the structured per-verb reference (with options, examples, and
 > output samples), see [02-commands.md](02-commands.md). This page is

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/docs/FORMALIZATION.md

@@ -39,7 +39,7 @@ Forge certify scores out of **100** in two layers:
 JS / TS packages cap at **60/100** today: they earn the four
 structural axes, but the +25 runtime-import smoke and +30 behavioural
 pytest are Python-only. Wiring `npm test` / Vitest into the
-behavioural axis is on the post-v0.77.0 roadmap.
+behavioural axis is on the post-v0.78.0 roadmap.
 
 ---
 
@@ -131,7 +131,7 @@ runtime dependency makes the package unusable.
 
 **Why JS/TS does not get this gate yet.** AAM §5.4 (Threats to
 Validity) explicitly flags polyglot runtime gating as a roadmap
-item (post-v0.77.0): the equivalent for JS would be an `npm test`
+item (post-v0.78.0): the equivalent for JS would be an `npm test`
 invocation, which requires a Node toolchain we do not yet bundle.
 
 **Citation.** AAM §5.1 (Core Pipeline Pseudocode); AAM §5.4 (Threats

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/docs/RECEIPT.md

@@ -30,7 +30,7 @@ referenced from the Receipt.
 {
   "schema_version": "atomadic-forge.receipt/v1",
   "generated_at_utc": "2026-04-28T17:42:11Z",
-  "forge_version": "0.77.0",
+  "forge_version": "0.78.0",
   "verdict": "PASS",
   "project":           { ... },
   "certify":           { ... },
@@ -108,7 +108,7 @@ cited:
 {
   "schema_version": "atomadic-forge.receipt/v1",
   "generated_at_utc": "2026-04-28T17:42:11Z",
-  "forge_version": "0.77.0",
+  "forge_version": "0.78.0",
   "verdict": "PASS",
 
   "project": {

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "atomadic-forge"
-version = "0.78.0"
+version = "0.80.0"
 description = "Atomadic Forge — absorb, enforce, emerge. Polyglot (Python · JavaScript/TypeScript · Rust · Go · Swift · Kotlin) architecture guardian for AI-generated code."
 readme = "README.md"
 requires-python = ">=3.10"

{atomadic_forge-0.78.0 → atomadic_forge-0.80.0}/src/atomadic_forge/a1_at_functions/doc_auto_update.py

@@ -58,7 +58,7 @@ from __future__ import annotations
 import json
 import re
 import subprocess
-from datetime import UTC, datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
@@ -318,7 +318,7 @@ def _build_metrics_table(metrics: dict[str, Any]) -> str:
 
 def _build_changelog_block(version: str, log_lines: list[str]) -> str:
     """Generate a CHANGELOG section for the given version."""
-    today = datetime.now(UTC).strftime("%Y-%m-%d")
+    today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
     items = "\n".join(f"- {line}" for line in log_lines[:20]) if log_lines else "- (see git log)"
     return (
         f"## v{version} — {today}\n\n"

atomadic_forge-0.80.0/src/atomadic_forge/a1_at_functions/ifwc_fuzz.py

@@ -0,0 +1,158 @@
+"""Tier a1 — IFWC-lite property-based fuzzer.
+
+Any callable carrying an ``__invariants__`` dict is fair game:
+
+    def add(a: int, b: int) -> int:
+        return a + b
+    add.__invariants__ = {
+        "args": {"a": "integers", "b": "integers"},
+        "post": "lambda r, a, b: r == a + b",
+    }
+
+``args`` maps parameter name → hypothesis strategy name (or ``"any"``).
+``post`` is a string lambda evaluated with ``(result, **kwargs)``;
+returning False (or raising) ⇒ falsifying example captured.
+
+Pure stdlib + ``hypothesis`` (already a Forge dev dep). No I/O.
+"""
+from __future__ import annotations
+
+import importlib
+import inspect
+from collections.abc import Callable
+from typing import Any
+
+SCHEMA_VERSION_IFWC_V1 = "atomadic-forge.ifwc/v1"
+
+
+_STRATEGY_MAP: dict[str, str] = {
+    "integers": "integers",
+    "floats": "floats",
+    "text": "text",
+    "booleans": "booleans",
+    "none": "none",
+    "any": "integers",  # default fallback
+}
+
+
+def _build_strategies(args_spec: dict[str, str]) -> dict[str, Any]:
+    """Translate ``{"a": "integers"}`` → ``{"a": st.integers()}``."""
+    try:
+        from hypothesis import strategies as st
+    except ImportError as exc:  # pragma: no cover - dev dep
+        raise RuntimeError(
+            "hypothesis not installed; `pip install hypothesis`"
+        ) from exc
+    out: dict[str, Any] = {}
+    for name, strat_name in args_spec.items():
+        key = _STRATEGY_MAP.get(strat_name, "integers")
+        out[name] = getattr(st, key)()
+    return out
+
+
+def fuzz_callable(
+    fn: Callable[..., Any],
+    *,
+    max_examples: int = 100,
+) -> dict[str, Any]:
+    """Run hypothesis against ``fn`` using its ``__invariants__`` spec.
+
+    Returns ``{verdict, examples_run, falsifying_example|None,
+    error|None, function}``.
+    """
+    spec = getattr(fn, "__invariants__", None)
+    if not spec:
+        return {
+            "schema_version": SCHEMA_VERSION_IFWC_V1,
+            "function": fn.__name__,
+            "verdict": "SKIP",
+            "reason": "no __invariants__ marker",
+            "examples_run": 0,
+        }
+
+    try:
+        from hypothesis import given, settings
+    except ImportError:
+        return {
+            "schema_version": SCHEMA_VERSION_IFWC_V1,
+            "function": fn.__name__,
+            "verdict": "ERROR",
+            "reason": "hypothesis not installed",
+            "examples_run": 0,
+        }
+
+    args_spec = dict(spec.get("args") or {})
+    post = spec.get("post")
+    strategies = _build_strategies(args_spec)
+    counter = {"n": 0}
+    failure = {"example": None, "error": None}
+
+    @settings(max_examples=int(max_examples), deadline=None)
+    @given(**strategies)
+    def _runner(**kwargs: Any) -> None:
+        counter["n"] += 1
+        result = fn(**kwargs)
+        if post:
+            ok = False
+            try:
+                check = eval(post) if isinstance(post, str) else post  # noqa: S307
+                ok = bool(check(result, **kwargs))
+            except Exception as exc:  # noqa: BLE001
+                failure["example"] = kwargs
+                failure["error"] = str(exc)
+                raise AssertionError(
+                    f"post-condition raised: {exc}"
+                ) from exc
+            if not ok:
+                failure["example"] = kwargs
+                raise AssertionError(
+                    f"post-condition False on {kwargs} -> {result!r}",
+                )
+
+    try:
+        _runner()
+    except Exception as exc:  # noqa: BLE001
+        return {
+            "schema_version": SCHEMA_VERSION_IFWC_V1,
+            "function": fn.__name__,
+            "verdict": "FAIL",
+            "examples_run": counter["n"],
+            "falsifying_example": failure["example"],
+            "error": str(exc),
+        }
+    return {
+        "schema_version": SCHEMA_VERSION_IFWC_V1,
+        "function": fn.__name__,
+        "verdict": "PASS",
+        "examples_run": counter["n"],
+        "falsifying_example": None,
+    }
+
+
+def fuzz_module(
+    module_name: str,
+    *,
+    max_examples: int = 100,
+) -> dict[str, Any]:
+    """Import ``module_name`` and fuzz every callable carrying invariants."""
+    mod = importlib.import_module(module_name)
+    results: list[dict[str, Any]] = []
+    for _name, obj in inspect.getmembers(mod):
+        if callable(obj) and hasattr(obj, "__invariants__"):
+            results.append(fuzz_callable(obj, max_examples=max_examples))
+    pass_n = sum(1 for r in results if r["verdict"] == "PASS")
+    fail_n = sum(1 for r in results if r["verdict"] == "FAIL")
+    return {
+        "schema_version": SCHEMA_VERSION_IFWC_V1,
+        "module": module_name,
+        "function_count": len(results),
+        "pass_count": pass_n,
+        "fail_count": fail_n,
+        "verdict": "PASS" if fail_n == 0 and pass_n > 0 else (
+            "FAIL" if fail_n else "EMPTY"
+        ),
+        "results": results,
+    }
+
+
+__all__ = ["SCHEMA_VERSION_IFWC_V1", "fuzz_callable", "fuzz_module"]

atomadic_forge-0.80.0/src/atomadic_forge/a1_at_functions/monadic_laws.py

@@ -0,0 +1,235 @@
+"""Tier a1 — Monadic Laws (v0.80): MCB / AHLP / AIOM checkers.
+
+Three pure deterministic AST scanners that surface the v7.0 blueprint
+laws without breaking existing repos:
+
+* :func:`scan_mcb`  — Monadic Compute Bounding: ban ``while`` and
+  recursion in tier-a1 modules.
+* :func:`fingerprint_a1` — AHLP-style SHA-256 of normalized AST
+  per a1 module. Tamper-evident receipts foundation.
+* :func:`scan_aiom` — Algebraic I/O Monad enforcer: forbid network /
+  process / socket imports from tier-a1 (the pure layer).
+
+All three are pure: AST-in, dict-out, no side effects.
+"""
+from __future__ import annotations
+
+import ast
+import hashlib
+from pathlib import Path
+from typing import Any
+
+SCHEMA_VERSION_MCB_V1 = "atomadic-forge.mcb/v1"
+SCHEMA_VERSION_AHLP_V1 = "atomadic-forge.ahlp.fingerprint/v1"
+SCHEMA_VERSION_AIOM_V1 = "atomadic-forge.aiom/v1"
+
+# Modules forbidden in tier-a1 (the pure mathematical layer).
+# Keep this list conservative — anything that talks to the OS,
+# network, or a subprocess. ``pathlib``/``json`` are allowed:
+# they're stdlib data shapers, not effect carriers.
+_AIOM_FORBIDDEN: frozenset[str] = frozenset({
+    "requests", "urllib", "urllib3", "httpx", "aiohttp",
+    "http", "socket", "smtplib", "ftplib", "telnetlib",
+    "subprocess", "multiprocessing",
+    "os.system", "os.popen", "shutil.move",  # checked via attribute walk
+})
+
+_AIOM_FORBIDDEN_PREFIX: tuple[str, ...] = (
+    "requests", "urllib", "urllib3", "httpx", "aiohttp",
+    "http.", "socket", "smtplib", "ftplib", "telnetlib",
+    "subprocess", "multiprocessing.",
+)
+
+A1_TIER_DIR = "a1_at_functions"
+
+
+# ── MCB ─────────────────────────────────────────────────────────────
+
+
+def _scan_one_for_while_recursion(path: Path) -> list[dict[str, Any]]:
+    """Return MCB violations in one file (empty list ⇒ clean)."""
+    findings: list[dict[str, Any]] = []
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+    except (OSError, SyntaxError):
+        return findings
+    func_names = {
+        n.name for n in ast.walk(tree)
+        if isinstance(n, ast.FunctionDef | ast.AsyncFunctionDef)
+    }
+    for node in ast.walk(tree):
+        if isinstance(node, ast.While):
+            findings.append({
+                "kind": "while_loop",
+                "line": node.lineno,
+                "detail": "unbounded `while` in pure-tier function",
+            })
+        elif isinstance(node, ast.Call):
+            # Direct recursion: `foo(...)` inside `def foo`.
+            f = node.func
+            if isinstance(f, ast.Name) and f.id in func_names:
+                # Walk up: are we inside a function with the same name?
+                # Cheap textual heuristic: only flag when name matches.
+                findings.append({
+                    "kind": "self_call",
+                    "line": node.lineno,
+                    "detail": f"possible recursion via `{f.id}(...)`",
+                })
+    return findings
+
+
+def scan_mcb(package_root: Path) -> dict[str, Any]:
+    """Scan ``<package_root>/a1_at_functions/`` for MCB violations.
+
+    Returns a structured report with verdict PASS / FAIL and the list
+    of files + findings. The report is advisory unless the caller
+    enforces it (e.g. ``forge wire --strict-mcb``).
+    """
+    pkg = Path(package_root)
+    a1_dir = pkg / A1_TIER_DIR
+    files: list[dict[str, Any]] = []
+    if a1_dir.is_dir():
+        for f in sorted(a1_dir.glob("*.py")):
+            if f.name == "__init__.py":
+                continue
+            findings = _scan_one_for_while_recursion(f)
+            if findings:
+                files.append({
+                    "file": str(f.relative_to(pkg)),
+                    "findings": findings,
+                })
+    total = sum(len(it["findings"]) for it in files)
+    return {
+        "schema_version": SCHEMA_VERSION_MCB_V1,
+        "package_root": str(pkg),
+        "violation_count": total,
+        "files": files,
+        "verdict": "PASS" if total == 0 else "FAIL",
+    }
+
+
+# ── AHLP fingerprint ────────────────────────────────────────────────
+
+
+def _normalized_ast_bytes(path: Path) -> bytes:
+    """Return a stable byte representation of the file's AST.
+
+    ``ast.dump`` with ``annotate_fields=True, include_attributes=False``
+    is reproducible across runs and stable to whitespace / comment
+    edits — which is exactly what we want for a tamper-evident
+    fingerprint of *logic*, not formatting.
+    """
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+    except (OSError, SyntaxError):
+        return b""
+    return ast.dump(tree, annotate_fields=True,
+                     include_attributes=False).encode("utf-8")
+
+
+def fingerprint_a1(package_root: Path) -> dict[str, Any]:
+    """SHA-256 every a1 module's normalized AST.
+
+    Returns ``{schema_version, package_root, count, fingerprints[]}``.
+    Each fingerprint entry: ``{file, sha256, ast_bytes_len}``.
+    """
+    pkg = Path(package_root)
+    a1_dir = pkg / A1_TIER_DIR
+    out: list[dict[str, Any]] = []
+    if a1_dir.is_dir():
+        for f in sorted(a1_dir.glob("*.py")):
+            if f.name == "__init__.py":
+                continue
+            ast_bytes = _normalized_ast_bytes(f)
+            if not ast_bytes:
+                continue
+            digest = hashlib.sha256(ast_bytes).hexdigest()
+            out.append({
+                "file": str(f.relative_to(pkg)),
+                "sha256": digest,
+                "ast_bytes_len": len(ast_bytes),
+            })
+    return {
+        "schema_version": SCHEMA_VERSION_AHLP_V1,
+        "package_root": str(pkg),
+        "count": len(out),
+        "fingerprints": out,
+    }
+
+
+# ── AIOM ────────────────────────────────────────────────────────────
+
+
+def _scan_one_for_io_imports(path: Path) -> list[dict[str, Any]]:
+    findings: list[dict[str, Any]] = []
+    try:
+        tree = ast.parse(path.read_text(encoding="utf-8"))
+    except (OSError, SyntaxError):
+        return findings
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                if _is_forbidden(alias.name):
+                    findings.append({
+                        "kind": "import",
+                        "module": alias.name,
+                        "line": node.lineno,
+                    })
+        elif isinstance(node, ast.ImportFrom):
+            mod = node.module or ""
+            if _is_forbidden(mod):
+                findings.append({
+                    "kind": "from_import",
+                    "module": mod,
+                    "line": node.lineno,
+                })
+    return findings
+
+
+def _is_forbidden(modname: str) -> bool:
+    if not modname:
+        return False
+    if modname in _AIOM_FORBIDDEN:
+        return True
+    return any(modname == p.rstrip(".") or modname.startswith(p)
+                for p in _AIOM_FORBIDDEN_PREFIX)
+
+
+def scan_aiom(package_root: Path) -> dict[str, Any]:
+    """Scan ``<package_root>/a1_at_functions/`` for forbidden I/O imports.
+
+    Pure-tier modules cannot reach the network, processes, sockets, or
+    SMTP. The blocklist is conservative — ``pathlib``, ``json``,
+    ``hashlib`` etc. remain allowed because they're data shapers.
+    """
+    pkg = Path(package_root)
+    a1_dir = pkg / A1_TIER_DIR
+    files: list[dict[str, Any]] = []
+    if a1_dir.is_dir():
+        for f in sorted(a1_dir.glob("*.py")):
+            if f.name == "__init__.py":
+                continue
+            findings = _scan_one_for_io_imports(f)
+            if findings:
+                files.append({
+                    "file": str(f.relative_to(pkg)),
+                    "findings": findings,
+                })
+    total = sum(len(it["findings"]) for it in files)
+    return {
+        "schema_version": SCHEMA_VERSION_AIOM_V1,
+        "package_root": str(pkg),
+        "violation_count": total,
+        "files": files,
+        "verdict": "PASS" if total == 0 else "FAIL",
+    }
+
+
+__all__ = [
+    "SCHEMA_VERSION_AHLP_V1",
+    "SCHEMA_VERSION_AIOM_V1",
+    "SCHEMA_VERSION_MCB_V1",
+    "fingerprint_a1",
+    "scan_aiom",
+    "scan_mcb",
+]