linkml-reference-validator 0.2.0rc1__tar.gz → 0.2.1rc2__tar.gz

linkml_reference_validator-0.2.1rc2/.claude/settings.json

@@ -0,0 +1,2 @@
+{
+}

linkml_reference_validator-0.2.1rc2/.devcontainer/devcontainer.json

@@ -0,0 +1,27 @@
+{
+  "name": "odkfull-codespace",
+  // consider also: Codespaces Prebuilds
+  "image": "obolibrary/odkfull:latest",
+
+  // Mount your repo where ODK expects it
+  "workspaceMount": "source=${localWorkspaceFolder},target=/work,type=bind,consistency=cached",
+  "workspaceFolder": "/work",
+
+  // Keep VS Code in control of the container command (safer than using image ENTRYPOINT)
+  "overrideCommand": true,
+
+  // Be root so you can add small tools if you need them
+  "remoteUser": "root",    
+  //"features": {
+  //  "ghcr.io/devcontainers/features/node:1": { "version": "lts" }
+  //},
+  "extensions": [
+      "anthropic.claude-code",
+      "ms-python.python",
+      "ms-azuretools.vscode-docker"
+  ],
+  "remoteEnv": {
+    "TEST_ENV": "123"
+  },
+  "postCreateCommand": "bash .devcontainer/post_create.sh"
+}

linkml_reference_validator-0.2.1rc2/.devcontainer/post_create.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -e
+odk --help || true
+#curl -LsSf https://astral.sh/uv/install.sh | sh
+#uv pip install oaklib
+npm install -g @anthropic-ai/claude-code

linkml_reference_validator-0.2.1rc2/.github/workflows/claude-code-review.yml

@@ -0,0 +1,61 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+    
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: read
+      issues: read
+      id-token: write
+    
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # In v1, providing a `prompt` runs in automation mode, which does NOT
+          # post a comment by default. track_progress restores the v0.x
+          # "post the review as a PR comment" behavior and auto-injects PR context.
+          track_progress: true
+
+          # Prompt for the automated review (no @claude mention needed).
+          prompt: |
+            Please review this pull request and provide feedback on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Performance considerations
+            - Security concerns
+            - Test coverage
+
+            Be constructive and helpful in your feedback.
+
+          # Args passed through to the Claude CLI. Use the `opus` alias rather
+          # than a dated model id so the workflow tracks the current Opus and
+          # won't 404 when a specific version is retired.
+          claude_args: |
+            --model opus
+

{linkml_reference_validator-0.2.0rc1 → linkml_reference_validator-0.2.1rc2}/.github/workflows/claude-ontology-review.yml

@@ -35,15 +35,23 @@ jobs:
 
       - name: Run Claude Code Ontology Review
         id: claude-review
-        uses: anthropics/claude-code-action@beta
+        uses: anthropics/claude-code-action@v1
         with:
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
 
-          # Optional: Specify model (commenting defaults to Claude Sonnet 4)
-          model: "claude-opus-4-1-20250805"
+          # In v1, providing a `prompt` runs in automation mode, which does NOT
+          # post a comment by default. track_progress restores the v0.x
+          # "post the review as a PR comment" behavior and auto-injects PR context.
+          track_progress: true
 
-          # Direct prompt for automated review (no @claude mention needed)
-          direct_prompt: |
+          # Model is passed through to the Claude CLI via claude_args. Use the
+          # `opus` alias so the workflow tracks the current Opus and won't 404
+          # when a specific dated model id is retired.
+          claude_args: |
+            --model opus
+
+          # Prompt for the automated review (no @claude mention needed)
+          prompt: |
             REPO: ${{ github.repository }}
             PR NUMBER: ${{ github.event.pull_request.number }}
 
@@ -90,26 +98,4 @@ jobs:
 
           # Optional: Use sticky comments to make Claude reuse the same comment on subsequent pushes to the same PR
           use_sticky_comment: true
-          
-          # Optional: Customize review based on file types
-          # direct_prompt: |
-          #   Review this PR focusing on:
-          #   - For TypeScript files: Type safety and proper interface usage
-          #   - For API endpoints: Security, input validation, and error handling
-          #   - For React components: Performance, accessibility, and best practices
-          #   - For tests: Coverage, edge cases, and test quality
-          
-          # Optional: Different prompts for different authors
-          # direct_prompt: |
-          #   ${{ github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR' && 
-          #   'Welcome! Please review this PR from a first-time contributor. Be encouraging and provide detailed explanations for any suggestions.' ||
-          #   'Please provide a thorough code review focusing on our coding standards and best practices.' }}
-          
-          # Optional: Add specific tools for running tests or linting
-          # allowed_tools: "Bash(npm run test),Bash(npm run lint),Bash(npm run typecheck)"
-          
-          # Optional: Skip review for certain conditions
-          # if: |
-          #   !contains(github.event.pull_request.title, '[skip-review]') &&
-          #   !contains(github.event.pull_request.title, '[WIP]')
 

linkml_reference_validator-0.2.1rc2/.github/workflows/claude.yml

@@ -0,0 +1,62 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 1
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+            
+      - name: Install python tools
+        run: |
+          uv sync
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # In v1 the model, MCP servers, and allowed tools are passed through to
+          # the Claude CLI via claude_args (the v0.x model / mcp_config /
+          # allowed_tools inputs were removed). The `opus` alias tracks the
+          # current Opus so this won't 404 when a dated model id is retired.
+          claude_args: |
+            --model opus
+            --mcp-config '{"mcpServers":{"ols":{"command":"uvx","args":["ols-mcp"]},"sequential-thinking":{"command":"npx","args":["-y","@modelcontextprotocol/server-sequential-thinking"]}}}'
+            --allowedTools "Bash(*),FileEdit,Edit,MultiEdit,WebSearch,WebFetch,mcp__ols_mcp__search_all_ontologies,mcp__ols_mcp__get_terms_from_ontology"
+
+          # Optional: Customize the trigger phrase (default: @claude)
+          # trigger_phrase: "/claude"
+

{linkml_reference_validator-0.2.0rc1 → linkml_reference_validator-0.2.1rc2}/.github/workflows/dragon-ai.yml

@@ -29,7 +29,7 @@ jobs:
         
       - name: Check for qualifying mention
         id: check
-        uses: actions/github-script@v6
+        uses: actions/github-script@v9
         with:
           github-token: ${{ secrets.PAT_FOR_PR }}  # Use PAT instead of default token
           script: |
@@ -131,7 +131,7 @@ jobs:
           ls -alt ${{ env.TOOLS_DIR }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v7
           
       - name: Install python tools
         run: |

{linkml_reference_validator-0.2.0rc1 → linkml_reference_validator-0.2.1rc2}/.gitignore

@@ -141,3 +141,4 @@ dmypy.json
 .idea
 # Local vscode editor config
 .vscode
+.cursor

linkml_reference_validator-0.2.1rc2/.goosehints

@@ -0,0 +1 @@
+AGENTS.md

linkml_reference_validator-0.2.1rc2/AGENTS.md

@@ -0,0 +1 @@
+CLAUDE.md

linkml_reference_validator-0.2.1rc2/BUG_GEO_ACCESSION_TO_UID.md

@@ -0,0 +1,137 @@
+# Bug: GEOSource fails to fetch GEO datasets
+
+## Summary
+
+The `GEOSource` class in `linkml_reference_validator/etl/sources/entrez.py` cannot fetch GEO dataset metadata because it passes GSE accessions directly to `esummary`, but the GDS Entrez database requires numeric UIDs.
+
+## Error Observed
+
+```
+WARNING:linkml_reference_validator.etl.sources.entrez:Failed to fetch Entrez summary for GEO:GSE67472: Invalid uid GSE67472 at position= 0
+```
+
+## Root Cause
+
+The `EntrezSummarySource.fetch()` method calls:
+
+```python
+handle = Entrez.esummary(db=self.ENTREZ_DB, id=identifier)
+```
+
+For GEO, this becomes `esummary(db='gds', id='GSE67472')`, but the GDS database doesn't accept accession numbers as IDs - it requires numeric UIDs like `200067472`.
+
+## Proof of Concept
+
+```python
+from Bio import Entrez
+Entrez.email = 'test@example.com'
+
+# This FAILS - accession not accepted as UID
+handle = Entrez.esummary(db='gds', id='GSE67472')
+# Error: Invalid uid GSE67472 at position=0
+
+# This WORKS - use esearch first to get UID
+handle = Entrez.esearch(db='gds', term='GSE67472[Accession]')
+result = Entrez.read(handle)
+handle.close()
+# result['IdList'] = ['200067472', ...]
+
+uid = result['IdList'][0]  # '200067472'
+
+handle = Entrez.esummary(db='gds', id=uid)
+summary = Entrez.read(handle)
+handle.close()
+print(summary[0].get('title'))
+# Output: "Airway epithelial gene expression in asthma versus healthy controls"
+```
+
+## Proposed Fix
+
+Override `fetch()` in `GEOSource` to add an `esearch` step that converts accessions to UIDs:
+
+```python
+@ReferenceSourceRegistry.register
+class GEOSource(EntrezSummarySource):
+    """Fetch GEO series and dataset summaries from Entrez."""
+
+    PREFIX = "GEO"
+    ENTREZ_DB = "gds"
+    TITLE_FIELDS = ("title", "description", "summary")
+    CONTENT_FIELDS = ("summary", "description", "title")
+    ID_PATTERNS = (r"^GSE\d+$", r"^GDS\d+$")
+
+    def fetch(
+        self, identifier: str, config: ReferenceValidationConfig
+    ) -> Optional[ReferenceContent]:
+        """Fetch GEO dataset metadata, converting accession to UID first."""
+        Entrez.email = config.email
+        time.sleep(config.rate_limit_delay)
+
+        # Convert accession to UID via esearch
+        uid = self._accession_to_uid(identifier)
+        if not uid:
+            logger.warning(f"Could not find GDS UID for {identifier}")
+            return None
+
+        # Now fetch summary with numeric UID
+        handle = None
+        try:
+            handle = Entrez.esummary(db=self.ENTREZ_DB, id=uid)
+            records = Entrez.read(handle)
+        except Exception as exc:
+            logger.warning(f"Failed to fetch Entrez summary for {self.prefix()}:{identifier}: {exc}")
+            return None
+        finally:
+            if handle is not None:
+                handle.close()
+
+        record = self._extract_record(records)
+        if not record:
+            logger.warning(f"No Entrez summary found for {self.prefix()}:{identifier}")
+            return None
+
+        title = self._get_first_field_value(record, self.TITLE_FIELDS)
+        content = self._get_first_field_value(record, self.CONTENT_FIELDS)
+        content_type = "summary" if content else "unavailable"
+
+        return ReferenceContent(
+            reference_id=f"{self.prefix()}:{identifier}",
+            title=title,
+            content=content,
+            content_type=content_type,
+            metadata={"entrez_db": self.ENTREZ_DB, "entrez_uid": uid},
+        )
+
+    def _accession_to_uid(self, accession: str) -> Optional[str]:
+        """Convert a GEO accession (GSE/GDS) to its Entrez UID."""
+        handle = None
+        try:
+            handle = Entrez.esearch(db=self.ENTREZ_DB, term=f"{accession}[Accession]")
+            result = Entrez.read(handle)
+            if result.get("IdList"):
+                return result["IdList"][0]
+        except Exception as exc:
+            logger.warning(f"esearch failed for {accession}: {exc}")
+        finally:
+            if handle is not None:
+                handle.close()
+        return None
+```
+
+## Testing
+
+After the fix, validation should catch title mismatches like:
+
+```yaml
+# In kb/disorders/Asthma.yaml
+datasets:
+  - accession: geo:GSE67472
+    title: xxxAirway epithelial gene expression in asthma versus healthy controls  # Wrong!
+```
+
+Expected validation error:
+```
+[ERROR] Title mismatch for geo:GSE67472
+  Expected: "Airway epithelial gene expression in asthma versus healthy controls"
+  Found: "xxxAirway epithelial gene expression in asthma versus healthy controls"
+```

linkml_reference_validator-0.2.1rc2/BUG_ZENODO_DOI_AND_URL_HANDLING.md

@@ -0,0 +1,258 @@
+# Bug Report: Zenodo DOIs and bare HTTPS URLs not handled
+
+## Summary
+
+Two related bugs prevent fetching Zenodo DOIs and bare HTTPS URLs:
+
+1. **Zenodo DOIs return 404**: DOIs like `DOI:10.5281/zenodo.17993529` fail because the DOI source only queries Crossref, but Zenodo DOIs are registered with DataCite.
+
+2. **Bare HTTPS URLs not recognized**: URLs like `https://doi.org/10.5281/zenodo.17993529` fail because the prefix parser extracts `https` as the prefix, which gets uppercased to `HTTPS` and doesn't match any source.
+
+## Reproduction
+
+```bash
+# Both of these fail:
+linkml-reference-validator lookup --no-cache https://doi.org/10.5281/zenodo.17993529
+# Output: No source found for reference type: HTTPS://doi.org/10.5281/zenodo.17993529
+
+linkml-reference-validator lookup --no-cache DOI:10.5281/zenodo.17993529
+# Output: Failed to fetch DOI:10.5281/zenodo.17993529 - status 404
+```
+
+## Root Cause Analysis
+
+### Bug 1: URL Prefix Handling
+
+In `src/linkml_reference_validator/etl/reference_fetcher.py`:
+
+```python
+# Line 141 - regex parses https://example.com as:
+#   prefix = "https"
+#   identifier = "//example.com"
+match = re.match(r"^([A-Za-z_]+)[:\s]+(.+)$", stripped)
+
+# Lines 174-178 - prefix normalization uppercases non-file/url prefixes:
+def _normalize_prefix(self, prefix: str) -> str:
+    if prefix.lower() in ("file", "url"):
+        return prefix.lower()
+    return prefix.upper()  # "https" becomes "HTTPS"
+```
+
+No source is registered for `HTTPS:`, so lookup fails.
+
+### Bug 2: Crossref-only DOI Resolution
+
+In `src/linkml_reference_validator/etl/sources/doi.py`:
+
+```python
+# Line 72 - only queries Crossref API
+url = f"https://api.crossref.org/works/{doi}"
+```
+
+Zenodo DOIs (prefix `10.5281/zenodo.*`) are registered with **DataCite**, not Crossref. Crossref returns 404 for these DOIs.
+
+## Solution
+
+### Fix 1: Handle bare HTTP/HTTPS URLs
+
+In `reference_fetcher.py`, add detection for bare URLs before the prefix regex matching:
+
+```python
+def _parse_reference_id(self, reference_id: str) -> tuple[str, str]:
+    stripped = reference_id.strip()
+
+    # NEW: Handle bare URLs (http:// or https://)
+    if stripped.lower().startswith(("http://", "https://")):
+        return "url", stripped
+
+    # Existing prefix:identifier parsing...
+    match = re.match(r"^([A-Za-z_]+)[:\s]+(.+)$", stripped)
+    # ... rest of method
+```
+
+### Fix 2: Add DataCite fallback for DOIs
+
+In `doi.py`, try Crossref first, then fall back to DataCite if 404:
+
+```python
+def fetch(
+    self, identifier: str, config: ReferenceValidationConfig
+) -> Optional[ReferenceContent]:
+    doi = identifier.strip()
+    time.sleep(config.rate_limit_delay)
+
+    # Try Crossref first
+    result = self._fetch_from_crossref(doi, config)
+    if result:
+        return result
+
+    # Fall back to DataCite (handles Zenodo, Figshare, etc.)
+    return self._fetch_from_datacite(doi, config)
+
+def _fetch_from_crossref(self, doi: str, config: ReferenceValidationConfig) -> Optional[ReferenceContent]:
+    """Fetch from Crossref API."""
+    url = f"https://api.crossref.org/works/{doi}"
+    headers = {
+        "User-Agent": f"linkml-reference-validator/1.0 (mailto:{config.email})",
+    }
+
+    response = requests.get(url, headers=headers, timeout=30)
+    if response.status_code != 200:
+        logger.debug(f"Crossref returned {response.status_code} for DOI:{doi}, will try DataCite")
+        return None
+
+    data = response.json()
+    if data.get("status") != "ok":
+        return None
+
+    message = data.get("message", {})
+    return self._parse_crossref_response(doi, message)
+
+def _fetch_from_datacite(self, doi: str, config: ReferenceValidationConfig) -> Optional[ReferenceContent]:
+    """Fetch from DataCite API (handles Zenodo, Figshare, Dryad, etc.)."""
+    url = f"https://api.datacite.org/dois/{doi}"
+    headers = {
+        "User-Agent": f"linkml-reference-validator/1.0 (mailto:{config.email})",
+        "Accept": "application/json",
+    }
+
+    response = requests.get(url, headers=headers, timeout=30)
+    if response.status_code != 200:
+        logger.warning(f"Failed to fetch DOI:{doi} from both Crossref and DataCite")
+        return None
+
+    data = response.json()
+    attributes = data.get("data", {}).get("attributes", {})
+
+    # Extract title
+    titles = attributes.get("titles", [])
+    title = titles[0].get("title", "") if titles else ""
+
+    # Extract authors
+    authors = self._parse_datacite_creators(attributes.get("creators", []))
+
+    # Extract year
+    year = str(attributes.get("publicationYear", ""))
+
+    # Extract abstract from descriptions
+    abstract = ""
+    for desc in attributes.get("descriptions", []):
+        if desc.get("descriptionType") == "Abstract":
+            abstract = desc.get("description", "")
+            break
+
+    # Publisher as journal equivalent
+    publisher = attributes.get("publisher", "")
+
+    return ReferenceContent(
+        reference_id=f"DOI:{doi}",
+        title=title,
+        content=abstract if abstract else None,
+        content_type="abstract_only" if abstract else "unavailable",
+        authors=authors,
+        journal=publisher,
+        year=year,
+        doi=doi,
+    )
+
+def _parse_datacite_creators(self, creators: list) -> list[str]:
+    """Parse creator list from DataCite response."""
+    result = []
+    for creator in creators:
+        # DataCite may have full name or given/family
+        name = creator.get("name")
+        if not name:
+            given = creator.get("givenName", "")
+            family = creator.get("familyName", "")
+            if given and family:
+                name = f"{given} {family}"
+            elif family:
+                name = family
+            elif given:
+                name = given
+        if name:
+            result.append(name)
+    return result
+```
+
+## DataCite API Response Structure
+
+The DataCite API at `https://api.datacite.org/dois/{doi}` returns:
+
+```json
+{
+  "data": {
+    "attributes": {
+      "doi": "10.5281/zenodo.17993529",
+      "titles": [{"title": "Gene Ontology Curators AI Workshop (Part 1)"}],
+      "creators": [
+        {
+          "name": "Mungall, Christopher",
+          "givenName": "Christopher",
+          "familyName": "Mungall",
+          "affiliation": [{"name": "Lawrence Berkeley National Laboratory"}]
+        }
+      ],
+      "publicationYear": 2025,
+      "publisher": "Zenodo",
+      "descriptions": [
+        {
+          "description": "Workshop aims to equip curators with...",
+          "descriptionType": "Abstract"
+        }
+      ]
+    }
+  }
+}
+```
+
+## Test Cases
+
+Add tests for both fixes:
+
+```python
+@pytest.mark.integration
+def test_zenodo_doi():
+    """Test that Zenodo DOIs are fetched via DataCite."""
+    config = ReferenceValidationConfig()
+    fetcher = ReferenceFetcher(config)
+    ref = fetcher.fetch("DOI:10.5281/zenodo.17993529", force_refresh=True)
+    assert ref is not None
+    assert "Gene Ontology" in ref.title
+    assert ref.year == "2025"
+
+@pytest.mark.integration
+def test_bare_https_url():
+    """Test that bare HTTPS URLs are handled."""
+    config = ReferenceValidationConfig()
+    fetcher = ReferenceFetcher(config)
+    ref = fetcher.fetch("https://example.com", force_refresh=True)
+    assert ref is not None
+    assert ref.reference_id == "url:https://example.com"
+
+def test_parse_bare_url():
+    """Test URL parsing for bare HTTP/HTTPS URLs."""
+    config = ReferenceValidationConfig()
+    fetcher = ReferenceFetcher(config)
+
+    assert fetcher._parse_reference_id("https://example.com") == ("url", "https://example.com")
+    assert fetcher._parse_reference_id("http://example.com/path") == ("url", "http://example.com/path")
+    assert fetcher._parse_reference_id("url:https://example.com") == ("url", "https://example.com")
+```
+
+## Files to Modify
+
+1. `src/linkml_reference_validator/etl/reference_fetcher.py` - Add bare URL detection
+2. `src/linkml_reference_validator/etl/sources/doi.py` - Add DataCite fallback
+3. `tests/test_reference_fetcher.py` - Add unit tests
+4. `tests/test_doi_source.py` or similar - Add integration tests
+
+## Verification
+
+After fixes, these should work:
+
+```bash
+linkml-reference-validator lookup DOI:10.5281/zenodo.17993529
+linkml-reference-validator lookup https://doi.org/10.5281/zenodo.17993529
+linkml-reference-validator lookup https://zenodo.org/records/17993529
+```

linkml_reference_validator-0.2.1rc2/CLI-ISSUES.md

@@ -0,0 +1,31 @@
+# CLI Issues
+
+## 1) `validate data` summary label is misleading
+
+**Current behavior**
+The CLI prints:
+```
+Validation Summary:
+  Total checks: <N>
+```
+where `<N>` is the **number of issues** (`len(all_results)`), not the number of checks performed. This makes successful runs look like they performed zero checks (e.g., “Total checks: 0”), which is confusing.
+
+**Where**
+`linkml_reference_validator/cli/validate.py` (near the end of `validate data` command).
+
+**Repro**
+Run with a file that has valid evidence/snippets and get:
+```
+Validation Summary:
+  Total checks: 0
+  All validations passed!
+```
+
+**Suggested fix**
+Either:
+- Rename the label to **“Total issues”**, or
+- Add two counters:
+  - **Checks performed** (number of excerpt/reference pairs found)
+  - **Issues found** (`len(all_results)`) 
+
+This would make the summary accurate and less surprising.