refactor(explorer): improve file history state management

Adjusts the logic governing when file history views are refreshed or displayed. This ensures that selecting a file via the explorer correctly hides any active file history view, and prevents unnecessary refreshes of history data if the view is already collapsed or if the repository path is not yet set.

- Added explicit function to reset file history state
- Prevents automatic display of file history upon file selection
- Refines conditions for refreshing file history during repo updates

.claude/settings.local.json

@@ -23,7 +23,100 @@
       "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",
+      "Bash(node -p \"require\\('./package.json'\\).version\")",
+      "Bash(bash -n PKGBUILD)",
+      "Bash(makepkg --printsrcinfo)",
+      "Bash(npx tauri *)",
+      "Bash(echo \"---exit code:$?---\")",
+      "Bash(git -C /mnt/data/Development/GitLite status --short)",
+      "Bash(makepkg -f --noconfirm)",
+      "Bash(tar -tf gitty-2026.7.19-1-x86_64.pkg.tar.zst)",
+      "Bash(cp /mnt/data/Development/GitLite/PKGBUILD .)",
+      "Bash(sed -i 's/^pkgrel=1/pkgrel=3/' PKGBUILD)",
+      "Bash(node -e \"const fs=require\\('fs'\\); const version='2026.8.1'; const pkgbuild=fs.readFileSync\\('PKGBUILD','utf8'\\).replace\\(/^pkgver=.*\\\\$/m, 'pkgver='+version\\).replace\\(/^pkgrel=.*\\\\$/m, 'pkgrel=1'\\); fs.writeFileSync\\('PKGBUILD', pkgbuild\\);\")",
+      "Bash(rm PKGBUILD)"
     ]
   }
 }

.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,25 +82,24 @@ 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"
+          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');"
-          $version = '${{ github.ref_name }}'
+
-          $content = Get-Content -Raw -Encoding UTF8 $path
+      - name: Update PKGBUILD Version
-          $regex = [regex]'"version"\s*:\s*"[^"]*"'
+        run: |
-          $replacement = '"version": "' + $version + '"'
+          node -e "const fs=require('fs'); const version=require('./package.json').version; const pkgbuild=fs.readFileSync('PKGBUILD','utf8').replace(/^pkgver=.*$/m, 'pkgver='+version).replace(/^pkgrel=.*$/m, 'pkgrel=1'); fs.writeFileSync('PKGBUILD', pkgbuild);"
-          $updated = $regex.Replace($content, $replacement, 1)
-          $encoding = New-Object System.Text.UTF8Encoding($false)
-          [System.IO.File]::WriteAllText($path, $updated, $encoding)
 
       - name: Commit and Push Changes
+        if: matrix.platform == 'windows-latest'
         shell: powershell
         run: |
           git config user.name '${{ vars.USERNAME_GIT }}'
           git config user.email '${{ vars.EMAIL_GIT }}'
           # npm version also bumps the version inside package-lock.json, so stage it
           # too -- otherwise it stays as an unstaged change and blocks the rebase.
-          git add package.json package-lock.json src-tauri/tauri.conf.json
+          git add package.json package-lock.json src-tauri/tauri.conf.json PKGBUILD
 
           git commit -m 'Update version to ${{ github.ref_name }}'
           if ($LASTEXITCODE -ne 0) {
@@ -131,12 +143,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,8 @@
 .idea
 .DS_Store
 ~
+.codex*
+target
+
+*.pkg.tar.zst
+pkg

PKGBUILD

@@ -0,0 +1,66 @@
+# Maintainer: Christoph Brandau <c.brandau91@googlemail.com>
+#
+# Local/in-tree PKGBUILD: builds straight from this working directory (no
+# source download, no tauri-bundler/AppImage step) and installs the raw
+# binary + desktop entry. Run `makepkg -si` from the repo root.
+
+pkgname=gitty
+pkgver=2026.7.19
+pkgrel=1
+pkgdesc="A lightweight, modern Git client built with Tauri"
+arch=('x86_64')
+url="https://git.cbsk-tech.de/Christoph/GitLite"
+license=('MIT')
+depends=('webkit2gtk-4.1' 'gtk3' 'git' 'hicolor-icon-theme')
+makedepends=('rust' 'nodejs' 'npm')
+options=('!lto')
+
+source=()
+sha256sums=()
+
+# Keeps pkgver in sync with package.json (the release CI bumps that file).
+pkgver() {
+  cd "$startdir"
+  node -p "require('./package.json').version"
+}
+
+build() {
+  cd "$startdir"
+  npm ci
+  # Build through the Tauri CLI (not a raw `cargo build --release`): it enables
+  # the `custom-protocol` cargo feature that makes the binary load the embedded
+  # `dist/` assets instead of the Vite dev server URL (127.0.0.1:1420), and runs
+  # `beforeBuildCommand` (`npm run build`) for us. `--no-bundle` skips deb/rpm/
+  # appimage packaging (and with it linuxdeploy/FUSE) since pacman owns that here.
+  npm run tauri -- build --no-bundle
+}
+
+package() {
+  cd "$startdir"
+
+  install -Dm755 "src-tauri/target/release/gitty" "$pkgdir/usr/bin/gitty"
+
+  install -Dm644 "src-tauri/icons/32x32.png" \
+    "$pkgdir/usr/share/icons/hicolor/32x32/apps/gitty.png"
+  install -Dm644 "src-tauri/icons/128x128.png" \
+    "$pkgdir/usr/share/icons/hicolor/128x128/apps/gitty.png"
+  install -Dm644 "src-tauri/icons/128x128@2x.png" \
+    "$pkgdir/usr/share/icons/hicolor/256x256@2/apps/gitty.png"
+  install -Dm644 "src-tauri/icons/icon.png" \
+    "$pkgdir/usr/share/icons/hicolor/512x512/apps/gitty.png"
+
+  install -d "$pkgdir/usr/share/applications"
+  cat > "$pkgdir/usr/share/applications/gitty.desktop" <<-EOF
+	[Desktop Entry]
+	Type=Application
+	Name=Gitty
+	Comment=$pkgdesc
+	Exec=gitty
+	Icon=gitty
+	Terminal=false
+	Categories=Development;RevisionControl;
+	StartupWMClass=gitty
+	EOF
+
+  install -Dm644 "README.md" "$pkgdir/usr/share/doc/$pkgname/README.md"
+}

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
+**A lightweight, modern Git client built with Tauri.**
-- 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
 
-## Entwicklung
+Fast, simple, and designed for developers who want a clean Git experience without unnecessary complexity.
 
-```powershell
+</div>
-npm install
-npm run tauri:dev
-```
 
-Frontend allein:
+---
 
-```powershell
+## ✨ Features
-npm run dev
-```
 
-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 (
+    bundle_dirs = {
-        ARTIFACT_ROOT / "msi",
+        ARTIFACT_ROOT / "msi": (".msi", ".sig"),
-        ARTIFACT_ROOT / "nsis",
+        ARTIFACT_ROOT / "nsis": (".exe", ".sig"),
-        ARTIFACT_ROOT / "app",
+        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]:
+def _select_primary_artifact(
-    priority = (".exe", ".msi", ".zip", ".dmg")
+    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 = {
+    platforms: dict[str, Any] = {}
-        "version": version,
+    existing_notes = None
-        "pub_date": pub_date,
+    if existing_payload and existing_payload.get("version") == version:
-        "notes": os.environ.get("RELEASE_NOTES", "Automated release"),
+        existing_platforms = existing_payload.get("platforms")
-        "platforms": {
+        if isinstance(existing_platforms, dict):
-            "windows-x86_64": {
+            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").
+    # S3_BUCKET variable is cased (e.g. "Gitty" -> "gitty").
-    bucket_name = (os.environ.get("S3_BUCKET") or "gitlite").lower()
+    bucket_name = (os.environ.get("S3_BUCKET") or "gitty").lower()
-    bucket_prefix = (app_dir or os.environ.get("APP_DIR") or "gitlite").strip("/")
+    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,
     )
-
+    latest_json = json.dumps(latest_payload, separators=(",", ":"))
-    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_path.write_text(latest_json + "\n", encoding="utf-8")
 
-    client = _create_minio_client()
+    for target in publish_targets:
-    _ensure_bucket(client, bucket_name)
+        _publish_target(
-
+            client=client,
-    for artifact in artifacts:
+            target=target,
-        object_segments = [part for part in (resolved_version, artifact.name) if part]
+            version=resolved_version,
-        object_name = "/".join(object_segments)
+            platform=platform,
-        client.fput_object(bucket_name, object_name, str(artifact))
+            artifacts=artifacts,
-        print(f"Uploaded {artifact.name} -> s3://{bucket_name}/{object_name}")
+            primary_artifact=primary,
-
+            signature=signature,
-    latest_object_name = "latest.json"
+            artifact_base_url=artifact_base_url,
-    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",
         )
-    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",
+  "name": "gitty",
-  "version": "0.0.3",
+  "version": "2026.7.19",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "tauri-git-lite",
+      "name": "gitty",
-      "version": "0.0.3",
+      "version": "2026.7.19",
       "dependencies": {
         "@lucide/svelte": "^1.21.0",
         "@tailwindcss/vite": "^4.3.1",

package.json

@@ -1,11 +1,12 @@
 {
-  "name": "git-lite",
+  "name": "gitty",
-  "version": "0.0.3",
+  "version": "2026.7.19",
   "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,57 @@
 [package]
-name = "tauri_git_lite"
+name = "gitty"
 version = "0.1.0"
 description = "Rust backend for a lightweight Git desktop client"
-edition = "2021"
+edition = "2024"
-rust-version = "1.77"
+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"
+
+# Self-updating only makes sense for install methods this app ships itself
+# (NSIS on Windows, the .app bundle on macOS). On Linux the app is meant to be
+# installed via the system package manager (e.g. the PKGBUILD), which owns
+# updates instead — so the updater plugin isn't even compiled in there.
+[target.'cfg(not(any(target_os = "android", target_os = "ios", target_os = "linux")))'.dependencies]
 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/capabilities/desktop.json

@@ -2,8 +2,7 @@
   "identifier": "desktop-capability",
   "platforms": [
     "macOS",
-    "windows",
+    "windows"
-    "linux"
   ],
   "windows": [
     "main"

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,340 @@
+use std::time::Duration;
+
+use serde::{Deserialize, Serialize};
+
+use crate::{build_messages, build_review_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
+}
+
+async fn openai_compatible_review_request(
+    url: String,
+    bearer: Option<&str>,
+    model: &str,
+    diff: &str,
+) -> Result<String, String> {
+    let (system, user) = build_review_messages(diff)?;
+    let body = OpenAiRequest {
+        model: model.to_string(),
+        messages: vec![
+            OpenAiMessage {
+                role: "system",
+                content: system,
+            },
+            OpenAiMessage {
+                role: "user",
+                content: user,
+            },
+        ],
+        temperature: 0.1,
+    };
+    let client = http_client()?;
+    let mut request = client.post(url).json(&body);
+    if let Some(key) = bearer.filter(|key| !key.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}"))?;
+    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 review.".to_string())
+}
+
+pub async fn review_openai(api_key: &str, model: &str, diff: &str) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("OpenAI API key is missing.".to_string());
+    }
+    openai_compatible_review_request(
+        "https://api.openai.com/v1/chat/completions".to_string(),
+        Some(api_key),
+        model,
+        diff,
+    )
+    .await
+}
+
+pub async fn review_custom(
+    base_url: &str,
+    api_key: Option<&str>,
+    model: &str,
+    diff: &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_review_request(url, api_key, model, diff).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)
+}
+
+pub async fn review_anthropic(api_key: &str, model: &str, diff: &str) -> Result<String, String> {
+    if api_key.trim().is_empty() {
+        return Err("Anthropic API key is missing.".to_string());
+    }
+    let (system, user) = build_review_messages(diff)?;
+    let body = AnthropicRequest {
+        model: model.to_string(),
+        max_tokens: 2400,
+        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}"))?;
+    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 review.".to_string())
+}

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

@@ -0,0 +1,472 @@
+mod cloud;
+
+pub use cloud::{
+    generate_anthropic, generate_custom, generate_openai, review_anthropic, review_custom,
+    review_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))
+}
+
+pub(crate) fn build_review_messages(diff: &str) -> Result<(String, String), String> {
+    if diff.trim().is_empty() {
+        return Err("No staged changes available for review.".to_string());
+    }
+
+    const MAX_CHARS: usize = 36_000;
+    let diff = truncate_at_char_boundary(diff, MAX_CHARS);
+    let system = r#"You are a senior software engineer performing a focused pre-commit review.
+Review only the supplied staged Git diff. Look for concrete correctness bugs, security issues,
+data loss, regressions, broken edge cases, unsafe error handling, and meaningful performance or
+maintainability risks. Do not report formatting preferences or speculative nitpicks.
+
+Return ONLY valid JSON with this exact shape:
+{"summary":"one concise overall assessment","risk":"low|medium|high","findings":[{"severity":"critical|warning|info","title":"short title","description":"clear evidence and impact","file":"path or null","line":123,"suggestion":"specific safe next step"}]}
+
+Use the new-file line number from the diff when it is known; otherwise use null. Use null for file
+when the issue is repository-wide. Maximum 12 findings, ordered critical then warning then info.
+If no actionable issue exists, return an empty findings array and risk low. Never use markdown,
+code fences, commentary outside the JSON, or claim that tests were executed."#
+        .to_string();
+    let user = format!("Staged diff to review:\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,141 @@
 #![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,
+    SearchCancellationState, amend_commit, apply_file_patch, cancel_code_search,
-    compare_file_to_parent, cred_delete, cred_load, cred_save, diff_file_against_working_tree,
+    cancel_file_history, checkout_branch, cherry_pick_abort, cherry_pick_commit,
-    get_remote_url, get_status, list_branches, list_commits, list_file_history,
+    cherry_pick_continue, clone_repository, commit, commit_ai_generate, commit_ai_load,
-    list_repository_files, merge_branch, open_repository, pull, push, read_conflict,
+    commit_ai_local_models, commit_ai_review, commit_ai_status, compare_commits,
-    resolve_conflict, resolve_conflict_side, restore_file_from_commit, restore_files,
+    compare_file_to_head, compare_file_to_parent, create_branch, create_tag, cred_delete,
-    restore_to_commit, search_code_introductions, stage_files, unstage_files,
+    cred_load, cred_save, delete_branch, delete_tag, diff_file_against_working_tree, fetch,
-    SearchCancellationState,
+    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;
 
-fn main() {
+#[tauri::command]
-    tauri::Builder::default()
+fn close_splashscreen(app: tauri::AppHandle) -> Result<(), String> {
-        .plugin(tauri_plugin_updater::Builder::new().build())
+    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") {
+        let _ = window.maximize();
+        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;
+    }
+
+    let builder = 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_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())
-        .plugin(tauri_plugin_dialog::init())
+        .manage(commit_ai::CommitAiEngine::new())
+        .plugin(tauri_plugin_dialog::init());
+
+    // Linux installs are expected to come from the system package manager (see the
+    // PKGBUILD), which owns updates itself — the self-updater is only wired up for
+    // the platforms whose install method this app ships (NSIS/Windows, .app/macOS).
+    #[cfg(not(target_os = "linux"))]
+    let builder = builder.plugin(tauri_plugin_updater::Builder::new().build());
+
+    builder
         .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,
+            commit_ai_review,
             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 +148,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",
+  "productName": "Gitty",
-  "version": "0.0.3",
+  "version": "2026.7.19",
-  "identifier": "com.git-lite",
+  "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",
+    "targets": [
-    "icon": ["icons/icon.ico"],
+      "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/RepoTabs.svelte

@@ -0,0 +1,77 @@
+<script lang="ts">
+  import { BookOpen, Database, Plus, X } from "@lucide/svelte";
+
+  interface RepositoryTabItem {
+    path: string;
+    name: string;
+    branch: string | null;
+  }
+
+  export let activeView: "management" | "repository" = "management";
+  export let repoTabs: RepositoryTabItem[] = [];
+  export let isBusy: boolean = false;
+  export let language: "en" | "de" = "en";
+  export let onOpenManagement: () => void = () => {};
+  export let isActive: (path: string) => boolean = () => false;
+  export let onSelect: (path: string) => void | Promise<void> = () => {};
+  export let onClose: (path: string, event: MouseEvent) => void | Promise<void> = () => {};
+  export let onContextMenu: (path: string, event: MouseEvent) => void = () => {};
+  export let onAdd: () => void | Promise<void> = () => {};
+</script>
+
+<header class="repo-tabbar" aria-label={language === "de" ? "Repository-Reiter" : "Repository tabs"}>
+  <button
+    class="repo-tab management"
+    class:active={activeView === "management"}
+    type="button"
+    onclick={onOpenManagement}
+    disabled={isBusy}
+    title={language === "de" ? "Repository-Verwaltung" : "Repository Management"}
+  >
+    <BookOpen size={14} aria-hidden="true" />
+    <span>{language === "de" ? "Repository-Verwaltung" : "Repository Management"}</span>
+  </button>
+
+  <div class="repo-tabs-scroll">
+    {#each repoTabs as repo (repo.path)}
+      <div
+        class="repo-tab-wrap"
+        class:active={isActive(repo.path)}
+        role="presentation"
+        oncontextmenu={(event) => onContextMenu(repo.path, event)}
+      >
+        <button
+          class="repo-tab"
+          type="button"
+          onclick={() => onSelect(repo.path)}
+          disabled={isBusy}
+          title={repo.path}
+        >
+          <Database size={15} aria-hidden="true" />
+          <span>{repo.name}</span>
+        </button>
+        <button
+          class="repo-tab-close"
+          type="button"
+          onclick={(event) => onClose(repo.path, event)}
+          disabled={isBusy}
+          aria-label={language === "de" ? `${repo.name} schließen` : `Close ${repo.name}`}
+          title={language === "de" ? "Repository-Tab schließen" : "Close repository tab"}
+        >
+          <X size={13} aria-hidden="true" />
+        </button>
+      </div>
+    {/each}
+  </div>
+
+  <button
+    class="repo-tab-add"
+    type="button"
+    onclick={onAdd}
+    disabled={isBusy}
+    title={language === "de" ? "Repository-Ordner öffnen" : "Open repository folder"}
+    aria-label={language === "de" ? "Repository-Ordner öffnen" : "Open repository folder"}
+  >
+    <Plus size={15} aria-hidden="true" />
+  </button>
+</header>

src/lib/RepoToolbar.svelte

@@ -0,0 +1,202 @@
+<script lang="ts">
+  import {
+    ChevronDown,
+    CloudDownload,
+    Download,
+    FolderOpen,
+    GitCompare,
+    History,
+    ListRestart,
+    LoaderCircle,
+    RefreshCw,
+    Search,
+    Upload,
+  } from "@lucide/svelte";
+
+  export let hasRepository: boolean = false;
+  export let isBusy: boolean = false;
+  export let operation: string = "";
+  export let ahead: number = 0;
+  export let behind: number = 0;
+  export let language: "en" | "de" = "en";
+  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 = () => {};
+
+  let historyOpen = false;
+  let toolbarElement: HTMLDivElement;
+
+  $: isGerman = language === "de";
+
+  function runHistoryAction(action: () => void) {
+    historyOpen = false;
+    action();
+  }
+
+  function handleWindowClick(event: MouseEvent) {
+    if (historyOpen && toolbarElement && !toolbarElement.contains(event.target as Node)) {
+      historyOpen = false;
+    }
+  }
+
+  function handleWindowKeydown(event: KeyboardEvent) {
+    if (event.key === "Escape" && historyOpen) {
+      event.stopPropagation();
+      historyOpen = false;
+    }
+  }
+</script>
+
+<svelte:window onclick={handleWindowClick} onkeydown={handleWindowKeydown} />
+
+<div bind:this={toolbarElement} class="repo-toolbar" role="toolbar" aria-label={isGerman ? "Repository-Aktionen" : "Repository actions"}>
+  <div class="repo-toolbar-sync">
+    <div class="repo-action-group repo-sync-actions">
+      <button
+        class="repo-action fetch"
+        onclick={onFetch}
+        disabled={!hasRepository || isBusy}
+        title="Fetch"
+        aria-label="Fetch"
+      >
+        {#if operation === "Fetching"}
+          <LoaderCircle class="spin" size={15} aria-hidden="true" />
+        {:else}
+          <CloudDownload size={15} aria-hidden="true" />
+        {/if}
+        <span class="repo-action-label">Fetch</span>
+      </button>
+
+      <button
+        class="repo-action sync-primary"
+        onclick={onPull}
+        disabled={!hasRepository || isBusy}
+        title="Pull"
+        aria-label={behind > 0
+          ? `Pull, ${behind} ${isGerman ? (behind === 1 ? "Remote-Commit voraus" : "Remote-Commits voraus") : (behind === 1 ? "commit behind" : "commits behind")}`
+          : "Pull"}
+      >
+        {#if operation === "Pulling"}
+          <LoaderCircle class="spin" size={15} aria-hidden="true" />
+        {:else}
+          <Download size={15} aria-hidden="true" />
+        {/if}
+        <span class="repo-action-label">Pull</span>
+        {#if behind > 0}<span class="repo-action-count behind">↓{behind}</span>{/if}
+      </button>
+
+      <button
+        class="repo-action sync-primary"
+        onclick={onPush}
+        disabled={!hasRepository || isBusy}
+        title="Push"
+        aria-label={ahead > 0
+          ? `Push, ${ahead} ${isGerman ? (ahead === 1 ? "lokaler Commit voraus" : "lokale Commits voraus") : (ahead === 1 ? "commit ahead" : "commits ahead")}`
+          : "Push"}
+      >
+        {#if operation === "Pushing"}
+          <LoaderCircle class="spin" size={15} aria-hidden="true" />
+        {:else}
+          <Upload size={15} aria-hidden="true" />
+        {/if}
+        <span class="repo-action-label">Push</span>
+        {#if ahead > 0}<span class="repo-action-count ahead">↑{ahead}</span>{/if}
+      </button>
+    </div>
+  </div>
+
+  <div class="repo-toolbar-divider" aria-hidden="true"></div>
+
+  <div class="repo-action-group repo-inspect-actions">
+    <button
+      class="repo-action"
+      onclick={onSearch}
+      disabled={!hasRepository || isBusy}
+      title={isGerman ? "Globale Suche" : "Global search"}
+      aria-label={isGerman ? "Globale Suche" : "Global search"}
+    >
+      <Search size={15} aria-hidden="true" />
+      <span class="repo-action-label">{isGerman ? "Suchen" : "Search"}</span>
+    </button>
+
+    <button
+      class="repo-action"
+      onclick={onCompare}
+      disabled={!hasRepository || isBusy}
+      title={isGerman ? "Commits vergleichen" : "Compare commits"}
+      aria-label={isGerman ? "Commits vergleichen" : "Compare commits"}
+    >
+      <GitCompare size={15} aria-hidden="true" />
+      <span class="repo-action-label">{isGerman ? "Vergleichen" : "Compare"}</span>
+    </button>
+
+    <div class="repo-history-wrap">
+      <button
+        class="repo-action history-trigger"
+        class:active={historyOpen}
+        type="button"
+        onclick={() => { historyOpen = !historyOpen; }}
+        disabled={!hasRepository || isBusy}
+        aria-haspopup="menu"
+        aria-expanded={historyOpen}
+        title={isGerman ? "Verlauf und Rebase" : "History and rebase"}
+      >
+        <History size={15} aria-hidden="true" />
+        <span class="repo-action-label">{isGerman ? "Verlauf" : "History"}</span>
+        <ChevronDown class="history-chevron" size={13} aria-hidden="true" />
+      </button>
+
+      {#if historyOpen}
+        <div class="repo-history-menu" role="menu">
+          <button type="button" role="menuitem" onclick={() => runHistoryAction(onReflog)}>
+            <History size={15} aria-hidden="true" />
+            <span>
+              <strong>Reflog</strong>
+              <small>{isGerman ? "Lokale Referenzbewegungen" : "Local reference movements"}</small>
+            </span>
+          </button>
+          <button type="button" role="menuitem" onclick={() => runHistoryAction(onInteractiveRebase)}>
+            <ListRestart size={15} aria-hidden="true" />
+            <span>
+              <strong>{isGerman ? "Interaktiver Rebase" : "Interactive rebase"}</strong>
+              <small>{isGerman ? "Commits ordnen und zusammenfassen" : "Reorder and combine commits"}</small>
+            </span>
+          </button>
+        </div>
+      {/if}
+    </div>
+  </div>
+
+  <div class="repo-toolbar-spacer"></div>
+  <div class="repo-toolbar-divider utility" aria-hidden="true"></div>
+
+  <div class="repo-action-group repo-utility-actions">
+    <button
+      class="repo-action"
+      onclick={onOpenInExplorer}
+      disabled={!hasRepository || isBusy}
+      title={isGerman ? "Repository im Explorer öffnen" : "Open repository in Explorer"}
+      aria-label={isGerman ? "Repository im Explorer öffnen" : "Open repository in Explorer"}
+    >
+      <FolderOpen size={15} aria-hidden="true" />
+      <span class="repo-action-label utility-label">Explorer</span>
+    </button>
+
+    <button
+      class="repo-action"
+      onclick={onRefresh}
+      disabled={isBusy || !hasRepository}
+      title={isGerman ? "Manuell aktualisieren" : "Refresh now"}
+      aria-label={isGerman ? "Manuell aktualisieren" : "Refresh now"}
+    >
+      <RefreshCw class={operation === "Refreshing" ? "spin" : ""} size={16} aria-hidden="true" />
+      <span class="repo-action-label utility-label">{isGerman ? "Aktualisieren" : "Refresh"}</span>
+    </button>
+  </div>
+</div>

src/lib/TitleBar.svelte

@@ -1,168 +1,84 @@
 <script lang="ts">
   import { onDestroy, onMount } from "svelte";
   import { getCurrentWindow } from "@tauri-apps/api/window";
-  import { Download, GitBranch, LoaderCircle, Minus, RefreshCw, Search, Upload, X } from "@lucide/svelte";
+  import { CircleHelp, Minus, Settings, X } from "@lucide/svelte";
+  import iconUrl from "../../src-tauri/icons/icon.png";
 
-  export let branch: string = "";
+  export let onOpenHelp: () => void = () => {};
-  export let ahead: number = 0;
+  export let onOpenSettings: () => void = () => {};
-  export let behind: number = 0;
+  export let language: "en" | "de" = "en";
-  export let repoName: string = "";
-  export let hasRepository: boolean = false;
-  export let isBusy: boolean = false;
-  export let operation: string = "";
-  export let autoRefreshEnabled: boolean = true;
-  export let autoRefreshInFlight: boolean = false;
-  export let onPull: () => void = () => {};
-  export let onPush: () => void = () => {};
-  export let onRefresh: () => void = () => {};
-  export let onSearch: () => void = () => {};
-  export let onToggleAutoRefresh: () => void = () => {};
 
-  const win = getCurrentWindow();
+  let win: ReturnType<typeof getCurrentWindow> | null = null;
   let isMaximized = false;
   let unlisten: (() => void) | undefined;
 
   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;
+    }
   });
 
   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
+    <span class="titlebar-brand-icon" data-tauri-drag-region>
-      width="15"
+      <img src={iconUrl} alt="" data-tauri-drag-region />
-      height="15"
+    </span>
-      viewBox="0 0 24 24"
+    <span data-tauri-drag-region>Gitty</span>
-      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>
   </div>
 
-  <!-- Center: repo + branch info -->
+  <div class="titlebar-drag" data-tauri-drag-region aria-hidden="true"></div>
-  <div class="titlebar-info" data-tauri-drag-region>
-    {#if hasRepository}
-      {#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>
-      {#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}
-    {:else}
-      <span class="tb-no-repo" data-tauri-drag-region>No repository open</span>
-    {/if}
-  </div>
 
-  <!-- Right: actions + window controls -->
+  <!-- Right: app-global actions + window controls -->
-  <div class="titlebar-right">
+  <div class="titlebar-globals">
-    <div class="titlebar-actions" role="toolbar" aria-label="Repository actions">
     <button
       class="tb-action"
-        onclick={onSearch}
+      onclick={onOpenHelp}
-        disabled={!hasRepository || isBusy}
+      title={language === "de" ? "Hilfe (Ctrl+/)" : "Help (Ctrl+/)"}
-        title="Global search"
+      aria-label={language === "de" ? "Hilfe öffnen" : "Open help"}
-        aria-label="Global search"
     >
-        <Search size={14} aria-hidden="true" />
+      <CircleHelp size={14} aria-hidden="true" />
-        <span class="tb-action-label">Search</span>
     </button>
-
     <button
       class="tb-action"
-        onclick={onPull}
+      onclick={onOpenSettings}
-        disabled={!hasRepository || isBusy}
+      title={language === "de" ? "Einstellungen" : "Settings"}
-        title="Pull"
+      aria-label={language === "de" ? "Einstellungen" : "Settings"}
-        aria-label="Pull"
     >
-        {#if operation === "Pulling"}
+      <Settings size={14} aria-hidden="true" />
-          <LoaderCircle class="spin" size={14} aria-hidden="true" />
-        {:else}
-          <Download size={14} aria-hidden="true" />
-        {/if}
-        <span class="tb-action-label">Pull</span>
-      </button>
-
-      <button
-        class="tb-action"
-        onclick={onPush}
-        disabled={!hasRepository || isBusy}
-        title="Push"
-        aria-label="Push"
-      >
-        {#if operation === "Pushing"}
-          <LoaderCircle class="spin" size={14} aria-hidden="true" />
-        {:else}
-          <Upload size={14} aria-hidden="true" />
-        {/if}
-        <span class="tb-action-label">Push</span>
-      </button>
-
-      <button
-        class="tb-action"
-        onclick={onRefresh}
-        disabled={isBusy || !hasRepository}
-        title="Refresh"
-        aria-label="Refresh"
-      >
-        <RefreshCw
-          class={operation === "Refreshing" ? "spin" : ""}
-          size={14}
-          aria-hidden="true"
-        />
-        <span class="tb-action-label">Refresh</span>
-      </button>
-
-      <button
-        class="tb-action auto-toggle"
-        class:active={autoRefreshEnabled}
-        onclick={onToggleAutoRefresh}
-        aria-pressed={autoRefreshEnabled}
-        title={autoRefreshEnabled ? "Auto-refresh on — click to disable" : "Auto-refresh off — click to enable"}
-        aria-label="Toggle auto-refresh"
-      >
-        <RefreshCw
-          class={autoRefreshInFlight ? "spin" : ""}
-          size={14}
-          aria-hidden="true"
-        />
-        <span class="tb-action-label">Auto</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,9 +93,8 @@
         </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>
-  </div>
 </header>

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/AiReviewDialog.svelte

@@ -0,0 +1,94 @@
+<script lang="ts">
+  import { AlertTriangle, CircleAlert, FileCode, Info, LoaderCircle, RotateCw, ShieldCheck, X } from "@lucide/svelte";
+  import type { AiReviewFinding, AiReviewResult, CommitAiProvider } from "../types";
+
+  interface Props {
+    result: AiReviewResult;
+    provider: CommitAiProvider;
+    isReviewing: boolean;
+    onRerun: () => void;
+    onClose: () => void;
+  }
+
+  let { result, provider, isReviewing = false, onRerun, onClose }: Props = $props();
+
+  function providerLabel(value: CommitAiProvider): string {
+    if (value === "openai") return "OpenAI";
+    if (value === "anthropic") return "Anthropic";
+    if (value === "custom") return "Custom endpoint";
+    return "Local AI";
+  }
+
+  function locationLabel(finding: AiReviewFinding): string {
+    if (!finding.file) return "Repository-wide";
+    return finding.line ? `${finding.file}:${finding.line}` : finding.file;
+  }
+</script>
+
+<svelte:window onkeydown={(event) => { if (event.key === "Escape" && !isReviewing) onClose(); }} />
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog ai-review-dialog" role="dialog" aria-modal="true" aria-label="AI pre-commit review" tabindex="-1">
+    <header class="dialog-header ai-review-header">
+      <div>
+        <span class="eyebrow">Staged changes</span>
+        <h2>AI pre-commit review</h2>
+      </div>
+      <div class="dialog-header-actions">
+        <span class="ai-review-provider">{providerLabel(provider)}</span>
+        <button class="dialog-close" type="button" onclick={onClose} disabled={isReviewing} aria-label="Close review"><X size={18} aria-hidden="true" /></button>
+      </div>
+    </header>
+
+    <div class="ai-review-summary">
+      <div class="ai-review-summary-icon" class:clean={result.findings.length === 0}>
+        {#if result.findings.length === 0}<ShieldCheck size={22} aria-hidden="true" />{:else}<AlertTriangle size={22} aria-hidden="true" />{/if}
+      </div>
+      <div>
+        <div class="ai-review-summary-line">
+          <strong>{result.findings.length === 0 ? "No actionable issues found" : `${result.findings.length} review ${result.findings.length === 1 ? "finding" : "findings"}`}</strong>
+          <span class="ai-review-risk {result.risk}">{result.risk} risk</span>
+        </div>
+        <p>{result.summary}</p>
+      </div>
+    </div>
+
+    <div class="ai-review-findings">
+      {#if result.findings.length === 0}
+        <div class="ai-review-clean-state">
+          <ShieldCheck size={30} aria-hidden="true" />
+          <strong>The staged diff looks ready for human verification.</strong>
+          <span>AI reviews can miss issues. Run the relevant tests before committing.</span>
+        </div>
+      {:else}
+        {#each result.findings as finding, index (`${finding.file ?? "repo"}:${finding.line ?? 0}:${finding.title}:${index}`)}
+          <article class="ai-review-finding {finding.severity}">
+            <div class="ai-review-finding-icon">
+              {#if finding.severity === "critical"}<CircleAlert size={17} aria-hidden="true" />{:else if finding.severity === "warning"}<AlertTriangle size={17} aria-hidden="true" />{:else}<Info size={17} aria-hidden="true" />{/if}
+            </div>
+            <div class="ai-review-finding-body">
+              <div class="ai-review-finding-title">
+                <span>{finding.severity}</span>
+                <strong>{finding.title}</strong>
+              </div>
+              <p>{finding.description}</p>
+              <div class="ai-review-location"><FileCode size={13} aria-hidden="true" /><code>{locationLabel(finding)}</code></div>
+              {#if finding.suggestion}<div class="ai-review-suggestion"><strong>Suggested next step</strong><span>{finding.suggestion}</span></div>{/if}
+            </div>
+          </article>
+        {/each}
+      {/if}
+    </div>
+
+    <footer class="dialog-footer ai-review-footer">
+      <p>Review suggestions are advisory and never modify files automatically.</p>
+      <div>
+        <button class="btn-secondary" type="button" onclick={onRerun} disabled={isReviewing}>
+          {#if isReviewing}<LoaderCircle class="spin" size={14} aria-hidden="true" />{:else}<RotateCw size={14} aria-hidden="true" />{/if}
+          Review again
+        </button>
+        <button class="btn-primary" type="button" onclick={onClose} disabled={isReviewing}>Done</button>
+      </div>
+    </footer>
+  </div>
+</div>

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,142 @@
+<script lang="ts">
+  import { Check, Languages, RefreshCw, Settings, X } from "@lucide/svelte";
+  import type { AnalyticsSettings, AppLanguage, AppTheme } from "../types";
+
+  interface Props {
+    analytics: AnalyticsSettings;
+    theme: AppTheme;
+    language: AppLanguage;
+    autoRefresh: boolean;
+    onSave: (settings: AnalyticsSettings, theme: AppTheme, language: AppLanguage, autoRefresh: boolean) => void;
+    onClose: () => void;
+  }
+
+  let { analytics, theme = "system", language = "en", autoRefresh = true, onSave = () => {}, onClose = () => {} }: Props = $props();
+
+  let analyticsEnabled = $state(true);
+  let selectedTheme = $state<AppTheme>("system");
+  let selectedLanguage = $state<AppLanguage>("en");
+  let autoRefreshEnabled = $state(true);
+  const isGerman = $derived(selectedLanguage === "de");
+
+  $effect(() => {
+    analyticsEnabled = analytics.enabled;
+    selectedTheme = theme;
+    selectedLanguage = language;
+    autoRefreshEnabled = autoRefresh;
+  });
+
+  function save() {
+    onSave({
+      ...analytics,
+      enabled: analyticsEnabled,
+      noticeSeen: true,
+    }, selectedTheme, selectedLanguage, autoRefreshEnabled);
+  }
+</script>
+
+<div class="dialog-backdrop" role="presentation">
+  <div class="dialog app-settings-dialog" role="dialog" aria-modal="true" aria-label={isGerman ? "Einstellungen" : "Settings"} tabindex="-1">
+    <header class="dialog-header">
+      <div>
+        <span class="eyebrow">Gitty</span>
+        <h2 class="dialog-title">{isGerman ? "Einstellungen" : "Settings"}</h2>
+      </div>
+      <button class="dialog-close" type="button" onclick={onClose} title={isGerman ? "Schließen" : "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">{isGerman ? "Darstellung" : "Appearance"}</span>
+            <h3>{isGerman ? "Farbschema" : "Theme"}</h3>
+          </div>
+        </header>
+
+        <div class="settings-segmented" role="radiogroup" aria-label={isGerman ? "Farbschema" : "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>{isGerman ? "Hell" : "Light"}</span>
+          </label>
+          <label class:active={selectedTheme === "dark"}>
+            <input type="radio" bind:group={selectedTheme} value="dark" />
+            <span>{isGerman ? "Dunkel" : "Dark"}</span>
+          </label>
+        </div>
+      </section>
+
+      <section class="settings-section">
+        <header>
+          <RefreshCw size={16} aria-hidden="true" />
+          <div>
+            <span class="eyebrow">Repository</span>
+            <h3>{isGerman ? "Automatische Aktualisierung" : "Auto refresh"}</h3>
+          </div>
+        </header>
+
+        <label class="settings-toggle-row">
+          <input type="checkbox" bind:checked={autoRefreshEnabled} />
+          <span>
+            <strong>{isGerman ? "Repositories automatisch aktualisieren" : "Refresh repositories automatically"}</strong>
+            <small>{isGerman ? "Aktualisiert Arbeitsbereich, Branch-Status und Remotes regelmäßig im Hintergrund." : "Periodically refreshes the working tree, branch status, and remotes in the background."}</small>
+          </span>
+        </label>
+      </section>
+
+      <section class="settings-section">
+        <header>
+          <Languages size={16} aria-hidden="true" />
+          <div>
+            <span class="eyebrow">{isGerman ? "Sprache" : "Language"}</span>
+            <h3>{isGerman ? "App-Sprache" : "App language"}</h3>
+          </div>
+        </header>
+
+        <div class="settings-segmented settings-language" role="radiogroup" aria-label={isGerman ? "App-Sprache" : "App language"}>
+          <label class:active={selectedLanguage === "en"}>
+            <input type="radio" bind:group={selectedLanguage} value="en" />
+            <span>EN · English</span>
+          </label>
+          <label class:active={selectedLanguage === "de"}>
+            <input type="radio" bind:group={selectedLanguage} value="de" />
+            <span>DE · Deutsch</span>
+          </label>
+        </div>
+      </section>
+
+      <section class="settings-section">
+        <header>
+          <Settings size={16} aria-hidden="true" />
+          <div>
+            <span class="eyebrow">Analytics</span>
+            <h3>{isGerman ? "Anonyme Nutzungsanalyse" : "Anonymous usage analytics"}</h3>
+          </div>
+        </header>
+
+        <label class="settings-toggle-row">
+          <input type="checkbox" bind:checked={analyticsEnabled} />
+          <span>
+            <strong>{isGerman ? "Anonyme Aptabase-Ereignisse erlauben" : "Allow anonymous Aptabase events"}</strong>
+            <small>{isGerman ? "Es werden keine Repository-Pfade, Remotes, Branches, Commit-Nachrichten, Dateinamen, Diffs, Zugangsdaten oder Code übertragen." : "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}>{isGerman ? "Abbrechen" : "Cancel"}</button>
+        <button class="btn-primary" type="submit">
+          <Check size={16} aria-hidden="true" />
+          {isGerman ? "Speichern" : "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 { Check, ChevronDown, ChevronRight, Folder, FolderOpen, GitBranch, GitMerge, Pencil, Plus, Tag as TagIcon, Trash2, Upload, X } from "@lucide/svelte";
-  import type { GitBranch as GitBranchInfo } from "../types";
+  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">
+    <div class="branch-list overflow-auto p-2 flex flex-col gap-0">
-      {#if localBranches.length > 0}
+      {#if createOpen}
-        <div class="branch-group-label">
+        <form class="branch-create-form" onsubmit={submitCreate}>
-          <span>Local</span>
+          <GitBranch size={15} aria-hidden="true" />
-          <span class="branch-group-count">{localBranches.length}</span>
+          <input
-        </div>
+            bind:this={createInput}
-        {#each localBranches as branch (branch.name)}
+            bind:value={newBranchName}
-          {#snippet branchCard()}
+            disabled={isBusy}
-            <article class="branch-row" class:current={branch.current}>
+            autocomplete="off"
-              <div class="branch-info">
+            spellcheck="false"
-                <GitBranch size={16} aria-hidden="true" />
+            placeholder="new-branch-name"
-                <div>
+            aria-label="New branch name"
-                  <strong>{branch.name}</strong>
+          />
-                  <span>local</span>
+          <button class="branch-create-action confirm" type="submit" disabled={isBusy || newBranchName.trim().length === 0} title="Create branch">
-                </div>
+            <Check size={14} aria-hidden="true" />
-              </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
           </button>
-                  <button class="btn-sm" type="button" onclick={() => onMerge(branch)} disabled={isBusy} title="Merge into current">
+          <button class="branch-create-action" type="button" onclick={closeCreateForm} disabled={isBusy} title="Cancel">
-                    <GitMerge size={15} aria-hidden="true" />
+            <X size={14} aria-hidden="true" />
-                    Merge
           </button>
-                </div>
+        </form>
-              {/if}
-            </article>
-          {/snippet}
-          {@render branchCard()}
-        {/each}
       {/if}
 
-      {#if remoteBranches.length > 0}
+      <div class="branch-group">
-        <div class="branch-group-label" style="margin-top: {localBranches.length > 0 ? '12px' : '0'}">
+        <button
-          <span>Remote</span>
+          class="branch-group-toggle"
-          <span class="branch-group-count">{remoteBranches.length}</span>
+          type="button"
-        </div>
+          onclick={() => { localOpen = !localOpen; }}
-        {#each remoteBranches as branch (branch.name)}
+          aria-expanded={localOpen}
-          <article class="branch-row" class:current={branch.current}>
+        >
+          {#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>
+                      <strong>{row.displayName}</strong>
-                <span>remote</span>
+                      <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">
+            <ChevronRight size={14} aria-hidden="true" />
-                <button class="btn-sm" type="button" onclick={() => onCheckout(branch)} disabled={isBusy}>
+          {/if}
-                  Checkout
+          <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" />
+        {#if remoteOpen}
-                  Merge
+          {#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, ShieldCheck, Sparkles } from "@lucide/svelte";
+  import type { CommitAiPhase, CommitAiProvider } from "../types";
 
   interface Props {
     commitMessage: string;
@@ -9,8 +10,19 @@
     isBusy: boolean;
     operation: string;
     stagedCount: number;
+    commitAiProvider: CommitAiProvider;
+    commitAiPhase: CommitAiPhase;
+    commitAiGenerating: boolean;
+    commitAiReviewing: boolean;
+    canAmend: boolean;
+    amendMode: boolean;
     onCommit: () => void;
     onCommitMessageChange: (msg: string) => void;
+    onGenerateCommitMessage: () => void;
+    onReviewStaged: () => void;
+    onOpenAiSettings: () => void;
+    onToggleAmend: (checked: boolean) => void;
+    onUndoLastCommit: () => void;
   }
 
   let {
@@ -21,42 +33,121 @@
     isBusy = false,
     operation = "",
     stagedCount = 0,
+    commitAiProvider = "local",
+    commitAiPhase = "idle",
+    commitAiGenerating = false,
+    commitAiReviewing = false,
+    canAmend = false,
+    amendMode = false,
     onCommit = () => {},
     onCommitMessageChange = () => {},
+    onGenerateCommitMessage = () => {},
+    onReviewStaged = () => {},
+    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 &&
+    !commitAiReviewing &&
+    stagedCount > 0 &&
+    (commitAiProvider !== "local" || commitAiPhase === "ready"),
+  );
+  let canReview = $derived(canGenerate && commitAiProvider !== "local");
 </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>
+      <span class="eyebrow">Create revision</span>
-      <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Message</h2>
+      <h2 class="mt-0.5 text-ink text-base font-bold leading-tight">Commit</h2>
     </div>
+    <div class="commit-head-actions">
       <span class="pill pill-count">{stagedCount} staged</span>
+      <button
+        class="commit-review-button"
+        type="button"
+        onclick={onReviewStaged}
+        disabled={!canReview}
+        title={commitAiProvider === "local" ? "Pre-commit review currently requires an API provider" : stagedCount === 0 ? "Stage changes first" : "Review staged changes for bugs and risks"}
+      >
+        {#if commitAiReviewing}<LoaderCircle class="spin" size={14} aria-hidden="true" />{:else}<ShieldCheck size={14} aria-hidden="true" />{/if}
+        Review
+      </button>
+      <button
+        class="commit-generate-button"
+        type="button"
+        onclick={onGenerateCommitMessage}
+        disabled={!canGenerate}
+        title={aiButtonTitle(commitAiProvider, commitAiPhase, stagedCount)}
+      >
+        {#if commitAiGenerating || localModelLoading}<LoaderCircle class="spin" size={14} aria-hidden="true" />{:else}<Sparkles size={14} aria-hidden="true" />{/if}
+        Generate
+      </button>
+      <button class="commit-settings-button" type="button" onclick={onOpenAiSettings} disabled={isBusy} title="AI settings" aria-label="AI settings">
+        <Settings size={14} aria-hidden="true" />
+      </button>
+    </div>
   </div>
 
   <form class="commit-form" onsubmit={handleSubmit}>
     <textarea
       value={commitMessage}
       oninput={(e) => onCommitMessageChange((e.target as HTMLTextAreaElement).value)}
-      placeholder="Commit message..."
+      placeholder="Commit message"
       disabled={!hasRepository || isBusy}
     ></textarea>
     {#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 canAmend}
-      {#if operation === "Committing"}
+      <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>
+    </div>
   </form>
 </section>

src/lib/components/CompareDialog.svelte

@@ -10,11 +10,19 @@
         rightNum?: number; rightText?: string; rightKind: "add" | "context" | "empty";
       };
 
+  interface DiffMarker {
+    start: number;
+    end: number;
+    kind: "add" | "delete" | "mixed";
+  }
+
   interface Props {
     comparison: GitCommitComparison;
     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 +33,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;
@@ -157,16 +179,45 @@
     return rows;
   }
 
+  function buildDiffMarkers(rows: SplitRow[]): DiffMarker[] {
+    const markers: DiffMarker[] = [];
+    let current: DiffMarker | null = null;
+    for (let index = 0; index < rows.length; index++) {
+      const row = rows[index];
+      if (row.type !== "pair" || (row.leftKind === "context" && row.rightKind === "context")) {
+        current = null;
+        continue;
+      }
+      const kind = row.leftKind === "del" && row.rightKind === "add"
+        ? "mixed"
+        : row.rightKind === "add" ? "add" : "delete";
+      if (current && current.end === index - 1 && current.kind === kind) {
+        current.end = index;
+      } else {
+        current = { start: index, end: index, kind };
+        markers.push(current);
+      }
+    }
+    return markers;
+  }
+
+  function scrollToDiffMarker(rowIndex: number) {
+    const ratio = rowIndex / Math.max(splitRows.length - 1, 1);
+    for (const pane of [beforePane, afterPane]) {
+      if (pane) pane.scrollTop = ratio * Math.max(pane.scrollHeight - pane.clientHeight, 0);
+    }
+  }
+
   let diffByPath      = $derived(buildDiffByPath(comparison.patch));
   let selectedFile    = $derived(comparison.files.find((f) => f.path === selectedDiffPath) ?? null);
   let selectedPatch   = $derived(selectedFile ? (diffByPath.get(selectedFile.path) ?? "") : "");
   let splitRows       = $derived(buildSplitRows(selectedPatch));
+  let diffMarkers     = $derived(buildDiffMarkers(splitRows));
 </script>
 
 <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">
 
@@ -247,6 +298,7 @@
             </div>
 
             <!-- Split diff grid -->
+            <div class="split-diff-shell">
             <div class="split-diff" role="table" aria-label="Side-by-side diff">
               <div
                 class="split-pane"
@@ -259,8 +311,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-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"}>{row.leftText ?? " "}</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,13 +328,26 @@
                     {#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-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"}>{row.rightText ?? " "}</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>
               </div>
             </div>
+            <nav class="diff-overview" aria-label="Change overview">
+              {#each diffMarkers as marker, index (`${marker.start}-${marker.end}-${marker.kind}`)}
+                <button
+                  class="diff-overview-marker {marker.kind}"
+                  type="button"
+                  style={`--marker-position: ${(marker.start / Math.max(splitRows.length - 1, 1)) * 100}%`}
+                  onclick={() => scrollToDiffMarker(marker.start)}
+                  title={`Jump to change ${index + 1} of ${diffMarkers.length}`}
+                  aria-label={`Jump to change ${index + 1} of ${diffMarkers.length}`}
+                ></button>
+              {/each}
+            </nav>
+            </div>
           {/if}
         </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 actionLabel = $derived(action === "push" ? "Push" : action === "fetch" ? "Fetch" : action === "clone" ? "Clone" : "Pull");
-  let actionTitle = $derived(action === "push" ? "Push authentifizieren" : "Pull authentifizieren");
+  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."
+    ? "The remote needs write access. Use a password or a token with the appropriate repository permissions."
-    : "Der Remote braucht Zugriff auf das Repository. Nutze deine Git-Zugangsdaten oder einen Personal Access Token.");
+    : 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"
+                ? "ghp_... or another access token"
-                : "Passwort oder Personal 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}