forgepair 1.0.0__tar.gz

forgepair-1.0.0/.dockerignore

@@ -0,0 +1,10 @@
+.BC.*
+tmp*
+*~
+OLD*
+*.pyc
+.DS_Store
+.env
+.venv
+.aider.*
+build

forgepair-1.0.0/.flake8

@@ -0,0 +1,3 @@
+[flake8]
+ignore = E203,W503
+max-line-length = 100

forgepair-1.0.0/.github/ISSUE_TEMPLATE/issue.yml

@@ -0,0 +1,21 @@
+name: Question or bug report
+description: Submit a question or bug report to help us improve aider
+labels: []
+body:
+  - type: textarea
+    attributes:
+      label: Issue
+      description: Please describe your problem or question.
+    validations:
+      required: true      
+  - type: textarea
+    attributes:
+      label: Version and model info
+      description: Please include aider version, model being used (`gpt-4-xxx`, etc) and any other switches or config settings that are active.
+      placeholder: |          
+        Aider v0.XX.Y
+        Model: gpt-N-... using ???? edit format
+        Git repo: .git with ### files
+        Repo-map: using #### tokens
+    validations:
+      required: false

forgepair-1.0.0/.github/workflows/check_pypi_version.yml

@@ -0,0 +1,100 @@
+name: Check PyPI Version
+
+# Confirms that ForgePair's latest git tag is actually the version PyPI
+# currently serves as the latest release -- i.e. that "the release worked"
+# is true, not just that continuous-release.yml *ran* successfully.
+#
+# Deliberately does NOT `pip install forgepair` and build it: aider's
+# original version of this check did that, and it fails on unrelated build-
+# environment issues (e.g. a missing/incompatible setuptools.build_meta
+# backend) that have nothing to do with whether the release itself is
+# healthy -- see the investigation notes in STATUS.md for a concrete
+# example. Querying PyPI's own JSON API is enough to answer "does PyPI's
+# latest match our latest tag" without doing a full package build, and
+# runs identically on every OS (no bash/PowerShell duplication needed).
+#
+# Skips cleanly, not with a build-tool failure, if nothing has been
+# published yet (continuous-release.yml is still in dry-run mode as of
+# this writing -- see STATUS.md's "Known gaps" section).
+
+on:
+  schedule:
+    # Once a day at midnight UTC
+    - cron: '0 0 * * *'
+  workflow_dispatch: # Allows manual triggering
+
+jobs:
+  check_version:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Fetch all history for all tags
+
+      - name: Get latest tag
+        id: latest_tag
+        run: |
+          set -x
+          git fetch --tags origin main
+          # Latest tag strictly matching vX.Y.Z (no .dev/.rc suffixes)
+          latest_tag=$(git tag --sort=-v:refname | grep -P '^v\d+\.\d+\.\d+$' | head -n 1)
+
+          if [ -z "$latest_tag" ]; then
+            echo "No vX.Y.Z tags found yet -- nothing to check against. Skipping."
+            echo "has_tag=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          echo "has_tag=true" >> "$GITHUB_OUTPUT"
+          echo "tag=${latest_tag#v}" >> "$GITHUB_OUTPUT"
+          echo "Latest tag: $latest_tag"
+
+      - name: Query PyPI for the latest published version
+        id: pypi_version
+        if: steps.latest_tag.outputs.has_tag == 'true'
+        run: |
+          set -x
+          http_status=$(curl -s -o /tmp/pypi.json -w '%{http_code}' https://pypi.org/pypi/forgepair/json)
+
+          if [ "$http_status" = "404" ]; then
+            echo "forgepair is not on PyPI yet (404) -- nothing published, skipping."
+            echo "published=false" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          if [ "$http_status" != "200" ]; then
+            echo "Error: PyPI API returned unexpected status $http_status"
+            cat /tmp/pypi.json
+            exit 1
+          fi
+
+          pypi_version=$(python3 -c "import json; print(json.load(open('/tmp/pypi.json'))['info']['version'])")
+
+          if [ -z "$pypi_version" ]; then
+            echo "Error: could not read version from PyPI API response"
+            cat /tmp/pypi.json
+            exit 1
+          fi
+
+          echo "published=true" >> "$GITHUB_OUTPUT"
+          echo "version=$pypi_version" >> "$GITHUB_OUTPUT"
+          echo "PyPI's latest version: $pypi_version"
+
+      - name: Compare versions
+        if: steps.latest_tag.outputs.has_tag == 'true' && steps.pypi_version.outputs.published == 'true'
+        run: |
+          tag_version="${{ steps.latest_tag.outputs.tag }}"
+          pypi_version="${{ steps.pypi_version.outputs.version }}"
+
+          echo "Latest git tag:    $tag_version"
+          echo "PyPI latest:       $pypi_version"
+
+          if [ "$tag_version" != "$pypi_version" ]; then
+            echo "Error: PyPI's latest published version ($pypi_version) does not match the latest git tag ($tag_version)."
+            echo "Either the release for $tag_version never published successfully, or something later got yanked."
+            exit 1
+          fi
+
+          echo "Versions match."

forgepair-1.0.0/.github/workflows/continuous-release.yml

@@ -0,0 +1,76 @@
+name: Continuous Release (dry run)
+
+# Computes what the next release tag/version WOULD be on every merge to
+# main, and reports it in the workflow summary -- without actually
+# creating the tag or triggering a PyPI publish.
+#
+# This exists to close the exact gap that hurt upstream aider: commits
+# landed on main for months with no corresponding release, so users
+# never got the fixes. Once ForgePair is ready to publish real packages
+# (see BUILD_PLAN.md Phase 2 item 4), flip DRY_RUN below to false --
+# at that point this workflow will actually create and push the
+# `vX.Y.Z` tag, which is release.yml's existing trigger for building
+# and publishing to PyPI (that workflow is unchanged and already
+# gated on the PYPI_API_TOKEN secret, which is intentionally not
+# configured yet).
+#
+# Version bump policy (dry run and once live): patch bump on every
+# merge to main. This is the aider-established policy already used by
+# setuptools_scm (see pyproject.toml) -- ForgePair keeps it rather than
+# inventing conventional-commit-based bumping, to stay compatible with
+# how the fork's own version numbers are already being derived from
+# git tags.
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - 'aider/website/**'
+      - 'README.md'
+      - 'HISTORY.md'
+      - 'CHANGES.md'
+
+env:
+  DRY_RUN: "true"
+
+jobs:
+  compute-next-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # need full history + tags for version computation
+
+      - name: Compute next version
+        id: next_version
+        run: |
+          set -x
+          latest_tag=$(git tag --sort=-v:refname | grep -P '^v\d+\.\d+\.\d+$' | head -n 1)
+          if [ -z "$latest_tag" ]; then
+            echo "No existing vX.Y.Z tag found -- would start at v0.1.0"
+            next="0.1.0"
+          else
+            tag_num=${latest_tag#v}
+            IFS='.' read -r major minor patch <<< "$tag_num"
+            next="${major}.${minor}.$((patch + 1))"
+          fi
+          echo "next_version=$next" >> "$GITHUB_OUTPUT"
+          echo "### Next release version: v${next}" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          if [ "$DRY_RUN" = "true" ]; then
+            echo "DRY RUN -- no tag created, no release published." >> "$GITHUB_STEP_SUMMARY"
+            echo "When ready to go live: set DRY_RUN to false in this workflow file," >> "$GITHUB_STEP_SUMMARY"
+            echo "add the PYPI_API_TOKEN repo secret, and this job will start" >> "$GITHUB_STEP_SUMMARY"
+            echo "pushing real vX.Y.Z tags, which trigger release.yml's publish step." >> "$GITHUB_STEP_SUMMARY"
+          fi
+
+      - name: Create and push tag
+        if: env.DRY_RUN != 'true'
+        run: |
+          set -x
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag "v${{ steps.next_version.outputs.next_version }}"
+          git push origin "v${{ steps.next_version.outputs.next_version }}"

forgepair-1.0.0/.github/workflows/docker-build-test.yml

@@ -0,0 +1,69 @@
+name: Docker Build Test
+
+# Validates that docker/Dockerfile still builds successfully on every
+# push/PR. Build-only (push: false) -- does not require or use any
+# Docker Hub credentials, and never publishes anything. This is a
+# deliberate choice (see CHANGES.md): the upstream version of this
+# workflow attempted to push a `:dev` tag to Docker Hub on every push
+# to main using DOCKERHUB_USERNAME/DOCKERHUB_PASSWORD secrets, which
+# forks don't inherit -- so it failed on every run with "Username and
+# password required" until fixed here. If/when ForgePair is ready to
+# publish real Docker images, see docker-release.yml (tag-triggered,
+# separately gated) rather than re-enabling pushes here.
+#
+# Performance notes (see CHANGES.md -- this workflow was originally
+# taking 20+ minutes per run):
+# - amd64 only, not amd64+arm64. arm64 here means QEMU-emulated
+#   software instruction translation, not real hardware -- compiling
+#   this project's heavier native dependencies (tree-sitter, etc.)
+#   under emulation is what made this slow. Since this workflow only
+#   needs to answer "does the Dockerfile still build", not "produce a
+#   real publishable arm64 image", amd64-only is sufficient. Real
+#   multi-arch correctness only matters once images are actually
+#   published -- see docker-release.yml, which still builds both
+#   platforms for that reason.
+# - GitHub Actions layer cache (cache-from/cache-to: type=gha) so
+#   unchanged layers (base image, most pip installs) are reused across
+#   runs instead of rebuilding from scratch every time. First run after
+#   this change will still be a full build; subsequent runs should be
+#   much faster as long as the Dockerfile/dependencies haven't changed.
+# - The two build targets (aider, aider-full) run as a matrix so they
+#   build concurrently instead of sequentially.
+#
+# No paths-ignore filter, deliberately: this check is required by
+# branch protection, and a required check a path filter can skip
+# permanently blocks matching PRs (confirmed directly, see CHANGES.md).
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  docker_build_test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        target: [aider, aider-full]
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Build Docker image (no push)
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: linux/amd64
+        push: false
+        target: ${{ matrix.target }}
+        cache-from: type=gha,scope=${{ matrix.target }}
+        cache-to: type=gha,mode=max,scope=${{ matrix.target }}

forgepair-1.0.0/.github/workflows/docker-release.yml

@@ -0,0 +1,60 @@
+name: Docker Release
+
+# Only runs when a real vX.Y.Z tag is pushed. Currently dormant: this
+# repo's continuous-release.yml workflow is in dry-run mode and does
+# not create/push tags yet (see BUILD_PLAN.md Phase 2 item 4), so this
+# workflow never actually fires today. When continuous-release.yml is
+# flipped to live, this will start running and WILL fail immediately
+# unless DOCKERHUB_USERNAME/DOCKERHUB_PASSWORD secrets are added first
+# (same gating consideration as release.yml's PyPI publish step).
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+
+jobs:
+  docker_build_and_push:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up QEMU
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+
+    - name: Login to DockerHub
+      uses: docker/login-action@v3
+      with:
+        username: ${{ secrets.DOCKERHUB_USERNAME }}
+        password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+    - name: Build and push Docker images
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: linux/amd64,linux/arm64
+        push: true
+        tags: |
+          ${{ secrets.DOCKERHUB_USERNAME }}/aider:${{ github.ref_name }}
+          ${{ secrets.DOCKERHUB_USERNAME }}/aider:latest
+        target: aider
+
+    - name: Build and push Docker full image
+      uses: docker/build-push-action@v5
+      with:
+        context: .
+        file: ./docker/Dockerfile
+        platforms: linux/amd64,linux/arm64
+        push: true
+        tags: |
+          ${{ secrets.DOCKERHUB_USERNAME }}/aider-full:${{ github.ref_name }}
+          ${{ secrets.DOCKERHUB_USERNAME }}/aider-full:latest
+        target: aider-full

forgepair-1.0.0/.github/workflows/issues.yml

@@ -0,0 +1,41 @@
+name: Process GitHub Issues
+
+# Automated issue/PR triage. Per SPEC.md section 5 / BUILD_PLAN.md
+# Phase 3: verify-before-redirect duplicate handling (won't close a new
+# crash report as a duplicate unless the canonical issue has evidence
+# of being resolved), report-count-driven severity escalation
+# (high-impact label) instead of silent dedup-closing, feature-request
+# clustering by text similarity, and a rewritten known-issues dashboard
+# issue. See scripts/issues.py's module docstring for the full design
+# rationale vs. upstream's original bot.
+
+on:
+  schedule:
+    - cron: '0 */12 * * *'  # Run every 12 hours
+  workflow_dispatch:  # Allow manual triggers
+
+jobs:
+  process-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write  # Required to modify issues
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install requests python-dotenv tqdm
+
+      - name: Run issues script
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_REPOSITORY_OWNER: ${{ github.repository_owner }}
+          GITHUB_REPOSITORY_NAME: ${{ github.event.repository.name }}
+        run: python scripts/issues.py --yes

forgepair-1.0.0/.github/workflows/model-list-freshness.yml

@@ -0,0 +1,88 @@
+name: Model List Freshness Check
+
+# Runs scripts/update_model_lists.py --check on a schedule to catch drift
+# in the OPENAI_MODELS/ANTHROPIC_MODELS fast-path lists in aider/models.py
+# (see CHANGES.md Phase 1 and BUILD_PLAN.md Phase 2's tracked sub-item).
+#
+# Phase 1 fixed *how* these lists get regenerated (accurately, from
+# litellm's live data, via one command) but not *when* -- nothing ran
+# the script automatically. This workflow closes that gap: it runs the
+# check weekly and opens an issue if the lists have drifted, so
+# staleness gets surfaced instead of silently accumulating again.
+#
+# This intentionally opens an issue rather than auto-committing the
+# regenerated lists directly to main, so a human reviews the diff
+# (per CONTRIBUTING.md's low-risk-tier review process) before it lands
+# -- even though model list updates are low-risk, an unreviewed bot
+# commit to main is a bigger governance risk than a slightly-stale list
+# for a few days.
+
+on:
+  schedule:
+    # Every Monday at 09:00 UTC
+    - cron: '0 9 * * 1'
+  workflow_dispatch: # Allows manual triggering
+
+permissions:
+  issues: write
+
+jobs:
+  check-model-lists:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Install aider (for litellm + aider.models)
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e .
+
+      - name: Check model list freshness
+        id: check
+        run: |
+          set +e
+          python scripts/update_model_lists.py --check
+          echo "exit_code=$?" >> "$GITHUB_OUTPUT"
+          set -e
+
+      - name: Open issue if stale
+        if: steps.check.outputs.exit_code != '0'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const title = "Model list is stale: run scripts/update_model_lists.py";
+            const body = [
+              "This is an automated check (`.github/workflows/model-list-freshness.yml`).",
+              "",
+              "`scripts/update_model_lists.py --check` found that `aider/models.py`'s",
+              "OPENAI_MODELS / ANTHROPIC_MODELS fast-path lists are stale relative to",
+              "litellm's current bundled model data.",
+              "",
+              "To fix: run `python scripts/update_model_lists.py`, review the diff,",
+              "and open a PR (this falls under CONTRIBUTING.md's low-risk review tier).",
+            ].join("\n");
+
+            const existing = await github.rest.issues.listForRepo({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              state: "open",
+              labels: "model-list-stale",
+            });
+            if (existing.data.length > 0) {
+              console.log("Issue already open, not creating a duplicate.");
+              return;
+            }
+
+            await github.rest.issues.create({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              title,
+              body,
+              labels: ["model-list-stale"],
+            });

forgepair-1.0.0/.github/workflows/pages.yml

@@ -0,0 +1,87 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# Sample workflow for building and deploying a Jekyll site to GitHub Pages
+name: Deploy Jekyll site to Pages
+
+on:
+  push:
+    branches:
+      - "main"
+    paths:
+      - "aider/website/**"
+      - ".github/workflows/pages.yml"
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow one concurrent deployment
+concurrency:
+  group: "pages"
+  cancel-in-progress: true
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: aider/website
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Setup Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3' # Not needed with a .ruby-version file
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+          cache-version: 0 # Increment this number if you need to re-download cached gems
+          working-directory: '${{ github.workspace }}/aider/website'
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v3
+      - name: Build with Jekyll
+        # Outputs to the './_site' directory by default
+        run: bundle exec jekyll build --baseurl "${{ steps.pages.outputs.base_path }}"
+        env:
+          JEKYLL_ENV: production
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "aider/website/_site"
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+        
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install linkchecker
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install linkchecker
+
+      - name: Run linkchecker
+        run: |
+          linkchecker --ignore-url='.+\.(mp4|mov|avi)' https://aider.chat

forgepair-1.0.0/.github/workflows/pre-commit.yml

@@ -0,0 +1,48 @@
+---
+name: pre-commit
+on:
+  pull_request:
+  push:
+  workflow_dispatch:
+jobs:
+  pre-commit:
+    runs-on: ubuntu-latest
+    env:
+      RAW_LOG: pre-commit.log
+      CS_XML: pre-commit.xml
+    steps:
+      - run: sudo apt-get update && sudo apt-get install cppcheck uncrustify
+        if: false
+      - uses: actions/checkout@v4
+      - run: python -m pip install pre-commit
+      - uses: actions/cache/restore@v4
+        with:
+          path: ~/.cache/pre-commit/
+          key: pre-commit-4|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Run pre-commit hooks
+        env:
+          SKIP: no-commit-to-branch
+        run: |
+          set -o pipefail
+          pre-commit gc
+          pre-commit run --show-diff-on-failure --color=always --all-files | tee ${RAW_LOG}
+      - name: Convert Raw Log to Checkstyle format (launch action)
+        uses: mdeweerd/logToCheckStyle@v2025.1.1
+        if: ${{ failure() }}
+        with:
+          in: ${{ env.RAW_LOG }}
+          # out: ${{ env.CS_XML }}
+      - uses: actions/cache/save@v4
+        if: ${{ ! cancelled() }}
+        with:
+          path: ~/.cache/pre-commit/
+          key: pre-commit-4|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }}
+      - name: Provide log as artifact
+        uses: actions/upload-artifact@v4
+        if: ${{ ! cancelled() }}
+        with:
+          name: precommit-logs
+          path: |
+            ${{ env.RAW_LOG }}
+            ${{ env.CS_XML }}
+          retention-days: 2

forgepair-1.0.0/.github/workflows/release.yml

@@ -0,0 +1,41 @@
+name: PyPI Release
+
+# Publishes to PyPI via Trusted Publishing (OIDC) -- no long-lived
+# PYPI_API_TOKEN secret to store, rotate, or leak. PyPI authenticates
+# this workflow run directly by its GitHub identity (repo + workflow
+# file name), verified against the pending publisher registered at
+# https://pypi.org/manage/account/publishing/ for the `forgepair`
+# project (owner TVick64889, repo forgepair, workflow release.yml).
+
+on:
+  workflow_dispatch:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+
+jobs:
+  build_and_publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # required for PyPI Trusted Publishing (OIDC)
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.x
+
+    - name: Install build dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build
+
+    - name: Build
+      run: python -m build
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1