animamunch 1.108.82__tar.gz

animamunch-1.108.82/.clabot

@@ -0,0 +1,28 @@
+{
+  "allowlist": [
+    "gokhanozdemir",
+    "thellMa",
+    "DrHayt",
+    "horknfbr",
+    "astrobleem",
+    "Cobdog",
+    "vvaltson",
+    "sanyapuer",
+    "paperlinguist",
+    "swmeyer1979",
+    "gebeer",
+    "josh-stephens",
+    "Mharbulous",
+    "snafu4",
+    "MariusAdrian88",
+    "ivanmilov",
+    "zrk02",
+    "Wes2000ley",
+    "allenguarnes",
+    "phuzzled",
+    "levonbragg",
+    "briepace",
+    "halindrome",
+    "vadash"
+  ]
+}

animamunch-1.108.82/.dockerignore

@@ -0,0 +1,14 @@
+.git
+.github
+__pycache__
+*.pyc
+*.egg-info
+dist
+build
+tests
+benchmarks
+*.pdf
+.venv
+.mypy_cache
+.pytest_cache
+node_modules

animamunch-1.108.82/.github/actions/health-radar/README.md

@@ -0,0 +1,109 @@
+# jCodeMunch Health Radar — GitHub Action
+
+A composite action that computes a six-axis code-health radar on the PR
+branch and the base branch, diffs them, and posts the result as a
+**sticky PR comment**. Suggestion-style — never blocks merges.
+
+## What it does
+
+1. Indexes the PR branch with `jcodemunch-mcp index .`
+2. Runs `jcodemunch-mcp health . --radar-only` → PR radar JSON
+3. Checks out the base branch, re-indexes, runs the same command → base
+   radar JSON
+4. Computes the diff via the same pure helper exposed as the
+   `diff_health_radar` MCP tool
+5. Renders a markdown table + axis movements + regression / improvement
+   bullets
+6. Finds an existing sticky comment by HTML marker — `PATCH`es it on
+   re-runs, `POST`s a new one on the first run.
+
+## Why a comment, not a status check
+
+Status checks block merges. A heuristic that blocks merges gets the
+Action disabled by the first frustrated maintainer. The radar comment
+is **explanatory, not gating** — reviewers see the deltas, decide for
+themselves.
+
+## Usage
+
+```yaml
+# .github/workflows/health-radar.yml
+name: Health Radar
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  pull-requests: write   # for sticky comment
+  contents: read         # for git checkout
+
+jobs:
+  radar:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0    # need full history for index + base checkout
+      - uses: jgravelle/jcodemunch-mcp/.github/actions/health-radar@v1.88.0
+```
+
+That's the whole setup. The action handles install, index, base/branch
+toggling, and comment posting itself.
+
+## Inputs
+
+| Input | Default | Description |
+|---|---|---|
+| `python-version` | `3.11` | Python version on the runner. |
+| `jcodemunch-version` | `latest` | Pin a specific package version, or `latest`. |
+| `base-ref` | _(PR's base branch)_ | Override the comparison ref. |
+| `github-token` | `${{ github.token }}` | Token used to post/edit the comment. |
+
+## Output shape
+
+The sticky comment looks like:
+
+```markdown
+<!-- jcm-health-radar -->
+## jCodeMunch Health Radar
+
+🟡 **Composite:** B → C (-7.5 pts)
+🔴 **Verdict:** REGRESSION on 2 axis/axes (composite -7.5)
+
+| Axis | Baseline | PR | Δ |
+|---|---:|---:|---:|
+| `complexity`     | 88 | 64 | **-24.0** ↓ |
+| `dead_code`      | 82 | 79 | -3.0 ↓ |
+| `cycles`         | 100 | 100 | +0.0 · |
+...
+
+### Regressions
+- `complexity`: raw 4.5 → 11.0
+- `dead_code`: raw 4.5 → 5.7
+```
+
+## Methodology
+
+Per-axis scoring rules and rationale: see
+[`tools/health_radar.py`](https://github.com/jgravelle/jcodemunch-mcp/blob/main/src/jcodemunch_mcp/tools/health_radar.py).
+
+The composite is the arithmetic mean of every scored axis;
+`omitted_axes` lists axes whose underlying signals weren't available
+(e.g. `test_gap` if `get_untested_symbols` couldn't run).
+
+## Known caveats
+
+- **Re-indexes on both branches** — adds runtime in CI, scaling roughly
+  with codebase size. For very large repos, the baseline could be
+  cached by base SHA in a follow-up release.
+- **Heuristic, not coverage data** — `test_gap` is import-graph
+  reachability + name matching. It catches "this function isn't
+  referenced by anything in `tests/`," not runtime line coverage.
+- **`coupling` axis penalises high import fan-out**, which can be
+  legitimate in framework-style codebases. Treat the absolute number
+  as suggestive; the *delta* is what matters at PR time.
+
+## Disabling
+
+Just remove the workflow file. The action stores no state outside the
+runner; no cleanup is required.

animamunch-1.108.82/.github/actions/health-radar/action.yml

@@ -0,0 +1,145 @@
+name: 'jCodeMunch Health Radar'
+description: >-
+  Compute a six-axis code-health radar on the PR branch and the base branch,
+  diff them, and post the result as a sticky PR comment. Suggestion-style;
+  never blocks merges.
+author: 'jgravelle'
+branding:
+  icon: 'activity'
+  color: 'purple'
+
+inputs:
+  python-version:
+    description: 'Python version for the Actions runner.'
+    default: '3.11'
+    required: false
+  jcodemunch-version:
+    description: >-
+      Pin a specific jcodemunch-mcp version (e.g. 1.88.0) or 'latest'.
+    default: 'latest'
+    required: false
+  base-ref:
+    description: >-
+      Git ref to compare against (default: the PR's base branch).
+    default: ''
+    required: false
+  github-token:
+    description: 'Token for posting/editing the PR comment.'
+    default: ${{ github.token }}
+    required: false
+
+runs:
+  using: 'composite'
+  steps:
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ inputs.python-version }}
+
+    - name: Install jcodemunch-mcp
+      shell: bash
+      run: |
+        if [ "${{ inputs.jcodemunch-version }}" = "latest" ]; then
+          pip install -U jcodemunch-mcp
+        else
+          pip install "jcodemunch-mcp==${{ inputs.jcodemunch-version }}"
+        fi
+        jcodemunch-mcp --version || true
+
+    - name: Resolve base ref
+      id: base
+      shell: bash
+      run: |
+        BASE="${{ inputs.base-ref }}"
+        if [ -z "$BASE" ]; then
+          BASE="${{ github.base_ref }}"
+        fi
+        if [ -z "$BASE" ]; then
+          echo "no base ref available — skipping (this Action is meant for pull_request triggers)"
+          echo "skip=true" >> "$GITHUB_OUTPUT"
+        else
+          echo "base=$BASE" >> "$GITHUB_OUTPUT"
+        fi
+
+    - name: Compute radar on PR branch
+      if: steps.base.outputs.skip != 'true'
+      shell: bash
+      run: |
+        jcodemunch-mcp index .
+        jcodemunch-mcp health . --radar-only > "$RUNNER_TEMP/pr_radar.json"
+        echo "PR radar:"
+        cat "$RUNNER_TEMP/pr_radar.json"
+
+    - name: Compute radar on base branch
+      if: steps.base.outputs.skip != 'true'
+      shell: bash
+      env:
+        BASE: ${{ steps.base.outputs.base }}
+      run: |
+        # Stash uncommitted state isn't needed (clean checkout in CI), but
+        # capture HEAD so we can restore it.
+        ORIG_REF=$(git rev-parse HEAD)
+        echo "$ORIG_REF" > "$RUNNER_TEMP/orig_ref"
+
+        git fetch origin "$BASE" --depth=1 || git fetch origin "$BASE"
+        git checkout "origin/$BASE" --quiet || git checkout "$BASE" --quiet
+
+        # Re-index against the base tree.
+        jcodemunch-mcp index .
+        jcodemunch-mcp health . --radar-only > "$RUNNER_TEMP/base_radar.json"
+        echo "Base radar:"
+        cat "$RUNNER_TEMP/base_radar.json"
+
+        # Restore PR HEAD so any subsequent steps see the PR tree.
+        git checkout "$ORIG_REF" --quiet
+
+    - name: Render comment markdown
+      if: steps.base.outputs.skip != 'true'
+      id: render
+      shell: bash
+      run: |
+        VERSION=$(python -c "from importlib.metadata import version; print(version('jcodemunch-mcp'))" 2>/dev/null || echo "")
+        python "${GITHUB_ACTION_PATH}/render_comment.py" \
+          --baseline "$RUNNER_TEMP/base_radar.json" \
+          --current  "$RUNNER_TEMP/pr_radar.json" \
+          --version  "$VERSION" \
+          > "$RUNNER_TEMP/comment.md"
+        echo "Rendered comment:"
+        cat "$RUNNER_TEMP/comment.md"
+
+    - name: Post or update sticky comment
+      # Fork-sourced pull_request events get a read-only GITHUB_TOKEN,
+      # so the comment POST returns 403 regardless of the workflow's
+      # declared `permissions:` block. For fork PRs we instead upload
+      # the rendered comment as an artifact in the calling workflow and
+      # post it from a workflow_run-triggered companion job (which DOES
+      # run in the base repo's trusted secret context). See
+      # .github/workflows/health-radar-comment.yml.
+      if: >-
+        steps.base.outputs.skip != 'true'
+        && github.event_name == 'pull_request'
+        && github.event.pull_request.head.repo.fork != true
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.github-token }}
+        PR_NUMBER: ${{ github.event.pull_request.number }}
+        REPO: ${{ github.repository }}
+      run: |
+        # Sticky-comment pattern: find existing comment by HTML marker; PATCH it
+        # if found, otherwise POST a new one. Marker is on the first line of the
+        # rendered body so a simple startswith match is robust.
+        EXISTING=$(gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" --paginate \
+          --jq '.[] | select(.body | startswith("<!-- jcm-health-radar -->")) | .id' \
+          | head -n1)
+
+        if [ -n "$EXISTING" ]; then
+          gh api "repos/${REPO}/issues/comments/${EXISTING}" \
+            --method PATCH \
+            -F "body=@${RUNNER_TEMP}/comment.md"
+          echo "Updated existing health-radar comment ${EXISTING}."
+        else
+          gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" \
+            --method POST \
+            -F "body=@${RUNNER_TEMP}/comment.md"
+          echo "Posted new health-radar comment."
+        fi

animamunch-1.108.82/.github/actions/health-radar/render_comment.py

@@ -0,0 +1,170 @@
+"""Render a sticky PR comment from baseline + PR radar JSON files.
+
+Reads two radar payloads (the `radar` sub-field of `jcodemunch-mcp
+health` output), computes the diff via the same pure helper the MCP
+tool exposes, and prints a markdown PR comment to stdout.
+
+Stable HTML comment marker on the first line lets the calling shell
+script find/edit an existing comment instead of spamming the PR.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import Iterable
+
+# This script runs in the Actions runner where jcodemunch-mcp has been
+# pip-installed, so the import works directly.
+from jcodemunch_mcp.tools.health_radar import diff_radar
+
+
+_MARKER = "<!-- jcm-health-radar -->"
+_GRADE_EMOJI = {"A": "🟢", "B": "🟢", "C": "🟡", "D": "🟠", "F": "🔴"}
+
+
+def _arrow(delta) -> str:
+    if delta is None:
+        return "—"
+    if delta >= 3.0:
+        return "↑"
+    if delta <= -3.0:
+        return "↓"
+    return "·"
+
+
+def _signed(v) -> str:
+    if v is None:
+        return "—"
+    if v > 0:
+        return f"+{v:.1f}"
+    return f"{v:.1f}"
+
+
+def _radar_table(diff: dict) -> str:
+    lines = [
+        "| Axis | Baseline | PR | Δ |",
+        "|---|---:|---:|---:|",
+    ]
+    for axis, d in sorted(diff["axis_deltas"].items()):
+        b = d.get("from")
+        c = d.get("to")
+        delta = d.get("delta")
+        if b is None and c is None:
+            continue
+        b_s = "—" if b is None else f"{b:.0f}"
+        c_s = "—" if c is None else f"{c:.0f}"
+        delta_s = _signed(delta)
+        emphasis = "**" if delta is not None and abs(delta) >= 3.0 else ""
+        lines.append(
+            f"| `{axis}` | {b_s} | {c_s} | {emphasis}{delta_s}{emphasis} {_arrow(delta)} |"
+        )
+    return "\n".join(lines)
+
+
+def _regression_detail(diff: dict, kind: str) -> str:
+    """Render the bulleted regression / improvement axes with raw values."""
+    items = diff.get(kind, [])
+    if not items:
+        return ""
+    lines = [f"### {'Regressions' if kind == 'regressions' else 'Improvements'}"]
+    for axis in items:
+        d = diff["axis_deltas"][axis]
+        raw_from = d.get("raw_from")
+        raw_to = d.get("raw_to")
+        if raw_from is not None and raw_to is not None:
+            lines.append(f"- `{axis}`: raw {raw_from} → {raw_to}")
+        else:
+            lines.append(f"- `{axis}`: score {d.get('from')} → {d.get('to')}")
+    return "\n".join(lines)
+
+
+def _verdict_emoji(diff: dict) -> str:
+    if diff.get("regressions") and not diff.get("improvements"):
+        return "🔴"
+    if diff.get("improvements") and not diff.get("regressions"):
+        return "🟢"
+    if diff.get("regressions") and diff.get("improvements"):
+        return "🟡"
+    return "⚪"
+
+
+def render(baseline: dict, current: dict, *, version: str = "") -> str:
+    diff = diff_radar(baseline, current)
+
+    base_grade = baseline.get("grade", "?")
+    cur_grade = current.get("grade", "?")
+    grade_line = (
+        f"{_GRADE_EMOJI.get(cur_grade, '')} **Composite:** "
+        f"{base_grade} → {cur_grade} ({_signed(diff['composite_delta'])} pts)"
+    )
+
+    blocks: list[str] = [
+        _MARKER,
+        "## jCodeMunch Health Radar",
+        "",
+        grade_line,
+        f"{_verdict_emoji(diff)} **Verdict:** {diff['verdict']}",
+        "",
+        _radar_table(diff),
+    ]
+
+    regressions = _regression_detail(diff, "regressions")
+    if regressions:
+        blocks.append("")
+        blocks.append(regressions)
+
+    improvements = _regression_detail(diff, "improvements")
+    if improvements:
+        blocks.append("")
+        blocks.append(improvements)
+
+    blocks.append("")
+    blocks.append(
+        "_[Methodology](https://github.com/jgravelle/jcodemunch-mcp/blob/main/src/jcodemunch_mcp/tools/health_radar.py) "
+        f"· Posted by `jcodemunch-mcp{(' v' + version) if version else ''}`. "
+        "Re-runs on every push to this PR; this comment is sticky._"
+    )
+    return "\n".join(blocks).rstrip() + "\n"
+
+
+def _load_radar(path: Path) -> dict:
+    """Load a radar payload from JSON. Accepts either the `radar` sub-dict
+    or the full get_repo_health response (we'll unwrap)."""
+    payload = json.loads(path.read_text(encoding="utf-8"))
+    if isinstance(payload, dict) and "axes" in payload:
+        return payload
+    if isinstance(payload, dict) and "radar" in payload:
+        return payload["radar"]
+    raise ValueError(
+        f"{path} doesn't look like a radar payload (no `axes` field, no `radar` sub-field)"
+    )
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        description="Render a sticky PR comment from baseline + PR radar JSON.",
+    )
+    parser.add_argument("--baseline", type=Path, required=True,
+        help="Path to baseline radar JSON (e.g. base branch).")
+    parser.add_argument("--current", type=Path, required=True,
+        help="Path to current radar JSON (e.g. PR branch).")
+    parser.add_argument("--version", default="",
+        help="jcodemunch-mcp version string for the footer.")
+    args = parser.parse_args(argv)
+
+    try:
+        baseline = _load_radar(args.baseline)
+        current = _load_radar(args.current)
+    except (OSError, json.JSONDecodeError, ValueError) as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 2
+
+    sys.stdout.write(render(baseline, current, version=args.version))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

animamunch-1.108.82/.github/dependabot.yml

@@ -0,0 +1,15 @@
+version: 2
+# Security-only, batched. We do NOT run version updates (open-pull-requests-limit: 0
+# suppresses them); Dependabot still opens PRs for actual vulnerability alerts, and the
+# `groups` directive collapses those into a single combined PR instead of one-per-alert.
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    open-pull-requests-limit: 0
+    groups:
+      security-updates:
+        applies-to: security-updates
+        patterns:
+          - "*"

animamunch-1.108.82/.github/workflows/health-radar-comment.yml

@@ -0,0 +1,80 @@
+# Companion to health-radar.yml. Fork-sourced pull_request events get a
+# read-only GITHUB_TOKEN, so they cannot post PR comments. The radar workflow
+# uploads the rendered comment as an artifact for fork PRs; this workflow runs
+# on `workflow_run` (which runs in the base repo's trusted secret context with
+# a write-capable token) and posts the sticky comment on the fork PR's behalf.
+#
+# Same-repo PRs are unaffected: their comment is posted inline by the action.
+
+name: Health Radar Comment
+
+on:
+  workflow_run:
+    workflows: ["Health Radar"]
+    types: [completed]
+
+permissions:
+  pull-requests: write
+  contents: read
+  actions: read
+
+jobs:
+  comment:
+    runs-on: ubuntu-latest
+    # Only act on pull_request runs (the only event Health Radar fires on).
+    if: github.event.workflow_run.event == 'pull_request'
+    steps:
+      - name: Download comment payload
+        id: download
+        uses: actions/download-artifact@v4
+        with:
+          name: health-radar-payload
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ github.token }}
+          path: payload
+        continue-on-error: true
+
+      - name: Skip if no payload
+        if: steps.download.outcome != 'success'
+        shell: bash
+        run: |
+          echo "No health-radar-payload artifact from run ${{ github.event.workflow_run.id }} — same-repo PR or radar failed before render. Nothing to post."
+
+      - name: Post or update sticky comment
+        if: steps.download.outcome == 'success'
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+        run: |
+          if [ ! -f payload/pr_number.txt ]; then
+            echo "No pr_number.txt in payload — skipping."
+            exit 0
+          fi
+          if [ ! -f payload/comment.md ]; then
+            echo "No comment.md in payload (radar likely failed before render) — skipping."
+            exit 0
+          fi
+
+          PR_NUMBER=$(tr -d '[:space:]' < payload/pr_number.txt)
+          if [ -z "$PR_NUMBER" ]; then
+            echo "Empty PR number in payload — skipping."
+            exit 0
+          fi
+
+          # Sticky-comment pattern: PATCH existing if present, otherwise POST.
+          EXISTING=$(gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" --paginate \
+            --jq '.[] | select(.body | startswith("<!-- jcm-health-radar -->")) | .id' \
+            | head -n1)
+
+          if [ -n "$EXISTING" ]; then
+            gh api "repos/${REPO}/issues/comments/${EXISTING}" \
+              --method PATCH \
+              -F "body=@payload/comment.md"
+            echo "Updated existing health-radar comment ${EXISTING} on PR #${PR_NUMBER}."
+          else
+            gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" \
+              --method POST \
+              -F "body=@payload/comment.md"
+            echo "Posted new health-radar comment on PR #${PR_NUMBER}."
+          fi

animamunch-1.108.82/.github/workflows/health-radar.yml

@@ -0,0 +1,53 @@
+# Dogfood the in-repo health-radar action on jcodemunch-mcp's own PRs.
+# Posts a sticky PR comment with six-axis radar deltas vs the base branch.
+
+name: Health Radar
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+permissions:
+  pull-requests: write
+  contents: read
+
+jobs:
+  radar:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          # Need enough history to checkout the base branch in the action.
+          fetch-depth: 0
+
+      - name: Run health-radar
+        uses: ./.github/actions/health-radar
+        with:
+          # Pin to the version we're shipping the action with so PRs
+          # don't accidentally regress against a never-released local
+          # change. Override per-PR if testing the action itself.
+          jcodemunch-version: '1.88.0'
+
+      # Fork PRs cannot post comments from `pull_request` context
+      # (read-only GITHUB_TOKEN). Stage the rendered comment + PR number
+      # as a workflow artifact; the companion `health-radar-comment.yml`
+      # workflow runs on `workflow_run` (trusted secret context) and
+      # posts the sticky comment on behalf of the fork PR.
+      - name: Stage comment payload (fork PRs)
+        if: always() && github.event.pull_request.head.repo.fork == true
+        shell: bash
+        run: |
+          mkdir -p "${{ runner.temp }}/radar-payload"
+          if [ -f "${{ runner.temp }}/comment.md" ]; then
+            cp "${{ runner.temp }}/comment.md" "${{ runner.temp }}/radar-payload/comment.md"
+          fi
+          echo "${{ github.event.pull_request.number }}" > "${{ runner.temp }}/radar-payload/pr_number.txt"
+
+      - name: Upload comment payload (fork PRs)
+        if: always() && github.event.pull_request.head.repo.fork == true
+        uses: actions/upload-artifact@v4
+        with:
+          name: health-radar-payload
+          path: ${{ runner.temp }}/radar-payload/
+          if-no-files-found: warn
+          retention-days: 1

animamunch-1.108.82/.github/workflows/publish.yml

@@ -0,0 +1,49 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  id-token: write   # Trusted Publisher (OIDC)
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: "0.6.5"
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Build dist
+        run: uv build
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-pypi:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1