knots-test-complexity 1.11.0__tar.gz

knots_test_complexity-1.11.0/.github/workflows/build.yml

@@ -0,0 +1,501 @@
+name: Build and Release
+
+on:
+  push:
+    branches:
+      - main
+    tags:
+      - 'v*.*.*'
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Build
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-22.04
+            artifact_name: knots-linux-x64
+            knots_binary: target/release/knots
+            test_complexity_binary: target/release/knots-test-complexity
+          - os: windows-2022
+            artifact_name: knots-windows-x64
+            knots_binary: target/release/knots.exe
+            test_complexity_binary: target/release/knots-test-complexity.exe
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Extract version from Cargo.toml
+        id: version
+        run: |
+          VERSION=$(grep '^version = ' Cargo.toml | head -1 | sed 's/version = "\(.*\)"/\1/')
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          echo "Extracted version: $VERSION"
+        shell: bash
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Verify Rust installation
+        run: |
+          rustc --version
+          cargo --version
+
+      - name: Cache cargo registry
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry
+          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache cargo index
+        uses: actions/cache@v4
+        with:
+          path: ~/.cargo/git
+          key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Cache target directory
+        uses: actions/cache@v4
+        with:
+          path: target
+          key: ${{ runner.os }}-target-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Security Audit - Check Dependencies
+        run: |
+          cargo install cargo-audit
+          cargo audit
+        continue-on-error: true
+
+      - name: Build Release Binary
+        run: cargo build --release --workspace
+
+      - name: Run Tests - Knots
+        run: cargo test --release -p knots
+        continue-on-error: true
+
+      - name: Run Tests - Test Complexity
+        run: cargo test --release -p knots-test-complexity
+        continue-on-error: true
+
+      - name: Verify Binaries
+        run: |
+          echo "=== Verifying binaries ==="
+          ${{ matrix.knots_binary }} --version
+          ${{ matrix.test_complexity_binary }} --help | head -5
+
+      - name: Install cargo-about
+        run: cargo install cargo-about --features cli
+
+      - name: Generate Third-Party Licenses
+        shell: bash
+        run: cargo about generate about.hbs -o THIRD_PARTY_LICENSES.txt
+
+      - name: Install cargo-cyclonedx
+        run: cargo install cargo-cyclonedx
+
+      - name: Generate SBOM (CycloneDX)
+        shell: bash
+        run: cargo cyclonedx --format json --spec-version 1.5
+
+      - name: List Build Output (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          echo "=== Build Artifacts ==="
+          echo "Knots binary:"
+          ls -lh ${{ matrix.knots_binary }} || echo "Knots binary not found"
+          echo "Test-complexity binary:"
+          ls -lh ${{ matrix.test_complexity_binary }} || echo "Test-complexity binary not found"
+
+      - name: List Build Output (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          Write-Host "=== Build Artifacts ==="
+          Write-Host "Knots binary:"
+          if (Test-Path "${{ matrix.knots_binary }}") {
+            Get-Item "${{ matrix.knots_binary }}" | Format-List Name, Length, LastWriteTime
+          } else {
+            Write-Host "Knots binary not found"
+          }
+          Write-Host "Test-complexity binary:"
+          if (Test-Path "${{ matrix.test_complexity_binary }}") {
+            Get-Item "${{ matrix.test_complexity_binary }}" | Format-List Name, Length, LastWriteTime
+          } else {
+            Write-Host "Test-complexity binary not found"
+          }
+        shell: pwsh
+
+      - name: Stage Artifacts (Linux)
+        if: runner.os == 'Linux'
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+          ARTIFACT_DIR="artifacts/${{ matrix.artifact_name }}-${VERSION}"
+          mkdir -p "${ARTIFACT_DIR}"
+          cp ${{ matrix.knots_binary }} "${ARTIFACT_DIR}/"
+          cp ${{ matrix.test_complexity_binary }} "${ARTIFACT_DIR}/"
+          cp README.md "${ARTIFACT_DIR}/" 2>/dev/null || true
+          cp LICENSE "${ARTIFACT_DIR}/" 2>/dev/null || true
+          cp THIRD_PARTY_LICENSES.txt "${ARTIFACT_DIR}/"
+          cp knots.cdx.json "${ARTIFACT_DIR}/"
+          cp knots-test-complexity/knots-test-complexity.cdx.json "${ARTIFACT_DIR}/"
+          cp knots-test-complexity/README.md "${ARTIFACT_DIR}/TEST_COMPLEXITY_README.md" 2>/dev/null || true
+          cp hooks/README.md "${ARTIFACT_DIR}/HOOKS_README.md" 2>/dev/null || true
+          mkdir -p "${ARTIFACT_DIR}/man"
+          cp man/knots.1 "${ARTIFACT_DIR}/man/"
+          cp man/knots-test-complexity.1 "${ARTIFACT_DIR}/man/"
+          echo "=== Artifacts staged ==="
+          ls -lhR "${ARTIFACT_DIR}/"
+          echo "ARTIFACT_DIR=${ARTIFACT_DIR}" >> $GITHUB_ENV
+
+      - name: Stage Artifacts (Windows)
+        if: runner.os == 'Windows'
+        run: |
+          $VERSION = "${{ steps.version.outputs.VERSION }}"
+          $ARTIFACT_DIR = "artifacts/${{ matrix.artifact_name }}-${VERSION}"
+          New-Item -ItemType Directory -Force -Path $ARTIFACT_DIR
+          Copy-Item "${{ matrix.knots_binary }}" -Destination $ARTIFACT_DIR
+          Copy-Item "${{ matrix.test_complexity_binary }}" -Destination $ARTIFACT_DIR
+          Copy-Item "README.md" -Destination $ARTIFACT_DIR -ErrorAction SilentlyContinue
+          Copy-Item "LICENSE" -Destination $ARTIFACT_DIR -ErrorAction SilentlyContinue
+          Copy-Item "THIRD_PARTY_LICENSES.txt" -Destination $ARTIFACT_DIR
+          Copy-Item "knots.cdx.json" -Destination $ARTIFACT_DIR
+          Copy-Item "knots-test-complexity/knots-test-complexity.cdx.json" -Destination $ARTIFACT_DIR
+          Copy-Item "knots-test-complexity/README.md" -Destination "$ARTIFACT_DIR/TEST_COMPLEXITY_README.md" -ErrorAction SilentlyContinue
+          Copy-Item "hooks/README.md" -Destination "$ARTIFACT_DIR/HOOKS_README.md" -ErrorAction SilentlyContinue
+          Write-Host "=== Artifacts staged ==="
+          Get-ChildItem $ARTIFACT_DIR
+          echo "ARTIFACT_DIR=${ARTIFACT_DIR}" >> $env:GITHUB_ENV
+        shell: pwsh
+
+      - name: Upload Build Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ matrix.artifact_name }}-${{ steps.version.outputs.VERSION }}
+          path: ${{ env.ARTIFACT_DIR }}
+          retention-days: 30
+
+  package:
+    name: Package Release
+    needs: build
+    runs-on: ubuntu-22.04
+    if: >-
+      (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v'))
+      && github.event_name != 'pull_request'
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Extract version from Cargo.toml
+        id: version
+        run: |
+          VERSION=$(grep '^version = ' Cargo.toml | head -1 | sed 's/version = "\(.*\)"/\1/')
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+          echo "Extracted version: $VERSION"
+
+      - name: Install packaging tools
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y rpm libfuse2
+
+      - name: Download Linux Artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: knots-linux-x64-${{ steps.version.outputs.VERSION }}
+          path: artifacts/knots-linux-x64-${{ steps.version.outputs.VERSION }}
+
+      - name: Download Windows Artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: knots-windows-x64-${{ steps.version.outputs.VERSION }}
+          path: artifacts/knots-windows-x64-${{ steps.version.outputs.VERSION }}
+
+      - name: Restore binary execute bits
+        run: |
+          chmod +x artifacts/knots-linux-x64-${{ steps.version.outputs.VERSION }}/knots
+          chmod +x artifacts/knots-linux-x64-${{ steps.version.outputs.VERSION }}/knots-test-complexity
+
+      - name: Verify Release Package
+        run: |
+          echo "=== Downloaded Artifacts ==="
+          ls -lR artifacts/
+          echo ""
+          echo "Release package ready with version: ${{ steps.version.outputs.VERSION }}"
+
+      - name: Create Release Archive (Linux)
+        run: |
+          cd artifacts
+          tar -czf knots-linux-x64-${{ steps.version.outputs.VERSION }}.tar.gz knots-linux-x64-${{ steps.version.outputs.VERSION }}
+          cd ..
+
+      - name: Create Release Archive (Windows)
+        run: |
+          cd artifacts
+          zip -r knots-windows-x64-${{ steps.version.outputs.VERSION }}.zip knots-windows-x64-${{ steps.version.outputs.VERSION }}
+          cd ..
+
+      - name: Build deb package
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+          PKG_DIR="knots_${VERSION}_amd64"
+          mkdir -p "${PKG_DIR}/DEBIAN"
+          mkdir -p "${PKG_DIR}/usr/bin"
+          mkdir -p "${PKG_DIR}/usr/share/man/man1"
+          mkdir -p "${PKG_DIR}/usr/share/doc/knots"
+
+          # Control file
+          cat > "${PKG_DIR}/DEBIAN/control" << EOF
+          Package: knots
+          Version: ${VERSION}
+          Section: devel
+          Priority: optional
+          Architecture: amd64
+          Maintainer: Brandon Arrendondo <brandon@arrendondo.dev>
+          Homepage: https://github.com/brandon-arrendondo/knots
+          Description: Multi-language code complexity analyzer
+           A fast, powerful code complexity analyzer for C, C++, Rust, Python, and
+           JavaScript with visual indicators, built on tree-sitter. Knots computes
+           McCabe cyclomatic complexity, cognitive complexity, nesting depth, SLOC,
+           ABC complexity, and test scoring metrics. Includes knots-test-complexity
+           for validating unit test quality against source complexity.
+          EOF
+          # Remove leading whitespace from control file (heredoc indentation)
+          sed -i 's/^          //' "${PKG_DIR}/DEBIAN/control"
+
+          # Binaries
+          cp "artifacts/knots-linux-x64-${VERSION}/knots" "${PKG_DIR}/usr/bin/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity" "${PKG_DIR}/usr/bin/"
+          chmod 755 "${PKG_DIR}/usr/bin/knots"
+          chmod 755 "${PKG_DIR}/usr/bin/knots-test-complexity"
+
+          # Man pages
+          gzip -c man/knots.1 > "${PKG_DIR}/usr/share/man/man1/knots.1.gz"
+          gzip -c man/knots-test-complexity.1 > "${PKG_DIR}/usr/share/man/man1/knots-test-complexity.1.gz"
+
+          # Docs
+          cp README.md "${PKG_DIR}/usr/share/doc/knots/"
+          cp LICENSE "${PKG_DIR}/usr/share/doc/knots/copyright"
+          cp "artifacts/knots-linux-x64-${VERSION}/THIRD_PARTY_LICENSES.txt" \
+             "${PKG_DIR}/usr/share/doc/knots/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots.cdx.json" \
+             "${PKG_DIR}/usr/share/doc/knots/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity.cdx.json" \
+             "${PKG_DIR}/usr/share/doc/knots/"
+
+          dpkg-deb --build --root-owner-group "${PKG_DIR}"
+          mv "${PKG_DIR}.deb" "artifacts/"
+          echo "=== deb package ==="
+          dpkg-deb --info "artifacts/${PKG_DIR}.deb"
+
+      - name: Build rpm package
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+
+          mkdir -p rpmbuild/{BUILD,RPMS,SOURCES,SPECS,SRPMS}
+
+          # Create tarball for rpmbuild
+          TARDIR="knots-${VERSION}"
+          mkdir -p "${TARDIR}/bin"
+          mkdir -p "${TARDIR}/man"
+          mkdir -p "${TARDIR}/doc"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots" "${TARDIR}/bin/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity" "${TARDIR}/bin/"
+          cp man/knots.1 "${TARDIR}/man/"
+          cp man/knots-test-complexity.1 "${TARDIR}/man/"
+          cp README.md "${TARDIR}/doc/"
+          cp LICENSE "${TARDIR}/doc/"
+          cp "artifacts/knots-linux-x64-${VERSION}/THIRD_PARTY_LICENSES.txt" "${TARDIR}/doc/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots.cdx.json" "${TARDIR}/doc/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity.cdx.json" "${TARDIR}/doc/"
+          tar -czf "rpmbuild/SOURCES/knots-${VERSION}.tar.gz" "${TARDIR}"
+          rm -rf "${TARDIR}"
+
+          # Spec file
+          cat > rpmbuild/SPECS/knots.spec << 'SPEC_EOF'
+          Name:           knots
+          Version:        VERSION_PLACEHOLDER
+          Release:        1%{?dist}
+          Summary:        Multi-language code complexity analyzer
+          License:        MIT
+          URL:            https://github.com/brandon-arrendondo/knots
+          Source0:        %{name}-%{version}.tar.gz
+
+          %description
+          A fast, powerful code complexity analyzer for C, C++, Rust, Python, and
+          JavaScript with visual indicators, built on tree-sitter. Knots computes
+          McCabe cyclomatic complexity, cognitive complexity, nesting depth, SLOC,
+          ABC complexity, and test scoring metrics. Includes knots-test-complexity
+          for validating unit test quality against source complexity.
+
+          %prep
+          %setup -q
+
+          %install
+          mkdir -p %{buildroot}%{_bindir}
+          mkdir -p %{buildroot}%{_mandir}/man1
+          mkdir -p %{buildroot}%{_docdir}/%{name}
+          install -m 755 bin/knots %{buildroot}%{_bindir}/knots
+          install -m 755 bin/knots-test-complexity %{buildroot}%{_bindir}/knots-test-complexity
+          install -m 644 man/knots.1 %{buildroot}%{_mandir}/man1/knots.1
+          install -m 644 man/knots-test-complexity.1 %{buildroot}%{_mandir}/man1/knots-test-complexity.1
+          install -m 644 doc/README.md %{buildroot}%{_docdir}/%{name}/README.md
+          install -m 644 doc/LICENSE %{buildroot}%{_docdir}/%{name}/LICENSE
+          install -m 644 doc/THIRD_PARTY_LICENSES.txt %{buildroot}%{_docdir}/%{name}/THIRD_PARTY_LICENSES.txt
+          install -m 644 doc/knots.cdx.json %{buildroot}%{_docdir}/%{name}/knots.cdx.json
+          install -m 644 doc/knots-test-complexity.cdx.json %{buildroot}%{_docdir}/%{name}/knots-test-complexity.cdx.json
+
+          %files
+          %{_bindir}/knots
+          %{_bindir}/knots-test-complexity
+          %{_mandir}/man1/knots.1*
+          %{_mandir}/man1/knots-test-complexity.1*
+          %doc %{_docdir}/%{name}/README.md
+          %doc %{_docdir}/%{name}/THIRD_PARTY_LICENSES.txt
+          %doc %{_docdir}/%{name}/knots.cdx.json
+          %doc %{_docdir}/%{name}/knots-test-complexity.cdx.json
+          %license %{_docdir}/%{name}/LICENSE
+          SPEC_EOF
+
+          # Fix indentation and substitute version
+          sed -i 's/^          //' rpmbuild/SPECS/knots.spec
+          sed -i "s/VERSION_PLACEHOLDER/${VERSION}/" rpmbuild/SPECS/knots.spec
+
+          rpmbuild --define "_topdir $(pwd)/rpmbuild" -bb rpmbuild/SPECS/knots.spec
+          cp rpmbuild/RPMS/x86_64/knots-*.rpm artifacts/
+          echo "=== rpm package ==="
+          rpm -qip artifacts/knots-*.rpm
+
+      - name: Build AppImage
+        run: |
+          VERSION="${{ steps.version.outputs.VERSION }}"
+
+          # Download appimagetool
+          curl -Lo appimagetool https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-x86_64.AppImage
+          chmod +x appimagetool
+
+          # Create AppDir structure
+          APPDIR="knots.AppDir"
+          mkdir -p "${APPDIR}/usr/bin"
+          mkdir -p "${APPDIR}/usr/share/man/man1"
+          mkdir -p "${APPDIR}/usr/share/metainfo"
+          mkdir -p "${APPDIR}/usr/share/icons/hicolor/256x256/apps"
+
+          # Binaries
+          cp "artifacts/knots-linux-x64-${VERSION}/knots" "${APPDIR}/usr/bin/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity" "${APPDIR}/usr/bin/"
+          chmod 755 "${APPDIR}/usr/bin/knots"
+          chmod 755 "${APPDIR}/usr/bin/knots-test-complexity"
+
+          # Man pages
+          cp man/knots.1 "${APPDIR}/usr/share/man/man1/"
+          cp man/knots-test-complexity.1 "${APPDIR}/usr/share/man/man1/"
+
+          # License docs
+          mkdir -p "${APPDIR}/usr/share/doc/knots"
+          cp LICENSE "${APPDIR}/usr/share/doc/knots/"
+          cp "artifacts/knots-linux-x64-${VERSION}/THIRD_PARTY_LICENSES.txt" \
+             "${APPDIR}/usr/share/doc/knots/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots.cdx.json" \
+             "${APPDIR}/usr/share/doc/knots/"
+          cp "artifacts/knots-linux-x64-${VERSION}/knots-test-complexity.cdx.json" \
+             "${APPDIR}/usr/share/doc/knots/"
+
+          # Desktop entry
+          cat > "${APPDIR}/knots.desktop" << EOF
+          [Desktop Entry]
+          Type=Application
+          Name=knots
+          Exec=knots
+          Icon=knots
+          Comment=Multi-language code complexity analyzer
+          Categories=Development;
+          Terminal=true
+          NoDisplay=true
+          EOF
+          sed -i 's/^          //' "${APPDIR}/knots.desktop"
+
+          # Icon (generate a simple SVG icon)
+          cat > "${APPDIR}/knots.svg" << 'SVG_EOF'
+          <?xml version="1.0" encoding="UTF-8"?>
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" width="256" height="256">
+            <rect width="256" height="256" rx="32" fill="#2d3748"/>
+            <text x="128" y="160" font-family="monospace" font-size="120" font-weight="bold" fill="#e2e8f0" text-anchor="middle">K</text>
+          </svg>
+          SVG_EOF
+          sed -i 's/^          //' "${APPDIR}/knots.svg"
+          cp "${APPDIR}/knots.svg" "${APPDIR}/usr/share/icons/hicolor/256x256/apps/"
+
+          # AppRun
+          cat > "${APPDIR}/AppRun" << 'APPRUN_EOF'
+          #!/bin/bash
+          SELF=$(readlink -f "$0")
+          HERE=${SELF%/*}
+          export PATH="${HERE}/usr/bin:${PATH}"
+          export MANPATH="${HERE}/usr/share/man:${MANPATH}"
+
+          ARGV0="${ARGV0:-knots}"
+          case "$(basename "${ARGV0}")" in
+            knots-test-complexity)
+              exec "${HERE}/usr/bin/knots-test-complexity" "$@"
+              ;;
+            *)
+              exec "${HERE}/usr/bin/knots" "$@"
+              ;;
+          esac
+          APPRUN_EOF
+          chmod +x "${APPDIR}/AppRun"
+
+          # Build AppImage
+          ARCH=x86_64 ./appimagetool "${APPDIR}" "artifacts/knots-${VERSION}-x86_64.AppImage"
+          echo "=== AppImage ==="
+          ls -lh "artifacts/knots-${VERSION}-x86_64.AppImage"
+
+      - name: Upload Release Archives
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-packages-${{ steps.version.outputs.VERSION }}
+          path: |
+            artifacts/*.tar.gz
+            artifacts/*.zip
+            artifacts/*.deb
+            artifacts/*.rpm
+            artifacts/*.AppImage
+          retention-days: 90
+
+      - name: Create GitHub Release
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          files: |
+            artifacts/*.tar.gz
+            artifacts/*.zip
+            artifacts/*.deb
+            artifacts/*.rpm
+            artifacts/*.AppImage
+
+  docs:
+    name: Docs
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Sphinx and theme
+        run: pip install sphinx sphinx-rtd-theme
+
+      - name: Build HTML docs
+        run: sphinx-build -W -b html docs docs/_build/html
+
+      - name: Deploy to GitHub Pages
+        if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: docs/_build/html

knots_test_complexity-1.11.0/.github/workflows/wheels.yml

@@ -0,0 +1,109 @@
+name: Wheels (PyPI)
+
+# Build per-platform wheels + sdists for the `knots` and `knots-test-complexity`
+# binaries with maturin (bindings = "bin"), and publish them to PyPI via Trusted
+# Publishing (OIDC, no API token) on a v*.*.* tag. These prebuilt wheels are what
+# the knots-pre-commit mirror repo installs, giving a zero-compile first run.
+#
+# Validate the matrix without publishing by running this workflow manually
+# (Actions tab -> "Wheels (PyPI)" -> Run workflow); publish only happens on tags.
+
+on:
+  push:
+    tags:
+      - 'v*.*.*'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: build ${{ matrix.package.name }} (${{ matrix.platform.id }})
+    runs-on: ${{ matrix.platform.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        package:
+          - { name: knots, manifest: Cargo.toml }
+          - { name: knots-test-complexity, manifest: knots-test-complexity/Cargo.toml }
+        platform:
+          # `id` must be unique per row — macOS and Linux share the bare
+          # x86_64/aarch64 target labels, which would otherwise collide as
+          # artifact names (upload-artifact@v4 rejects duplicate names).
+          - { id: linux-x86_64,  runner: ubuntu-22.04, target: x86_64, manylinux: auto }
+          - { id: linux-aarch64, runner: ubuntu-22.04, target: aarch64, manylinux: auto }
+          - { id: musl-x86_64,   runner: ubuntu-22.04, target: x86_64-unknown-linux-musl, manylinux: musllinux_1_2 }
+          - { id: musl-aarch64,  runner: ubuntu-22.04, target: aarch64-unknown-linux-musl, manylinux: musllinux_1_2 }
+          # Both macOS arches build on the Apple-Silicon runner; x86_64 is
+          # cross-compiled. Avoids the deprecated/scarce macos-13 Intel runners.
+          - { id: macos-x86_64,  runner: macos-14, target: x86_64-apple-darwin }
+          - { id: macos-aarch64, runner: macos-14, target: aarch64 }
+          - { id: windows-x64,   runner: windows-2022, target: x64 }
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheel
+        uses: PyO3/maturin-action@v1
+        with:
+          command: build
+          target: ${{ matrix.platform.target }}
+          # bindings = "bin" comes from each crate's pyproject.toml; -m selects it.
+          args: --release --out dist -m ${{ matrix.package.manifest }}
+          manylinux: ${{ matrix.platform.manylinux }}
+          sccache: 'true'
+
+      - name: Upload wheel artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: wheel-${{ matrix.package.name }}-${{ matrix.platform.id }}
+          path: dist/*.whl
+
+  sdist:
+    name: sdist ${{ matrix.package.name }}
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        package:
+          - { name: knots, manifest: Cargo.toml }
+          - { name: knots-test-complexity, manifest: knots-test-complexity/Cargo.toml }
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist -m ${{ matrix.package.manifest }}
+
+      - name: Upload sdist artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: sdist-${{ matrix.package.name }}
+          path: dist/*.tar.gz
+
+  publish:
+    name: Publish to PyPI
+    needs: [build, sdist]
+    runs-on: ubuntu-22.04
+    if: startsWith(github.ref, 'refs/tags/v')
+    environment: release
+    permissions:
+      id-token: write          # required for PyPI Trusted Publishing (OIDC)
+    steps:
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true   # flatten wheel-*/ and sdist-*/ into dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          packages-dir: dist
+          # Files route to their PyPI project by name: knots-* vs
+          # knots_test_complexity-*. Both projects must trust this workflow.
+          # skip-existing makes re-runs idempotent: already-published files
+          # (e.g. a version where one package uploaded and the other failed)
+          # are skipped instead of erroring on "file already exists".
+          skip-existing: true

knots_test_complexity-1.11.0/.gitignore

@@ -0,0 +1,12 @@
+report.txt
+target/
+THIRD_PARTY_LICENSES.txt
+*.cdx.json
+docs/_build/
+
+# maturin / PyPI build output
+dist/
+*.whl
+
+.todo-sqlite-cli
+*.db

knots_test_complexity-1.11.0/.pre-commit-config.yaml

@@ -0,0 +1,42 @@
+# Pre-commit hooks for knots
+# Install: pre-commit install
+# Run manually: pre-commit run --all-files
+
+repos:
+  - repo: local
+    hooks:
+      - id: cargo-fmt
+        name: cargo fmt (auto-fix)
+        description: Format Rust code with rustfmt
+        entry: bash -c 'cargo fmt --all 2>&1 && echo "Formatting complete"'
+        language: system
+        pass_filenames: false
+        types: [rust]
+        verbose: true
+
+      - id: cargo-clippy
+        name: cargo clippy
+        description: Lint Rust code with Clippy - deny warnings (all targets including tests)
+        entry: bash -c 'cargo clippy --all-targets --all-features -- -D warnings 2>&1'
+        language: system
+        pass_filenames: false
+        types: [rust]
+        verbose: true
+
+      - id: cargo-test
+        name: cargo test
+        description: Run the test suite
+        entry: bash -c 'cargo test --workspace 2>&1'
+        language: system
+        pass_filenames: false
+        types: [rust]
+        verbose: true
+
+      - id: knots-self-check
+        name: knots (self-check)
+        description: Check this repo's own Rust source complexity with knots
+        entry: bash -c 'cargo run --quiet -- --mccabe-threshold=15 --cognitive-threshold=15 --nesting-threshold=5 --sloc-threshold=50 --abc-threshold=10.0 --return-threshold=3 "$@"' --
+        language: system
+        types: [rust]
+        pass_filenames: true
+        verbose: true