git2report 0.1.0__tar.gz

git2report-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vijay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

git2report-0.1.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: git2report
+Version: 0.1.0
+Summary: Turn Git history into a plain-language, evidence-linked progress report with visual charts and Terminal Web Studio.
+Author-email: Vijay <vijaykd04@users.noreply.github.com>
+License: MIT
+Project-URL: Homepage, https://github.com/vijaykd04/Git2Report
+Project-URL: Repository, https://github.com/vijaykd04/Git2Report.git
+Project-URL: Issues, https://github.com/vijaykd04/Git2Report/issues
+Keywords: git,report,changelog,ai,gemini,ollama,terminal,metrics
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydriller>=2.5
+Requires-Dist: typer>=0.9
+Requires-Dist: jinja2>=3.1
+Requires-Dist: reportlab>=4.0
+Requires-Dist: ollama>=0.3
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Dynamic: license-file
+
+# Git2Report
+
+Turn a Git repository's history into a plain-language weekly progress report, where **every number is
+counted by code** and **every line carries commit IDs as proof**. The AI (optional, local) only writes
+sentences.
+
+```
+git2report --repo . --since 7d --audience guide --out report.pdf
+```
+
+## Install
+
+```
+python -m venv .venv
+.venv\Scripts\activate          # Windows   (Linux/macOS: source .venv/bin/activate)
+pip install -e ".[dev]"          # core + pytest
+pip install -e ".[ollama]"       # only if you want AI sentences (also install Ollama from ollama.com)
+```
+
+## Use
+
+### 🖥️ Interactive Web Studio GUI
+Launch the browser-based dashboard to configure, run, preview, and download reports with 1 click:
+```
+git2report --ui               # Opens Web Studio at http://localhost:5000
+# or: git2report-ui
+```
+
+### 💻 Command Line (Terminal)
+```bash
+# 1. Standard full-format generation (PDF + HTML + Markdown)
+git2report --repo ./myproject --since 7d --all --out report.html
+
+# 2. Local AI with Ollama (Private, offline, zero API keys)
+git2report --repo ./myproject --llm ollama --model llama3:8b
+# Or shortcut:
+git2report --repo ./myproject --ollama --model mistral
+
+# 3. Cloud AI with Google Gemini (Fast, smart summary caching)
+git2report --repo ./myproject --llm gemini --model gemini-2.5-flash
+
+# 4. Pure offline deterministic mode (Zero AI, instant)
+git2report --repo ./myproject --llm offline --audience guide
+
+# 5. Targeted audience personas
+git2report --repo ./myproject --since 2w --audience client --both          # Business & user-facing
+git2report --repo ./myproject --since 2w --audience team --both            # Engineering release notes
+
+# 6. Sprint goals & caching
+git2report --repo . --next "Finish payment gateway" --next "Write tests"   # Authentic developer goals
+git2report --clear-cache                                                   # Reset summary cache
+```
+
+### AI Engines (`--llm`)
+- **`--llm ollama`**: Uses a local model running on your machine via [Ollama](https://ollama.com/) (e.g., `llama3:8b`, `llama3.2`, `mistral`, `deepseek-r1:8b`, `phi4`). Zero data leaves your machine. Automatically discovers available local models. If Ollama is offline or uninstalled, it gracefully falls back to deterministic offline wording without crashing.
+- **`--llm gemini`**: Uses Google Gemini (`gemini-2.5-flash`) with smart SHA-256 caching (`.git2report_cache.json`) for fast execution and zero duplicate token costs. Set `GEMINI_API_KEY` in your environment or `.env` file.
+- **`--llm offline`** (default): Builds clean human sentences directly from commit messages without invoking any AI.
+
+Every AI output is validated by code: if the model returns invalid JSON, mentions raw numbers, or mentions file paths, Git2Report automatically retries once and falls back safely.
+
+
+## Evaluation (manual vs tool vs baseline)
+
+```
+git2report-eval sheet --repo ./proj --since 45d --n 25 --out eval.csv    # builds the sheet
+# open eval.csv in Excel: write manual_summary, give 1-5 scores, count unsupported claims
+git2report-eval score eval.csv --out results.md                          # averages: tool vs baseline
+```
+The baseline is what you get without the pipeline: the raw commit message (offline) or the raw commit pasted
+to the AI (`--llm ollama`). Be honest in the project report about the sample size and whose repo it was.
+
+## Audiences (offline mode)
+
+`guide` = full list, `client` = only user-facing work (features, fixes, performance), `team` = release-notes
+grouped by type. A commit's type comes from `type(scope):` if present, otherwise it is guessed from its first
+word (Add = feature, Fix = fix, Remove = refactor...). It is a heuristic, so check it on your own repo.
+
+## How it works (7 steps, one file each)
+
+| Step | File | Output |
+|---|---|---|
+| 1 Extract | `extractor.py` | list of `CommitRecord` |
+| 2 Filter | `filtering.py` | kept commits + a reason for every decision |
+| 3 Cluster | `clustering.py` | `{module: [commits]}` (scope, then folder, then commit type) |
+| 4 Metrics | `metrics.py` | numbers (junk files excluded) |
+| 5 Chunk | `chunker.py` | short code text per module, within a token budget |
+| 6 Summarise | `summarizer.py` | one sentence per module (AI or offline), checked by code |
+| 7 Report | `report.py` | Markdown (Jinja2) and PDF (ReportLab) |
+
+Tunable rules (junk files, noise words, aliases, budget) live in `config.py`.
+
+## Develop
+
+```
+pytest -q                  # 38 tests, uses a throw-away real Git repo
+bash scripts/make_demo_repo.sh   # 10-commit demo repo in ./demo_repo
+```
+
+## Status
+
+Done and tested:
+- Steps 1-7 deterministic pipeline with verified commit hashes.
+- 🖥️ **Interactive Web Studio GUI** (`git2report --ui`) with real-time progress, live preview, and direct PDF/HTML/MD downloads.
+- ⚡ **Smart Summary Cache** (`.git2report_cache.json`) for instant sub-second re-runs and 0 API token waste.
+- 📊 **Visual Analytics & Charts** (Commit type distribution segmented bar & module churn chart embedded in PDF & HTML).
+- Offline summaries per audience, unmerged "in progress" branches, developer-written sprint goals.
+- 🦙 **Ollama Local AI & Google Gemini Cloud AI**: Choose between 100% private local models (`llama3:8b`, `mistral`, `deepseek-r1`) or Google Gemini (`gemini-2.5-flash`), with automated code-validation and fallback.
+- ReportLab PDF, interactive HTML, Markdown, and 43 automated tests.
+- Tried on demo repo, pallets/click, and real full-stack project (CampusThrift).
+
+**Optional future work:** config file, multi-repo aggregator.

git2report-0.1.0/README.md

@@ -0,0 +1,111 @@
+# Git2Report
+
+Turn a Git repository's history into a plain-language weekly progress report, where **every number is
+counted by code** and **every line carries commit IDs as proof**. The AI (optional, local) only writes
+sentences.
+
+```
+git2report --repo . --since 7d --audience guide --out report.pdf
+```
+
+## Install
+
+```
+python -m venv .venv
+.venv\Scripts\activate          # Windows   (Linux/macOS: source .venv/bin/activate)
+pip install -e ".[dev]"          # core + pytest
+pip install -e ".[ollama]"       # only if you want AI sentences (also install Ollama from ollama.com)
+```
+
+## Use
+
+### 🖥️ Interactive Web Studio GUI
+Launch the browser-based dashboard to configure, run, preview, and download reports with 1 click:
+```
+git2report --ui               # Opens Web Studio at http://localhost:5000
+# or: git2report-ui
+```
+
+### 💻 Command Line (Terminal)
+```bash
+# 1. Standard full-format generation (PDF + HTML + Markdown)
+git2report --repo ./myproject --since 7d --all --out report.html
+
+# 2. Local AI with Ollama (Private, offline, zero API keys)
+git2report --repo ./myproject --llm ollama --model llama3:8b
+# Or shortcut:
+git2report --repo ./myproject --ollama --model mistral
+
+# 3. Cloud AI with Google Gemini (Fast, smart summary caching)
+git2report --repo ./myproject --llm gemini --model gemini-2.5-flash
+
+# 4. Pure offline deterministic mode (Zero AI, instant)
+git2report --repo ./myproject --llm offline --audience guide
+
+# 5. Targeted audience personas
+git2report --repo ./myproject --since 2w --audience client --both          # Business & user-facing
+git2report --repo ./myproject --since 2w --audience team --both            # Engineering release notes
+
+# 6. Sprint goals & caching
+git2report --repo . --next "Finish payment gateway" --next "Write tests"   # Authentic developer goals
+git2report --clear-cache                                                   # Reset summary cache
+```
+
+### AI Engines (`--llm`)
+- **`--llm ollama`**: Uses a local model running on your machine via [Ollama](https://ollama.com/) (e.g., `llama3:8b`, `llama3.2`, `mistral`, `deepseek-r1:8b`, `phi4`). Zero data leaves your machine. Automatically discovers available local models. If Ollama is offline or uninstalled, it gracefully falls back to deterministic offline wording without crashing.
+- **`--llm gemini`**: Uses Google Gemini (`gemini-2.5-flash`) with smart SHA-256 caching (`.git2report_cache.json`) for fast execution and zero duplicate token costs. Set `GEMINI_API_KEY` in your environment or `.env` file.
+- **`--llm offline`** (default): Builds clean human sentences directly from commit messages without invoking any AI.
+
+Every AI output is validated by code: if the model returns invalid JSON, mentions raw numbers, or mentions file paths, Git2Report automatically retries once and falls back safely.
+
+
+## Evaluation (manual vs tool vs baseline)
+
+```
+git2report-eval sheet --repo ./proj --since 45d --n 25 --out eval.csv    # builds the sheet
+# open eval.csv in Excel: write manual_summary, give 1-5 scores, count unsupported claims
+git2report-eval score eval.csv --out results.md                          # averages: tool vs baseline
+```
+The baseline is what you get without the pipeline: the raw commit message (offline) or the raw commit pasted
+to the AI (`--llm ollama`). Be honest in the project report about the sample size and whose repo it was.
+
+## Audiences (offline mode)
+
+`guide` = full list, `client` = only user-facing work (features, fixes, performance), `team` = release-notes
+grouped by type. A commit's type comes from `type(scope):` if present, otherwise it is guessed from its first
+word (Add = feature, Fix = fix, Remove = refactor...). It is a heuristic, so check it on your own repo.
+
+## How it works (7 steps, one file each)
+
+| Step | File | Output |
+|---|---|---|
+| 1 Extract | `extractor.py` | list of `CommitRecord` |
+| 2 Filter | `filtering.py` | kept commits + a reason for every decision |
+| 3 Cluster | `clustering.py` | `{module: [commits]}` (scope, then folder, then commit type) |
+| 4 Metrics | `metrics.py` | numbers (junk files excluded) |
+| 5 Chunk | `chunker.py` | short code text per module, within a token budget |
+| 6 Summarise | `summarizer.py` | one sentence per module (AI or offline), checked by code |
+| 7 Report | `report.py` | Markdown (Jinja2) and PDF (ReportLab) |
+
+Tunable rules (junk files, noise words, aliases, budget) live in `config.py`.
+
+## Develop
+
+```
+pytest -q                  # 38 tests, uses a throw-away real Git repo
+bash scripts/make_demo_repo.sh   # 10-commit demo repo in ./demo_repo
+```
+
+## Status
+
+Done and tested:
+- Steps 1-7 deterministic pipeline with verified commit hashes.
+- 🖥️ **Interactive Web Studio GUI** (`git2report --ui`) with real-time progress, live preview, and direct PDF/HTML/MD downloads.
+- ⚡ **Smart Summary Cache** (`.git2report_cache.json`) for instant sub-second re-runs and 0 API token waste.
+- 📊 **Visual Analytics & Charts** (Commit type distribution segmented bar & module churn chart embedded in PDF & HTML).
+- Offline summaries per audience, unmerged "in progress" branches, developer-written sprint goals.
+- 🦙 **Ollama Local AI & Google Gemini Cloud AI**: Choose between 100% private local models (`llama3:8b`, `mistral`, `deepseek-r1`) or Google Gemini (`gemini-2.5-flash`), with automated code-validation and fallback.
+- ReportLab PDF, interactive HTML, Markdown, and 43 automated tests.
+- Tried on demo repo, pallets/click, and real full-stack project (CampusThrift).
+
+**Optional future work:** config file, multi-repo aggregator.

git2report-0.1.0/git2report/__init__.py

@@ -0,0 +1,2 @@
+"""Git2Report: turn Git history into a plain-language, evidence-linked progress report."""
+__version__ = "0.1.0"

git2report-0.1.0/git2report/__main__.py

@@ -0,0 +1,4 @@
+from git2report.cli import app
+
+if __name__ == "__main__":
+    app()

git2report-0.1.0/git2report/branches.py

@@ -0,0 +1,34 @@
+"""Open branches = work that exists but is not merged yet. Used for the 'In progress' section."""
+from __future__ import annotations
+
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+from git2report.models import BranchInfo
+
+
+def _git(repo: Path, *args: str) -> str:
+    r = subprocess.run(["git", *args], cwd=repo, capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if r.returncode != 0:
+        raise RuntimeError(r.stderr.strip())
+    return r.stdout
+
+
+def open_branches(repo: Path, since: datetime, base: str = "HEAD") -> list[BranchInfo]:
+    """Branches not merged into `base` with activity since `since`. Never raises: returns [] on any problem."""
+    try:
+        fmt = "%(refname:short)|%(committerdate:short)|%(subject)"
+        out = _git(Path(repo), "for-each-ref", f"--no-merged={base}", f"--format={fmt}", "refs/heads", "refs/remotes")
+        found: dict[str, BranchInfo] = {}
+        for line in out.splitlines():
+            name, date, subject = line.split("|", 2)
+            short = name.split("/", 1)[1] if name.startswith("origin/") else name
+            if name == "origin" or short == "HEAD" or short in found or date < since.date().isoformat():
+                continue
+            ahead = int(_git(Path(repo), "rev-list", "--count", f"{base}..{name}").strip() or 0)
+            if ahead:
+                found[short] = BranchInfo(short, date, ahead, subject)
+        return sorted(found.values(), key=lambda b: b.last_date, reverse=True)
+    except Exception:
+        return []

git2report-0.1.0/git2report/cache.py

@@ -0,0 +1,78 @@
+"""Smart summary cache for Git2Report.
+
+Caches AI module summaries and executive summaries by commit hashes,
+preventing redundant LLM calls and enabling sub-second re-runs.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+from pathlib import Path
+from typing import Any
+
+logger = logging.getLogger("git2report.cache")
+DEFAULT_CACHE_FILE = Path(".git2report_cache.json")
+
+
+def compute_cache_key(prefix: str, module: str, commit_hashes: list[str], audience: str, model: str) -> str:
+    """Create a deterministic SHA-256 cache key based on inputs."""
+    sorted_hashes = sorted(commit_hashes)
+    payload = f"{prefix}::{module}::{','.join(sorted_hashes)}::{audience}::{model}"
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+
+class SummaryCache:
+    def __init__(self, cache_file: Path | str = DEFAULT_CACHE_FILE, enabled: bool = True):
+        self.cache_file = Path(cache_file)
+        self.enabled = enabled
+        self._data: dict[str, dict[str, Any]] = {}
+        self._load()
+
+    def _load(self) -> None:
+        if not self.enabled or not self.cache_file.exists():
+            return
+        try:
+            raw = self.cache_file.read_text(encoding="utf-8")
+            self._data = json.loads(raw)
+        except Exception as exc:
+            logger.debug(f"Failed to load cache: {exc}")
+            self._data = {}
+
+    def _save(self) -> None:
+        if not self.enabled:
+            return
+        try:
+            self.cache_file.write_text(json.dumps(self._data, indent=2), encoding="utf-8")
+        except Exception as exc:
+            logger.debug(f"Failed to save cache: {exc}")
+
+    def get(self, key: str) -> dict[str, Any] | None:
+        if not self.enabled:
+            return None
+        return self._data.get(key)
+
+    def set(self, key: str, summary: str, mode: str = "ai", meta: dict[str, Any] | None = None) -> None:
+        if not self.enabled:
+            return
+        entry = {
+            "summary": summary,
+            "mode": mode,
+            "meta": meta or {},
+        }
+        self._data[key] = entry
+        self._save()
+
+    def clear(self) -> int:
+        count = len(self._data)
+        self._data = {}
+        if self.cache_file.exists():
+            try:
+                self.cache_file.unlink()
+            except Exception:
+                pass
+        return count
+
+
+# Global default cache instance
+default_cache = SummaryCache()

git2report-0.1.0/git2report/charts.py

@@ -0,0 +1,155 @@
+"""Visual analytics and chart generators for Git2Report.
+
+Renders vector drawings for ReportLab PDF and embedded responsive SVG/HTML charts
+without requiring external heavy chart dependencies.
+"""
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from reportlab.lib import colors
+from reportlab.graphics.shapes import Drawing, Group, Line, Rect, String
+
+
+TYPE_COLORS = {
+    "feat": colors.HexColor("#059669"),      # Emerald Green
+    "fix": colors.HexColor("#DC2626"),       # Red
+    "perf": colors.HexColor("#7C3AED"),      # Purple
+    "refactor": colors.HexColor("#D97706"),  # Amber
+    "docs": colors.HexColor("#0284C7"),      # Cyan
+    "test": colors.HexColor("#0D9488"),      # Teal
+    "style": colors.HexColor("#64748B"),     # Slate
+    "chore": colors.HexColor("#94A3B8"),     # Light Slate
+    "other": colors.HexColor("#3B82F6"),     # Blue
+}
+
+
+def build_type_breakdown_bar(commits_by_type: dict[str, int], width: float = 490, height: float = 38) -> Drawing:
+    """Creates a sleek, segmented horizontal bar drawing showing commit type percentages."""
+    d = Drawing(width, height)
+    total = sum(commits_by_type.values())
+    if total <= 0:
+        return d
+
+    bar_y = 16
+    bar_h = 14
+    cur_x = 0.0
+
+    # Draw segments
+    for ctype, count in commits_by_type.items():
+        if count <= 0:
+            continue
+        seg_w = (count / total) * width
+        color = TYPE_COLORS.get(ctype.lower(), TYPE_COLORS["other"])
+        d.add(Rect(cur_x, bar_y, seg_w, bar_h, fillColor=color, strokeColor=colors.white, strokeWidth=1))
+        
+        # Label percentage inside segment if wide enough
+        if seg_w > 26:
+            pct_text = f"{int(round((count / total) * 100))}%"
+            d.add(String(cur_x + seg_w / 2, bar_y + 3.5, pct_text, textAnchor="middle",
+                         fontName="Helvetica-Bold", fontSize=7.5, fillColor=colors.white))
+        cur_x += seg_w
+
+    # Draw Legend below the bar
+    leg_x = 0.0
+    for ctype, count in list(commits_by_type.items())[:6]:
+        if count <= 0:
+            continue
+        color = TYPE_COLORS.get(ctype.lower(), TYPE_COLORS["other"])
+        # Dot
+        d.add(Rect(leg_x, 3, 7, 7, fillColor=color, strokeColor=color, rx=1.5, ry=1.5))
+        label = f"{ctype.upper()} ({count})"
+        d.add(String(leg_x + 10, 3, label, fontName="Helvetica", fontSize=7, fillColor=colors.HexColor("#475569")))
+        leg_x += len(label) * 4.4 + 16
+
+    return d
+
+
+def build_module_churn_chart(sections: list[Any], width: float = 490, height: float = 85) -> Drawing:
+    """Creates a horizontal vector bar chart showing code churn (+added / -deleted) per module."""
+    d = Drawing(width, height)
+    if not sections:
+        return d
+
+    # Collect up to 4 top modules by line changes
+    module_data = []
+    for s in sections[:4]:
+        added = sum(getattr(cm, "added", 0) for cm in getattr(s, "commits", []))
+        deleted = sum(getattr(cm, "deleted", 0) for cm in getattr(s, "commits", []))
+        module_data.append((s.module, added, deleted))
+
+    if not module_data:
+        return d
+
+    max_val = max(max(a, d_) for _, a, d_ in module_data) or 1
+    row_h = 16
+    start_y = height - 12
+    label_w = 90
+    bar_max_w = width - label_w - 45
+
+    green = colors.HexColor("#059669")
+    red = colors.HexColor("#DC2626")
+
+    for i, (mod, added, deleted) in enumerate(module_data):
+        y = start_y - (i * (row_h + 3))
+
+        # Module Name label
+        mod_name = mod[:14] + ".." if len(mod) > 16 else mod
+        d.add(String(0, y + 2, mod_name, fontName="Helvetica-Bold", fontSize=7.5, fillColor=colors.HexColor("#1E293B")))
+
+        # Added bar (Green)
+        w_add = max(2.0, (added / max_val) * (bar_max_w / 2)) if added > 0 else 0
+        if w_add > 0:
+            d.add(Rect(label_w, y, w_add, 7, fillColor=green, strokeColor=green, rx=1, ry=1))
+
+        # Deleted bar (Red)
+        w_del = max(2.0, (deleted / max_val) * (bar_max_w / 2)) if deleted > 0 else 0
+        if w_del > 0:
+            d.add(Rect(label_w + w_add + 4, y, w_del, 7, fillColor=red, strokeColor=red, rx=1, ry=1))
+
+        # Stat text
+        stat_text = f"+{added} / -{deleted}"
+        d.add(String(label_w + w_add + w_del + 10, y + 1, stat_text, fontName="Courier", fontSize=6.5, fillColor=colors.HexColor("#64748B")))
+
+    return d
+
+
+def generate_svg_churn_chart(sections: list[Any]) -> str:
+    """Generates an embedded responsive SVG for the interactive HTML report dashboard."""
+    module_data = []
+    for s in sections[:5]:
+        added = sum(getattr(cm, "added", 0) for cm in getattr(s, "commits", []))
+        deleted = sum(getattr(cm, "deleted", 0) for cm in getattr(s, "commits", []))
+        module_data.append((s.module, added, deleted))
+
+    if not module_data:
+        return ""
+
+    max_val = max(max(a, d_) for _, a, d_ in module_data) or 1
+    svg_height = len(module_data) * 36 + 20
+    rows = []
+
+    for i, (mod, added, deleted) in enumerate(module_data):
+        y = 20 + i * 36
+        w_add = (added / max_val) * 220 if added > 0 else 0
+        w_del = (deleted / max_val) * 220 if deleted > 0 else 0
+
+        rows.append(f"""
+          <g class="chart-row">
+            <text x="0" y="{y + 14}" fill="currentColor" font-size="12" font-weight="600">{mod}</text>
+            <rect x="130" y="{y}" width="{w_add:.1f}" height="16" rx="3" fill="#10b981" opacity="0.9">
+              <title>Added: +{added} lines</title>
+            </rect>
+            <rect x="{135 + w_add:.1f}" y="{y}" width="{w_del:.1f}" height="16" rx="3" fill="#ef4444" opacity="0.9">
+              <title>Deleted: -{deleted} lines</title>
+            </rect>
+            <text x="{145 + w_add + w_del:.1f}" y="{y + 13}" fill="var(--text-muted)" font-size="11" font-family="monospace">+{added} / -{deleted}</text>
+          </g>
+        """)
+
+    return f"""
+    <svg viewBox="0 0 650 {svg_height}" width="100%" height="{svg_height}" xmlns="http://www.w3.org/2000/svg" style="overflow: visible;">
+      {''.join(rows)}
+    </svg>
+    """

git2report-0.1.0/git2report/chunker.py

@@ -0,0 +1,47 @@
+"""STEP 5: shrink a module's code changes to fit the AI's limit.
+Drop junk files, rank files (source before tests, big before small), split into hunks,
+keep only the added/removed lines, and stop when the token budget is full."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from git2report.config import Config
+from git2report.models import CommitRecord
+from git2report.rules import is_junk, is_test, tokens
+
+
+@dataclass
+class Chunk:
+    text: str
+    raw_tokens: int
+    used_tokens: int
+    hunks_dropped: int
+
+
+def chunk_module(commits: list[CommitRecord], cfg: Config, budget: int | None = None) -> Chunk:
+    budget = cfg.token_budget if budget is None else budget
+    all_files = [f for c in commits for f in c.files]
+    raw = sum(tokens(f.diff) for f in all_files)
+    files = [f for f in all_files if not is_junk(f.path, cfg.junk) and f.diff.strip()]
+    files.sort(key=lambda f: (is_test(f.path), -(f.added + f.deleted)))
+    parts: list[str] = []
+    used = dropped = 0
+    for f in files:
+        for hunk in re.split(r"(?m)^(?=@@)", f.diff):
+            if not hunk.strip():
+                continue
+            body = "\n".join(
+                line for line in hunk.splitlines()
+                if line[:1] in ("+", "-") and not line.startswith(("+++", "---"))
+            )
+            if not body.strip():
+                continue
+            piece = f"# {f.path}\n{body}"
+            cost = tokens(piece)
+            if used + cost <= budget:
+                parts.append(piece)
+                used += cost
+            else:
+                dropped += 1
+    return Chunk("\n".join(parts), raw, used, dropped)