git-juggler 0.2.14__tar.gz → 0.2.16__tar.gz

{git_juggler-0.2.14 → git_juggler-0.2.16}/.github/workflows/build-package.yml

@@ -17,7 +17,7 @@ jobs:
             fi
           fi
 
-  build:
+  test:
     needs: validate-tag
     runs-on: ubuntu-latest
 
@@ -39,8 +39,8 @@ jobs:
         with:
           python-version: "3.12"
 
-      - name: Install Python build tooling
-        run: python -m pip install --upgrade pip build pytest
+      - name: Install Python test tooling
+        run: python -m pip install --upgrade pip pytest
 
       - name: Install backend test dependencies
         run: python -m pip install -e .
@@ -56,6 +56,31 @@ jobs:
         working-directory: src/frontend
         run: npm test
 
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # full history + tags, needed by hatch-vcs to derive the version
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: src/frontend/package-lock.json
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install Python build tooling
+        run: python -m pip install --upgrade pip build
+
       - name: Build frontend and Python distributions
         run: ./scripts/build-package.sh
 

{git_juggler-0.2.14 → git_juggler-0.2.16}/PKG-INFO

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

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/agents/hook_events.py

@@ -230,6 +230,8 @@ class AgentHookEventReader:
         self._cached_signature: tuple | None = None
         self._cached_scans: list[AgentRepositoryScan] = []
         self._cached_valid_until = 0
+        self._last_active_heads: dict[tuple[tuple[str, str], str], GitWorktreeInfo] = {}
+        self._idle_heads: dict[tuple[tuple[str, str], str], GitWorktreeInfo] = {}
 
     def recent_scans(self, now: int | None = None) -> list[AgentRepositoryScan]:
         """One scan per open agent session.
@@ -294,6 +296,7 @@ class AgentHookEventReader:
         opencode_signature = db_signature(self.opencode_db_path)
         scans: list[AgentRepositoryScan] = []
         next_change: int | None = None
+        seen_head_keys: set[tuple[tuple[str, str], str]] = set()
         for session_key, session_events in sessions.items():
             # A session is open until its end hook fires (or its process dies),
             # however long it has been quiet.
@@ -374,6 +377,8 @@ class AgentHookEventReader:
             elif busy is True:
                 # Working right now: the most recently touched worktree is where.
                 max(activities.values(), key=lambda item: item.last_activity).state = "active"
+            for activity in activities.values():
+                self._pin_idle_head(session_key, activity, seen_head_keys)
             details: SessionDetails | None = None
             if card is not None and session_id:
                 details = self._session_details(card, session_id)
@@ -404,8 +409,48 @@ class AgentHookEventReader:
                     parent_provider=provider if parent_opencode_session is not None else None,
                 )
             )
+        self._prune_head_state(seen_head_keys)
         return scans, next_change
 
+    def _pin_idle_head(
+        self,
+        session_key: tuple[str, str],
+        activity: AgentWorktreeActivity,
+        seen: set[tuple[tuple[str, str], str]],
+    ) -> None:
+        key = (session_key, activity.worktree_path)
+        seen.add(key)
+        current = self._worktree_info(activity)
+        if activity.state == "active":
+            self._idle_heads.pop(key, None)
+            self._last_active_heads[key] = current
+            return
+
+        anchor = self._idle_heads.get(key)
+        if anchor is None or anchor.repository_id != activity.repository_id:
+            anchor = self._last_active_heads.get(key)
+            if anchor is None or anchor.repository_id != activity.repository_id:
+                anchor = current
+            self._idle_heads[key] = anchor
+        activity.branch = anchor.branch
+        activity.commit = anchor.commit
+
+    def _prune_head_state(self, seen: set[tuple[tuple[str, str], str]]) -> None:
+        for cache in (self._last_active_heads, self._idle_heads):
+            for key in list(cache):
+                if key not in seen:
+                    del cache[key]
+
+    @staticmethod
+    def _worktree_info(activity: AgentWorktreeActivity) -> GitWorktreeInfo:
+        return GitWorktreeInfo(
+            repository_id=activity.repository_id,
+            worktree_path=activity.worktree_path,
+            common_git_dir=activity.repository_id,
+            branch=activity.branch,
+            commit=activity.commit,
+        )
+
     @staticmethod
     def _since_last_prompt(events: list[HookEvent]) -> list[HookEvent]:
         """The session's events from its latest user prompt onward.

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/api/ci.py

@@ -25,7 +25,7 @@ router = APIRouter()
 
 
 def _resolve_repo_path(repo_id: str) -> Path:
-    path = resolve_repo_path(config.load_repo_paths(), repo_id)
+    path = resolve_repo_path(config.load_repo_paths(), repo_id, config.load_individual_repo_paths())
     if path is None:
         raise HTTPException(status_code=404, detail="repo not found")
     return path
@@ -82,7 +82,7 @@ def api_ci_stages(repo_id: str, provider: str, run_id: str) -> list[CiStage]:
 @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()),
+        list_repos(config.load_repo_paths(), config.load_individual_repo_paths()),
         config.load_github_config(),
         config.load_jenkins_config(),
         limit,

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/api/config.py

@@ -25,6 +25,7 @@ def create_config_router(root_path: Path) -> APIRouter:
     def _current_config() -> ConfigResponse:
         return ConfigResponse(
             repo_paths=[str(p) for p in config.load_repo_paths()],
+            individual_repo_paths=[str(p) for p in config.load_individual_repo_paths()],
             pinned_repo_paths=config.load_pinned_repo_paths(),
             repo_groups=config.load_repo_groups(),
             excluded_paths=config.load_excluded_paths(),
@@ -32,27 +33,36 @@ def create_config_router(root_path: Path) -> APIRouter:
             github=config.load_github_config(),
             jenkins=config.load_jenkins_config(),
             terminal_shell=terminal_shell,
+            terminal_helper_command=[sys.executable, "-m", "git_juggler.main"],
         )
 
     @router.get("/api/config", response_model=ConfigResponse)
     def api_get_config() -> ConfigResponse:
         return _current_config()
 
+    def _resolve_dirs(raw_paths: list[str], *, require_git: bool) -> list[Path]:
+        resolved: list[Path] = []
+        seen: set[str] = set()
+        for raw in raw_paths:
+            path = Path(raw).expanduser().resolve()
+            if not path.is_dir():
+                raise HTTPException(status_code=400, detail=f"not a directory: {raw}")
+            if require_git and not (path / ".git").exists():
+                raise HTTPException(status_code=400, detail=f"not a git repository: {raw}")
+            key = str(path)
+            if key in seen:
+                continue
+            seen.add(key)
+            resolved.append(path)
+        return resolved
+
     @router.put("/api/config", response_model=ConfigResponse)
     def api_update_config(body: ConfigUpdateRequest) -> ConfigResponse:
         if body.repo_paths is not None:
-            resolved: list[Path] = []
-            seen: set[str] = set()
-            for raw in body.repo_paths:
-                path = Path(raw).expanduser().resolve()
-                if not path.is_dir():
-                    raise HTTPException(status_code=400, detail=f"not a directory: {raw}")
-                key = str(path)
-                if key in seen:
-                    continue
-                seen.add(key)
-                resolved.append(path)
-            config.save_repo_paths(resolved)
+            config.save_repo_paths(_resolve_dirs(body.repo_paths, require_git=False))
+
+        if body.individual_repo_paths is not None:
+            config.save_individual_repo_paths(_resolve_dirs(body.individual_repo_paths, require_git=True))
 
         if body.pinned_repo_paths is not None:
             deduped = list(dict.fromkeys(body.pinned_repo_paths))

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/api/git.py

@@ -5,18 +5,19 @@ from pathlib import Path
 from fastapi import APIRouter, HTTPException, Query
 
 from .. import config
+from ..git.conflicts import create_resolution_token, get_conflict_file_content
 from ..git.data import GRAPH_PAGE_SIZE, HistoryChangedError, get_graph, get_repo_status
 from ..git.detail import get_commit_detail
 from ..git.diff import get_commit_file_diff, get_working_file_diff
 from ..repo_discovery import resolve_repo_path
-from ..schemas import CommitDetail, FileDiff, GraphResponse, RepoStatusResponse
+from ..schemas import CommitDetail, ConflictFileContent, ConflictResolutionTokenRequest, ConflictResolutionTokenResponse, FileDiff, GraphResponse, RepoStatusResponse
 
 
 router = APIRouter()
 
 
 def _resolve_repo_path(repo_id: str) -> Path:
-    path = resolve_repo_path(config.load_repo_paths(), repo_id)
+    path = resolve_repo_path(config.load_repo_paths(), repo_id, config.load_individual_repo_paths())
     if path is None:
         raise HTTPException(status_code=404, detail="repo not found")
     return path
@@ -75,3 +76,24 @@ def api_working_file_diff(
         return get_working_file_diff(repo_path, path, old_path, full)
     except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
         raise HTTPException(status_code=404, detail="diff not found") from exc
+
+
+@router.get("/api/repos/{repo_id}/conflicts/content", response_model=ConflictFileContent)
+def api_conflict_file_content(repo_id: str, path: str) -> ConflictFileContent:
+    repo_path = _resolve_repo_path(repo_id)
+    try:
+        return get_conflict_file_content(repo_path, path)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
+        raise HTTPException(status_code=404, detail="conflict file not found") from exc
+
+
+@router.post("/api/repos/{repo_id}/conflicts/resolution-token", response_model=ConflictResolutionTokenResponse)
+def api_create_conflict_resolution_token(
+    repo_id: str, request: ConflictResolutionTokenRequest
+) -> ConflictResolutionTokenResponse:
+    if request.repo_id != repo_id:
+        raise HTTPException(status_code=400, detail="repo mismatch")
+    _resolve_repo_path(repo_id)
+    return ConflictResolutionTokenResponse(
+        token=create_resolution_token(repo_id, request.path, request.content)
+    )

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/api/repos.py

@@ -13,7 +13,7 @@ router = APIRouter()
 
 @router.get("/api/repos", response_model=list[RepoSummary])
 def api_list_repos() -> list[RepoSummary]:
-    return list_repos(config.load_repo_paths())
+    return list_repos(config.load_repo_paths(), config.load_individual_repo_paths())
 
 
 @router.get("/api/repos/scan-progress", response_model=RepoScanProgress)

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/api/terminal.py

@@ -17,7 +17,7 @@ def create_terminal_router(root_path: Path) -> APIRouter:
         repo_id = websocket.query_params.get("repo")
         cwd = root_path
         if repo_id:
-            resolved = resolve_repo_path(config.load_repo_paths(), repo_id)
+            resolved = resolve_repo_path(config.load_repo_paths(), repo_id, config.load_individual_repo_paths())
             if resolved is None:
                 await websocket.close(code=1008)
                 return

{git_juggler-0.2.14 → git_juggler-0.2.16}/src/backend/git_juggler/config.py

@@ -5,11 +5,22 @@ from pathlib import Path
 
 from pydantic import ValidationError
 
-from .schemas import Preferences
+from .schemas import JenkinsConfig, JenkinsRuleConfig, Preferences
 
 CONFIG_DIR = Path.home() / ".config" / "git-juggler"
 CONFIG_PATH = CONFIG_DIR / "config.json"
 
+# A fresh install ships one example Jenkins rule so the settings show how
+# pipeline URL placeholders work. It has no repos, so nothing is ever requested
+# from the placeholder host until the user assigns some. The settings' "Add
+# rule" starts from the same rule (lib/jenkinsUrlTemplate.ts in the frontend).
+EXAMPLE_JENKINS_BASE_URL = "https://jenkins.example.com"
+EXAMPLE_JENKINS_RULE = JenkinsRuleConfig(
+    id="example",
+    name="Example rule",
+    job_url=EXAMPLE_JENKINS_BASE_URL + "/job/{repo_name_url}/job/{branch_name_url}",
+)
+
 
 def _load_raw() -> dict:
     if not CONFIG_PATH.exists():
@@ -41,6 +52,21 @@ def save_repo_paths(paths: list[Path]) -> None:
     _save_raw(data)
 
 
+def load_individual_repo_paths() -> list[Path]:
+    """Repos the user added one by one, on top of whatever the search paths
+    (``repo_paths``) turn up."""
+    raw = _load_raw().get("individual_repo_paths", [])
+    if not isinstance(raw, list):
+        return []
+    return [Path(p) for p in raw if isinstance(p, str)]
+
+
+def save_individual_repo_paths(paths: list[Path]) -> None:
+    data = _load_raw()
+    data["individual_repo_paths"] = [str(p) for p in paths]
+    _save_raw(data)
+
+
 def load_pinned_repo_paths() -> list[str]:
     raw = _load_raw().get("pinned_repo_paths", [])
     if not isinstance(raw, list):
@@ -201,10 +227,12 @@ def save_jenkins_config(jenkins: dict | None) -> None:
 
 def ensure_seeded(default_path: Path) -> None:
     """On first run (no config file yet), seed it with the CLI-provided path
-    so existing single-path usage keeps working without extra setup."""
+    so existing single-path usage keeps working without extra setup, plus the
+    example Jenkins rule."""
     if CONFIG_PATH.exists():
         return
     save_repo_paths([default_path])
+    save_jenkins_config(JenkinsConfig(base_url=EXAMPLE_JENKINS_BASE_URL, rules=[EXAMPLE_JENKINS_RULE]).model_dump())
 
 
 def reset_to_factory(default_path: Path) -> None: