git2report 0.1.0__py3-none-any.whl

git2report/__init__.py

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

git2report/__main__.py

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

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/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/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/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)

git2report/cli.py

@@ -0,0 +1,173 @@
+"""Command line: git2report --repo . --since 7d --audience guide --out report.pdf"""
+from __future__ import annotations
+
+import sys
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from git2report import __version__
+from git2report.models import GitReportError
+from git2report.pipeline import Options, run_pipeline
+from git2report.report import render_html, render_markdown, render_pdf
+from git2report.summarizer import get_summarizer
+from git2report.timeutil import parse_since
+
+
+def _preprocess_argv(argv: list[str]) -> list[str]:
+    result = []
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
+        if arg == "--ai":
+            result.extend(["--llm", "gemini"])
+            i += 1
+            continue
+        if arg == "--ollama":
+            result.extend(["--llm", "ollama"])
+            i += 1
+            continue
+        if arg == "--llm":
+            if i + 1 < len(argv) and not argv[i + 1].startswith("-") and argv[i + 1].lower() in ("gemini", "ollama", "offline"):
+                result.extend(["--llm", argv[i + 1].lower()])
+                i += 2
+                continue
+            # When --llm is passed alone, default to gemini
+            result.extend(["--llm", "gemini"])
+            i += 1
+            continue
+        result.append(arg)
+        i += 1
+    return result
+
+
+if len(sys.argv) > 1:
+    sys.argv = [sys.argv[0]] + _preprocess_argv(sys.argv[1:])
+
+
+class AppWrapper(typer.Typer):
+    def __call__(self, *args, **kwargs):
+        if not args and not kwargs and len(sys.argv) > 1:
+            sys.argv = [sys.argv[0]] + _preprocess_argv(sys.argv[1:])
+        return super().__call__(*args, **kwargs)
+
+
+app = AppWrapper(add_completion=False, help="Turn Git history into a plain-language, evidence-linked progress report.")
+
+
+class Audience(str, Enum):
+    guide = "guide"
+    client = "client"
+    team = "team"
+
+
+class Llm(str, Enum):
+    offline = "offline"
+    gemini = "gemini"
+    ollama = "ollama"
+
+
+def _version(value: bool):
+    if value:
+        typer.echo(f"git2report {__version__}")
+        raise typer.Exit()
+
+
+@app.command()
+def main(
+    repo: str = typer.Option(".", "--repo", "-r", help="Path to the Git repository or remote Git URL."),
+    since: str = typer.Option("7d", "--since", "-s", help="How far back: 7d, 2w, 12h or a date like 2026-10-01."),
+    audience: Audience = typer.Option(Audience.guide, "--audience", "-a", help="Who will read the report."),
+    llm: Llm = typer.Option(Llm.offline, "--llm", help="'offline' uses commit messages; 'gemini' uses Google Gemini; 'ollama' uses local Ollama."),
+    model: str = typer.Option("", "--model", help="AI model name (default: gemini-2.5-flash for gemini, llama3:8b for ollama)."),
+    api_key: Optional[str] = typer.Option(None, "--api-key", envvar="GEMINI_API_KEY", help="API key for Gemini (or set GEMINI_API_KEY env var)."),
+    out: Path = typer.Option(Path("report.pdf"), "--out", "-o", help="Output file: .pdf, .md, or .html"),
+    both: bool = typer.Option(False, "--both", help="Write both the PDF and the Markdown file."),
+    html: bool = typer.Option(False, "--html", help="Write an interactive HTML report dashboard."),
+    all_formats: bool = typer.Option(False, "--all", help="Write PDF, Markdown, and HTML reports."),
+    planned: list[str] = typer.Option([], "--next", "-n", help="A planned goal for next period (repeat the option for several)."),
+    branches: bool = typer.Option(True, "--branches/--no-branches", help="List unmerged branches as 'in progress'."),
+    artifacts: Optional[Path] = typer.Option(None, "--artifacts", help="Folder to save every step's result (JSON/text)."),
+    ui: bool = typer.Option(False, "--ui", help="Launch the interactive Web Studio GUI in your browser."),
+    port: int = typer.Option(5000, "--port", help="Port to run the Web Studio GUI on."),
+    no_cache: bool = typer.Option(False, "--no-cache", help="Disable the smart summary cache."),
+    clear_cache: bool = typer.Option(False, "--clear-cache", help="Clear the smart summary cache."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Hide progress messages."),
+    version: bool = typer.Option(False, "--version", callback=_version, is_eager=True, help="Show version."),
+):
+    if clear_cache:
+        from git2report.cache import default_cache
+        count = default_cache.clear()
+        typer.echo(f"Cleared {count} entries from smart summary cache.")
+        raise typer.Exit()
+
+    if ui:
+        from git2report.web import launch_web_server
+        launch_web_server(port=port)
+        raise typer.Exit()
+
+    if no_cache:
+        from git2report.cache import default_cache
+        default_cache.enabled = False
+
+    log = (lambda _m: None) if quiet else (lambda m: typer.echo(m, err=True))
+    try:
+        raw_repo = str(repo).strip().replace("\\", "/")
+        if raw_repo.startswith("https:/") and not raw_repo.startswith("https://"):
+            raw_repo = "https://" + raw_repo[len("https:/"):]
+        elif raw_repo.startswith("http:/") and not raw_repo.startswith("http://"):
+            raw_repo = "http://" + raw_repo[len("http:/"):]
+
+        if raw_repo.startswith(("http://", "https://", "git@")):
+            repo_name = raw_repo.rstrip("/").split("/")[-1]
+            if repo_name.endswith(".git"):
+                repo_name = repo_name[:-4]
+            local_dir = Path("cloned_repos") / repo_name
+            local_dir.parent.mkdir(parents=True, exist_ok=True)
+            if not (local_dir / ".git").exists():
+                log(f"Cloning remote repository {raw_repo} into {local_dir}...")
+                import subprocess
+                r = subprocess.run(["git", "clone", raw_repo, str(local_dir)], capture_output=True, text=True)
+                if r.returncode != 0:
+                    raise GitReportError(f"Failed to clone repository: {r.stderr.strip()}")
+            repo_path = local_dir
+        else:
+            repo_path = Path(repo)
+
+        chosen_model = model or ("gemini-2.5-flash" if llm == Llm.gemini else ("llama3:8b" if llm == Llm.ollama else ""))
+        opts = Options(repo=repo_path, since=parse_since(since), audience=audience.value, artifacts=artifacts,
+                       planned=planned, include_branches=branches)
+        data = run_pipeline(opts, get_summarizer(llm.value, chosen_model, api_key=api_key), log=log)
+        written = []
+        out.parent.mkdir(parents=True, exist_ok=True)
+        is_html = out.suffix.lower() == ".html"
+        is_md = out.suffix.lower() == ".md"
+        is_pdf = out.suffix.lower() == ".pdf" or (not is_html and not is_md)
+
+        if all_formats or both or is_md:
+            md_path = out.with_suffix(".md")
+            md_path.write_text(render_markdown(data), encoding="utf-8")
+            written.append(md_path)
+
+        if all_formats or html or is_html:
+            html_path = out.with_suffix(".html")
+            html_path.write_text(render_html(data), encoding="utf-8")
+            written.append(html_path)
+
+        if all_formats or both or is_pdf:
+            pdf_path = out if out.suffix.lower() == ".pdf" else out.with_suffix(".pdf")
+            render_pdf(data, pdf_path)
+            written.append(pdf_path)
+    except GitReportError as exc:
+        typer.secho(f"Error: {exc}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(code=1)
+    for p in written:
+        typer.echo(f"Wrote {p}")
+    if llm == Llm.offline:
+        typer.echo("Note: offline mode used (no AI). Add --llm gemini for AI-written plain-language sentences.", err=True)
+
+
+if __name__ == "__main__":
+    app()

git2report/clustering.py

@@ -0,0 +1,56 @@
+"""STEP 3: group commits by module using three rules, in this order:
+1. the scope in the message, e.g. feat(auth): ...
+2. the folder with the most changed lines
+3. the commit type, e.g. docs: ...
+Every commit also records WHY it landed in its module, so each decision can be explained."""
+from __future__ import annotations
+
+from git2report.config import Config
+from git2report.models import CommitRecord
+from git2report.rules import is_junk, is_test, parse_conventional
+
+
+def _pretty(name: str, cfg: Config) -> str:
+    key = name.strip().lower()
+    if key in cfg.aliases:
+        return cfg.aliases[key]
+    return name.replace("-", " ").replace("_", " ").strip().title()
+
+
+def _top_folder(commit: CommitRecord, cfg: Config) -> str | None:
+    """Folder with the most changed lines. Test files are ignored unless the commit touched nothing else,
+    otherwise a commit that changes source AND tests would be filed under 'Tests'."""
+    def totals(include_tests: bool) -> dict[str, int]:
+        out: dict[str, int] = {}
+        for f in commit.files:
+            if is_junk(f.path, cfg.junk) or (is_test(f.path) and not include_tests):
+                continue
+            parts = f.path.replace("\\", "/").split("/")[:-1]          # folders only
+            parts = [p for p in parts if p.lower() not in cfg.generic_folders]
+            if parts:
+                out[parts[0]] = out.get(parts[0], 0) + f.added + f.deleted
+        return out
+
+    t = totals(False) or totals(True)
+    return max(t, key=t.get) if t else None
+
+
+def module_of(commit: CommitRecord, cfg: Config) -> tuple[str, str]:
+    ctype, scope, _ = parse_conventional(commit.subject)
+    if scope:
+        return _pretty(scope, cfg), "scope in message"
+    folder = _top_folder(commit, cfg)
+    if folder:
+        return _pretty(folder, cfg), "top folder by lines"
+    if ctype and ctype in cfg.type_modules:
+        return cfg.type_modules[ctype], "commit type"
+    return "Other", "fallback"
+
+
+def cluster(commits: list[CommitRecord], cfg: Config) -> dict[str, list[CommitRecord]]:
+    groups: dict[str, list[CommitRecord]] = {}
+    for c in commits:
+        c.module, c.module_reason = module_of(c, cfg)
+        groups.setdefault(c.module, []).append(c)
+    # Biggest modules first; ties by name so the output is stable.
+    return dict(sorted(groups.items(), key=lambda kv: (-len(kv[1]), kv[0])))

git2report/config.py

@@ -0,0 +1,28 @@
+"""Tunable rules in one place. Change these instead of hunting through the code."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Config:
+    # Files that are generated by tools and say nothing about the developer's effort.
+    junk: tuple[str, ...] = (
+        "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "poetry.lock", "Pipfile.lock",
+        ".min.js", ".min.css", "dist/", "build/", "node_modules/",
+    )
+    # Commits whose subject has one of these words are noise, unless they changed a lot.
+    noise_words: tuple[str, ...] = ("wip", "typo", "typos", "formatting", "whitespace")
+    keep_if_lines: int = 30          # a noisy commit with >= this many changed lines is kept
+    token_budget: int = 1500         # max tokens of code sent to the AI per module
+    # Readable module names for common commit scopes / folders.
+    aliases: dict[str, str] = field(default_factory=lambda: {
+        "ui": "UI", "db": "Database", "auth": "Authentication", "jobs": "Job Search",
+        "api": "API", "ci": "CI/CD", "docs": "Documentation", "deps": "Dependencies",
+    })
+    # Used when a commit has no scope and no useful folder: map the commit TYPE to a module.
+    type_modules: dict[str, str] = field(default_factory=lambda: {
+        "docs": "Documentation", "ci": "CI/CD", "build": "Build", "test": "Testing", "chore": "Maintenance",
+    })
+    # Folders that carry no meaning as a module name.
+    generic_folders: tuple[str, ...] = ("src", "lib", "app", "source", "packages")