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

git_juggler-0.2.7/PKG-INFO

@@ -0,0 +1,141 @@
+Metadata-Version: 2.5
+Name: git-juggler
+Version: 0.2.7
+Summary: A local Git dashboard for people juggling agents and too many repos.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110
+Requires-Dist: gitpython>=3.1
+Requires-Dist: pywinpty>=2.0; sys_platform == 'win32'
+Requires-Dist: uvicorn[standard]>=0.29
+Description-Content-Type: text/markdown
+
+<img src="https://github.com/franz38/git-juggler/blob/main/src/frontend/public/logo.png?raw=true" alt="git-juggler" width="400">
+
+A local Git dashboard for people juggling agents and too many repos.
+
+Watch agents work live, follow every repo’s git graph, and catch what changed across your workspace — all from one place, without opening a dozen editors.
+
+<img src="https://github.com/franz38/git-juggler/blob/main/resources/git-juggler-demo-1.gif?raw=true" alt="git-juggler" width="100%">
+
+<img src="https://github.com/franz38/git-juggler/blob/main/resources/git-juggler-demo-4.png?raw=true" alt="git-juggler" width="100%">
+
+## What it does
+
+- Scans the immediate children of one or more configured folders for Git repos.
+- Lets you inspect and manage each repo's graph, branches, tags, stashes, dirty files, and file diffs.
+- Keeps a persistent terminal per open repo and runs Git actions there so you see the real commands and output.
+- Tracks local Claude Code and OpenCode sessions.
+- Connects GitHub Actions and Jenkins runs to commits and active pipelines.
+- VS Code-compatible themes.
+
+## How to install
+
+git-juggler is published on PyPI. The recommended way to install it is with
+[pipx](https://pipx.pypa.io), which puts the `git-juggler` command on your
+PATH in its own isolated environment, without touching your system Python:
+
+```
+pipx install git-juggler
+git-juggler [path-to-scan] [--host HOST] [--port PORT] [--no-open]
+```
+
+`<path-to-scan>` is optional and defaults to the current directory. It is used
+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`.
+- `--no-open` disables opening the app in your browser automatically.
+
+If you don't have pipx yet:
+
+**macOS**
+```
+brew install pipx
+pipx ensurepath
+```
+
+**Linux**
+```
+sudo apt install pipx   # Debian/Ubuntu
+sudo dnf install pipx   # Fedora
+pipx ensurepath
+```
+Many recent distros (like macOS with Homebrew) block a plain global
+`pip install` outside a virtual environment (PEP 668); pipx is the
+supported way around that.
+
+**Windows**
+```
+py -m pip install --user pipx
+py -m pipx ensurepath
+```
+
+Restart your terminal after `ensurepath` so the updated PATH takes effect.
+To upgrade later: `pipx upgrade git-juggler`.
+
+## Dev mode
+
+Use the dev script to start both the backend and frontend dev servers:
+
+```
+./scripts/dev.sh [path-to-scan] [--port PORT] [--no-open]
+```
+
+- `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.
+- `--no-open` disables opening the app in your browser automatically.
+
+Or run them manually in two terminals:
+
+```
+python3 -m venv .venv
+.venv/bin/pip install -e .
+.venv/bin/git-juggler <path-to-scan> --reload [--no-open]
+```
+
+```
+cd src/frontend
+npm install
+npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8000)
+```
+
+Open http://localhost:5173.
+
+By default, `./scripts/dev.sh` opens http://localhost:5173 in your browser.
+
+## Production (single port)
+
+```
+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.
+By default, it opens the app in your browser.
+
+## Build a Python package
+
+The Python wheel includes the built frontend assets. The generated assets are
+not committed; `scripts/build-package.sh` builds them and copies them into the
+backend package before creating the distributions.
+
+```
+python3 -m venv .venv
+.venv/bin/pip install build
+./scripts/build-package.sh
+```
+
+The wheel and source distribution are written to `dist/`.
+
+Install the wheel locally with:
+
+```
+pipx install dist/git_juggler-*.whl --force
+git-juggler <path-to-scan> [--no-open]
+```
+
+Versions are derived from Git tags. GitHub Actions runs the same build, uploads
+the distributions as artifacts, and publishes tagged releases to PyPI.

git_juggler-0.2.7/README.md

@@ -0,0 +1,128 @@
+<img src="https://github.com/franz38/git-juggler/blob/main/src/frontend/public/logo.png?raw=true" alt="git-juggler" width="400">
+
+A local Git dashboard for people juggling agents and too many repos.
+
+Watch agents work live, follow every repo’s git graph, and catch what changed across your workspace — all from one place, without opening a dozen editors.
+
+<img src="https://github.com/franz38/git-juggler/blob/main/resources/git-juggler-demo-1.gif?raw=true" alt="git-juggler" width="100%">
+
+<img src="https://github.com/franz38/git-juggler/blob/main/resources/git-juggler-demo-4.png?raw=true" alt="git-juggler" width="100%">
+
+## What it does
+
+- Scans the immediate children of one or more configured folders for Git repos.
+- Lets you inspect and manage each repo's graph, branches, tags, stashes, dirty files, and file diffs.
+- Keeps a persistent terminal per open repo and runs Git actions there so you see the real commands and output.
+- Tracks local Claude Code and OpenCode sessions.
+- Connects GitHub Actions and Jenkins runs to commits and active pipelines.
+- VS Code-compatible themes.
+
+## How to install
+
+git-juggler is published on PyPI. The recommended way to install it is with
+[pipx](https://pipx.pypa.io), which puts the `git-juggler` command on your
+PATH in its own isolated environment, without touching your system Python:
+
+```
+pipx install git-juggler
+git-juggler [path-to-scan] [--host HOST] [--port PORT] [--no-open]
+```
+
+`<path-to-scan>` is optional and defaults to the current directory. It is used
+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`.
+- `--no-open` disables opening the app in your browser automatically.
+
+If you don't have pipx yet:
+
+**macOS**
+```
+brew install pipx
+pipx ensurepath
+```
+
+**Linux**
+```
+sudo apt install pipx   # Debian/Ubuntu
+sudo dnf install pipx   # Fedora
+pipx ensurepath
+```
+Many recent distros (like macOS with Homebrew) block a plain global
+`pip install` outside a virtual environment (PEP 668); pipx is the
+supported way around that.
+
+**Windows**
+```
+py -m pip install --user pipx
+py -m pipx ensurepath
+```
+
+Restart your terminal after `ensurepath` so the updated PATH takes effect.
+To upgrade later: `pipx upgrade git-juggler`.
+
+## Dev mode
+
+Use the dev script to start both the backend and frontend dev servers:
+
+```
+./scripts/dev.sh [path-to-scan] [--port PORT] [--no-open]
+```
+
+- `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.
+- `--no-open` disables opening the app in your browser automatically.
+
+Or run them manually in two terminals:
+
+```
+python3 -m venv .venv
+.venv/bin/pip install -e .
+.venv/bin/git-juggler <path-to-scan> --reload [--no-open]
+```
+
+```
+cd src/frontend
+npm install
+npm run dev                                     # http://localhost:5173 (proxies /api and /ws to :8000)
+```
+
+Open http://localhost:5173.
+
+By default, `./scripts/dev.sh` opens http://localhost:5173 in your browser.
+
+## Production (single port)
+
+```
+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.
+By default, it opens the app in your browser.
+
+## Build a Python package
+
+The Python wheel includes the built frontend assets. The generated assets are
+not committed; `scripts/build-package.sh` builds them and copies them into the
+backend package before creating the distributions.
+
+```
+python3 -m venv .venv
+.venv/bin/pip install build
+./scripts/build-package.sh
+```
+
+The wheel and source distribution are written to `dist/`.
+
+Install the wheel locally with:
+
+```
+pipx install dist/git_juggler-*.whl --force
+git-juggler <path-to-scan> [--no-open]
+```
+
+Versions are derived from Git tags. GitHub Actions runs the same build, uploads
+the distributions as artifacts, and publishes tagged releases to PyPI.

{git_juggler-0.2.5 → git_juggler-0.2.7}/scripts/dev.sh

@@ -5,14 +5,16 @@ set -euo pipefail
 
 ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 BACKEND_PORT=8000
+OPEN_BROWSER=1
 
 usage() {
-  echo "Usage: $0 [path-to-scan] [--port PORT]" >&2
+  echo "Usage: $0 [path-to-scan] [--port PORT] [--no-open]" >&2
   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 "  --no-open       don't open the app in a browser automatically." >&2
 }
 
 SCAN_PATH=""
@@ -26,6 +28,10 @@ while [ $# -gt 0 ]; do
       BACKEND_PORT="${2:?--port requires a value}"
       shift 2
       ;;
+    --no-open)
+      OPEN_BROWSER=0
+      shift
+      ;;
     -*)
       echo "Unknown argument: $1" >&2
       usage
@@ -101,10 +107,10 @@ trap cleanup EXIT INT TERM
 
 if [ -n "$SCAN_PATH" ]; then
   echo "Starting backend (--reload) on port $BACKEND_PORT, scanning $SCAN_PATH ..."
-  "$GIT_JUGGLER" "$SCAN_PATH" --reload --port "$BACKEND_PORT" &
+  "$GIT_JUGGLER" "$SCAN_PATH" --reload --port "$BACKEND_PORT" --no-open &
 else
   echo "Starting backend (--reload) on port $BACKEND_PORT (scan paths from config) ..."
-  "$GIT_JUGGLER" --reload --port "$BACKEND_PORT" &
+  "$GIT_JUGGLER" --reload --port "$BACKEND_PORT" --no-open &
 fi
 BACKEND_PID=$!
 
@@ -112,6 +118,10 @@ echo "Starting frontend dev server..."
 (cd "$ROOT_DIR/src/frontend" && npm run dev) &
 FRONTEND_PID=$!
 
+if [ "$OPEN_BROWSER" = "1" ]; then
+  (sleep 1 && "$VENV_BIN/python" -m webbrowser http://localhost:5173) >/dev/null 2>&1 &
+fi
+
 echo ""
 echo "Backend:  http://127.0.0.1:$BACKEND_PORT"
 echo "Frontend: http://localhost:5173  <- open this"

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

@@ -51,10 +51,11 @@ def api_ci_poll(
     repo_id: str,
     run: Annotated[list[str] | None, Query()] = None,
     head_sha: str | None = None,
+    branch_name: str | None = None,
 ) -> list[CiRunInfo]:
     path = _resolve_repo_path(repo_id)
     return poll_ci_runs(
-        path, run, head_sha, config.load_github_config(), config.load_jenkins_config()
+        path, run, head_sha, branch_name, config.load_github_config(), config.load_jenkins_config()
     )
 
 

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

@@ -19,7 +19,7 @@ class CiProvider(Protocol):
         graph and refreshed on its own, slow, interval — never by the run poll."""
         ...
 
-    def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None) -> list[CiRunInfo]:
+    def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None, branch_name: str | None) -> list[CiRunInfo]:
         """`run_ids=None`: every active (queued/running) run of the repo, to
         discover a pipeline that just started (`head_sha` narrows it to one
         commit where the provider can filter). Otherwise exactly those runs,
@@ -36,7 +36,7 @@ class GitHubActionsProvider:
     def fetch_completed_runs(self, repo_path: Path, commit_hashes: set[str]) -> dict[str, list[CiRunInfo]]:
         return github_actions.get_github_actions_runs(repo_path, commit_hashes, self.config or {})
 
-    def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None) -> list[CiRunInfo]:
+    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)
 
 
@@ -48,8 +48,8 @@ class JenkinsProvider:
     def fetch_completed_runs(self, repo_path: Path, commit_hashes: set[str]) -> dict[str, list[CiRunInfo]]:
         return jenkins.get_jenkins_builds(repo_path, commit_hashes, self.config)
 
-    def poll_runs(self, repo_path: Path, run_ids: list[str] | None, head_sha: str | None) -> list[CiRunInfo]:
-        return jenkins.poll_runs(repo_path, self.config, run_ids, head_sha)
+    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 enabled_providers(github_config: dict | None, jenkins_config: dict | None) -> list[CiProvider]:
@@ -78,6 +78,7 @@ def poll_ci_runs(
     repo_path: Path,
     run_refs: list[str] | None,
     head_sha: str | None,
+    branch_name: str | None,
     github_config: dict | None,
     jenkins_config: dict | None,
 ) -> list[CiRunInfo]:
@@ -86,7 +87,7 @@ def poll_ci_runs(
     providers named there are asked, about just those runs."""
     providers = enabled_providers(github_config, jenkins_config)
     if run_refs is None:
-        return [run for provider in providers for run in provider.poll_runs(repo_path, None, head_sha)]
+        return [run for provider in providers for run in provider.poll_runs(repo_path, None, head_sha, branch_name)]
 
     ids_by_provider: dict[str, list[str]] = {}
     for ref in run_refs:
@@ -97,7 +98,7 @@ def poll_ci_runs(
         run
         for provider in providers
         if provider.name in ids_by_provider
-        for run in provider.poll_runs(repo_path, ids_by_provider[provider.name], head_sha)
+        for run in provider.poll_runs(repo_path, ids_by_provider[provider.name], head_sha, branch_name)
     ]
 
 
@@ -116,7 +117,7 @@ def get_ci_run_stages(
 
 
 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, github_config, jenkins_config)
+    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]
 
 

{git_juggler-0.2.5 → git_juggler-0.2.7}/src/backend/git_juggler/ci/jenkins.py

@@ -2,31 +2,125 @@ from __future__ import annotations
 
 import base64
 import os
+import re
 from datetime import datetime, timezone
 from pathlib import Path
-from urllib.parse import unquote, urlencode, urlparse
+from urllib.parse import quote, unquote, urlencode, urlparse
 from urllib.request import urlopen
 
 from .http import fetch_json
 from ..schemas import CiRunInfo, CiStage
 
 
-def _matching_job_configs(jenkins_config: dict, repo_path: Path) -> list[dict]:
-    matches: list[dict] = []
-    for item in jenkins_config.get("jobs", []):
-        if not isinstance(item, dict):
+_TEMPLATE_RE = re.compile(r"\{([A-Za-z0-9_]+)\}")
+_BRANCH_TEMPLATE_RE = re.compile(r"\{branch_[A-Za-z0-9_]+\}")
+
+
+def _slug(value: str) -> str:
+    return re.sub(r"[^A-Za-z0-9._-]+", "-", value).strip("-") or value
+
+
+def _repo_template_values(repo_path: Path) -> dict[str, str]:
+    resolved = repo_path.expanduser().resolve()
+    repo_name = resolved.name
+    repo_slug = _slug(repo_name)
+    return {
+        "repo_path": str(resolved),
+        "repo_name": repo_name,
+        "repo_name_url": quote(repo_name, safe=""),
+        "repo_slug": repo_slug,
+        "repo_slug_url": quote(repo_slug, safe=""),
+    }
+
+
+def _branch_template_values(branch_name: str | None) -> dict[str, str]:
+    if not branch_name:
+        return {}
+    branch_slug = _slug(branch_name)
+    return {
+        "branch_name": branch_name,
+        "branch_name_url": quote(branch_name, safe=""),
+        "branch_slug": branch_slug,
+        "branch_slug_url": quote(branch_slug, safe=""),
+    }
+
+
+def _render_template(value: str, values: dict[str, str]) -> str:
+    return _TEMPLATE_RE.sub(lambda match: values.get(match.group(1), match.group(0)), value)
+
+
+def _has_branch_template(value: str) -> bool:
+    return _BRANCH_TEMPLATE_RE.search(value) is not None
+
+
+def _matches_repo_path(raw_path: str, repo_path: Path, values: dict[str, str]) -> bool:
+    rendered_path = _render_template(raw_path, values).strip()
+    if rendered_path == "*":
+        return True
+    try:
+        return Path(rendered_path).expanduser().resolve() == repo_path.resolve()
+    except Exception:
+        return False
+
+
+def _render_job_config(item: dict, repo_path: Path, values: dict[str, str], branch_name: str | None) -> dict | None:
+    job_url = item.get("job_url")
+    if not isinstance(job_url, str) or not job_url:
+        return None
+    if _has_branch_template(job_url) and not branch_name:
+        return None
+    rendered = _render_template(job_url, {**values, **_branch_template_values(branch_name)})
+    return {**item, "repo_path": str(repo_path.resolve()), "job_url": rendered}
+
+
+def _matching_rule_job_configs(jenkins_config: dict, repo_path: Path, values: dict[str, str], branch_name: str | None) -> list[dict]:
+    for rule in jenkins_config.get("rules", []):
+        if not isinstance(rule, dict):
             continue
-        raw_path = item.get("repo_path")
-        job_url = item.get("job_url")
-        if not isinstance(raw_path, str) or not isinstance(job_url, str) or not job_url:
+        repo_paths = rule.get("repo_paths")
+        if not isinstance(repo_paths, list) or not any(
+            isinstance(raw_path, str) and _matches_repo_path(raw_path, repo_path, values) for raw_path in repo_paths
+        ):
             continue
-        try:
-            configured_path = Path(raw_path).expanduser().resolve()
-        except Exception:
+        rendered = _render_job_config({"repo_path": str(repo_path), "job_url": rule.get("job_url")}, repo_path, values, branch_name)
+        if rendered is not None:
+            return [rendered]
+        return []
+    return []
+
+
+def _matching_job_configs(jenkins_config: dict, repo_path: Path, branch_name: str | None = None) -> list[dict]:
+    values = _repo_template_values(repo_path)
+    return _matching_rule_job_configs(jenkins_config, repo_path, values, branch_name)
+
+
+def _job_url_prefixes(jenkins_config: dict, repo_path: Path) -> list[str]:
+    values = _repo_template_values(repo_path)
+    prefixes: list[str] = []
+    for job in _matching_job_configs(jenkins_config, repo_path):
+        prefixes.append(str(job["job_url"]).rstrip("/"))
+
+    items: list[dict] = []
+    for rule in jenkins_config.get("rules", []):
+        if not isinstance(rule, dict):
             continue
-        if configured_path == repo_path.resolve():
-            matches.append(item)
-    return matches
+        repo_paths = rule.get("repo_paths")
+        if not isinstance(repo_paths, list) or not any(
+            isinstance(raw_path, str) and _matches_repo_path(raw_path, repo_path, values) for raw_path in repo_paths
+        ):
+            continue
+        items.append({"job_url": rule.get("job_url")})
+        break
+
+    for item in items:
+        raw_url = item.get("job_url")
+        if not isinstance(raw_url, str) or not _has_branch_template(raw_url):
+            continue
+        prefix_template = _BRANCH_TEMPLATE_RE.split(raw_url, maxsplit=1)[0]
+        prefix = _render_template(prefix_template, values).rstrip("/")
+        if prefix:
+            prefixes.append(prefix)
+    return list(dict.fromkeys(prefixes))
 
 
 def _headers(jenkins_config: dict) -> dict[str, str]:
@@ -228,14 +322,13 @@ def get_build_stages(repo_path: Path, jenkins_config: dict | None, build_url: st
     followed when it lives under a job configured for this repo."""
     if not jenkins_config:
         return None
-    wanted = build_url.rstrip("/") + "/"
-    for job in _matching_job_configs(jenkins_config, repo_path):
-        if wanted.startswith(str(job["job_url"]).rstrip("/") + "/"):
-            return _fetch_build_stages(build_url, _headers(jenkins_config))
+    wanted = build_url.rstrip("/")
+    if any(wanted.startswith(prefix + "/") for prefix in _job_url_prefixes(jenkins_config, repo_path)):
+        return _fetch_build_stages(build_url, _headers(jenkins_config))
     return None
 
 
-def get_active_builds(repo_path: Path, jenkins_config: dict | None) -> list[CiRunInfo]:
+def get_active_builds(repo_path: Path, jenkins_config: dict | None, branch_name: str | None = None) -> list[CiRunInfo]:
     """Builds running right now, with their stages."""
     if not jenkins_config:
         return []
@@ -245,7 +338,7 @@ def get_active_builds(repo_path: Path, jenkins_config: dict | None) -> list[CiRu
         "actions[lastBuiltRevision[SHA1,branch[name]],parameters[name,value]]]{0,10}"
     )
     result: list[CiRunInfo] = []
-    for job in _matching_job_configs(jenkins_config, repo_path):
+    for job in _matching_job_configs(jenkins_config, repo_path, branch_name):
         job_url = str(job["job_url"])
         data = _fetch_json(f"{job_url.rstrip('/')}/api/json?{urlencode({'tree': tree})}", headers)
         builds = data.get("builds") if isinstance(data, dict) else None
@@ -266,7 +359,7 @@ def get_builds_by_url(repo_path: Path, jenkins_config: dict | None, build_urls:
     if not jenkins_config:
         return []
     headers = _headers(jenkins_config)
-    job_urls = [str(job["job_url"]).rstrip("/") for job in _matching_job_configs(jenkins_config, repo_path)]
+    job_urls = _job_url_prefixes(jenkins_config, repo_path)
 
     result: list[CiRunInfo] = []
     for build_url in build_urls:
@@ -289,12 +382,13 @@ def poll_runs(
     jenkins_config: dict | None,
     run_ids: list[str] | None,
     head_sha: str | None = None,
+    branch_name: str | None = None,
 ) -> list[CiRunInfo]:
     """`run_ids=None`: every running build of the repo's jobs (discovery).
     Otherwise exactly those builds, whatever their state. Jenkins can't filter
     builds by commit, so `head_sha` is accepted for interface parity only."""
     if run_ids is None:
-        return get_active_builds(repo_path, jenkins_config)
+        return get_active_builds(repo_path, jenkins_config, branch_name)
     return get_builds_by_url(repo_path, jenkins_config, run_ids)
 
 
@@ -308,10 +402,11 @@ def test_connection(jenkins_config: dict | None) -> tuple[bool, str]:
     if isinstance(base_url, str) and base_url.strip():
         urls.append(f"{base_url.strip().rstrip('/')}/api/json")
 
-    for job in jenkins_config.get("jobs", []):
-        job_url = job.get("job_url") if isinstance(job, dict) else None
-        if isinstance(job_url, str) and job_url.strip():
-            urls.append(f"{job_url.strip().rstrip('/')}/api/json")
+    for rule in jenkins_config.get("rules", []):
+        if isinstance(rule, dict):
+            job_url = rule.get("job_url")
+            if isinstance(job_url, str) and job_url.strip() and not _has_branch_template(job_url):
+                urls.append(f"{job_url.strip().rstrip('/')}/api/json")
 
     if not urls:
         return False, "Set a Jenkins base URL or at least one job URL first."