git-juggler 0.2.15__tar.gz → 0.2.17__tar.gz

{git_juggler-0.2.15 → git_juggler-0.2.17}/.gitignore

@@ -25,7 +25,8 @@ secrets.env
 .vscode/
 *.sw?
 
-# Personal task notes (see CLAUDE.md)
+# Local assistant/project notes
+CLAUDE.md
 todo.txt
 
 plans/

{git_juggler-0.2.15 → git_juggler-0.2.17}/PKG-INFO

@@ -1,9 +1,28 @@
 Metadata-Version: 2.5
 Name: git-juggler
-Version: 0.2.15
+Version: 0.2.17
 Summary: A local Git dashboard for people juggling agents and too many repos.
+Project-URL: Homepage, https://github.com/franz38/git-juggler
+Project-URL: Repository, https://github.com/franz38/git-juggler
+Project-URL: Issues, https://github.com/franz38/git-juggler/issues
+Project-URL: Releases, https://github.com/franz38/git-juggler/releases
 License-Expression: MIT
 License-File: LICENSE
+Keywords: agents,dashboard,git,repositories,terminal
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: FastAPI
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control :: Git
 Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.110
 Requires-Dist: gitpython>=3.1
@@ -30,6 +49,14 @@ Watch agents work live, follow every repo’s git graph, and catch what changed
 - Connects GitHub Actions and Jenkins runs to commits and active pipelines.
 - VS Code-compatible themes.
 
+## Privacy / local-first
+
+- Runs locally and binds to `127.0.0.1` by default.
+- No telemetry or analytics are built in, and none are planned.
+- Repo scanning and Claude/OpenCode session tracking read local files on your machine.
+- Git mutations run through visible terminal commands, so you can see the exact command and output.
+- Network requests are only used for features you configure, such as CI integrations.
+
 ## How to install
 
 git-juggler is published on PyPI. The recommended way to install it is with
@@ -46,7 +73,7 @@ to seed the initial search path; after that, search paths are managed in the app
 from the welcome wizard or Settings.
 
 - `--host HOST` changes the bind host from the default `127.0.0.1`.
-- `--port PORT` changes the backend port from the default `8000`.
+- `--port PORT` changes the backend port from the default `8788`.
 - `--no-open` disables opening the app in your browser automatically.
 
 If you don't have pipx yet:
@@ -85,7 +112,7 @@ Use the dev script to start both the backend and frontend dev servers:
 ```
 
 - `path-to-scan` is optional. On first run, it seeds the folder whose immediate children are scanned for Git repos.
-- `--port PORT` is optional. It changes the backend port from the default `8000`; if you use it, update `src/frontend/vite.config.ts` locally so Vite proxies `/api` and `/ws` to the same port.
+- `--port PORT` is optional. It changes the backend port from the default `8788`; the dev script passes the selected port to Vite automatically.
 - `--no-open` disables opening the app in your browser automatically.
 
 Or run them manually in two terminals:
@@ -99,7 +126,7 @@ python3 -m venv .venv
 ```
 cd src/frontend
 npm install
-npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8000)
+npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8788)
 ```
 
 Open http://localhost:5173.
@@ -113,7 +140,7 @@ cd src/frontend && npm install && npm run build
 cd ../.. && .venv/bin/git-juggler <path-to-scan> [--no-open]
 ```
 
-The backend serves the built frontend in this mode, so only port 8000 is needed.
+The backend serves the built frontend in this mode, so only port 8788 is needed.
 By default, it opens the app in your browser.
 
 ## Build a Python package

{git_juggler-0.2.15 → git_juggler-0.2.17}/README.md

@@ -17,6 +17,14 @@ Watch agents work live, follow every repo’s git graph, and catch what changed
 - Connects GitHub Actions and Jenkins runs to commits and active pipelines.
 - VS Code-compatible themes.
 
+## Privacy / local-first
+
+- Runs locally and binds to `127.0.0.1` by default.
+- No telemetry or analytics are built in, and none are planned.
+- Repo scanning and Claude/OpenCode session tracking read local files on your machine.
+- Git mutations run through visible terminal commands, so you can see the exact command and output.
+- Network requests are only used for features you configure, such as CI integrations.
+
 ## How to install
 
 git-juggler is published on PyPI. The recommended way to install it is with
@@ -33,7 +41,7 @@ to seed the initial search path; after that, search paths are managed in the app
 from the welcome wizard or Settings.
 
 - `--host HOST` changes the bind host from the default `127.0.0.1`.
-- `--port PORT` changes the backend port from the default `8000`.
+- `--port PORT` changes the backend port from the default `8788`.
 - `--no-open` disables opening the app in your browser automatically.
 
 If you don't have pipx yet:
@@ -72,7 +80,7 @@ Use the dev script to start both the backend and frontend dev servers:
 ```
 
 - `path-to-scan` is optional. On first run, it seeds the folder whose immediate children are scanned for Git repos.
-- `--port PORT` is optional. It changes the backend port from the default `8000`; if you use it, update `src/frontend/vite.config.ts` locally so Vite proxies `/api` and `/ws` to the same port.
+- `--port PORT` is optional. It changes the backend port from the default `8788`; the dev script passes the selected port to Vite automatically.
 - `--no-open` disables opening the app in your browser automatically.
 
 Or run them manually in two terminals:
@@ -86,7 +94,7 @@ python3 -m venv .venv
 ```
 cd src/frontend
 npm install
-npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8000)
+npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8788)
 ```
 
 Open http://localhost:5173.
@@ -100,7 +108,7 @@ cd src/frontend && npm install && npm run build
 cd ../.. && .venv/bin/git-juggler <path-to-scan> [--no-open]
 ```
 
-The backend serves the built frontend in this mode, so only port 8000 is needed.
+The backend serves the built frontend in this mode, so only port 8788 is needed.
 By default, it opens the app in your browser.
 
 ## Build a Python package

git_juggler-0.2.17/pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "git-juggler"
+dynamic = ["version"]
+description = "A local Git dashboard for people juggling agents and too many repos."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+keywords = ["agents", "dashboard", "git", "repositories", "terminal"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Web Environment",
+    "Framework :: FastAPI",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Version Control :: Git",
+]
+dependencies = [
+    "fastapi>=0.110",
+    "uvicorn[standard]>=0.29",
+    "gitpython>=3.1",
+    "pywinpty>=2.0; sys_platform == 'win32'",
+]
+
+[project.scripts]
+git-juggler = "git_juggler.main:cli"
+
+[project.urls]
+Homepage = "https://github.com/franz38/git-juggler"
+Repository = "https://github.com/franz38/git-juggler"
+Issues = "https://github.com/franz38/git-juggler/issues"
+Releases = "https://github.com/franz38/git-juggler/releases"
+
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/backend/git_juggler"]
+artifacts = ["src/backend/git_juggler/frontend_dist/**"]
+
+[tool.hatch.build.targets.sdist]
+artifacts = ["src/backend/git_juggler/frontend_dist/**"]

{git_juggler-0.2.15 → git_juggler-0.2.17}/scripts/dev.sh

@@ -1,10 +1,10 @@
 #!/usr/bin/env bash
 # Runs the backend and frontend dev servers together, both hot-reloading.
-# See CLAUDE.md's "How to run locally" section for the equivalent manual steps.
+# See README.md's "Dev mode" section for the equivalent manual steps.
 set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
-BACKEND_PORT=8000
+BACKEND_PORT=8788
 OPEN_BROWSER=1
 
 usage() {
@@ -12,8 +12,7 @@ usage() {
   echo "  path-to-scan    optional: directory whose first-level children get scanned for git repos." >&2
   echo "                  Only used to seed the config on first run; scan paths are otherwise" >&2
   echo "                  managed in the app (welcome wizard / Settings)." >&2
-  echo "  --port PORT     backend port (default: 8000). If you change this, also update" >&2
-  echo "                  src/frontend/vite.config.ts's proxy target -- don't commit that change." >&2
+  echo "  --port PORT     backend port (default: 8788)." >&2
   echo "  --no-open       don't open the app in a browser automatically." >&2
 }
 
@@ -115,7 +114,7 @@ fi
 BACKEND_PID=$!
 
 echo "Starting frontend dev server..."
-(cd "$ROOT_DIR/src/frontend" && npm run dev) &
+(cd "$ROOT_DIR/src/frontend" && GIT_JUGGLER_BACKEND_URL="http://127.0.0.1:$BACKEND_PORT" npm run dev) &
 FRONTEND_PID=$!
 
 if [ "$OPEN_BROWSER" = "1" ]; then
@@ -125,11 +124,6 @@ fi
 echo ""
 echo "Backend:  http://127.0.0.1:$BACKEND_PORT"
 echo "Frontend: http://localhost:5173  <- open this"
-if [ "$BACKEND_PORT" != "8000" ]; then
-  echo ""
-  echo "NOTE: backend is on a non-default port. Update the proxy target in" \
-       "src/frontend/vite.config.ts to http://127.0.0.1:$BACKEND_PORT (local-only change, do not commit)."
-fi
 echo ""
 echo "Press Ctrl+C to stop both."
 

{git_juggler-0.2.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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.15 → git_juggler-0.2.17}/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: