git-juggler 0.1.0__py3-none-any.whl

git_juggler/app.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from . import config
+from .commit_detail import get_commit_detail
+from .git_data import get_graph, get_repo_status
+from .github_actions import get_github_actions_runs
+from .repos import list_repos, resolve_repo_path
+from .schemas import CommitDetail, ConfigResponse, ConfigUpdateRequest, GitHubActionsRunInfo, GraphResponse, RepoStatusResponse, RepoSummary
+from .terminal import run_terminal_session
+
+
+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)
+
+    # Only needed for local dev, when the Vite dev server (a different origin)
+    # talks to this API directly instead of through its proxy.
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    def _resolve_repo_path(repo_id: str) -> Path:
+        path = resolve_repo_path(config.load_repo_paths(), repo_id)
+        if path is None:
+            raise HTTPException(status_code=404, detail="repo not found")
+        return path
+
+    @app.get("/api/repos", response_model=list[RepoSummary])
+    def api_list_repos() -> list[RepoSummary]:
+        return list_repos(config.load_repo_paths())
+
+    def _current_config() -> ConfigResponse:
+        return ConfigResponse(
+            repo_paths=[str(p) for p in config.load_repo_paths()],
+            pinned_repo_paths=config.load_pinned_repo_paths(),
+            github=config.load_github_config(),
+        )
+
+    @app.get("/api/config", response_model=ConfigResponse)
+    def api_get_config() -> ConfigResponse:
+        return _current_config()
+
+    @app.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)
+
+        if body.pinned_repo_paths is not None:
+            deduped = list(dict.fromkeys(body.pinned_repo_paths))
+            config.save_pinned_repo_paths(deduped)
+
+        if body.github is not None:
+            config.save_github_config(body.github.model_dump())
+
+        return _current_config()
+
+    @app.get("/api/repos/{repo_id}/graph", response_model=GraphResponse)
+    def api_graph(repo_id: str) -> GraphResponse:
+        path = _resolve_repo_path(repo_id)
+        commits, branches, current_branch, head_commit, upstream_commit, is_dirty, uncommitted_files, checked_out_branches = get_graph(path)
+        return GraphResponse(
+            commits=commits,
+            branches=branches,
+            current_branch=current_branch,
+            head_commit=head_commit,
+            upstream_commit=upstream_commit,
+            is_dirty=is_dirty,
+            uncommitted_files=uncommitted_files,
+            checked_out_branches=checked_out_branches,
+        )
+
+    @app.get("/api/repos/{repo_id}/status", response_model=RepoStatusResponse)
+    def api_repo_status(repo_id: str) -> RepoStatusResponse:
+        path = _resolve_repo_path(repo_id)
+        return get_repo_status(path)
+
+    @app.get("/api/repos/{repo_id}/commits/{sha}", response_model=CommitDetail)
+    def api_commit_detail(repo_id: str, sha: str) -> CommitDetail:
+        path = _resolve_repo_path(repo_id)
+        try:
+            return get_commit_detail(path, sha)
+        except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
+            raise HTTPException(status_code=404, detail="commit not found") from exc
+
+    @app.get("/api/repos/{repo_id}/github/actions", response_model=dict[str, list[GitHubActionsRunInfo]])
+    def api_github_actions(repo_id: str) -> dict[str, list[GitHubActionsRunInfo]]:
+        path = _resolve_repo_path(repo_id)
+        commits, _, _, _, _, _, _, _ = get_graph(path)
+        return get_github_actions_runs(path, {c.hash for c in commits}, config.load_github_config())
+
+    @app.websocket("/ws/terminal")
+    async def ws_terminal(websocket: WebSocket) -> None:
+        repo_id = websocket.query_params.get("repo")
+        cwd = root_path
+        if repo_id:
+            resolved = resolve_repo_path(config.load_repo_paths(), repo_id)
+            if resolved is None:
+                await websocket.close(code=1008)
+                return
+            cwd = resolved
+        await websocket.accept()
+        try:
+            await run_terminal_session(websocket, cwd=cwd)
+        except WebSocketDisconnect:
+            pass
+
+    if frontend_dist and frontend_dist.exists():
+        assets_dir = frontend_dist / "assets"
+        if assets_dir.exists():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+        @app.get("/{full_path:path}")
+        def spa(full_path: str) -> FileResponse:
+            candidate = frontend_dist / full_path
+            if full_path and candidate.is_file():
+                return FileResponse(candidate)
+            return FileResponse(frontend_dist / "index.html")
+
+    return app

git_juggler/commit_detail.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from git import NULL_TREE, Repo
+
+from .schemas import CommitDetail, FileChange, PersonInfo
+
+_STATUS_MAP = {
+    "A": "added",
+    "M": "modified",
+    "D": "deleted",
+    "R": "renamed",
+    "C": "copied",
+    "T": "modified",
+}
+
+
+def get_commit_detail(repo_path: Path, sha: str) -> CommitDetail:
+    repo = Repo(repo_path)
+    commit = repo.commit(sha)
+
+    if commit.parents:
+        diffs = commit.parents[0].diff(commit)
+    else:
+        diffs = commit.diff(NULL_TREE)
+
+    files: list[FileChange] = []
+    for d in diffs:
+        status = _STATUS_MAP.get(d.change_type or "M", "modified")
+        path = d.b_path or d.a_path or "?"
+        files.append(FileChange(path=path, status=status))
+    files.sort(key=lambda f: f.path)
+
+    subject = commit.summary if isinstance(commit.summary, str) else commit.summary.decode()
+    message = commit.message if isinstance(commit.message, str) else commit.message.decode()
+
+    return CommitDetail(
+        hash=commit.hexsha,
+        short_hash=commit.hexsha[:7],
+        parents=[p.hexsha for p in commit.parents],
+        author=PersonInfo(name=commit.author.name or "", email=commit.author.email or ""),
+        committer=PersonInfo(name=commit.committer.name or "", email=commit.committer.email or ""),
+        authored_date=commit.authored_datetime.isoformat(),
+        committed_date=commit.committed_datetime.isoformat(),
+        subject=subject,
+        message=message,
+        files=files,
+    )

git_juggler/config.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+CONFIG_DIR = Path.home() / ".config" / "git-juggler"
+CONFIG_PATH = CONFIG_DIR / "config.json"
+
+
+def _load_raw() -> dict:
+    if not CONFIG_PATH.exists():
+        return {}
+    try:
+        data = json.loads(CONFIG_PATH.read_text())
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _save_raw(data: dict) -> None:
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    tmp_path = CONFIG_PATH.with_suffix(".tmp")
+    tmp_path.write_text(json.dumps(data, indent=2))
+    tmp_path.replace(CONFIG_PATH)
+
+
+def load_repo_paths() -> list[Path]:
+    raw = _load_raw().get("repo_paths", [])
+    if not isinstance(raw, list):
+        return []
+    return [Path(p) for p in raw if isinstance(p, str)]
+
+
+def save_repo_paths(paths: list[Path]) -> None:
+    data = _load_raw()
+    data["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):
+        return []
+    return [p for p in raw if isinstance(p, str)]
+
+
+def save_pinned_repo_paths(paths: list[str]) -> None:
+    data = _load_raw()
+    data["pinned_repo_paths"] = paths
+    _save_raw(data)
+
+
+def load_github_config() -> dict | None:
+    raw = _load_raw().get("github")
+    return raw if isinstance(raw, dict) else None
+
+
+def save_github_config(github: dict | None) -> None:
+    data = _load_raw()
+    if github is None:
+        data.pop("github", None)
+    else:
+        data["github"] = github
+    _save_raw(data)
+
+
+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."""
+    if CONFIG_PATH.exists():
+        return
+    save_repo_paths([default_path])

git_juggler/dev_app.py

@@ -0,0 +1,16 @@
+"""ASGI app factory used only by `uvicorn --reload`, which needs an import
+string (not a live app object) so it can restart the app in a subprocess.
+The scanned root path is passed through an env var by main.py.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from .app import create_app
+
+_root_path = Path(os.environ["GIT_JUGGLER_ROOT"])
+_frontend_dist = Path(__file__).resolve().parent.parent.parent / "frontend" / "dist"
+
+app = create_app(_root_path, frontend_dist=_frontend_dist if _frontend_dist.exists() else None)