feat: add interactive heatmap visualization for batch assessments

Adds comprehensive heatmap visualization feature for batch repository assessments,
displaying attributes (columns) versus repositories (rows) with color-coded scores.

Core Features:
- Interactive Plotly heatmap with zoom, pan, and hover tooltips
- Repositories sorted by overall score (descending)
- Attributes sorted by tier (1-4), then alphabetically
- Color scale: Gray (N/A), Red (0-39), Yellow (40-59), Green (60-89), Dark Green (90-100)
- Certification badges (💎🥇🥈🥉⚠️) with overall scores annotated on left axis
- Standalone HTML output (5MB, no external dependencies)

CLI Integration:
- `--generate-heatmap` flag for assess-batch command
- `--heatmap-output` flag for custom output path
- Automatic heatmap generation saved to reports-*/heatmap.html

Implementation Details:
1. Extended AttributeAnalyzer with analyze_batch() method
2. DataFrame transformation with pandas for matrix data
3. Custom colorscale with -1 sentinel for NaN (gray for not_applicable)
4. Duplicate attribute deduplication (workaround for assessor bug)
5. Added analyze_batch_from_json() to bypass broken cache deserialization

Duplicate Attribute Fix:
- Identified 3 duplicate attributes (one_command_setup, architecture_decisions, issue_pr_templates)
- Each appeared 2× per repo, with 2nd occurrence marked not_applicable (causing gray squares)
- Added deduplication logic: skip duplicates, keep first occurrence only
- Reduces 31 attributes → 28 real attributes, eliminating 108 erroneous gray cells

Cache Deserialization Workaround:
- Discovered AssessmentCache._deserialize_assessment() raises NotImplementedError
- Added analyze_batch_from_json() method that works directly with dict data
- Added _prepare_batch_dataframe_from_json() for JSON-based DataFrame preparation
- Enables heatmap regeneration without requiring object deserialization

Utility Scripts:
- scripts/extract_repo_urls.py: Extract URLs from filtered JSON for batch input
- scripts/fix_heatmap_data.py: Remove duplicate attributes from all-assessments.json
- scripts/regenerate_heatmap.py: Regenerate heatmap from fixed JSON data

Testing:
- Validated with 36 OpenDataHub repositories
- Average score: 40.1/100 (Bronze)
- 100% success rate on initial run
- Heatmap size: 5.1 MB (36 repos × 28 attributes)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jeremyeder

scripts/extract_repo_urls.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""
+Extract repository URLs from filtered GitHub org analysis.
+
+Reads the filtered active originals JSON and outputs a simple text file
+with one repository URL per line for use with agentready assess-batch.
+"""
+
+import json
+from pathlib import Path
+
+
+def main():
+    # Input: filtered repos JSON
+    input_file = Path(".cache/github-org-analysis/opendatahub-io-active-originals.json")
+
+    # Output: simple text file with URLs
+    output_file = Path("opendatahub-repos.txt")
+
+    # Load filtered repository data
+    print(f"Loading filtered repositories from {input_file}")
+    with input_file.open() as f:
+        data = json.load(f)
+
+    repos = data["repositories"]
+    print(f"Found {len(repos)} repositories")
+
+    # Extract URLs
+    urls = [repo["url"] for repo in repos]
+
+    # Write to output file
+    with output_file.open("w") as f:
+        for url in urls:
+            f.write(f"{url}\n")
+
+    print(f"✅ Wrote {len(urls)} repository URLs to {output_file}")
+    print(f"\nUsage:")
+    print(
+        f"  agentready assess-batch --repos-file {output_file} --cache-dir ~/repos/cache/github-org --generate-heatmap"
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/fix_heatmap_data.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""Fix heatmap by removing duplicate attributes from successful batch assessment."""
+
+import json
+from pathlib import Path
+
+
+def fix_duplicate_attributes():
+    """Remove duplicate attribute findings from all-assessments.json."""
+    input_file = Path(".agentready/batch/reports-20251124-160049/all-assessments.json")
+    output_file = Path(
+        ".agentready/batch/reports-20251124-160049/all-assessments-fixed.json"
+    )
+
+    print(f"Loading {input_file}...")
+    with input_file.open() as f:
+        data = json.load(f)
+
+    total_removed = 0
+    for result in data["results"]:
+        assessment = result.get("assessment")
+        if not assessment:
+            continue
+
+        # Track seen attributes and filter duplicates (keep first occurrence)
+        seen_attrs = set()
+        fixed_findings = []
+
+        for finding in assessment["findings"]:
+            attr_id = finding["attribute"]["id"]
+            if attr_id in seen_attrs:
+                total_removed += 1
+                print(
+                    f"  Removing duplicate: {attr_id} from "
+                    f"{assessment['repository']['name']}"
+                )
+                continue
+            seen_attrs.add(attr_id)
+            fixed_findings.append(finding)
+
+        # Update findings list
+        assessment["findings"] = fixed_findings
+
+        # Update counts
+        assessment["attributes_assessed"] = len(fixed_findings)
+
+    print(f"\n✓ Removed {total_removed} duplicate attribute findings")
+    print(f"✓ Writing fixed data to {output_file}...")
+
+    with output_file.open("w") as f:
+        json.dump(data, f, indent=2)
+
+    print(f"✓ Done! File size: {output_file.stat().st_size / 1024 / 1024:.1f} MB")
+
+
+if __name__ == "__main__":
+    fix_duplicate_attributes()

scripts/regenerate_heatmap.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Regenerate heatmap from existing batch assessment JSON."""
+
+import json
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from agentready.services.attribute_analyzer import AttributeAnalyzer
+
+
+def main():
+    """Load fixed all-assessments.json and regenerate heatmap with deduplication fix."""
+    # Use the fixed JSON with duplicates removed
+    input_file = Path(
+        ".agentready/batch/reports-20251124-160049/all-assessments-fixed.json"
+    )
+    output_file = Path(".agentready/batch/reports-20251124-160049/heatmap-fixed.html")
+
+    print(f"Loading batch assessment from {input_file}...")
+
+    with input_file.open() as f:
+        batch_data = json.load(f)
+
+    successful = len([r for r in batch_data["results"] if r.get("assessment")])
+    print(f"Loaded {len(batch_data['results'])} repositories, {successful} successful")
+
+    # Generate heatmap using the new JSON-based method
+    print(f"Generating heatmap to {output_file}...")
+    analyzer = AttributeAnalyzer()
+    analyzer.analyze_batch_from_json(batch_data, output_file)
+
+    print(f"\n✓ Heatmap regenerated successfully!")
+    print(f"  File: {output_file}")
+    print(f"  Size: {output_file.stat().st_size / 1024 / 1024:.1f} MB")
+
+
+if __name__ == "__main__":
+    main()

src/agentready/cli/assess_batch.py

@@ -249,6 +249,18 @@ def _generate_multi_reports(batch_assessment, output_path: Path, verbose: bool)
     default=None,
     help="Custom cache directory (default: .agentready/cache/)",
 )
+@click.option(
+    "--generate-heatmap",
+    is_flag=True,
+    default=False,
+    help="Generate interactive Plotly heatmap visualization",
+)
+@click.option(
+    "--heatmap-output",
+    type=click.Path(),
+    default=None,
+    help="Custom path for heatmap HTML (default: reports-*/heatmap.html)",
+)
 def assess_batch(
     repos_file: Optional[str],
     repos: tuple,
@@ -260,6 +272,8 @@ def assess_batch(
     config: Optional[str],
     use_cache: bool,
     cache_dir: Optional[str],
+    generate_heatmap: bool,
+    heatmap_output: Optional[str],
 ):
     """Assess multiple repositories in a batch operation.
 
@@ -414,6 +428,30 @@ def show_progress(current: int, total: int):
     # Generate comprehensive Phase 2 reports
     _generate_multi_reports(batch_assessment, output_path, verbose)
 
+    # Generate heatmap if requested
+    if generate_heatmap:
+        from ..services.attribute_analyzer import AttributeAnalyzer
+
+        timestamp = batch_assessment.timestamp.strftime("%Y%m%d-%H%M%S")
+        reports_dir = output_path / f"reports-{timestamp}"
+        heatmap_path = (
+            Path(heatmap_output) if heatmap_output else (reports_dir / "heatmap.html")
+        )
+
+        if verbose:
+            click.echo(f"\nGenerating heatmap visualization...")
+
+        try:
+            analyzer = AttributeAnalyzer()
+            analyzer.analyze_batch(batch_assessment, heatmap_path)
+            click.echo(f"  ✓ heatmap.html")
+        except Exception as e:
+            click.echo(f"⚠ Warning: Failed to generate heatmap: {e}", err=True)
+            if verbose:
+                import traceback
+
+                traceback.print_exc()
+
     # Print summary
     click.echo("\n" + "=" * 50)
     click.echo("Batch Assessment Summary")