git-juggler 0.1.2__tar.gz → 0.1.3__tar.gz

{git_juggler-0.1.2 → git_juggler-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-juggler
-Version: 0.1.2
+Version: 0.1.3
 Summary: Browse multiple local git repos' commit graphs and a shell, from one local web UI.
 License-Expression: MIT
 License-File: LICENSE

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from .activity_tracker import ActivityTracker
+from .agent_repository_tracker import AgentRepositoryScan, AgentRepositoryTracker
+from .process_info import ProcessInfo
+
+__all__ = ["ActivityTracker", "AgentRepositoryScan", "AgentRepositoryTracker", "ProcessInfo"]

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/activity_tracker.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+
+from .agent_repository_tracker import AgentRepositoryScan, AgentRepositoryTracker
+
+
+class ActivityTracker:
+    def __init__(self, tracker: AgentRepositoryTracker | None = None, poll_interval_ms: int = 1000) -> None:
+        self.tracker = tracker or AgentRepositoryTracker()
+        self.poll_interval_ms = poll_interval_ms
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+    def start(self, agent_pid: int, on_scan: Callable[[AgentRepositoryScan], None]) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, args=(agent_pid, on_scan), daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=max(1, self.poll_interval_ms / 1000 * 2))
+        self._thread = None
+
+    def _run(self, agent_pid: int, on_scan: Callable[[AgentRepositoryScan], None]) -> None:
+        interval_seconds = max(0.1, self.poll_interval_ms / 1000)
+        while not self._stop_event.is_set():
+            scan = self.tracker.scan(agent_pid)
+            on_scan(scan)
+            self._stop_event.wait(interval_seconds)

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/agent_activity_adapter.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from .process_info import ProcessInfo
+from .worktree_evidence import WorktreeEvidence
+
+
+class AgentActivityAdapter(Protocol):
+    def supports(self, process: ProcessInfo) -> bool:
+        ...
+
+    def get_session_directory(self, process: ProcessInfo) -> str | None:
+        ...
+
+    def get_activity_evidence(self, process: ProcessInfo) -> list[WorktreeEvidence]:
+        ...

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/agent_process_discovery.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import os
+import subprocess
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+
+DEFAULT_AGENT_PATTERNS = ("claude", "opencode")
+
+
+@dataclass(frozen=True)
+class AgentProcessCandidate:
+    pid: int
+    command_line: str
+    matched_pattern: str
+
+
+class CommandRunner:
+    def run(self, args: Sequence[str]) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(args, capture_output=True, text=True, timeout=5, check=False)  # noqa: S603 - fixed executable plus arg array
+
+
+def parse_pgrep_output(output: str, pattern: str, current_pid: int | None = None) -> list[AgentProcessCandidate]:
+    candidates: list[AgentProcessCandidate] = []
+    for line in output.splitlines():
+        stripped = line.strip()
+        if not stripped:
+            continue
+        pid_text, _, command_line = stripped.partition(" ")
+        try:
+            pid = int(pid_text)
+        except ValueError:
+            continue
+        if current_pid is not None and pid == current_pid:
+            continue
+        candidates.append(AgentProcessCandidate(pid=pid, command_line=command_line or pattern, matched_pattern=pattern))
+    return candidates
+
+
+class AgentProcessDiscovery:
+    def __init__(self, patterns: Sequence[str] = DEFAULT_AGENT_PATTERNS, runner: CommandRunner | None = None) -> None:
+        self.patterns = tuple(pattern for pattern in patterns if pattern.strip())
+        self.runner = runner or CommandRunner()
+
+    def discover(self) -> list[AgentProcessCandidate]:
+        by_pid: dict[int, AgentProcessCandidate] = {}
+        for pattern in self.patterns:
+            for candidate in self._discover_pattern(pattern):
+                by_pid.setdefault(candidate.pid, candidate)
+        return sorted(by_pid.values(), key=lambda candidate: candidate.pid)
+
+    def _discover_pattern(self, pattern: str) -> list[AgentProcessCandidate]:
+        try:
+            result = self.runner.run(["pgrep", "-af", pattern])
+        except (OSError, subprocess.SubprocessError):
+            return []
+        if result.returncode not in (0, 1):
+            return []
+        return parse_pgrep_output(result.stdout, pattern, current_pid=os.getpid())

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/agent_repository_tracker.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from collections.abc import Sequence
+
+from .agent_activity_adapter import AgentActivityAdapter
+from .create_process_inspector import create_process_inspector
+from .git_resolver import GitResolver, GitWorktreeInfo
+from .process_info import ProcessInfo
+from .process_inspector import ProcessInspector
+from .worktree_evidence import WorktreeEvidence, command_path_evidence, cwd_evidence, file_access_evidence, session_directory_evidence
+
+
+WORKTREE_ACTIVITY_TTL_MS = 30_000
+MIN_ACTIVE_WORKTREE_SCORE = 3
+
+
+@dataclass(frozen=True)
+class ActivityEvidence:
+    type: str
+    pid: int | None = None
+    cwd: str | None = None
+    path: str | None = None
+    executable: str | None = None
+    command: str | None = None
+    process_role: str | None = None
+    tool: str | None = None
+    score: int = 0
+
+
+@dataclass
+class AgentWorktreeActivity:
+    repository_id: str
+    worktree_path: str
+    branch: str | None
+    commit: str
+    process_ids: list[int]
+    first_seen: int
+    last_seen: int
+    last_activity: int
+    evidence: list[ActivityEvidence] = field(default_factory=list)
+    activity_score: int = 0
+
+
+@dataclass(frozen=True)
+class AgentRepositoryScan:
+    agent_pid: int
+    session_directory: str | None
+    processes: list[ProcessInfo]
+    worktrees: list[AgentWorktreeActivity]
+    scanned_at: int
+
+
+class AgentRepositoryTracker:
+    def __init__(
+        self,
+        process_inspector: ProcessInspector | None = None,
+        git_resolver: GitResolver | None = None,
+        adapters: Sequence[AgentActivityAdapter] = (),
+        worktree_activity_ttl_ms: int = WORKTREE_ACTIVITY_TTL_MS,
+    ) -> None:
+        self.process_inspector = process_inspector or create_process_inspector()
+        self.git_resolver = git_resolver or GitResolver()
+        self.adapters = tuple(adapters)
+        self.worktree_activity_ttl_ms = worktree_activity_ttl_ms
+        self._activities: dict[str, AgentWorktreeActivity] = {}
+        self._scan_running = False
+
+    def scan(self, agent_pid: int) -> AgentRepositoryScan:
+        if self._scan_running:
+            now = int(time.time() * 1000)
+            return AgentRepositoryScan(agent_pid=agent_pid, session_directory=None, processes=[], worktrees=self._retained(now), scanned_at=now)
+
+        self._scan_running = True
+        try:
+            return self._scan(agent_pid)
+        finally:
+            self._scan_running = False
+
+    def _scan(self, agent_pid: int) -> AgentRepositoryScan:
+        scanned_at = int(time.time() * 1000)
+        self.git_resolver.clear_cache()
+
+        root = self.process_inspector.get_process(agent_pid)
+        descendants = self.process_inspector.get_descendants(agent_pid) if root is not None else []
+        processes = ([root] if root is not None else []) + descendants
+        child_depths = self._child_depths(agent_pid, descendants)
+        session_directory = self._session_directory(root) if root is not None else None
+
+        current = self._collect_current_activities(agent_pid, processes, child_depths, scanned_at)
+        for key, activity in current.items():
+            existing = self._activities.get(key)
+            if existing is not None:
+                activity.first_seen = existing.first_seen
+            self._activities[key] = activity
+
+        self._expire(scanned_at)
+        return AgentRepositoryScan(
+            agent_pid=agent_pid,
+            session_directory=session_directory,
+            processes=processes,
+            worktrees=sorted(self._activities.values(), key=lambda item: item.worktree_path),
+            scanned_at=scanned_at,
+        )
+
+    def _collect_current_activities(self, root_pid: int, processes: list[ProcessInfo], child_depths: dict[int, int], observed_at: int) -> dict[str, AgentWorktreeActivity]:
+        activities: dict[str, AgentWorktreeActivity] = {}
+        for process in processes:
+            for evidence in self._path_evidence_for_process(process, root_pid, child_depths):
+                worktree = self.git_resolver.resolve_path(evidence.path)
+                if worktree is None:
+                    continue
+                activity = activities.get(worktree.worktree_path)
+                if activity is None:
+                    activity = self._new_activity(worktree, observed_at)
+                    activities[worktree.worktree_path] = activity
+                if process.pid not in activity.process_ids and evidence.pid is not None:
+                    activity.process_ids.append(process.pid)
+                self._add_evidence(activity, evidence)
+                activity.last_seen = observed_at
+                if evidence.score >= MIN_ACTIVE_WORKTREE_SCORE:
+                    activity.last_activity = observed_at
+
+        active = {key: activity for key, activity in activities.items() if activity.activity_score >= MIN_ACTIVE_WORKTREE_SCORE}
+        for activity in active.values():
+            activity.process_ids.sort()
+        return active
+
+    def _path_evidence_for_process(self, process: ProcessInfo, root_pid: int, child_depths: dict[int, int]) -> list[WorktreeEvidence]:
+        evidence: list[WorktreeEvidence] = []
+        command_evidence = command_path_evidence(process, root_pid, child_depths)
+        file_evidence = file_access_evidence(process, root_pid, child_depths)
+        if process.pid == root_pid:
+            session_evidence = session_directory_evidence(process)
+            if session_evidence is not None:
+                evidence.append(session_evidence)
+        process_cwd_evidence = cwd_evidence(process, root_pid, child_depths)
+        if process_cwd_evidence is not None and not command_evidence:
+            evidence.append(process_cwd_evidence)
+        evidence.extend(command_evidence)
+        evidence.extend(file_evidence)
+        for adapter in self._supported_adapters(process):
+            evidence.extend(adapter.get_activity_evidence(process))
+        return evidence
+
+    def _session_directory(self, process: ProcessInfo) -> str | None:
+        for adapter in self._supported_adapters(process):
+            session_directory = adapter.get_session_directory(process)
+            if session_directory:
+                return session_directory
+        return process.cwd
+
+    def _supported_adapters(self, process: ProcessInfo) -> list[AgentActivityAdapter]:
+        return [adapter for adapter in self.adapters if adapter.supports(process)]
+
+    def _child_depths(self, root_pid: int, descendants: list[ProcessInfo]) -> dict[int, int]:
+        by_pid = {process.pid: process for process in descendants}
+        depths: dict[int, int] = {}
+        for process in descendants:
+            depth = 1
+            cursor = process
+            seen: set[int] = set()
+            while cursor.parent_pid is not None and cursor.parent_pid != root_pid and cursor.parent_pid in by_pid and cursor.parent_pid not in seen:
+                seen.add(cursor.parent_pid)
+                depth += 1
+                cursor = by_pid[cursor.parent_pid]
+            depths[process.pid] = depth
+        return depths
+
+    def _new_activity(self, worktree: GitWorktreeInfo, observed_at: int) -> AgentWorktreeActivity:
+        return AgentWorktreeActivity(
+            repository_id=worktree.repository_id,
+            worktree_path=worktree.worktree_path,
+            branch=worktree.branch,
+            commit=worktree.commit,
+            process_ids=[],
+            first_seen=observed_at,
+            last_seen=observed_at,
+            last_activity=observed_at,
+        )
+
+    def _add_evidence(self, activity: AgentWorktreeActivity, evidence: WorktreeEvidence) -> None:
+        activity.evidence.append(
+            ActivityEvidence(
+                type=evidence.type,
+                pid=evidence.pid,
+                cwd=evidence.path if evidence.type.endswith("cwd") else None,
+                path=evidence.path,
+                executable=evidence.executable,
+                command=evidence.command,
+                process_role=evidence.process_role,
+                tool=evidence.tool,
+                score=evidence.score,
+            )
+        )
+        activity.activity_score += evidence.score
+
+    def _expire(self, now: int) -> None:
+        expired = [key for key, activity in self._activities.items() if now - activity.last_activity > self.worktree_activity_ttl_ms]
+        for key in expired:
+            del self._activities[key]
+
+    def _retained(self, now: int) -> list[AgentWorktreeActivity]:
+        self._expire(now)
+        return sorted(self._activities.values(), key=lambda item: item.worktree_path)

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/create_process_inspector.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import sys
+
+from .linux_process_inspector import LinuxProcessInspector
+from .mac_process_inspector import MacProcessInspector
+from .process_inspector import ProcessInspector
+
+
+def create_process_inspector() -> ProcessInspector:
+    if sys.platform == "darwin":
+        return MacProcessInspector()
+    if sys.platform.startswith("linux"):
+        return LinuxProcessInspector()
+    raise RuntimeError(f"unsupported platform for process inspection: {sys.platform}")

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/git_resolver.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+import subprocess
+from collections.abc import Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from .paths import normalize_path
+
+
+@dataclass(frozen=True)
+class GitWorktreeInfo:
+    repository_id: str
+    worktree_path: str
+    common_git_dir: str
+    branch: str | None
+    commit: str
+
+
+class GitCommandRunner:
+    def run(self, args: Sequence[str]) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(args, capture_output=True, text=True, timeout=5, check=False)  # noqa: S603 - fixed executable plus arg array
+
+
+class GitResolver:
+    def __init__(self, runner: GitCommandRunner | None = None) -> None:
+        self.runner = runner or GitCommandRunner()
+        self._cache: dict[str, GitWorktreeInfo | None] = {}
+
+    def clear_cache(self) -> None:
+        self._cache.clear()
+
+    def resolve_directory(self, directory: str | Path) -> GitWorktreeInfo | None:
+        try:
+            key = normalize_path(directory)
+        except OSError:
+            return None
+        if key not in self._cache:
+            self._cache[key] = self._resolve_uncached(Path(key))
+        return self._cache[key]
+
+    def resolve_path(self, path: str | Path) -> GitWorktreeInfo | None:
+        try:
+            candidate = Path(path).expanduser().resolve()
+        except OSError:
+            return None
+        if candidate.is_file():
+            candidate = candidate.parent
+        while True:
+            resolved = self.resolve_directory(candidate)
+            if resolved is not None:
+                return resolved
+            parent = candidate.parent
+            if parent == candidate:
+                return None
+            candidate = parent
+
+    def _resolve_uncached(self, directory: Path) -> GitWorktreeInfo | None:
+        top_level = self._git(directory, "rev-parse", "--show-toplevel")
+        common_git_dir = self._git(directory, "rev-parse", "--git-common-dir")
+        commit = self._git(directory, "rev-parse", "HEAD")
+        if top_level is None or common_git_dir is None or commit is None:
+            return None
+
+        branch = self._git(directory, "branch", "--show-current")
+        normalized_common = self._normalize_git_path(directory, common_git_dir)
+        normalized_top = normalize_path(top_level)
+        return GitWorktreeInfo(
+            repository_id=normalized_common,
+            worktree_path=normalized_top,
+            common_git_dir=normalized_common,
+            branch=branch if branch else None,
+            commit=commit,
+        )
+
+    def _git(self, directory: Path, *args: str) -> str | None:
+        try:
+            result = self.runner.run(["git", "-C", str(directory), *args])
+        except (OSError, subprocess.SubprocessError):
+            return None
+        if result.returncode != 0:
+            return None
+        return result.stdout.strip()
+
+    def _normalize_git_path(self, directory: Path, raw_path: str) -> str:
+        path = Path(raw_path)
+        if not path.is_absolute():
+            path = directory / path
+        return normalize_path(path)

git_juggler-0.1.3/src/backend/git_juggler/agent_tracking/linux_process_inspector.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .process_info import ProcessInfo
+
+
+PROC_ROOT = Path("/proc")
+
+
+def parse_proc_stat_ppid(stat: str) -> int | None:
+    close = stat.rfind(")")
+    if close < 0:
+        return None
+    rest = stat[close + 1 :].strip().split()
+    if len(rest) < 2:
+        return None
+    try:
+        return int(rest[1])
+    except ValueError:
+        return None
+
+
+def parse_proc_cmdline(raw: bytes) -> str | None:
+    parts = parse_proc_cmdline_args(raw)
+    return " ".join(parts) if parts else None
+
+
+def parse_proc_cmdline_args(raw: bytes) -> list[str]:
+    parts = [part.decode("utf-8", errors="replace") for part in raw.split(b"\0") if part]
+    return parts
+
+
+class LinuxProcessInspector:
+    def __init__(self, proc_root: Path = PROC_ROOT) -> None:
+        self.proc_root = proc_root
+
+    def get_process(self, pid: int) -> ProcessInfo | None:
+        return self._read_process(pid)
+
+    def get_children(self, pid: int) -> list[ProcessInfo]:
+        return [process for process in self._snapshot().values() if process.parent_pid == pid]
+
+    def get_descendants(self, pid: int) -> list[ProcessInfo]:
+        snapshot = self._snapshot()
+        children_by_parent: dict[int, list[ProcessInfo]] = {}
+        for process in snapshot.values():
+            if process.parent_pid is not None:
+                children_by_parent.setdefault(process.parent_pid, []).append(process)
+
+        descendants: list[ProcessInfo] = []
+        stack = list(children_by_parent.get(pid, []))
+        seen: set[int] = set()
+        while stack:
+            process = stack.pop()
+            if process.pid in seen:
+                continue
+            seen.add(process.pid)
+            descendants.append(process)
+            stack.extend(children_by_parent.get(process.pid, []))
+        return descendants
+
+    def _snapshot(self) -> dict[int, ProcessInfo]:
+        processes: dict[int, ProcessInfo] = {}
+        try:
+            entries = list(os.scandir(self.proc_root))
+        except OSError:
+            return processes
+        for entry in entries:
+            if not entry.name.isdigit():
+                continue
+            process = self._read_process(int(entry.name))
+            if process is not None:
+                processes[process.pid] = process
+        return processes
+
+    def _read_process(self, pid: int) -> ProcessInfo | None:
+        base = self.proc_root / str(pid)
+        parent_pid = self._read_parent_pid(base)
+        if parent_pid is None:
+            return None
+        return ProcessInfo(
+            pid=pid,
+            parent_pid=parent_pid,
+            executable=self._readlink_or_none(base / "exe"),
+            command_line=self._read_cmdline(base / "cmdline"),
+            arguments=self._read_cmdline_args(base / "cmdline"),
+            open_files=self._read_open_files(base / "fd"),
+            cwd=self._readlink_or_none(base / "cwd"),
+        )
+
+    def _read_parent_pid(self, base: Path) -> int | None:
+        try:
+            return parse_proc_stat_ppid((base / "stat").read_text(encoding="utf-8", errors="replace"))
+        except OSError:
+            return None
+
+    def _read_cmdline(self, path: Path) -> str | None:
+        try:
+            return parse_proc_cmdline(path.read_bytes())
+        except OSError:
+            return None
+
+    def _read_cmdline_args(self, path: Path) -> list[str] | None:
+        try:
+            return parse_proc_cmdline_args(path.read_bytes())
+        except OSError:
+            return None
+
+    def _readlink_or_none(self, path: Path) -> str | None:
+        try:
+            return os.readlink(path)
+        except OSError:
+            return None
+
+    def _read_open_files(self, fd_dir: Path) -> list[str]:
+        paths: list[str] = []
+        try:
+            entries = list(os.scandir(fd_dir))
+        except OSError:
+            return paths
+        for entry in entries:
+            try:
+                target = os.readlink(entry.path)
+            except OSError:
+                continue
+            if target.startswith("/"):
+                paths.append(target)
+        return list(dict.fromkeys(paths))