Merge branch 'opt/light_mode'

The git module now correctly handles scenarios where the selected base branch is diverged from HEAD. This removes unnecessary ancestor checks during rebase planning, improving overall robustness of the feature. Additionally, the ReflogDialog component was updated to reliably retrieve the current HEAD hash for accurate display in the UI.

- Removed strict ancestor checking when starting interactive rebase operations.
- Updated App.svelte to accurately find and use the current HEAD entry from reflog data.

.claude/settings.local.json

@@ -23,7 +23,88 @@
       "Bash(npx vite *)",
       "Bash(cargo tree *)",
       "Bash(jobs)",
-      "Bash(npx svelte-check *)"
+      "Bash(npx svelte-check *)",
+      "Bash(git log *)",
+      "Bash(xxd)",
+      "Bash(python3 -)",
+      "Bash(echo \"exit: $?\")",
+      "Bash(grep -n \"input,\\\\|select,\\\\|input {\\\\|select {\\\\|.repo-form input\\\\|input:focus\\\\|::placeholder\" src/app.css)",
+      "Bash(sudo -n true)",
+      "Bash(rustc --version)",
+      "Read(//mnt/c/Users/cbr/Desktop/src-tauri/src/**)",
+      "Bash(sudo apt install -y libdbus-1-dev pkg-config)",
+      "Bash(dpkg -l)",
+      "Bash(apt list *)",
+      "Bash(cargo search *)",
+      "Bash(curl -s \"https://crates.io/api/v1/crates/mistralrs\")",
+      "Bash(cargo info *)",
+      "WebFetch(domain:raw.githubusercontent.com)",
+      "Bash(gh api *)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:ericlbuehler.github.io)",
+      "WebFetch(domain:docs.rs)",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-1.5B-Instruct-GGUF\")",
+      "Bash(python3 -c ' *)",
+      "Bash(curl -sI \"https://huggingface.co/Qwen/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/qwen2.5-1.5b-instruct-q4_k_m.gguf\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-1.5B-Instruct-GGUF?blobs=true\")",
+      "Bash(grep -n 'from \"\\\\./lib/git\"\\\\|from \"\\\\./lib/types\"\\\\|^    commit,$' src/App.svelte)",
+      "Bash(kill 24343 24363 24375 24376)",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-0.5B-Instruct-GGUF?blobs=true\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/bartowski/Llama-3.2-3B-Instruct-GGUF?blobs=true\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/bartowski/Llama-3.2-3B-Instruct-GGUF\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-3B-Instruct-GGUF\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-3B-Instruct-GGUF?blobs=true\")",
+      "Bash(curl -s \"https://huggingface.co/api/models/Qwen/Qwen2.5-3B-Instruct\")",
+      "Bash(: *)",
+      "Bash(exit 0 *)",
+      "Bash(rustc -O sanitize_test.rs -o sanitize_test)",
+      "Bash(./sanitize_test)",
+      "Bash(echo \"exit:$?\")",
+      "Bash(grep -rlP \"[äöüßÄÖÜ]\" src src-tauri/src src-tauri/crates --include=\"*.rs\" --include=\"*.svelte\" --include=\"*.ts\")",
+      "Bash(echo \"---exit $?---\")",
+      "Bash(apt-cache policy *)",
+      "Bash(timeout 5 curl -sI http://archive.ubuntu.com)",
+      "Bash(sudo -n apt-get install -y libdbus-1-dev pkg-config)",
+      "Bash(grep -n '\"Unerwarteter Git-Log-Eintrag: {}\",' src-tauri/src/git.rs)",
+      "Bash(grep -E \"git_lite$|tauri_git_lite$\")",
+      "Bash(rustfmt --edition 2024 --check src-tauri/src/git.rs)",
+      "Bash(echo \"EXIT:$?\")",
+      "Bash(ls target/)",
+      "Bash(rustup target *)",
+      "Bash(echo \"exit code: $?\")",
+      "Read(//home/cbr/.cargo/registry/src/**)",
+      "Bash(find / -maxdepth 6 -iname \"mistralrs-*\" -type d)",
+      "Bash(grep -A2 '^name = \"tauri\"$' \"/mnt/c/Users/cbr/Desktop/Neuer Ordner \\(6\\)/src-tauri/Cargo.lock\")",
+      "Bash(rustfmt --edition 2024 --check src/badge.rs src/main.rs)",
+      "Bash(rustfmt --edition 2024 --check src/git.rs)",
+      "Bash(rustfmt --edition 2024 --check src/badge.rs)",
+      "Bash(rustfmt --edition 2024 --check src/git.rs src/main.rs)",
+      "Bash(pkg-config --list-all)",
+      "Bash(rustc --edition 2021 --crate-type lib -o /dev/null --emit=metadata src/git.rs)",
+      "Bash(rustc --edition 2021 --crate-type lib -o /dev/null --emit=metadata /mnt/d/Development/GitLite/src-tauri/src/git.rs)",
+      "Bash(rustc --edition 2021 --crate-type bin -o /dev/null --emit=metadata src/main.rs)",
+      "Bash(grep -B1 \"^error\\\\[E0432\\\\]\\\\|^error$\")",
+      "Bash(grep -v \"^--$\")",
+      "Bash(grep \"^error$\" -A2)",
+      "Bash(cargo run *)",
+      "Bash(node_modules/.bin/svelte-check --version)",
+      "Bash(rustfmt --check --edition 2021 src/git.rs src/main.rs)",
+      "Bash(rustfmt --check --edition 2021 src/git.rs)",
+      "Bash(awk *)",
+      "Bash(rustfmt --edition 2021 /tmp/blame_chunk.rs)",
+      "Read(//tmp/**)",
+      "Bash(identify src-tauri/icons/GitCat.ico)",
+      "Bash(python3 -c \"import PIL; print\\(PIL.__version__\\)\")",
+      "Bash(python3 *)",
+      "Bash(xxd -l 16 src-tauri/icons/GitCat.ico)",
+      "Bash(pkg-config --exists openssl)",
+      "Bash(sudo apt-get install -y libssl-dev pkg-config)",
+      "Bash(dpkg -L libssl3t64)",
+      "Bash(grep *)",
+      "Read(//home/christoph/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tauri-2.11.5/src/**)",
+      "Read(//home/christoph/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tauri-runtime-wry-2.11.4/src/**)",
+      "Read(//home/christoph/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tauri-2.11.5/src/window/**)",
+      "WebSearch"
     ]
   }
 }

.gitea/workflows/app_builder.yaml

@@ -32,16 +32,21 @@ jobs:
 
     strategy:
       fail-fast: false
+      max-parallel: 1
       matrix:
         include:
           # - platform: 'macos-latest'
           #   args: '--target aarch64-apple-darwin'
           # - platform: 'macos-latest'
           #   args: '--target x86_64-apple-darwin'
-          # - platform: 'ubuntu-22.04'
-          #   args: ''
           - platform: "windows-latest"
-            args: ""
+            bundles: "nsis"
+            updater_platform: "windows-x86_64"
+            no_strip: ""
+          - platform: "ubuntu-22.04"
+            bundles: "appimage"
+            updater_platform: "linux-x86_64"
+            no_strip: "1"
 
     runs-on: ${{ matrix.platform }}
 
@@ -55,13 +60,21 @@ jobs:
         if: matrix.platform == 'ubuntu-22.04'
         run: |
           sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y build-essential curl wget file libssl-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev librsvg2-dev patchelf libxdo-dev libfuse2
 
       - name: setup node
         uses: actions/setup-node@v4
         with:
           node-version: lts/*
 
+      - name: Install uv
+        if: matrix.platform == 'ubuntu-22.04'
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b
+
+      - name: install rust toolchain
+        if: matrix.platform == 'ubuntu-22.04'
+        uses: dtolnay/rust-toolchain@stable
+
       - name: install frontend dependencies
         run: npm ci
 
@@ -69,18 +82,13 @@ jobs:
         run: npm version ${{ github.ref_name }} --no-git-tag-version --allow-same-version
 
       - name: Update tauri.conf.json Version
-        shell: powershell
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
         run: |
-          $path = ".\src-tauri\tauri.conf.json"
-          $version = '${{ github.ref_name }}'
-          $content = Get-Content -Raw -Encoding UTF8 $path
-          $regex = [regex]'"version"\s*:\s*"[^"]*"'
-          $replacement = '"version": "' + $version + '"'
-          $updated = $regex.Replace($content, $replacement, 1)
-          $encoding = New-Object System.Text.UTF8Encoding($false)
-          [System.IO.File]::WriteAllText($path, $updated, $encoding)
+          node -e "const fs=require('fs'); const path='src-tauri/tauri.conf.json'; const config=JSON.parse(fs.readFileSync(path,'utf8')); config.version=process.env.RELEASE_VERSION; fs.writeFileSync(path, JSON.stringify(config,null,2)+'\n');"
 
       - name: Commit and Push Changes
+        if: matrix.platform == 'windows-latest'
         shell: powershell
         run: |
           git config user.name '${{ vars.USERNAME_GIT }}'
@@ -131,12 +139,15 @@ jobs:
         env:
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD}}
-        run: npm run tauri build
+          NO_STRIP: ${{ matrix.no_strip }}
+        run: npm run tauri -- build --bundles ${{ matrix.bundles }}
       # ----------------------
       # Upload to MinIO (via mc) and create latest.json
       # ----------------------
       - name: Upload artifacts to MinIO with cicd_tool
         working-directory: GitLite/cicd_tool
+        env:
+          PUBLISH_PLATFORM: ${{ matrix.updater_platform }}
         run: |
           uv sync
           uv run main.py

.gitignore

@@ -5,3 +5,5 @@
 .idea
 .DS_Store
 ~
+.codex*
+target

README.md

@@ -1,45 +1,51 @@
-# Tauri Git Lite
+<div align="center">
 
-Eine kleine Git-Desktop-App mit Tauri, Rust und Svelte.
+<img src="public/splash-icon.png" alt="Gitty Logo" width="360">
 
-## Funktionen
+# Gitty
 
-- Repository per lokalem Pfad öffnen
-- aktuellen Branch, Upstream, Ahead/Behind und Arbeitsbaumstatus anzeigen
-- Branches auflisten und auschecken
-- Branches in den aktuellen Branch mergen
-- Commit-History mit geänderten Dateien anzeigen
-- Explorer-Ansicht mit Ordnerbaum sowie getrackten und ungetrackten Dateien
-- Datei- und Ordner-History direkt aus dem Explorer anzeigen
-- einzelne Dateien stagen, unstagen und wiederherstellen
-- einzelne Dateien oder ganze Ordner aus einem History-Commit wiederherstellen
-- aktuellen Branch auf einen ausgewählten Commit zurücksetzen
-- Commit mit Message erstellen
-- Pull mit Fast-Forward-Strategie
-- Push auf den konfigurierten Upstream
+**A lightweight, modern Git client built with Tauri.**
 
-## Entwicklung
+Fast, simple, and designed for developers who want a clean Git experience without unnecessary complexity.
 
-```powershell
-npm install
-npm run tauri:dev
-```
+</div>
 
-Frontend allein:
+---
 
-```powershell
-npm run dev
-```
+## ✨ Features
 
-Checks:
+- 🚀 Fast native performance
+- 🌿 Branch management
+- 📝 Commit history
+- 🔄 Pull, Push & Fetch
+- 🔀 Merge & Rebase
+- 📦 Repository management
+- 🎨 Modern and intuitive UI
 
-```powershell
-npm run check
-npm run build
-cd src-tauri
-cargo check
-```
+---
 
-## Hinweis
+## 📸 Preview
 
-Die App nutzt das lokal installierte `git` CLI. Ein Repository muss daher bereits auf der Maschine vorhanden sein, und Push/Pull verwenden die Credentials, die Git lokal kennt.
+> Screenshots coming soon.
+
+---
+
+## 🛠️ Built With
+
+- **Tauri**
+- **Rust**
+- **Svelte**
+
+---
+
+## 🚧 Status
+
+Gitty is currently under active development.
+
+Contributions, feedback and feature requests are always welcome!
+
+---
+
+## 📄 License
+
+MIT License

cicd_tool/main.py

@@ -4,14 +4,14 @@ import json
 import os
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Iterable, List, Optional
+from typing import Any, Iterable, List, NamedTuple, Optional
 from urllib.parse import urlparse
 
 from minio import Minio
 from minio.error import S3Error
 
 
-# cicd_tool lives inside the GitLite repo, so its parent dir is the app root.
+# cicd_tool lives inside the Gitty repo, so its parent dir is the app root.
 PROJECT_DIR = Path(__file__).resolve().parent.parent
 ARTIFACT_ROOT = PROJECT_DIR / "src-tauri" / "target" / "release" / "bundle"
 
@@ -20,6 +20,11 @@ class ConfigurationError(RuntimeError):
     """Raised when required configuration values are missing or invalid."""
 
 
+class PublishTarget(NamedTuple):
+    bucket_name: str
+    app_dir: str
+
+
 def _resolve_version(version_arg: Optional[str]) -> str:
     """Resolve the version to publish, falling back to tauri.conf.json."""
     if version_arg and version_arg.lower() not in {"auto"}:
@@ -115,23 +120,57 @@ def _ensure_bucket(client: Minio, bucket_name: str) -> None:
 
 def _collect_artifacts() -> List[Path]:
     artifacts: List[Path] = []
-    for directory in (
-        ARTIFACT_ROOT / "msi",
-        ARTIFACT_ROOT / "nsis",
-        ARTIFACT_ROOT / "app",
-    ):
+    bundle_dirs = {
+        ARTIFACT_ROOT / "msi": (".msi", ".sig"),
+        ARTIFACT_ROOT / "nsis": (".exe", ".sig"),
+        ARTIFACT_ROOT / "appimage": (".appimage", ".sig"),
+        ARTIFACT_ROOT / "deb": (".deb", ".sig"),
+        ARTIFACT_ROOT / "rpm": (".rpm", ".sig"),
+        ARTIFACT_ROOT / "app": (".dmg", ".zip", ".sig"),
+    }
+    for directory, suffixes in bundle_dirs.items():
         if directory.exists():
-            artifacts.extend(p for p in directory.rglob("*") if p.is_file())
+            artifacts.extend(
+                p
+                for p in directory.iterdir()
+                if p.is_file() and p.suffix.lower() in suffixes
+            )
     return artifacts
 
 
-def _select_primary_artifact(artifacts: Iterable[Path]) -> Optional[Path]:
-    priority = (".exe", ".msi", ".zip", ".dmg")
+def _select_primary_artifact(
+    artifacts: Iterable[Path], platform: Optional[str] = None
+) -> Optional[Path]:
+    artifact_list = list(artifacts)
+    priorities = {
+        "windows-x86_64": (".exe", ".msi"),
+        "linux-x86_64": (".appimage", ".deb", ".rpm"),
+        "darwin-x86_64": (".dmg", ".zip"),
+        "darwin-aarch64": (".dmg", ".zip"),
+    }
+    priority = priorities.get(platform or "", ())
+    priority += (".exe", ".msi", ".appimage", ".deb", ".rpm", ".zip", ".dmg")
     for ext in priority:
-        for artifact in artifacts:
+        for artifact in artifact_list:
             if artifact.suffix.lower() == ext:
                 return artifact
-    return next(iter(artifacts), None)
+    return next(
+        (artifact for artifact in artifact_list if artifact.suffix != ".sig"), None
+    )
+
+
+def _infer_platform(artifact: Path) -> str:
+    suffix = artifact.suffix.lower()
+    if suffix in {".exe", ".msi"}:
+        return "windows-x86_64"
+    if suffix in {".appimage", ".deb", ".rpm"}:
+        return "linux-x86_64"
+    if suffix in {".dmg", ".zip"}:
+        return "darwin-x86_64"
+    raise ConfigurationError(
+        f"Cannot infer updater platform from artifact: {artifact.name}. "
+        "Set PUBLISH_PLATFORM explicitly."
+    )
 
 
 def _read_signature(artifact: Path) -> str:
@@ -145,16 +184,55 @@ def _read_signature(artifact: Path) -> str:
     raise FileNotFoundError(f"Signature not found for {artifact.name}")
 
 
-def _build_latest_json(
+def _build_artifact_url(
     version: str,
     primary_artifact: Path,
-    signature: str,
     artifact_base_url: str,
     app_dir: str,
 ) -> str:
     base_url = artifact_base_url.rstrip("/")
     path_parts = [app_dir.strip("/"), version, primary_artifact.name]
-    artifact_url = "/".join([base_url, *filter(None, path_parts)])
+    return "/".join([base_url, *filter(None, path_parts)])
+
+
+def _read_existing_latest_json(
+    client: Minio, bucket_name: str
+) -> Optional[dict[str, Any]]:
+    try:
+        response = client.get_object(bucket_name, "latest.json")
+    except S3Error as exc:
+        if exc.code in {"NoSuchKey", "NoSuchObject"}:
+            return None
+        raise
+
+    try:
+        payload = json.loads(response.read().decode("utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ConfigurationError("Existing latest.json is invalid JSON") from exc
+    finally:
+        response.close()
+        response.release_conn()
+
+    if not isinstance(payload, dict):
+        raise ConfigurationError("Existing latest.json must be a JSON object")
+    return payload
+
+
+def _build_latest_payload(
+    version: str,
+    platform: str,
+    primary_artifact: Path,
+    signature: str,
+    artifact_base_url: str,
+    app_dir: str,
+    existing_payload: Optional[dict[str, Any]] = None,
+) -> dict[str, Any]:
+    artifact_url = _build_artifact_url(
+        version=version,
+        primary_artifact=primary_artifact,
+        artifact_base_url=artifact_base_url,
+        app_dir=app_dir,
+    )
 
     pub_date = (
         datetime.now(timezone.utc)
@@ -163,18 +241,92 @@ def _build_latest_json(
         .replace("+00:00", "Z")
     )
 
-    latest_payload = {
-        "version": version,
-        "pub_date": pub_date,
-        "notes": os.environ.get("RELEASE_NOTES", "Automated release"),
-        "platforms": {
-            "windows-x86_64": {
+    platforms: dict[str, Any] = {}
+    existing_notes = None
+    if existing_payload and existing_payload.get("version") == version:
+        existing_platforms = existing_payload.get("platforms")
+        if isinstance(existing_platforms, dict):
+            platforms.update(existing_platforms)
+        existing_notes = existing_payload.get("notes")
+
+    platforms[platform] = {
         "signature": signature,
         "url": artifact_url,
     }
-        },
+
+    return {
+        "version": version,
+        "pub_date": pub_date,
+        "notes": os.environ.get("RELEASE_NOTES")
+        or existing_notes
+        or "Automated release",
+        "platforms": platforms,
     }
-    return json.dumps(latest_payload, separators=(",", ":"))
+
+
+def _parse_publish_targets(primary_bucket: str, primary_app_dir: str) -> list[PublishTarget]:
+    targets = [PublishTarget(primary_bucket, primary_app_dir)]
+    raw_legacy_targets = os.environ.get("LEGACY_UPDATE_TARGETS", "gitlite:gitlite")
+
+    for raw_target in raw_legacy_targets.split(","):
+        value = raw_target.strip()
+        if not value:
+            continue
+
+        if ":" in value:
+            bucket_name, app_dir = value.split(":", 1)
+        else:
+            bucket_name = value
+            app_dir = value
+
+        target = PublishTarget(bucket_name.strip().lower(), app_dir.strip("/"))
+        if target.bucket_name and target not in targets:
+            targets.append(target)
+
+    return targets
+
+
+def _publish_target(
+    client: Minio,
+    target: PublishTarget,
+    version: str,
+    platform: str,
+    artifacts: Iterable[Path],
+    primary_artifact: Path,
+    signature: str,
+    artifact_base_url: str,
+) -> None:
+    _ensure_bucket(client, target.bucket_name)
+    existing_latest_json = _read_existing_latest_json(client, target.bucket_name)
+    latest_payload = _build_latest_payload(
+        version=version,
+        platform=platform,
+        primary_artifact=primary_artifact,
+        signature=signature,
+        artifact_base_url=artifact_base_url,
+        app_dir=target.app_dir,
+        existing_payload=existing_latest_json,
+    )
+    latest_json = json.dumps(latest_payload, separators=(",", ":"))
+
+    for artifact in artifacts:
+        object_segments = [part for part in (version, artifact.name) if part]
+        object_name = "/".join(object_segments)
+        client.fput_object(target.bucket_name, object_name, str(artifact))
+        print(f"Uploaded {artifact.name} -> s3://{target.bucket_name}/{object_name}")
+
+    latest_bytes = latest_json.encode("utf-8")
+    client.put_object(
+        bucket_name=target.bucket_name,
+        object_name="latest.json",
+        data=io.BytesIO(latest_bytes),
+        length=len(latest_bytes),
+        content_type="application/json",
+    )
+    print(
+        f"Uploaded latest.json for {platform} -> "
+        f"s3://{target.bucket_name}/latest.json"
+    )
 
 
 def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
@@ -184,9 +336,10 @@ def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
         raise ConfigurationError("ARTIFACT_BASE_URL is required")
 
     # S3/MinIO bucket names must be lowercase, so normalise regardless of how the
-    # S3_BUCKET variable is cased (e.g. "GitLite" -> "gitlite").
-    bucket_name = (os.environ.get("S3_BUCKET") or "gitlite").lower()
-    bucket_prefix = (app_dir or os.environ.get("APP_DIR") or "gitlite").strip("/")
+    # S3_BUCKET variable is cased (e.g. "Gitty" -> "gitty").
+    bucket_name = (os.environ.get("S3_BUCKET") or "gitty").lower()
+    bucket_prefix = (app_dir or os.environ.get("APP_DIR") or "gitty").strip("/")
+    publish_targets = _parse_publish_targets(bucket_name, bucket_prefix)
 
     artifacts = _collect_artifacts()
     if not artifacts:
@@ -194,49 +347,48 @@ def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
             "No release artifacts found in src-tauri/target/release/bundle."
         )
 
-    primary = _select_primary_artifact(artifacts)
+    publish_platform = os.environ.get("PUBLISH_PLATFORM") or os.environ.get(
+        "UPDATER_PLATFORM"
+    )
+    primary = _select_primary_artifact(artifacts, publish_platform)
     if not primary:
         raise FileNotFoundError("Unable to determine primary artifact to publish.")
 
+    platform = publish_platform or _infer_platform(primary)
     signature = _read_signature(primary)
 
-    latest_json = _build_latest_json(
+    client = _create_minio_client()
+
+    local_dist_dir = PROJECT_DIR / "dist"
+    local_dist_dir.mkdir(parents=True, exist_ok=True)
+    latest_json_path = local_dist_dir / "latest.json"
+    latest_payload = _build_latest_payload(
         version=resolved_version,
+        platform=platform,
         primary_artifact=primary,
         signature=signature,
         artifact_base_url=artifact_base_url,
         app_dir=bucket_prefix,
     )
-
-    local_dist_dir = PROJECT_DIR / "dist"
-    local_dist_dir.mkdir(parents=True, exist_ok=True)
-    latest_json_path = local_dist_dir / "latest.json"
+    latest_json = json.dumps(latest_payload, separators=(",", ":"))
     latest_json_path.write_text(latest_json + "\n", encoding="utf-8")
 
-    client = _create_minio_client()
-    _ensure_bucket(client, bucket_name)
-
-    for artifact in artifacts:
-        object_segments = [part for part in (resolved_version, artifact.name) if part]
-        object_name = "/".join(object_segments)
-        client.fput_object(bucket_name, object_name, str(artifact))
-        print(f"Uploaded {artifact.name} -> s3://{bucket_name}/{object_name}")
-
-    latest_object_name = "latest.json"
-    latest_bytes = latest_json.encode("utf-8")
-    client.put_object(
-        bucket_name=bucket_name,
-        object_name=latest_object_name,
-        data=io.BytesIO(latest_bytes),
-        length=len(latest_bytes),
-        content_type="application/json",
+    for target in publish_targets:
+        _publish_target(
+            client=client,
+            target=target,
+            version=resolved_version,
+            platform=platform,
+            artifacts=artifacts,
+            primary_artifact=primary,
+            signature=signature,
+            artifact_base_url=artifact_base_url,
         )
-    print(f"Uploaded latest.json -> s3://{bucket_name}/{latest_object_name}")
 
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
-        description="Upload GitLite release artifacts to MinIO."
+        description="Upload Gitty release artifacts to MinIO."
     )
     parser.add_argument(
         "-v",
@@ -247,7 +399,7 @@ if __name__ == "__main__":
     parser.add_argument(
         "--app-dir",
         default=None,
-        help="App directory prefix inside the bucket (defaults to gitlite).",
+        help="App directory prefix inside the bucket (defaults to gitty).",
     )
     args = parser.parse_args()
 

index.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Tauri Git Lite</title>
+    <title>Gitty</title>
   </head>
   <body>
     <div id="app"></div>

package-lock.json

@@ -1,12 +1,12 @@
 {
-  "name": "tauri-git-lite",
-  "version": "0.0.3",
+  "name": "gitty",
+  "version": "0.200.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "tauri-git-lite",
-      "version": "0.0.3",
+      "name": "gitty",
+      "version": "0.200.10",
       "dependencies": {
         "@lucide/svelte": "^1.21.0",
         "@tailwindcss/vite": "^4.3.1",

package.json

@@ -1,11 +1,12 @@
 {
-  "name": "git-lite",
-  "version": "0.0.3",
+  "name": "gitty",
+  "version": "0.200.10",
   "private": true,
   "type": "module",
   "scripts": {
     "dev": "vite --host 127.0.0.1",
     "build": "vite build",
+    "icons": "node scripts/generate-app-icons.mjs",
     "preview": "vite preview --host 127.0.0.1",
     "tauri": "tauri",
     "tauri:dev": "tauri dev",

public/splashscreen.html

@@ -0,0 +1,241 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Gitty</title>
+    <style>
+      :root {
+        color-scheme: dark;
+        --ink: #f3f5ff;
+        --muted: #9aa3c5;
+        --purple: #9b70ff;
+        --orange: #ff6d26;
+        --panel: rgba(15, 18, 31, 0.9);
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      * {
+        box-sizing: border-box;
+      }
+
+      html,
+      body {
+        width: 100%;
+        height: 100%;
+        margin: 0;
+        overflow: hidden;
+        background: #050712;
+      }
+
+      body {
+        display: grid;
+        place-items: center;
+        background:
+          radial-gradient(circle at 50% 38%, rgba(137, 92, 255, 0.22), transparent 36%),
+          linear-gradient(135deg, #050712 0%, #080b16 48%, #140b18 100%);
+      }
+
+      .grid {
+        position: fixed;
+        inset: 0;
+        opacity: 0.28;
+        background-image:
+          linear-gradient(rgba(151, 118, 255, 0.12) 1px, transparent 1px),
+          linear-gradient(90deg, rgba(255, 109, 38, 0.08) 1px, transparent 1px);
+        background-size: 42px 42px;
+        mask-image: radial-gradient(circle at center, black 0%, transparent 70%);
+        animation: grid-drift 10s linear infinite;
+      }
+
+      .splash {
+        position: relative;
+        display: grid;
+        justify-items: center;
+        gap: 16px;
+        width: 100vw;
+        height: 100vh;
+        align-content: center;
+        padding: 32px;
+        border: 0;
+        border-radius: 0;
+        background:
+          linear-gradient(180deg, rgba(23, 26, 43, 0.92), rgba(12, 15, 27, 0.94)),
+          var(--panel);
+        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.04);
+        overflow: hidden;
+      }
+
+      .mark {
+        position: relative;
+        display: grid;
+        place-items: center;
+        width: 174px;
+        height: 174px;
+        isolation: isolate;
+      }
+
+      .halo {
+        position: absolute;
+        inset: 10px;
+        border: 1px solid rgba(151, 118, 255, 0.25);
+        border-radius: 36px;
+        transform: rotate(45deg);
+        animation: halo-breathe 2.4s ease-in-out infinite;
+      }
+
+      .halo.secondary {
+        inset: 25px;
+        border-color: rgba(255, 109, 38, 0.28);
+        animation-direction: reverse;
+      }
+
+      .traces {
+        position: absolute;
+        inset: -18px;
+        width: 210px;
+        height: 210px;
+        overflow: visible;
+      }
+
+      .trace {
+        fill: none;
+        stroke-width: 3;
+        stroke-linecap: round;
+        stroke-dasharray: 165;
+        stroke-dashoffset: 165;
+        filter: drop-shadow(0 0 8px rgba(151, 118, 255, 0.55));
+        animation: trace-draw 2.6s ease-in-out infinite;
+      }
+
+      .trace.main {
+        stroke: var(--purple);
+      }
+
+      .trace.branch {
+        stroke: var(--orange);
+        animation-delay: 0.28s;
+      }
+
+      .trace.base {
+        stroke: rgba(255, 255, 255, 0.42);
+        stroke-dasharray: 128;
+        stroke-dashoffset: 128;
+        animation-delay: 0.55s;
+      }
+
+      .icon {
+        position: relative;
+        z-index: 1;
+        width: 136px;
+        height: 136px;
+        object-fit: contain;
+        filter:
+          drop-shadow(0 18px 24px rgba(0, 0, 0, 0.55))
+          drop-shadow(0 0 18px rgba(151, 118, 255, 0.3));
+        animation: icon-float 2.4s ease-in-out infinite;
+      }
+
+      .copy {
+        position: relative;
+        display: grid;
+        gap: 4px;
+        justify-items: center;
+        text-align: center;
+      }
+
+      .copy strong {
+        color: var(--ink);
+        font-size: 22px;
+        font-weight: 900;
+        line-height: 1;
+      }
+
+      .copy span {
+        color: var(--muted);
+        font-size: 12.5px;
+        font-weight: 700;
+      }
+
+      .bar {
+        position: relative;
+        width: 230px;
+        height: 4px;
+        margin-top: 2px;
+        overflow: hidden;
+        border-radius: 999px;
+        background: rgba(151, 118, 255, 0.14);
+      }
+
+      .bar span {
+        position: absolute;
+        inset: 0;
+        width: 46%;
+        border-radius: inherit;
+        background: linear-gradient(90deg, transparent, var(--purple) 40%, var(--orange) 74%, transparent);
+        box-shadow: 0 0 16px rgba(255, 109, 38, 0.32);
+        animation: bar-slide 1.35s ease-in-out infinite;
+      }
+
+      @keyframes grid-drift {
+        to { transform: translate3d(42px, 42px, 0); }
+      }
+
+      @keyframes icon-float {
+        0%, 100% { transform: translateY(0) scale(1); }
+        50% { transform: translateY(-5px) scale(1.015); }
+      }
+
+      @keyframes halo-breathe {
+        0%, 100% { opacity: 0.35; transform: rotate(45deg) scale(0.95); }
+        50% { opacity: 0.8; transform: rotate(45deg) scale(1.04); }
+      }
+
+      @keyframes trace-draw {
+        0% { stroke-dashoffset: 165; opacity: 0; }
+        36% { opacity: 1; }
+        64%, 100% { stroke-dashoffset: 0; opacity: 0.72; }
+      }
+
+      @keyframes bar-slide {
+        0% { transform: translateX(-120%); }
+        100% { transform: translateX(320%); }
+      }
+
+      @media (prefers-reduced-motion: reduce) {
+        .grid,
+        .halo,
+        .trace,
+        .icon,
+        .bar span {
+          animation: none;
+        }
+
+        .trace {
+          stroke-dashoffset: 0;
+          opacity: 0.72;
+        }
+      }
+    </style>
+  </head>
+  <body>
+    <div class="grid" aria-hidden="true"></div>
+    <main class="splash" role="status" aria-live="polite">
+      <div class="mark" aria-hidden="true">
+        <span class="halo"></span>
+        <span class="halo secondary"></span>
+        <svg class="traces" viewBox="0 0 220 220">
+          <path class="trace main" d="M28 154 C72 114, 88 108, 110 110 S156 116, 192 68" />
+          <path class="trace branch" d="M62 74 C100 88, 126 124, 158 166" />
+          <path class="trace base" d="M46 180 L174 180" />
+        </svg>
+        <img class="icon" src="/splash-icon.png" alt="" />
+      </div>
+      <div class="copy">
+        <strong>Gitty</strong>
+        <span>Starting workspace</span>
+      </div>
+      <div class="bar" aria-hidden="true"><span></span></div>
+    </main>
+  </body>
+</html>

scripts/generate-app-icons.mjs

@@ -0,0 +1,266 @@
+import { Buffer } from "node:buffer";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { deflateSync, inflateSync } from "node:zlib";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const iconsDir = join(root, "src-tauri", "icons");
+const sourcePath = join(iconsDir, "GitCat_org.png");
+
+const pngSizes = [32, 64, 128, 512];
+const icoSizes = [16, 24, 32, 48, 64, 128, 256];
+
+function decodePng(buffer) {
+  if (buffer.subarray(0, 8).toString("hex") !== "89504e470d0a1a0a") {
+    throw new Error("Source icon must be a PNG file.");
+  }
+
+  let width = 0;
+  let height = 0;
+  const idatChunks = [];
+
+  for (let offset = 8; offset < buffer.length; ) {
+    const length = buffer.readUInt32BE(offset);
+    const type = buffer.subarray(offset + 4, offset + 8).toString("ascii");
+    const dataStart = offset + 8;
+    const dataEnd = dataStart + length;
+    const data = buffer.subarray(dataStart, dataEnd);
+
+    if (type === "IHDR") {
+      width = data.readUInt32BE(0);
+      height = data.readUInt32BE(4);
+      if (data[8] !== 8 || data[9] !== 6) {
+        throw new Error("Source icon must be an 8-bit RGBA PNG.");
+      }
+    } else if (type === "IDAT") {
+      idatChunks.push(data);
+    } else if (type === "IEND") {
+      break;
+    }
+
+    offset = dataEnd + 4;
+  }
+
+  const stride = width * 4;
+  const raw = inflateSync(Buffer.concat(idatChunks));
+  const rgba = Buffer.alloc(width * height * 4);
+
+  for (let y = 0; y < height; y += 1) {
+    const rowStart = y * (stride + 1);
+    const filter = raw[rowStart];
+    const input = raw.subarray(rowStart + 1, rowStart + 1 + stride);
+    const priorOffset = (y - 1) * stride;
+    const outputOffset = y * stride;
+
+    for (let x = 0; x < stride; x += 1) {
+      const left = x >= 4 ? rgba[outputOffset + x - 4] : 0;
+      const up = y > 0 ? rgba[priorOffset + x] : 0;
+      const upLeft = y > 0 && x >= 4 ? rgba[priorOffset + x - 4] : 0;
+      let value = input[x];
+
+      if (filter === 1) value += left;
+      else if (filter === 2) value += up;
+      else if (filter === 3) value += Math.floor((left + up) / 2);
+      else if (filter === 4) value += paeth(left, up, upLeft);
+      else if (filter !== 0) throw new Error(`Unsupported PNG filter: ${filter}`);
+
+      rgba[outputOffset + x] = value & 0xff;
+    }
+  }
+
+  return { width, height, rgba };
+}
+
+function paeth(left, up, upLeft) {
+  const estimate = left + up - upLeft;
+  const distanceLeft = Math.abs(estimate - left);
+  const distanceUp = Math.abs(estimate - up);
+  const distanceUpLeft = Math.abs(estimate - upLeft);
+
+  if (distanceLeft <= distanceUp && distanceLeft <= distanceUpLeft) return left;
+  if (distanceUp <= distanceUpLeft) return up;
+  return upLeft;
+}
+
+function visibleSquare(image, alphaThreshold = 8) {
+  let minX = image.width;
+  let minY = image.height;
+  let maxX = -1;
+  let maxY = -1;
+
+  for (let y = 0; y < image.height; y += 1) {
+    for (let x = 0; x < image.width; x += 1) {
+      const alpha = image.rgba[(y * image.width + x) * 4 + 3];
+      if (alpha > alphaThreshold) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+      }
+    }
+  }
+
+  if (maxX < 0 || maxY < 0) {
+    throw new Error("Source icon has no visible pixels.");
+  }
+
+  const visibleWidth = maxX - minX + 1;
+  const visibleHeight = maxY - minY + 1;
+  const side = Math.max(visibleWidth, visibleHeight);
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  const left = Math.max(0, Math.min(image.width - side, Math.round(centerX - side / 2)));
+  const top = Math.max(0, Math.min(image.height - side, Math.round(centerY - side / 2)));
+
+  return { left, top, side };
+}
+
+function resizePng(image, crop, size) {
+  const rgba = Buffer.alloc(size * size * 4);
+  const scale = crop.side / size;
+
+  for (let y = 0; y < size; y += 1) {
+    for (let x = 0; x < size; x += 1) {
+      const sourceX = crop.left + (x + 0.5) * scale - 0.5;
+      const sourceY = crop.top + (y + 0.5) * scale - 0.5;
+      const pixel = sampleBilinear(image, sourceX, sourceY);
+      const offset = (y * size + x) * 4;
+      rgba[offset] = pixel.r;
+      rgba[offset + 1] = pixel.g;
+      rgba[offset + 2] = pixel.b;
+      rgba[offset + 3] = pixel.a;
+    }
+  }
+
+  return encodePng(size, size, rgba);
+}
+
+function sampleBilinear(image, x, y) {
+  const x0 = Math.max(0, Math.min(image.width - 1, Math.floor(x)));
+  const y0 = Math.max(0, Math.min(image.height - 1, Math.floor(y)));
+  const x1 = Math.max(0, Math.min(image.width - 1, x0 + 1));
+  const y1 = Math.max(0, Math.min(image.height - 1, y0 + 1));
+  const tx = x - x0;
+  const ty = y - y0;
+  const top = mixPixels(getPixel(image, x0, y0), getPixel(image, x1, y0), tx);
+  const bottom = mixPixels(getPixel(image, x0, y1), getPixel(image, x1, y1), tx);
+
+  return mixPixels(top, bottom, ty);
+}
+
+function getPixel(image, x, y) {
+  const offset = (y * image.width + x) * 4;
+  return {
+    r: image.rgba[offset],
+    g: image.rgba[offset + 1],
+    b: image.rgba[offset + 2],
+    a: image.rgba[offset + 3],
+  };
+}
+
+function mixPixels(a, b, t) {
+  return {
+    r: Math.round(a.r + (b.r - a.r) * t),
+    g: Math.round(a.g + (b.g - a.g) * t),
+    b: Math.round(a.b + (b.b - a.b) * t),
+    a: Math.round(a.a + (b.a - a.a) * t),
+  };
+}
+
+const crcTable = new Uint32Array(256);
+for (let n = 0; n < 256; n += 1) {
+  let c = n;
+  for (let k = 0; k < 8; k += 1) {
+    c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  }
+  crcTable[n] = c >>> 0;
+}
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function chunk(type, payload) {
+  const typeBytes = Buffer.from(type);
+  const out = Buffer.alloc(12 + payload.length);
+  out.writeUInt32BE(payload.length, 0);
+  typeBytes.copy(out, 4);
+  payload.copy(out, 8);
+  out.writeUInt32BE(crc32(Buffer.concat([typeBytes, payload])), out.length - 4);
+  return out;
+}
+
+function encodePng(width, height, rgba) {
+  const header = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 6;
+
+  const raw = Buffer.alloc((width * 4 + 1) * height);
+  for (let y = 0; y < height; y += 1) {
+    const rowStart = y * (width * 4 + 1);
+    raw[rowStart] = 0;
+    rgba.copy(raw, rowStart + 1, y * width * 4, (y + 1) * width * 4);
+  }
+
+  return Buffer.concat([
+    header,
+    chunk("IHDR", ihdr),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+function makeIco(images) {
+  const header = Buffer.alloc(6);
+  header.writeUInt16LE(0, 0);
+  header.writeUInt16LE(1, 2);
+  header.writeUInt16LE(images.length, 4);
+
+  const entries = Buffer.alloc(images.length * 16);
+  let offset = 6 + images.length * 16;
+
+  images.forEach((image, index) => {
+    const entry = index * 16;
+    entries[entry] = image.size >= 256 ? 0 : image.size;
+    entries[entry + 1] = image.size >= 256 ? 0 : image.size;
+    entries[entry + 2] = 0;
+    entries[entry + 3] = 0;
+    entries.writeUInt16LE(1, entry + 4);
+    entries.writeUInt16LE(32, entry + 6);
+    entries.writeUInt32LE(image.png.length, entry + 8);
+    entries.writeUInt32LE(offset, entry + 12);
+    offset += image.png.length;
+  });
+
+  return Buffer.concat([header, entries, ...images.map((image) => image.png)]);
+}
+
+mkdirSync(iconsDir, { recursive: true });
+
+const source = decodePng(readFileSync(sourcePath));
+const crop = visibleSquare(source);
+const rendered = new Map(
+  [...new Set([...pngSizes, ...icoSizes])].map((size) => [size, resizePng(source, crop, size)]),
+);
+
+writeFileSync(join(iconsDir, "32x32.png"), rendered.get(32));
+writeFileSync(join(iconsDir, "64x64.png"), rendered.get(64));
+writeFileSync(join(iconsDir, "128x128.png"), rendered.get(128));
+writeFileSync(join(iconsDir, "icon.png"), rendered.get(512));
+writeFileSync(join(iconsDir, "icon.ico"), makeIco(icoSizes.map((size) => ({ size, png: rendered.get(size) }))));
+
+console.log(`Read ${join("src-tauri", "icons", "GitCat_org.png")}`);
+console.log(`Cropped visible icon area to ${crop.side}x${crop.side} at ${crop.left},${crop.top}`);
+console.log(`Wrote ${join("src-tauri", "icons", "32x32.png")}`);
+console.log(`Wrote ${join("src-tauri", "icons", "64x64.png")}`);
+console.log(`Wrote ${join("src-tauri", "icons", "128x128.png")}`);
+console.log(`Wrote ${join("src-tauri", "icons", "icon.png")}`);
+console.log(`Wrote ${join("src-tauri", "icons", "icon.ico")} (${icoSizes.length} sizes)`);

scripts/generate-icon.mjs

@@ -1,3 +1,7 @@
+import "./generate-app-icons.mjs";
+
+process.exit(0);
+
 import { Buffer } from "node:buffer";
 import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";

src-tauri/Cargo.toml

@@ -1,20 +1,51 @@
 [package]
-name = "tauri_git_lite"
+name = "gitty"
 version = "0.1.0"
 description = "Rust backend for a lightweight Git desktop client"
-edition = "2021"
-rust-version = "1.77"
+edition = "2024"
+rust-version = "1.88"
 build = "build.rs"
 
+[workspace]
+members = [".", "crates/commit_ai"]
+
+[workspace.package]
+edition = "2024"
+
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 tauri = { version = "2", features = [] }
 tauri-plugin-dialog = "=2.7.0"
+tauri-plugin-aptabase = "1.0"
 keyring = { version = "3", features = ["apple-native", "windows-native", "async-secret-service", "crypto-rust", "async-io"] }
+commit_ai = { path = "crates/commit_ai" }
+tokio = "1.52.3"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
 
 [target.'cfg(not(any(target_os = "android", target_os = "ios")))'.dependencies]
+tauri-plugin-single-instance = "2"
 tauri-plugin-updater = "2"
+
+# ── Build profiles ───────────────────────────────────────────────────────────
+# Dev: keep incremental compilation and emit only line-table debug info instead
+# of full debuginfo. This cuts link time noticeably (linking is the slow part of
+# a `tauri dev` recompile) while still giving panic backtraces with line numbers.
+[profile.dev]
+incremental = true
+debug = "line-tables-only"
+
+# Optimize third-party dependencies once (they are cached), so the running dev
+# build is snappy without slowing down rebuilds of our own crate.
+[profile.dev.package."*"]
+opt-level = 2
+
+# Release: smaller binary (also shrinks the auto-updater download) without
+# regressing runtime performance of the code-search feature.
+[profile.release]
+opt-level = 3
+lto = "thin"
+codegen-units = 1
+strip = true

src-tauri/build.rs

@@ -1,3 +1,4 @@
 fn main() {
+    println!("cargo:rerun-if-env-changed=APTABASE_KEY");
     tauri_build::build();
 }

src-tauri/capabilities/default.json

@@ -11,6 +11,7 @@
     "core:window:allow-close",
     "core:window:allow-is-maximized",
     "core:window:allow-start-dragging",
-    "dialog:allow-open"
+    "dialog:allow-open",
+    "aptabase:allow-track-event"
   ]
 }

src-tauri/crates/commit_ai/Cargo.toml

@@ -0,0 +1,12 @@
+
+[package]
+name = "commit_ai"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+mistralrs = "0.8"
+tokio = { version = "1", features = ["sync"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }

src-tauri/crates/commit_ai/src/cloud.rs

@@ -0,0 +1,222 @@
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{build_messages, looks_like_diff_echo, sanitize_message};
+
+// Generous sizing so a detailed body with bullet points isn't cut off.
+const DEFAULT_MAX_TOKENS: u32 = 1500;
+// Without a timeout, a hanging endpoint would permanently block the "AI" button.
+const REQUEST_TIMEOUT: Duration = Duration::from_secs(60);
+
+fn http_client() -> Result<reqwest::Client, String> {
+    reqwest::Client::builder()
+        .timeout(REQUEST_TIMEOUT)
+        .build()
+        .map_err(|err| format!("Could not create HTTP client: {err}"))
+}
+
+#[derive(Serialize)]
+struct OpenAiMessage {
+    role: &'static str,
+    content: String,
+}
+
+#[derive(Serialize)]
+struct OpenAiRequest {
+    model: String,
+    messages: Vec<OpenAiMessage>,
+    temperature: f32,
+}
+
+#[derive(Deserialize)]
+struct OpenAiResponseMessage {
+    content: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct OpenAiChoice {
+    message: OpenAiResponseMessage,
+}
+
+#[derive(Deserialize)]
+struct OpenAiResponse {
+    #[serde(default)]
+    choices: Vec<OpenAiChoice>,
+}
+
+async fn openai_compatible_request(
+    url: String,
+    bearer: Option<&str>,
+    model: &str,
+    diff: &str,
+    notes: Option<&str>,
+) -> Result<String, String> {
+    let (system, user) = build_messages(diff, notes)?;
+    let body = OpenAiRequest {
+        model: model.to_string(),
+        messages: vec![
+            OpenAiMessage {
+                role: "system",
+                content: system,
+            },
+            OpenAiMessage {
+                role: "user",
+                content: user,
+            },
+        ],
+        temperature: 0.3,
+    };
+
+    let client = http_client()?;
+    let mut request = client.post(url).json(&body);
+    if let Some(key) = bearer.filter(|k| !k.trim().is_empty()) {
+        request = request.bearer_auth(key);
+    }
+
+    let response = request
+        .send()
+        .await
+        .map_err(|err| format!("Request to the AI model failed: {err}"))?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|err| format!("Could not read response: {err}"))?;
+
+    if !status.is_success() {
+        return Err(format!("API error ({status}): {text}"));
+    }
+
+    let parsed: OpenAiResponse =
+        serde_json::from_str(&text).map_err(|err| format!("Could not process response: {err}"))?;
+
+    let message = parsed
+        .choices
+        .into_iter()
+        .next()
+        .and_then(|choice| choice.message.content)
+        .map(|content| sanitize_message(&content))
+        .filter(|content| !content.is_empty())
+        .ok_or_else(|| "The model did not return a response.".to_string())?;
+
+    if looks_like_diff_echo(&message) {
+        return Err("The model returned the diff instead of a commit message.".to_string());
+    }
+    Ok(message)
+}
+
+pub async fn generate_openai(
+    api_key: &str,
+    model: &str,
+    diff: &str,
+    notes: Option<&str>,
+) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("OpenAI API key is missing.".to_string());
+    }
+    openai_compatible_request(
+        "https://api.openai.com/v1/chat/completions".to_string(),
+        Some(api_key),
+        model,
+        diff,
+        notes,
+    )
+    .await
+}
+
+pub async fn generate_custom(
+    base_url: &str,
+    api_key: Option<&str>,
+    model: &str,
+    diff: &str,
+    notes: Option<&str>,
+) -> Result<String, String> {
+    if base_url.trim().is_empty() {
+        return Err("Endpoint URL is missing.".to_string());
+    }
+    let url = format!("{}/chat/completions", base_url.trim_end_matches('/'));
+    openai_compatible_request(url, api_key, model, diff, notes).await
+}
+
+#[derive(Serialize)]
+struct AnthropicMessage {
+    role: &'static str,
+    content: String,
+}
+
+#[derive(Serialize)]
+struct AnthropicRequest {
+    model: String,
+    max_tokens: u32,
+    system: String,
+    messages: Vec<AnthropicMessage>,
+}
+
+#[derive(Deserialize)]
+struct AnthropicContentBlock {
+    #[serde(default)]
+    text: Option<String>,
+}
+
+#[derive(Deserialize)]
+struct AnthropicResponse {
+    #[serde(default)]
+    content: Vec<AnthropicContentBlock>,
+}
+
+pub async fn generate_anthropic(
+    api_key: &str,
+    model: &str,
+    diff: &str,
+    notes: Option<&str>,
+) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("Anthropic API key is missing.".to_string());
+    }
+    let (system, user) = build_messages(diff, notes)?;
+    let body = AnthropicRequest {
+        model: model.to_string(),
+        max_tokens: DEFAULT_MAX_TOKENS,
+        system,
+        messages: vec![AnthropicMessage {
+            role: "user",
+            content: user,
+        }],
+    };
+
+    let client = http_client()?;
+    let response = client
+        .post("https://api.anthropic.com/v1/messages")
+        .header("x-api-key", api_key)
+        .header("anthropic-version", "2023-06-01")
+        .json(&body)
+        .send()
+        .await
+        .map_err(|err| format!("Request to Anthropic failed: {err}"))?;
+    let status = response.status();
+    let text = response
+        .text()
+        .await
+        .map_err(|err| format!("Could not read response: {err}"))?;
+
+    if !status.is_success() {
+        return Err(format!("API error ({status}): {text}"));
+    }
+
+    let parsed: AnthropicResponse =
+        serde_json::from_str(&text).map_err(|err| format!("Could not process response: {err}"))?;
+
+    let message = parsed
+        .content
+        .into_iter()
+        .find_map(|block| block.text)
+        .map(|text| sanitize_message(&text))
+        .filter(|text| !text.is_empty())
+        .ok_or_else(|| "The model did not return a response.".to_string())?;
+
+    if looks_like_diff_echo(&message) {
+        return Err("The model returned the diff instead of a commit message.".to_string());
+    }
+    Ok(message)
+}

src-tauri/crates/commit_ai/src/lib.rs

@@ -0,0 +1,445 @@
+mod cloud;
+
+pub use cloud::{generate_anthropic, generate_custom, generate_openai};
+
+use std::{
+    collections::hash_map::DefaultHasher,
+    hash::{Hash, Hasher},
+    sync::Arc,
+};
+
+use mistralrs::{GgufModelBuilder, Model, RequestBuilder, TextMessageRole};
+use tokio::sync::RwLock;
+
+/// One selectable local (on-device) model. Larger models produce better commit messages
+/// but take longer to download (first run only, then cached) and run slower on CPU.
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct LocalModelOption {
+    pub id: &'static str,
+    pub label: &'static str,
+    pub approx_size_mb: u32,
+    repo: &'static str,
+    file: &'static str,
+    tokenizer_repo: &'static str,
+}
+
+pub const DEFAULT_LOCAL_MODEL_ID: &str = "qwen2.5-0.5b";
+
+pub const LOCAL_MODELS: &[LocalModelOption] = &[
+    LocalModelOption {
+        id: "qwen2.5-0.5b",
+        label: "Qwen2.5 0.5B Instruct — fast, lower quality",
+        approx_size_mb: 490,
+        repo: "Qwen/Qwen2.5-0.5B-Instruct-GGUF",
+        file: "qwen2.5-0.5b-instruct-q4_k_m.gguf",
+        tokenizer_repo: "Qwen/Qwen2.5-0.5B-Instruct",
+    },
+    LocalModelOption {
+        id: "qwen2.5-1.5b",
+        label: "Qwen2.5 1.5B Instruct — recommended",
+        approx_size_mb: 1050,
+        repo: "Qwen/Qwen2.5-1.5B-Instruct-GGUF",
+        file: "qwen2.5-1.5b-instruct-q4_k_m.gguf",
+        tokenizer_repo: "Qwen/Qwen2.5-1.5B-Instruct",
+    },
+    LocalModelOption {
+        id: "qwen2.5-3b",
+        label: "Qwen2.5 3B Instruct — best quality, slower",
+        approx_size_mb: 2100,
+        repo: "Qwen/Qwen2.5-3B-Instruct-GGUF",
+        file: "qwen2.5-3b-instruct-q4_k_m.gguf",
+        tokenizer_repo: "Qwen/Qwen2.5-3B-Instruct",
+    },
+];
+
+fn find_local_model(model_id: &str) -> Option<&'static LocalModelOption> {
+    LOCAL_MODELS.iter().find(|option| option.id == model_id)
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum LocalGenerationProfile {
+    Fast,
+    Balanced,
+    Detailed,
+}
+
+impl Default for LocalGenerationProfile {
+    fn default() -> Self {
+        Self::Fast
+    }
+}
+
+impl LocalGenerationProfile {
+    pub fn from_id(value: Option<&str>) -> Self {
+        match value
+            .unwrap_or_default()
+            .trim()
+            .to_ascii_lowercase()
+            .as_str()
+        {
+            "balanced" => Self::Balanced,
+            "detailed" => Self::Detailed,
+            _ => Self::Fast,
+        }
+    }
+
+    pub fn diff_unified_context(self) -> &'static str {
+        match self {
+            Self::Fast => "--unified=1",
+            Self::Balanced => "--unified=2",
+            Self::Detailed => "--unified=3",
+        }
+    }
+
+    fn max_diff_chars(self) -> usize {
+        match self {
+            Self::Fast => 8_000,
+            Self::Balanced => 12_000,
+            Self::Detailed => 24_000,
+        }
+    }
+
+    fn max_output_tokens(self) -> usize {
+        match self {
+            Self::Fast => 160,
+            Self::Balanced => 360,
+            Self::Detailed => 750,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum CommitAiPhase {
+    /// Nothing has been requested yet.
+    Idle,
+    /// Downloading (first run only, then cached by hf-hub) and/or loading into memory.
+    Loading,
+    Ready,
+    Error,
+}
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub struct CommitAiStatus {
+    pub phase: CommitAiPhase,
+    pub model_id: Option<String>,
+    pub error: Option<String>,
+}
+
+struct Inner {
+    phase: CommitAiPhase,
+    model_id: Option<String>,
+    error: Option<String>,
+    model: Option<Arc<Model>>,
+    cache: Option<GenerationCache>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct GenerationCacheKey {
+    model_id: String,
+    profile: LocalGenerationProfile,
+    input_hash: u64,
+}
+
+#[derive(Debug, Clone)]
+struct GenerationCache {
+    key: GenerationCacheKey,
+    message: String,
+}
+
+/// Manages the local (on-device) model only. Cloud providers are stateless HTTP calls
+/// (see [`cloud`]) and don't need this — there's nothing to download or keep loaded.
+#[derive(Clone)]
+pub struct CommitAiEngine {
+    inner: Arc<RwLock<Inner>>,
+}
+
+impl Default for CommitAiEngine {
+    fn default() -> Self {
+        Self {
+            inner: Arc::new(RwLock::new(Inner {
+                phase: CommitAiPhase::Idle,
+                model_id: None,
+                error: None,
+                model: None,
+                cache: None,
+            })),
+        }
+    }
+}
+
+impl CommitAiEngine {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub async fn status(&self) -> CommitAiStatus {
+        let guard = self.inner.read().await;
+        CommitAiStatus {
+            phase: guard.phase,
+            model_id: guard.model_id.clone(),
+            error: guard.error.clone(),
+        }
+    }
+
+    /// Downloads (first run only; hf-hub caches the files afterwards) and loads the given
+    /// local model. Safe to call repeatedly — a call for the model that's already
+    /// ready/loading is a no-op; a call for a *different* model switches to it (the
+    /// previous one is dropped once no generation is still using it).
+    pub async fn ensure_loaded(&self, model_id: &str) {
+        {
+            let guard = self.inner.read().await;
+            let same_model = guard.model_id.as_deref() == Some(model_id);
+            if same_model && matches!(guard.phase, CommitAiPhase::Ready | CommitAiPhase::Loading) {
+                return;
+            }
+        }
+
+        let Some(option) = find_local_model(model_id) else {
+            let mut guard = self.inner.write().await;
+            guard.phase = CommitAiPhase::Error;
+            guard.model_id = Some(model_id.to_string());
+            guard.error = Some(format!("Unknown local model: {model_id}"));
+            guard.cache = None;
+            return;
+        };
+
+        {
+            let mut guard = self.inner.write().await;
+            guard.phase = CommitAiPhase::Loading;
+            guard.model_id = Some(model_id.to_string());
+            guard.error = None;
+            guard.model = None;
+            guard.cache = None;
+        }
+
+        let result = GgufModelBuilder::new(option.repo, vec![option.file])
+            .with_tok_model_id(option.tokenizer_repo)
+            .with_logging()
+            .build()
+            .await;
+
+        let mut guard = self.inner.write().await;
+        // If the user switched to yet another model while this one was loading, drop this
+        // (now stale) result instead of overwriting the newer request's state.
+        if guard.model_id.as_deref() != Some(model_id) {
+            return;
+        }
+        match result {
+            Ok(model) => {
+                guard.model = Some(Arc::new(model));
+                guard.phase = CommitAiPhase::Ready;
+                guard.error = None;
+                guard.cache = None;
+            }
+            Err(err) => {
+                guard.phase = CommitAiPhase::Error;
+                guard.error = Some(err.to_string());
+                guard.cache = None;
+            }
+        }
+    }
+
+    pub async fn generate_commit_message(
+        &self,
+        diff: &str,
+        notes: Option<&str>,
+        profile: LocalGenerationProfile,
+    ) -> Result<String, String> {
+        let (model, cache_key) = {
+            let guard = self.inner.read().await;
+            match (guard.phase, &guard.model) {
+                (CommitAiPhase::Ready, Some(model)) => {
+                    let cache_key = GenerationCacheKey {
+                        model_id: guard.model_id.clone().unwrap_or_default(),
+                        profile,
+                        input_hash: generation_input_hash(diff, notes),
+                    };
+                    if let Some(cache) = &guard.cache {
+                        if cache.key == cache_key {
+                            return Ok(cache.message.clone());
+                        }
+                    }
+                    (model.clone(), cache_key)
+                }
+                _ => return Err("The local AI model is not ready yet.".to_string()),
+            }
+        };
+
+        let (system, user) = build_local_messages(diff, notes, profile)?;
+        let request = RequestBuilder::new()
+            .set_sampler_max_len(profile.max_output_tokens())
+            .add_message(TextMessageRole::System, system)
+            .add_message(TextMessageRole::User, user);
+
+        let response = model
+            .send_chat_request(request)
+            .await
+            .map_err(|err| err.to_string())?;
+
+        let content = response
+            .choices
+            .first()
+            .and_then(|choice| choice.message.content.clone())
+            .ok_or_else(|| "The model did not return a response.".to_string())?;
+
+        let message = sanitize_message(&content);
+        if message.is_empty() {
+            return Err("The model did not return a response.".to_string());
+        }
+        if looks_like_diff_echo(&message) {
+            return Err(
+                "The local model returned the diff instead of a commit message. Try a larger local model (1.5B or 3B) or a cloud provider.".to_string(),
+            );
+        }
+        {
+            let mut guard = self.inner.write().await;
+            guard.cache = Some(GenerationCache {
+                key: cache_key,
+                message: message.clone(),
+            });
+        }
+        Ok(message)
+    }
+}
+
+fn generation_input_hash(diff: &str, notes: Option<&str>) -> u64 {
+    let mut hasher = DefaultHasher::new();
+    diff.hash(&mut hasher);
+    notes.unwrap_or("").hash(&mut hasher);
+    hasher.finish()
+}
+
+/// Models occasionally ignore the "no code fences" instruction (small local models
+/// especially) — strip a wrapping ``` fence and wrapping quotes so the result can go
+/// straight into the commit-message box.
+pub(crate) fn sanitize_message(raw: &str) -> String {
+    let mut text = raw.trim().to_string();
+    if text.starts_with("```") {
+        text = match text.split_once('\n') {
+            // Drop the opening fence line (which may carry a language tag) and the closing fence.
+            Some((_fence, rest)) => rest.trim_end().trim_end_matches("```").trim().to_string(),
+            None => text.trim_matches('`').trim().to_string(),
+        };
+    }
+    let trimmed = text.trim();
+    if trimmed.len() >= 2 && trimmed.starts_with('"') && trimmed.ends_with('"') {
+        return trimmed[1..trimmed.len() - 1].trim().to_string();
+    }
+    trimmed.to_string()
+}
+
+/// Weak models (small local ones especially) sometimes just echo the prompt's diff
+/// sections back instead of writing a commit message. Catch that so the UI can show a
+/// clear error instead of dumping raw diff text into the commit-message box.
+pub(crate) fn looks_like_diff_echo(message: &str) -> bool {
+    let lower = message.to_ascii_lowercase();
+    lower.contains("diff --git")
+        || lower.contains("staged files:")
+        || lower.contains("staged changes:")
+        || lower.contains("diff stat:")
+        || lower.contains("detailed diff:")
+        || message.lines().any(|line| line.starts_with("@@ "))
+}
+
+fn truncate_at_char_boundary(input: &str, max_chars: usize) -> String {
+    if input.len() <= max_chars {
+        return input.to_string();
+    }
+
+    let mut cut = max_chars;
+    while !input.is_char_boundary(cut) {
+        cut -= 1;
+    }
+    format!("{}\n\n[... diff truncated ...]", &input[..cut])
+}
+
+pub(crate) fn build_local_messages(
+    diff: &str,
+    notes: Option<&str>,
+    profile: LocalGenerationProfile,
+) -> Result<(String, String), String> {
+    if diff.trim().is_empty() {
+        return Err("No staged changes available for a commit message.".to_string());
+    }
+
+    let diff = truncate_at_char_boundary(diff, profile.max_diff_chars());
+    // Appended to every profile below: small local models occasionally just echo the input
+    // (the "Staged files:" / "Diff stat:" / "Detailed diff:" sections built in git.rs's
+    // `staged_diff_local`) instead of writing a new commit message. Naming those exact
+    // section headers here makes the failure mode explicit enough for weak models to avoid.
+    const ANTI_ECHO: &str = " Never repeat, quote, or paraphrase the diff or its headers — \
+do not include 'diff --git', '@@', 'Staged files:', 'Diff stat:', or 'Detailed diff:' \
+anywhere in your answer.";
+    let system = match profile {
+        LocalGenerationProfile::Fast => {
+            format!(
+                "You generate Git commit messages. Respond only with one Conventional Commits subject line: <type>(<scope>): <subject>. Max 72 characters. No body, bullets, preamble, explanation, code fences, or quotes. Answer in English.{ANTI_ECHO}"
+            )
+        }
+        LocalGenerationProfile::Balanced => {
+            format!(
+                "You generate Git commit messages. Respond with a Conventional Commits subject line, then a blank line, then at most two short bullet points. Keep every line under 72 characters. No preamble, explanation, code fences, or quotes. Answer in English.{ANTI_ECHO}"
+            )
+        }
+        LocalGenerationProfile::Detailed => {
+            format!(
+                "You generate Git commit messages. Respond with a Conventional Commits subject line, then a blank line, then a concise body and up to four short bullet points grouped by affected area/file. Keep every line under 72 characters. No preamble, explanation, code fences, or quotes. Answer in English.{ANTI_ECHO}"
+            )
+        }
+    };
+
+    let mut user = String::new();
+    if let Some(n) = notes.filter(|n| !n.trim().is_empty()) {
+        user.push_str(&format!("Developer notes:\n{n}\n\n"));
+    }
+    user.push_str(&format!("Staged changes:\n{diff}"));
+    Ok((system, user))
+}
+
+pub(crate) fn build_messages(diff: &str, notes: Option<&str>) -> Result<(String, String), String> {
+    if diff.trim().is_empty() {
+        return Err("No staged changes available for a commit message.".to_string());
+    }
+
+    // Rough token estimate — small models often have an 8-32k context window.
+    const MAX_CHARS: usize = 24_000;
+    let diff = truncate_at_char_boundary(diff, MAX_CHARS);
+
+    let system = "You are a tool that writes a Git commit message describing a staged diff. \
+Output ONLY the commit message text. Never quote, restate, or paraphrase the diff itself: \
+do not include lines starting with 'diff --git', '@@', '+', '-', 'index ', 'Staged files:', \
+or 'Diff stat:' anywhere in your answer. \
+Format: a Conventional Commits header (<type>(<scope>): <subject>) in imperative mood, \
+max. 72 characters, then a blank line, then a body. \
+The body is required: a short, general paragraph (2-4 sentences) summarizing what changed \
+and why at a high level — do NOT enumerate every changed file individually. \
+You may optionally add up to 3 bullet points (- ...) afterward, but only for the most \
+significant changes overall, never one bullet or heading per file. \
+Never use bold text, backticks, or markdown headings for file names. \
+Lines in the body max. 72 characters. \
+No preamble, no explanation, no code fences, answer in English.\n\n\
+Example:\n\
+Diff:\n\
+diff --git a/src/auth.py b/src/auth.py\n\
++def hash_password(pw):\n\
++    return bcrypt.hash(pw)\n\
+diff --git a/src/routes.py b/src/routes.py\n\
+-if password == stored_password:\n\
++if bcrypt.check(password, stored_password):\n\n\
+Commit message:\n\
+feat(auth): hash and verify passwords with bcrypt\n\n\
+Passwords were previously compared as plain text. This adds a bcrypt-based\n\
+hashing helper and updates the login check to verify against the hash\n\
+instead of a direct string comparison.\n\n\
+- Hash passwords on write, verify with bcrypt on login"
+        .to_string();
+
+    let mut user = String::new();
+    if let Some(n) = notes.filter(|n| !n.trim().is_empty()) {
+        user.push_str(&format!("Developer notes:\n{n}\n\n"));
+    }
+    user.push_str(&format!("Staged diff:\n{diff}"));
+    Ok((system, user))
+}

src-tauri/icons/android/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+  <background android:drawable="@color/ic_launcher_background"/>
+</adaptive-icon>

src-tauri/icons/android/values/ic_launcher_background.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="ic_launcher_background">#fff</color>
+</resources>

src-tauri/nsis-hooks.nsh

@@ -0,0 +1,72 @@
+!macro GITTY_MIGRATE_LEGACY_DATA_DIR oldDir newDir
+  ${IfNot} ${FileExists} "${newDir}\*.*"
+  ${AndIf} ${FileExists} "${oldDir}\*.*"
+    Rename "${oldDir}" "${newDir}"
+  ${EndIf}
+!macroend
+
+!macro GITTY_UNINSTALL_LEGACY_GITLITE rootKey
+  ClearErrors
+  ReadRegStr $R0 ${rootKey} "Software\Microsoft\Windows\CurrentVersion\Uninstall\GitLite" "UninstallString"
+  ${If} "$R0" != ""
+    ReadRegStr $R1 ${rootKey} "Software\git-lite\GitLite" ""
+    ${If} "$R1" == ""
+      ReadRegStr $R1 ${rootKey} "Software\Microsoft\Windows\CurrentVersion\Uninstall\GitLite" "InstallLocation"
+    ${EndIf}
+
+    DetailPrint "Removing legacy GitLite installation"
+    ${If} "$R1" != ""
+      ExecWait '$R0 /S _?=$R1' $R2
+    ${Else}
+      ExecWait '$R0 /S' $R2
+    ${EndIf}
+  ${EndIf}
+
+  DeleteRegKey ${rootKey} "Software\Microsoft\Windows\CurrentVersion\Uninstall\GitLite"
+  DeleteRegKey ${rootKey} "Software\git-lite\GitLite"
+  DeleteRegKey /ifempty ${rootKey} "Software\git-lite"
+!macroend
+
+!macro GITTY_CLEANUP_LEGACY_SHORTCUTS
+  Delete "$DESKTOP\GitLite.lnk"
+  Delete "$SMPROGRAMS\GitLite.lnk"
+  RMDir /r "$SMPROGRAMS\GitLite"
+!macroend
+
+!macro GITTY_REGISTER_INSTALL
+  WriteRegStr HKCU "${MANUPRODUCTKEY}" "" "$INSTDIR"
+  WriteRegStr HKCU "${UNINSTKEY}" "MainBinaryName" "${MAINBINARYNAME}.exe"
+  WriteRegStr HKCU "${UNINSTKEY}" "DisplayName" "${PRODUCTNAME}"
+  WriteRegStr HKCU "${UNINSTKEY}" "DisplayIcon" "$\"$INSTDIR\${MAINBINARYNAME}.exe$\""
+  WriteRegStr HKCU "${UNINSTKEY}" "DisplayVersion" "${VERSION}"
+  WriteRegStr HKCU "${UNINSTKEY}" "Publisher" "${MANUFACTURER}"
+  WriteRegStr HKCU "${UNINSTKEY}" "InstallLocation" "$\"$INSTDIR$\""
+  WriteRegStr HKCU "${UNINSTKEY}" "UninstallString" "$\"$INSTDIR\uninstall.exe$\""
+  WriteRegStr HKCU "${UNINSTKEY}" "QuietUninstallString" "$\"$INSTDIR\uninstall.exe$\" /S"
+  WriteRegDWORD HKCU "${UNINSTKEY}" "NoModify" "1"
+  WriteRegDWORD HKCU "${UNINSTKEY}" "NoRepair" "1"
+!macroend
+
+!macro GITTY_CREATE_UPDATE_SHORTCUTS
+  CreateShortcut "$SMPROGRAMS\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$SMPROGRAMS\${PRODUCTNAME}.lnk"
+  CreateShortcut "$DESKTOP\${PRODUCTNAME}.lnk" "$INSTDIR\${MAINBINARYNAME}.exe"
+  !insertmacro SetLnkAppUserModelId "$DESKTOP\${PRODUCTNAME}.lnk"
+!macroend
+
+!macro NSIS_HOOK_PREINSTALL
+  !insertmacro GITTY_MIGRATE_LEGACY_DATA_DIR "$APPDATA\com.git-lite" "$APPDATA\com.gitty"
+  !insertmacro GITTY_MIGRATE_LEGACY_DATA_DIR "$LOCALAPPDATA\com.git-lite" "$LOCALAPPDATA\com.gitty"
+  !insertmacro GITTY_UNINSTALL_LEGACY_GITLITE HKCU
+  !insertmacro GITTY_UNINSTALL_LEGACY_GITLITE HKLM
+!macroend
+
+!macro NSIS_HOOK_POSTINSTALL
+  !insertmacro GITTY_CLEANUP_LEGACY_SHORTCUTS
+  !insertmacro GITTY_REGISTER_INSTALL
+  !insertmacro GITTY_CREATE_UPDATE_SHORTCUTS
+!macroend
+
+!macro NSIS_HOOK_POSTUNINSTALL
+  !insertmacro GITTY_CLEANUP_LEGACY_SHORTCUTS
+!macroend

src-tauri/src/badge.rs

@@ -0,0 +1,200 @@
+//! Renders the combined repository attention count as a taskbar badge and applies it as the
+//! Windows taskbar overlay. Windows has no native numeric taskbar badge (unlike
+//! macOS/Linux, which support `Window::set_badge_count`), so the numbers have to be drawn
+//! into a plain RGBA icon ourselves and set via `Window::set_overlay_icon`.
+
+use tauri::Manager;
+use tauri::image::Image;
+
+const GLYPH_WIDTH: usize = 3;
+const GLYPH_HEIGHT: usize = 5;
+
+/// A minimal 3x5 pixel-grid font, just enough to draw digits and "+" legibly at badge size.
+fn glyph_rows(ch: char) -> [&'static str; GLYPH_HEIGHT] {
+    match ch {
+        '0' => ["111", "101", "101", "101", "111"],
+        '1' => ["010", "110", "010", "010", "111"],
+        '2' => ["111", "001", "111", "100", "111"],
+        '3' => ["111", "001", "111", "001", "111"],
+        '4' => ["101", "101", "111", "001", "001"],
+        '5' => ["111", "100", "111", "001", "111"],
+        '6' => ["111", "100", "111", "101", "111"],
+        '7' => ["111", "001", "010", "010", "010"],
+        '8' => ["111", "101", "111", "101", "111"],
+        '9' => ["111", "101", "111", "001", "111"],
+        '+' => ["000", "010", "111", "010", "000"],
+        _ => ["000", "000", "000", "000", "000"],
+    }
+}
+
+const BADGE_FILL: [u8; 4] = [224, 160, 64, 255];
+const BADGE_BORDER: [u8; 4] = [176, 118, 40, 255];
+const TEXT_FILL: [u8; 4] = [255, 255, 255, 255];
+const TEXT_SHADOW: [u8; 4] = [10, 12, 24, 190];
+const CIRCLE_BORDER_WIDTH: f32 = 3.0;
+
+/// Caps the displayed text at three characters ("99+") so it always fits legibly.
+fn cap_text(count: u32) -> String {
+    if count > 99 {
+        "99+".to_string()
+    } else {
+        count.to_string()
+    }
+}
+
+/// Draws a filled circle (with a slightly darker rim) centered at `(cx, cy)`.
+fn draw_circle(
+    rgba: &mut [u8],
+    size: usize,
+    cx: f32,
+    cy: f32,
+    radius: f32,
+    fill: [u8; 4],
+    border: [u8; 4],
+) {
+    for y in 0..size {
+        for x in 0..size {
+            let dx = x as f32 + 0.5 - cx;
+            let dy = y as f32 + 0.5 - cy;
+            let dist = (dx * dx + dy * dy).sqrt();
+            if dist <= radius {
+                let color = if dist >= radius - CIRCLE_BORDER_WIDTH {
+                    border
+                } else {
+                    fill
+                };
+                let idx = (y * size + x) * 4;
+                rgba[idx..idx + 4].copy_from_slice(&color);
+            }
+        }
+    }
+}
+
+fn draw_text_layer(
+    rgba: &mut [u8],
+    size: usize,
+    text: &str,
+    cx: f32,
+    cy: f32,
+    scale: usize,
+    offset: (isize, isize),
+    color: [u8; 4],
+) {
+    let glyphs: Vec<[&'static str; GLYPH_HEIGHT]> = text.chars().map(glyph_rows).collect();
+    let glyph_px_w = GLYPH_WIDTH * scale;
+    let glyph_px_h = GLYPH_HEIGHT * scale;
+    let gap = scale.max(1);
+    let total_w = glyphs.len() * glyph_px_w + gap * glyphs.len().saturating_sub(1);
+    let start_x = (cx - total_w as f32 / 2.0).round() as isize + offset.0;
+    let start_y = (cy - glyph_px_h as f32 / 2.0).round() as isize + offset.1;
+
+    for (gi, rows) in glyphs.iter().enumerate() {
+        let glyph_x = start_x + (gi * (glyph_px_w + gap)) as isize;
+        for (gy, row) in rows.iter().enumerate() {
+            for (gx, pixel) in row.chars().enumerate() {
+                if pixel != '1' {
+                    continue;
+                }
+                for py in 0..scale {
+                    for px in 0..scale {
+                        let x = glyph_x + (gx * scale + px) as isize;
+                        let y = start_y + (gy * scale + py) as isize;
+                        if x >= 0 && y >= 0 && (x as usize) < size && (y as usize) < size {
+                            let idx = (y as usize * size + x as usize) * 4;
+                            rgba[idx..idx + 4].copy_from_slice(&color);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Draws white `text` centered at `(cx, cy)`, scaling each font pixel up by `scale`.
+fn draw_text(rgba: &mut [u8], size: usize, text: &str, cx: f32, cy: f32, scale: usize) {
+    for offset in [(-1, 0), (1, 0), (0, -1), (0, 1)] {
+        draw_text_layer(rgba, size, text, cx, cy, scale, offset, TEXT_SHADOW);
+    }
+    draw_text_layer(rgba, size, text, cx, cy, scale, (0, 0), TEXT_FILL);
+}
+
+fn text_scale(text: &str) -> usize {
+    match text.len() {
+        0 | 1 => 7,
+        2 => 5,
+        _ => 4,
+    }
+}
+
+/// Renders a single large badge with `count`. Returns `None` when there's nothing to show,
+/// so the caller can clear the overlay icon.
+fn render_badge_icon(count: u32) -> Option<Image<'static>> {
+    if count == 0 {
+        return None;
+    }
+
+    const SIZE: usize = 64;
+    const RADIUS: f32 = 29.0;
+    let mut rgba = vec![0u8; SIZE * SIZE * 4];
+    let center = SIZE as f32 / 2.0;
+
+    let text = cap_text(count);
+    draw_circle(
+        &mut rgba,
+        SIZE,
+        center,
+        center,
+        RADIUS,
+        BADGE_FILL,
+        BADGE_BORDER,
+    );
+    draw_text(&mut rgba, SIZE, &text, center, center, text_scale(&text));
+
+    Some(Image::new_owned(rgba, SIZE as u32, SIZE as u32))
+}
+
+/// Sets the taskbar badge to `ahead + behind + changes` (0 clears it). Windows-only: Windows
+/// has no native numeric badge API, so this draws and applies a small overlay icon instead.
+/// No-op on other platforms: non-Windows desktops should use `Window::set_badge_count`
+/// for a real native badge instead, which this app doesn't currently wire up.
+#[tauri::command]
+pub fn set_sync_badge(
+    app: tauri::AppHandle,
+    ahead: u32,
+    behind: u32,
+    changes: u32,
+) -> Result<(), String> {
+    let count = ahead.saturating_add(behind).saturating_add(changes);
+
+    #[cfg(target_os = "windows")]
+    {
+        let Some(window) = app.get_webview_window("main") else {
+            return Ok(());
+        };
+        let icon = render_badge_icon(count);
+        window
+            .set_overlay_icon(icon)
+            .map_err(|err| format!("Could not set taskbar badge: {err}"))?;
+    }
+
+    // Native badge count: works on Linux (via the desktop's launcher API, e.g. Unity's
+    // LauncherEntry, also honored by GNOME/KDE) and macOS (dock badge). Matched against the
+    // app's `<product-name>.desktop` file on Linux, so it's a silent no-op on launchers that
+    // don't implement the protocol.
+    #[cfg(any(target_os = "linux", target_os = "macos"))]
+    {
+        let Some(window) = app.get_webview_window("main") else {
+            return Ok(());
+        };
+        window
+            .set_badge_count(if count > 0 { Some(count as i64) } else { None })
+            .map_err(|err| format!("Could not set taskbar badge: {err}"))?;
+    }
+
+    #[cfg(not(any(target_os = "windows", target_os = "linux", target_os = "macos")))]
+    {
+        let _ = (app, count);
+    }
+
+    Ok(())
+}

src-tauri/src/main.rs

@@ -1,39 +1,132 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+mod badge;
 mod git;
 
+use badge::set_sync_badge;
 use git::{
-    cancel_code_search, checkout_branch, commit, compare_commits, compare_file_to_head,
-    compare_file_to_parent, cred_delete, cred_load, cred_save, diff_file_against_working_tree,
-    get_remote_url, get_status, list_branches, list_commits, list_file_history,
-    list_repository_files, merge_branch, open_repository, pull, push, read_conflict,
-    resolve_conflict, resolve_conflict_side, restore_file_from_commit, restore_files,
-    restore_to_commit, search_code_introductions, stage_files, unstage_files,
-    SearchCancellationState,
+    SearchCancellationState, amend_commit, apply_file_patch, cancel_code_search,
+    cancel_file_history, checkout_branch, cherry_pick_abort, cherry_pick_commit,
+    cherry_pick_continue, clone_repository, commit, commit_ai_generate, commit_ai_load,
+    commit_ai_local_models, commit_ai_status, compare_commits, compare_file_to_head,
+    compare_file_to_parent, create_branch, create_tag, cred_delete, cred_load, cred_save,
+    delete_branch, delete_tag, diff_file_against_working_tree, fetch, get_file_blame,
+    get_file_patch, get_remote_url, get_status, last_commit_message, list_branches, list_commits,
+    list_file_history, list_interactive_rebase_commits, list_reflog, list_repository_files,
+    list_stashes, list_tags, merge_branch, open_repo_in_explorer, open_repository,
+    open_repository_bundle, open_repository_file, pull, push, push_tag, read_conflict,
+    rebase_abort, rebase_branch, rebase_continue, rename_branch, resolve_conflict,
+    resolve_conflict_side, restore_file_from_commit, restore_files, restore_reflog_entry,
+    restore_to_commit, run_sequence_editor_if_requested, search_code_introductions, stage_files,
+    start_interactive_rebase, stash_apply, stash_drop, stash_pop, stash_push, undo_last_commit,
+    unstage_files,
 };
+use tauri::Manager;
+
+#[tauri::command]
+fn close_splashscreen(app: tauri::AppHandle) -> Result<(), String> {
+    if let Some(window) = app.get_webview_window("splashscreen") {
+        let _ = window.hide();
+        window
+            .destroy()
+            .map_err(|error| format!("failed to destroy splashscreen: {error}"))?;
+    }
+
+    if let Some(window) = app.get_webview_window("main") {
+        window
+            .show()
+            .map_err(|error| format!("failed to show main window: {error}"))?;
+        let _ = window.set_focus();
+    }
+
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    if let Some(result) = run_sequence_editor_if_requested() {
+        if let Err(error) = result {
+            eprintln!("{error}");
+            std::process::exit(1);
+        }
+        return;
+    }
 
-fn main() {
     tauri::Builder::default()
+        .plugin(tauri_plugin_single_instance::init(|app, _, _| {
+            #[cfg(desktop)]
+            let _ = app
+                .get_webview_window("main")
+                .expect("no main window")
+                .set_focus();
+        }))
         .plugin(tauri_plugin_updater::Builder::new().build())
+        .plugin(
+            tauri_plugin_aptabase::Builder::new("A-SH-1344793789")
+                .with_options(tauri_plugin_aptabase::InitOptions {
+                    host: Some("https://aptabase.cbsk-tech.de".to_string()),
+                    flush_interval: None,
+                })
+                .build(),
+        )
         .manage(SearchCancellationState::default())
+        .manage(commit_ai::CommitAiEngine::new())
         .plugin(tauri_plugin_dialog::init())
         .invoke_handler(tauri::generate_handler![
             open_repository,
+            clone_repository,
+            open_repo_in_explorer,
+            open_repository_file,
             get_status,
             list_branches,
+            list_stashes,
             checkout_branch,
+            create_branch,
+            rename_branch,
+            delete_branch,
+            list_tags,
+            create_tag,
+            delete_tag,
+            push_tag,
+            cherry_pick_commit,
+            cherry_pick_continue,
+            cherry_pick_abort,
             stage_files,
             unstage_files,
+            stash_push,
+            stash_apply,
+            stash_pop,
+            stash_drop,
             restore_files,
+            get_file_patch,
+            apply_file_patch,
             commit,
+            amend_commit,
+            undo_last_commit,
+            last_commit_message,
+            commit_ai_status,
+            commit_ai_load,
+            commit_ai_local_models,
+            commit_ai_generate,
             pull,
             push,
+            fetch,
             list_commits,
             restore_to_commit,
             restore_file_from_commit,
             merge_branch,
+            rebase_branch,
+            rebase_continue,
+            rebase_abort,
+            list_interactive_rebase_commits,
+            start_interactive_rebase,
+            list_reflog,
+            restore_reflog_entry,
             list_repository_files,
+            open_repository_bundle,
             list_file_history,
+            cancel_file_history,
+            get_file_blame,
             compare_commits,
             compare_file_to_head,
             compare_file_to_parent,
@@ -46,7 +139,9 @@ fn main() {
             get_remote_url,
             cred_load,
             cred_save,
-            cred_delete
+            cred_delete,
+            set_sync_badge,
+            close_splashscreen
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/tauri.conf.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
-  "productName": "GitLite",
-  "version": "0.0.3",
-  "identifier": "com.git-lite",
+  "productName": "Gitty",
+  "version": "0.200.10",
+  "identifier": "com.gitty",
   "build": {
     "beforeDevCommand": "npm run dev",
     "devUrl": "http://127.0.0.1:1420",
@@ -13,13 +13,26 @@
     "windows": [
       {
         "label": "main",
-        "title": "GitLite",
+        "title": "Gitty",
         "width": 1200,
         "height": 800,
         "minWidth": 900,
         "minHeight": 600,
+        "visible": false,
         "decorations": false,
         "shadow": true
+      },
+      {
+        "label": "splashscreen",
+        "url": "splashscreen.html",
+        "title": "Gitty",
+        "width": 460,
+        "height": 420,
+        "resizable": false,
+        "decorations": false,
+        "center": true,
+        "skipTaskbar": true,
+        "shadow": true
       }
     ],
     "security": {
@@ -28,12 +41,22 @@
   },
   "bundle": {
     "active": true,
-    "targets": "all",
-    "icon": ["icons/icon.ico"],
+    "targets": [
+      "nsis"
+    ],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
     "createUpdaterArtifacts": true,
     "windows": {
       "nsis": {
-        "installMode": "currentUser"
+        "installMode": "currentUser",
+        "installerIcon": "icons/icon.ico",
+        "installerHooks": "nsis-hooks.nsh"
       }
     }
   },
@@ -41,6 +64,7 @@
     "updater": {
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDdDNEJGRTZERTREOTc5QjkKUldTNWVkbmtiZjVMZk02YzdpenVLOVltREJpRkFrc2F4dUwzaTV5M3pacFRVR0tmd25xSGtjK1MK",
       "endpoints": [
+        "https://cdn.cbsk-tech.de/gitty/latest.json",
         "https://cdn.cbsk-tech.de/gitlite/latest.json"
       ]
     }

src-tauri/tauri.linux.conf.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "bundle": {
+    "targets": ["appimage"]
+  }
+}

src/lib/TitleBar.svelte

@@ -1,7 +1,9 @@
 <script lang="ts">
   import { onDestroy, onMount } from "svelte";
+  import { getVersion } from "@tauri-apps/api/app";
   import { getCurrentWindow } from "@tauri-apps/api/window";
-  import { Download, GitBranch, LoaderCircle, Minus, RefreshCw, Search, Upload, X } from "@lucide/svelte";
+  import { CloudDownload, Download, FolderOpen, GitBranch, GitCompare, History, ListRestart, LoaderCircle, Minus, RefreshCw, Search, Settings, Upload, X } from "@lucide/svelte";
+  import iconUrl from "../../src-tauri/icons/icon.png";
 
   export let branch: string = "";
   export let ahead: number = 0;
@@ -12,67 +14,91 @@
   export let operation: string = "";
   export let autoRefreshEnabled: boolean = true;
   export let autoRefreshInFlight: boolean = false;
+  export let onFetch: () => void = () => {};
   export let onPull: () => void = () => {};
   export let onPush: () => void = () => {};
   export let onRefresh: () => void = () => {};
   export let onSearch: () => void = () => {};
+  export let onCompare: () => void = () => {};
+  export let onInteractiveRebase: () => void = () => {};
+  export let onReflog: () => void = () => {};
+  export let onOpenInExplorer: () => void = () => {};
   export let onToggleAutoRefresh: () => void = () => {};
+  export let onOpenSettings: () => void = () => {};
 
-  const win = getCurrentWindow();
+  let win: ReturnType<typeof getCurrentWindow> | null = null;
   let isMaximized = false;
   let unlisten: (() => void) | undefined;
+  let appVersion = "";
 
   onMount(async () => {
+    try {
+      win = getCurrentWindow();
       isMaximized = await win.isMaximized();
       unlisten = await win.onResized(async () => {
-      isMaximized = await win.isMaximized();
+        isMaximized = await win?.isMaximized() ?? false;
       });
+    } catch {
+      win = null;
+    }
+
+    try {
+      appVersion = await getVersion();
+    } catch {
+      appVersion = "";
+    }
   });
 
   onDestroy(() => {
     unlisten?.();
   });
+
+  function minimizeWindow() {
+    void win?.minimize();
+  }
+
+  function toggleMaximizeWindow() {
+    void win?.toggleMaximize();
+  }
+
+  function closeWindow() {
+    void win?.close();
+  }
 </script>
 
 <header class="titlebar" data-tauri-drag-region>
   <!-- Brand -->
   <div class="titlebar-brand" data-tauri-drag-region>
-    <svg
-      width="15"
-      height="15"
-      viewBox="0 0 24 24"
-      fill="none"
-      stroke="currentColor"
-      stroke-width="2"
-      stroke-linecap="round"
-      stroke-linejoin="round"
-      aria-hidden="true"
-      data-tauri-drag-region
-    >
-      <circle cx="12" cy="18" r="3" />
-      <circle cx="6" cy="6" r="3" />
-      <circle cx="18" cy="6" r="3" />
-      <path d="M18 9v1a2 2 0 0 1-2 2H8a2 2 0 0 1-2-2V9" />
-      <line x1="12" y1="12" x2="12" y2="15" />
-    </svg>
-    <span data-tauri-drag-region>GitLite</span>
+    <span class="titlebar-brand-icon" data-tauri-drag-region>
+      <img src={iconUrl} alt="" data-tauri-drag-region />
+    </span>
+    <span data-tauri-drag-region>Gitty</span>
+    {#if appVersion}
+      <span class="tb-version" data-tauri-drag-region title="Version {appVersion}">v{appVersion}</span>
+    {/if}
   </div>
 
   <!-- Center: repo + branch info -->
   <div class="titlebar-info" data-tauri-drag-region>
     {#if hasRepository}
+      <div class="titlebar-context" data-tauri-drag-region>
         {#if repoName}
           <span class="tb-repo" data-tauri-drag-region>{repoName}</span>
           <span class="tb-sep" data-tauri-drag-region aria-hidden="true">/</span>
         {/if}
         <GitBranch size={12} aria-hidden="true" />
-      <span class="tb-branch" data-tauri-drag-region>{branch}</span>
+        <span class="tb-branch" data-tauri-drag-region title={branch}>{branch}</span>
+      </div>
+      {#if ahead > 0 || behind > 0}
+        <div class="tb-sync-group" aria-label="Branch synchronization status">
           {#if ahead > 0}
             <span class="tb-sync ahead" title="{ahead} commits ahead">↑{ahead}</span>
           {/if}
           {#if behind > 0}
             <span class="tb-sync behind" title="{behind} commits behind">↓{behind}</span>
           {/if}
+        </div>
+      {/if}
     {:else}
       <span class="tb-no-repo" data-tauri-drag-region>No repository open</span>
     {/if}
@@ -81,6 +107,17 @@
   <!-- Right: actions + window controls -->
   <div class="titlebar-right">
     <div class="titlebar-actions" role="toolbar" aria-label="Repository actions">
+      <button
+        class="tb-action"
+        onclick={onOpenInExplorer}
+        disabled={!hasRepository || isBusy}
+        title="Open repository in Explorer"
+        aria-label="Open repository in Explorer"
+      >
+        <FolderOpen size={14} aria-hidden="true" />
+        <span class="tb-action-label">Explorer</span>
+      </button>
+
       <button
         class="tb-action"
         onclick={onSearch}
@@ -92,6 +129,54 @@
         <span class="tb-action-label">Search</span>
       </button>
 
+      <button
+        class="tb-action"
+        onclick={onCompare}
+        disabled={!hasRepository || isBusy}
+        title="Compare commits"
+        aria-label="Compare commits"
+      >
+        <GitCompare size={14} aria-hidden="true" />
+        <span class="tb-action-label">Compare</span>
+      </button>
+
+      <button
+        class="tb-action"
+        onclick={onInteractiveRebase}
+        disabled={!hasRepository || isBusy}
+        title="Interactive rebase"
+        aria-label="Interactive rebase"
+      >
+        <ListRestart size={14} aria-hidden="true" />
+        <span class="tb-action-label">Rebase</span>
+      </button>
+
+      <button
+        class="tb-action"
+        onclick={onReflog}
+        disabled={!hasRepository || isBusy}
+        title="Reflog"
+        aria-label="Reflog"
+      >
+        <History size={14} aria-hidden="true" />
+        <span class="tb-action-label">Reflog</span>
+      </button>
+
+      <button
+        class="tb-action"
+        onclick={onFetch}
+        disabled={!hasRepository || isBusy}
+        title="Fetch"
+        aria-label="Fetch"
+      >
+        {#if operation === "Fetching"}
+          <LoaderCircle class="spin" size={14} aria-hidden="true" />
+        {:else}
+          <CloudDownload size={14} aria-hidden="true" />
+        {/if}
+        <span class="tb-action-label">Fetch</span>
+      </button>
+
       <button
         class="tb-action"
         onclick={onPull}
@@ -152,17 +237,27 @@
         />
         <span class="tb-action-label">Auto</span>
       </button>
+
+      <button
+        class="tb-action"
+        onclick={onOpenSettings}
+        title="Settings"
+        aria-label="Settings"
+      >
+        <Settings size={14} aria-hidden="true" />
+        <span class="tb-action-label">Settings</span>
+      </button>
     </div>
 
     <div class="titlebar-divider" aria-hidden="true"></div>
 
     <div class="titlebar-controls">
-      <button class="tb-btn" onclick={() => win.minimize()} title="Minimize" aria-label="Minimize">
+      <button class="tb-btn" onclick={minimizeWindow} title="Minimize" aria-label="Minimize">
         <Minus size={12} aria-hidden="true" />
       </button>
       <button
         class="tb-btn"
-        onclick={() => win.toggleMaximize()}
+        onclick={toggleMaximizeWindow}
         title={isMaximized ? "Restore" : "Maximize"}
         aria-label={isMaximized ? "Restore" : "Maximize"}
       >
@@ -177,7 +272,7 @@
           </svg>
         {/if}
       </button>
-      <button class="tb-btn close" onclick={() => win.close()} title="Close" aria-label="Close">
+      <button class="tb-btn close" onclick={closeWindow} title="Close" aria-label="Close">
         <X size={12} aria-hidden="true" />
       </button>
     </div>

src/lib/analytics.ts

@@ -0,0 +1,12 @@
+import { invoke } from "@tauri-apps/api/core";
+
+export type AnalyticsEventProperties = Record<string, string | number>;
+
+export function trackAnalyticsEvent(name: string, props?: AnalyticsEventProperties) {
+  void invoke("plugin:aptabase|track_event", {
+    name,
+    props: props && Object.keys(props).length > 0 ? props : undefined,
+  }).catch(() => {
+    // Analytics must never interrupt the Git workflow.
+  });
+}

src/lib/components/AiSettingsDialog.svelte

@@ -0,0 +1,313 @@
+<script lang="ts">
+  import { onDestroy, onMount } from "svelte";
+  import { AlertCircle, Bot, Check, Cpu, Eye, EyeOff, Gauge, Globe, Key, LoaderCircle, Sparkles, X, Zap } from "@lucide/svelte";
+  import { credDelete, credLoad, credSave } from "../git";
+  import type { AiSettings, CommitAiLocalProfile, CommitAiProvider, LocalModelOption } from "../types";
+
+  interface Props {
+    settings: AiSettings;
+    localModels: LocalModelOption[];
+    onSave: (settings: AiSettings) => void;
+    onClose: () => void;
+  }
+
+  let { settings, localModels = [], onSave, onClose }: Props = $props();
+
+  type CloudProvider = Exclude<CommitAiProvider, "local">;
+
+  const CRED_KEYS: Record<CloudProvider, string> = {
+    openai: "ai:openai",
+    anthropic: "ai:anthropic",
+    custom: "ai:custom",
+  };
+
+  let provider = $state<CommitAiProvider>("local");
+  let localModelId = $state("");
+  let localProfile = $state<CommitAiLocalProfile>("fast");
+  let openaiModel = $state("");
+  let anthropicModel = $state("");
+  let customBaseUrl = $state("");
+  let customModel = $state("");
+
+  let openaiApiKey = $state("");
+  let anthropicApiKey = $state("");
+  let customApiKey = $state("");
+  let showKey = $state(false);
+  let loadingKeys = $state(true);
+  let saving = $state(false);
+  let error = $state("");
+  let errorHideTimer: ReturnType<typeof setTimeout> | undefined;
+
+  $effect(() => {
+    provider = settings.provider;
+    localModelId = settings.localModelId;
+    localProfile = settings.localProfile ?? "fast";
+    openaiModel = settings.openaiModel;
+    anthropicModel = settings.anthropicModel;
+    customBaseUrl = settings.customBaseUrl;
+    customModel = settings.customModel;
+  });
+
+  $effect(() => {
+    if (errorHideTimer) clearTimeout(errorHideTimer);
+    const currentError = error;
+    if (currentError) {
+      errorHideTimer = setTimeout(() => {
+        if (error === currentError) error = "";
+      }, 6000);
+    }
+  });
+
+  onMount(() => {
+    (async () => {
+      try {
+        const [openai, anthropic, custom] = await Promise.all([
+          credLoad(CRED_KEYS.openai),
+          credLoad(CRED_KEYS.anthropic),
+          credLoad(CRED_KEYS.custom),
+        ]);
+        openaiApiKey = openai?.password ?? "";
+        anthropicApiKey = anthropic?.password ?? "";
+        customApiKey = custom?.password ?? "";
+      } catch (err) {
+        error = err instanceof Error ? err.message : String(err);
+      } finally {
+        loadingKeys = false;
+      }
+    })();
+  });
+
+  onDestroy(() => {
+    if (errorHideTimer) clearTimeout(errorHideTimer);
+  });
+
+  async function persistKey(target: CloudProvider, value: string) {
+    const key = CRED_KEYS[target];
+    const trimmed = value.trim();
+    if (trimmed) {
+      await credSave(key, "api-key", trimmed, null);
+    } else {
+      await credDelete(key);
+    }
+  }
+
+  async function handleSave() {
+    saving = true;
+    error = "";
+    try {
+      await Promise.all([
+        persistKey("openai", openaiApiKey),
+        persistKey("anthropic", anthropicApiKey),
+        persistKey("custom", customApiKey),
+      ]);
+      onSave({
+        provider,
+        localModelId,
+        localProfile,
+        openaiModel: openaiModel.trim() || "gpt-4o-mini",
+        anthropicModel: anthropicModel.trim() || "claude-3-5-haiku-latest",
+        customBaseUrl: customBaseUrl.trim(),
+        customModel: customModel.trim(),
+      });
+    } catch (err) {
+      error = err instanceof Error ? err.message : String(err);
+    } finally {
+      saving = false;
+    }
+  }
+
+  function formatSize(mb: number): string {
+    return mb >= 1000 ? `${(mb / 1000).toFixed(1)} GB` : `${mb} MB`;
+  }
+
+  function recommendedModelForProfile(profile: CommitAiLocalProfile): string {
+    if (profile === "balanced") return "qwen2.5-1.5b";
+    if (profile === "detailed") return "qwen2.5-3b";
+    return "qwen2.5-0.5b";
+  }
+
+  function selectLocalProfile(profile: CommitAiLocalProfile) {
+    const previousRecommended = recommendedModelForProfile(localProfile);
+    localProfile = profile;
+    const nextRecommended = recommendedModelForProfile(profile);
+    if (!localModelId || localModelId === previousRecommended) {
+      localModelId = nextRecommended;
+    }
+  }
+
+  let selectedLocalModel = $derived(localModels.find((option) => option.id === localModelId));
+</script>
+
+<div
+  class="dialog-backdrop"
+  role="presentation"
+>
+  <div class="dialog ai-settings-dialog" role="dialog" aria-modal="true" aria-label="AI settings" tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Commit AI</span>
+        <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">AI settings</h2>
+      </div>
+      <button class="dialog-close" type="button" onclick={onClose} title="Close">
+        <X size={18} aria-hidden="true" />
+      </button>
+    </header>
+
+    <form class="ai-settings-form" onsubmit={(e) => { e.preventDefault(); void handleSave(); }}>
+      <div class="ai-provider-options" role="radiogroup" aria-label="AI provider">
+        <button
+          type="button"
+          class="ai-provider-option ai-provider-option-local"
+          class:active={provider === "local"}
+          disabled
+          title="Local AI is still in development and not yet available"
+        >
+          <Cpu size={16} aria-hidden="true" />
+          Local AI
+          <span class="ai-provider-badge">In development</span>
+        </button>
+        <button type="button" class="ai-provider-option" class:active={provider === "openai"} onclick={() => { provider = "openai"; }}>
+          <Bot size={16} aria-hidden="true" />
+          OpenAI
+        </button>
+        <button type="button" class="ai-provider-option" class:active={provider === "anthropic"} onclick={() => { provider = "anthropic"; }}>
+          <Bot size={16} aria-hidden="true" />
+          Anthropic (Claude)
+        </button>
+        <button type="button" class="ai-provider-option" class:active={provider === "custom"} onclick={() => { provider = "custom"; }}>
+          <Globe size={16} aria-hidden="true" />
+          Custom endpoint
+        </button>
+      </div>
+
+      {#if provider === "local"}
+        <div class="cred-field">
+          <span class="cred-field-label">Local speed</span>
+          <div class="ai-local-profile-options" role="radiogroup" aria-label="Local AI speed">
+            <button type="button" class="ai-local-profile-option" class:active={localProfile === "fast"} onclick={() => selectLocalProfile("fast")}>
+              <Zap size={15} aria-hidden="true" />
+              Fast
+            </button>
+            <button type="button" class="ai-local-profile-option" class:active={localProfile === "balanced"} onclick={() => selectLocalProfile("balanced")}>
+              <Gauge size={15} aria-hidden="true" />
+              Balanced
+            </button>
+            <button type="button" class="ai-local-profile-option" class:active={localProfile === "detailed"} onclick={() => selectLocalProfile("detailed")}>
+              <Sparkles size={15} aria-hidden="true" />
+              Detailed
+            </button>
+          </div>
+        </div>
+        <label class="cred-field">
+          <span class="cred-field-label">Model</span>
+          <select bind:value={localModelId}>
+            {#each localModels as option (option.id)}
+              <option value={option.id}>{option.label} — {formatSize(option.approx_size_mb)}</option>
+            {/each}
+          </select>
+        </label>
+        <div class="cred-token-hint">
+          <AlertCircle size={13} aria-hidden="true" />
+          <span>
+            Switching downloads the model{selectedLocalModel ? ` (${formatSize(selectedLocalModel.approx_size_mb)})` : ""}
+            in the background — depending on your internet connection this can take several minutes.
+            After that it stays cached locally and loads instantly on the next start.
+            The speed setting only changes Local AI; API providers keep their existing prompt.
+          </span>
+        </div>
+      {:else if provider === "openai"}
+        <label class="cred-field">
+          <span class="cred-field-label">Model</span>
+          <input type="text" bind:value={openaiModel} placeholder="gpt-4o-mini" autocomplete="off" spellcheck="false" />
+        </label>
+        <div class="cred-field">
+          <span class="cred-field-label">API key</span>
+          <div class="cred-input">
+            <Key size={15} class="cred-field-icon" aria-hidden="true" />
+            <input
+              type={showKey ? "text" : "password"}
+              bind:value={openaiApiKey}
+              placeholder="sk-..."
+              autocomplete="off"
+              spellcheck="false"
+              disabled={loadingKeys}
+            />
+            <button type="button" class="cred-reveal" tabindex="-1" onclick={() => { showKey = !showKey; }} aria-label={showKey ? "Hide" : "Show"}>
+              {#if showKey}<EyeOff size={14} aria-hidden="true" />{:else}<Eye size={14} aria-hidden="true" />{/if}
+            </button>
+          </div>
+        </div>
+      {:else if provider === "anthropic"}
+        <label class="cred-field">
+          <span class="cred-field-label">Model</span>
+          <input type="text" bind:value={anthropicModel} placeholder="claude-3-5-haiku-latest" autocomplete="off" spellcheck="false" />
+        </label>
+        <div class="cred-field">
+          <span class="cred-field-label">API key</span>
+          <div class="cred-input">
+            <Key size={15} class="cred-field-icon" aria-hidden="true" />
+            <input
+              type={showKey ? "text" : "password"}
+              bind:value={anthropicApiKey}
+              placeholder="sk-ant-..."
+              autocomplete="off"
+              spellcheck="false"
+              disabled={loadingKeys}
+            />
+            <button type="button" class="cred-reveal" tabindex="-1" onclick={() => { showKey = !showKey; }} aria-label={showKey ? "Hide" : "Show"}>
+              {#if showKey}<EyeOff size={14} aria-hidden="true" />{:else}<Eye size={14} aria-hidden="true" />{/if}
+            </button>
+          </div>
+        </div>
+      {:else}
+        <label class="cred-field">
+          <span class="cred-field-label">Endpoint URL</span>
+          <input type="text" bind:value={customBaseUrl} placeholder="http://localhost:11434/v1" autocomplete="off" spellcheck="false" />
+        </label>
+        <label class="cred-field">
+          <span class="cred-field-label">Model</span>
+          <input type="text" bind:value={customModel} placeholder="llama3.1" autocomplete="off" spellcheck="false" />
+        </label>
+        <div class="cred-field">
+          <span class="cred-field-label">API key (optional)</span>
+          <div class="cred-input">
+            <Key size={15} class="cred-field-icon" aria-hidden="true" />
+            <input
+              type={showKey ? "text" : "password"}
+              bind:value={customApiKey}
+              placeholder="Optional"
+              autocomplete="off"
+              spellcheck="false"
+              disabled={loadingKeys}
+            />
+            <button type="button" class="cred-reveal" tabindex="-1" onclick={() => { showKey = !showKey; }} aria-label={showKey ? "Hide" : "Show"}>
+              {#if showKey}<EyeOff size={14} aria-hidden="true" />{:else}<Eye size={14} aria-hidden="true" />{/if}
+            </button>
+          </div>
+        </div>
+        <div class="cred-token-hint">
+          <Globe size={13} aria-hidden="true" />
+          <span>For local OpenAI-compatible servers like Ollama or LM Studio. The base URL should end in /v1.</span>
+        </div>
+      {/if}
+
+      {#if error}
+        <p class="commit-block-reason">{error}</p>
+      {/if}
+
+      <div class="new-branch-actions">
+        <button class="btn-secondary" type="button" onclick={onClose} disabled={saving}>
+          Cancel
+        </button>
+        <button class="btn-primary" type="submit" disabled={saving || loadingKeys}>
+          {#if saving}
+            <LoaderCircle class="spin" size={16} aria-hidden="true" />
+          {:else}
+            <Check size={16} aria-hidden="true" />
+          {/if}
+          Save
+        </button>
+      </div>
+    </form>
+  </div>
+</div>

src/lib/components/AnalyticsNoticeDialog.svelte

@@ -0,0 +1,57 @@
+<script lang="ts">
+  import { BarChart3, Check, ShieldCheck } from "@lucide/svelte";
+
+  interface Props {
+    enabled: boolean;
+    onContinue: (enabled: boolean) => void;
+  }
+
+  let { enabled = true, onContinue = () => {} }: Props = $props();
+  let allowAnalytics = $state(true);
+
+  $effect(() => {
+    allowAnalytics = enabled;
+  });
+</script>
+
+<div class="dialog-backdrop app-chrome-backdrop" role="presentation">
+  <div class="dialog analytics-notice-dialog" role="dialog" aria-modal="true" aria-label="Analytics notice" tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Privacy</span>
+        <h2 class="dialog-title">Anonymous usage analytics</h2>
+      </div>
+      <ShieldCheck size={20} aria-hidden="true" />
+    </header>
+
+    <div class="analytics-notice-body">
+      <div class="analytics-notice-icon">
+        <BarChart3 size={24} aria-hidden="true" />
+      </div>
+      <div class="analytics-notice-copy">
+        <p>
+          Gitty can send anonymous usage events to Aptabase so crashes, rough edges, and commonly used workflows are easier to improve.
+        </p>
+        <p>
+          Events do not include repository paths, remote URLs, branch names, commit messages, diffs, file names, credentials, or source code.
+        </p>
+      </div>
+
+      <label class="settings-toggle-row analytics-notice-toggle">
+        <input type="checkbox" bind:checked={allowAnalytics} />
+        <span>
+          <strong>Allow anonymous analytics</strong>
+          <small>You can change this later in Settings.</small>
+        </span>
+      </label>
+    </div>
+
+    <footer class="dialog-footer analytics-notice-footer">
+      <span class="dialog-footer-info">Privacy-friendly, optional, and limited to product usage events.</span>
+      <button class="btn-primary" type="button" onclick={() => onContinue(allowAnalytics)}>
+        <Check size={16} aria-hidden="true" />
+        Continue
+      </button>
+    </footer>
+  </div>
+</div>

src/lib/components/AppSettingsDialog.svelte

@@ -0,0 +1,96 @@
+<script lang="ts">
+  import { Check, Settings, X } from "@lucide/svelte";
+  import type { AnalyticsSettings, AppTheme } from "../types";
+
+  interface Props {
+    analytics: AnalyticsSettings;
+    theme: AppTheme;
+    onSave: (settings: AnalyticsSettings, theme: AppTheme) => void;
+    onClose: () => void;
+  }
+
+  let { analytics, theme = "system", onSave = () => {}, onClose = () => {} }: Props = $props();
+
+  let analyticsEnabled = $state(true);
+  let selectedTheme = $state<AppTheme>("system");
+
+  $effect(() => {
+    analyticsEnabled = analytics.enabled;
+    selectedTheme = theme;
+  });
+
+  function save() {
+    onSave({
+      ...analytics,
+      enabled: analyticsEnabled,
+      noticeSeen: true,
+    }, selectedTheme);
+  }
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog app-settings-dialog" role="dialog" aria-modal="true" aria-label="Settings" tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Gitty</span>
+        <h2 class="dialog-title">Settings</h2>
+      </div>
+      <button class="dialog-close" type="button" onclick={onClose} title="Close">
+        <X size={18} aria-hidden="true" />
+      </button>
+    </header>
+
+    <form class="app-settings-form" onsubmit={(event) => { event.preventDefault(); save(); }}>
+      <section class="settings-section">
+        <header>
+          <Settings size={16} aria-hidden="true" />
+          <div>
+            <span class="eyebrow">Appearance</span>
+            <h3>Theme</h3>
+          </div>
+        </header>
+
+        <div class="settings-segmented" role="radiogroup" aria-label="Theme">
+          <label class:active={selectedTheme === "system"}>
+            <input type="radio" bind:group={selectedTheme} value="system" />
+            <span>System</span>
+          </label>
+          <label class:active={selectedTheme === "light"}>
+            <input type="radio" bind:group={selectedTheme} value="light" />
+            <span>Light</span>
+          </label>
+          <label class:active={selectedTheme === "dark"}>
+            <input type="radio" bind:group={selectedTheme} value="dark" />
+            <span>Dark</span>
+          </label>
+        </div>
+      </section>
+
+      <section class="settings-section">
+        <header>
+          <Settings size={16} aria-hidden="true" />
+          <div>
+            <span class="eyebrow">Analytics</span>
+            <h3>Anonymous usage analytics</h3>
+          </div>
+        </header>
+
+        <label class="settings-toggle-row">
+          <input type="checkbox" bind:checked={analyticsEnabled} />
+          <span>
+            <strong>Allow anonymous Aptabase events</strong>
+            <small>No repository paths, remotes, branches, commit messages, file names, diffs, credentials, or code are sent.</small>
+          </span>
+        </label>
+      </section>
+
+      <div class="new-branch-actions">
+        <button class="btn-secondary" type="button" onclick={onClose}>Cancel</button>
+        <button class="btn-primary" type="submit">
+          <Check size={16} aria-hidden="true" />
+          Save
+        </button>
+      </div>
+    </form>
+  </div>
+</div>

src/lib/components/BlameDialog.svelte

@@ -0,0 +1,230 @@
+<script lang="ts">
+  import { FileCode, LoaderCircle, Search, X } from "@lucide/svelte";
+  import type { GitBlameLine } from "../types";
+
+  interface BlameGroup {
+    id: string;
+    hash: string;
+    shortHash: string;
+    authorName: string;
+    authorEmail: string;
+    summary: string;
+    authorTime: number;
+    isUncommitted: boolean;
+    lines: GitBlameLine[];
+  }
+
+  interface TextSegment {
+    text: string;
+    matched: boolean;
+  }
+
+  interface Props {
+    filePath: string;
+    lines: GitBlameLine[];
+    isBusy: boolean;
+    isLoading: boolean;
+    error: string;
+    onClose: () => void;
+  }
+
+  let {
+    filePath = "",
+    lines = [],
+    isBusy = false,
+    isLoading = false,
+    error = "",
+    onClose = () => {},
+  }: Props = $props();
+
+  let blameSearch = $state("");
+
+  function groupBlameLines(source: GitBlameLine[]): BlameGroup[] {
+    const groups: BlameGroup[] = [];
+    for (const line of source) {
+      const last = groups[groups.length - 1];
+      if (last && last.hash === line.commit_hash) {
+        last.lines.push(line);
+        continue;
+      }
+      groups.push({
+        id: `${line.commit_hash}-${line.line_number}`,
+        hash: line.commit_hash,
+        shortHash: line.short_hash,
+        authorName: line.author_name,
+        authorEmail: line.author_email,
+        summary: line.summary,
+        authorTime: line.author_time,
+        isUncommitted: line.is_uncommitted,
+        lines: [line],
+      });
+    }
+    return groups;
+  }
+
+  function formatBlameDate(seconds: number): string {
+    if (!seconds) return "";
+    const date = new Date(seconds * 1000);
+    if (Number.isNaN(date.getTime())) return "";
+    return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" }).format(date);
+  }
+
+  function groupTooltip(group: BlameGroup): string {
+    if (group.isUncommitted) return "Not committed yet";
+    return `${group.authorName} <${group.authorEmail}>\n${group.summary}\n${group.hash}`;
+  }
+
+  function blameLineSearchText(line: GitBlameLine): string {
+    return [
+      line.line_number,
+      line.content,
+      line.commit_hash,
+      line.short_hash,
+      line.author_name,
+      line.author_email,
+      formatBlameDate(line.author_time),
+      line.summary,
+      line.is_uncommitted ? "uncommitted not committed yet" : "",
+    ].join("\n").toLowerCase();
+  }
+
+  function lineMatchesSearch(line: GitBlameLine, query: string): boolean {
+    return !query || blameLineSearchText(line).includes(query);
+  }
+
+  function textSegments(value: string | number): TextSegment[] {
+    const text = String(value ?? "");
+    const query = blameSearch.trim();
+    if (!query || !text) return [{ text, matched: false }];
+
+    const lowerText = text.toLowerCase();
+    const lowerQuery = query.toLowerCase();
+    const segments: TextSegment[] = [];
+    let cursor = 0;
+    let matchIndex = lowerText.indexOf(lowerQuery);
+
+    while (matchIndex !== -1) {
+      if (matchIndex > cursor) {
+        segments.push({ text: text.slice(cursor, matchIndex), matched: false });
+      }
+      const end = matchIndex + query.length;
+      segments.push({ text: text.slice(matchIndex, end), matched: true });
+      cursor = end;
+      matchIndex = lowerText.indexOf(lowerQuery, cursor);
+    }
+
+    if (cursor < text.length) {
+      segments.push({ text: text.slice(cursor), matched: false });
+    }
+
+    return segments.length > 0 ? segments : [{ text, matched: false }];
+  }
+
+  let searchQuery = $derived(blameSearch.trim().toLowerCase());
+  let searchActive = $derived(searchQuery.length > 0);
+  let visibleLines = $derived(searchActive ? lines.filter((line) => lineMatchesSearch(line, searchQuery)) : lines);
+  let groups = $derived(groupBlameLines(visibleLines));
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog blame-dialog" role="dialog" aria-modal="true" aria-label="File blame">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Blame</span>
+        <p class="dialog-title" title={filePath}>{filePath}</p>
+      </div>
+      <div class="dialog-header-actions">
+        <span class="pill pill-count">{lines.length}</span>
+        <button class="btn-sm dialog-close" type="button" onclick={onClose} disabled={isBusy} aria-label="Close">
+          <X size={16} aria-hidden="true" />
+        </button>
+      </div>
+    </header>
+
+    <div class="dialog-diff blame-body">
+      {#if isLoading}
+        <div class="blank-state">
+          <LoaderCircle class="spin" size={18} aria-hidden="true" />
+          Loading blame...
+        </div>
+      {:else if error}
+        <div class="blank-state">{error}</div>
+      {:else if lines.length === 0}
+        <div class="blank-state">No blame information available for this file.</div>
+      {:else}
+        <div class="diff-header blame-code-header">
+          <FileCode size={13} aria-hidden="true" />
+          <span title={filePath}>{filePath}</span>
+          <strong>{searchActive ? `${visibleLines.length} of ${lines.length} lines` : `${lines.length} lines`}</strong>
+        </div>
+        <div class="blame-search-bar">
+          <Search size={14} aria-hidden="true" />
+          <input
+            bind:value={blameSearch}
+            autocomplete="off"
+            spellcheck="false"
+            placeholder="Search blame"
+            aria-label="Search blame"
+          />
+          {#if searchActive}
+            <button class="btn-sm blame-search-clear" type="button" onclick={() => { blameSearch = ""; }} aria-label="Clear blame search">
+              <X size={14} aria-hidden="true" />
+            </button>
+          {/if}
+        </div>
+        <div class="split-col-headers blame-column-headers">
+          <div class="split-col-label blame-commit-col-label">Commit</div>
+          <div class="split-col-label blame-code-col-label">Code</div>
+        </div>
+        <div class="split-diff blame-diff" role="table" aria-label="File blame">
+          <div class="split-pane blame-scroll">
+            {#if groups.length === 0}
+              <div class="blank-state">No matches found.</div>
+            {:else}
+              <div class="blame-code-table">
+                {#each groups as group (group.id)}
+                  <div class="blame-group" class:uncommitted={group.isUncommitted} title={groupTooltip(group)}>
+                    <div class="blame-meta">
+                      <span class="blame-hash">
+                        {#each textSegments(group.isUncommitted ? "Uncommitted" : group.shortHash) as segment, index (`hash-${group.id}-${index}`)}
+                          {#if segment.matched}<mark class="blame-search-hit">{segment.text}</mark>{:else}{segment.text}{/if}
+                        {/each}
+                      </span>
+                      <span class="blame-author">
+                        {#each textSegments(group.isUncommitted ? "Not committed yet" : group.authorName) as segment, index (`author-${group.id}-${index}`)}
+                          {#if segment.matched}<mark class="blame-search-hit">{segment.text}</mark>{:else}{segment.text}{/if}
+                        {/each}
+                      </span>
+                      <span class="blame-summary">
+                        {#each textSegments(group.summary || "No commit message") as segment, index (`summary-${group.id}-${index}`)}
+                          {#if segment.matched}<mark class="blame-search-hit">{segment.text}</mark>{:else}{segment.text}{/if}
+                        {/each}
+                      </span>
+                      {#if !group.isUncommitted}
+                        <span class="blame-date">
+                          {#each textSegments(formatBlameDate(group.authorTime)) as segment, index (`date-${group.id}-${index}`)}
+                            {#if segment.matched}<mark class="blame-search-hit">{segment.text}</mark>{:else}{segment.text}{/if}
+                          {/each}
+                        </span>
+                      {/if}
+                    </div>
+                    <div class="split-pane-grid blame-lines">
+                      {#each group.lines as line (line.line_number)}
+                        <span class="split-num blame-line-number">{line.line_number}</span>
+                        <code class="split-cell blame-line-code">
+                          {#each textSegments(line.content) as segment, index (`line-${line.line_number}-${index}`)}
+                            {#if segment.matched}<mark class="blame-search-hit">{segment.text}</mark>{:else}{segment.text}{/if}
+                          {/each}
+                        </code>
+                      {/each}
+                    </div>
+                  </div>
+                {/each}
+              </div>
+            {/if}
+          </div>
+        </div>
+      {/if}
+    </div>
+  </div>
+</div>

src/lib/components/BranchDeleteConfirmDialog.svelte

@@ -0,0 +1,76 @@
+<script lang="ts">
+  import { AlertTriangle, GitBranch, LoaderCircle, Trash2, X } from "@lucide/svelte";
+  import type { GitBranch as GitBranchInfo } from "../types";
+
+  interface Props {
+    branch: GitBranchInfo;
+    force: boolean;
+    isBusy: boolean;
+    onConfirm: () => void | Promise<void>;
+    onClose: () => void;
+  }
+
+  let {
+    branch,
+    force = false,
+    isBusy = false,
+    onConfirm = () => {},
+    onClose = () => {},
+  }: Props = $props();
+
+  let title = $derived(force ? "Force delete branch?" : "Delete branch?");
+
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog branch-delete-dialog" role="dialog" aria-modal="true" aria-label={title}>
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">{force ? "Force delete" : "Delete branch"}</span>
+        <p class="dialog-title">{title}</p>
+      </div>
+      <button class="btn-sm dialog-close" type="button" onclick={onClose} disabled={isBusy} aria-label="Close">
+        <X size={16} aria-hidden="true" />
+      </button>
+    </header>
+
+    <div class="branch-delete-body">
+      <div class="discard-warning-icon" aria-hidden="true">
+        <AlertTriangle size={22} />
+      </div>
+
+      <div class="discard-confirm-copy">
+        <p>
+          {#if force}
+            This branch is not fully merged. Force deleting removes the branch pointer even if some commits are only reachable from this branch.
+          {:else}
+            Delete this local branch from the repository?
+          {/if}
+        </p>
+        <code class="discard-target" title={branch.name}>
+          <GitBranch size={13} aria-hidden="true" />
+          {branch.name}
+        </code>
+        <p class="discard-warning-text">
+          {#if force}
+            Make sure you no longer need the unique commits on this branch.
+          {:else}
+            Git will refuse if the branch is not fully merged.
+          {/if}
+        </p>
+      </div>
+    </div>
+
+    <footer class="discard-confirm-actions">
+      <button class="btn-secondary" type="button" onclick={onClose} disabled={isBusy}>Cancel</button>
+      <button class="btn-danger" type="button" onclick={onConfirm} disabled={isBusy}>
+        {#if isBusy}
+          <LoaderCircle class="spin" size={15} aria-hidden="true" />
+        {:else}
+          <Trash2 size={15} aria-hidden="true" />
+        {/if}
+        {force ? "Force delete" : "Delete"}
+      </button>
+    </footer>
+  </div>
+</div>

src/lib/components/BranchPanel.svelte

@@ -1,107 +1,700 @@
 <script lang="ts">
-  import { GitBranch, GitMerge } from "@lucide/svelte";
-  import type { GitBranch as GitBranchInfo } from "../types";
+  import { Check, ChevronDown, ChevronRight, Folder, FolderOpen, GitBranch, GitMerge, Pencil, Plus, Tag as TagIcon, Trash2, Upload, X } from "@lucide/svelte";
+  import type { GitBranch as GitBranchInfo, GitTag } from "../types";
+
+  type BranchTreeNode = BranchFolderNode | BranchLeafNode;
+
+  interface BranchFolderNode {
+    kind: "folder";
+    id: string;
+    name: string;
+    children: BranchTreeNode[];
+    branchCount: number;
+    current: boolean;
+    folders: Map<string, BranchFolderNode>;
+  }
+
+  interface BranchLeafNode {
+    kind: "branch";
+    id: string;
+    branch: GitBranchInfo;
+    displayName: string;
+  }
+
+  type BranchRow = BranchFolderRow | BranchLeafRow;
+
+  interface BranchFolderRow {
+    kind: "folder";
+    id: string;
+    name: string;
+    depth: number;
+    branchCount: number;
+    current: boolean;
+  }
+
+  interface BranchLeafRow {
+    kind: "branch";
+    id: string;
+    branch: GitBranchInfo;
+    displayName: string;
+    depth: number;
+    scopeLabel: string;
+  }
 
   interface Props {
     branches: GitBranchInfo[];
     localBranches: GitBranchInfo[];
     remoteBranches: GitBranchInfo[];
+    tags: GitTag[];
     hasRepository: boolean;
     isBusy: boolean;
     onCheckout: (branch: GitBranchInfo) => void;
     onMerge: (branch: GitBranchInfo) => void;
+    onRebase: (branch: GitBranchInfo) => void;
+    onCreateBranch: (branchName: string) => void | Promise<void>;
+    onRenameBranch: (branch: GitBranchInfo) => void | Promise<void>;
+    onDeleteBranch: (branch: GitBranchInfo) => void | Promise<void>;
+    onCreateTag: (name: string, message: string) => void | Promise<void>;
+    onDeleteTag: (tag: GitTag) => void | Promise<void>;
+    onPushTag: (tag: GitTag) => void | Promise<void>;
+    collapsed?: boolean;
+    onToggleCollapsed?: () => void;
   }
 
   let {
     branches = [],
     localBranches = [],
     remoteBranches = [],
+    tags = [],
     hasRepository = false,
     isBusy = false,
     onCheckout = () => {},
     onMerge = () => {},
+    onRebase = () => {},
+    onCreateBranch = () => {},
+    onRenameBranch = () => {},
+    onDeleteBranch = () => {},
+    onCreateTag = () => {},
+    onDeleteTag = () => {},
+    onPushTag = () => {},
+    collapsed = false,
+    onToggleCollapsed = () => {},
   }: Props = $props();
+
+  let localOpen = $state(true);
+  let remoteOpen = $state(false);
+  let tagsOpen = $state(false);
+  let createOpen = $state(false);
+  let newBranchName = $state("");
+  let createInput = $state<HTMLInputElement | null>(null);
+  let tagCreateOpen = $state(false);
+  let newTagName = $state("");
+  let newTagMessage = $state("");
+  let tagCreateInput = $state<HTMLInputElement | null>(null);
+  let panelElement = $state<HTMLElement | null>(null);
+  let contextBranch = $state<GitBranchInfo | null>(null);
+  let contextMenuX = $state(0);
+  let contextMenuY = $state(0);
+  let contextTag = $state<GitTag | null>(null);
+  let tagContextMenuX = $state(0);
+  let tagContextMenuY = $state(0);
+  let collapsedBranchFolders = $state<Set<string>>(new Set());
+
+  let localBranchRows = $derived(buildBranchRows("local", localBranches, "local"));
+  let remoteBranchRows = $derived(buildBranchRows("remote", remoteBranches, "remote"));
+
+  function createFolder(id: string, name: string): BranchFolderNode {
+    return {
+      kind: "folder",
+      id,
+      name,
+      children: [],
+      branchCount: 0,
+      current: false,
+      folders: new Map(),
+    };
+  }
+
+  function buildBranchRows(scope: string, branchList: GitBranchInfo[], scopeLabel: string): BranchRow[] {
+    const root = createFolder(`${scope}:root`, "");
+
+    for (const branch of branchList) {
+      const parts = branch.name.split("/").filter(Boolean);
+      const displayName = parts.length > 0 ? parts[parts.length - 1] : branch.name;
+      const folderParts = parts.slice(0, -1);
+      let parent = root;
+
+      for (let index = 0; index < folderParts.length; index += 1) {
+        const folderName = folderParts[index];
+        const folderPath = folderParts.slice(0, index + 1).join("/");
+        let folder = parent.folders.get(folderName);
+
+        if (!folder) {
+          folder = createFolder(`${scope}:folder:${folderPath}`, folderName);
+          parent.folders.set(folderName, folder);
+          parent.children.push(folder);
+        }
+
+        folder.branchCount += 1;
+        folder.current ||= branch.current;
+        parent = folder;
+      }
+
+      parent.children.push({
+        kind: "branch",
+        id: `${scope}:branch:${branch.name}`,
+        branch,
+        displayName,
+      });
+    }
+
+    sortBranchNodes(root.children);
+
+    const rows: BranchRow[] = [];
+    flattenBranchNodes(root.children, rows, 0, scopeLabel);
+    return rows;
+  }
+
+  function sortBranchNodes(nodes: BranchTreeNode[]) {
+    nodes.sort((left, right) => {
+      if (left.kind !== right.kind) return left.kind === "folder" ? -1 : 1;
+      const leftName = left.kind === "folder" ? left.name : left.displayName;
+      const rightName = right.kind === "folder" ? right.name : right.displayName;
+      return leftName.localeCompare(rightName, undefined, { sensitivity: "base" });
+    });
+
+    for (const node of nodes) {
+      if (node.kind === "folder") sortBranchNodes(node.children);
+    }
+  }
+
+  function flattenBranchNodes(nodes: BranchTreeNode[], rows: BranchRow[], depth: number, scopeLabel: string) {
+    for (const node of nodes) {
+      if (node.kind === "folder") {
+        rows.push({
+          kind: "folder",
+          id: node.id,
+          name: node.name,
+          depth,
+          branchCount: node.branchCount,
+          current: node.current,
+        });
+
+        if (isBranchFolderOpen(node.id)) {
+          flattenBranchNodes(node.children, rows, depth + 1, scopeLabel);
+        }
+      } else {
+        rows.push({
+          kind: "branch",
+          id: node.id,
+          branch: node.branch,
+          displayName: node.displayName,
+          depth,
+          scopeLabel,
+        });
+      }
+    }
+  }
+
+  function isBranchFolderOpen(id: string) {
+    return !collapsedBranchFolders.has(id);
+  }
+
+  function toggleBranchFolder(id: string) {
+    const next = new Set(collapsedBranchFolders);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    collapsedBranchFolders = next;
+  }
+
+  function openCreateForm() {
+    if (!hasRepository || isBusy) return;
+    createOpen = true;
+    queueMicrotask(() => createInput?.focus());
+  }
+
+  function closeCreateForm() {
+    createOpen = false;
+    newBranchName = "";
+  }
+
+  async function submitCreate(event: SubmitEvent) {
+    event.preventDefault();
+    const value = newBranchName.trim();
+    if (!value || !hasRepository || isBusy) return;
+    await onCreateBranch(value);
+    newBranchName = "";
+    createOpen = false;
+    localOpen = true;
+  }
+
+  function checkoutOnDoubleClick(event: MouseEvent, branch: GitBranchInfo) {
+    if (branch.current || isBusy) return;
+    const target = event.target instanceof HTMLElement ? event.target : null;
+    if (target?.closest("button")) return;
+    onCheckout(branch);
+  }
+
+  function openBranchContextMenu(event: MouseEvent, branch: GitBranchInfo) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (isBusy) return;
+
+    const rect = panelElement?.getBoundingClientRect();
+    const rawX = rect ? event.clientX - rect.left : event.offsetX;
+    const rawY = rect ? event.clientY - rect.top : event.offsetY;
+    const maxX = Math.max(8, (rect?.width ?? window.innerWidth) - 192);
+    const maxY = Math.max(8, (rect?.height ?? window.innerHeight) - 190);
+
+    contextBranch = branch;
+    contextMenuX = Math.max(8, Math.min(rawX, maxX));
+    contextMenuY = Math.max(8, Math.min(rawY, maxY));
+  }
+
+  function closeBranchContextMenu() {
+    contextBranch = null;
+  }
+
+  async function renameContextBranch() {
+    const branch = contextBranch;
+    if (!branch || isBusy) return;
+    closeBranchContextMenu();
+    await onRenameBranch(branch);
+  }
+
+  async function deleteContextBranch() {
+    const branch = contextBranch;
+    if (!branch || branch.current || branch.remote || isBusy) return;
+    closeBranchContextMenu();
+    await onDeleteBranch(branch);
+  }
+
+  async function checkoutContextBranch() {
+    const branch = contextBranch;
+    if (!branch || branch.current || isBusy) return;
+    closeBranchContextMenu();
+    await onCheckout(branch);
+  }
+
+  async function mergeContextBranch() {
+    const branch = contextBranch;
+    if (!branch || branch.current || isBusy) return;
+    closeBranchContextMenu();
+    await onMerge(branch);
+  }
+
+  async function rebaseContextBranch() {
+    const branch = contextBranch;
+    if (!branch || branch.current || isBusy) return;
+    closeBranchContextMenu();
+    await onRebase(branch);
+  }
+
+  function openTagCreateForm() {
+    if (!hasRepository || isBusy) return;
+    tagCreateOpen = true;
+    queueMicrotask(() => tagCreateInput?.focus());
+  }
+
+  function closeTagCreateForm() {
+    tagCreateOpen = false;
+    newTagName = "";
+    newTagMessage = "";
+  }
+
+  async function submitCreateTag(event: SubmitEvent) {
+    event.preventDefault();
+    const name = newTagName.trim();
+    if (!name || !hasRepository || isBusy) return;
+    await onCreateTag(name, newTagMessage.trim());
+    newTagName = "";
+    newTagMessage = "";
+    tagCreateOpen = false;
+    tagsOpen = true;
+  }
+
+  function openTagContextMenu(event: MouseEvent, tag: GitTag) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (isBusy) return;
+
+    const rect = panelElement?.getBoundingClientRect();
+    const rawX = rect ? event.clientX - rect.left : event.offsetX;
+    const rawY = rect ? event.clientY - rect.top : event.offsetY;
+    const maxX = Math.max(8, (rect?.width ?? window.innerWidth) - 192);
+    const maxY = Math.max(8, (rect?.height ?? window.innerHeight) - 130);
+
+    contextTag = tag;
+    tagContextMenuX = Math.max(8, Math.min(rawX, maxX));
+    tagContextMenuY = Math.max(8, Math.min(rawY, maxY));
+  }
+
+  function closeTagContextMenu() {
+    contextTag = null;
+  }
+
+  async function pushContextTag() {
+    const tag = contextTag;
+    if (!tag || isBusy) return;
+    closeTagContextMenu();
+    await onPushTag(tag);
+  }
+
+  async function deleteContextTag() {
+    const tag = contextTag;
+    if (!tag || isBusy) return;
+    closeTagContextMenu();
+    await onDeleteTag(tag);
+  }
+
+  function closeAllContextMenus() {
+    closeBranchContextMenu();
+    closeTagContextMenu();
+  }
+
+  function handleWindowKeydown(event: KeyboardEvent) {
+    if (event.key === "Escape") closeAllContextMenus();
+  }
 </script>
 
-<section class="panel grid grid-rows-[auto_1fr] overflow-hidden" aria-label="Branches">
+<svelte:window on:click={closeAllContextMenus} on:keydown={handleWindowKeydown} on:contextmenu|capture={closeAllContextMenus} />
+
+<section bind:this={panelElement} class="panel branch-panel grid grid-rows-[auto_1fr] overflow-hidden" class:collapsed aria-label="Branches">
   <div class="section-head">
     <div>
       <span class="eyebrow">Branches</span>
       <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Refs</h2>
     </div>
+    <div class="branch-head-actions">
+      <button
+        class="branch-create-toggle"
+        type="button"
+        onclick={openCreateForm}
+        disabled={!hasRepository || isBusy}
+        title="Create new branch"
+        aria-label="Create new branch"
+      >
+        <Plus size={14} aria-hidden="true" />
+      </button>
       <span class="pill pill-count">{branches.length}</span>
+      <button
+        class="branch-create-toggle panel-collapse-toggle"
+        type="button"
+        onclick={onToggleCollapsed}
+        aria-expanded={!collapsed}
+        title={collapsed ? "Expand branches" : "Collapse branches"}
+        aria-label={collapsed ? "Expand branches panel" : "Collapse branches panel"}
+      >
+        {#if collapsed}
+          <ChevronRight size={14} aria-hidden="true" />
+        {:else}
+          <ChevronDown size={14} aria-hidden="true" />
+        {/if}
+      </button>
+    </div>
   </div>
 
-  {#if !hasRepository}
+  {#if collapsed}
+    <!-- collapsed -->
+  {:else if !hasRepository}
     <p class="blank-state">Open a repository to list branches.</p>
-  {:else if branches.length === 0}
+  {:else if branches.length === 0 && tags.length === 0}
     <p class="blank-state">No branches returned.</p>
   {:else}
-    <div class="overflow-auto p-2 flex flex-col gap-0">
-      {#if localBranches.length > 0}
-        <div class="branch-group-label">
-          <span>Local</span>
-          <span class="branch-group-count">{localBranches.length}</span>
-        </div>
-        {#each localBranches as branch (branch.name)}
-          {#snippet branchCard()}
-            <article class="branch-row" class:current={branch.current}>
-              <div class="branch-info">
-                <GitBranch size={16} aria-hidden="true" />
-                <div>
-                  <strong>{branch.name}</strong>
-                  <span>local</span>
-                </div>
-              </div>
-              {#if branch.current}
-                <span class="pill pill-active">Current</span>
-              {:else}
-                <div class="branch-actions">
-                  <button class="btn-sm" type="button" onclick={() => onCheckout(branch)} disabled={isBusy}>
-                    Checkout
+    <div class="branch-list overflow-auto p-2 flex flex-col gap-0">
+      {#if createOpen}
+        <form class="branch-create-form" onsubmit={submitCreate}>
+          <GitBranch size={15} aria-hidden="true" />
+          <input
+            bind:this={createInput}
+            bind:value={newBranchName}
+            disabled={isBusy}
+            autocomplete="off"
+            spellcheck="false"
+            placeholder="new-branch-name"
+            aria-label="New branch name"
+          />
+          <button class="branch-create-action confirm" type="submit" disabled={isBusy || newBranchName.trim().length === 0} title="Create branch">
+            <Check size={14} aria-hidden="true" />
           </button>
-                  <button class="btn-sm" type="button" onclick={() => onMerge(branch)} disabled={isBusy} title="Merge into current">
-                    <GitMerge size={15} aria-hidden="true" />
-                    Merge
+          <button class="branch-create-action" type="button" onclick={closeCreateForm} disabled={isBusy} title="Cancel">
+            <X size={14} aria-hidden="true" />
           </button>
-                </div>
-              {/if}
-            </article>
-          {/snippet}
-          {@render branchCard()}
-        {/each}
+        </form>
       {/if}
 
-      {#if remoteBranches.length > 0}
-        <div class="branch-group-label" style="margin-top: {localBranches.length > 0 ? '12px' : '0'}">
-          <span>Remote</span>
-          <span class="branch-group-count">{remoteBranches.length}</span>
-        </div>
-        {#each remoteBranches as branch (branch.name)}
-          <article class="branch-row" class:current={branch.current}>
+      <div class="branch-group">
+        <button
+          class="branch-group-toggle"
+          type="button"
+          onclick={() => { localOpen = !localOpen; }}
+          aria-expanded={localOpen}
+        >
+          {#if localOpen}
+            <ChevronDown size={14} aria-hidden="true" />
+          {:else}
+            <ChevronRight size={14} aria-hidden="true" />
+          {/if}
+          <span>Local</span>
+          <span class="branch-group-count">{localBranches.length}</span>
+        </button>
+
+        {#if localOpen}
+          {#if localBranches.length === 0}
+            <div class="branch-empty">No local branches.</div>
+          {:else}
+            {#each localBranchRows as row (row.id)}
+              {#if row.kind === "folder"}
+                <button
+                  class="branch-folder-row"
+                  class:current={row.current}
+                  style={`--branch-indent: ${row.depth * 16}px;`}
+                  type="button"
+                  onclick={() => toggleBranchFolder(row.id)}
+                  aria-expanded={isBranchFolderOpen(row.id)}
+                  title={`${row.name} (${row.branchCount})`}
+                >
+                  {#if isBranchFolderOpen(row.id)}
+                    <ChevronDown size={14} aria-hidden="true" />
+                    <FolderOpen size={15} aria-hidden="true" />
+                  {:else}
+                    <ChevronRight size={14} aria-hidden="true" />
+                    <Folder size={15} aria-hidden="true" />
+                  {/if}
+                  <span class="branch-folder-name">{row.name}</span>
+                  <span class="branch-folder-count">{row.branchCount}</span>
+                </button>
+              {:else}
+                <article
+                  class="branch-row"
+                  class:current={row.branch.current}
+                  style={`--branch-indent: ${row.depth * 16}px;`}
+                  ondblclick={(event) => checkoutOnDoubleClick(event, row.branch)}
+                  oncontextmenu={(event) => openBranchContextMenu(event, row.branch)}
+                  title={row.branch.current ? "Current branch" : row.branch.name}
+                >
                   <div class="branch-info">
                     <GitBranch size={16} aria-hidden="true" />
                     <div>
-                <strong>{branch.name}</strong>
-                <span>remote</span>
+                      <strong>{row.displayName}</strong>
+                      <span>{row.scopeLabel}</span>
                     </div>
                   </div>
-            {#if branch.current}
+                  {#if row.branch.current}
                     <span class="pill pill-active">Current</span>
+                  {/if}
+                </article>
+              {/if}
+            {/each}
+          {/if}
+        {/if}
+      </div>
+
+      <div class="branch-group">
+        <button
+          class="branch-group-toggle"
+          type="button"
+          onclick={() => { remoteOpen = !remoteOpen; }}
+          aria-expanded={remoteOpen}
+        >
+          {#if remoteOpen}
+            <ChevronDown size={14} aria-hidden="true" />
           {:else}
-              <div class="branch-actions">
-                <button class="btn-sm" type="button" onclick={() => onCheckout(branch)} disabled={isBusy}>
-                  Checkout
+            <ChevronRight size={14} aria-hidden="true" />
+          {/if}
+          <span>Remote</span>
+          <span class="branch-group-count">{remoteBranches.length}</span>
         </button>
-                <button class="btn-sm" type="button" onclick={() => onMerge(branch)} disabled={isBusy} title="Merge into current">
-                  <GitMerge size={15} aria-hidden="true" />
-                  Merge
+
+        {#if remoteOpen}
+          {#if remoteBranches.length === 0}
+            <div class="branch-empty">No remote branches.</div>
+          {:else}
+            {#each remoteBranchRows as row (row.id)}
+              {#if row.kind === "folder"}
+                <button
+                  class="branch-folder-row"
+                  class:current={row.current}
+                  style={`--branch-indent: ${row.depth * 16}px;`}
+                  type="button"
+                  onclick={() => toggleBranchFolder(row.id)}
+                  aria-expanded={isBranchFolderOpen(row.id)}
+                  title={`${row.name} (${row.branchCount})`}
+                >
+                  {#if isBranchFolderOpen(row.id)}
+                    <ChevronDown size={14} aria-hidden="true" />
+                    <FolderOpen size={15} aria-hidden="true" />
+                  {:else}
+                    <ChevronRight size={14} aria-hidden="true" />
+                    <Folder size={15} aria-hidden="true" />
+                  {/if}
+                  <span class="branch-folder-name">{row.name}</span>
+                  <span class="branch-folder-count">{row.branchCount}</span>
+                </button>
+              {:else}
+                <article
+                  class="branch-row"
+                  class:current={row.branch.current}
+                  style={`--branch-indent: ${row.depth * 16}px;`}
+                  ondblclick={(event) => checkoutOnDoubleClick(event, row.branch)}
+                  oncontextmenu={(event) => openBranchContextMenu(event, row.branch)}
+                  title={row.branch.current ? "Current branch" : row.branch.name}
+                >
+                  <div class="branch-info">
+                    <GitBranch size={16} aria-hidden="true" />
+                    <div>
+                      <strong>{row.displayName}</strong>
+                      <span>{row.scopeLabel}</span>
+                    </div>
+                  </div>
+                  {#if row.branch.current}
+                    <span class="pill pill-active">Current</span>
+                  {/if}
+                </article>
+              {/if}
+            {/each}
+          {/if}
+        {/if}
+      </div>
+
+      <div class="branch-group">
+        <div class="tag-group-head">
+          <button
+            class="branch-group-toggle"
+            type="button"
+            onclick={() => { tagsOpen = !tagsOpen; }}
+            aria-expanded={tagsOpen}
+          >
+            {#if tagsOpen}
+              <ChevronDown size={14} aria-hidden="true" />
+            {:else}
+              <ChevronRight size={14} aria-hidden="true" />
+            {/if}
+            <span>Tags</span>
+            <span class="branch-group-count">{tags.length}</span>
+          </button>
+          <button
+            class="branch-create-toggle"
+            type="button"
+            onclick={openTagCreateForm}
+            disabled={!hasRepository || isBusy}
+            title="Create new tag"
+            aria-label="Create new tag"
+          >
+            <Plus size={13} aria-hidden="true" />
           </button>
         </div>
+
+        {#if tagCreateOpen}
+          <form class="branch-create-form tag-create-form" onsubmit={submitCreateTag}>
+            <TagIcon size={15} aria-hidden="true" />
+            <input
+              bind:this={tagCreateInput}
+              bind:value={newTagName}
+              disabled={isBusy}
+              autocomplete="off"
+              spellcheck="false"
+              placeholder="v1.0.0"
+              aria-label="New tag name"
+            />
+            <input
+              bind:value={newTagMessage}
+              disabled={isBusy}
+              autocomplete="off"
+              spellcheck="false"
+              placeholder="Message (optional)"
+              aria-label="Tag message"
+            />
+            <button class="branch-create-action confirm" type="submit" disabled={isBusy || newTagName.trim().length === 0} title="Create tag">
+              <Check size={14} aria-hidden="true" />
+            </button>
+            <button class="branch-create-action" type="button" onclick={closeTagCreateForm} disabled={isBusy} title="Cancel">
+              <X size={14} aria-hidden="true" />
+            </button>
+          </form>
         {/if}
+
+        {#if tagsOpen}
+          {#if tags.length === 0}
+            <div class="branch-empty">No tags.</div>
+          {:else}
+            {#each tags as tag (tag.name)}
+              <article
+                class="branch-row"
+                oncontextmenu={(event) => openTagContextMenu(event, tag)}
+                title={tag.message ?? tag.name}
+              >
+                <div class="branch-info">
+                  <TagIcon size={16} aria-hidden="true" />
+                  <div>
+                    <strong>{tag.name}</strong>
+                    <span>{tag.short_hash}</span>
+                  </div>
+                </div>
               </article>
             {/each}
           {/if}
+        {/if}
+      </div>
+    </div>
+  {/if}
+
+  {#if contextBranch}
+    <div
+      class="branch-context-menu"
+      style={`left: ${contextMenuX}px; top: ${contextMenuY}px;`}
+      role="menu"
+      tabindex="-1"
+      aria-label={`Actions for ${contextBranch.name}`}
+    >
+      <button type="button" role="menuitem" onclick={checkoutContextBranch} disabled={isBusy || contextBranch.current}>
+        <GitBranch size={14} aria-hidden="true" />
+        Checkout
+      </button>
+      <button type="button" role="menuitem" onclick={mergeContextBranch} disabled={isBusy || contextBranch.current}>
+        <GitMerge size={14} aria-hidden="true" />
+        Merge into current
+      </button>
+      <button type="button" role="menuitem" onclick={rebaseContextBranch} disabled={isBusy || contextBranch.current}>
+        <GitBranch size={14} aria-hidden="true" />
+        Rebase current onto this
+      </button>
+      <div class="menu-separator" role="separator"></div>
+      <button type="button" role="menuitem" onclick={renameContextBranch} disabled={isBusy || contextBranch.remote}>
+        <Pencil size={14} aria-hidden="true" />
+        Rename
+      </button>
+      <button
+        class="danger"
+        type="button"
+        role="menuitem"
+        onclick={deleteContextBranch}
+        disabled={isBusy || contextBranch.current || contextBranch.remote}
+        title={contextBranch.current ? "Current branch cannot be deleted" : contextBranch.remote ? "Remote branch cannot be deleted here" : "Delete local branch"}
+      >
+        <Trash2 size={14} aria-hidden="true" />
+        Delete
+      </button>
+    </div>
+  {/if}
+
+  {#if contextTag}
+    <div
+      class="branch-context-menu"
+      style={`left: ${tagContextMenuX}px; top: ${tagContextMenuY}px;`}
+      role="menu"
+      tabindex="-1"
+      aria-label={`Actions for ${contextTag.name}`}
+    >
+      <button type="button" role="menuitem" onclick={pushContextTag} disabled={isBusy}>
+        <Upload size={14} aria-hidden="true" />
+        Push to remote
+      </button>
+      <div class="menu-separator" role="separator"></div>
+      <button class="danger" type="button" role="menuitem" onclick={deleteContextTag} disabled={isBusy} title="Delete local tag">
+        <Trash2 size={14} aria-hidden="true" />
+        Delete
+      </button>
     </div>
   {/if}
 </section>

src/lib/components/CloneRepositoryDialog.svelte

@@ -0,0 +1,175 @@
+<script lang="ts">
+  import { onDestroy } from "svelte";
+  import { open as openDialog } from "@tauri-apps/plugin-dialog";
+  import { Download, FolderOpen, LoaderCircle, X } from "@lucide/svelte";
+
+  interface Props {
+    isBusy: boolean;
+    error: string;
+    onClone: (remoteUrl: string, parentPath: string, directoryName: string) => void;
+    onClose: () => void;
+  }
+
+  let {
+    isBusy = false,
+    error = "",
+    onClone = () => {},
+    onClose = () => {},
+  }: Props = $props();
+
+  let remoteUrl = $state("");
+  let parentPath = $state("");
+  let directoryName = $state("");
+  let directoryNameEdited = $state(false);
+  let directoryAutoName = $state("");
+  let browseError = $state("");
+  let visibleError = $state("");
+  let errorHideTimer: ReturnType<typeof setTimeout> | undefined;
+
+  let directorySuggestion = $derived(directoryNameFromRemoteUrl(remoteUrl));
+  let canSubmit = $derived(
+    !isBusy &&
+    remoteUrl.trim().length > 0 &&
+    parentPath.trim().length > 0,
+  );
+
+  $effect(() => {
+    const nextError = error || browseError;
+    if (errorHideTimer) clearTimeout(errorHideTimer);
+    visibleError = nextError;
+    if (nextError) {
+      errorHideTimer = setTimeout(() => {
+        visibleError = "";
+      }, 6000);
+    }
+  });
+
+  onDestroy(() => {
+    if (errorHideTimer) clearTimeout(errorHideTimer);
+  });
+
+  function directoryNameFromRemoteUrl(url: string): string {
+    const trimmed = url.trim().split(/[?#]/, 1)[0]?.replace(/[\\/]+$/g, "") ?? "";
+    const lastSegment = trimmed.split(/[\\/:]/).filter(Boolean).pop() ?? "";
+    return lastSegment.replace(/\.git$/i, "").trim();
+  }
+
+  function errorToMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    try { return JSON.stringify(error) ?? "Unknown error"; } catch { return "Unknown error"; }
+  }
+
+  async function chooseParentFolder() {
+    if (isBusy) return;
+    browseError = "";
+    try {
+      const selected = await openDialog({
+        title: "Select clone destination",
+        directory: true,
+        multiple: false,
+        defaultPath: parentPath.trim() || undefined,
+      });
+      if (typeof selected !== "string") return;
+      parentPath = selected;
+    } catch (error) {
+      browseError = errorToMessage(error);
+    }
+  }
+
+  function handleRemoteInput(event: Event) {
+    const nextRemoteUrl = (event.currentTarget as HTMLInputElement).value;
+    if (directoryNameEdited) return;
+    directoryAutoName = directoryNameFromRemoteUrl(nextRemoteUrl);
+    directoryName = directoryAutoName;
+  }
+
+  function handleDirectoryInput(event: Event) {
+    const nextDirectoryName = (event.currentTarget as HTMLInputElement).value;
+    directoryNameEdited = nextDirectoryName.trim().length > 0 && nextDirectoryName !== directoryAutoName;
+  }
+
+  function submit(event: SubmitEvent) {
+    event.preventDefault();
+    if (!canSubmit) return;
+    onClone(remoteUrl.trim(), parentPath.trim(), directoryName.trim());
+  }
+
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog clone-repository-dialog" role="dialog" aria-modal="true" aria-label="Clone repository" tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Repository Management</span>
+        <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Clone repository</h2>
+      </div>
+      <button class="dialog-close" type="button" onclick={onClose} disabled={isBusy} title="Close">
+        <X size={18} aria-hidden="true" />
+      </button>
+    </header>
+
+    <form class="clone-dialog-form" onsubmit={submit}>
+      <label class="clone-dialog-field">
+        <span>Remote URL</span>
+        <!-- svelte-ignore a11y_autofocus -->
+        <input
+          bind:value={remoteUrl}
+          oninput={handleRemoteInput}
+          autocomplete="off"
+          spellcheck="false"
+          placeholder="https://github.com/org/project.git"
+          disabled={isBusy}
+          autofocus
+        />
+      </label>
+
+      <label class="clone-dialog-field">
+        <span>Destination</span>
+        <div class="clone-dialog-path-field">
+          <input
+            bind:value={parentPath}
+            autocomplete="off"
+            spellcheck="false"
+            placeholder="Choose parent folder"
+            disabled={isBusy}
+          />
+          <button class="btn-secondary" type="button" onclick={chooseParentFolder} disabled={isBusy}>
+            <FolderOpen size={14} aria-hidden="true" />
+            Browse
+          </button>
+        </div>
+      </label>
+
+      <label class="clone-dialog-field">
+        <span>Folder name</span>
+        <input
+          bind:value={directoryName}
+          oninput={handleDirectoryInput}
+          autocomplete="off"
+          spellcheck="false"
+          placeholder={directorySuggestion || "Optional"}
+          disabled={isBusy}
+        />
+      </label>
+
+      {#if visibleError}
+        <div class="clone-dialog-error" role="alert">{visibleError}</div>
+      {/if}
+
+      <div class="clone-dialog-actions">
+        <button class="btn-secondary" type="button" onclick={onClose} disabled={isBusy}>
+          Cancel
+        </button>
+        <button class="btn-primary" type="submit" disabled={!canSubmit}>
+          {#if isBusy}
+            <LoaderCircle class="spin" size={16} aria-hidden="true" />
+          {:else}
+            <Download size={16} aria-hidden="true" />
+          {/if}
+          Clone
+        </button>
+      </div>
+    </form>
+  </div>
+</div>

src/lib/components/CommitPanel.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-  import { Check, LoaderCircle } from "@lucide/svelte";
+  import { Check, LoaderCircle, RotateCcw, Settings, Sparkles } from "@lucide/svelte";
+  import type { CommitAiPhase, CommitAiProvider } from "../types";
 
   interface Props {
     commitMessage: string;
@@ -9,8 +10,17 @@
     isBusy: boolean;
     operation: string;
     stagedCount: number;
+    commitAiProvider: CommitAiProvider;
+    commitAiPhase: CommitAiPhase;
+    commitAiGenerating: boolean;
+    canAmend: boolean;
+    amendMode: boolean;
     onCommit: () => void;
     onCommitMessageChange: (msg: string) => void;
+    onGenerateCommitMessage: () => void;
+    onOpenAiSettings: () => void;
+    onToggleAmend: (checked: boolean) => void;
+    onUndoLastCommit: () => void;
   }
 
   let {
@@ -21,17 +31,42 @@
     isBusy = false,
     operation = "",
     stagedCount = 0,
+    commitAiProvider = "local",
+    commitAiPhase = "idle",
+    commitAiGenerating = false,
+    canAmend = false,
+    amendMode = false,
     onCommit = () => {},
     onCommitMessageChange = () => {},
+    onGenerateCommitMessage = () => {},
+    onOpenAiSettings = () => {},
+    onToggleAmend = () => {},
+    onUndoLastCommit = () => {},
   }: Props = $props();
 
   function handleSubmit(event: SubmitEvent) {
     event.preventDefault();
     onCommit();
   }
+
+  function aiButtonTitle(provider: CommitAiProvider, phase: CommitAiPhase, staged: number): string {
+    if (staged === 0) return "Stage changes first";
+    if (provider === "local" && phase === "loading") return "AI model is downloading/loading — this happens once";
+    if (provider === "local" && phase === "error") return "AI model failed to load — check AI settings";
+    return "Generate commit message with AI from the staged diff";
+  }
+
+  let localModelLoading = $derived(commitAiProvider === "local" && commitAiPhase === "loading");
+  let canGenerate = $derived(
+    hasRepository &&
+    !isBusy &&
+    !commitAiGenerating &&
+    stagedCount > 0 &&
+    (commitAiProvider !== "local" || commitAiPhase === "ready"),
+  );
 </script>
 
-<section class="panel flex flex-col" aria-label="Commit">
+<section class="panel commit-panel" aria-label="Commit">
   <div class="section-head">
     <div>
       <span class="eyebrow">Commit</span>
@@ -50,13 +85,62 @@
     {#if commitBlockReason}
       <p class="commit-block-reason">{commitBlockReason}</p>
     {/if}
-    <button class="btn-primary w-full flex-shrink-0" type="submit" disabled={!canCommit} title={commitBlockReason || "Commit staged changes"}>
-      {#if operation === "Committing"}
+    {#if canAmend}
+      <div class="commit-amend-row">
+        <label class="commit-amend-toggle">
+          <input
+            type="checkbox"
+            checked={amendMode}
+            disabled={isBusy}
+            onchange={(e) => onToggleAmend((e.target as HTMLInputElement).checked)}
+          />
+          Amend last commit
+        </label>
+        <button
+          class="btn-secondary commit-undo-button"
+          type="button"
+          onclick={onUndoLastCommit}
+          disabled={isBusy}
+          title="Undo the last commit — its changes come back as uncommitted changes (not pushed yet, so safe)"
+        >
+          <RotateCcw size={13} aria-hidden="true" />
+          Undo last commit
+        </button>
+      </div>
+    {/if}
+    <div class="commit-actions-row flex-shrink-0">
+      <button class="btn-primary flex-1" type="submit" disabled={!canCommit} title={commitBlockReason || (amendMode ? "Amend the last commit" : "Commit staged changes")}>
+        {#if operation === "Committing" || operation === "Amending"}
           <LoaderCircle class="spin" size={16} aria-hidden="true" />
         {:else}
           <Check size={16} aria-hidden="true" />
         {/if}
-      Commit
+        {amendMode ? "Amend" : "Commit"}
       </button>
+      <button
+        class="btn-secondary commit-ai-button"
+        type="button"
+        onclick={onGenerateCommitMessage}
+        disabled={!canGenerate}
+        title={aiButtonTitle(commitAiProvider, commitAiPhase, stagedCount)}
+      >
+        {#if commitAiGenerating || localModelLoading}
+          <LoaderCircle class="spin" size={16} aria-hidden="true" />
+        {:else}
+          <Sparkles size={16} aria-hidden="true" />
+        {/if}
+        AI
+      </button>
+      <button
+        class="btn-secondary commit-ai-settings-button"
+        type="button"
+        onclick={onOpenAiSettings}
+        disabled={isBusy}
+        title="AI settings"
+        aria-label="AI settings"
+      >
+        <Settings size={16} aria-hidden="true" />
+      </button>
+    </div>
   </form>
 </section>

src/lib/components/CompareDialog.svelte

@@ -15,6 +15,8 @@
     selectedDiffPath: string;
     isBusy: boolean;
     restoreLabel?: string;
+    /** When opened from a search hit, the term to highlight on matching lines. */
+    highlightQuery?: string;
     onClose: () => void;
     onRestore?: () => void;
     onSelectFile: (file: GitDiffFile) => void;
@@ -25,11 +27,25 @@
     selectedDiffPath = "",
     isBusy = false,
     restoreLabel = "",
+    highlightQuery = "",
     onClose = () => {},
     onRestore = undefined,
     onSelectFile = () => {},
   }: Props = $props();
 
+  // Needle = first non-empty line of the search query, lowercased for matching.
+  let highlightNeedle = $derived(
+    highlightQuery
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0)
+      ?.toLowerCase() ?? ""
+  );
+
+  function isMatch(text?: string): boolean {
+    return highlightNeedle.length > 0 && !!text && text.toLowerCase().includes(highlightNeedle);
+  }
+
   let beforePane = $state<HTMLDivElement | null>(null);
   let afterPane = $state<HTMLDivElement | null>(null);
   let isSyncingSplitScroll = false;
@@ -166,7 +182,6 @@
 <div
   class="dialog-backdrop"
   role="presentation"
-  onclick={(e) => { if (e.target === e.currentTarget) onClose(); }}
 >
   <div class="dialog compare-dialog" role="dialog" aria-modal="true" aria-label="Commit comparison" tabindex="-1">
 
@@ -259,8 +274,8 @@
                     {#if row.type === "span"}
                       <div class="split-span split-{row.kind}">{row.text}</div>
                     {:else}
-                      <div class="split-num" class:del={row.leftKind === "del"} class:empty={row.leftKind === "empty"}>{row.leftNum ?? ""}</div>
-                      <div class="split-cell" class:del={row.leftKind === "del"} class:empty={row.leftKind === "empty"}>{row.leftText ?? " "}</div>
+                      <div class="split-num" class:del={row.leftKind === "del"} class:empty={row.leftKind === "empty"} class:match={isMatch(row.leftText)}>{row.leftNum ?? ""}</div>
+                      <div class="split-cell" class:del={row.leftKind === "del"} class:empty={row.leftKind === "empty"} class:match={isMatch(row.leftText)}>{row.leftText ?? " "}</div>
                     {/if}
                   {/each}
                 </div>
@@ -276,8 +291,8 @@
                     {#if row.type === "span"}
                       <div class="split-span split-{row.kind}">{row.text}</div>
                     {:else}
-                      <div class="split-num" class:add={row.rightKind === "add"} class:empty={row.rightKind === "empty"}>{row.rightNum ?? ""}</div>
-                      <div class="split-cell" class:add={row.rightKind === "add"} class:empty={row.rightKind === "empty"}>{row.rightText ?? " "}</div>
+                      <div class="split-num" class:add={row.rightKind === "add"} class:empty={row.rightKind === "empty"} class:match={isMatch(row.rightText)}>{row.rightNum ?? ""}</div>
+                      <div class="split-cell" class:add={row.rightKind === "add"} class:empty={row.rightKind === "empty"} class:match={isMatch(row.rightText)}>{row.rightText ?? " "}</div>
                     {/if}
                   {/each}
                 </div>

src/lib/components/CompareSelectDialog.svelte

@@ -0,0 +1,107 @@
+<script lang="ts">
+  import { ArrowRight, GitCompare, LoaderCircle, X } from "@lucide/svelte";
+  import type { GitCommit } from "../types";
+
+  interface Props {
+    commits: GitCommit[];
+    compareFrom: string;
+    compareTo: string;
+    canCompare: boolean;
+    isBusy: boolean;
+    operation: string;
+    onCompareFromChange: (val: string) => void;
+    onCompareToChange: (val: string) => void;
+    onCompare: () => void;
+    onClose: () => void;
+  }
+
+  let {
+    commits = [],
+    compareFrom = "",
+    compareTo = "",
+    canCompare = false,
+    isBusy = false,
+    operation = "",
+    onCompareFromChange = () => {},
+    onCompareToChange = () => {},
+    onCompare = () => {},
+    onClose = () => {},
+  }: Props = $props();
+
+  function commitOptionLabel(item: GitCommit): string {
+    return `${item.short_hash} - ${item.summary}`;
+  }
+
+  function handleSubmit(event: SubmitEvent) {
+    event.preventDefault();
+    onCompare();
+  }
+</script>
+
+<div
+  class="dialog-backdrop"
+  role="presentation"
+>
+  <div class="dialog compare-select-dialog" role="dialog" aria-modal="true" aria-label="Select commits to compare" tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Compare</span>
+        <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Select commits</h2>
+      </div>
+      <button class="dialog-close" type="button" onclick={onClose} title="Close">
+        <X size={18} aria-hidden="true" />
+      </button>
+    </header>
+
+    {#if commits.length < 2}
+      <div class="blank-state">At least two commits are needed to compare.</div>
+    {:else}
+      <form class="compare-form" onsubmit={handleSubmit}>
+        <label class="compare-field">
+          <span>From (older)</span>
+          <select
+            value={compareFrom}
+            onchange={(e) => onCompareFromChange((e.target as HTMLSelectElement).value)}
+            disabled={isBusy}
+          >
+            <option value="" disabled>Select a commit</option>
+            {#each commits as item (item.hash)}
+              <option value={item.hash}>{commitOptionLabel(item)}</option>
+            {/each}
+          </select>
+        </label>
+
+        <ArrowRight class="compare-arrow" size={18} aria-hidden="true" />
+
+        <label class="compare-field">
+          <span>To (newer)</span>
+          <select
+            value={compareTo}
+            onchange={(e) => onCompareToChange((e.target as HTMLSelectElement).value)}
+            disabled={isBusy}
+          >
+            <option value="" disabled>Select a commit</option>
+            {#each commits as item (item.hash)}
+              <option value={item.hash}>{commitOptionLabel(item)}</option>
+            {/each}
+          </select>
+        </label>
+
+        <button class="btn-primary" type="submit" disabled={!canCompare}>
+          {#if operation === "Comparing commits"}
+            <LoaderCircle class="spin" size={16} aria-hidden="true" />
+          {:else}
+            <GitCompare size={16} aria-hidden="true" />
+          {/if}
+          Compare
+        </button>
+      </form>
+
+      {#if compareFrom && compareTo && compareFrom === compareTo}
+        <div class="blank-state">Select two different commits to compare.</div>
+      {:else}
+        <div class="blank-state">Pick two commits and run a comparison.</div>
+      {/if}
+    {/if}
+  </div>
+</div>

src/lib/components/CredentialDialog.svelte

@@ -14,7 +14,7 @@
   } from "@lucide/svelte";
 
   interface Props {
-    action: "push" | "pull";
+    action: "push" | "pull" | "fetch" | "clone";
     error: string;
     isBusy: boolean;
     onSubmit: (username: string, password: string, save: boolean, expiresAt: string | null) => void;
@@ -35,7 +35,7 @@
   let username = $state("");
   let password = $state("");
   let showPassword = $state(false);
-  let saveSession = $state(false);
+  let saveSession = $state(true);
   let expiresAt = $state("");
 
   let canSubmit = $derived(
@@ -43,11 +43,21 @@
     password.trim().length > 0 &&
     (mode === "token" || username.trim().length > 0),
   );
-  let actionLabel = $derived(action === "push" ? "Push" : "Pull");
-  let actionTitle = $derived(action === "push" ? "Push authentifizieren" : "Pull authentifizieren");
+  let actionLabel = $derived(action === "push" ? "Push" : action === "fetch" ? "Fetch" : action === "clone" ? "Clone" : "Pull");
+  let actionTitle = $derived(
+    action === "push"
+      ? "Authenticate push"
+      : action === "fetch"
+        ? "Authenticate fetch"
+        : action === "clone"
+          ? "Authenticate clone"
+          : "Authenticate pull",
+  );
   let actionHint = $derived(action === "push"
-    ? "Der Remote braucht Schreibrechte. Nutze ein Passwort oder einen Token mit passenden Repository-Rechten."
-    : "Der Remote braucht Zugriff auf das Repository. Nutze deine Git-Zugangsdaten oder einen Personal Access Token.");
+    ? "The remote needs write access. Use a password or a token with the appropriate repository permissions."
+    : action === "clone"
+      ? "The repository needs access before it can be cloned. Use your Git credentials or a personal access token."
+      : "The remote needs access to the repository. Use your Git credentials or a personal access token.");
 
   function handleSubmit(e: SubmitEvent) {
     e.preventDefault();
@@ -64,9 +74,8 @@
 <div
   class="dialog-backdrop"
   role="presentation"
-  onclick={(e) => { if (e.target === e.currentTarget) onCancel(); }}
 >
-  <div class="cred-card" role="dialog" aria-modal="true" aria-label="Git-Zugangsdaten" tabindex="-1">
+  <div class="cred-card" role="dialog" aria-modal="true" aria-label="Git credentials" tabindex="-1">
     <div class="cred-hero">
       <div class="cred-hero-top">
         <div class="cred-hero-icon">
@@ -80,7 +89,7 @@
           <p class="cred-hero-label">{actionLabel} Remote</p>
           <h2 class="cred-hero-title">{actionTitle}</h2>
         </div>
-        <button class="cred-close" type="button" onclick={onCancel} title="Abbrechen" aria-label="Abbrechen">
+        <button class="cred-close" type="button" onclick={onCancel} title="Cancel" aria-label="Cancel">
           <X size={16} aria-hidden="true" />
         </button>
       </div>
@@ -89,12 +98,12 @@
 
       <div class="cred-security-note">
         <ShieldCheck size={14} aria-hidden="true" />
-        <span>Beim Speichern landet der Token verschluesselt im Schluesselbund des Betriebssystems – nie im Klartext.</span>
+        <span>When saved, the token is stored encrypted in the operating system's keychain — never in plain text.</span>
       </div>
     </div>
 
     <form class="cred-body" onsubmit={handleSubmit}>
-      <div class="cred-segment" role="group" aria-label="Authentifizierungsart">
+      <div class="cred-segment" role="group" aria-label="Authentication method">
         <button
           type="button"
           class="cred-seg-btn"
@@ -103,7 +112,7 @@
           aria-pressed={mode === "credentials"}
         >
           <User size={13} aria-hidden="true" />
-          Username + Passwort
+          Username + password
         </button>
         <button
           type="button"
@@ -127,7 +136,7 @@
                 id="cred-username"
                 type="text"
                 bind:value={username}
-                placeholder="z. B. mein-github-username"
+                placeholder="e.g. my-github-username"
                 autocomplete="username"
                 disabled={isBusy}
               />
@@ -137,7 +146,7 @@
 
         <div class="cred-field">
           <label class="cred-field-label" for="cred-password">
-            {mode === "token" ? "Token" : "Passwort"}
+            {mode === "token" ? "Token" : "Password"}
           </label>
           <div class="cred-input">
             <Lock size={15} class="cred-field-icon" aria-hidden="true" />
@@ -146,8 +155,8 @@
               type={showPassword ? "text" : "password"}
               bind:value={password}
               placeholder={mode === "token"
-                ? "ghp_... oder anderer Zugangstoken"
-                : "Passwort oder Personal Access Token"}
+                ? "ghp_... or another access token"
+                : "Password or personal access token"}
               autocomplete="current-password"
               disabled={isBusy}
             />
@@ -156,7 +165,7 @@
               class="cred-reveal"
               onclick={() => { showPassword = !showPassword; }}
               tabindex="-1"
-              aria-label={showPassword ? "Verbergen" : "Anzeigen"}
+              aria-label={showPassword ? "Hide" : "Show"}
             >
               {#if showPassword}
                 <EyeOff size={14} aria-hidden="true" />
@@ -171,7 +180,7 @@
       {#if mode === "token"}
         <div class="cred-token-hint">
           <Key size={13} aria-hidden="true" />
-          <span>Username wird automatisch auf <code>oauth2</code> gesetzt. Das funktioniert mit GitHub, GitLab und Bitbucket.</span>
+          <span>Username is automatically set to <code>oauth2</code>. This works with GitHub, GitLab, and Bitbucket.</span>
         </div>
       {/if}
 
@@ -184,26 +193,26 @@
 
       {#if saveSession}
         <div class="cred-expiry">
-          <label class="cred-field-label" for="cred-expiry">Ablaufdatum (optional)</label>
+          <label class="cred-field-label" for="cred-expiry">Expiration date (optional)</label>
           <input
             id="cred-expiry"
             type="date"
             bind:value={expiresAt}
             disabled={isBusy}
           />
-          <span class="cred-expiry-hint">Nach diesem Datum wird automatisch erneut nach dem Login gefragt.</span>
+          <span class="cred-expiry-hint">After this date you'll automatically be asked to log in again.</span>
         </div>
       {/if}
 
       <div class="cred-footer">
         <label class="cred-save">
           <input type="checkbox" bind:checked={saveSession} disabled={isBusy} />
-          <span>Im Schluesselbund speichern</span>
+          <span>Save in keychain</span>
         </label>
 
         <div class="cred-btns">
           <button type="button" class="cred-cancel" onclick={onCancel} disabled={isBusy}>
-            Abbrechen
+            Cancel
           </button>
           <button class="cred-submit" type="submit" disabled={!canSubmit}>
             {#if isBusy}

src/lib/components/DiscardConfirmDialog.svelte

@@ -0,0 +1,87 @@
+<script lang="ts">
+  import { AlertTriangle, LoaderCircle, RotateCcw, X } from "@lucide/svelte";
+  import type { GitFileStatus } from "../types";
+
+  interface Props {
+    files: GitFileStatus[];
+    staged: boolean | null;
+    scope: "file" | "hunk";
+    isBusy: boolean;
+    onConfirm: () => void | Promise<void>;
+    onClose: () => void;
+  }
+
+  let {
+    files,
+    staged = false,
+    scope = "file",
+    isBusy = false,
+    onConfirm = () => {},
+    onClose = () => {},
+  }: Props = $props();
+
+  function targetPath(file: GitFileStatus): string {
+    return file.old_path ? `${file.old_path} -> ${file.path}` : file.path;
+  }
+
+  let count = $derived(files.length);
+  let title = $derived(
+    scope === "hunk" ? "Discard hunk?" : count > 1 ? `Discard changes in ${count} files?` : "Discard file changes?"
+  );
+  let scopeLabel = $derived(scope === "hunk" ? "selected hunk" : count > 1 ? `${count} files` : "file");
+  let sourceLabel = $derived(staged === null ? "staged and unstaged changes" : staged ? "staged changes" : "unstaged changes");
+
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog discard-confirm-dialog" role="dialog" aria-modal="true" aria-label={title}>
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Confirm discard</span>
+        <p class="dialog-title">{title}</p>
+      </div>
+      <button class="btn-sm dialog-close" type="button" onclick={onClose} disabled={isBusy} aria-label="Close">
+        <X size={16} aria-hidden="true" />
+      </button>
+    </header>
+
+    <div class="discard-confirm-body">
+      <div class="discard-warning-icon" aria-hidden="true">
+        <AlertTriangle size={22} />
+      </div>
+
+      <div class="discard-confirm-copy">
+        <p>
+          This will reset the {sourceLabel} for the {scopeLabel} below.
+        </p>
+        {#if count > 1}
+          <ul class="discard-target-list">
+            {#each files.slice(0, 8) as file (`${file.old_path ?? ""}:${file.path}`)}
+              <li><code class="discard-target" title={targetPath(file)}>{targetPath(file)}</code></li>
+            {/each}
+            {#if files.length > 8}
+              <li class="discard-target-more">+{files.length - 8} more</li>
+            {/if}
+          </ul>
+        {:else if count === 1}
+          <code class="discard-target" title={targetPath(files[0])}>{targetPath(files[0])}</code>
+        {/if}
+        <p class="discard-warning-text">
+          This cannot be undone. If a file only exists in your working tree, it can be deleted entirely.
+        </p>
+      </div>
+    </div>
+
+    <footer class="discard-confirm-actions">
+      <button class="btn-secondary" type="button" onclick={onClose} disabled={isBusy}>Cancel</button>
+      <button class="btn-danger" type="button" onclick={onConfirm} disabled={isBusy}>
+        {#if isBusy}
+          <LoaderCircle class="spin" size={15} aria-hidden="true" />
+        {:else}
+          <RotateCcw size={15} aria-hidden="true" />
+        {/if}
+        Discard
+      </button>
+    </footer>
+  </div>
+</div>

src/lib/components/ExplorerPanel.svelte

@@ -17,6 +17,8 @@
     FileVideo,
     Folder,
     FolderOpen,
+    ExternalLink,
+    History,
     Terminal,
   } from "@lucide/svelte";
   import { languageIconForPath } from "../languageIcons";
@@ -34,6 +36,10 @@
     onExpandAllFolders: () => void;
     onCollapseAllFolders: () => void;
     onSelectNode: (node: ExplorerNode) => void;
+    onOpenFile: (node: ExplorerNode) => void;
+    onBlame: (node: ExplorerNode) => void;
+    collapsed?: boolean;
+    onToggleCollapsed?: () => void;
   }
 
   let {
@@ -47,8 +53,16 @@
     onExpandAllFolders = () => {},
     onCollapseAllFolders = () => {},
     onSelectNode = () => {},
+    onOpenFile = () => {},
+    onBlame = () => {},
+    collapsed = false,
+    onToggleCollapsed = () => {},
   }: Props = $props();
 
+  let contextNode = $state<ExplorerNode | null>(null);
+  let contextMenuX = $state(0);
+  let contextMenuY = $state(0);
+
   function mergeExplorerStatus(current: FileStatusKind | null, next: FileStatusKind | null): FileStatusKind | null {
     if (!next) return current;
     if (!current) return next;
@@ -154,12 +168,46 @@
     return "text";
   }
 
+  function openFileContextMenu(event: MouseEvent, node: ExplorerNode) {
+    if (node.kind !== "file") return;
+    event.preventDefault();
+    event.stopPropagation();
+
+    contextNode = node;
+    contextMenuX = Math.max(8, Math.min(event.clientX + 2, window.innerWidth - 192));
+    contextMenuY = Math.max(8, Math.min(event.clientY + 2, window.innerHeight - 56));
+  }
+
+  function closeFileContextMenu() {
+    contextNode = null;
+  }
+
+  function openContextFile() {
+    const node = contextNode;
+    if (!node || node.kind !== "file") return;
+    closeFileContextMenu();
+    onOpenFile(node);
+  }
+
+  function openContextBlame() {
+    const node = contextNode;
+    if (!node || node.kind !== "file") return;
+    closeFileContextMenu();
+    onBlame(node);
+  }
+
+  function handleWindowKeydown(event: KeyboardEvent) {
+    if (event.key === "Escape") closeFileContextMenu();
+  }
+
   let explorerTree = $derived(buildExplorerTree(repoFiles));
   let visibleNodes = $derived(flattenExplorerTree(explorerTree, expandedExplorerPaths));
   let hasFolders = $derived(explorerTree.some((node) => node.kind === "folder"));
 </script>
 
-<section class="panel grid grid-rows-[auto_1fr] overflow-hidden" aria-label="File explorer">
+<svelte:window on:click={closeFileContextMenu} on:keydown={handleWindowKeydown} on:contextmenu|capture={closeFileContextMenu} />
+
+<section class="panel explorer-panel grid grid-rows-[auto_1fr] overflow-hidden" class:collapsed aria-label="File explorer">
   <div class="section-head">
     <div>
       <span class="eyebrow">Explorer</span>
@@ -187,10 +235,26 @@
         <Folder size={14} aria-hidden="true" />
       </button>
       <span class="pill pill-count">{repoFiles.length}</span>
+      <button
+        class="explorer-bulk-button panel-collapse-toggle"
+        type="button"
+        onclick={onToggleCollapsed}
+        aria-expanded={!collapsed}
+        title={collapsed ? "Expand file explorer" : "Collapse file explorer"}
+        aria-label={collapsed ? "Expand file explorer panel" : "Collapse file explorer panel"}
+      >
+        {#if collapsed}
+          <ChevronRight size={14} aria-hidden="true" />
+        {:else}
+          <ChevronDown size={14} aria-hidden="true" />
+        {/if}
+      </button>
     </div>
   </div>
 
-  {#if !hasRepository}
+  {#if collapsed}
+    <!-- collapsed -->
+  {:else if !hasRepository}
     <p class="blank-state">Open a repository to browse files.</p>
   {:else if repoFiles.length === 0}
     <p class="blank-state">No files returned.</p>
@@ -264,6 +328,7 @@
             class="explorer-select"
             type="button"
             onclick={() => onSelectNode(node)}
+            oncontextmenu={(event) => openFileContextMenu(event, node)}
             disabled={isBusy}
             title={`Show history for ${node.path}`}
           >
@@ -279,4 +344,36 @@
       {/each}
     </div>
   {/if}
+
 </section>
+
+{#if contextNode}
+  <div
+    class="explorer-context-menu"
+    style={`left: ${contextMenuX}px; top: ${contextMenuY}px;`}
+    role="menu"
+    tabindex="-1"
+    aria-label={`Actions for ${contextNode.path}`}
+  >
+    <button
+      type="button"
+      role="menuitem"
+      onclick={openContextFile}
+      disabled={contextNode.status === "deleted"}
+      title={contextNode.status === "deleted" ? "Deleted files cannot be revealed in Explorer" : "Reveal this file in Explorer"}
+    >
+      <ExternalLink size={14} aria-hidden="true" />
+      Open in Explorer
+    </button>
+    <button
+      type="button"
+      role="menuitem"
+      onclick={openContextBlame}
+      disabled={!contextNode.tracked || contextNode.status === "deleted"}
+      title={!contextNode.tracked || contextNode.status === "deleted" ? "Blame is only available for tracked files" : "Show blame for this file"}
+    >
+      <History size={14} aria-hidden="true" />
+      Blame
+    </button>
+  </div>
+{/if}

src/lib/components/FileHistoryPanel.svelte

@@ -1,5 +1,6 @@
 <script lang="ts">
-  import { GitCompare, History, RotateCcw } from "@lucide/svelte";
+  import { ChevronLeft, ChevronRight, GitCompare, History, RotateCcw } from "@lucide/svelte";
+  import iconUrl from "../../../src-tauri/icons/icon.png";
   import type { GitCommit } from "../types";
 
   interface Props {
@@ -8,8 +9,11 @@
     selectedExplorerLabel: string;
     hasRepository: boolean;
     isBusy: boolean;
+    isLoading?: boolean;
     onDiff: (commit: GitCommit) => void;
     onRestore: (commit: GitCommit) => void;
+    collapsed?: boolean;
+    onToggleCollapsed?: () => void;
   }
 
   let {
@@ -18,8 +22,11 @@
     selectedExplorerLabel = "File history",
     hasRepository = false,
     isBusy = false,
+    isLoading = false,
     onDiff = () => {},
     onRestore = () => {},
+    collapsed = false,
+    onToggleCollapsed = () => {},
   }: Props = $props();
 
   function formatCommitDate(value: string): string {
@@ -73,7 +80,23 @@
   }
 </script>
 
-<section class="panel grid grid-rows-[auto_1fr] overflow-hidden" aria-label="Selected file history">
+<section class="panel file-history-panel grid grid-rows-[auto_1fr] overflow-hidden" class:collapsed aria-label="Selected file history">
+  {#if collapsed}
+    <button
+      class="file-history-rail-toggle"
+      type="button"
+      onclick={onToggleCollapsed}
+      aria-expanded={!collapsed}
+      title="Expand file history"
+      aria-label="Expand file history panel"
+    >
+      <ChevronLeft size={16} aria-hidden="true" />
+      <span>File history</span>
+      {#if selectedExplorerPath}
+        <small>{fileHistory.length}</small>
+      {/if}
+    </button>
+  {:else}
   <div class="section-head file-history-head">
     <div class="file-history-heading">
       <span class="eyebrow">{selectedExplorerLabel}</span>
@@ -82,13 +105,38 @@
         use:pathTooltip={selectedExplorerPath}
       >{selectedExplorerPath ? fileName(selectedExplorerPath) : "No file"}</h2>
     </div>
+    <div class="file-history-head-actions">
       <span class="pill pill-count file-history-count">{fileHistory.length}</span>
+      <button
+        class="file-history-toggle panel-collapse-toggle"
+        type="button"
+        onclick={onToggleCollapsed}
+        aria-expanded={!collapsed}
+        title="Collapse file history"
+        aria-label="Collapse file history panel"
+      >
+        <ChevronRight size={14} aria-hidden="true" />
+      </button>
+    </div>
   </div>
 
   {#if !hasRepository}
     <div class="blank-state">No repository loaded.</div>
   {:else if !selectedExplorerPath}
     <div class="blank-state">Select a file in Explorer.</div>
+  {:else if isLoading}
+    <div class="file-history-loading" role="status" aria-live="polite">
+      <div class="file-history-loading-mark" aria-hidden="true">
+        <span class="file-history-loading-halo"></span>
+        <svg class="file-history-loading-traces" viewBox="0 0 120 120">
+          <path class="fhl-trace fhl-trace-main" d="M14 82 C38 60, 48 58, 60 60 S84 66, 106 36" />
+          <path class="fhl-trace fhl-trace-branch" d="M28 36 C52 48, 70 70, 91 94" />
+        </svg>
+        <img src={iconUrl} alt="" class="file-history-loading-icon" />
+      </div>
+      <span class="file-history-loading-label">Loading history…</span>
+      <span class="file-history-loading-bar" aria-hidden="true"><span></span></span>
+    </div>
   {:else if fileHistory.length === 0}
     <div class="blank-state">No history returned for this selection.</div>
   {:else}
@@ -120,4 +168,5 @@
       {/each}
     </div>
   {/if}
+  {/if}
 </section>

src/lib/components/GlobalSearchDialog.svelte

@@ -1,6 +1,21 @@
 <script lang="ts">
-  import { CalendarDays, FileCode, LoaderCircle, Search, User, X } from "@lucide/svelte";
-  import type { GitSearchHit } from "../types";
+  import {
+    CalendarDays,
+    FileCode,
+    FileText,
+    GitCompare,
+    History,
+    LoaderCircle,
+    RotateCcw,
+    Search,
+    User,
+    X,
+  } from "@lucide/svelte";
+  import { languageIconForPath } from "../languageIcons";
+  import type { GitCommit, GitRepositoryFile, GitSearchHit } from "../types";
+  import LanguageIcon from "./LanguageIcon.svelte";
+
+  type SearchTab = "code" | "files";
 
   interface Props {
     hasRepository: boolean;
@@ -8,9 +23,16 @@
     isSearching: boolean;
     error: string;
     results: GitSearchHit[];
+    files: GitRepositoryFile[];
+    fileHistory: GitCommit[];
+    selectedFilePath: string;
     onClose: () => void;
     onSearch: (query: string, caseSensitive: boolean, limit: number) => void | Promise<void>;
     onCancel: () => void | Promise<void>;
+    onDiff: (hit: GitSearchHit) => void | Promise<void>;
+    onSelectFile: (file: GitRepositoryFile) => void | Promise<void>;
+    onFileHistoryDiff: (commit: GitCommit) => void | Promise<void>;
+    onFileHistoryRestore: (commit: GitCommit) => void | Promise<void>;
   }
 
   let {
@@ -19,16 +41,28 @@
     isSearching = false,
     error = "",
     results = [],
+    files = [],
+    fileHistory = [],
+    selectedFilePath = "",
     onClose = () => {},
     onSearch = () => {},
     onCancel = () => {},
+    onDiff = () => {},
+    onSelectFile = () => {},
+    onFileHistoryDiff = () => {},
+    onFileHistoryRestore = () => {},
   }: Props = $props();
 
+  let activeTab = $state<SearchTab>("code");
   let query = $state("");
   let caseSensitive = $state(false);
   let limit = $state(250);
   let searchedQuery = $state("");
   let searched = $state(false);
+  let fileQuery = $state("");
+
+  const fileSearchActive = $derived(fileQuery.trim().length > 0);
+  const fileSearchResults = $derived(filterFiles(files, fileQuery, 200));
 
   function submit(event?: SubmitEvent) {
     event?.preventDefault();
@@ -54,18 +88,53 @@
   function displayPath(hit: GitSearchHit): string {
     return hit.old_file ? `${hit.old_file} -> ${hit.file}` : hit.file;
   }
+
+  function fileName(path: string): string {
+    return path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+  }
+
+  function folderName(path: string): string {
+    const parts = path.split(/[\\/]/).filter(Boolean);
+    parts.pop();
+    return parts.length > 0 ? parts.join("/") : "Repository root";
+  }
+
+  function filterFiles(source: GitRepositoryFile[], value: string, maxResults: number): GitRepositoryFile[] {
+    const terms = value
+      .trim()
+      .toLowerCase()
+      .split(/\s+/)
+      .filter(Boolean);
+    if (terms.length === 0) return [];
+
+    return source
+      .filter((file) => {
+        const path = file.path.toLowerCase();
+        const name = fileName(file.path).toLowerCase();
+        return terms.every((term) => path.includes(term) || name.includes(term));
+      })
+      .sort((a, b) => {
+        const aName = fileName(a.path).toLowerCase();
+        const bName = fileName(b.path).toLowerCase();
+        const first = terms[0] ?? "";
+        const aStarts = aName.startsWith(first) ? 0 : 1;
+        const bStarts = bName.startsWith(first) ? 0 : 1;
+        if (aStarts !== bStarts) return aStarts - bStarts;
+        return a.path.localeCompare(b.path);
+      })
+      .slice(0, maxResults);
+  }
 </script>
 
 <div
   class="dialog-backdrop"
   role="presentation"
-  onclick={(e) => { if (e.target === e.currentTarget) onClose(); }}
 >
-  <div class="dialog global-search-dialog" role="dialog" aria-modal="true" aria-label="Global code search" tabindex="-1">
+  <div class="dialog global-search-dialog" role="dialog" aria-modal="true" aria-label="Global search" tabindex="-1">
     <header class="dialog-header">
       <div>
         <span class="eyebrow">Global search</span>
-        <h2 class="dialog-title">Find where code was introduced</h2>
+        <h2 class="dialog-title">{activeTab === "code" ? "Find where code was introduced" : "Find file history"}</h2>
       </div>
       <button class="dialog-close" type="button" onclick={onClose} title="Close">
         <X size={18} aria-hidden="true" />
@@ -73,6 +142,32 @@
     </header>
 
     <div class="global-search-body">
+      <div class="global-search-tabs" role="tablist" aria-label="Search mode">
+        <button
+          class="global-search-tab"
+          class:active={activeTab === "code"}
+          type="button"
+          role="tab"
+          aria-selected={activeTab === "code"}
+          onclick={() => { activeTab = "code"; }}
+        >
+          <Search size={14} aria-hidden="true" />
+          Code
+        </button>
+        <button
+          class="global-search-tab"
+          class:active={activeTab === "files"}
+          type="button"
+          role="tab"
+          aria-selected={activeTab === "files"}
+          onclick={() => { activeTab = "files"; }}
+        >
+          <FileText size={14} aria-hidden="true" />
+          Files
+        </button>
+      </div>
+
+      {#if activeTab === "code"}
         <form class="global-search-form" onsubmit={submit}>
           <label class="global-search-query">
             <span>String or function</span>
@@ -148,6 +243,16 @@
                     {#if hit.matches_added > 1}
                       <span class="pill pill-active">+{hit.matches_added} matches</span>
                     {/if}
+                    <button
+                      class="btn-secondary search-hit-diff"
+                      type="button"
+                      disabled={isBusy}
+                      title={`Compare this version of ${hit.file} with the current version`}
+                      onclick={() => onDiff(hit)}
+                    >
+                      <GitCompare size={14} aria-hidden="true" />
+                      DIFF
+                    </button>
                   </header>
 
                   <div class="search-hit-meta">
@@ -169,6 +274,122 @@
             </div>
           {/if}
         </section>
+      {:else}
+        <form class="global-search-form file-search-form" onsubmit={(event) => event.preventDefault()}>
+          <label class="global-search-query">
+            <span>File name or path</span>
+            <input
+              bind:value={fileQuery}
+              disabled={!hasRepository || isBusy}
+              spellcheck="false"
+              autocomplete="off"
+              placeholder="Search files, folders, extensions..."
+            />
+          </label>
+        </form>
+
+        <section class="global-search-results file-search-results" aria-live="polite">
+          {#if !hasRepository}
+            <div class="blank-state">Open a repository first.</div>
+          {:else if files.length === 0}
+            <div class="blank-state">No files loaded for this repository.</div>
+          {:else}
+            <div class="file-search-split">
+              <div class="file-search-column">
+                {#if !fileSearchActive}
+                  <div class="blank-state">Search a file name or path, then choose a result to show its history.</div>
+                {:else if fileSearchResults.length === 0}
+                  <div class="blank-state">No file found for "{fileQuery.trim()}".</div>
+                {:else}
+                  <div class="search-result-head">
+                    <strong>{fileSearchResults.length}</strong>
+                    <span>{fileSearchResults.length === 1 ? "file" : "files"} found for "{fileQuery.trim()}"</span>
+                  </div>
+
+                  <div class="file-search-list">
+                    {#each fileSearchResults as file (file.path)}
+                      {@const languageIcon = languageIconForPath(file.path)}
+                      <button
+                        class="file-search-hit"
+                        class:active={selectedFilePath === file.path}
+                        type="button"
+                        disabled={isBusy || isSearching}
+                        title={`Show history for ${file.path}`}
+                        onclick={() => onSelectFile(file)}
+                      >
+                        <span class="file-search-icon">
+                          {#if languageIcon}
+                            <LanguageIcon icon={languageIcon.icon} title={languageIcon.title} />
+                          {:else}
+                            <FileText size={16} aria-hidden="true" />
+                          {/if}
+                        </span>
+
+                        <span class="file-search-main">
+                          <strong>{fileName(file.path)}</strong>
+                          <span>{folderName(file.path)}</span>
+                        </span>
+
+                        {#if file.status}
+                          <small class={`status-badge ${file.status}`}>{file.status}</small>
+                        {:else if !file.tracked}
+                          <small class="status-badge untracked">untracked</small>
+                        {/if}
+
+                        <span class="file-search-action">
+                          <History size={14} aria-hidden="true" />
+                          History
+                        </span>
+                      </button>
+                    {/each}
+                  </div>
+                {/if}
+              </div>
+
+              <aside class="file-search-history" aria-label="Selected file history">
+                <header class="file-search-history-head">
+                  <span>History</span>
+                  <strong title={selectedFilePath}>{selectedFilePath ? fileName(selectedFilePath) : "No file selected"}</strong>
+                </header>
+
+                {#if !selectedFilePath}
+                  <div class="blank-state">Select a file result to load its commit history.</div>
+                {:else if isBusy}
+                  <div class="blank-state">
+                    <LoaderCircle class="spin" size={18} aria-hidden="true" />
+                    Loading history...
+                  </div>
+                {:else if fileHistory.length === 0}
+                  <div class="blank-state">No history returned for this file.</div>
+                {:else}
+                  <div class="file-search-history-list">
+                    {#each fileHistory as commit (commit.hash)}
+                      <article class="file-search-history-row">
+                        <div class="file-search-history-main">
+                          <span class="hash">{commit.short_hash}</span>
+                          <strong title={commit.summary}>{commit.summary || "No commit message"}</strong>
+                          <span>{commit.author_name || "Unknown author"} - {formatCommitDate(commit.date)}</span>
+                        </div>
+
+                        <div class="file-search-history-actions">
+                          <button class="btn-sm" type="button" onclick={() => onFileHistoryDiff(commit)} disabled={isBusy}>
+                            <GitCompare size={14} aria-hidden="true" />
+                            Diff
+                          </button>
+                          <button class="btn-sm" type="button" onclick={() => onFileHistoryRestore(commit)} disabled={isBusy}>
+                            <RotateCcw size={14} aria-hidden="true" />
+                            Restore
+                          </button>
+                        </div>
+                      </article>
+                    {/each}
+                  </div>
+                {/if}
+              </aside>
+            </div>
+          {/if}
+        </section>
+      {/if}
     </div>
   </div>
 </div>

src/lib/components/HistoryPanel.svelte

@@ -1,46 +1,74 @@
 <script lang="ts">
-  import { ChevronDown, ChevronRight, RotateCcw } from "@lucide/svelte";
+  import { Cherry, ChevronDown, ChevronRight, EllipsisVertical, GitBranch, GitMerge, RotateCcw, X } from "@lucide/svelte";
   import type { FileStatusKind, GitCommit, GitCommitFile } from "../types";
 
   interface GraphSegment {
     fromCol: number;
     toCol: number;
     color: string;
+    branches: string[];
   }
 
   interface GraphRow {
     dotCol: number;
     dotColor: string;
+    branchLabels: string[];
     top: GraphSegment[];
     bottom: GraphSegment[];
   }
 
+  interface VisibleCommitEntry {
+    commit: GitCommit;
+    graphCommit: GitCommit;
+  }
+
   const GRAPH_COLORS = [
-    "#2f6fb0", "#4aa777", "#c9851f", "#a05bd0",
-    "#cc4b6e", "#1f9ab0", "#7a8a1f", "#b0631f",
+    "#69a7ff", "#5bd18a", "#d8a74a", "#ba82ff",
+    "#ff7c9f", "#48c7d8", "#c5cf54", "#e18c55",
   ];
-  const GRAPH_LANE = 16;
+  const GRAPH_LANE = 18;
 
   interface Props {
     commits: GitCommit[];
+    localBranchNames: string[];
+    activeBranch: string;
+    activeUpstream: string;
+    repositoryKey: string;
     hasRepository: boolean;
     isBusy: boolean;
     expandedCommitHashes: Set<string>;
     onRestoreCommit: (commit: GitCommit) => void;
     onPreviewCommitFile: (commit: GitCommit, file: GitCommitFile) => void;
     onToggleCommitFiles: (hash: string) => void;
+    onCreateBranchFromCommit: (commit: GitCommit) => void;
+    onCherryPickCommit: (commit: GitCommit) => void;
   }
 
   let {
     commits = [],
+    localBranchNames = [],
+    activeBranch = "",
+    activeUpstream = "",
+    repositoryKey = "",
     hasRepository = false,
     isBusy = false,
     expandedCommitHashes = new Set(),
     onRestoreCommit = () => {},
     onPreviewCommitFile = () => {},
     onToggleCommitFiles = () => {},
+    onCreateBranchFromCommit = () => {},
+    onCherryPickCommit = () => {},
   }: Props = $props();
 
+  let hiddenGraphBranches = $state<Set<string>>(new Set());
+  let branchDialogOpen = $state(false);
+  let userAdjustedBranchFilter = $state(false);
+  let lastDefaultFilterKey = $state("");
+  let panelElement = $state<HTMLElement | null>(null);
+  let contextCommit = $state<GitCommit | null>(null);
+  let contextMenuX = $state(0);
+  let contextMenuY = $state(0);
+
   function laneColor(col: number): string {
     return GRAPH_COLORS[((col % GRAPH_COLORS.length) + GRAPH_COLORS.length) % GRAPH_COLORS.length];
   }
@@ -49,13 +77,23 @@
     return col * GRAPH_LANE + GRAPH_LANE / 2;
   }
 
-  function computeGraph(items: GitCommit[]): { rows: GraphRow[]; columns: number } {
+  function graphPath(seg: GraphSegment, fromY: number, toY: number): string {
+    const x1 = graphColX(seg.fromCol);
+    const x2 = graphColX(seg.toCol);
+    if (x1 === x2) return `M ${x1} ${fromY} L ${x2} ${toY}`;
+    const midY = (fromY + toY) / 2;
+    return `M ${x1} ${fromY} C ${x1} ${midY}, ${x2} ${midY}, ${x2} ${toY}`;
+  }
+
+  function computeGraph(items: GitCommit[], branchMembership = new Map<string, string[]>()): { rows: GraphRow[]; columns: number } {
     const rows: GraphRow[] = [];
     let lanes: (string | null)[] = [];
+    let laneBranches: string[][] = [];
     let maxColumns = 1;
 
     for (const commit of items) {
       const before = lanes.slice();
+      const beforeBranches = laneBranches.map((branches) => branches.slice());
 
       let col = before.indexOf(commit.hash);
       if (col === -1) {
@@ -65,18 +103,27 @@
 
       const after = before.slice();
       while (after.length <= col) after.push(null);
+      const afterBranches = beforeBranches.map((branches) => branches.slice());
+      while (afterBranches.length <= col) afterBranches.push([]);
 
       for (let k = 0; k < after.length; k++) {
-        if (after[k] === commit.hash) after[k] = null;
+        if (after[k] === commit.hash) {
+          after[k] = null;
+          afterBranches[k] = [];
+        }
       }
 
+      const currentBranches = branchMembership.get(commit.hash) ?? localBranchRefs(commit);
+      const commitBranches = uniqueStrings([...(beforeBranches[col] ?? []), ...currentBranches]);
       after[col] = commit.parents.length > 0 ? commit.parents[0] : null;
+      afterBranches[col] = after[col] ? commitBranches.slice() : [];
 
       const fromCommit = new Set<number>([col]);
       for (let p = 1; p < commit.parents.length; p++) {
         let slot = after.indexOf(null);
-        if (slot === -1) { slot = after.length; after.push(null); }
+        if (slot === -1) { slot = after.length; after.push(null); afterBranches.push([]); }
         after[slot] = commit.parents[p];
+        afterBranches[slot] = [];
         fromCommit.add(slot);
       }
 
@@ -84,19 +131,28 @@
       for (let k = 0; k < before.length; k++) {
         const target = before[k];
         if (target == null) continue;
-        top.push({ fromCol: k, toCol: target === commit.hash ? col : k, color: laneColor(k) });
+        top.push({ fromCol: k, toCol: target === commit.hash ? col : k, color: laneColor(k), branches: beforeBranches[k] ?? [] });
       }
 
       const bottom: GraphSegment[] = [];
       for (let k = 0; k < after.length; k++) {
         if (after[k] == null) continue;
-        bottom.push({ fromCol: fromCommit.has(k) ? col : k, toCol: k, color: laneColor(k) });
+        bottom.push({
+          fromCol: fromCommit.has(k) ? col : k,
+          toCol: k,
+          color: laneColor(k),
+          branches: fromCommit.has(k) ? commitBranches : afterBranches[k] ?? [],
+        });
       }
 
-      rows.push({ dotCol: col, dotColor: laneColor(col), top, bottom });
+      rows.push({ dotCol: col, dotColor: laneColor(col), branchLabels: currentBranches, top, bottom });
 
       lanes = after.slice();
-      while (lanes.length > 0 && lanes[lanes.length - 1] == null) lanes.pop();
+      laneBranches = afterBranches.map((branches) => branches.slice());
+      while (lanes.length > 0 && lanes[lanes.length - 1] == null) {
+        lanes.pop();
+        laneBranches.pop();
+      }
       maxColumns = Math.max(maxColumns, before.length, after.length, col + 1);
     }
 
@@ -111,73 +167,469 @@
     return file.old_path ? `${file.old_path} -> ${file.path}` : file.path;
   }
 
+  function baseName(path: string): string {
+    return path.split(/[\\/]/).filter(Boolean).pop() ?? path;
+  }
+
+  function commitFileName(file: GitCommitFile): string {
+    return file.old_path
+      ? `${baseName(file.old_path)} -> ${baseName(file.path)}`
+      : baseName(file.path);
+  }
+
+  function authorInitials(name: string): string {
+    const parts = name.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0) return "?";
+    if (parts.length === 1) return parts[0].slice(0, 2).toUpperCase();
+    return `${parts[0][0]}${parts[parts.length - 1][0]}`.toUpperCase();
+  }
+
+  function commitKind(commit: GitCommit): "merge" | "root" | "commit" {
+    if (commit.parents.length > 1) return "merge";
+    if (commit.parents.length === 0) return "root";
+    return "commit";
+  }
+
+  function commitKindLabel(commit: GitCommit): string {
+    const kind = commitKind(commit);
+    if (kind === "merge") return "merge";
+    if (kind === "root") return "root";
+    return "commit";
+  }
+
+  let localBranchNameSet = $derived(new Set(localBranchNames));
+
+  function uniqueStrings(values: string[]): string[] {
+    return [...new Set(values.filter(Boolean))];
+  }
+
+  let graphBranchNames = $derived(uniqueStrings([...localBranchNames, activeUpstream].filter(Boolean)));
+  let graphBranchNameSet = $derived(new Set(graphBranchNames));
+
+  function branchIsVisible(branch: string): boolean {
+    if (branch === activeUpstream && activeUpstream) {
+      return !activeBranch || !hiddenGraphBranches.has(activeBranch);
+    }
+    return !hiddenGraphBranches.has(branch);
+  }
+
+  function visibleBranchLabels(labels: string[]): string[] {
+    return labels.filter(branchIsVisible);
+  }
+
+  function commitHoverBranchLabels(commit: GitCommit, row: GraphRow | undefined): string[] {
+    const directBranches = graphBranchRefs(commit);
+    if (directBranches.length > 0) return directBranches;
+
+    const containingBranches = row?.branchLabels ?? [];
+    if (containingBranches.length <= 3) return containingBranches;
+    return [...containingBranches.slice(0, 3), `+${containingBranches.length - 3} more`];
+  }
+
+  function commitHoverTitle(commit: GitCommit, row: GraphRow | undefined): string {
+    const directBranches = graphBranchRefs(commit);
+    if (directBranches.length > 0) return `Branches: ${directBranches.join(", ")}`;
+
+    const containingBranches = row?.branchLabels ?? [];
+    if (containingBranches.length === 0) return commit.short_hash;
+    return `Branches containing this commit: ${containingBranches.join(", ")}`;
+  }
+
+  function segmentIsVisible(segment: GraphSegment): boolean {
+    return segment.branches.length === 0 || segment.branches.some(branchIsVisible);
+  }
+
+  function syncClassForBranches(labels: string[]): "" | "ahead" | "behind" {
+    if (!activeBranch || !activeUpstream) return "";
+    const hasLocal = labels.includes(activeBranch);
+    const hasRemote = labels.includes(activeUpstream);
+    if (hasLocal && !hasRemote) return "ahead";
+    if (hasRemote && !hasLocal) return "behind";
+    return "";
+  }
+
+  function branchesAreVisible(branches: string[]): boolean {
+    if (graphBranchNames.length === 0) return true;
+    return branches.some(branchIsVisible);
+  }
+
+  function rowGraphIsVisible(row: GraphRow | undefined): boolean {
+    return branchesAreVisible(row?.branchLabels ?? []);
+  }
+
+  function nearestVisibleGraphParents(
+    hash: string,
+    visibleHashes: Set<string>,
+    commitByHash: Map<string, GitCommit>,
+    seen: Set<string>,
+  ): string[] {
+    if (visibleHashes.has(hash)) return [hash];
+    if (seen.has(hash)) return [];
+    seen.add(hash);
+
+    const commit = commitByHash.get(hash);
+    if (!commit) return [];
+    return uniqueStrings(
+      commit.parents.flatMap((parentHash) => (
+        nearestVisibleGraphParents(parentHash, visibleHashes, commitByHash, new Set(seen))
+      )),
+    );
+  }
+
+  function branchMembershipByHash(items: GitCommit[]): Map<string, string[]> {
+    const commitByHash = new Map(items.map((commit) => [commit.hash, commit]));
+    const membership = new Map<string, Set<string>>();
+
+    for (const commit of items) {
+      for (const branch of graphBranchRefs(commit)) {
+        const stack = [commit.hash];
+        const seen = new Set<string>();
+
+        while (stack.length > 0) {
+          const hash = stack.pop();
+          if (!hash || seen.has(hash)) continue;
+          seen.add(hash);
+
+          let branches = membership.get(hash);
+          if (!branches) {
+            branches = new Set<string>();
+            membership.set(hash, branches);
+          }
+          branches.add(branch);
+
+          const parentCommit = commitByHash.get(hash);
+          if (parentCommit) stack.push(...parentCommit.parents);
+        }
+      }
+    }
+
+    return new Map(
+      items.map((commit) => [
+        commit.hash,
+        graphBranchNames.filter((branch) => membership.get(commit.hash)?.has(branch)),
+      ]),
+    );
+  }
+
+  function visibleCommitEntriesForGraph(items: GitCommit[], branchMembership: Map<string, string[]>): VisibleCommitEntry[] {
+    const visibleItems = items.filter((commit) => branchesAreVisible(branchMembership.get(commit.hash) ?? []));
+    const visibleHashes = new Set(visibleItems.map((commit) => commit.hash));
+    const commitByHash = new Map(items.map((commit) => [commit.hash, commit]));
+
+    return visibleItems.map((commit) => {
+      const parents = uniqueStrings(
+        commit.parents.flatMap((parentHash) => (
+          nearestVisibleGraphParents(parentHash, visibleHashes, commitByHash, new Set())
+        )),
+      );
+      return { commit, graphCommit: { ...commit, parents } };
+    });
+  }
+
+  function toggleGraphBranch(branch: string) {
+    const next = new Set(hiddenGraphBranches);
+    if (next.has(branch)) next.delete(branch); else next.add(branch);
+    hiddenGraphBranches = next;
+    userAdjustedBranchFilter = true;
+  }
+
+  function showAllGraphBranches() {
+    hiddenGraphBranches = new Set();
+    userAdjustedBranchFilter = true;
+  }
+
+  function hideAllGraphBranches() {
+    hiddenGraphBranches = new Set(localBranchNames);
+    userAdjustedBranchFilter = true;
+  }
+
+  function openBranchDialog() {
+    branchDialogOpen = true;
+  }
+
+  function closeBranchDialog() {
+    branchDialogOpen = false;
+  }
+
+  function handleBranchDialogKeydown(event: KeyboardEvent) {
+    if (branchDialogOpen && event.key === "Escape") {
+      closeBranchDialog();
+    }
+  }
+
+  function openCommitActionMenu(event: MouseEvent, commit: GitCommit) {
+    event.preventDefault();
+    event.stopPropagation();
+    if (isBusy) return;
+
+    if (contextCommit?.hash === commit.hash) {
+      closeCommitContextMenu();
+      return;
+    }
+
+    const panelRect = panelElement?.getBoundingClientRect();
+    const buttonRect = event.currentTarget instanceof HTMLElement
+      ? event.currentTarget.getBoundingClientRect()
+      : null;
+    const rawX = panelRect && buttonRect ? buttonRect.right - panelRect.left - 184 : event.offsetX;
+    const rawY = panelRect && buttonRect ? buttonRect.bottom - panelRect.top + 4 : event.offsetY;
+    const maxX = Math.max(8, (panelRect?.width ?? window.innerWidth) - 192);
+    const maxY = Math.max(8, (panelRect?.height ?? window.innerHeight) - 96);
+
+    contextCommit = commit;
+    contextMenuX = Math.max(8, Math.min(rawX, maxX));
+    contextMenuY = Math.max(8, Math.min(rawY, maxY));
+  }
+
+  function closeCommitContextMenu() {
+    contextCommit = null;
+  }
+
+  async function createBranchFromContextCommit() {
+    const commit = contextCommit;
+    if (!commit || isBusy) return;
+    closeCommitContextMenu();
+    await onCreateBranchFromCommit(commit);
+  }
+
+  async function restoreContextCommit() {
+    const commit = contextCommit;
+    if (!commit || isBusy) return;
+    closeCommitContextMenu();
+    await onRestoreCommit(commit);
+  }
+
+  async function cherryPickContextCommit() {
+    const commit = contextCommit;
+    if (!commit || isBusy) return;
+    closeCommitContextMenu();
+    await onCherryPickCommit(commit);
+  }
+
+  function handleWindowKeydown(event: KeyboardEvent) {
+    if (event.key !== "Escape") return;
+    closeCommitContextMenu();
+    handleBranchDialogKeydown(event);
+  }
+
+  function localBranchRefs(commit: GitCommit): string[] {
+    const seen = new Set<string>();
+    const labels: string[] = [];
+    for (const ref of commit.refs) {
+      const label = refLabel(ref);
+      if (!localBranchNameSet.has(label) || seen.has(label)) continue;
+      seen.add(label);
+      labels.push(label);
+    }
+    return labels;
+  }
+
+  function graphBranchRefs(commit: GitCommit): string[] {
+    const seen = new Set<string>();
+    const labels: string[] = [];
+    for (const ref of commit.refs) {
+      const label = refLabel(ref);
+      if (!graphBranchNameSet.has(label) || seen.has(label)) continue;
+      seen.add(label);
+      labels.push(label);
+    }
+    return labels;
+  }
+
+  function visibleRefs(commit: GitCommit): string[] {
+    return commit.refs.filter((ref) => !localBranchNameSet.has(refLabel(ref)));
+  }
+
+  function refClass(ref: string): string {
+    if (ref.startsWith("HEAD")) return "head";
+    if (ref.startsWith("tag:")) return "tag";
+    if (localBranchNameSet.has(refLabel(ref))) return "branch";
+    if (ref.includes("/")) return "remote";
+    return "branch";
+  }
+
+  function refLabel(ref: string): string {
+    return ref.replace(/^HEAD ->\s*/, "").replace(/^tag:\s*/, "");
+  }
+
   function formatCommitDate(value: string): string {
     const date = new Date(value);
     if (Number.isNaN(date.getTime())) return value;
     return new Intl.DateTimeFormat(undefined, { dateStyle: "medium", timeStyle: "short" }).format(date);
   }
 
-  let graph = $derived(computeGraph(commits));
+  $effect(() => {
+    const available = new Set(localBranchNames);
+    const nextHidden = new Set([...hiddenGraphBranches].filter((branch) => available.has(branch)));
+    if (nextHidden.size !== hiddenGraphBranches.size) {
+      hiddenGraphBranches = nextHidden;
+    }
+  });
+
+  $effect(() => {
+    const defaultBranch = activeBranch && localBranchNames.includes(activeBranch)
+      ? activeBranch
+      : (graphBranchNames[0] ?? "");
+    const defaultFilterKey = `${repositoryKey}::${defaultBranch}`;
+
+    if (!defaultBranch) {
+      if (lastDefaultFilterKey !== defaultFilterKey) {
+        hiddenGraphBranches = new Set();
+        userAdjustedBranchFilter = false;
+        lastDefaultFilterKey = defaultFilterKey;
+      }
+      return;
+    }
+
+    if (lastDefaultFilterKey !== defaultFilterKey) {
+      userAdjustedBranchFilter = false;
+      lastDefaultFilterKey = defaultFilterKey;
+    }
+
+    if (!userAdjustedBranchFilter) {
+      hiddenGraphBranches = new Set(localBranchNames.filter((branch) => branch !== defaultBranch));
+    }
+  });
+
+  let branchMembership = $derived(branchMembershipByHash(commits));
+  let visibleCommitEntries = $derived(visibleCommitEntriesForGraph(commits, branchMembership));
+  let visibleCommits = $derived(visibleCommitEntries.map((entry) => entry.commit));
+  let graphCommits = $derived(visibleCommitEntries.map((entry) => entry.graphCommit));
+  let visibleBranchCount = $derived(localBranchNames.filter(branchIsVisible).length);
+  let graph = $derived(computeGraph(graphCommits, branchMembership));
   let graphRows = $derived(graph.rows);
-  let graphWidth = $derived(Math.max(graph.columns, 1) * GRAPH_LANE);
+  let graphWidth = $derived(Math.max(Math.max(graph.columns, 1) * GRAPH_LANE + 18, 42));
 </script>
 
-<section class="panel grid grid-rows-[auto_1fr] overflow-hidden" aria-label="Commit history">
+<svelte:window onclick={closeCommitContextMenu} onkeydown={handleWindowKeydown} on:contextmenu|capture={closeCommitContextMenu} />
+
+<section bind:this={panelElement} class="panel history-panel grid grid-rows-[auto_1fr] overflow-hidden" aria-label="Commit history">
   <div class="section-head">
     <div>
       <span class="eyebrow">History</span>
       <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Commits</h2>
     </div>
-    <span class="pill pill-count">{commits.length}</span>
+    <div class="section-head-actions">
+      {#if localBranchNames.length > 0}
+        <button
+          class="graph-branch-dialog-button"
+          type="button"
+          onclick={openBranchDialog}
+          title="Select branches shown in the graph"
+        >
+          <GitBranch size={13} aria-hidden="true" />
+          Branches
+          <span>{visibleBranchCount}/{localBranchNames.length}</span>
+        </button>
+      {/if}
+      <span class="pill pill-count" title={visibleCommits.length === commits.length ? "Commits" : `${visibleCommits.length} of ${commits.length} commits shown`}>
+        {visibleCommits.length}
+      </span>
+    </div>
   </div>
 
   {#if !hasRepository}
     <div class="blank-state">No repository loaded.</div>
   {:else if commits.length === 0}
     <div class="blank-state">No commits returned.</div>
+  {:else if visibleCommits.length === 0}
+    <div class="blank-state">No commits match the selected branches.</div>
   {:else}
     <div class="history-list graph-list overflow-auto">
-      {#each commits as item, rowIndex (item.hash)}
+      {#each visibleCommitEntries as entry, rowIndex (entry.commit.hash)}
+        {@const item = entry.commit}
         {@const row = graphRows[rowIndex]}
-        <article class="commit-row graph-row">
+        {@const hoverBranchRefs = commitHoverBranchLabels(item, row)}
+        {@const otherRefs = visibleRefs(item)}
+        {@const rowSyncClass = syncClassForBranches(row?.branchLabels ?? [])}
+        <article
+          class="commit-row graph-row"
+          class:graph-ahead-row={rowSyncClass === "ahead"}
+          class:graph-behind-row={rowSyncClass === "behind"}
+          class:merge-row={item.parents.length > 1}
+          class:root-row={item.parents.length === 0}
+          class:tip-row={item.refs.length > 0}
+        >
           <div class="graph-gutter" style={`width:${graphWidth}px`} aria-hidden="true">
             {#if row}
               <svg class="graph-svg" viewBox={`0 0 ${graphWidth} 100`} preserveAspectRatio="none">
                 {#each row.top as seg}
-                  <line
-                    x1={graphColX(seg.fromCol)} y1="0"
-                    x2={graphColX(seg.toCol)} y2="50"
-                    stroke={seg.color} stroke-width="2" vector-effect="non-scaling-stroke"
+                  <path
+                    class:hidden-branch={!segmentIsVisible(seg)}
+                    class:graph-segment-ahead={syncClassForBranches(seg.branches) === "ahead"}
+                    class:graph-segment-behind={syncClassForBranches(seg.branches) === "behind"}
+                    d={graphPath(seg, 0, 50)}
+                    stroke={seg.color}
+                    stroke-width="2.2"
+                    vector-effect="non-scaling-stroke"
                   />
                 {/each}
                 {#each row.bottom as seg}
-                  <line
-                    x1={graphColX(seg.fromCol)} y1="50"
-                    x2={graphColX(seg.toCol)} y2="100"
-                    stroke={seg.color} stroke-width="2" vector-effect="non-scaling-stroke"
+                  <path
+                    class:hidden-branch={!segmentIsVisible(seg)}
+                    class:graph-segment-ahead={syncClassForBranches(seg.branches) === "ahead"}
+                    class:graph-segment-behind={syncClassForBranches(seg.branches) === "behind"}
+                    d={graphPath(seg, 50, 100)}
+                    stroke={seg.color}
+                    stroke-width="2.2"
+                    vector-effect="non-scaling-stroke"
                   />
                 {/each}
               </svg>
               <span
                 class="graph-dot"
                 class:merge={item.parents.length > 1}
+                class:tip={item.refs.length > 0}
+                class:hidden-branch={!rowGraphIsVisible(row)}
+                class:ahead={rowSyncClass === "ahead"}
+                class:behind={rowSyncClass === "behind"}
+                title={commitHoverTitle(item, row)}
                 style={`left:${graphColX(row.dotCol)}px; --dot-color:${row.dotColor}`}
               ></span>
+              {#if hoverBranchRefs.length > 0}
+                <div class="graph-hover-branches" style={`left:${graphColX(row.dotCol) + 13}px`}>
+                  {#each hoverBranchRefs as branch}
+                    <span
+                      class:remote={branch === activeUpstream}
+                      class:ahead={activeBranch === branch && rowSyncClass === "ahead"}
+                      class:behind={activeUpstream === branch && rowSyncClass === "behind"}
+                      title={branch}
+                    >
+                      <GitBranch size={10} aria-hidden="true" />
+                      {branch}
+                    </span>
+                  {/each}
+                </div>
+              {/if}
             {/if}
           </div>
 
           <div class="commit-body">
-            <div class="commit-line">
-              <div>
-                <strong title={item.summary}>{item.summary}</strong>
-                <span>{item.short_hash} - {item.author_name}</span>
+            <div class="commit-card-head">
+              <span class="commit-avatar">
+                {authorInitials(item.author_name)}
+              </span>
+              <div class="commit-card-main">
+                <div class="commit-title-row">
+                  <strong class="commit-summary" title={item.summary}>{item.summary}</strong>
+                  <span class={`commit-kind ${commitKind(item)}`}>
+                    {#if item.parents.length > 1}
+                      <GitMerge size={12} aria-hidden="true" />
+                    {/if}
+                    {commitKindLabel(item)}
+                  </span>
+                </div>
+                <div class="commit-meta-line">
+                  <span class="commit-hash">{item.short_hash}</span>
+                  <span class="commit-author" title={item.author_email}>{item.author_name}</span>
+                </div>
               </div>
             </div>
 
-            {#if item.refs.length > 0}
+            {#if otherRefs.length > 0}
               <div class="ref-list" aria-label="Commit refs">
-                {#each item.refs as ref}
-                  <span>{ref}</span>
+                {#each otherRefs as ref}
+                  <span class={`ref-chip ${refClass(ref)}`}>{refLabel(ref)}</span>
                 {/each}
               </div>
             {/if}
@@ -206,10 +658,10 @@
                         type="button"
                         onclick={() => onPreviewCommitFile(item, file)}
                         disabled={isBusy}
-                        title="Show differences before restoring"
+                        title={`Show differences before restoring - ${displayCommitFile(file)}`}
                       >
                         <span class={`status-badge ${file.status}`}>{statusLabel(file.status)}</span>
-                        <strong>{displayCommitFile(file)}</strong>
+                        <strong>{commitFileName(file)}</strong>
                       </button>
                     {/each}
                   </div>
@@ -218,11 +670,19 @@
             {/if}
 
             <div class="commit-actions">
-              <time datetime={item.date}>{formatCommitDate(item.date)}</time>
+              <time class="commit-time" datetime={item.date}>{formatCommitDate(item.date)}</time>
               <div class="commit-action-buttons">
-                <button class="btn-sm" type="button" onclick={() => onRestoreCommit(item)} disabled={isBusy} title="Reset current branch to this commit">
-                  <RotateCcw size={15} aria-hidden="true" />
-                  Restore
+                <button
+                  class="commit-menu-button"
+                  type="button"
+                  onclick={(event) => openCommitActionMenu(event, item)}
+                  disabled={isBusy}
+                  title="Commit actions"
+                  aria-label={`Actions for ${item.short_hash}`}
+                  aria-haspopup="menu"
+                  aria-expanded={contextCommit?.hash === item.hash}
+                >
+                  <EllipsisVertical size={15} aria-hidden="true" />
                 </button>
               </div>
             </div>
@@ -231,4 +691,76 @@
       {/each}
     </div>
   {/if}
+
+  {#if contextCommit}
+    <div
+      class="history-context-menu"
+      style={`left: ${contextMenuX}px; top: ${contextMenuY}px;`}
+      role="menu"
+      tabindex="-1"
+      aria-label={`Actions for ${contextCommit.short_hash}`}
+    >
+      <button type="button" role="menuitem" onclick={createBranchFromContextCommit} disabled={isBusy}>
+        <GitBranch size={14} aria-hidden="true" />
+        Branch
+      </button>
+      <button type="button" role="menuitem" onclick={restoreContextCommit} disabled={isBusy}>
+        <RotateCcw size={14} aria-hidden="true" />
+        Restore
+      </button>
+      <button
+        type="button"
+        role="menuitem"
+        onclick={cherryPickContextCommit}
+        disabled={isBusy}
+        title="Apply this commit's changes on top of the current branch"
+      >
+        <Cherry size={14} aria-hidden="true" />
+        Cherry-pick
+      </button>
+    </div>
+  {/if}
 </section>
+
+{#if branchDialogOpen}
+  <div class="branch-filter-backdrop" role="presentation">
+    <div
+      class="branch-filter-dialog"
+      role="dialog"
+      aria-modal="true"
+      aria-label="Select visible branches"
+    >
+      <header class="branch-filter-dialog-head">
+        <div>
+          <span class="eyebrow">Git graph</span>
+          <h3>Visible branches</h3>
+        </div>
+        <button class="dialog-icon-button" type="button" onclick={closeBranchDialog} aria-label="Close branch selection">
+          <X size={16} aria-hidden="true" />
+        </button>
+      </header>
+
+      <div class="branch-filter-summary">
+        <span>{visibleBranchCount} of {localBranchNames.length} branches selected</span>
+        <div class="branch-filter-actions">
+          <button type="button" onclick={showAllGraphBranches} disabled={visibleBranchCount === localBranchNames.length}>Show all</button>
+          <button type="button" onclick={hideAllGraphBranches} disabled={visibleBranchCount === 0}>Hide all</button>
+        </div>
+      </div>
+
+      <div class="branch-filter-dialog-list">
+        {#each localBranchNames as branch}
+          <label class:muted={!branchIsVisible(branch)} class="branch-filter-option" title={branch}>
+            <input
+              type="checkbox"
+              checked={branchIsVisible(branch)}
+              onchange={() => toggleGraphBranch(branch)}
+            />
+            <GitBranch size={14} aria-hidden="true" />
+            <span>{branch}</span>
+          </label>
+        {/each}
+      </div>
+    </div>
+  </div>
+{/if}