atomadic-forge 0.16.2__tar.gz → 0.50.0__tar.gz

{atomadic_forge-0.16.2 → atomadic_forge-0.50.0}/.github/workflows/ci.yml

@@ -94,3 +94,24 @@ jobs:
         with:
           name: atomadic-forge-dist
           path: dist/*
+
+  metrics:
+    name: Metrics freshness
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.12"
+          cache: pip
+
+      - name: Install package
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[dev]"
+
+      - name: Verify forge_metrics.json is current
+        run: python scripts/update_metrics.py --check

{atomadic_forge-0.16.2 → atomadic_forge-0.50.0}/.github/workflows/customer-refactor.yml

@@ -1,4 +1,4 @@
-# Customer Refactor — fully automated $499 forge.atomadic.tech fulfillment.
+# Customer Refactor — fully automated $149/$99 forge.atomadic.tech fulfillment.
 #
 # Triggered by Atomadic's REFACTOR_REPO action via the GitHub
 # repository_dispatch API. The cognition worker POSTs:
@@ -28,7 +28,7 @@
 # The cognition endpoint emails the customer (apology + refund offer) and
 # pings Dad on Discord so the order can be retried manually.
 
-name: Customer Refactor (forge.atomadic.tech $499 fulfillment)
+name: Customer Refactor (forge.atomadic.tech $149/$99 fulfillment)
 
 on:
   repository_dispatch:
@@ -55,7 +55,7 @@ on:
         description: "Amount paid (cents)"
         required: false
         type: string
-        default: "49900"
+        default: "9900"
 
 permissions:
   contents: read
@@ -234,7 +234,7 @@ jobs:
             echo "   above."
             echo "4. Run your own test suite — Forge does not touch behavior."
             echo ""
-            echo "One round of revisions is included with your $499 order."
+            echo "One round of revisions is included with your order."
             echo "Reply to the email you received from Atomadic with anything"
             echo "you want changed."
             echo ""

atomadic_forge-0.50.0/.github/workflows/metrics-auto-regen.yml

@@ -0,0 +1,96 @@
+name: Metrics Auto-Regenerate
+
+# Single-source-of-truth pipeline. On every push to main, recomputes the
+# canonical forge_metrics.json artifact and pushes a follow-up commit if
+# the artifact drifted from what the source tree should produce.
+#
+# Together with metrics-drift.yml (CI gate on PRs), this means:
+#   - PRs are blocked on stale metrics.
+#   - Direct pushes to main self-heal automatically.
+#   - Public surfaces (atomadic.tech, shields.io endpoints proxied by
+#     the worker) always read live numbers from the same JSON.
+#
+# Lean theorem count requires the IP-protected mhed-codex repo. The
+# FORGE_MHED_CODEX_REPO secret (org-level) provides a deploy-key URL;
+# without it the lean_theorems block is preserved from the prior commit
+# (see surgical merge step below) so this workflow never destroys real
+# numbers when running without the IP repo attached.
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - "src/atomadic_forge/**"
+      - "tests/**"
+      - "pyproject.toml"
+      - "src/atomadic_forge/a1_at_functions/forge_metrics.py"
+      - "src/atomadic_forge/a3_og_features/forge_metrics_feature.py"
+
+permissions:
+  contents: write
+
+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') }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install package
+        run: pip install -e . --quiet
+      - name: Run pytest to count live passing
+        id: pytest
+        run: |
+          set +e
+          out=$(python -m pytest tests/ -q --no-header 2>&1 | tail -3)
+          echo "$out"
+          passed=$(echo "$out" | grep -oE '[0-9]+ passed' | head -1 | grep -oE '[0-9]+')
+          echo "passed=${passed:-0}" >> "$GITHUB_OUTPUT"
+      - name: Optionally clone IP-protected mhed-codex (preserves lean count)
+        if: ${{ env.MHED_CODEX_DEPLOY_KEY != '' }}
+        env:
+          MHED_CODEX_DEPLOY_KEY: ${{ secrets.MHED_CODEX_DEPLOY_KEY }}
+        run: |
+          mkdir -p ~/.ssh && chmod 700 ~/.ssh
+          echo "$MHED_CODEX_DEPLOY_KEY" > ~/.ssh/mhed_key && chmod 600 ~/.ssh/mhed_key
+          GIT_SSH_COMMAND="ssh -i ~/.ssh/mhed_key -o StrictHostKeyChecking=no" \
+            git clone --depth 1 git@github.com:atomadictech/mhed-codex.git /tmp/mhed-codex
+          echo "FORGE_MHED_CODEX=/tmp/mhed-codex" >> "$GITHUB_ENV"
+      - name: Regenerate forge_metrics.json
+        run: |
+          # Save the previous lean_theorems block so we can preserve it
+          # when no mhed-codex is attached (avoid zeroing the public
+          # number on a routine source-only push).
+          python -c "import json; d=json.load(open('forge_metrics.json')); print(json.dumps(d.get('lean_theorems', {})))" > /tmp/prev_lean.json
+          forge metrics --apply --tests-passing ${{ steps.pytest.outputs.passed }}
+          # If no mhed-codex was attached this run, restore prior lean block.
+          if [ -z "${FORGE_MHED_CODEX:-}" ]; then
+            python <<'PY'
+          import json, pathlib
+          p = pathlib.Path("forge_metrics.json")
+          d = json.loads(p.read_text())
+          prev = json.loads(pathlib.Path("/tmp/prev_lean.json").read_text())
+          # Only restore if the freshly-computed block reports found=False
+          # (i.e. mhed-codex unavailable) AND the prior had a real count.
+          if not d.get("lean_theorems", {}).get("found") and prev.get("count"):
+              d["lean_theorems"] = prev
+              p.write_text(json.dumps(d, indent=2, sort_keys=True) + "\n")
+          PY
+          fi
+      - name: Commit if drifted
+        run: |
+          git config user.name  "atomadic-bot"
+          git config user.email "bot@atomadic.tech"
+          if git diff --quiet -- forge_metrics.json; then
+            echo "metrics already current — no commit"
+            exit 0
+          fi
+          git add forge_metrics.json
+          git commit -m "chore(metrics): auto-regenerate forge_metrics.json [skip ci]"
+          git push origin main

atomadic_forge-0.50.0/.github/workflows/metrics-drift.yml

@@ -0,0 +1,61 @@
+name: Metrics Drift Gate
+
+# CI gate that keeps forge_metrics.json in sync with the live forge surface.
+# Any PR that changes TOOLS, CLI registry, source/test counts, or
+# pyproject.toml WITHOUT regenerating forge_metrics.json fails this check.
+#
+# Lean theorem count is recomputed only when the FORGE_MHED_CODEX repo is
+# accessible (CI env var). When not set, the lean_theorems block is
+# preserved from the in-tree forge_metrics.json so PRs that don't touch
+# mhed-codex don't get blocked here.
+#
+# Fix when this fails:  forge metrics --apply && git add forge_metrics.json
+
+on:
+  pull_request:
+    paths:
+      - "src/atomadic_forge/a0_qk_constants/schema_version_registry.py"
+      - "src/atomadic_forge/a1_at_functions/mcp_protocol.py"
+      - "src/atomadic_forge/a1_at_functions/forge_metrics.py"
+      - "src/atomadic_forge/a3_og_features/forge_metrics_feature.py"
+      - "src/atomadic_forge/a4_sy_orchestration/cli.py"
+      - "src/atomadic_forge/commands/**"
+      - "pyproject.toml"
+      - "forge_metrics.json"
+  push:
+    branches: [main]
+
+jobs:
+  metrics-drift:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Install package (editable)
+        run: pip install -e . --quiet
+      - name: Compute live metrics + diff vs. checked-in artifact
+        run: |
+          set -euo pipefail
+          # Save committed copy.
+          cp forge_metrics.json /tmp/forge_metrics.committed.json
+          # Recompute (Lean count zero in CI unless FORGE_MHED_CODEX is wired).
+          forge metrics --apply
+          # If the only delta is the timestamp, that's expected — strip it
+          # before diffing so we only fail on substantive drift.
+          jq 'del(.generated_at_utc)' /tmp/forge_metrics.committed.json > /tmp/a.json
+          jq 'del(.generated_at_utc)' forge_metrics.json > /tmp/b.json
+          # If FORGE_MHED_CODEX is not set, also ignore the lean_theorems
+          # block (will be 0 in CI but the committed artifact has the real
+          # count from the IP repo).
+          if [ -z "${FORGE_MHED_CODEX:-}" ]; then
+            jq 'del(.lean_theorems)' /tmp/a.json > /tmp/a2.json && mv /tmp/a2.json /tmp/a.json
+            jq 'del(.lean_theorems)' /tmp/b.json > /tmp/b2.json && mv /tmp/b2.json /tmp/b.json
+          fi
+          if ! diff -u /tmp/a.json /tmp/b.json; then
+            echo "::error::forge_metrics.json is stale. Run 'forge metrics --apply' and commit the result."
+            exit 1
+          fi
+          echo "metrics drift check: OK"

atomadic_forge-0.50.0/.github/workflows/publish-on-tag.yml

@@ -0,0 +1,104 @@
+name: Publish on tag
+
+# v0.50.0 — single tag → full publish chain.
+#
+# Pushing a v* tag fires this workflow, which:
+#   1. Verifies forge_metrics.json is current at the tag (no stale numbers
+#      shipping to PyPI / atomadic.tech / shields.io).
+#   2. Creates a GitHub Release using the matching CHANGELOG section.
+#      The GH-Release event triggers release.yml which builds + publishes
+#      to PyPI.
+#   3. Fires a `repository_dispatch` to atomadic-forge-cloudflare-workers
+#      so the MCP worker redeploys with the same version. Public
+#      surfaces (badges, metrics.json proxy, MCP endpoint) are then in
+#      lockstep with the PyPI release.
+#
+# Required secrets:
+#   GH_TOKEN — automatic (github.token)
+#   WORKER_DEPLOY_PAT — PAT with `repo` scope on the worker repo;
+#       grants permission to fire repository_dispatch. If unset, the
+#       cross-repo dispatch is skipped (worker can be redeployed
+#       manually via its own workflow_dispatch).
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  publish:
+    name: Publish chain (metrics → GH Release → worker dispatch)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Extract version from tag
+        id: version
+        run: echo "version=${GITHUB_REF_NAME#v}" >> "$GITHUB_OUTPUT"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install package
+        run: pip install -e . --quiet
+
+      - name: Verify forge_metrics.json is current at this tag
+        run: |
+          set -euo pipefail
+          # Save the in-tree artifact, recompute, diff (ignoring
+          # generated_at_utc and lean_theorems — Lean count requires
+          # the IP-protected mhed-codex repo, not present in CI).
+          cp forge_metrics.json /tmp/forge_metrics.committed.json
+          # Use the most recent passing test count from the suite.
+          set +e
+          ptout=$(python -m pytest tests/ -q --no-header 2>&1 | tail -3)
+          set -e
+          passed=$(echo "$ptout" | grep -oE '[0-9]+ passed' | head -1 | grep -oE '[0-9]+')
+          forge metrics --apply --tests-passing "${passed:-0}"
+          jq 'del(.generated_at_utc) | del(.lean_theorems) | del(.tests_passing)' \
+            /tmp/forge_metrics.committed.json > /tmp/a.json
+          jq 'del(.generated_at_utc) | del(.lean_theorems) | del(.tests_passing)' \
+            forge_metrics.json > /tmp/b.json
+          if ! diff -u /tmp/a.json /tmp/b.json; then
+            echo "::error::forge_metrics.json is stale at tag ${GITHUB_REF_NAME}. Re-run \`forge metrics --apply\` and re-tag."
+            exit 1
+          fi
+
+      - name: Extract changelog for this version
+        id: changelog
+        run: |
+          version="${{ steps.version.outputs.version }}"
+          changelog=$(sed -n "/^## .*${version}/,/^## /{/^## .*${version}/d;/^## /d;p}" CHANGELOG.md | head -100)
+          if [ -z "$changelog" ]; then
+            changelog="Release v${version}"
+          fi
+          echo "$changelog" > /tmp/release_notes.md
+
+      - name: Create GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create "${{ github.ref_name }}" \
+            --title "Atomadic Forge ${{ github.ref_name }}" \
+            --notes-file /tmp/release_notes.md
+
+      - name: Dispatch worker redeploy
+        if: ${{ secrets.WORKER_DEPLOY_PAT != '' }}
+        env:
+          PAT: ${{ secrets.WORKER_DEPLOY_PAT }}
+        run: |
+          curl -fsS -X POST \
+            -H "Accept: application/vnd.github+json" \
+            -H "Authorization: Bearer ${PAT}" \
+            -H "X-GitHub-Api-Version: 2022-11-28" \
+            https://api.github.com/repos/atomadictech/atomadic-forge-cloudflare-workers/dispatches \
+            -d "{\"event_type\":\"forge-released\",\"client_payload\":{\"version\":\"${{ steps.version.outputs.version }}\"}}"
+          echo "dispatched forge-released v${{ steps.version.outputs.version }} → worker repo"

atomadic_forge-0.50.0/.github/workflows/uptime.yml

@@ -0,0 +1,72 @@
+name: Uptime monitor
+
+# Runs every 30 minutes. Pings all Atomadic services and opens an
+# issue if any are down. Free uptime monitoring via GitHub Actions.
+
+on:
+  schedule:
+    - cron: '*/30 * * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  issues: write
+
+jobs:
+  check:
+    name: Health check
+    runs-on: ubuntu-latest
+    timeout-minutes: 3
+    steps:
+      - name: Ping all services
+        id: ping
+        run: |
+          failed=""
+          for entry in \
+            "forge.atomadic.tech|https://forge.atomadic.tech" \
+            "forge-mcp|https://forge.atomadic.tech/mcp" \
+            "chat.atomadic.tech|https://chat.atomadic.tech" \
+            "forge-auth|https://forge-auth.atomadic.tech" \
+          ; do
+            name="${entry%%|*}"
+            url="${entry##*|}"
+            status=$(curl -s -o /dev/null -w "%{http_code}" --max-time 10 "$url" 2>/dev/null || echo "000")
+            # 200, 401, 405 are all "alive" responses for various endpoints
+            if [[ "$status" =~ ^(200|301|302|401|403|405)$ ]]; then
+              echo "OK  $status  $name"
+            else
+              echo "ERR $status  $name"
+              failed="$failed $name($status)"
+            fi
+          done
+
+          if [ -n "$failed" ]; then
+            echo "failed=$failed" >> "$GITHUB_OUTPUT"
+            echo "has_failure=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_failure=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Open issue if services are down
+        if: steps.ping.outputs.has_failure == 'true'
+        uses: actions/checkout@v6
+
+      - name: Create or update issue
+        if: steps.ping.outputs.has_failure == 'true'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          title="Uptime alert: services down"
+          body="The following services are unreachable: ${{ steps.ping.outputs.failed }}
+
+          Detected at $(date -u +'%Y-%m-%d %H:%M UTC')
+
+          Run \`make uptime\` locally to verify."
+
+          # Check if an open uptime issue already exists
+          existing=$(gh issue list --label uptime --state open --json number -q '.[0].number' 2>/dev/null || true)
+          if [ -n "$existing" ]; then
+            gh issue comment "$existing" --body "$body"
+          else
+            gh issue create --title "$title" --body "$body" --label uptime
+          fi