repoglance 0.4.2__tar.gz → 0.5.0__tar.gz

repoglance-0.5.0/.repoglance-badge.json

@@ -0,0 +1 @@
+{"schemaVersion": 1, "label": "repoglance", "message": "3.4k loc \u2022 Python", "color": "blue"}

{repoglance-0.4.2 → repoglance-0.5.0}/CHANGELOG.md

@@ -4,6 +4,36 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-08-01
+
+### Added
+- **Refactor priority**: files ranked by **churn × complexity** — frequently
+  changed *and* complex code, the classic "fix this first" signal. Shown as a
+  panel and in JSON (`risk`).
+- **Coverage × complexity** (`--coverage <cobertura.xml|lcov>`): surfaces
+  complex, poorly-covered files (risk = complexity × (1 − coverage)).
+- **Python quality**: docstring and type-hint coverage across functions.
+- **Import graph** (`--imports`): intra-repo Python module coupling and
+  **circular-import detection**.
+- **Longest functions**: biggest functions by logical lines (in JSON).
+- **Activity trend**: commits-per-month sparkline in the git panel.
+- **GitHub Action inline annotations** (`annotations: true`): a Check Run places
+  complexity warnings on the exact lines in a PR.
+
+## [0.4.3] - 2026-08-01
+
+### Added
+- **`--fast` mode**: counts only (languages, LOC, sizes), skipping per-function
+  complexity parsing — the expensive step. Combined with the process pool this
+  scans **20 million lines in ~4.4 s** (~4.5M LOC/s). Use it for size/inventory
+  passes on very large monorepos; drop it for full complexity/health analysis.
+
+### Changed
+- **Python complexity now uses CPython's C-accelerated `ast`** instead of the
+  pure-Python tokenizer, roughly **halving full-analysis time on Python-heavy
+  repos** (Django 415k LOC: ~10 s → ~5 s on 8 cores). Other languages still use
+  lizard. Adaptive process-pool chunk sizing reduces IPC overhead.
+
 ## [0.4.2] - 2026-08-01
 
 ### Added

{repoglance-0.4.2 → repoglance-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: repoglance
-Version: 0.4.2
+Version: 0.5.0
 Summary: Instant, gorgeous insight into any code repository — languages, complexity hotspots, TODOs and git activity in one terminal command.
 Project-URL: Homepage, https://github.com/SRJ-ai/repoglance
 Project-URL: Repository, https://github.com/SRJ-ai/repoglance
@@ -112,6 +112,8 @@ repoglance --ci --fail-under 70 --max-complexity 25     # gate a build
 repoglance --include "src/**" --exclude "**/*_pb2.py"   # glob filters
 repoglance --duplicates          # detect copy-paste blocks
 repoglance --owners              # attribute hotspots to authors (git blame)
+repoglance --imports             # python import graph + circular imports
+repoglance --coverage coverage.xml   # cross coverage with complexity
 repoglance --cache .rg.cache     # incremental cache for fast repeat runs
 repoglance --watch               # live re-render on file changes
 repoglance --no-git --jobs 8
@@ -132,6 +134,11 @@ repoglance --json | jq '.languages.Python.code'
 | **Languages** | Lines of code per language, ranked, with % bars |
 | **Complexity hotspots** | Real per-function cyclomatic complexity across 15+ languages (C/C++, Java, C#, JS, TS, Go, Rust, Ruby, PHP, Swift, Kotlin, Python…) via [lizard](https://github.com/terryyin/lizard) |
 | **Maintainability index** | Approximate MI (0–100) from complexity, size and token counts |
+| **Refactor priority** | Files ranked by churn × complexity — what to fix first |
+| **Coverage risk** | Cross a coverage report with complexity (`--coverage`): complex + untested = danger |
+| **Python quality** | Docstring and type-hint coverage across functions |
+| **Import graph** | Python module coupling + circular-import detection (`--imports`) |
+| **Longest functions** | The biggest functions by logical lines |
 | **Duplicate code** | Copy-paste blocks across files, with a duplication % |
 | **TODO tracker** | Every `TODO` / `FIXME` / `HACK` / `XXX` / `BUG` with file:line |
 | **Biggest files & directories** | Where the mass and the worst complexity live |
@@ -155,6 +162,9 @@ gives you artifacts you can put in a PR or a README.
 |---|:---:|:---:|:---:|:---:|
 | Lines-of-code by language | ✅ | ✅ | ✅ | ✅ |
 | Per-function complexity (15+ langs) | ✅ | ❌ | ⚠️ file-level | ❌ |
+| **Refactor priority (churn × complexity)** | ✅ | ❌ | ❌ | ❌ |
+| **Coverage × complexity risk** | ✅ | ❌ | ❌ | ❌ |
+| **Circular-import detection** | ✅ | ❌ | ❌ | ❌ |
 | Maintainability index | ✅ | ❌ | ❌ | ❌ |
 | TODO / FIXME tracker | ✅ | ❌ | ❌ | ❌ |
 | Git activity (authors, churn) | ✅ | ❌ | ❌ | ❌ |
@@ -302,11 +312,16 @@ millions of lines, thousands of files — not just small projects:
 
 Measured on Django (3,180 files, ~415k lines of code), single machine:
 
-| Run | Time |
-|---|--:|
-| Cold scan, threads | ~20.5 s |
-| Cold scan, process pool (auto on large repos) | ~10.1 s |
-| Re-run with `--cache` | ~1.1 s |
+| Run | Repo | Time |
+|---|---|--:|
+| Cold scan, full analysis (8 cores) | Django, 415k LOC | ~5.0 s |
+| Re-run with `--cache` | Django, 415k LOC | ~1.1 s |
+| **`--fast` (counts only), process pool** | **20,000,000 LOC** | **~4.4 s** |
+
+`--fast` skips per-function complexity parsing (the expensive step) and reports
+languages, line counts and sizes only — that's what makes a 20-million-line
+scan finish in seconds (~4.5M LOC/s here). Drop `--fast` when you want the full
+complexity/health analysis.
 
 The cold scan is dominated by real per-function complexity parsing. The process
 pool spreads that across cores (~2× here); the incremental cache (`--cache

{repoglance-0.4.2 → repoglance-0.5.0}/README.md

@@ -80,6 +80,8 @@ repoglance --ci --fail-under 70 --max-complexity 25     # gate a build
 repoglance --include "src/**" --exclude "**/*_pb2.py"   # glob filters
 repoglance --duplicates          # detect copy-paste blocks
 repoglance --owners              # attribute hotspots to authors (git blame)
+repoglance --imports             # python import graph + circular imports
+repoglance --coverage coverage.xml   # cross coverage with complexity
 repoglance --cache .rg.cache     # incremental cache for fast repeat runs
 repoglance --watch               # live re-render on file changes
 repoglance --no-git --jobs 8
@@ -100,6 +102,11 @@ repoglance --json | jq '.languages.Python.code'
 | **Languages** | Lines of code per language, ranked, with % bars |
 | **Complexity hotspots** | Real per-function cyclomatic complexity across 15+ languages (C/C++, Java, C#, JS, TS, Go, Rust, Ruby, PHP, Swift, Kotlin, Python…) via [lizard](https://github.com/terryyin/lizard) |
 | **Maintainability index** | Approximate MI (0–100) from complexity, size and token counts |
+| **Refactor priority** | Files ranked by churn × complexity — what to fix first |
+| **Coverage risk** | Cross a coverage report with complexity (`--coverage`): complex + untested = danger |
+| **Python quality** | Docstring and type-hint coverage across functions |
+| **Import graph** | Python module coupling + circular-import detection (`--imports`) |
+| **Longest functions** | The biggest functions by logical lines |
 | **Duplicate code** | Copy-paste blocks across files, with a duplication % |
 | **TODO tracker** | Every `TODO` / `FIXME` / `HACK` / `XXX` / `BUG` with file:line |
 | **Biggest files & directories** | Where the mass and the worst complexity live |
@@ -123,6 +130,9 @@ gives you artifacts you can put in a PR or a README.
 |---|:---:|:---:|:---:|:---:|
 | Lines-of-code by language | ✅ | ✅ | ✅ | ✅ |
 | Per-function complexity (15+ langs) | ✅ | ❌ | ⚠️ file-level | ❌ |
+| **Refactor priority (churn × complexity)** | ✅ | ❌ | ❌ | ❌ |
+| **Coverage × complexity risk** | ✅ | ❌ | ❌ | ❌ |
+| **Circular-import detection** | ✅ | ❌ | ❌ | ❌ |
 | Maintainability index | ✅ | ❌ | ❌ | ❌ |
 | TODO / FIXME tracker | ✅ | ❌ | ❌ | ❌ |
 | Git activity (authors, churn) | ✅ | ❌ | ❌ | ❌ |
@@ -270,11 +280,16 @@ millions of lines, thousands of files — not just small projects:
 
 Measured on Django (3,180 files, ~415k lines of code), single machine:
 
-| Run | Time |
-|---|--:|
-| Cold scan, threads | ~20.5 s |
-| Cold scan, process pool (auto on large repos) | ~10.1 s |
-| Re-run with `--cache` | ~1.1 s |
+| Run | Repo | Time |
+|---|---|--:|
+| Cold scan, full analysis (8 cores) | Django, 415k LOC | ~5.0 s |
+| Re-run with `--cache` | Django, 415k LOC | ~1.1 s |
+| **`--fast` (counts only), process pool** | **20,000,000 LOC** | **~4.4 s** |
+
+`--fast` skips per-function complexity parsing (the expensive step) and reports
+languages, line counts and sizes only — that's what makes a 20-million-line
+scan finish in seconds (~4.5M LOC/s here). Drop `--fast` when you want the full
+complexity/health analysis.
 
 The cold scan is dominated by real per-function complexity parsing. The process
 pool spreads that across cores (~2× here); the incremental cache (`--cache

{repoglance-0.4.2 → repoglance-0.5.0}/action.yml

@@ -29,6 +29,14 @@ inputs:
     description: "Only analyze files changed since this git ref (e.g. origin/main). Empty = whole repo."
     required: false
     default: ""
+  annotations:
+    description: "Create a Check Run with inline complexity annotations on the PR (requires checks: write)."
+    required: false
+    default: "false"
+  annotation-threshold:
+    description: "Minimum complexity to annotate inline."
+    required: false
+    default: "15"
   github-token:
     description: "Token used to post the PR comment."
     required: false
@@ -83,6 +91,47 @@ runs:
           gh api -X POST "repos/${{ github.repository }}/issues/$pr/comments" -f body="$body" >/dev/null
         fi
 
+    - name: Inline annotations (Check Run)
+      if: ${{ inputs.annotations == 'true' }}
+      shell: bash
+      env:
+        GH_TOKEN: ${{ inputs.github-token }}
+      run: |
+        repoglance "${{ inputs.path }}" --json > "$RUNNER_TEMP/repoglance.json"
+        python - "$RUNNER_TEMP/repoglance.json" "${{ inputs.annotation-threshold }}" <<'PY' > "$RUNNER_TEMP/checkrun.json"
+        import json, sys
+        report = json.load(open(sys.argv[1]))
+        threshold = int(sys.argv[2])
+        anns = []
+        for h in report.get("hotspots", []):
+            if h["complexity"] < threshold:
+                continue
+            anns.append({
+                "path": h["path"],
+                "start_line": max(1, h["line"]),
+                "end_line": max(1, h["line"]),
+                "annotation_level": "failure" if h["complexity"] >= 25 else "warning",
+                "message": f"Function '{h['name']}' has cyclomatic complexity {h['complexity']}.",
+                "title": "High complexity",
+            })
+        health = report.get("health", {})
+        out = {
+            "name": "repoglance",
+            "head_sha": "__SHA__",
+            "status": "completed",
+            "conclusion": "neutral",
+            "output": {
+                "title": f"Health {health.get('score','?')}/100 ({health.get('grade','?')})",
+                "summary": f"{len(anns)} complexity hotspot(s) at or above {threshold}.",
+                "annotations": anns[:50],
+            },
+        }
+        print(json.dumps(out))
+        PY
+        sha="${{ github.event.pull_request.head.sha || github.sha }}"
+        sed -i "s/__SHA__/$sha/" "$RUNNER_TEMP/checkrun.json"
+        gh api -X POST "repos/${{ github.repository }}/check-runs" --input "$RUNNER_TEMP/checkrun.json" >/dev/null || true
+
     - name: Gate
       shell: bash
       run: |