gitpulse-tui 1.2.0__tar.gz → 1.2.1__tar.gz

{gitpulse_tui-1.2.0/gitpulse_tui.egg-info → gitpulse_tui-1.2.1}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: gitpulse-tui
-Version: 1.2.0
+Version: 1.2.1
 Summary: Git Repo Dashboard TUI — live status, commits, diffs, and branches in your terminal
 Requires-Python: >=3.10
 License-File: LICENSE
 Requires-Dist: textual>=0.50.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: gitpython>=3.1.0
+Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Dynamic: license-file

gitpulse_tui-1.2.1/gitpulse/config.py

@@ -0,0 +1,169 @@
+"""
+config.py — TOML configuration loader for GitPulse.
+
+Reads ~/.config/gitpulse/config.toml (or a path supplied via --config).
+Uses tomllib (stdlib, Python 3.11+) or tomli (backport, 3.10).
+Missing file → silent fallback to built-in defaults.
+CLI flags always take precedence over config values.
+"""
+
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# tomllib is stdlib on 3.11+; tomli is the backport for 3.10
+if sys.version_info >= (3, 11):
+    import tomllib
+else:
+    try:
+        import tomli as tomllib  # type: ignore[no-redef]
+    except ImportError:
+        tomllib = None  # type: ignore[assignment]
+
+DEFAULT_CONFIG_PATH = Path("~/.config/gitpulse/config.toml")
+EXAMPLE_CONFIG_PATH = Path("~/.config/gitpulse/config.toml.example")
+
+_EXAMPLE_CONTENT = """\
+# GitPulse configuration — copy to config.toml and edit as needed.
+
+[scan]
+# roots = ["~/projects", "~/work"]   # override --root; list of directories to scan
+
+[author]
+# emails = ["you@example.com"]       # used by digest mode; defaults to git config user.email
+
+[watch]
+enabled = true
+interval_seconds = 5
+
+[stale]
+weeks = 8
+default_branches = ["main", "master", "develop", "trunk"]
+
+[bulk]
+max_workers = 8
+
+[digest]
+default_window = "1d"
+"""
+
+
+@dataclass
+class ScanConfig:
+    roots: list[str] = field(default_factory=list)
+
+
+@dataclass
+class AuthorConfig:
+    emails: list[str] = field(default_factory=list)
+
+
+@dataclass
+class WatchConfig:
+    enabled: bool = True
+    interval_seconds: int = 5
+
+
+@dataclass
+class StaleConfig:
+    weeks: int = 8
+    default_branches: list[str] = field(
+        default_factory=lambda: ["main", "master", "develop", "trunk"]
+    )
+
+
+@dataclass
+class BulkConfig:
+    max_workers: int = 8
+
+
+@dataclass
+class DigestConfig:
+    default_window: str = "1d"
+
+
+@dataclass
+class GitPulseConfig:
+    scan: ScanConfig = field(default_factory=ScanConfig)
+    author: AuthorConfig = field(default_factory=AuthorConfig)
+    watch: WatchConfig = field(default_factory=WatchConfig)
+    stale: StaleConfig = field(default_factory=StaleConfig)
+    bulk: BulkConfig = field(default_factory=BulkConfig)
+    digest: DigestConfig = field(default_factory=DigestConfig)
+
+
+def _write_example_if_missing() -> None:
+    example = EXAMPLE_CONFIG_PATH.expanduser()
+    if not example.exists():
+        try:
+            example.parent.mkdir(parents=True, exist_ok=True)
+            example.write_text(_EXAMPLE_CONTENT)
+        except Exception:
+            pass
+
+
+def load(path: Path | None = None) -> GitPulseConfig:
+    """Load and return the GitPulse configuration.
+
+    Falls back to defaults silently if the file is absent or tomli is
+    unavailable. Writes a .example file on first run.
+    """
+    cfg = GitPulseConfig()
+    _write_example_if_missing()
+
+    config_path = (path or DEFAULT_CONFIG_PATH).expanduser()
+    if not config_path.exists():
+        return cfg
+
+    if tomllib is None:
+        # Python 3.10 without tomli installed — use defaults
+        return cfg
+
+    try:
+        with open(config_path, "rb") as fh:
+            raw = tomllib.load(fh)
+    except Exception:
+        return cfg
+
+    if "scan" in raw:
+        s = raw["scan"]
+        cfg.scan.roots = s.get("roots", [])
+
+    if "author" in raw:
+        a = raw["author"]
+        cfg.author.emails = a.get("emails", [])
+
+    if "watch" in raw:
+        w = raw["watch"]
+        cfg.watch.enabled = bool(w.get("enabled", True))
+        cfg.watch.interval_seconds = int(w.get("interval_seconds", 5))
+
+    if "stale" in raw:
+        st = raw["stale"]
+        cfg.stale.weeks = int(st.get("weeks", 8))
+        cfg.stale.default_branches = list(
+            st.get("default_branches", ["main", "master", "develop", "trunk"])
+        )
+
+    if "bulk" in raw:
+        cfg.bulk.max_workers = int(raw["bulk"].get("max_workers", 8))
+
+    if "digest" in raw:
+        cfg.digest.default_window = str(raw["digest"].get("default_window", "1d"))
+
+    return cfg
+
+
+# Module-level singleton — loaded once, reused everywhere.
+# Call load() explicitly if you need a custom path.
+_default: GitPulseConfig | None = None
+
+
+def get() -> GitPulseConfig:
+    """Return the cached default config (loaded once on first call)."""
+    global _default
+    if _default is None:
+        _default = load()
+    return _default

gitpulse_tui-1.2.1/gitpulse/digest.py

@@ -0,0 +1,165 @@
+"""
+digest.py — Activity digest aggregation for GitPulse.
+
+Collects commits authored by a set of email patterns across all scanned repos
+within a time window, groups them by repo, and produces a Digest object.
+Renders as markdown for stdout/clipboard use.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    from gitpulse.git_ops import RepoInfo, AuthorCommit, get_author_commits, get_author_email
+    from gitpulse.parallel import run_parallel
+    from gitpulse.utils import relative_time
+except ImportError:
+    from git_ops import RepoInfo, AuthorCommit, get_author_commits, get_author_email  # type: ignore
+    from parallel import run_parallel  # type: ignore
+    from utils import relative_time  # type: ignore
+
+
+@dataclass
+class RepoDigest:
+    repo: RepoInfo
+    commits: list[AuthorCommit]
+
+    @property
+    def insertions(self) -> int:
+        return sum(c.insertions for c in self.commits)
+
+    @property
+    def deletions(self) -> int:
+        return sum(c.deletions for c in self.commits)
+
+    @property
+    def files_changed(self) -> int:
+        return sum(c.files_changed for c in self.commits)
+
+
+@dataclass
+class Digest:
+    since_ts: float
+    until_ts: float
+    author_patterns: list[str]
+    by_repo: list[RepoDigest] = field(default_factory=list)
+
+    @property
+    def total_commits(self) -> int:
+        return sum(len(rd.commits) for rd in self.by_repo)
+
+    @property
+    def total_insertions(self) -> int:
+        return sum(rd.insertions for rd in self.by_repo)
+
+    @property
+    def total_deletions(self) -> int:
+        return sum(rd.deletions for rd in self.by_repo)
+
+    @property
+    def repos_active(self) -> int:
+        return len(self.by_repo)
+
+
+def _collect_for_repo(
+    args: tuple[RepoInfo, float, list[str]],
+) -> RepoDigest | None:
+    """Worker target: fetch commits for one repo. Returns None if no commits."""
+    repo, since_ts, author_patterns = args
+    all_commits: list[AuthorCommit] = []
+    for pattern in author_patterns:
+        commits = get_author_commits(repo.path, since_ts, pattern)
+        all_commits.extend(commits)
+
+    if not all_commits:
+        return None
+
+    # De-duplicate by hash in case multiple patterns matched same commit
+    seen: set[str] = set()
+    unique: list[AuthorCommit] = []
+    for c in all_commits:
+        if c.short_hash not in seen:
+            seen.add(c.short_hash)
+            unique.append(c)
+
+    unique.sort(key=lambda c: c.ts, reverse=True)
+    return RepoDigest(repo=repo, commits=unique)
+
+
+def _resolve_author_patterns(
+    repos: list[RepoInfo],
+    explicit_patterns: list[str],
+) -> list[str]:
+    """If no explicit patterns given, try to read user.email from the first N repos."""
+    if explicit_patterns:
+        return explicit_patterns
+    emails: set[str] = set()
+    for repo in repos[:5]:
+        email = get_author_email(repo.path)
+        if email:
+            emails.add(email)
+    return list(emails) if emails else []
+
+
+def build_digest(
+    repos: list[RepoInfo],
+    since_ts: float,
+    author_patterns: list[str] | None = None,
+    max_workers: int = 8,
+) -> Digest:
+    """Build a Digest aggregating all matching commits across *repos*."""
+    patterns = _resolve_author_patterns(repos, author_patterns or [])
+    until_ts = time.time()
+
+    if not patterns:
+        return Digest(since_ts=since_ts, until_ts=until_ts, author_patterns=[])
+
+    args_list = [(repo, since_ts, patterns) for repo in repos]
+    results = run_parallel(_collect_for_repo, args_list, max_workers=max_workers)
+
+    by_repo = [
+        result
+        for _, result in results
+        if result is not None and not isinstance(result, Exception)
+    ]
+    by_repo.sort(key=lambda rd: len(rd.commits), reverse=True)
+
+    return Digest(
+        since_ts=since_ts,
+        until_ts=until_ts,
+        author_patterns=patterns,
+        by_repo=by_repo,
+    )
+
+
+def render_markdown(d: Digest) -> str:
+    """Render a Digest as a markdown standup summary."""
+    from datetime import datetime, timezone
+
+    lines: list[str] = []
+    since_str = datetime.fromtimestamp(d.since_ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    until_str = datetime.fromtimestamp(d.until_ts, tz=timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
+    authors_str = ", ".join(d.author_patterns) if d.author_patterns else "all authors"
+
+    lines.append(f"# Activity digest — {since_str} → {until_str}")
+    lines.append(f"**Author(s):** {authors_str}  ")
+    lines.append(
+        f"**Summary:** {d.total_commits} commit{'s' if d.total_commits != 1 else ''} "
+        f"across {d.repos_active} repo{'s' if d.repos_active != 1 else ''} "
+        f"· +{d.total_insertions} -{d.total_deletions} lines"
+    )
+    lines.append("")
+
+    for rd in d.by_repo:
+        lines.append(f"## {rd.repo.name} ({len(rd.commits)} commits · +{rd.insertions} -{rd.deletions})")
+        for c in rd.commits:
+            rel = relative_time(c.ts)
+            stats = f"+{c.insertions}/-{c.deletions}" if c.insertions or c.deletions else ""
+            stats_str = f" `{stats}`" if stats else ""
+            lines.append(f"- `{c.short_hash}` {c.message}{stats_str} _{rel}_")
+        lines.append("")
+
+    return "\n".join(lines)

{gitpulse_tui-1.2.0 → gitpulse_tui-1.2.1}/gitpulse/git_ops.py

@@ -9,6 +9,7 @@ branches. Uses GitPython for interfacing with local git repositories.
 from __future__ import annotations
 
 import enum
+import re
 import time
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -46,6 +47,10 @@ class RepoInfo:
     total_commits: int = 0              # Total commit count on current branch
     contributor_count: int = 0          # Unique author count
     commit_activity: list[int] = field(default_factory=list)  # Commits per week, 7 weeks oldest→newest
+    ahead: int = 0                       # Commits ahead of upstream
+    behind: int = 0                      # Commits behind upstream
+    stash_count: int = 0                 # Number of stash entries
+    has_stale_branches: bool = False     # True if any branch is older than stale threshold
 
 
 @dataclass
@@ -68,6 +73,17 @@ class CommitInfo:
     deletions: int = 0
 
 
+@dataclass
+class AuthorCommit:
+    """A single commit attributed to a specific author, used by digest mode."""
+    short_hash: str
+    ts: float
+    message: str
+    insertions: int = 0
+    deletions: int = 0
+    files_changed: int = 0
+
+
 @dataclass
 class BranchInfo:
     """Information about a local branch."""
@@ -75,6 +91,21 @@ class BranchInfo:
     is_current: bool
 
 
+@dataclass
+class BranchDetail:
+    """Rich branch information used by stale-branch analysis."""
+    repo_path: Path
+    repo_name: str
+    name: str
+    last_commit_ts: float
+    last_commit_msg: str
+    is_current: bool
+    has_upstream: bool
+    is_merged_into_default: bool
+    is_wip: bool         # subject matches ^(wip|fixup!|squash!|tmp)\b
+    age_days: int
+
+
 @dataclass
 class StashEntry:
     """A single stash entry."""
@@ -184,6 +215,48 @@ def get_repo_info(path: Path) -> RepoInfo:
         except Exception:
             pass
 
+        # Ahead/behind relative to upstream (skip for detached HEAD)
+        ahead = 0
+        behind = 0
+        try:
+            if branch != "(detached)":
+                _br = repo.active_branch
+                tracking = _br.tracking_branch()
+                if tracking:
+                    ahead = len(list(repo.iter_commits(f"{tracking.name}..{_br.name}")))
+                    behind = len(list(repo.iter_commits(f"{_br.name}..{tracking.name}")))
+        except Exception:
+            pass
+
+        # Stash count
+        stash_count = 0
+        try:
+            sl = repo.git.stash("list")
+            stash_count = len(sl.strip().splitlines()) if sl.strip() else 0
+        except Exception:
+            pass
+
+        # Stale-branch quick check (any local branch older than 8 weeks, not current)
+        has_stale = False
+        try:
+            _stale_cutoff = time.time() - (8 * 7 * 86400)
+            ref_out = repo.git.for_each_ref(
+                "refs/heads/",
+                format="%(refname:short) %(committerdate:unix)",
+            )
+            for _line in ref_out.strip().splitlines():
+                _parts = _line.rsplit(" ", 1)
+                if len(_parts) == 2:
+                    _bname, _ts_str = _parts
+                    try:
+                        if float(_ts_str) < _stale_cutoff and _bname != branch:
+                            has_stale = True
+                            break
+                    except ValueError:
+                        pass
+        except Exception:
+            pass
+
     except (InvalidGitRepositoryError, Exception):
         branch = "unknown"
         status = RepoStatus.CLEAN
@@ -193,6 +266,10 @@ def get_repo_info(path: Path) -> RepoInfo:
         total = 0
         contributor_count = 0
         activity = []
+        ahead = 0
+        behind = 0
+        stash_count = 0
+        has_stale = False
 
     return RepoInfo(
         name=path.name,
@@ -205,6 +282,10 @@ def get_repo_info(path: Path) -> RepoInfo:
         total_commits=total,
         contributor_count=contributor_count,
         commit_activity=activity,
+        ahead=ahead,
+        behind=behind,
+        stash_count=stash_count,
+        has_stale_branches=has_stale,
     )
 
 
@@ -709,6 +790,36 @@ def git_push(path: Path) -> str:
         return f"Error pushing: {exc}"
 
 
+def git_gc(path: Path) -> str:
+    """Run git gc --auto to prune loose objects."""
+    repo = _open_repo(path)
+    try:
+        repo.git.gc("--auto")
+        return "gc --auto completed ✓"
+    except Exception as exc:
+        return f"Error running gc: {exc}"
+
+
+def git_remote_prune(path: Path) -> str:
+    """Run git remote prune origin to remove stale remote-tracking refs."""
+    repo = _open_repo(path)
+    try:
+        result = repo.git.remote("prune", "origin")
+        return result.strip() if result.strip() else "remote prune origin completed ✓"
+    except Exception as exc:
+        return f"Error pruning: {exc}"
+
+
+def git_clean_dry(path: Path) -> str:
+    """Run git clean -nd (dry run) and return untracked file list."""
+    repo = _open_repo(path)
+    try:
+        result = repo.git.clean("-nd")
+        return result.strip() if result.strip() else "Nothing to clean ✓"
+    except Exception as exc:
+        return f"Error running clean: {exc}"
+
+
 # ===================================================================
 # Stash operations
 # ===================================================================
@@ -790,3 +901,160 @@ def get_tracked_files(path: Path) -> list[str]:
         return sorted(p for p in ls_output.splitlines() if p.strip())
     except Exception:
         return []
+
+
+# ===================================================================
+# Author / Digest operations
+# ===================================================================
+
+def default_branch_for(repo, candidates: list[str] | None = None) -> str | None:
+    """Return the first candidate branch that exists locally, else None."""
+    _candidates = candidates or ["main", "master", "develop", "trunk"]
+    local_names = {b.name for b in repo.branches}
+    for name in _candidates:
+        if name in local_names:
+            return name
+    return None
+
+
+def get_branch_details(
+    path: Path,
+    default_branches: list[str] | None = None,
+) -> list[BranchDetail]:
+    """Return rich details for every local branch in the repo."""
+    import time as _time
+    repo = _open_repo(path)
+    details: list[BranchDetail] = []
+
+    try:
+        current = repo.active_branch.name if not repo.head.is_detached else None
+    except Exception:
+        current = None
+
+    default = default_branch_for(repo, default_branches)
+
+    # Collect merged branches (names only)
+    merged: set[str] = set()
+    if default:
+        try:
+            merged_out = repo.git.branch("--merged", default)
+            for line in merged_out.splitlines():
+                merged.add(line.strip().lstrip("* "))
+        except Exception:
+            pass
+
+    _wip_re = re.compile(r"^(wip|fixup!|squash!|tmp)\b", re.IGNORECASE)
+    now = _time.time()
+
+    try:
+        raw = repo.git.for_each_ref(
+            "refs/heads/",
+            format="%(refname:short)%00%(committerdate:unix)%00%(contents:subject)%00%(upstream:short)%00%(HEAD)",
+        )
+    except Exception:
+        return details
+
+    for line in raw.strip().splitlines():
+        parts = line.split("\x00")
+        if len(parts) < 5:
+            continue
+        bname, ts_str, subject, upstream, head_marker = parts[0], parts[1], parts[2], parts[3], parts[4]
+
+        try:
+            ts = float(ts_str)
+        except ValueError:
+            ts = 0.0
+
+        age_days = int((now - ts) / 86400) if ts else 0
+
+        details.append(BranchDetail(
+            repo_path=path,
+            repo_name=path.name,
+            name=bname,
+            last_commit_ts=ts,
+            last_commit_msg=subject.strip()[:80],
+            is_current=(head_marker.strip() == "*" or bname == current),
+            has_upstream=bool(upstream.strip()),
+            is_merged_into_default=(bname in merged),
+            is_wip=bool(_wip_re.match(subject.strip())),
+            age_days=age_days,
+        ))
+
+    return details
+
+
+def get_author_email(path: Path) -> str:
+    """Return the configured git user.email for this repo, or empty string."""
+    repo = _open_repo(path)
+    try:
+        return repo.git.config("user.email").strip()
+    except Exception:
+        return ""
+
+
+def get_author_commits(
+    path: Path,
+    since_ts: float,
+    author_pattern: str,
+) -> list[AuthorCommit]:
+    """Return commits by *author_pattern* in *path* since *since_ts*.
+
+    Uses ``--all`` so commits on any branch are credited. Parses shortstat
+    blocks to extract insertions/deletions without iterating commit objects.
+    """
+    repo = _open_repo(path)
+    commits: list[AuthorCommit] = []
+    try:
+        # Request log with NUL-separated records: hash\x1fts\x1fsubject
+        # then a blank line and the shortstat
+        raw = repo.git.log(
+            "--all",
+            "--no-merges",
+            f"--since=@{int(since_ts)}",
+            f"--author={author_pattern}",
+            "--pretty=format:\x1e%H\x1f%ct\x1f%s",
+            "--shortstat",
+        )
+        if not raw.strip():
+            return []
+
+        # Split on the record separator \x1e (prepended to each commit header)
+        records = [r for r in raw.split("\x1e") if r.strip()]
+        for record in records:
+            lines = record.strip().splitlines()
+            if not lines:
+                continue
+            header_line = lines[0]
+            parts = header_line.split("\x1f", 2)
+            if len(parts) < 3:
+                continue
+            full_hash, ts_str, subject = parts[0].strip(), parts[1], parts[2]
+            try:
+                ts = float(ts_str)
+            except ValueError:
+                continue
+
+            insertions = 0
+            deletions = 0
+            files_changed = 0
+            # shortstat line looks like: "3 files changed, 42 insertions(+), 5 deletions(-)"
+            stat_lines = [l for l in lines[1:] if "changed" in l or "insertion" in l or "deletion" in l]
+            for stat in stat_lines:
+                m_files = re.search(r"(\d+) file", stat)
+                m_ins   = re.search(r"(\d+) insertion", stat)
+                m_del   = re.search(r"(\d+) deletion", stat)
+                if m_files: files_changed = int(m_files.group(1))
+                if m_ins:   insertions    = int(m_ins.group(1))
+                if m_del:   deletions     = int(m_del.group(1))
+
+            commits.append(AuthorCommit(
+                short_hash=full_hash[:7],
+                ts=ts,
+                message=subject.strip(),
+                insertions=insertions,
+                deletions=deletions,
+                files_changed=files_changed,
+            ))
+    except Exception:
+        pass
+    return commits