git-juggler 0.2.7__tar.gz → 0.2.10__tar.gz

{git_juggler-0.2.7 → git_juggler-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-juggler
-Version: 0.2.7
+Version: 0.2.10
 Summary: A local Git dashboard for people juggling agents and too many repos.
 License-Expression: MIT
 License-File: LICENSE

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/agents/hook_events.py

@@ -150,6 +150,7 @@ class AgentHookEventReader:
             session_events = self._since_last_prompt(session_events)
             card: ClaudeSession | None = None
             opencode_session: OpenCodeSession | None = None
+            parent_opencode_session: OpenCodeSession | None = None
             busy: bool | None = None  # what the agent itself reports, when it does
             waiting_for: str | None = None
             if provider == "claude" and registry is not None and session_id:
@@ -169,9 +170,10 @@ class AgentHookEventReader:
                     if not session_id:
                         continue  # the plugin's start event: an instance, not yet a session
                     opencode_session = self._opencode_session(session_id, opencode_signature)
-                    # Deleted, archived, or a sub-agent's session (its parent is what the user sees).
-                    if opencode_session is None or opencode_session.archived or opencode_session.is_child:
+                    if opencode_session is None or opencode_session.archived:
                         continue
+                    if opencode_session.parent_id:
+                        parent_opencode_session = self._opencode_session(opencode_session.parent_id, opencode_signature)
                     busy = opencode_session.busy
 
             activities: dict[str, AgentWorktreeActivity] = {}
@@ -240,6 +242,11 @@ class AgentHookEventReader:
                     name=card.name if card is not None else (opencode_session.title if opencode_session is not None else None),
                     details=details,
                     waiting_for=waiting_for,
+                    is_subagent=opencode_session.is_child if opencode_session is not None else False,
+                    parent_session_id=opencode_session.parent_id if opencode_session is not None else None,
+                    parent_title=parent_opencode_session.title if parent_opencode_session is not None else None,
+                    parent_agent=parent_opencode_session.agent if parent_opencode_session is not None else None,
+                    parent_provider=provider if parent_opencode_session is not None else None,
                 )
             )
         return scans, next_change

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/agents/hooks.py

@@ -102,8 +102,8 @@ def _claude_snippet_dict() -> dict:
         "hooks": {
             "SessionStart": [_claude_hook_entry("SessionStart")],
             "UserPromptSubmit": [_claude_hook_entry("UserPromptSubmit")],
-            "PreToolUse": [_claude_hook_entry("PreToolUse", "Bash|Edit|MultiEdit|Write|Read|Glob|Grep|LS")],
-            "PostToolUse": [_claude_hook_entry("PostToolUse", "Bash|Edit|MultiEdit|Write|Read|Glob|Grep|LS")],
+            "PreToolUse": [_claude_hook_entry("PreToolUse", "Bash|Edit|MultiEdit|Write|Read|Glob|Grep|LS|Task")],
+            "PostToolUse": [_claude_hook_entry("PostToolUse", "Bash|Edit|MultiEdit|Write|Read|Glob|Grep|LS|Task")],
             "SessionEnd": [_claude_hook_entry("SessionEnd")],
         }
     }

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/agents/tracking/activity_models.py

@@ -63,3 +63,8 @@ class AgentRepositoryScan:
     details: SessionDetails | None = None
     # What the agent is blocked on ("permission prompt", "input needed"), or None.
     waiting_for: str | None = None
+    is_subagent: bool = False
+    parent_session_id: str | None = None
+    parent_title: str | None = None
+    parent_agent: str | None = None
+    parent_provider: str | None = None

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/agents/tracking/opencode_sessions.py

@@ -27,10 +27,14 @@ class OpenCodeSession:
     time_created: int | None
     time_updated: int | None
     archived: bool
-    is_child: bool
+    parent_id: str | None
     busy: bool
     last_prompt: str | None
 
+    @property
+    def is_child(self) -> bool:
+        return self.parent_id is not None
+
 
 def db_signature(path: Path | None) -> tuple | None:
     """Change marker for the DB (OpenCode uses WAL, so the -wal file moves first).
@@ -117,7 +121,7 @@ def read_session(path: Path | None, session_id: str, now_ms: int | None = None)
             time_created=time_created if isinstance(time_created, int) else None,
             time_updated=time_updated if isinstance(time_updated, int) else None,
             archived=time_archived is not None,
-            is_child=parent_id is not None,
+            parent_id=parent_id if isinstance(parent_id, str) else None,
             busy=busy,
             last_prompt=last_prompt,
         )

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/api/agents.py

@@ -46,6 +46,11 @@ def _agent_scan_response(scan: AgentRepositoryScan) -> AgentRepositoryScanRespon
         name=scan.name,
         details=scan.details.__dict__ if scan.details is not None else None,
         waiting_for=scan.waiting_for,
+        is_subagent=scan.is_subagent,
+        parent_session_id=scan.parent_session_id,
+        parent_title=scan.parent_title,
+        parent_agent=scan.parent_agent,
+        parent_provider=scan.parent_provider,
     )
 
 

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/api/ci.py

@@ -6,8 +6,8 @@ from typing import Annotated
 from fastapi import APIRouter, HTTPException, Query
 
 from .. import config
-from ..ci import github_actions, jenkins
-from ..ci import get_active_pipelines, get_ci_run_stages, get_ci_runs, poll_ci_runs
+from ..ci import github_actions, jenkins, run_cache
+from ..ci import get_ci_run_stages, get_ci_runs, get_recent_pipelines, poll_ci_runs
 from ..git.data import get_commit_hashes
 from ..repo_discovery import list_repos, resolve_repo_path
 from ..schemas import (
@@ -17,6 +17,7 @@ from ..schemas import (
     CiStage,
     GitHubConfig,
     JenkinsConfig,
+    JenkinsRuleTestRequest,
 )
 
 
@@ -76,16 +77,24 @@ def api_ci_stages(repo_id: str, provider: str, run_id: str) -> list[CiStage]:
     return stages
 
 
-# Queued/running pipelines across all repos, for the Pipelines tab.
-@router.get("/api/ci/active", response_model=list[ActivePipeline])
-def api_ci_active() -> list[ActivePipeline]:
-    return get_active_pipelines(
+# The most recent pipelines (running or finished) across all repos, for the
+# Pipelines tab.
+@router.get("/api/ci/recent", response_model=list[ActivePipeline])
+def api_ci_recent(limit: Annotated[int, Query(ge=1, le=50)] = 10) -> list[ActivePipeline]:
+    return get_recent_pipelines(
         list_repos(config.load_repo_paths()),
         config.load_github_config(),
         config.load_jenkins_config(),
+        limit,
     )
 
 
+# Forget every stored finished run (and runs the CI servers no longer have).
+@router.post("/api/ci/cache/clear", status_code=204)
+def api_ci_cache_clear() -> None:
+    run_cache.clear()
+
+
 @router.post("/api/ci/github/test", response_model=CiConnectionTestResponse)
 def api_test_github_connection(body: GitHubConfig) -> CiConnectionTestResponse:
     ok, message = github_actions.test_connection(body.model_dump())
@@ -96,3 +105,9 @@ def api_test_github_connection(body: GitHubConfig) -> CiConnectionTestResponse:
 def api_test_jenkins_connection(body: JenkinsConfig) -> CiConnectionTestResponse:
     ok, message = jenkins.test_connection(body.model_dump())
     return CiConnectionTestResponse(ok=ok, message=message)
+
+
+@router.post("/api/ci/jenkins/rule-test", response_model=CiConnectionTestResponse)
+def api_test_jenkins_rule(body: JenkinsRuleTestRequest) -> CiConnectionTestResponse:
+    ok, message = jenkins.test_rule_connection(body.config.model_dump(), body.rule.model_dump(), Path(body.repo_path))
+    return CiConnectionTestResponse(ok=ok, message=message)

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/app.py

@@ -14,12 +14,14 @@ from .api.config import create_config_router
 from .api.git import router as git_router
 from .api.repos import router as repos_router
 from .api.terminal import create_terminal_router
+from .ci import run_cache
 
 
 def create_app(root_path: Path, frontend_dist: Path | None = None) -> FastAPI:
     app = FastAPI(title="git-juggler")
     app.state.root_path = root_path
     config.ensure_seeded(root_path)
+    run_cache.configure(config.CONFIG_DIR / "ci-cache.sqlite")
 
     # Only needed for local dev, when the Vite dev server (a different origin)
     # talks to this API directly instead of through its proxy.

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/ci/__init__.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Protocol
 
@@ -27,6 +28,11 @@ class CiProvider(Protocol):
         Stages are included for runs that are still going."""
         ...
 
+    def recent_runs(self, repo_path: Path, limit: int) -> list[CiRunInfo]:
+        """The repo's latest runs (at most `limit` per job/workflow listing),
+        running or finished, without stages."""
+        ...
+
 
 @dataclass
 class GitHubActionsProvider:
@@ -39,6 +45,9 @@ class GitHubActionsProvider:
     def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None, branch_name: str | None) -> list[CiRunInfo]:
         return github_actions.poll_runs(repo_path, self.config, run_ids, head_sha)
 
+    def recent_runs(self, repo_path: Path, limit: int) -> list[CiRunInfo]:
+        return github_actions.get_recent_runs(repo_path, self.config, limit)
+
 
 @dataclass
 class JenkinsProvider:
@@ -51,6 +60,9 @@ class JenkinsProvider:
     def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None, branch_name: str | None) -> list[CiRunInfo]:
         return jenkins.poll_runs(repo_path, self.config, run_ids, head_sha, branch_name)
 
+    def recent_runs(self, repo_path: Path, limit: int) -> list[CiRunInfo]:
+        return jenkins.get_recent_builds(repo_path, self.config, limit)
+
 
 def enabled_providers(github_config: dict | None, jenkins_config: dict | None) -> list[CiProvider]:
     providers: list[CiProvider] = []
@@ -116,32 +128,54 @@ def get_ci_run_stages(
     return None
 
 
-def _active_runs_for_repo(repo: RepoSummary, github_config: dict | None, jenkins_config: dict | None) -> list[ActivePipeline]:
-    runs = poll_ci_runs(Path(repo.path), None, None, None, github_config, jenkins_config)
-    return [ActivePipeline(repo_id=repo.id, repo_name=repo.name, run=run) for run in runs]
+def _recent_runs_for_repo(
+    repo: RepoSummary, github_config: dict | None, jenkins_config: dict | None, limit: int
+) -> list[tuple[RepoSummary, CiRunInfo]]:
+    providers = enabled_providers(github_config, jenkins_config)
+    return [(repo, run) for provider in providers for run in provider.recent_runs(Path(repo.path), limit)]
+
 
+def _run_key(run: CiRunInfo) -> tuple[str, str]:
+    return (run.provider, run.run_id or run.url)
 
-def _pipeline_key(pipeline: ActivePipeline) -> tuple[str, str]:
-    run = pipeline.run
-    if run.run_id:
-        return (run.provider, run.run_id)
-    return (run.provider, run.url)
 
+def _created_at_key(run: CiRunInfo) -> datetime:
+    # Providers format timestamps differently ("Z" vs "+00:00"), so compare
+    # parsed values rather than strings.
+    try:
+        parsed = datetime.fromisoformat((run.created_at or "").replace("Z", "+00:00"))
+    except ValueError:
+        return datetime.min.replace(tzinfo=timezone.utc)
+    return parsed if parsed.tzinfo else parsed.replace(tzinfo=timezone.utc)
 
-def get_active_pipelines(
+
+def get_recent_pipelines(
     repos: list[RepoSummary],
     github_config: dict | None,
     jenkins_config: dict | None,
+    limit: int = 10,
 ) -> list[ActivePipeline]:
-    """Queued/running pipelines across every known repo. Repos are queried
-    concurrently since each one is a network round trip."""
-    if not repos:
+    """The `limit` most recent pipelines across every known repo, running or
+    finished, newest first, with their stages. Repos are queried concurrently
+    since each one is a network round trip; stages are only fetched for the
+    runs that make the cut."""
+    if not repos or limit <= 0:
         return []
     with ThreadPoolExecutor(max_workers=min(8, len(repos))) as pool:
-        per_repo = pool.map(lambda repo: _active_runs_for_repo(repo, github_config, jenkins_config), repos)
-        pipelines = [item for group in per_repo for item in group]
-    deduped_by_key: dict[tuple[str, str], ActivePipeline] = {}
-    for pipeline in pipelines:
-        deduped_by_key.setdefault(_pipeline_key(pipeline), pipeline)
-    deduped = list(deduped_by_key.values())
-    return sorted(deduped, key=lambda item: item.run.created_at or "", reverse=True)
+        per_repo = pool.map(lambda repo: _recent_runs_for_repo(repo, github_config, jenkins_config, limit), repos)
+        found = [item for group in per_repo for item in group]
+    deduped: dict[tuple[str, str], tuple[RepoSummary, CiRunInfo]] = {}
+    for repo, run in found:
+        deduped.setdefault(_run_key(run), (repo, run))
+    newest = sorted(deduped.values(), key=lambda item: _created_at_key(item[1]), reverse=True)[:limit]
+
+    def with_stages(item: tuple[RepoSummary, CiRunInfo]) -> ActivePipeline:
+        repo, run = item
+        if run.run_id:
+            run.stages = get_ci_run_stages(Path(repo.path), run.provider, run.run_id, github_config, jenkins_config)
+        return ActivePipeline(repo_id=repo.id, repo_name=repo.name, run=run)
+
+    if not newest:
+        return []
+    with ThreadPoolExecutor(max_workers=min(8, len(newest))) as pool:
+        return list(pool.map(with_stages, newest))

{git_juggler-0.2.7 → git_juggler-0.2.10}/src/backend/git_juggler/ci/github_actions.py

@@ -10,10 +10,12 @@ from urllib.request import Request, urlopen
 
 from git import Repo
 
+from . import run_cache
 from .http import fetch_json
 from ..schemas import CiRunInfo, CiStage
 
 
+PROVIDER = "github_actions"
 GITHUB_RUNS_PER_PAGE = 100
 GITHUB_RUNS_MAX_PAGES = 10
 ACTIVE_RUN_STATUSES = {"queued", "in_progress", "waiting", "pending", "requested"}
@@ -257,11 +259,47 @@ def _fetch_run_stages(github_config: dict, repo_config: dict, run_id: str) -> li
 
 
 def get_run_stages(repo_path: Path, github_config: dict | None, run_id: str) -> list[CiStage] | None:
+    """A run's jobs/steps; a finished run's come from the run cache once stored."""
     github_config = github_config or {}
     repo_config = _resolve_repo_config(github_config, repo_path)
     if repo_config is None:
         return None
-    return _fetch_run_stages(github_config, repo_config, run_id)
+    cached = run_cache.get(PROVIDER, run_id)
+    if cached is not None and cached.run.stages is not None:
+        return cached.run.stages
+    stages = _fetch_run_stages(github_config, repo_config, run_id)
+    if stages is not None and cached is not None:
+        run_cache.put_stages(PROVIDER, run_id, stages)
+    return stages
+
+
+def _remember_runs(scope: str, runs: list[tuple[CiRunInfo, set[str]]]) -> None:
+    """Store the finished runs among `runs` (with the commits they match). A
+    stored run that changed since (re-run: same id, new attempt) is replaced,
+    dropping its old stages."""
+    stored = run_cache.get_many(PROVIDER, [info.run_id for info, _ in runs if info.run_id])
+    for info, shas in runs:
+        cached = stored.get(info.run_id or "")
+        if cached is not None:
+            if cached.run.updated_at == info.updated_at and cached.run.status == info.status:
+                continue
+            run_cache.delete(PROVIDER, cached.run.run_id or "")
+        run_cache.put(PROVIDER, scope, info, shas)
+
+
+def _unlisted_cached_runs(scope: str, listed: list[CiRunInfo], limit: int | None = None) -> list[run_cache.CachedRun]:
+    """Stored runs of the repo that the live listing didn't return, marked
+    `archived` when they fall inside the listed time range (so GitHub no longer
+    has them); older ones may just be past the capped listing."""
+    listed_ids = {info.run_id for info in listed}
+    oldest = min((info.created_at for info in listed if info.created_at), default=None)
+    result: list[run_cache.CachedRun] = []
+    for cached in run_cache.for_scope_prefixes(PROVIDER, [scope], limit):
+        if cached.run.run_id in listed_ids:
+            continue
+        cached.run.archived = oldest is not None and (cached.run.created_at or "") >= oldest
+        result.append(cached)
+    return result
 
 
 def get_active_runs(repo_path: Path, github_config: dict | None, head_sha: str | None = None) -> list[CiRunInfo]:
@@ -301,6 +339,22 @@ def get_active_runs(repo_path: Path, github_config: dict | None, head_sha: str |
     return result
 
 
+def get_recent_runs(repo_path: Path, github_config: dict | None, limit: int) -> list[CiRunInfo]:
+    """The repo's latest runs, running or finished, newest first, without
+    stages. Same single cached call as `get_active_runs`."""
+    github_config = github_config or {}
+    repo_config = _resolve_repo_config(github_config, repo_path)
+    repo_url = _repo_api_url(github_config, repo_config) if repo_config else None
+    if repo_url is None:
+        return []
+    data = _get_json_cached(f"{repo_url}/actions/runs?{urlencode({'per_page': '30'})}", _headers(github_config))
+    items = data.get("workflow_runs") if isinstance(data, dict) else None
+    listed = [_run_info(run) for run in (items if isinstance(items, list) else []) if isinstance(run, dict)]
+    _remember_runs(repo_url, [(info, {info.head_sha} if info.head_sha else set()) for info in listed])
+    archived = [cached.run for cached in _unlisted_cached_runs(repo_url, listed, limit) if cached.run.archived]
+    return sorted(listed[:limit] + archived, key=lambda info: info.created_at or "", reverse=True)[:limit]
+
+
 def get_runs_by_id(repo_path: Path, github_config: dict | None, run_ids: list[str]) -> list[CiRunInfo]:
     """Current state of specific runs (one conditional call per run, plus one
     for the stages of a run that is still going). A run that has finished comes
@@ -393,12 +447,20 @@ def get_github_actions_runs(repo_path: Path, commit_hashes: set[str], github_con
 
     by_sha: dict[str, list[CiRunInfo]] = {}
     tags_by_name = _tag_targets(repo_path)
+    listed: list[tuple[CiRunInfo, set[str]]] = []
     for run in _fetch_workflow_runs(github_config, repo_config):
+        info = _run_info(run)
         sha = _matching_run_sha(run, commit_hashes, tags_by_name)
-        if sha is None:
-            continue
+        listed.append((info, {s for s in (info.head_sha, sha) if s}))
+        if sha is not None:
+            by_sha.setdefault(sha, []).append(info)
 
-        info = _run_info(run)
-        by_sha.setdefault(sha, []).append(info)
+    # Runs GitHub no longer lists (pruned past its retention) come from the cache.
+    repo_url = _repo_api_url(github_config, repo_config)
+    if repo_url is not None:
+        _remember_runs(repo_url, listed)
+        for cached in _unlisted_cached_runs(repo_url, [info for info, _ in listed]):
+            for sha in cached.shas & commit_hashes:
+                by_sha.setdefault(sha, []).append(cached.run.model_copy(update={"stages": None}))
 
     return by_sha