feat(repo-tabs): replace tab bar with workspace navigation

Replace the legacy repository tab bar with a compact workspace
navigation that groups primary views and exposes a dedicated
"Repositories" action. The repository list is shown only when the
repository view is active and supports per-repo selection and closing.
Also add a Repositories open handler in the app to select the active
repo or prompt to choose a repository folder when none is available.

- Introduce top-level navigation (Dashboard, PRs, Issues, Repositories)
- Add onOpenRepositories hook and app logic to select or choose repo
- Update icons, styles, and accessibility attributes for the nav

.claude/settings.json

@@ -1,5 +0,0 @@
-{
-  "enabledPlugins": {
-    "frontend-design@claude-plugins-official": true
-  }
-}

.claude/settings.local.json

@@ -1,79 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(cargo build *)",
-      "Bash(npm run *)",
-      "Bash(kill %1)",
-      "Bash(perl -0pi -e 's/\\\\{line \\\\|\\\\| \" \"\\\\}/{displayLine\\(line\\) || \" \"}/g' src/App.svelte)",
-      "Bash(kill 26306)",
-      "Bash(convert --version)",
-      "Bash(magick /mnt/data/Development/GitLite/src-tauri/icons/icon.ico /mnt/data/Development/GitLite/src-tauri/icons/icon.png)",
-      "Bash(magick /mnt/data/Development/GitLite/src-tauri/icons/icon.ico -type TrueColorAlpha -alpha on PNG32:/mnt/data/Development/GitLite/src-tauri/icons/icon.png)",
-      "Bash(magick identify *)",
-      "Bash(magick -size 512x512 xc:\"rgba\\(70,130,180,255\\)\" PNG32:/mnt/data/Development/GitLite/src-tauri/icons/icon.png)",
-      "Bash(pkill -f \"vite --host\")",
-      "Bash(pkill -f \"tauri dev\")",
-      "Bash(pkill -f \"tauri_git_lite\")",
-      "Bash(xargs kill -9)",
-      "Bash(grep -qE \"\\(Running \\\\`target|error\\\\[|panicked|terminated\\)\" /tmp/claude-1000/-mnt-data-Development-GitLite/71a8b49f-ac61-4ad9-aaba-dc0219044038/tasks/b4ujhgmdk.output)",
-      "Bash(grep -qE \"\\(Running \\\\`target|error\\\\[|panicked|terminated\\)\" /tmp/claude-1000/-mnt-data-Development-GitLite/71a8b49f-ac61-4ad9-aaba-dc0219044038/tasks/bt54rikhh.output)",
-      "Bash(grep -qE \"\\(Running \\\\`target|error\\\\[|panicked|terminated\\)\" /tmp/claude-1000/-mnt-data-Development-GitLite/71a8b49f-ac61-4ad9-aaba-dc0219044038/tasks/b7nyub68s.output)",
-      "Bash(npm install *)",
-      "Bash(cargo check *)",
-      "Bash(npx vite *)",
-      "Bash(cargo tree *)",
-      "Bash(jobs)",
-      "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)"
-    ]
-  }
-}

.gitea/workflows/app_builder.yaml

@@ -5,7 +5,8 @@ on:
     types: [published]
 
 jobs:
-  publish-tauri:
+  publish-windows:
+    name: Build and publish Windows installer
     permissions:
       contents: write
     environment: production
@@ -30,20 +31,7 @@ jobs:
       run:
         working-directory: GitLite
 
-    strategy:
-      fail-fast: false
-      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: ""
-
-    runs-on: ${{ matrix.platform }}
+    runs-on: windows-latest
 
     steps:
       # cicd_tool/main.py expects the repo at <workspace>/GitLite, so check out there.
@@ -51,12 +39,6 @@ jobs:
         with:
           path: GitLite
 
-      - name: install dependencies (ubuntu only)
-        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
-
       - name: setup node
         uses: actions/setup-node@v4
         with:
@@ -69,16 +51,10 @@ jobs:
         run: npm version ${{ github.ref_name }} --no-git-tag-version --allow-same-version
 
       - name: Update tauri.conf.json Version
-        shell: powershell
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
         run: |
-          $path = ".\src-tauri\tauri.conf.json"
-          $version = '${{ github.ref_name }}'
-          $content = Get-Content -Raw -Encoding UTF8 $path
-          $regex = [regex]'"version"\s*:\s*"[^"]*"'
-          $replacement = '"version": "' + $version + '"'
-          $updated = $regex.Replace($content, $replacement, 1)
-          $encoding = New-Object System.Text.UTF8Encoding($false)
-          [System.IO.File]::WriteAllText($path, $updated, $encoding)
+          node -e "const fs=require('fs'); const path='src-tauri/tauri.conf.json'; const config=JSON.parse(fs.readFileSync(path,'utf8')); config.version=process.env.RELEASE_VERSION; fs.writeFileSync(path, JSON.stringify(config,null,2)+'\n');"
 
       - name: Commit and Push Changes
         shell: powershell
@@ -131,12 +107,421 @@ 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: ""
+        run: npm run tauri -- build --bundles nsis
       # ----------------------
       # 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: windows-x86_64
+        run: |
+          uv sync
+          uv run main.py
+
+  publish-arch:
+    name: Build and publish AUR packages
+    needs: publish-ubuntu
+    permissions:
+      contents: write
+    runs-on: archlinux
+    environment: production
+    env:
+      AUR_SSH_PRIVATE_KEY: ${{ secrets.AUR_SSH_PRIVATE_KEY }}
+      GITEA_API: https://git.cbsk-tech.de/api/v1
+      OWNER: Christoph
+      REPO: GitLite
+      GITEA_TOKEN: ${{ secrets.ACTIONS_TOKEN }}
+      GITEA_FALLBACK_TOKEN: ${{ github.token }}
+
+    defaults:
+      run:
+        working-directory: GitLite
+
+    steps:
+      - name: Prepare Arch job container
+        working-directory: /
+        run: |
+          set -euo pipefail
+
+          # The runner image may contain only a single geo mirror. Seed several
+          # currently active HTTPS mirrors and retain the image's list as a
+          # fallback so one slow CDN cannot fail the complete release.
+          ARCH_MIRROR_BACKUP="$(mktemp)"
+          cp /etc/pacman.d/mirrorlist "$ARCH_MIRROR_BACKUP"
+          printf '%s\n' \
+            'Server = https://frankfurt.mirror.pkgbuild.com/$repo/os/$arch' \
+            'Server = https://mirror.osbeck.com/archlinux/$repo/os/$arch' \
+            'Server = https://mirror.ubrco.de/archlinux/$repo/os/$arch' \
+            'Server = https://ftp.halifax.rwth-aachen.de/archlinux/$repo/os/$arch' \
+            'Server = https://geo.mirror.pkgbuild.com/$repo/os/$arch' \
+            > /etc/pacman.d/mirrorlist
+          sed -n '/^[[:space:]]*Server[[:space:]]*=/p' "$ARCH_MIRROR_BACKUP" \
+            >> /etc/pacman.d/mirrorlist
+
+          ARCH_PACKAGES=(
+            base-devel curl git git-lfs nodejs npm openssh rust
+            webkit2gtk-4.1 gtk3 hicolor-icon-theme
+            libappindicator-gtk3 librsvg xdotool
+          )
+
+          for ARCH_INSTALL_ATTEMPT in 1 2 3; do
+            echo "pacman attempt $ARCH_INSTALL_ATTEMPT of 3"
+            timeout --signal=TERM 30m \
+              pacman -Syu --needed --noconfirm --noprogressbar \
+              "${ARCH_PACKAGES[@]}" \
+              </dev/null &
+            ARCH_PACMAN_PID=$!
+            (
+              ARCH_WAIT_SECONDS=0
+              while true; do
+                sleep 30
+                ((ARCH_WAIT_SECONDS += 30))
+                echo "pacman is still running (${ARCH_WAIT_SECONDS}s elapsed)"
+              done
+            ) &
+            ARCH_HEARTBEAT_PID=$!
+
+            ARCH_PACMAN_STATUS=0
+            wait "$ARCH_PACMAN_PID" || ARCH_PACMAN_STATUS=$?
+            kill "$ARCH_HEARTBEAT_PID" 2>/dev/null || true
+            wait "$ARCH_HEARTBEAT_PID" 2>/dev/null || true
+
+            if [ "$ARCH_PACMAN_STATUS" -eq 0 ]; then
+              break
+            fi
+
+            if [ "$ARCH_PACMAN_STATUS" -eq 124 ]; then
+              echo "pacman attempt timed out after 30 minutes" >&2
+            fi
+
+            if [ "$ARCH_INSTALL_ATTEMPT" -eq 3 ]; then
+              echo "pacman failed after 3 attempts" >&2
+              exit 1
+            fi
+
+            sleep "$((ARCH_INSTALL_ATTEMPT * 5))"
+          done
+
+      - uses: actions/checkout@v5
+        with:
+          path: GitLite
+
+      - name: Set release version
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+        run: |
+          npm version "$RELEASE_VERSION" --no-git-tag-version --allow-same-version
+          PACKAGE_VERSION="$(node -p "require('./package.json').version")"
+          echo "PACKAGE_VERSION=$PACKAGE_VERSION" >> "$GITHUB_ENV"
+          echo "RELEASE_TAG=$RELEASE_VERSION" >> "$GITHUB_ENV"
+
+      - name: Generate and build AUR package
+        run: |
+          if ! id -u builder >/dev/null 2>&1; then
+            useradd --create-home builder
+          fi
+
+          AUR_SOURCE_DIR="$(mktemp -d)"
+          cp PKGBUILD "$AUR_SOURCE_DIR/PKGBUILD"
+          SOURCE_ARCHIVE="$AUR_SOURCE_DIR/gitty-desktop-$PACKAGE_VERSION.tar.gz"
+          curl --fail --location --silent --show-error \
+            --output "$SOURCE_ARCHIVE" \
+            "https://git.cbsk-tech.de/Christoph/GitLite/archive/$RELEASE_TAG.tar.gz"
+          CHECKSUM="$(sha256sum "$SOURCE_ARCHIVE" | cut -d ' ' -f 1)"
+
+          sed -i \
+            -e "s/^pkgver=.*/pkgver=$PACKAGE_VERSION/" \
+            -e "s/^pkgrel=.*/pkgrel=1/" \
+            -e "s/^_tag=.*/_tag=$RELEASE_TAG/" \
+            -e "s/^sha256sums=.*/sha256sums=('$CHECKSUM')/" \
+            "$AUR_SOURCE_DIR/PKGBUILD"
+
+          chown -R builder:builder "$AUR_SOURCE_DIR"
+          runuser -u builder -- \
+            bash -lc "cd '$AUR_SOURCE_DIR' && makepkg --cleanbuild --noconfirm && makepkg --printsrcinfo > .SRCINFO"
+
+          ARCH_PACKAGE_PATH="$(find "$AUR_SOURCE_DIR" -maxdepth 1 -type f -name 'gitty-desktop-*.pkg.tar.zst' -print -quit)"
+          if [ -z "$ARCH_PACKAGE_PATH" ]; then
+            echo "The native Arch package was not created" >&2
+            exit 1
+          fi
+
+          echo "AUR_SOURCE_DIR=$AUR_SOURCE_DIR" >> "$GITHUB_ENV"
+          echo "ARCH_PACKAGE_PATH=$ARCH_PACKAGE_PATH" >> "$GITHUB_ENV"
+
+      - name: Attach native Arch package to Gitea release
+        run: |
+          set -euo pipefail
+
+          TOKEN="${GITEA_TOKEN:-${GITEA_FALLBACK_TOKEN:-}}"
+          if [ -z "$TOKEN" ]; then
+            echo "A Gitea token is required to upload the native Arch package" >&2
+            exit 1
+          fi
+
+          RELEASE_JSON="$(curl --fail --location --silent --show-error \
+            --header "Authorization: token $TOKEN" \
+            "$GITEA_API/repos/$OWNER/$REPO/releases/tags/$RELEASE_TAG")"
+          export RELEASE_JSON
+          RELEASE_ID="$(node -e "const r=JSON.parse(process.env.RELEASE_JSON); if (!r.id) process.exit(1); process.stdout.write(String(r.id))")"
+          PACKAGE_NAME="${ARCH_PACKAGE_PATH##*/}"
+          export PACKAGE_NAME
+
+          if node -e "const r=JSON.parse(process.env.RELEASE_JSON); process.exit((r.assets || []).some(a => a.name === process.env.PACKAGE_NAME) ? 0 : 1)"; then
+            echo "Release asset $PACKAGE_NAME already exists; skipping upload."
+          else
+            curl --fail --location --silent --show-error \
+              --request POST \
+              --header "Authorization: token $TOKEN" \
+              --form "attachment=@$ARCH_PACKAGE_PATH;type=application/octet-stream" \
+              "$GITEA_API/repos/$OWNER/$REPO/releases/$RELEASE_ID/assets?name=$PACKAGE_NAME"
+            echo
+            echo "Attached $PACKAGE_NAME to Gitea release $RELEASE_TAG."
+          fi
+
+      - name: Generate and build binary AUR package
+        run: |
+          set -euo pipefail
+
+          TOKEN="${GITEA_TOKEN:-${GITEA_FALLBACK_TOKEN:-}}"
+          if [ -z "$TOKEN" ]; then
+            echo "A Gitea token is required to locate the native Arch package" >&2
+            exit 1
+          fi
+
+          RELEASE_JSON="$(curl --fail --location --silent --show-error \
+            --header "Authorization: token $TOKEN" \
+            "$GITEA_API/repos/$OWNER/$REPO/releases/tags/$RELEASE_TAG")"
+          export RELEASE_JSON
+          PACKAGE_NAME="${ARCH_PACKAGE_PATH##*/}"
+          export PACKAGE_NAME
+          PACKAGE_URL="$(node -e "const r=JSON.parse(process.env.RELEASE_JSON); const a=(r.assets || []).find(a => a.name === process.env.PACKAGE_NAME); if (!a?.browser_download_url) process.exit(1); process.stdout.write(a.browser_download_url)")"
+
+          AUR_BIN_DIR="$(mktemp -d)"
+          cp PKGBUILD-bin "$AUR_BIN_DIR/PKGBUILD"
+          PACKAGE_PATH="$AUR_BIN_DIR/$PACKAGE_NAME"
+          curl --fail --location --silent --show-error \
+            --header "Authorization: token $TOKEN" \
+            --output "$PACKAGE_PATH" "$PACKAGE_URL"
+          PACKAGE_CHECKSUM="$(sha256sum "$PACKAGE_PATH" | cut -d ' ' -f 1)"
+
+          sed -i \
+            -e "s/^pkgver=.*/pkgver=$PACKAGE_VERSION/" \
+            -e "s/^pkgrel=.*/pkgrel=1/" \
+            -e "s|^_package=.*|_package=\"$PACKAGE_NAME\"|" \
+            -e "s|^_artifact_url=.*|_artifact_url=\"$PACKAGE_URL\"|" \
+            -e "s/^sha256sums=.*/sha256sums=('$PACKAGE_CHECKSUM')/" \
+            "$AUR_BIN_DIR/PKGBUILD"
+
+          chown -R builder:builder "$AUR_BIN_DIR"
+          runuser -u builder -- \
+            bash -lc "cd '$AUR_BIN_DIR' && makepkg --cleanbuild --noconfirm && makepkg --printsrcinfo > .SRCINFO"
+
+          ARCH_BIN_PACKAGE_PATH="$(find "$AUR_BIN_DIR" -maxdepth 1 -type f -name 'gitty-desktop-bin-*.pkg.tar.zst' -print -quit)"
+          if [ -z "$ARCH_BIN_PACKAGE_PATH" ]; then
+            echo "The binary Arch package was not created" >&2
+            exit 1
+          fi
+
+          echo "AUR_BIN_DIR=$AUR_BIN_DIR" >> "$GITHUB_ENV"
+          echo "ARCH_BIN_PACKAGE_PATH=$ARCH_BIN_PACKAGE_PATH" >> "$GITHUB_ENV"
+
+      - name: Attach binary Arch package to Gitea release
+        run: |
+          set -euo pipefail
+
+          TOKEN="${GITEA_TOKEN:-${GITEA_FALLBACK_TOKEN:-}}"
+          if [ -z "$TOKEN" ]; then
+            echo "A Gitea token is required to upload the Arch package" >&2
+            exit 1
+          fi
+
+          RELEASE_JSON="$(curl --fail --location --silent --show-error \
+            --header "Authorization: token $TOKEN" \
+            "$GITEA_API/repos/$OWNER/$REPO/releases/tags/$RELEASE_TAG")"
+          export RELEASE_JSON
+          RELEASE_ID="$(node -e "const r=JSON.parse(process.env.RELEASE_JSON); if (!r.id) process.exit(1); process.stdout.write(String(r.id))")"
+          PACKAGE_NAME="${ARCH_BIN_PACKAGE_PATH##*/}"
+          export PACKAGE_NAME
+
+          if node -e "const r=JSON.parse(process.env.RELEASE_JSON); process.exit((r.assets || []).some(a => a.name === process.env.PACKAGE_NAME) ? 0 : 1)"; then
+            echo "Release asset $PACKAGE_NAME already exists; skipping upload."
+          else
+            curl --fail --location --silent --show-error \
+              --request POST \
+              --header "Authorization: token $TOKEN" \
+              --form "attachment=@$ARCH_BIN_PACKAGE_PATH;type=application/octet-stream" \
+              "$GITEA_API/repos/$OWNER/$REPO/releases/$RELEASE_ID/assets?name=$PACKAGE_NAME"
+            echo
+            echo "Attached $PACKAGE_NAME to Gitea release $RELEASE_TAG."
+          fi
+
+      - name: Publish PKGBUILD to AUR
+        env:
+          AUR_GIT_NAME: ${{ vars.USERNAME_GIT }}
+          AUR_GIT_EMAIL: ${{ vars.EMAIL_GIT }}
+        run: |
+          set -euo pipefail
+
+          if [ -z "$AUR_SSH_PRIVATE_KEY" ]; then
+            echo "AUR_SSH_PRIVATE_KEY is required" >&2
+            exit 1
+          fi
+
+          install -d -m 0700 "$HOME/.ssh"
+          printf '%s\n' "$AUR_SSH_PRIVATE_KEY" > "$HOME/.ssh/aur"
+          chmod 0600 "$HOME/.ssh/aur"
+
+          AUR_RETRY_DELAYS=(30 60 120 240)
+          AUR_KNOWN_HOSTS_TEMP="$(mktemp)"
+          AUR_HOST_KEY_READY=0
+          for AUR_ATTEMPT in 1 2 3 4 5; do
+            echo "AUR host-key attempt $AUR_ATTEMPT of 5"
+            if timeout 30s ssh-keyscan -T 15 -H aur.archlinux.org > "$AUR_KNOWN_HOSTS_TEMP" \
+              && [ -s "$AUR_KNOWN_HOSTS_TEMP" ]; then
+              AUR_HOST_KEY_READY=1
+              break
+            fi
+            if [ "$AUR_ATTEMPT" -lt 5 ]; then
+              sleep "${AUR_RETRY_DELAYS[$((AUR_ATTEMPT - 1))]}"
+            fi
+          done
+          if [ "$AUR_HOST_KEY_READY" -ne 1 ]; then
+            echo "Could not retrieve the AUR SSH host key after 5 attempts" >&2
+            exit 1
+          fi
+          install -m 0600 "$AUR_KNOWN_HOSTS_TEMP" "$HOME/.ssh/known_hosts"
+          export GIT_SSH_COMMAND="ssh -i $HOME/.ssh/aur -o IdentitiesOnly=yes -o BatchMode=yes -o ConnectTimeout=30 -o ServerAliveInterval=15 -o ServerAliveCountMax=2"
+
+          publish_aur_package() {
+            local package_name="$1"
+            local package_source_dir="$2"
+            local checkout_root checkout clone_candidate pushed
+
+            checkout_root="$(mktemp -d)"
+            checkout=""
+            for AUR_ATTEMPT in 1 2 3 4 5; do
+              clone_candidate="$checkout_root/attempt-$AUR_ATTEMPT"
+              echo "$package_name clone attempt $AUR_ATTEMPT of 5"
+              if timeout 3m git -c init.defaultBranch=master clone \
+                "ssh://aur@aur.archlinux.org/$package_name.git" "$clone_candidate"; then
+                checkout="$clone_candidate"
+                break
+              fi
+              if [ "$AUR_ATTEMPT" -lt 5 ]; then
+                echo "AUR is unavailable; retrying after backoff"
+                sleep "${AUR_RETRY_DELAYS[$((AUR_ATTEMPT - 1))]}"
+              fi
+            done
+            if [ -z "$checkout" ]; then
+              echo "Could not clone $package_name after 5 attempts" >&2
+              return 1
+            fi
+
+            cp "$package_source_dir/PKGBUILD" "$package_source_dir/.SRCINFO" "$checkout/"
+            git -C "$checkout" config user.name "${AUR_GIT_NAME:-Gitty Release Bot}"
+            git -C "$checkout" config user.email "${AUR_GIT_EMAIL:-aur@localhost}"
+            git -C "$checkout" add PKGBUILD .SRCINFO
+
+            if git -C "$checkout" diff --cached --quiet; then
+              echo "$package_name already matches release $PACKAGE_VERSION"
+              return 0
+            fi
+
+            git -C "$checkout" commit -m "Update to $PACKAGE_VERSION"
+            pushed=0
+            for AUR_ATTEMPT in 1 2 3 4 5; do
+              echo "$package_name push attempt $AUR_ATTEMPT of 5"
+              if timeout 3m git -C "$checkout" push origin HEAD:master; then
+                pushed=1
+                break
+              fi
+              if [ "$AUR_ATTEMPT" -lt 5 ]; then
+                echo "AUR push failed; retrying after backoff"
+                sleep "${AUR_RETRY_DELAYS[$((AUR_ATTEMPT - 1))]}"
+              fi
+            done
+            if [ "$pushed" -ne 1 ]; then
+              echo "Could not publish $package_name after 5 attempts" >&2
+              return 1
+            fi
+          }
+
+          publish_aur_package gitty-desktop "$AUR_SOURCE_DIR"
+          publish_aur_package gitty-desktop-bin "$AUR_BIN_DIR"
+
+  publish-ubuntu:
+    name: Build and publish Ubuntu AppImage
+    permissions:
+      contents: write
+    environment: production
+    env:
+      GITEA_API: https://git.cbsk-tech.de/api/v1
+      OWNER: Christoph
+      REPO: GitLite
+      GITEA_TOKEN: ${{ secrets.ACTIONS_TOKEN }}
+      GITEA_FALLBACK_TOKEN: ${{ github.token }}
+
+      MINIO_ENDPOINT: ${{ vars.MINIO_ENDPOINT }}
+      S3_BUCKET: ${{ vars.S3_BUCKET }}
+      AWS_ACCESS_KEY_ID: ${{ secrets.S3_ACCESS_KEY }}
+      AWS_SECRET_ACCESS_KEY: ${{ secrets.S3_SECRET_KEY }}
+      ARTIFACT_BASE_URL: ${{ vars.ARTIFACT_BASE_URL }}
+      S3_ACCESS_KEY: ${{ secrets.S3_ACCESS_KEY }}
+      S3_SECRET_KEY: ${{ secrets.S3_SECRET_KEY }}
+
+    defaults:
+      run:
+        working-directory: GitLite
+
+    runs-on: ubuntu-22.04
+
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          path: GitLite
+
+      - name: Install Ubuntu dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential curl wget file git-lfs 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
+        uses: astral-sh/setup-uv@08807647e7069bb48b6ef5acd8ec9567f424441b
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Update package.json version
+        run: npm version ${{ github.ref_name }} --no-git-tag-version --allow-same-version
+
+      - name: Update tauri.conf.json version
+        env:
+          RELEASE_VERSION: ${{ github.ref_name }}
+        run: |
+          node -e "const fs=require('fs'); const path='src-tauri/tauri.conf.json'; const config=JSON.parse(fs.readFileSync(path,'utf8')); config.version=process.env.RELEASE_VERSION; fs.writeFileSync(path, JSON.stringify(config,null,2)+'\n');"
+
+      - name: Build Tauri App
+        env:
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD}}
+          NO_STRIP: "1"
+        run: npm run tauri -- build --bundles appimage
+
+      - name: Upload artifacts to MinIO with cicd_tool
+        working-directory: GitLite/cicd_tool
+        env:
+          PUBLISH_PLATFORM: linux-x86_64
         run: |
           uv sync
           uv run main.py

.gitignore

@@ -1,9 +1,15 @@
 /node_modules
 /dist
 /src-tauri/target
+/src-tauri/binaries/git-lfs
+/src-tauri/binaries/git-lfs.exe
+/src-tauri/binaries/git-lfs-*-*-*
 *.log
 .idea
 .DS_Store
 ~
 .codex*
 target
+
+*.pkg.tar.zst
+pkg

CHANGELOG.md

@@ -0,0 +1,300 @@
+# Changelog
+
+All notable user-facing changes to Gitty are documented in this file.
+
+The project uses calendar-style versions in the form `YYYY.M.PATCH`.
+
+## [2026.8.8] - 2026-08-29
+
+### Added
+
+- Git hosting integrations for GitHub, GitLab.com, GitLab Self-Managed,
+  Azure DevOps, and Gitea. Personal access tokens are stored separately in
+  the operating system keychain.
+- Azure DevOps supports multiple independently configurable organizations,
+  each with its own display name, organization URL, username, and token.
+- The Clone dialog has an Integrations tab that loads all repositories
+  available to the selected account, supports filtering and refresh, sorts
+  repositories alphabetically, and clones the selected repository directly
+  with its stored credentials.
+
+### Changed
+
+- Repository tabs use a more compact Git-client-style bar. Close buttons
+  remain visible and turn red only while hovered.
+- The integration repository list uses a narrow custom scrollbar that grows
+  only slightly on hover and no longer covers repository names or metadata.
+- Repository loading and status overlays use theme-aware design tokens with
+  improved contrast and a more compact presentation.
+
+### Fixed
+
+- Clearing sync settings on a branch that never had an upstream is now a safe
+  no-op instead of failing with a fatal Git error.
+
+## [2026.8.7] - 2026-08-23
+
+### Added
+
+- Appearance settings now offer Modern, Classic, and Custom styles. Custom
+  themes can define their own persisted color palette, while a complete light
+  theme is available alongside the refreshed dark appearance.
+- The branch visibility dialog groups local and remote branches into
+  collapsible sections with selected-branch counts. Local branches open by
+  default, while the remote group starts collapsed for quicker navigation.
+
+### Changed
+
+- Dark-theme colors, surfaces, controls, and focus outlines have been refined
+  for clearer interactive boundaries and more consistent contrast throughout
+  the application.
+- The branch visibility dialog follows the responsive layout and visual
+  language of the rest of Gitty more closely.
+
+## [2026.8.6] - 2026-08-18
+
+### Changed
+
+- Activating LFS or adding a tracking pattern now ensures that a root
+  `.gitattributes` file is not hidden by Git ignore rules. When necessary,
+  Gitty adds the scoped `!/.gitattributes` exception to `.gitignore`.
+- The standard Tauri development launcher now removes an injected non-routing
+  `127.0.0.1:9` proxy and blocking SSH placeholder from the debug child
+  process, while preserving real user and company proxy settings.
+
+### Fixed
+
+- Root `.gitattributes` LFS patterns remain visible while the file is
+  untracked or ignored, instead of disappearing from the LFS dialog.
+- Git LFS pushes rejected with HTTP 413 are retried once with a command-scoped
+  HTTP/1.1 override, which works around Azure DevOps' large HTTP/2 upload
+  behavior without changing repository or global Git settings.
+- LFS and other generic push failures no longer trigger the unrelated
+  Pull/Push retry flow intended only for non-fast-forward rejections.
+
+## [2026.8.5] - 2026-08-17
+
+### Added
+
+- Integrated Git LFS management now detects the available extension and the
+  repository setup, shows tracked patterns and checkout objects, and provides
+  actions for local activation, tracking and untracking patterns, downloading
+  objects, and pruning the local cache. Desktop installers bundle Git LFS,
+  while Arch packages declare it as a dependency.
+- The Changes panel now offers a List/Tree switch. Tree view groups staged and
+  unstaged files into independently collapsible folders while retaining all
+  existing file actions.
+- Files and folders in the Changes panel now have context-menu actions for
+  staging or unstaging their scope and for creating a stash containing only
+  the selected file or folder. New and untracked items can also be added to
+  the repository `.gitignore` from Changes or the File Explorer as an exact
+  file, a complete folder, or an extension-wide pattern. Folder rules are only
+  offered for folder selections. Tracked files and folders can be removed from
+  the Git index without deleting their working-tree contents.
+- Gitty can open a repository directly at startup through the `--repo PATH` or
+  `--repo=PATH` command-line argument.
+- The executable can clone and immediately open a repository with
+  `clone REMOTE TARGET`, `--clone REMOTE TARGET`, or `--clone=REMOTE TARGET`.
+  Relative targets use the caller's working directory, and requests are also
+  forwarded to an already-running Gitty instance.
+
+### Changed
+
+- Successful clones and pulls now detect repositories that use LFS and
+  download the required LFS objects automatically with the same remote and
+  credentials. Fresh clones also activate LFS locally before they are opened.
+- Unstaged and staged changes use an equal-width side-by-side layout with
+  independent scrolling, directional stage/unstage actions, and a responsive
+  vertical fallback. The List/Tree switch is centered above both areas.
+- File and folder context menus now separate the selected name from its parent
+  path, show the affected file count, and present stage, unstage, and stash
+  actions with clearer icons and descriptions.
+- Controls and surfaces use a more consistent square visual language while
+  circular status markers, avatars, and branch shapes remain recognizable.
+- The built-in German and English help now includes Git LFS setup, tracking,
+  troubleshooting, and everyday workflow guidance.
+
+## [2026.8.4] - 2026-08-15
+
+### Added
+
+- Branch folders now have a context-menu action for deleting all contained
+  local or remote branches at once. The top-level remote folder such as
+  `origin` is protected, while its nested folders remain manageable. The
+  currently checked-out branch is kept,
+  and individual failures are reported after the remaining branches have been
+  processed.
+
+### Changed
+
+- The Compare selector is fully localized in German and uses the same visual
+  language as the external-tool selectors for its fields, groups, typography,
+  and dialog surfaces.
+- Repository-tab close buttons are square and have clearer spacing, hover
+  behavior, and keyboard-focus feedback.
+
+## [2026.8.3] - 2026-08-13
+
+### Added
+
+- Configurable external tools for editors, diff viewers, merge tools,
+  terminals, and file managers, including automatic cross-platform discovery
+  and presets for VS Code, JetBrains IDEs, Beyond Compare, and other common
+  applications.
+- Repository and file actions for opening content in the configured external
+  application. Supported tools open in a separate window.
+- A choice between Gitty's internal diff/merge views and the configured
+  external applications.
+- Git Notes support for attaching editable notes to commits without rewriting
+  commit history, including fetch and push synchronization.
+- A command palette for quickly opening repository actions, files, and commits.
+- Complete branch-to-branch comparisons for local and remote branches. The
+  comparison dialog shows every changed file and its side-by-side diff.
+- Safe remote branch renaming from the branch context menu.
+
+### Changed
+
+- Redesigned the settings window with tool categories, detected applications,
+  preset dropdowns, and clearer explanations of where each tool is used.
+- Redesigned the history graph's branch presentation with compact labels,
+  hover details, cleaner flag connectors, and branch visibility controls.
+- Reduced the minimum width of the commit history panel so the workspace can
+  be resized more freely.
+- Local-only branches are now identified consistently in the toolbar,
+  repository summary, status bar, and commit graph. Their first push is labeled
+  Publish and configures the remote tracking branch automatically.
+- Git operations now run asynchronously to keep the application responsive
+  during slower repository commands.
+
+### Fixed
+
+- Closing supported external tools no longer reports their documented
+  comparison result codes as application errors.
+- External tools that otherwise reuse an existing process are explicitly
+  opened in a new window where supported.
+- Remote branch renaming uses an atomic push with lease checks, preventing an
+  existing destination branch or a newly changed remote branch from being
+  overwritten.
+
+## [2026.8.2] - 2026-08-10
+
+### Changed
+
+- History graph colors remain stable across parent lanes, making longer and
+  branching histories easier to follow.
+- Release artifacts are published to the matching Gitea release automatically
+  without creating duplicate assets.
+- Application shutdown now completes telemetry cleanup more reliably.
+
+## [2026.8.1] - 2026-08-04
+
+### Added
+
+- Paginated commit history that loads older commits on demand instead of
+  limiting the visible repository history to the initial page.
+- A dedicated file-history dialog opened from the explorer context menu.
+- Windows and Ubuntu release publishing plus improved AUR packaging workflows.
+
+### Changed
+
+- File history moved out of the permanent workspace panel into a focused,
+  larger dialog.
+- Dialogs close more consistently with the Escape key.
+- Arch Linux installation documentation now uses the `gitty-desktop` AUR
+  package.
+
+### Fixed
+
+- AUR SSH setup, package installation timeouts, and clone/push retries are more
+  robust in the release workflow.
+
+## [2026.07.22] - 2026-07-22
+
+### Added
+
+- AI-assisted commit splitting for staged changes:
+  - analyze the staged diff and propose an ordered set of logical commits;
+  - generate an editable Conventional Commit message for every group;
+  - move files between proposed commits before applying the plan;
+  - create all accepted commits sequentially with **Commit all**.
+- Support for commit-splitting suggestions through OpenAI, Anthropic, and
+  custom OpenAI-compatible endpoints.
+
+### Changed
+
+- The commit-splitting dialog now explains why a plan cannot be applied and
+  clearly marks AI-generated commit messages as editable.
+- Safety checks prevent applying a stale plan after the staged files change
+  and reject files that contain both staged and unstaged changes.
+
+### Fixed
+
+- **Commit all** now passes a plain state snapshot to the commit workflow
+  instead of failing silently when cloning a reactive UI proxy.
+- Closing the active repository tab no longer allows an in-flight status or
+  fetch response to reopen and reactivate the closed repository.
+
+## [2026.07.21] - 2026-07-21
+
+### Added
+
+- Full Git worktree management:
+  - create a worktree from an existing branch;
+  - create a new branch and worktree together;
+  - create a detached worktree at a commit;
+  - open a worktree as a repository tab;
+  - move, lock, unlock, repair, remove, and prune worktrees.
+- A dedicated **Worktrees** entry below **Tags** in the branch panel.
+- An **Open in new worktree** action in the local branch context menu.
+- Line-level patch selection with Shift-click range selection.
+- Stage, unstage, and discard actions for selected lines while retaining the
+  existing whole-file and whole-hunk workflows.
+- Arch Linux package automation that builds from `PKGBUILD`, publishes the
+  `.pkg.tar.zst` artifact, and updates the Pacman repository database on the
+  CDN.
+- Detailed German and English help for worktrees, line-level staging, Pacman
+  installation, and release changes.
+
+### Changed
+
+- Branch deletion now uses a clearer confirmation dialog with more explicit
+  branch and upstream information.
+- Dialog backdrops blur the application instead of covering it with a nearly
+  black background.
+- Remote operations and authentication errors provide more actionable
+  feedback.
+- Build diagnostics and resource handling for the Arch package pipeline are
+  more robust.
+
+### Infrastructure
+
+- Added centralized error notifications.
+- Added structured, privacy-conscious telemetry.
+- Stabilized the Arch Linux container build and `makepkg` workflow.
+
+## [2026.7.20] - 2026-07-13
+
+### Added
+
+- AI-assisted review of staged changes before committing.
+- Optional automatic repository refresh.
+- Comprehensive German Git documentation in the built-in help.
+- Initial `PKGBUILD` and automated package version synchronization.
+
+### Changed
+
+- Redesigned the repository action toolbar and workspace status presentation.
+- Improved repository tabs, diff styling, spacing, and panel structure.
+- Improved file-history state handling.
+
+[2026.07.22]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.22
+[2026.07.21]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.21
+[2026.7.20]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.7.20
+[2026.8.8]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.8
+[2026.8.7]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.7
+[2026.8.6]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.6
+[2026.8.5]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.5
+[2026.8.4]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.4
+[2026.8.3]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.3
+[2026.8.2]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.2
+[2026.8.1]: https://git.cbsk-tech.de/Christoph/GitLite/releases/tag/2026.8.1

PKGBUILD

@@ -0,0 +1,69 @@
+# Maintainer: Christoph Brandau <c.brandau91@googlemail.com>
+
+pkgname=gitty-desktop
+pkgver=2026.7.22
+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' 'git-lfs' 'hicolor-icon-theme' 'libappindicator-gtk3' 'librsvg' 'xdotool')
+makedepends=('rust' 'nodejs' 'npm')
+options=('!lto' '!debug')
+
+_tag=2026.7.22
+source=("gitty-desktop-${pkgver}.tar.gz::${url}/archive/${_tag}.tar.gz")
+sha256sums=('bd6c7d9da54917cbea98ce31172934b4657cc2fe2020f49d27ea2acb51348e9c')
+
+prepare() {
+  cd "$srcdir/gitlite"
+
+  # Keep application metadata aligned even when a release tag contains
+  # leading zeroes that npm normalizes (for example 2026.7.01 -> 2026.7.1).
+  npm version "$pkgver" --no-git-tag-version --allow-same-version
+  RELEASE_VERSION="$pkgver" 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');"
+}
+
+build() {
+  cd "$srcdir/gitlite"
+
+  # Keep the large Rust release build within the Arch runner's memory limit.
+  export CARGO_BUILD_JOBS=1
+  export CARGO_PROFILE_RELEASE_OPT_LEVEL=2
+  export CARGO_PROFILE_RELEASE_LTO=false
+  export CARGO_PROFILE_RELEASE_CODEGEN_UNITS=8
+  export CARGO_PROFILE_RELEASE_DEBUG=0
+
+  npm ci
+  npm run tauri -- build --no-bundle
+}
+
+package() {
+  cd "$srcdir/gitlite"
+
+  install -Dm755 "src-tauri/target/release/gitty" "$pkgdir/usr/bin/gitty-desktop"
+
+  install -Dm644 "src-tauri/icons/32x32.png" \
+    "$pkgdir/usr/share/icons/hicolor/32x32/apps/gitty-desktop.png"
+  install -Dm644 "src-tauri/icons/128x128.png" \
+    "$pkgdir/usr/share/icons/hicolor/128x128/apps/gitty-desktop.png"
+  install -Dm644 "src-tauri/icons/128x128@2x.png" \
+    "$pkgdir/usr/share/icons/hicolor/256x256@2/apps/gitty-desktop.png"
+  install -Dm644 "src-tauri/icons/icon.png" \
+    "$pkgdir/usr/share/icons/hicolor/512x512/apps/gitty-desktop.png"
+
+  install -d "$pkgdir/usr/share/applications"
+  cat > "$pkgdir/usr/share/applications/gitty-desktop.desktop" <<-EOF
+	[Desktop Entry]
+	Type=Application
+	Name=Gitty
+	Comment=$pkgdesc
+	Exec=gitty-desktop
+	Icon=gitty-desktop
+	Terminal=false
+	Categories=Development;RevisionControl;
+	StartupWMClass=gitty
+	EOF
+
+  install -Dm644 README.md "$pkgdir/usr/share/doc/$pkgname/README.md"
+}

PKGBUILD-bin

@@ -0,0 +1,25 @@
+# Maintainer: Christoph Brandau <c.brandau91@googlemail.com>
+
+pkgname=gitty-desktop-bin
+pkgver=2026.8.6
+pkgrel=1
+pkgdesc="A lightweight, modern Git client built with Tauri (prebuilt Arch package)"
+arch=('x86_64')
+url="https://git.cbsk-tech.de/Christoph/GitLite"
+license=('MIT')
+depends=('git' 'git-lfs' 'webkit2gtk-4.1' 'gtk3' 'hicolor-icon-theme' 'libappindicator-gtk3' 'librsvg' 'xdotool')
+provides=('gitty-desktop')
+conflicts=('gitty-desktop')
+options=('!strip')
+
+_package="gitty-desktop-${pkgver}-1-x86_64.pkg.tar.zst"
+_artifact_url="https://git.cbsk-tech.de/Christoph/GitLite/releases/download/${pkgver}/${_package}"
+source=("${_package}::${_artifact_url}")
+noextract=("${_package}")
+sha256sums=('SKIP')
+
+package() {
+  # Extract only the native package payload, without carrying its package
+  # metadata (.PKGINFO, .BUILDINFO and .MTREE) across.
+  bsdtar -xf "$srcdir/$_package" -C "$pkgdir" usr
+}

README.md

@@ -1,45 +1,133 @@
-# Tauri Git Lite
+<div align="center">
 
-Eine kleine Git-Desktop-App mit Tauri, Rust und Svelte.
+<img src="public/splash-icon.png" alt="Gitty Logo" width="360">
 
-## Funktionen
+# Gitty
 
-- Repository per lokalem Pfad öffnen
-- aktuellen Branch, Upstream, Ahead/Behind und Arbeitsbaumstatus anzeigen
-- Branches auflisten und auschecken
-- Branches in den aktuellen Branch mergen
-- Commit-History mit geänderten Dateien anzeigen
-- Explorer-Ansicht mit Ordnerbaum sowie getrackten und ungetrackten Dateien
-- Datei- und Ordner-History direkt aus dem Explorer anzeigen
-- einzelne Dateien stagen, unstagen und wiederherstellen
-- einzelne Dateien oder ganze Ordner aus einem History-Commit wiederherstellen
-- aktuellen Branch auf einen ausgewählten Commit zurücksetzen
-- Commit mit Message erstellen
-- Pull mit Fast-Forward-Strategie
-- Push auf den konfigurierten Upstream
+**A lightweight, modern Git client built with Tauri.**
 
-## Entwicklung
+Fast, simple, and designed for developers who want a clean Git experience without unnecessary complexity.
 
-```powershell
-npm install
-npm run tauri:dev
+</div>
+
+---
+
+## ✨ Features
+
+- 🚀 Fast native performance
+- 🌿 Branch management
+- 📝 Commit history
+- 🔄 Pull, Push & Fetch
+- 🔀 Merge & Rebase
+- 📦 Repository management
+- ☁️ GitHub, GitLab, Azure DevOps, and Gitea integrations
+- 🗄️ Git LFS detection, tracking and object management
+- 🎨 Modern and intuitive UI
+
+---
+
+## 📸 Preview
+
+> Screenshots comes later.
+
+---
+
+## 🛠️ Built With
+
+- **Tauri**
+- **Rust**
+- **Svelte**
+
+---
+
+## 🚧 Status
+
+Gitty is currently under active development.
+
+Contributions, feedback and feature requests are always welcome!
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+## Arch Linux
+
+Install Gitty from the AUR with an AUR helper:
+
+```bash
+yay -S gitty-desktop
 ```
 
-Frontend allein:
+To install the prebuilt native Arch package instead of compiling from source:
 
-```powershell
-npm run dev
+```bash
+yay -S gitty-desktop-bin
 ```
 
-Checks:
+Or build the AUR package manually:
 
-```powershell
-npm run check
-npm run build
-cd src-tauri
-cargo check
+```bash
+git clone https://aur.archlinux.org/gitty-desktop.git
+cd gitty-desktop
+makepkg -si
 ```
 
-## Hinweis
+The source recipe downloads the public Gitea release archive and builds Gitty.
+The `-bin` recipe repackages the native `.pkg.tar.zst` release artifact. The
+release pipeline updates both packages' versions, checksums, and `.SRCINFO`
+files.
+
+---
+
+## Command line
+
+Open an existing repository when Gitty starts:
+
+```text
+gitty.exe --repo "D:\Projects\ExistingRepo"
+```
+
+Clone a remote into an exact local target folder and open it immediately:
+
+```text
+gitty.exe --clone "https://example.com/team/project.git" "D:\Projects\Project"
+gitty clone "git@example.com:team/project.git" "D:\Projects\Project"
+```
+
+`--clone=<REMOTE>` is also accepted. Relative target paths are resolved from
+the current working directory. Clone and repository requests are forwarded to
+the running window when Gitty is already open.
+
+---
+
+## Git hosting integrations
+
+Gitty connects to GitHub, GitLab.com, GitLab Self-Managed, Azure DevOps, and
+Gitea from **Settings → Integrations**. Each connection uses a personal access
+token that is stored in the operating system keychain instead of application
+settings. Azure DevOps can manage multiple organizations with separate URLs,
+usernames, and tokens.
+
+After enabling a connection, open **Clone → Integrations** to load the
+repositories available to that account. Repositories are sorted
+alphabetically and can be filtered, refreshed, selected, and cloned directly
+with the stored credentials.
+
+---
+
+
+## Git LFS
+
+Gitty bundles the `git-lfs` executable in its desktop installers and checks it
+at runtime before offering LFS actions. Arch packages also declare `git-lfs` as
+a dependency so Git hooks and command-line workflows outside Gitty use the same
+extension. The repository toolbar exposes LFS setup, tracked patterns, object
+downloads, and safe cache pruning. After every successful clone or pull, Gitty
+detects LFS usage and automatically downloads the required LFS objects with the
+same remote and credentials, so no second pull is needed. Fresh clones also get
+repository-local LFS filters and the pre-push hook before they are opened.
 
-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.

cicd_tool/main.py

@@ -1,17 +1,21 @@
 import argparse
 import io
 import json
+import mimetypes
 import os
+import uuid
 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 urllib.parse import quote, urlencode
+from urllib.request import Request, urlopen
 
 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 +24,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 +124,57 @@ def _ensure_bucket(client: Minio, bucket_name: str) -> None:
 
 def _collect_artifacts() -> List[Path]:
     artifacts: List[Path] = []
-    for directory in (
-        ARTIFACT_ROOT / "msi",
-        ARTIFACT_ROOT / "nsis",
-        ARTIFACT_ROOT / "app",
-    ):
+    bundle_dirs = {
+        ARTIFACT_ROOT / "msi": (".msi", ".sig"),
+        ARTIFACT_ROOT / "nsis": (".exe", ".sig"),
+        ARTIFACT_ROOT / "appimage": (".appimage", ".sig"),
+        ARTIFACT_ROOT / "deb": (".deb", ".sig"),
+        ARTIFACT_ROOT / "rpm": (".rpm", ".sig"),
+        ARTIFACT_ROOT / "app": (".dmg", ".zip", ".sig"),
+    }
+    for directory, suffixes in bundle_dirs.items():
         if directory.exists():
-            artifacts.extend(p for p in directory.rglob("*") if p.is_file())
+            artifacts.extend(
+                p
+                for p in directory.iterdir()
+                if p.is_file() and p.suffix.lower() in suffixes
+            )
     return artifacts
 
 
-def _select_primary_artifact(artifacts: Iterable[Path]) -> Optional[Path]:
-    priority = (".exe", ".msi", ".zip", ".dmg")
+def _select_primary_artifact(
+    artifacts: Iterable[Path], platform: Optional[str] = None
+) -> Optional[Path]:
+    artifact_list = list(artifacts)
+    priorities = {
+        "windows-x86_64": (".exe", ".msi"),
+        "linux-x86_64": (".appimage", ".deb", ".rpm"),
+        "darwin-x86_64": (".dmg", ".zip"),
+        "darwin-aarch64": (".dmg", ".zip"),
+    }
+    priority = priorities.get(platform or "", ())
+    priority += (".exe", ".msi", ".appimage", ".deb", ".rpm", ".zip", ".dmg")
     for ext in priority:
-        for artifact in artifacts:
+        for artifact in artifact_list:
             if artifact.suffix.lower() == ext:
                 return artifact
-    return next(iter(artifacts), None)
+    return next(
+        (artifact for artifact in artifact_list if artifact.suffix != ".sig"), None
+    )
+
+
+def _infer_platform(artifact: Path) -> str:
+    suffix = artifact.suffix.lower()
+    if suffix in {".exe", ".msi"}:
+        return "windows-x86_64"
+    if suffix in {".appimage", ".deb", ".rpm"}:
+        return "linux-x86_64"
+    if suffix in {".dmg", ".zip"}:
+        return "darwin-x86_64"
+    raise ConfigurationError(
+        f"Cannot infer updater platform from artifact: {artifact.name}. "
+        "Set PUBLISH_PLATFORM explicitly."
+    )
 
 
 def _read_signature(artifact: Path) -> str:
@@ -145,16 +188,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 +245,151 @@ def _build_latest_json(
         .replace("+00:00", "Z")
     )
 
-    latest_payload = {
+    platforms: dict[str, Any] = {}
+    existing_notes = None
+    if existing_payload and existing_payload.get("version") == version:
+        existing_platforms = existing_payload.get("platforms")
+        if isinstance(existing_platforms, dict):
+            platforms.update(existing_platforms)
+        existing_notes = existing_payload.get("notes")
+
+    platforms[platform] = {
+        "signature": signature,
+        "url": artifact_url,
+    }
+
+    return {
         "version": version,
         "pub_date": pub_date,
-        "notes": os.environ.get("RELEASE_NOTES", "Automated release"),
-        "platforms": {
-            "windows-x86_64": {
-                "signature": signature,
-                "url": artifact_url,
-            }
-        },
+        "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 _gitea_request(url: str, token: str, data: Optional[bytes] = None, **headers: str):
+    request = Request(url, data=data, headers={"Authorization": f"token {token}", **headers})
+    return urlopen(request, timeout=120)
+
+
+def _upload_gitea_release_asset(version: str, artifact: Path) -> None:
+    """Attach the installer to the Gitea release that triggered this build."""
+    api_url = os.environ.get("GITEA_API", "").rstrip("/")
+    owner = os.environ.get("OWNER", "")
+    repo = os.environ.get("REPO", "")
+    token = os.environ.get("GITEA_TOKEN") or os.environ.get("GITEA_FALLBACK_TOKEN")
+    if not all((api_url, owner, repo, token)):
+        raise ConfigurationError(
+            "GITEA_API, OWNER, REPO and GITEA_TOKEN are required to publish "
+            "the release asset."
+        )
+
+    release_url = (
+        f"{api_url}/repos/{quote(owner, safe='')}/{quote(repo, safe='')}"
+        f"/releases/tags/{quote(version, safe='')}"
+    )
+    with _gitea_request(release_url, token) as response:
+        release = json.load(response)
+
+    existing_names = {
+        asset.get("name") for asset in release.get("assets", []) if isinstance(asset, dict)
+    }
+    if artifact.name in existing_names:
+        print(f"Release asset {artifact.name} already exists; skipping upload.")
+        return
+
+    boundary = f"----gitty-{uuid.uuid4().hex}"
+    content_type = mimetypes.guess_type(artifact.name)[0] or "application/octet-stream"
+    body = b"".join(
+        (
+            f"--{boundary}\r\n".encode(),
+            (
+                f'Content-Disposition: form-data; name="attachment"; '
+                f'filename="{artifact.name}"\r\n'
+            ).encode(),
+            f"Content-Type: {content_type}\r\n\r\n".encode(),
+            artifact.read_bytes(),
+            f"\r\n--{boundary}--\r\n".encode(),
+        )
+    )
+    upload_url = (
+        f"{api_url}/repos/{quote(owner, safe='')}/{quote(repo, safe='')}"
+        f"/releases/{release['id']}/assets?{urlencode({'name': artifact.name})}"
+    )
+    with _gitea_request(
+        upload_url,
+        token,
+        data=body,
+        **{"Content-Type": f"multipart/form-data; boundary={boundary}"},
+    ):
+        pass
+    print(f"Attached {artifact.name} to Gitea release {version}.")
 
 
 def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
@@ -184,9 +399,10 @@ def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
         raise ConfigurationError("ARTIFACT_BASE_URL is required")
 
     # S3/MinIO bucket names must be lowercase, so normalise regardless of how the
-    # S3_BUCKET variable is cased (e.g. "GitLite" -> "gitlite").
-    bucket_name = (os.environ.get("S3_BUCKET") or "gitlite").lower()
-    bucket_prefix = (app_dir or os.environ.get("APP_DIR") or "gitlite").strip("/")
+    # S3_BUCKET variable is cased (e.g. "Gitty" -> "gitty").
+    bucket_name = (os.environ.get("S3_BUCKET") or "gitty").lower()
+    bucket_prefix = (app_dir or os.environ.get("APP_DIR") or "gitty").strip("/")
+    publish_targets = _parse_publish_targets(bucket_name, bucket_prefix)
 
     artifacts = _collect_artifacts()
     if not artifacts:
@@ -194,49 +410,50 @@ def main(version: Optional[str] = None, app_dir: Optional[str] = None) -> None:
             "No release artifacts found in src-tauri/target/release/bundle."
         )
 
-    primary = _select_primary_artifact(artifacts)
+    publish_platform = os.environ.get("PUBLISH_PLATFORM") or os.environ.get(
+        "UPDATER_PLATFORM"
+    )
+    primary = _select_primary_artifact(artifacts, publish_platform)
     if not primary:
         raise FileNotFoundError("Unable to determine primary artifact to publish.")
 
+    platform = publish_platform or _infer_platform(primary)
     signature = _read_signature(primary)
 
-    latest_json = _build_latest_json(
+    client = _create_minio_client()
+
+    local_dist_dir = PROJECT_DIR / "dist"
+    local_dist_dir.mkdir(parents=True, exist_ok=True)
+    latest_json_path = local_dist_dir / "latest.json"
+    latest_payload = _build_latest_payload(
         version=resolved_version,
+        platform=platform,
         primary_artifact=primary,
         signature=signature,
         artifact_base_url=artifact_base_url,
         app_dir=bucket_prefix,
     )
-
-    local_dist_dir = PROJECT_DIR / "dist"
-    local_dist_dir.mkdir(parents=True, exist_ok=True)
-    latest_json_path = local_dist_dir / "latest.json"
+    latest_json = json.dumps(latest_payload, separators=(",", ":"))
     latest_json_path.write_text(latest_json + "\n", encoding="utf-8")
 
-    client = _create_minio_client()
-    _ensure_bucket(client, bucket_name)
+    for target in publish_targets:
+        _publish_target(
+            client=client,
+            target=target,
+            version=resolved_version,
+            platform=platform,
+            artifacts=artifacts,
+            primary_artifact=primary,
+            signature=signature,
+            artifact_base_url=artifact_base_url,
+        )
 
-    for artifact in artifacts:
-        object_segments = [part for part in (resolved_version, artifact.name) if part]
-        object_name = "/".join(object_segments)
-        client.fput_object(bucket_name, object_name, str(artifact))
-        print(f"Uploaded {artifact.name} -> s3://{bucket_name}/{object_name}")
-
-    latest_object_name = "latest.json"
-    latest_bytes = latest_json.encode("utf-8")
-    client.put_object(
-        bucket_name=bucket_name,
-        object_name=latest_object_name,
-        data=io.BytesIO(latest_bytes),
-        length=len(latest_bytes),
-        content_type="application/json",
-    )
-    print(f"Uploaded latest.json -> s3://{bucket_name}/{latest_object_name}")
+    _upload_gitea_release_asset(resolved_version, primary)
 
 
 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 +464,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()
 

docs/api-contract.md

@@ -15,6 +15,9 @@ interface GitStatus {
   behind: number;
   files: GitFileStatus[];
   clean: boolean;
+  rebase_in_progress: boolean;
+  cherry_pick_in_progress: boolean;
+  merge_in_progress: boolean;
 }
 
 interface GitFileStatus {
@@ -30,6 +33,24 @@ interface GitBranch {
   remote: boolean;
 }
 
+interface GitWorktree {
+  path: string;
+  head: string | null;
+  short_head: string | null;
+  branch: string | null;
+  bare: boolean;
+  detached: boolean;
+  locked: boolean;
+  lock_reason: string | null;
+  prunable: boolean;
+  prune_reason: string | null;
+  missing: boolean;
+  is_main: boolean;
+  is_current: boolean;
+  clean: boolean;
+  changed_files: number;
+}
+
 interface GitCommit {
   hash: string;
   short_hash: string;
@@ -52,23 +73,99 @@ interface GitRepositoryFile {
   tracked: boolean;
   status: FileStatusKind | null;
 }
+
+interface GitLfsStatus {
+  available: boolean;
+  bundled: boolean;
+  version: string | null;
+  filters_configured: boolean;
+  hook_installed: boolean;
+  repository_uses_lfs: boolean;
+  patterns: GitLfsPattern[];
+  files: GitLfsFile[];
+}
+
+interface GitLfsPattern {
+  pattern: string;
+  source: string;
+  lockable: boolean;
+  tracked: boolean;
+}
+
+interface GitLfsFile {
+  name: string;
+  size: number;
+  checkout: boolean;
+  downloaded: boolean;
+  oid_type: string;
+  oid: string;
+  version: string;
+}
+
+type GitIntegrationProvider = "github" | "gitlab" | "gitlab-self-hosted" | "azure-devops" | "gitea";
+
+interface IntegrationRepository {
+  id: string;
+  name: string;
+  fullName: string;
+  description: string;
+  cloneUrl: string;
+  sshUrl: string;
+  webUrl: string;
+  updatedAt: string;
+  private: boolean;
+}
 ```
 
 ## Commands
 
+The command list below includes the repository-management and synchronization API. The TypeScript wrappers in `src/lib/git.ts` are the authoritative full list.
+
 - `open_repository(path: string): Promise<GitStatus>`
+- `init_repository(path: string, initialBranch?: string): Promise<GitStatus>`
+- `clone_repository(...): Promise<RepositoryBundle>`
+- `list_integration_repositories(provider: GitIntegrationProvider, baseUrl: string, accountId?: string): Promise<IntegrationRepository[]>`; loads credentials from the operating system keychain and returns every repository accessible through the configured Git hosting account.
 - `get_status(path: string): Promise<GitStatus>`
+- `git_lfs_status(path: string): Promise<GitLfsStatus>`
+- `git_lfs_install(path: string): Promise<GitLfsStatus>`
+- `git_lfs_track(path: string, pattern: string, lockable?: boolean): Promise<GitLfsStatus>`
+- `git_lfs_untrack(path: string, pattern: string): Promise<GitLfsStatus>`
+- `git_lfs_pull(path: string, remote?: string, username?: string, password?: string): Promise<GitLfsStatus>`
+- `git_lfs_prune(path: string): Promise<GitLfsStatus>`
+- `pull(...)` automatically runs `git lfs pull` after a successful Git pull when
+  the repository contains LFS attributes or tracked LFS objects.
 - `list_branches(path: string): Promise<GitBranch[]>`
+- `list_remotes(path: string): Promise<GitRemote[]>`
+- `add_remote(path: string, name: string, url: string): Promise<GitRemote[]>`
+- `update_remote(path: string, name: string, url: string): Promise<GitRemote[]>`
+- `remove_remote(path: string, name: string): Promise<GitRemote[]>`
+- `set_branch_upstream(path: string, branch: string, upstream?: string): Promise<GitStatus>`
+- `delete_remote_branch(path: string, remote: string, branch: string): Promise<GitStatus>`
 - `checkout_branch(path: string, branch: string): Promise<GitStatus>`
+- `list_worktrees(path: string): Promise<GitWorktree[]>`
+- `add_worktree(path: string, worktreePath: string, ...): Promise<GitWorktree[]>`
+- `remove_worktree(path: string, worktreePath: string, force?: boolean): Promise<GitWorktree[]>`
+- `move_worktree(path: string, worktreePath: string, destination: string): Promise<GitWorktree[]>`
+- `lock_worktree(path: string, worktreePath: string, reason?: string): Promise<GitWorktree[]>`
+- `unlock_worktree(path: string, worktreePath: string): Promise<GitWorktree[]>`
+- `prune_worktrees(path: string): Promise<GitWorktree[]>`
+- `repair_worktree(path: string, worktreePath: string): Promise<GitWorktree[]>`
 - `stage_files(path: string, files: string[]): Promise<GitStatus>`
 - `unstage_files(path: string, files: string[]): Promise<GitStatus>`
+- `add_to_gitignore(path: string, target: string, kind: "file" | "extension" | "folder"): Promise<GitStatus>`; appends a repository-root `.gitignore` rule and unstages newly-added matching files.
+- `untrack_paths(path: string, targets: string[]): Promise<GitStatus>`; removes files or folders from the Git index while preserving their working-tree contents.
 - `restore_files(path: string, files: string[], staged: boolean): Promise<GitStatus>`
+- `stash_push(path: string, message?: string, includeUntracked?: boolean, paths?: string[]): Promise<GitStatus>`; when `paths` is provided, only matching files are stashed.
 - `commit(path: string, message: string): Promise<GitStatus>`
-- `pull(path: string): Promise<GitStatus>`
-- `push(path: string): Promise<GitStatus>`
-- `list_commits(path: string, limit?: number): Promise<GitCommit[]>`
+- `fetch(path: string, prune?: boolean, remote?: string): Promise<GitStatus>`
+- `pull(path: string, strategy?: "merge" | "rebase" | "ff-only", remote?: string, branch?: string): Promise<GitStatus>`
+- `push(path: string, forceWithLease?: boolean, remote?: string): Promise<GitStatus>`
+- `list_commits(path: string, limit?: number, skip?: number): Promise<GitCommit[]>`
 - `restore_to_commit(path: string, commit: string): Promise<GitStatus>`
 - `restore_file_from_commit(path: string, commit: string, file: string): Promise<GitStatus>` (the `file` argument can also be a folder path)
-- `merge_branch(path: string, branch: string): Promise<GitStatus>`
+- `merge_branch(path: string, branch: string, strategy?: "default" | "squash" | "ff-only" | "no-ff"): Promise<GitStatus>`
+- `merge_continue(path: string): Promise<GitStatus>`
+- `merge_abort(path: string): Promise<GitStatus>`
+- `revert_commit(path: string, commit: string): Promise<GitStatus>`
 - `list_repository_files(path: string): Promise<GitRepositoryFile[]>`
 - `list_file_history(path: string, file: string, limit?: number): Promise<GitCommit[]>` (the `file` argument can also be a folder path)

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,18 +1,20 @@
 {
-  "name": "tauri-git-lite",
-  "version": "2026.7.7",
+  "name": "gitty",
+  "version": "2026.9.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "tauri-git-lite",
-      "version": "2026.7.7",
+      "name": "gitty",
+      "version": "2026.9.3",
       "dependencies": {
         "@lucide/svelte": "^1.21.0",
         "@tailwindcss/vite": "^4.3.1",
         "@tauri-apps/api": "^2.5.0",
         "@tauri-apps/plugin-dialog": "^2.7.1",
         "@tauri-apps/plugin-updater": "^2.10.1",
+        "dompurify": "^3.4.15",
+        "marked": "^18.0.12",
         "simple-icons": "^16.24.1",
         "svelte": "^5.0.0",
         "tailwindcss": "^4.3.1"
@@ -1557,6 +1559,15 @@
       "integrity": "sha512-4CXDYRBGqN+57wVJkuXBYmpAVUSg3L6JAQa/DFqm238G73E1wuyc/JhGQJzN7vUf/CMphYau2zXbfWzDR5aTEw==",
       "license": "MIT"
     },
+    "node_modules/dompurify": {
+      "version": "3.4.15",
+      "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.15.tgz",
+      "integrity": "sha512-EUBjM+B+lkDE41iE82DDSCfkoPGfXx8IxFxPMjNzm/Uk4xDet77rTN9wqlxlVg71kK7XGuUMv6wUxJUwwv+Xyw==",
+      "license": "(MPL-2.0 OR Apache-2.0)",
+      "optionalDependencies": {
+        "@types/trusted-types": "^2.0.7"
+      }
+    },
     "node_modules/enhanced-resolve": {
       "version": "5.21.6",
       "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.21.6.tgz",
@@ -1975,6 +1986,18 @@
         "@jridgewell/sourcemap-codec": "^1.5.5"
       }
     },
+    "node_modules/marked": {
+      "version": "18.0.12",
+      "resolved": "https://registry.npmjs.org/marked/-/marked-18.0.12.tgz",
+      "integrity": "sha512-LEm4ga2YeI2T3GVHj9b0BaDPPk93LLTHMFeMyQbNIzPxc8vCI0y/scy0ZA6z6lXKyT9j9Nhl/OC6ZYKYGuFScA==",
+      "license": "MIT",
+      "bin": {
+        "marked": "bin/marked.js"
+      },
+      "engines": {
+        "node": ">= 20"
+      }
+    },
     "node_modules/mri": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/mri/-/mri-1.2.0.tgz",

package.json

@@ -1,14 +1,16 @@
 {
-  "name": "git-lite",
-  "version": "2026.7.7",
+  "name": "gitty",
+  "version": "2026.9.3",
   "private": true,
   "type": "module",
   "scripts": {
     "dev": "vite --host 127.0.0.1",
     "build": "vite build",
+    "prepare:lfs": "node scripts/prepare-git-lfs-sidecar.mjs",
+    "icons": "node scripts/generate-app-icons.mjs",
     "preview": "vite preview --host 127.0.0.1",
     "tauri": "tauri",
-    "tauri:dev": "tauri dev",
+    "tauri:dev": "node scripts/tauri-dev.mjs",
     "tauri:build": "tauri build",
     "check": "svelte-check --tsconfig ./tsconfig.json"
   },
@@ -18,6 +20,8 @@
     "@tauri-apps/api": "^2.5.0",
     "@tauri-apps/plugin-dialog": "^2.7.1",
     "@tauri-apps/plugin-updater": "^2.10.1",
+    "dompurify": "^3.4.15",
+    "marked": "^18.0.12",
     "simple-icons": "^16.24.1",
     "svelte": "^5.0.0",
     "tailwindcss": "^4.3.1"

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";

scripts/prepare-git-lfs-sidecar.mjs

@@ -0,0 +1,71 @@
+import { copyFileSync, existsSync, mkdirSync, chmodSync, statSync } from "node:fs";
+import { basename, delimiter, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDirectory = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(scriptDirectory, "..");
+const binariesDirectory = join(projectRoot, "src-tauri", "binaries");
+const extension = process.platform === "win32" ? ".exe" : "";
+
+function defaultTargetTriple() {
+  const triples = {
+    "win32:x64": "x86_64-pc-windows-msvc",
+    "win32:arm64": "aarch64-pc-windows-msvc",
+    "linux:x64": "x86_64-unknown-linux-gnu",
+    "linux:arm64": "aarch64-unknown-linux-gnu",
+    "darwin:x64": "x86_64-apple-darwin",
+    "darwin:arm64": "aarch64-apple-darwin",
+  };
+  return triples[`${process.platform}:${process.arch}`];
+}
+
+function executableCandidates() {
+  const configured = process.env.GIT_LFS_BINARY?.trim();
+  if (configured) return [configured];
+
+  const pathEntries = (process.env.PATH ?? "")
+    .split(delimiter)
+    .filter(Boolean);
+  const candidates = pathEntries.map((entry) => join(entry, `git-lfs${extension}`));
+  if (process.platform === "win32") {
+    for (const entry of pathEntries) {
+      if (basename(entry).toLowerCase() === "cmd") {
+        candidates.push(resolve(entry, "..", "mingw64", "bin", "git-lfs.exe"));
+      }
+    }
+  }
+  return candidates;
+}
+
+const source = executableCandidates()
+  .filter((candidate) => existsSync(candidate))
+  // Git for Windows exposes a small launcher in cmd/ and the standalone
+  // executable in mingw64/bin/. The standalone file is the portable sidecar.
+  .sort((left, right) => statSync(right).size - statSync(left).size)[0];
+if (!source) {
+  throw new Error(
+    "Git LFS was not found. Install git-lfs or set GIT_LFS_BINARY before building Gitty.",
+  );
+}
+
+const targetTriple = (
+  process.env.GITTY_TARGET_TRIPLE
+  ?? process.env.TAURI_ENV_TARGET_TRIPLE
+  ?? process.env.TARGET
+  ?? defaultTargetTriple()
+)?.trim();
+if (!targetTriple) throw new Error("Rust did not report a target triple.");
+
+mkdirSync(binariesDirectory, { recursive: true });
+
+const developmentTarget = join(binariesDirectory, `git-lfs${extension}`);
+const bundleTarget = join(
+  binariesDirectory,
+  `git-lfs-${targetTriple}${extension}`,
+);
+for (const target of [developmentTarget, bundleTarget]) {
+  if (resolve(source) !== resolve(target)) copyFileSync(source, target);
+  if (process.platform !== "win32") chmodSync(target, 0o755);
+}
+
+console.log(`Prepared bundled git-lfs from ${source} for ${targetTriple}.`);

scripts/tauri-dev.mjs

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+
+const debugEnvironment = { ...process.env };
+const clearedVariables = [];
+const blockedProxy = /^https?:\/\/127\.0\.0\.1:9\/?$/i;
+const proxyVariables = new Set([
+  "all_proxy",
+  "http_proxy",
+  "https_proxy",
+  "git_http_proxy",
+  "git_https_proxy",
+]);
+
+for (const [name, value] of Object.entries(debugEnvironment)) {
+  if (proxyVariables.has(name.toLowerCase()) && blockedProxy.test(value ?? "")) {
+    delete debugEnvironment[name];
+    clearedVariables.push(name);
+  }
+}
+
+for (const [name, value] of Object.entries(debugEnvironment)) {
+  if (
+    name.toLowerCase() === "git_ssh_command"
+    && /^cmd(?:\.exe)?\s+\/c\s+exit\s+1$/i.test((value ?? "").trim())
+  ) {
+    delete debugEnvironment[name];
+    clearedVariables.push(name);
+  }
+}
+
+if (process.argv.includes("--check-environment")) {
+  process.stdout.write(
+    clearedVariables.length > 0
+      ? `Debug environment ready; cleared: ${clearedVariables.sort().join(", ")}\n`
+      : "Debug environment ready; no blocked proxy variables found.\n",
+  );
+  process.exit(0);
+}
+
+if (clearedVariables.length > 0) {
+  process.stdout.write(
+    `Starting Gitty without the blocked debug proxy (${clearedVariables.sort().join(", ")}).\n`,
+  );
+}
+
+const isWindows = process.platform === "win32";
+const child = spawn(isWindows ? "tauri.cmd" : "tauri", ["dev"], {
+  cwd: process.cwd(),
+  env: debugEnvironment,
+  stdio: "inherit",
+  shell: isWindows,
+});
+
+child.on("error", (error) => {
+  process.stderr.write(`Could not start Tauri development mode: ${error.message}\n`);
+  process.exitCode = 1;
+});
+
+child.on("exit", (code) => {
+  process.exitCode = code ?? 1;
+});

src-tauri/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "git_lite"
+name = "gitty"
 version = "0.1.0"
 description = "Rust backend for a lightweight Git desktop client"
 edition = "2024"
@@ -17,13 +17,26 @@ 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 = { version = "1.52.3", features = ["macros", "rt-multi-thread", "time"] }
+log = "0.4"
+reqwest = { version = "0.12", default-features = false, features = ["blocking", "json", "rustls-tls"] }
+sysinfo = { version = "=0.38.3", default-features = false, features = ["system"] }
+shlex = "2"
 
 [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 ───────────────────────────────────────────────────────────

src-tauri/binaries/git-lfs-LICENSE.txt

@@ -0,0 +1,48 @@
+MIT License
+
+Copyright (c) 2014- GitHub, Inc. and Git LFS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+Portions of the subprocess and tools directories are copied from Go and are
+under the following license:
+
+Copyright (c) 2009,2010 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+   * Redistributions of source code must retain the above copyright notice,
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in the
+     documentation and/or other materials provided with the distribution.
+   * Neither the name of Google Inc. nor the names of its contributors may be
+     used to endorse or promote products derived from this software without
+     specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

@@ -9,8 +9,10 @@
     "core:window:allow-toggle-maximize",
     "core:window:allow-unminimize",
     "core:window:allow-close",
+    "core:window:allow-destroy",
     "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",
-    "linux"
+    "windows"
   ],
   "windows": [
     "main"

src-tauri/crates/commit_ai/Cargo.toml

@@ -5,8 +5,6 @@ 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

@@ -2,7 +2,7 @@ use std::time::Duration;
 
 use serde::{Deserialize, Serialize};
 
-use crate::{build_messages, looks_like_diff_echo, sanitize_message};
+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;
@@ -139,6 +139,165 @@ pub async fn generate_custom(
     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
+}
+
+async fn openai_compatible_split_request(
+    url: String,
+    bearer: Option<&str>,
+    model: &str,
+    diff: &str,
+) -> Result<String, String> {
+    let system = "You split staged Git changes into small, logical commits. Return only JSON in this exact shape: {\"summary\":\"...\",\"groups\":[{\"message\":\"type(scope): subject\",\"reason\":\"...\",\"files\":[\"path\"]}]}. Every staged file must appear exactly once. Use only paths from the supplied staged file list. Keep messages in English and use Conventional Commits. Do not use markdown.";
+    let user =
+        format!("Analyze these staged changes and propose an ordered commit plan:\n\n{diff}");
+    let body = OpenAiRequest {
+        model: model.to_string(),
+        messages: vec![
+            OpenAiMessage {
+                role: "system",
+                content: system.to_string(),
+            },
+            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 commit plan.".to_string())
+}
+
+pub async fn split_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_split_request(
+        "https://api.openai.com/v1/chat/completions".to_string(),
+        Some(api_key),
+        model,
+        diff,
+    )
+    .await
+}
+
+pub async fn split_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());
+    }
+    openai_compatible_split_request(
+        format!("{}/chat/completions", base_url.trim_end_matches('/')),
+        api_key,
+        model,
+        diff,
+    )
+    .await
+}
+
 #[derive(Serialize)]
 struct AnthropicMessage {
     role: &'static str,
@@ -220,3 +379,89 @@ pub async fn generate_anthropic(
     }
     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())
+}
+
+pub async fn split_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 = "You split staged Git changes into small, logical commits. Return only JSON in this exact shape: {\"summary\":\"...\",\"groups\":[{\"message\":\"type(scope): subject\",\"reason\":\"...\",\"files\":[\"path\"]}]}. Every staged file must appear exactly once. Use only paths from the supplied staged file list. Keep messages in English and use Conventional Commits. Do not use markdown.".to_string();
+    let body = AnthropicRequest {
+        model: model.to_string(),
+        max_tokens: 2400,
+        system,
+        messages: vec![AnthropicMessage {
+            role: "user",
+            content: format!(
+                "Analyze these staged changes and propose an ordered commit plan:\n\n{diff}"
+            ),
+        }],
+    };
+    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 commit plan.".to_string())
+}

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

@@ -1,319 +1,12 @@
 mod cloud;
 
-pub use cloud::{generate_anthropic, generate_custom, generate_openai};
-
-use std::{
-    collections::hash_map::DefaultHasher,
-    hash::{Hash, Hasher},
-    sync::Arc,
+pub use cloud::{
+    generate_anthropic, generate_custom, generate_openai, review_anthropic, review_custom,
+    review_openai, split_anthropic, split_custom, split_openai,
 };
 
-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.
+/// Strip a wrapping code 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("```") {
@@ -330,9 +23,9 @@ pub(crate) fn sanitize_message(raw: &str) -> 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.
+/// Some models echo the prompt's diff sections 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")
@@ -355,55 +48,12 @@ fn truncate_at_char_boundary(input: &str, max_chars: usize) -> String {
     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.
+    // Rough token estimate to keep requests within common context windows.
     const MAX_CHARS: usize = 24_000;
     let diff = truncate_at_char_boundary(diff, MAX_CHARS);
 
@@ -443,3 +93,27 @@ instead of a direct string comparison.\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/integrations/board_discovery.rs

@@ -0,0 +1,177 @@
+//! Discover boards without changing provider data. Return partial results with explicit warnings.
+use super::*;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BoardReference { title: String, web_url: String, scope: String }
+#[derive(Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BoardDirectory { boards: Vec<BoardReference>, warnings: Vec<String> }
+
+impl BoardDirectory {
+    fn add(&mut self, api: &BoardApi, title: String, web_url: String, scope: String) {
+        if board_path(api.base, &web_url).is_ok() && !self.boards.iter().any(|b| b.web_url == web_url) {
+            self.boards.push(BoardReference { title, web_url, scope });
+        }
+    }
+    fn warn(&mut self, scope: &str, error: String) { self.warnings.push(format!("{scope}: {error}")); }
+}
+
+fn rest_directory(api: &BoardApi, out: &mut BoardDirectory) -> Result<(), String> {
+    if api.provider == "gitea" {
+        // The deployed server schema is more useful than guessing from its version.
+        if let Ok(schema) = api.get(endpoint(api.base, &["swagger.v1.json"])?) {
+            if schema["paths"].as_object().is_some_and(|paths| !paths.contains_key("/repos/{owner}/{repo}/projects")) {
+                return Err("This Gitea server publishes no Projects/Columns API. Automatic board discovery and import are unavailable; use the original web board.".into());
+            }
+        }
+        let repos = api.pages(endpoint(api.base, &["api", "v1", "user", "repos"])?, &[])?;
+        for repo in repos {
+            if repo["has_projects"] == false { continue; }
+            let full = value_string(&repo, &["full_name"]);
+            let Some((owner, name)) = full.split_once('/') else { continue; };
+            let result = api.pages(endpoint(api.base, &["api", "v1", "repos", owner, name, "projects"])?, &[("state".into(), "open".into())]);
+            match result {
+                Ok(boards) => for board in boards {
+                    let id = json_id(&board);
+                    out.add(api, value_string(&board, &["title"]), endpoint(api.base, &[owner, name, "projects", &id])?, full.clone());
+                },
+                Err(e) => out.warn(&full, e),
+            }
+        }
+        match api.pages(endpoint(api.base, &["api", "v1", "user", "orgs"])?, &[]) {
+            Ok(orgs) => for org in orgs {
+                let name = value_string(&org, &["username"]);
+                let name = if name.is_empty() { value_string(&org, &["name"]) } else { name };
+                match api.pages(endpoint(api.base, &["api", "v1", "orgs", &name, "projects"])?, &[("state".into(), "open".into())]) {
+                    Ok(boards) => for board in boards { out.add(api, value_string(&board, &["title"]), endpoint(api.base, &["org", &name, "projects", &json_id(&board)])?, name.clone()); },
+                    Err(e) => out.warn(&name, e),
+                }
+            },
+            Err(e) => out.warn("Organizations", e),
+        }
+    } else {
+        for (scope, query) in [("projects", vec![("membership".into(), "true".into()), ("archived".into(), "false".into())]), ("groups", vec![("all_available".into(), "false".into())])] {
+            let entities = match api.pages(endpoint(api.base, &["api", "v4", scope])?, &query) { Ok(v) => v, Err(e) => { out.warn(scope, e); continue; } };
+            for entity in entities {
+                let id = json_id(&entity);
+                let name = value_string(&entity, &[if scope == "groups" { "full_path" } else { "path_with_namespace" }]);
+                let base = value_string(&entity, &["web_url"]);
+                match api.pages(endpoint(api.base, &["api", "v4", scope, &id, "boards"])?, &[]) {
+                    Ok(boards) => for board in boards {
+                        out.add(api, value_string(&board, &["name"]), format!("{}/-/boards/{}", base.trim_end_matches('/'), json_id(&board)), name.clone());
+                    },
+                    Err(e) => out.warn(&name, e),
+                }
+            }
+        }
+    }
+    Ok(())
+}
+
+fn github_directory(api: &BoardApi, out: &mut BoardDirectory) -> Result<(), String> {
+    let graphql = "https://api.github.com/graphql".to_string();
+    let mut owners = vec![];
+    let mut cursor = Value::Null;
+    for page in 0..20 {
+        let data = api.graphql(graphql.clone(), "query($cursor:String){viewer{login organizations(first:100,after:$cursor){nodes{login} pageInfo{hasNextPage endCursor}}}}", json!({"cursor":cursor}))?;
+        let viewer = &data["data"]["viewer"];
+        if page == 0 { owners.push(("user", value_string(viewer, &["login"]))); }
+        let orgs = &viewer["organizations"];
+        for org in orgs["nodes"].as_array().ok_or("Could not read GitHub organizations.")? { owners.push(("organization", value_string(org, &["login"]))); }
+        if orgs["pageInfo"]["hasNextPage"] != true { break; }
+        cursor = orgs["pageInfo"]["endCursor"].clone();
+        if page == 19 { out.warn("GitHub", "Organization page limit reached.".into()); }
+    }
+    for (kind, owner) in owners {
+        let query = format!("query($owner:String!,$cursor:String){{{kind}(login:$owner){{projectsV2(first:100,after:$cursor){{nodes{{title url closed}} pageInfo{{hasNextPage endCursor}}}}}}}}");
+        let mut cursor = Value::Null;
+        for page in 0..20 {
+            let data = match api.graphql(graphql.clone(), &query, json!({"owner":owner,"cursor":cursor})) { Ok(v) => v, Err(e) => { out.warn(&owner, e); break; } };
+            let projects = &data["data"][kind]["projectsV2"];
+            let Some(nodes) = projects["nodes"].as_array() else { out.warn(&owner, "Project list unavailable; check read:project access.".into()); break; };
+            for board in nodes { if board["closed"] != true { out.add(api, value_string(board, &["title"]), value_string(board, &["url"]), owner.clone()); } }
+            if projects["pageInfo"]["hasNextPage"] != true { break; }
+            cursor = projects["pageInfo"]["endCursor"].clone();
+            if page == 19 { out.warn(&owner, "Project page limit reached.".into()); }
+        }
+    }
+    Ok(())
+}
+
+fn azure_directory(api: &BoardApi, out: &mut BoardDirectory) -> Result<(), String> {
+    for page in 0..20 {
+        let teams = api.read(api.request(reqwest::Method::GET, endpoint(api.base, &["_apis", "teams"])?)
+            .query(&[("api-version", "7.1-preview.3".to_string()), ("$top", "100".into()), ("$skip", (page * 100).to_string())]))?;
+        let teams = teams["value"].as_array().ok_or("Could not read Azure teams.")?;
+        if teams.is_empty() { return Ok(()); }
+        for team in teams {
+            let project = value_string(team, &["projectName"]);
+            let name = value_string(team, &["name"]);
+            match api.read(api.request(reqwest::Method::GET, endpoint(api.base, &[&project, &name, "_apis", "work", "boards"])?)
+                .query(&[("api-version", "7.1")])) {
+                Ok(data) => {
+                    let Some(boards) = data["value"].as_array() else { out.warn(&name, "Invalid Azure board list.".into()); continue; };
+                    for board in boards {
+                        let title = value_string(board, &["name"]);
+                        out.add(api, title.clone(), endpoint(api.base, &[&project, "_boards", "board", "t", &name, &title])?, format!("{project} / {name}"));
+                    }
+                },
+                Err(e) => out.warn(&name, e),
+            }
+        }
+    }
+    out.warn("Azure", "Team page limit reached.".into());
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn list_integration_boards(provider: String, base_url: String, username: String, token: String) -> Result<BoardDirectory, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if token.trim().is_empty() { return Err("No token stored for this integration.".into()); }
+        let base = normalized_base_url(&base_url)?;
+        let api = BoardApi { client: Client::builder().connect_timeout(Duration::from_secs(7)).timeout(Duration::from_secs(12)).redirect(reqwest::redirect::Policy::none()).build().map_err(|e| e.to_string())?, provider: &provider, base: &base, username: &username, token: &token, started: Instant::now() };
+        let mut out = BoardDirectory::default();
+        let result = match provider.as_str() {
+            "gitea" | "gitlab" | "gitlab-self-hosted" => rest_directory(&api, &mut out),
+            "github" => github_directory(&api, &mut out),
+            "azure-devops" => azure_directory(&api, &mut out),
+            _ => Err("Unsupported board provider.".into()),
+        };
+        if let Err(e) = result { out.warn("Board discovery", e); }
+        out.boards.sort_by(|a,b| (&a.scope, &a.title).cmp(&(&b.scope, &b.title)));
+        Ok(out)
+    }).await.map_err(|e| e.to_string())?
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::super::tests::{mock_api, test_api};
+    #[test]
+    fn missing_gitea_routes_are_reported_without_querying_repositories() {
+        let (base, worker) = mock_api(vec![("/swagger.v1.json ", json!({"paths":{"/repos/{owner}/{repo}":{}}}))]);
+        let mut out = BoardDirectory::default();
+        let error = rest_directory(&test_api(&base,"gitea"), &mut out).unwrap_err();
+        assert!(error.contains("publishes no Projects/Columns API"));
+        assert!(out.boards.is_empty());
+        worker.join().unwrap();
+    }
+    #[test]
+    fn gitea_discovers_multiple_repository_boards_and_paginates() {
+        let (base, worker) = mock_api(vec![
+            ("/swagger.v1.json ",json!({"paths":{"/repos/{owner}/{repo}/projects":{}}})),
+            ("/user/repos?page=1",json!([{"full_name":"team/repo"}])),
+            ("/user/repos?page=2",json!([])),
+            ("/repos/team/repo/projects?state=open&page=1",json!([{"id":1,"title":"Delivery"},{"id":2,"title":"Roadmap"}])),
+            ("/repos/team/repo/projects?state=open&page=2",json!([])),
+            ("/user/orgs?page=1",json!([])),
+        ]);
+        let mut out = BoardDirectory::default();
+        rest_directory(&test_api(&base,"gitea"), &mut out).unwrap();
+        assert_eq!(out.boards.len(),2);
+        assert_eq!(out.boards[0].web_url,format!("{base}/team/repo/projects/1"));
+        assert!(out.warnings.is_empty());
+        worker.join().unwrap();
+    }
+}

src-tauri/src/integrations/board_moves.rs

@@ -0,0 +1,115 @@
+//! Persist one user-requested column move. Resolve all mutation metadata from a fresh board.
+use super::*;
+
+fn gitlab_move_body(board: &IntegrationBoard, source: &BoardColumn, target: &BoardColumn) -> Result<Value, String> {
+    let metadata = target.move_target.as_ref().ok_or("This board grouping does not support moving cards.")?;
+    let label = value_string(metadata, &["label"]);
+    // Only remove this board's grouping labels. Unrelated issue labels stay intact.
+    let remove = board.columns.iter().filter(|c| target.id == "open" || c.id == source.id).filter_map(|c| c.move_target.as_ref())
+        .map(|m| value_string(m, &["label"]))
+        .filter(|name| !name.is_empty() && *name != label).collect::<Vec<_>>();
+    if target.id != "closed" && remove.iter().any(|label| strings(metadata, "protectedLabels", "name").contains(label)) {
+        return Err("This move would remove a label required by the board filter. Open the original board to change its scope.".into());
+    }
+    let mut body = json!({"state_event": if target.id == "closed" { "close" } else { "reopen" }});
+    if target.id != "closed" {
+        body["remove_labels"] = json!(remove.join(","));
+        if !label.is_empty() { body["add_labels"] = json!(label); }
+    }
+    Ok(body)
+}
+
+fn azure_patch(item: &Value, metadata: &Value) -> Result<Value, String> {
+    let kind = value_string(item, &["fields", "System.WorkItemType"]);
+    let state = value_string(&metadata["states"], &[&kind]);
+    if state.is_empty() { return Err("The target column has no state mapping for this work item type.".into()); }
+    let rev = item["rev"].as_u64().ok_or("Azure returned no work item revision.")?;
+    let field = value_string(metadata, &["columnField"]);
+    wiql_field(&field)?;
+    let mut patch = vec![json!({"op":"test","path":"/rev","value":rev}),
+        json!({"op":"add","path":"/fields/System.State","value":state}),
+        json!({"op":"add","path":format!("/fields/{field}"),"value":metadata["name"]})];
+    let done_field = value_string(metadata, &["doneField"]);
+    if !done_field.is_empty() {
+        wiql_field(&done_field)?;
+        patch.push(json!({"op":"add","path":format!("/fields/{done_field}"),"value":metadata["done"]}));
+    }
+    Ok(json!(patch))
+}
+
+#[tauri::command]
+pub async fn move_integration_board_card(provider: String, base_url: String, username: String, token: String, board_url: String, card_id: String, source_column_id: String, target_column_id: String) -> Result<(), String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if token.trim().is_empty() { return Err("No token stored for this integration.".into()); }
+        let base = normalized_base_url(&base_url)?;
+        let path = board_path(&base, &board_url)?;
+        let api = BoardApi { client: Client::builder().connect_timeout(Duration::from_secs(7)).timeout(Duration::from_secs(12)).redirect(reqwest::redirect::Policy::none()).build().map_err(|e| e.to_string())?, provider: &provider, base: &base, username: &username, token: &token, started: Instant::now() };
+        let board = match provider.as_str() {
+            "github" => github_board(&api, &path, &board_url)?,
+            "gitlab" | "gitlab-self-hosted" => gitlab_board(&api, &path, &board_url)?,
+            "azure-devops" => azure_board(&api, &path, &board_url)?,
+            _ => return Err("Moving cards is not supported for this integration.".into()),
+        };
+        let card = board.columns.iter().find(|c| c.id == source_column_id).and_then(|c| c.cards.iter().find(|c| c.id == card_id))
+            .ok_or("The card has moved or is no longer in this board. Refresh before trying again.")?;
+        let target = board.columns.iter().find(|c| c.id == target_column_id).ok_or("The target column no longer exists.")?;
+        let metadata = target.move_target.as_ref().ok_or("This column does not support moving cards.")?;
+        if source_column_id == target_column_id { return Ok(()); }
+        match provider.as_str() {
+            "github" => {
+                let mut input = json!({"projectId":metadata["project"],"fieldId":metadata["field"],"itemId":card.id});
+                let query = if target.id == "unassigned" {
+                    "mutation($input:ClearProjectV2ItemFieldValueInput!){clearProjectV2ItemFieldValue(input:$input){projectV2Item{id}}}"
+                } else {
+                    input["value"] = json!({"singleSelectOptionId":target.id});
+                    "mutation($input:UpdateProjectV2ItemFieldValueInput!){updateProjectV2ItemFieldValue(input:$input){projectV2Item{id}}}"
+                };
+                api.graphql("https://api.github.com/graphql".into(), query, json!({"input":input}))?;
+            },
+            "gitlab" | "gitlab-self-hosted" => {
+                if card.repository.is_empty() { return Err("The issue's repository could not be resolved.".into()); }
+                let source = board.columns.iter().find(|c| c.id == source_column_id).ok_or("Source column no longer exists.")?;
+                let body = gitlab_move_body(&board, source, target)?;
+                api.read(api.request(reqwest::Method::PUT, endpoint(&base, &["api","v4","projects",&card.repository,"issues",&card.number.to_string()])?).json(&body))?;
+            },
+            "azure-devops" => {
+                let url = endpoint(&base, &["_apis","wit","workitems",&card.number.to_string()])?;
+                let item = api.read(api.request(reqwest::Method::GET,url.clone()).query(&[("api-version","7.1")]))?;
+                let source = board.columns.iter().find(|c| c.id == source_column_id).and_then(|c| c.move_target.as_ref()).ok_or("Source column no longer exists.")?;
+                let field = value_string(source, &["columnField"]);
+                let done = value_string(source, &["doneField"]);
+                if item["fields"][&field] != source["name"] || (!done.is_empty() && item["fields"][&done].as_bool().unwrap_or(false) != source["done"].as_bool().unwrap_or(false)) {
+                    return Err("The card has moved since the board was read. Refresh before trying again.".into());
+                }
+                let patch = azure_patch(&item,metadata)?;
+                api.read(api.request(reqwest::Method::PATCH,url).query(&[("api-version","7.1")]).header("Content-Type","application/json-patch+json").json(&patch))?;
+            },
+            _ => unreachable!(),
+        }
+        Ok(())
+    }).await.map_err(|e| e.to_string())?
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn label_move_preserves_unrelated_labels_and_close_keeps_assignments() {
+        let mut a = column("1".into(),"Todo".into()); a.move_target=Some(json!({"label":"Todo"}));
+        let mut b = column("2".into(),"Build".into()); b.move_target=Some(json!({"label":"Build"}));
+        let mut c = column("closed".into(),"Closed".into()); c.move_target=Some(json!({"state":"close"}));
+        let board=IntegrationBoard{title:String::new(),web_url:String::new(),notice:String::new(),columns:vec![a,b,c]};
+        assert_eq!(gitlab_move_body(&board,&board.columns[0],&board.columns[1]).unwrap(),json!({"add_labels":"Build","remove_labels":"Todo","state_event":"reopen"}));
+        assert_eq!(gitlab_move_body(&board,&board.columns[0],&board.columns[2]).unwrap(),json!({"state_event":"close"}));
+    }
+    #[test]
+    fn azure_move_checks_revision_and_uses_team_specific_fields() {
+        let item=json!({"rev":7,"fields":{"System.WorkItemType":"Bug"}});
+        let metadata=json!({"columnField":"WEF_Test.Column","doneField":"WEF_Test.Done","name":"Review","done":true,"states":{"Bug":"Active"}});
+        let patch=azure_patch(&item,&metadata).unwrap();
+        assert_eq!(patch[0],json!({"op":"test","path":"/rev","value":7}));
+        assert_eq!(patch[2]["path"],"/fields/WEF_Test.Column");
+        assert_eq!(patch[3]["value"],true);
+        assert!(azure_patch(&json!({"rev":1,"fields":{"System.WorkItemType":"Task"}}),&metadata).is_err());
+    }
+}

src-tauri/src/integrations/creation.rs

@@ -0,0 +1,168 @@
+use super::*;
+
+fn creation_payload(provider: &str, source: &str, target: &str, title: &str, description: &str) -> Result<serde_json::Value, String> {
+    if title.trim().is_empty() || source.trim().is_empty() || target.trim().is_empty() {
+        return Err("Title, source branch and target branch are required.".into());
+    }
+    if source == target { return Err("Source and target branch must be different.".into()); }
+    Ok(match provider {
+        "github" | "gitea" => serde_json::json!({"head":source,"base":target,"title":title,"body":description}),
+        "gitlab" | "gitlab-self-hosted" => serde_json::json!({"source_branch":source,"target_branch":target,"title":title,"description":description}),
+        "azure-devops" => serde_json::json!({"sourceRefName":format!("refs/heads/{source}"),"targetRefName":format!("refs/heads/{target}"),"title":title,"description":description}),
+        _ => return Err("Unsupported integration provider.".into()),
+    })
+}
+
+fn creation_endpoint(provider: &str, base: &str, repository: &IntegrationRepository) -> Result<reqwest::Url, String> {
+    let base = if provider == "github" { github_api_base_url(base)? } else { normalized_base_url(base)? };
+    let mut url = reqwest::Url::parse(&format!("{base}/")).map_err(|e| e.to_string())?;
+    {
+        let mut path = url.path_segments_mut().map_err(|_| "Invalid integration URL.")?;
+        path.pop_if_empty();
+        match provider {
+            "github" | "gitea" => {
+                let parts: Vec<_> = repository.full_name.split('/').collect();
+                if parts.len() != 2 || parts.iter().any(|part| part.is_empty() || *part == "." || *part == "..") {
+                    return Err("Invalid repository name.".into());
+                }
+                if provider == "gitea" { path.extend(["api", "v1"]); }
+                path.push("repos").extend(parts).push("pulls");
+            }
+            "gitlab" | "gitlab-self-hosted" => { path.extend(["api","v4","projects", &repository.id,"merge_requests"]); }
+            "azure-devops" => { path.extend(["_apis","git","repositories", &repository.id,"pullrequests"]); }
+            _ => return Err("Unsupported integration provider.".into()),
+        }
+    }
+    if provider == "azure-devops" { url.query_pairs_mut().append_pair("api-version", "7.1"); }
+    Ok(url)
+}
+
+#[tauri::command]
+pub async fn create_integration_review_request(provider: String, base_url: String, username: String, token: String, repository: IntegrationRepository, source_branch: String, target_branch: String, title: String, description: String) -> Result<IntegrationReviewRequest, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if token.trim().is_empty() { return Err("No token is stored for this integration.".into()); }
+        let source = source_branch.trim().strip_prefix("refs/heads/").unwrap_or(source_branch.trim());
+        let target = target_branch.trim().strip_prefix("refs/heads/").unwrap_or(target_branch.trim());
+        let payload = creation_payload(&provider, source, target, title.trim(), &description)?;
+        let endpoint = creation_endpoint(&provider, &base_url, &repository)?;
+        let client = client()?;
+        let request = client.post(endpoint).header(USER_AGENT, "Gitty").header(ACCEPT, "application/json");
+        let request = match provider.as_str() {
+            "github" => request.bearer_auth(&token),
+            "gitea" => request.header("Authorization", format!("token {token}")),
+            "gitlab" | "gitlab-self-hosted" => request.header("PRIVATE-TOKEN", &token),
+            "azure-devops" => request.basic_auth(if username.is_empty() { "gitty" } else { &username }, Some(&token)),
+            _ => unreachable!(),
+        };
+        // Never automatically retry creation: a lost response can still mean the PR was created.
+        let response = request.json(&payload).send().map_err(|_| "The creation response could not be received. Check the original repository before trying again.".to_string())?;
+        if !response.status().is_success() { return Err(response_error(response, &provider)); }
+        let mut value: serde_json::Value = response.json().map_err(|_| "The request was created, but its response could not be read. Refresh the Review Center before trying again.".to_string())?;
+        let mut review = match provider.as_str() {
+            "github" => {
+                value["pull_request"] = serde_json::json!({});
+                value["repository_url"] = serde_json::json!(format!("{}/repos/{}", github_api_base_url(&base_url)?, repository.full_name));
+                parse_github_review(&value).ok_or("Could not read the created PR.")?
+            }
+            "gitea" => {
+                value["pull_request"] = value.clone();
+                value["repository"] = serde_json::json!({"id":repository.id.parse::<u64>().unwrap_or_default(),"full_name":repository.full_name});
+                parse_gitea_review(&value).ok_or("Could not read the created PR.")?
+            }
+            "gitlab" | "gitlab-self-hosted" => parse_gitlab_review(&value, &provider),
+            "azure-devops" => parse_azure_review(&value, &repository),
+            _ => unreachable!(),
+        };
+        review.repository_name = repository.full_name;
+        review.source_branch = source.to_string();
+        review.target_branch = target.to_string();
+        Ok(review)
+    }).await.map_err(|e| format!("Could not create review request: {e}"))?
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn creation_payloads_and_validation() {
+        for provider in ["github", "gitea", "gitlab", "gitlab-self-hosted", "azure-devops"] {
+            assert!(creation_payload(provider, "main", "main", "Test", "").is_err());
+            assert!(creation_payload(provider, "topic", "main", " ", "").is_err());
+        }
+        assert_eq!(creation_payload("github", "feature/test", "main", "Test", "Body").unwrap()["head"], "feature/test");
+        assert_eq!(creation_payload("gitea", "topic", "main", "Test", "Body").unwrap()["body"], "Body");
+        assert_eq!(creation_payload("gitlab-self-hosted", "topic", "main", "Test", "").unwrap()["source_branch"], "topic");
+        assert_eq!(creation_payload("azure-devops", "topic", "main", "Test", "").unwrap()["targetRefName"], "refs/heads/main");
+    }
+    #[test]
+    fn creation_urls_preserve_prefixes_and_encode_paths() {
+        let repository: IntegrationRepository = serde_json::from_value(serde_json::json!({"id":"17","name":"repo","fullName":"owner/repo","description":"","cloneUrl":"","sshUrl":"","webUrl":"","updatedAt":"","private":false})).unwrap();
+        assert_eq!(creation_endpoint("github", "https://github.com", &repository).unwrap().as_str(), "https://api.github.com/repos/owner/repo/pulls");
+        assert_eq!(creation_endpoint("gitea", "https://git.example/sub", &repository).unwrap().path(), "/sub/api/v1/repos/owner/repo/pulls");
+        assert_eq!(creation_endpoint("gitlab", "https://git.example", &repository).unwrap().path(), "/api/v4/projects/17/merge_requests");
+        assert_eq!(creation_endpoint("azure-devops", "https://dev.azure.com/org", &repository).unwrap().as_str(), "https://dev.azure.com/org/_apis/git/repositories/17/pullrequests?api-version=7.1");
+    }
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepositoryBranches {
+    branches: Vec<String>,
+    default_branch: String,
+}
+
+#[tauri::command]
+pub async fn list_integration_repository_branches(provider: String, base_url: String, username: String, token: String, repository: IntegrationRepository) -> Result<RepositoryBranches, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if token.trim().is_empty() { return Err("No token is stored for this integration.".into()); }
+        let client = client()?;
+        let mut metadata_url = creation_endpoint(&provider, &base_url, &repository)?;
+        metadata_url.path_segments_mut().map_err(|_| "Invalid repository URL")?.pop();
+        let get = |url: reqwest::Url| -> Result<Response, String> {
+            let request = client.get(url).header(USER_AGENT, "Gitty").header(ACCEPT, "application/json");
+            let request = match provider.as_str() {
+                "github" => request.bearer_auth(&token),
+                "gitea" => request.header("Authorization", format!("token {token}")),
+                "gitlab" | "gitlab-self-hosted" => request.header("PRIVATE-TOKEN", &token),
+                "azure-devops" => request.basic_auth(&username, Some(&token)),
+                _ => return Err("Unsupported integration provider.".into()),
+            };
+            let response = request.send().map_err(|e| format!("Could not load branches: {e}"))?;
+            if !response.status().is_success() { return Err(response_error(response, &provider)); }
+            Ok(response)
+        };
+        let metadata: serde_json::Value = get(metadata_url.clone())?.json().map_err(|e| format!("Invalid repository response: {e}"))?;
+        let default_branch = value_string(&metadata, &[if provider == "azure-devops" { "defaultBranch" } else { "default_branch" }]).trim_start_matches("refs/heads/").to_string();
+        let mut branches = BTreeSet::new();
+        let mut continuation = String::new();
+        for page in 1..=1000 {
+            let mut url = metadata_url.clone();
+            {
+                let mut path = url.path_segments_mut().map_err(|_| "Invalid repository URL")?;
+                if provider.starts_with("gitlab") { path.push("repository"); }
+                path.push(if provider == "azure-devops" { "refs" } else { "branches" });
+            }
+            if provider == "azure-devops" {
+                url.query_pairs_mut().append_pair("filter", "heads/").append_pair("$top", "100");
+                if !continuation.is_empty() { url.query_pairs_mut().append_pair("continuationToken", &continuation); }
+            } else {
+                url.query_pairs_mut().append_pair("page", &page.to_string()).append_pair(if provider == "gitea" { "limit" } else { "per_page" }, "100");
+            }
+            let response = get(url)?;
+            let next = response.headers().get("x-ms-continuationtoken").and_then(|h| h.to_str().ok()).unwrap_or_default().to_string();
+            let data: serde_json::Value = response.json().map_err(|e| format!("Invalid branch response: {e}"))?;
+            let items = if provider == "azure-devops" { data.get("value") } else { Some(&data) }.and_then(serde_json::Value::as_array).ok_or("Invalid branch list.")?;
+            for item in items {
+                let name = value_string(item, &["name"]);
+                let name = if provider == "azure-devops" { name.strip_prefix("refs/heads/").unwrap_or(&name) } else { &name };
+                if !name.is_empty() { branches.insert(name.to_string()); }
+            }
+            if (provider == "azure-devops" && next.is_empty()) || (provider != "azure-devops" && items.len() < 100) {
+                return Ok(RepositoryBranches { branches: branches.into_iter().collect(), default_branch });
+            }
+            if provider == "azure-devops" && next == continuation { return Err("The server repeated its branch pagination token.".into()); }
+            continuation = next;
+        }
+        Err("The repository has too many branches to load completely.".into())
+    }).await.map_err(|e| format!("Could not load branches: {e}"))?
+}

src-tauri/src/integrations/issue_actions.rs

@@ -0,0 +1,53 @@
+use super::*;
+use super::issue_comments::{comment_url, request, comment_client};
+use serde_json::{Value,json};
+fn read(response: reqwest::blocking::Response, provider: &str) -> Result<Value,String> {
+    if !response.status().is_success() {return Err(response_error(response,provider));}
+    response.json().map_err(|e|e.to_string())
+}
+fn completed_state(value: &Value) -> Result<String,String> {
+    let states:Vec<_>=value["value"].as_array().into_iter().flatten().filter(|v|v["category"]=="Completed").filter_map(|v|v["name"].as_str()).filter(|s|!s.is_empty()).collect();
+    if states.len()!=1 {return Err("No unique completed state is configured for this work item type. Open the issue in Azure to select its state.".into());}
+    Ok(states[0].into())
+}
+#[tauri::command]
+pub async fn close_integration_issue(provider:String,base_url:String,username:String,token:String,repository:String,number:u64) -> Result<String,String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let client=comment_client()?;
+        let mut url=comment_url(&provider,&base_url,&repository,number)?;
+        url.path_segments_mut().map_err(|_|"Invalid issue URL.")?.pop();
+        if provider=="azure-devops" {
+            url.set_query(Some("api-version=7.1"));
+            let item=read(request(&client,reqwest::Method::GET,url.clone(),&provider,&username,&token)?.send().map_err(|e|e.to_string())?,&provider)?;
+            let kind=value_string(&item,&["fields","System.WorkItemType"]);
+            let mut states_url=reqwest::Url::parse(&normalized_base_url(&base_url)?).map_err(|e|e.to_string())?;
+            states_url.path_segments_mut().map_err(|_|"Invalid Azure URL.")?.pop_if_empty().extend([&repository,"_apis","wit","workitemtypes",&kind,"states"]);
+            states_url.set_query(Some("api-version=7.1"));
+            let states=read(request(&client,reqwest::Method::GET,states_url,&provider,&username,&token)?.send().map_err(|e|e.to_string())?,&provider)?;
+            let state=completed_state(&states)?;
+            if item["fields"]["System.State"]==state {return Ok(state);}
+            let rev=item["rev"].as_u64().ok_or("Azure returned no revision.")?;
+            let payload=json!([{"op":"test","path":"/rev","value":rev},{"op":"add","path":"/fields/System.State","value":state}]);
+            let result=read(request(&client,reqwest::Method::PATCH,url,&provider,&username,&token)?.header("Content-Type","application/json-patch+json").json(&payload).send().map_err(|e|e.to_string())?,&provider)?;
+            let actual=value_string(&result,&["fields","System.State"]);
+            if actual!=state {return Err("Azure did not confirm the completed state.".into());}
+            Ok(actual)
+        } else {
+            let gitlab=provider.starts_with("gitlab");
+            let method=if gitlab {reqwest::Method::PUT}else{reqwest::Method::PATCH};
+            let payload=if gitlab {json!({"state_event":"close"})}else{json!({"state":"closed"})};
+            let result=read(request(&client,method,url,&provider,&username,&token)?.json(&payload).send().map_err(|e|format!("Closing was not confirmed: {e}"))?,&provider)?;
+            let state=value_string(&result,&["state"]);
+            if state!="closed" {return Err("The provider did not confirm the closed state.".into());}
+            Ok(state)
+        }
+    }).await.map_err(|e|e.to_string())?
+}
+#[cfg(test)] mod tests {
+    use super::*;
+    #[test] fn uses_custom_completed_state_and_rejects_ambiguous_configuration() {
+        assert_eq!(completed_state(&json!({"value":[{"name":"Review","category":"Resolved"},{"name":"Delivered","category":"Completed"}]})).unwrap(),"Delivered");
+        assert!(completed_state(&json!({"value":[]})).is_err());
+        assert!(completed_state(&json!({"value":[{"name":"A","category":"Completed"},{"name":"B","category":"Completed"}]})).is_err());
+    }
+}

src-tauri/src/integrations/issue_comments.rs

@@ -0,0 +1,95 @@
+use super::*;
+use serde_json::{Value, json};
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IssueComment { id: String, author: String, body: String, created_at: String, body_html: bool }
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IssueCommentPage { comments: Vec<IssueComment>, next_cursor: Option<String> }
+
+pub(super) fn comment_url(provider: &str, base: &str, repository: &str, number: u64) -> Result<reqwest::Url, String> {
+    if repository.trim().is_empty() || number == 0 { return Err("Missing issue repository or number.".into()); }
+    let base = normalized_base_url(base)?;
+    let mut url = reqwest::Url::parse(if provider == "github" { "https://api.github.com" } else { &base }).map_err(|e|e.to_string())?;
+    let num = number.to_string();
+    let mut path = url.path_segments_mut().map_err(|_|"Invalid API URL.")?;
+    path.pop_if_empty();
+    match provider {
+        "github" | "gitea" => {
+            let (owner, repo) = repository.split_once('/').filter(|(a,b)|!a.is_empty() && !b.is_empty() && !b.contains('/')).ok_or("Invalid issue repository.")?;
+            if provider == "gitea" { path.extend(["api","v1"]); }
+            path.extend(["repos",owner,repo,"issues",&num,"comments"]);
+        },
+        "gitlab" | "gitlab-self-hosted" => { path.extend(["api","v4","projects",repository,"issues",&num,"notes"]); },
+        "azure-devops" => { path.extend([repository,"_apis","wit","workItems",&num,"comments"]); },
+        _ => return Err("Unsupported issue provider.".into()),
+    }
+    drop(path);
+    if provider == "azure-devops" { url.query_pairs_mut().append_pair("api-version","7.1-preview.4"); }
+    Ok(url)
+}
+pub(super) fn request(client: &Client, method: reqwest::Method, url: reqwest::Url, provider: &str, username: &str, token: &str) -> Result<reqwest::blocking::RequestBuilder, String> {
+    if token.trim().is_empty() { return Err("No token stored for this integration.".into()); }
+    let req = client.request(method,url).header(USER_AGENT,"Gitty").header(ACCEPT,"application/json");
+    Ok(match provider {
+        "github" => req.bearer_auth(token),
+        "gitea" => req.header("Authorization",format!("token {token}")),
+        "gitlab" | "gitlab-self-hosted" => req.header("PRIVATE-TOKEN",token),
+        _ => req.basic_auth(if username.is_empty(){"gitty"}else{username},Some(token)),
+    })
+}
+fn parse_comment(v: &Value, provider: &str) -> Option<IssueComment> {
+    if v["system"] == true || v["isDeleted"] == true { return None; }
+    let azure = provider == "azure-devops";
+    let id = if azure && v["id"].is_null() { json_id(&json!({"id":v["commentId"]})) } else { json_id(v) };
+    Some(IssueComment { id, author: value_string(v, if azure { &["createdBy","displayName"] } else if provider.starts_with("gitlab") { &["author","username"] } else { &["user","login"] }), body:value_string(v,&[if azure{"text"}else{"body"}]), created_at:value_string(v,&[if azure{"createdDate"}else{"created_at"}]), body_html: azure && (v["format"] == "html" || v["format"] == 0) })
+}
+pub(super) fn comment_client() -> Result<Client,String> {
+    Client::builder().timeout(Duration::from_secs(30)).connect_timeout(Duration::from_secs(7)).redirect(reqwest::redirect::Policy::none()).build().map_err(|e|e.to_string())
+}
+#[tauri::command]
+pub async fn list_integration_issue_comments(provider:String, base_url:String, username:String, token:String, repository:String, number:u64, cursor:Option<String>) -> Result<IssueCommentPage,String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        let client=comment_client()?;
+        let mut url=comment_url(&provider,&base_url,&repository,number)?;
+        let page=if provider!="azure-devops" { cursor.as_deref().unwrap_or("1").parse::<u32>().map_err(|_|"Invalid comment page.")?.max(1) } else {1};
+        if provider=="azure-devops" {
+            url.query_pairs_mut().append_pair("$top","100").append_pair("order","asc").append_pair("includeDeleted","false");
+            if let Some(cursor)=cursor {url.query_pairs_mut().append_pair("continuationToken",&cursor);}
+        } else {url.query_pairs_mut().append_pair("page",&page.to_string()).append_pair("per_page","100").append_pair("limit","100").append_pair("sort","asc").append_pair("order_by","created_at");}
+        let response=request(&client,reqwest::Method::GET,url,&provider,&username,&token)?.send().map_err(|e|e.to_string())?;
+        if !response.status().is_success(){return Err(response_error(response,&provider));}
+        let linked_next=response.headers().get("link").and_then(|h|h.to_str().ok()).map(|s|s.contains("rel=\"next\""));
+        let value:Value=response.json().map_err(|e|e.to_string())?;
+        let items=if provider=="azure-devops" {value["comments"].as_array()}else{value.as_array()}.ok_or("Invalid comment list.")?;
+        let next_cursor=if provider=="azure-devops" {value["continuationToken"].as_str().filter(|s|!s.is_empty()).map(str::to_string)}else if linked_next.unwrap_or(items.len()==100) {Some(page.saturating_add(1).to_string())}else{None};
+        Ok(IssueCommentPage{comments:items.iter().filter_map(|v|parse_comment(v,&provider)).collect(),next_cursor})
+    }).await.map_err(|e|e.to_string())?
+}
+#[tauri::command]
+pub async fn add_integration_issue_comment(provider:String, base_url:String, username:String, token:String, repository:String, number:u64, body:String) -> Result<IssueComment,String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        if body.trim().is_empty() || body.len()>100_000 {return Err("Comment must contain between 1 and 100,000 bytes.".into());}
+        let mut url=comment_url(&provider,&base_url,&repository,number)?;
+        if provider=="azure-devops" {url.query_pairs_mut().append_pair("format","markdown");}
+        let payload=if provider=="azure-devops"{json!({"text":body})}else{json!({"body":body})};
+        let response=request(&comment_client()?,reqwest::Method::POST,url,&provider,&username,&token)?.json(&payload).send().map_err(|e|format!("Comment delivery not confirmed: {e}"))?;
+        if !response.status().is_success(){return Err(response_error(response,&provider));}
+        parse_comment(&response.json::<Value>().map_err(|e|e.to_string())?,&provider).ok_or("Invalid posted comment.".into())
+    }).await.map_err(|e|e.to_string())?
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test] fn issue_endpoints_use_issue_notes_and_encode_project_paths() {
+        assert_eq!(comment_url("gitlab","https://git.test","team/sub/repo",4).unwrap().as_str(),"https://git.test/api/v4/projects/team%2Fsub%2Frepo/issues/4/notes");
+        assert_eq!(comment_url("azure-devops","https://dev.azure.com/org","My Project",4).unwrap().path(),"/org/My%20Project/_apis/wit/workItems/4/comments");
+        assert!(comment_url("gitea","https://git.test","owner/repo/invalid",4).is_err());
+    }
+    #[test] fn comments_filter_system_entries_and_preserve_html_format() {
+        assert!(parse_comment(&json!({"system":true}),"gitlab").is_none());
+        let c=parse_comment(&json!({"commentId":7,"text":"<p>Hello</p>","format":"html","createdBy":{"displayName":"Alex"}}),"azure-devops").unwrap();
+        assert_eq!(c.id,"7"); assert!(c.body_html); assert_eq!(c.author,"Alex");
+    }
+}

src-tauri/src/integrations/issues.rs

@@ -0,0 +1,336 @@
+use super::*;
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IntegrationIssue {
+    id: String,
+    number: u64,
+    title: String,
+    description: String,
+    description_html: bool,
+    repository_name: String,
+    author: String,
+    state: String,
+    labels: Vec<String>,
+    assignees: Vec<String>,
+    web_url: String,
+    updated_at: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IssuePage {
+    issues: Vec<IntegrationIssue>,
+    next_cursor: Option<String>,
+}
+
+fn parse_issue(value: &serde_json::Value, provider: &str) -> Option<IntegrationIssue> {
+    if value.get("pull_request").is_some_and(|v| !v.is_null()) {
+        return None;
+    }
+    let gitlab = provider.starts_with("gitlab");
+    let number = value_u64(value, if gitlab { "iid" } else { "number" });
+    if number == 0 {
+        return None;
+    }
+    let reference = value_string(value, &["references", "full"]);
+    let repository_name = if gitlab {
+        reference
+            .rsplit_once('#')
+            .map(|(repo, _)| repo.to_string())
+            .unwrap_or_else(|| value_u64(value, "project_id").to_string())
+    } else {
+        let name = value_string(value, &["repository", "full_name"]);
+        if name.is_empty() {
+            github_repository_name(&value_string(value, &["repository_url"]))
+        } else {
+            name
+        }
+    };
+    Some(IntegrationIssue {
+        id: format!("{provider}:{}", value_u64(value, "id")),
+        number,
+        title: value_string(value, &["title"]),
+        description: value_string(value, &[if gitlab { "description" } else { "body" }]),
+        description_html: false,
+        repository_name,
+        author: value_string(
+            value,
+            if gitlab {
+                &["author", "username"]
+            } else {
+                &["user", "login"]
+            },
+        ),
+        state: match value_string(value, &["state"]).as_str() {
+            "opened" => "open".into(),
+            state => state.to_string(),
+        },
+        labels: value
+            .get("labels")
+            .and_then(|v| v.as_array())
+            .into_iter()
+            .flatten()
+            .filter_map(|v| {
+                v.as_str()
+                    .or_else(|| v.get("name").and_then(|n| n.as_str()))
+                    .map(str::to_string)
+            })
+            .collect(),
+        assignees: review_names(
+            value,
+            "assignees",
+            if gitlab { "username" } else { "login" },
+        ),
+        web_url: value_string(value, &[if gitlab { "web_url" } else { "html_url" }]),
+        updated_at: value_string(value, &["updated_at"]),
+    })
+}
+
+fn json_response(
+    request: reqwest::blocking::RequestBuilder,
+    provider: &str,
+) -> Result<serde_json::Value, String> {
+    let response = request
+        .send()
+        .map_err(|err| format!("Could not reach {provider}: {err}"))?;
+    if !response.status().is_success() {
+        return Err(response_error(response, provider));
+    }
+    response
+        .json()
+        .map_err(|err| format!("Invalid {provider} issue response: {err}"))
+}
+
+fn azure_issue(value: &serde_json::Value, base: &str) -> IntegrationIssue {
+    let field = |name: &str| value_string(value, &["fields", name]);
+    let number = value_u64(value, "id");
+    let assigned = value_string(value, &["fields", "System.AssignedTo", "displayName"]);
+    IntegrationIssue {
+        id: format!("azure-devops:{number}"),
+        number,
+        title: field("System.Title"),
+        description: field("System.Description"),
+        description_html: true,
+        repository_name: field("System.TeamProject"),
+        author: value_string(value, &["fields", "System.CreatedBy", "displayName"]),
+        state: field("System.State"),
+        labels: field("System.Tags")
+            .split(';')
+            .map(str::trim)
+            .filter(|s| !s.is_empty())
+            .map(str::to_string)
+            .collect(),
+        assignees: if assigned.is_empty() {
+            vec![]
+        } else {
+            vec![assigned]
+        },
+        web_url: format!("{base}/_workitems/edit/{number}"),
+        updated_at: field("System.ChangedDate"),
+    }
+}
+
+fn azure_issues(
+    client: &Client,
+    base: &str,
+    username: &str,
+    token: &str,
+    cursor: Option<u64>,
+) -> Result<IssuePage, String> {
+    let condition = cursor
+        .map(|id| format!("[System.Id] < {id}"))
+        .unwrap_or_else(|| "[System.Id] > 0".into());
+    let payload = json_response(client.post(format!("{base}/_apis/wit/wiql"))
+        .basic_auth(username, Some(token)).query(&[("api-version", "7.1"), ("$top", "101")])
+        .json(&serde_json::json!({"query": format!("SELECT [System.Id] FROM WorkItems WHERE {condition} ORDER BY [System.Id] DESC")})), "Azure DevOps")?;
+    let ids: Vec<u64> = payload
+        .get("workItems")
+        .and_then(|v| v.as_array())
+        .ok_or("Azure DevOps returned no work item list.")?
+        .iter()
+        .filter_map(|v| v.get("id").and_then(|id| id.as_u64()))
+        .collect();
+    let next_cursor = if ids.len() > 100 {
+        Some(ids[99].to_string())
+    } else {
+        None
+    };
+    if ids.is_empty() {
+        return Ok(IssuePage {
+            issues: vec![],
+            next_cursor,
+        });
+    }
+    let ids = ids
+        .iter()
+        .take(100)
+        .map(u64::to_string)
+        .collect::<Vec<_>>()
+        .join(",");
+    let payload = json_response(
+        client
+            .get(format!("{base}/_apis/wit/workitems"))
+            .basic_auth(username, Some(token))
+            .query(&[("api-version", "7.1"), ("ids", ids.as_str())]),
+        "Azure DevOps",
+    )?;
+    let mut issues: Vec<_> = payload
+        .get("value")
+        .and_then(|v| v.as_array())
+        .ok_or("Azure DevOps returned no work item details.")?
+        .iter()
+        .map(|v| azure_issue(v, base))
+        .collect();
+    issues.sort_by_key(|issue| std::cmp::Reverse(issue.number));
+    Ok(IssuePage {
+        issues,
+        next_cursor,
+    })
+}
+
+#[tauri::command]
+pub async fn list_integration_issues(
+    provider: String,
+    base_url: String,
+    username: String,
+    token: String,
+    cursor: Option<String>,
+) -> Result<IssuePage, String> {
+    tokio::time::timeout(
+        REVIEW_REQUEST_TIMEOUT,
+        tauri::async_runtime::spawn_blocking(move || {
+            if token.trim().is_empty() {
+                return Err("No token is stored for this integration.".into());
+            }
+            let cursor = cursor
+                .map(|c| {
+                    c.parse::<u64>()
+                        .map_err(|_| "Invalid issue cursor.".to_string())
+                })
+                .transpose()?;
+            let base = normalized_base_url(&base_url)?;
+            let client = client()?;
+            if provider == "azure-devops" {
+                return azure_issues(
+                    &client,
+                    &base,
+                    if username.is_empty() {
+                        "gitty"
+                    } else {
+                        &username
+                    },
+                    &token,
+                    cursor,
+                );
+            }
+            let page = cursor.unwrap_or(1).max(1).to_string();
+            let request = match provider.as_str() {
+                "github" => client
+                    .get(format!("{}/issues", github_api_base_url(&base)?))
+                    .bearer_auth(&token)
+                    .query(&[
+                        ("filter", "all"),
+                        ("state", "all"),
+                        ("sort", "created"),
+                        ("direction", "desc"),
+                        ("per_page", "100"),
+                        ("page", page.as_str()),
+                    ]),
+                "gitlab" | "gitlab-self-hosted" => client
+                    .get(format!("{base}/api/v4/issues"))
+                    .header("PRIVATE-TOKEN", &token)
+                    .query(&[
+                        ("scope", "all"),
+                        ("state", "all"),
+                        ("order_by", "created_at"),
+                        ("sort", "desc"),
+                        ("per_page", "100"),
+                        ("page", page.as_str()),
+                    ]),
+                "gitea" => client
+                    .get(format!("{base}/api/v1/repos/issues/search"))
+                    .header("Authorization", format!("token {token}"))
+                    .query(&[
+                        ("type", "issues"),
+                        ("state", "all"),
+                        ("limit", "100"),
+                        ("page", page.as_str()),
+                    ]),
+                _ => return Err("Unsupported integration provider.".into()),
+            }
+            .header(USER_AGENT, "Gitty")
+            .header(ACCEPT, "application/json");
+            let response = request
+                .send()
+                .map_err(|err| format!("Could not reach {provider}: {err}"))?;
+            if !response.status().is_success() {
+                return Err(response_error(response, &provider));
+            }
+            let linked_next = response
+                .headers()
+                .get("link")
+                .and_then(|v| v.to_str().ok())
+                .map(|v| v.contains("rel=\"next\""));
+            let values: Vec<serde_json::Value> = response
+                .json()
+                .map_err(|err| format!("Invalid issue list: {err}"))?;
+            let next_cursor = if linked_next.unwrap_or(values.len() == 100) {
+                Some(cursor.unwrap_or(1).max(1).saturating_add(1).to_string())
+            } else {
+                None
+            };
+            Ok(IssuePage {
+                issues: values
+                    .iter()
+                    .filter_map(|v| parse_issue(v, &provider))
+                    .collect(),
+                next_cursor,
+            })
+        }),
+    )
+    .await
+    .map_err(|_| "The issue API did not respond within 35 seconds.".to_string())?
+    .map_err(|err| format!("Could not load issues: {err}"))?
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    #[test]
+    fn excludes_pull_requests_and_maps_github_issues() {
+        assert!(parse_issue(&json!({"number": 2, "pull_request": {}}), "github").is_none());
+        let issue = parse_issue(&json!({"id": 4, "number": 2, "repository_url": "https://api.github.com/repos/team/app", "labels": [{"name":"bug"}], "state":"open"}), "github").unwrap();
+        assert_eq!(issue.repository_name, "team/app");
+        assert_eq!(issue.labels, ["bug"]);
+    }
+    #[test]
+    fn maps_both_gitlab_variants_and_gitea() {
+        for provider in ["gitlab", "gitlab-self-hosted"] {
+            let issue = parse_issue(&json!({"id": 8,"iid": 3,"references":{"full":"team/app#3"},"state":"opened","labels":["bug"]}), provider).unwrap();
+            assert_eq!(issue.repository_name, "team/app");
+            assert_eq!(issue.state, "open");
+        }
+        let issue = parse_issue(
+            &json!({"id":9,"number":4,"repository":{"full_name":"team/app"},"pull_request":null}),
+            "gitea",
+        )
+        .unwrap();
+        assert_eq!(issue.repository_name, "team/app");
+    }
+    #[test]
+    fn preserves_custom_azure_states_and_project_identity() {
+        let issue = azure_issue(
+            &json!({"id":42,"fields":{"System.State":"Ready for QA","System.TeamProject":"Project","System.Tags":"bug; urgent"}}),
+            "https://dev.azure.com/org",
+        );
+        assert_eq!(issue.state, "Ready for QA");
+        assert_eq!(issue.repository_name, "Project");
+        assert_eq!(issue.labels, ["bug", "urgent"]);
+        assert_eq!(
+            issue.web_url,
+            "https://dev.azure.com/org/_workitems/edit/42"
+        );
+    }
+}

src-tauri/src/main.rs

@@ -1,55 +1,430 @@
 #![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
 
+mod badge;
+mod external_tools;
 mod git;
+mod integrations;
+mod telemetry;
 
-use git::{
-    SearchCancellationState, apply_file_patch, cancel_code_search, cancel_file_history,
-    checkout_branch, commit, commit_ai_generate, commit_ai_load, commit_ai_local_models,
-    commit_ai_status, compare_commits, compare_file_to_head, compare_file_to_parent,
-    create_branch, cred_delete, cred_load, cred_save, delete_branch,
-    diff_file_against_working_tree, get_file_patch, get_remote_url, get_status, list_branches,
-    list_commits, list_file_history, list_repository_files, merge_branch, open_repo_in_explorer,
-    open_repository, open_repository_bundle, open_repository_file, pull, push, read_conflict,
-    rename_branch, resolve_conflict, resolve_conflict_side, restore_file_from_commit,
-    restore_files, restore_to_commit, search_code_introductions, stage_files, unstage_files,
+use badge::set_sync_badge;
+use external_tools::{
+    detect_external_tools, launch_external_diff, launch_external_merge, launch_external_tool,
 };
+use git::{
+    SearchCancellationState, add_remote, add_to_gitignore, add_worktree, amend_commit,
+    apply_file_patch, cancel_code_search, cancel_file_history, checkout_branch, cherry_pick_abort,
+    cherry_pick_commit, cherry_pick_continue, clone_repository, commit, commit_ai_generate,
+    commit_ai_review, commit_ai_split, compare_commits, compare_file_to_head,
+    compare_file_to_parent, create_branch, create_tag, cred_delete, cred_load, cred_save,
+    delete_branch, delete_commit_note, delete_remote_branch, delete_remote_branches, delete_tag,
+    diff_file_against_working_tree, fetch, fetch_commit_notes, get_bisect_state, get_commit_note,
+    get_file_blame, get_file_patch, get_remote_url, get_status, git_lfs_install, git_lfs_prune,
+    git_lfs_pull, git_lfs_status, git_lfs_track, git_lfs_untrack, init_repository,
+    last_commit_message, list_branches, list_commits, list_file_history,
+    list_interactive_rebase_commits, list_reflog, list_remotes, list_repository_files,
+    list_stashes, list_tags, list_worktrees, lock_worktree, mark_bisect, merge_abort, merge_branch,
+    merge_continue, move_worktree, open_repo_in_explorer, open_repository, open_repository_bundle,
+    open_repository_file, prune_worktrees, pull, push, push_commit_notes, push_tag, read_conflict,
+    rebase_abort, rebase_branch, rebase_continue, remove_remote, remove_worktree, rename_branch,
+    rename_remote_branch, repair_worktree, reset_bisect, resolve_conflict, resolve_conflict_side,
+    restore_file_from_commit, restore_files, restore_reflog_entry, restore_to_commit,
+    revert_commit, run_sequence_editor_if_requested, search_code_introductions,
+    set_branch_upstream, set_commit_note, stage_files, start_bisect, start_interactive_rebase,
+    stash_apply, stash_drop, stash_pop, stash_push, undo_last_commit, unlock_worktree,
+    unstage_files, untrack_paths, update_remote,
+};
+use integrations::{
+    create_integration_review_request, list_integration_repository_branches,
+    add_integration_review_comment, get_integration_review_details, list_integration_repositories, list_integration_review_requests, open_in_browser,
+    run_integration_review_action, list_integration_issues, get_integration_board, list_integration_boards, move_integration_board_card, list_integration_issue_comments, add_integration_issue_comment, close_integration_issue,
+};
+use std::path::{Path, PathBuf};
+use std::sync::Mutex;
+use tauri::{Emitter, Manager};
+use telemetry::{emit_frontend_log, emit_frontend_span, set_telemetry_enabled};
 
-fn main() {
-    tauri::Builder::default()
-        .plugin(tauri_plugin_updater::Builder::new().build())
+struct StartupRepository(Mutex<Option<String>>);
+
+#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+struct StartupCloneRequest {
+    remote_url: String,
+    parent_path: String,
+    directory_name: String,
+}
+
+struct StartupClone(Mutex<Option<StartupCloneRequest>>);
+
+fn resolve_startup_path(path: &str, cwd: &Path) -> Option<PathBuf> {
+    let path = path.trim();
+    if path.is_empty() {
+        return None;
+    }
+    let path = PathBuf::from(path);
+    Some(if path.is_absolute() {
+        path
+    } else {
+        cwd.join(path)
+    })
+}
+
+fn clone_request_from_args(
+    args: impl IntoIterator<Item = String>,
+    cwd: &Path,
+) -> Option<StartupCloneRequest> {
+    let mut args = args.into_iter();
+
+    while let Some(arg) = args.next() {
+        let remote_url = if arg == "clone" || arg == "--clone" {
+            args.next()
+        } else {
+            arg.strip_prefix("--clone=").map(ToString::to_string)
+        };
+        let Some(remote_url) = remote_url.filter(|value| !value.trim().is_empty()) else {
+            continue;
+        };
+        let target = resolve_startup_path(&args.next()?, cwd)?;
+        let directory_name = target.file_name()?.to_string_lossy().trim().to_string();
+        let parent_path = target.parent()?.to_string_lossy().into_owned();
+        if directory_name.is_empty() || parent_path.trim().is_empty() {
+            return None;
+        }
+        return Some(StartupCloneRequest {
+            remote_url,
+            parent_path,
+            directory_name,
+        });
+    }
+
+    None
+}
+
+fn repository_path_from_args(args: impl IntoIterator<Item = String>, cwd: &Path) -> Option<String> {
+    let mut args = args.into_iter();
+    let mut repository = None;
+
+    while let Some(arg) = args.next() {
+        if arg == "clone" || arg == "--clone" || arg.starts_with("--clone=") {
+            return None;
+        }
+        if arg == "--repo" {
+            repository = args.next();
+            break;
+        }
+        if let Some(path) = arg.strip_prefix("--repo=") {
+            repository = Some(path.to_string());
+            break;
+        }
+        if !arg.starts_with('-') {
+            repository = Some(arg);
+            break;
+        }
+    }
+
+    repository
+        .and_then(|path| resolve_startup_path(&path, cwd))
+        .map(|path| path.to_string_lossy().into_owned())
+}
+
+#[cfg(test)]
+mod startup_repository_tests {
+    use super::{clone_request_from_args, repository_path_from_args};
+    use std::path::Path;
+
+    #[test]
+    fn accepts_direct_relative_repository_path() {
+        let path =
+            repository_path_from_args(["projects/repo".to_string()], Path::new("/home/user"));
+        assert_eq!(
+            path.map(|value| value.replace('\\', "/")),
+            Some("/home/user/projects/repo".to_string())
+        );
+    }
+
+    #[test]
+    fn accepts_repo_option() {
+        let path = repository_path_from_args(
+            ["--repo".to_string(), "/projects/repo".to_string()],
+            Path::new("/home/user"),
+        );
+        assert_eq!(path.as_deref(), Some("/projects/repo"));
+    }
+
+    #[test]
+    fn accepts_repo_equals_option() {
+        let path = repository_path_from_args(
+            ["--repo=projects/repo".to_string()],
+            Path::new("/home/user"),
+        );
+        assert_eq!(
+            path.map(|value| value.replace('\\', "/")),
+            Some("/home/user/projects/repo".to_string())
+        );
+    }
+
+    #[test]
+    fn accepts_clone_command_with_exact_relative_target() {
+        let request = clone_request_from_args(
+            [
+                "clone".to_string(),
+                "https://example.com/team/project.git".to_string(),
+                "clones/local-copy".to_string(),
+            ],
+            Path::new("/home/user"),
+        )
+        .expect("clone request should be parsed");
+
+        assert_eq!(request.remote_url, "https://example.com/team/project.git");
+        assert_eq!(request.directory_name, "local-copy");
+        assert_eq!(request.parent_path.replace('\\', "/"), "/home/user/clones");
+    }
+
+    #[test]
+    fn accepts_clone_option_and_clone_equals_option() {
+        for args in [
+            vec![
+                "--clone".to_string(),
+                "git@example.com:team/project.git".to_string(),
+                "/projects/project".to_string(),
+            ],
+            vec![
+                "--clone=git@example.com:team/project.git".to_string(),
+                "/projects/project".to_string(),
+            ],
+        ] {
+            let request = clone_request_from_args(args, Path::new("/home/user"))
+                .expect("clone option should be parsed");
+            assert_eq!(request.directory_name, "project");
+            assert_eq!(request.parent_path.replace('\\', "/"), "/projects");
+        }
+    }
+
+    #[test]
+    fn repository_parser_does_not_treat_clone_values_as_repository_paths() {
+        let path = repository_path_from_args(
+            [
+                "--clone".to_string(),
+                "https://example.com/team/project.git".to_string(),
+                "clones/project".to_string(),
+            ],
+            Path::new("/home/user"),
+        );
+        assert!(path.is_none());
+    }
+}
+
+#[tauri::command]
+fn take_startup_repository(state: tauri::State<'_, StartupRepository>) -> Option<String> {
+    state.0.lock().ok()?.take()
+}
+
+#[tauri::command]
+fn take_startup_clone(state: tauri::State<'_, StartupClone>) -> Option<StartupCloneRequest> {
+    state.0.lock().ok()?.take()
+}
+
+struct ConsoleLogger;
+
+impl log::Log for ConsoleLogger {
+    fn enabled(&self, metadata: &log::Metadata<'_>) -> bool {
+        metadata.level() <= log::Level::Info
+    }
+
+    fn log(&self, record: &log::Record<'_>) {
+        if self.enabled(record.metadata()) {
+            eprintln!(
+                "[{}] [{}] {}",
+                record.level(),
+                record.target(),
+                record.args()
+            );
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+static CONSOLE_LOGGER: ConsoleLogger = ConsoleLogger;
+
+fn init_console_logging() {
+    if log::set_logger(&CONSOLE_LOGGER).is_ok() {
+        log::set_max_level(log::LevelFilter::Info);
+        log::info!(target: "gitty", "Rust console logging initialized");
+    }
+}
+
+#[tauri::command]
+fn close_splashscreen(app: tauri::AppHandle) -> Result<(), String> {
+    if let Some(window) = app.get_webview_window("splashscreen") {
+        let _ = window.hide();
+        window
+            .destroy()
+            .map_err(|error| format!("failed to destroy splashscreen: {error}"))?;
+    }
+
+    if let Some(window) = app.get_webview_window("main") {
+        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() {
+    init_console_logging();
+    telemetry::init();
+    if let Some(result) = run_sequence_editor_if_requested() {
+        if let Err(error) = result {
+            eprintln!("{error}");
+            std::process::exit(1);
+        }
+        return;
+    }
+
+    let startup_args: Vec<String> = std::env::args().skip(1).collect();
+    let startup_cwd = std::env::current_dir().unwrap_or_default();
+    let startup_clone = clone_request_from_args(startup_args.clone(), &startup_cwd);
+    let startup_repository = repository_path_from_args(startup_args, &startup_cwd);
+
+    let builder = tauri::Builder::default()
+        .plugin(tauri_plugin_single_instance::init(|app, args, cwd| {
+            let args: Vec<String> = args.into_iter().skip(1).collect();
+            if let Some(request) = clone_request_from_args(args.clone(), Path::new(&cwd)) {
+                if let Ok(mut pending) = app.state::<StartupClone>().0.lock() {
+                    *pending = Some(request);
+                }
+                let _ = app.emit("open-startup-repository", ());
+            } else if let Some(path) = repository_path_from_args(args, Path::new(&cwd)) {
+                if let Ok(mut pending) = app.state::<StartupRepository>().0.lock() {
+                    *pending = Some(path);
+                }
+                let _ = app.emit("open-startup-repository", ());
+            }
+            #[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(StartupRepository(Mutex::new(startup_repository)))
+        .manage(StartupClone(Mutex::new(startup_clone)))
         .manage(SearchCancellationState::default())
-        .manage(commit_ai::CommitAiEngine::new())
-        .plugin(tauri_plugin_dialog::init())
+        .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,
+            init_repository,
+            clone_repository,
             open_repo_in_explorer,
             open_repository_file,
+            detect_external_tools,
+            launch_external_tool,
+            launch_external_diff,
+            launch_external_merge,
             get_status,
+            git_lfs_status,
+            git_lfs_install,
+            git_lfs_track,
+            git_lfs_untrack,
+            git_lfs_pull,
+            git_lfs_prune,
             list_branches,
+            list_remotes,
+            add_remote,
+            update_remote,
+            remove_remote,
+            set_branch_upstream,
+            delete_remote_branch,
+            delete_remote_branches,
+            list_stashes,
             checkout_branch,
             create_branch,
             rename_branch,
+            rename_remote_branch,
             delete_branch,
+            list_worktrees,
+            add_worktree,
+            remove_worktree,
+            move_worktree,
+            lock_worktree,
+            unlock_worktree,
+            prune_worktrees,
+            repair_worktree,
+            list_tags,
+            create_tag,
+            delete_tag,
+            push_tag,
+            cherry_pick_commit,
+            cherry_pick_continue,
+            cherry_pick_abort,
             stage_files,
             unstage_files,
+            add_to_gitignore,
+            untrack_paths,
+            stash_push,
+            stash_apply,
+            stash_pop,
+            stash_drop,
             restore_files,
             get_file_patch,
             apply_file_patch,
             commit,
-            commit_ai_status,
-            commit_ai_load,
-            commit_ai_local_models,
+            amend_commit,
+            undo_last_commit,
+            last_commit_message,
             commit_ai_generate,
+            commit_ai_review,
+            commit_ai_split,
             pull,
             push,
+            fetch,
             list_commits,
+            get_commit_note,
+            set_commit_note,
+            delete_commit_note,
+            fetch_commit_notes,
+            push_commit_notes,
             restore_to_commit,
             restore_file_from_commit,
             merge_branch,
+            merge_continue,
+            merge_abort,
+            revert_commit,
+            rebase_branch,
+            rebase_continue,
+            rebase_abort,
+            list_interactive_rebase_commits,
+            start_interactive_rebase,
+            list_reflog,
+            restore_reflog_entry,
+            get_bisect_state,
+            start_bisect,
+            mark_bisect,
+            reset_bisect,
             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,
@@ -62,7 +437,29 @@ fn main() {
             get_remote_url,
             cred_load,
             cred_save,
-            cred_delete
+            cred_delete,
+            list_integration_repository_branches,
+            create_integration_review_request,
+            list_integration_repositories,
+            list_integration_review_requests,
+            list_integration_issues,
+            get_integration_board,
+            list_integration_boards,
+            move_integration_board_card,
+            list_integration_issue_comments,
+            add_integration_issue_comment,
+            close_integration_issue,
+            get_integration_review_details,
+            add_integration_review_comment,
+            run_integration_review_action,
+            open_in_browser,
+            set_sync_badge,
+            close_splashscreen,
+            set_telemetry_enabled,
+            emit_frontend_log,
+            emit_frontend_span,
+            take_startup_repository,
+            take_startup_clone
         ])
         .run(tauri::generate_context!())
         .expect("error while running tauri application");

src-tauri/src/telemetry.rs

@@ -0,0 +1,363 @@
+use std::{
+    sync::{
+        OnceLock,
+        atomic::{AtomicBool, Ordering},
+        mpsc::{SyncSender, sync_channel},
+    },
+    time::{Duration, SystemTime, UNIX_EPOCH},
+};
+
+use serde::Deserialize;
+use serde_json::json;
+
+const DEFAULT_OTLP_LOGS_ENDPOINT: &str = "https://telemetry.cbsk-tech.de/v1/logs";
+const DEFAULT_OTLP_TRACES_ENDPOINT: &str = "https://telemetry.cbsk-tech.de/v1/traces";
+const DEFAULT_OTLP_METRICS_ENDPOINT: &str = "https://telemetry.cbsk-tech.de/v1/metrics";
+const METRICS_INTERVAL: Duration = Duration::from_secs(30);
+const MAX_BODY_BYTES: usize = 2_048;
+
+static ENABLED: AtomicBool = AtomicBool::new(false);
+static SENDER: OnceLock<SyncSender<TelemetrySignal>> = OnceLock::new();
+
+#[derive(Debug)]
+enum TelemetrySignal {
+    Log(TelemetryRecord),
+    Span(FrontendSpan),
+    Metrics(ProcessMetrics),
+}
+
+#[derive(Debug)]
+struct ProcessMetrics {
+    cpu_utilization: f64,
+    memory_bytes: u64,
+}
+
+#[derive(Debug)]
+struct TelemetryRecord {
+    severity: &'static str,
+    severity_number: u8,
+    body: String,
+    event_name: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendLog {
+    level: String,
+    message: String,
+    event_name: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FrontendSpan {
+    name: String,
+    trace_id: String,
+    span_id: String,
+    started_at_ms: u64,
+    duration_ms: f64,
+    success: bool,
+}
+
+pub fn init() {
+    let endpoint = std::env::var("GITTY_OTLP_LOGS_ENDPOINT")
+        .unwrap_or_else(|_| DEFAULT_OTLP_LOGS_ENDPOINT.to_string());
+    let traces_endpoint = std::env::var("GITTY_OTLP_TRACES_ENDPOINT")
+        .unwrap_or_else(|_| DEFAULT_OTLP_TRACES_ENDPOINT.to_string());
+    let metrics_endpoint = std::env::var("GITTY_OTLP_METRICS_ENDPOINT")
+        .unwrap_or_else(|_| DEFAULT_OTLP_METRICS_ENDPOINT.to_string());
+    let (sender, receiver) = sync_channel::<TelemetrySignal>(256);
+    if SENDER.set(sender.clone()).is_err() {
+        return;
+    }
+
+    start_process_metrics(sender);
+
+    std::thread::Builder::new()
+        .name("gitty-telemetry".into())
+        .spawn(move || {
+            let client = match reqwest::blocking::Client::builder()
+                .timeout(Duration::from_secs(5))
+                .build()
+            {
+                Ok(client) => client,
+                Err(error) => {
+                    eprintln!("[WARN] [gitty::telemetry] could not create OTLP client: {error}");
+                    return;
+                }
+            };
+
+            let mut export_warning_shown = false;
+            while let Ok(signal) = receiver.recv() {
+                let (target_endpoint, payload) = match signal {
+                    TelemetrySignal::Log(record) => (&endpoint, log_payload(record)),
+                    TelemetrySignal::Span(span) => (&traces_endpoint, span_payload(span)),
+                    TelemetrySignal::Metrics(metrics) => {
+                        (&metrics_endpoint, metrics_payload(metrics))
+                    }
+                };
+                export(
+                    &client,
+                    target_endpoint,
+                    &payload,
+                    &mut export_warning_shown,
+                );
+            }
+        })
+        .expect("failed to start telemetry worker");
+}
+
+fn start_process_metrics(sender: SyncSender<TelemetrySignal>) {
+    std::thread::Builder::new()
+        .name("gitty-process-metrics".into())
+        .spawn(move || {
+            use sysinfo::{ProcessRefreshKind, ProcessesToUpdate, System};
+
+            let Ok(pid) = sysinfo::get_current_pid() else {
+                return;
+            };
+            let refresh_kind = ProcessRefreshKind::nothing().with_cpu().with_memory();
+            let cpu_count = std::thread::available_parallelism()
+                .map(|count| count.get())
+                .unwrap_or(1) as f64;
+            let mut system = System::new();
+            let mut primed = false;
+
+            loop {
+                std::thread::sleep(METRICS_INTERVAL);
+                if !ENABLED.load(Ordering::Relaxed) {
+                    primed = false;
+                    continue;
+                }
+                system.refresh_processes_specifics(
+                    ProcessesToUpdate::Some(&[pid]),
+                    true,
+                    refresh_kind,
+                );
+                let Some(process) = system.process(pid) else {
+                    continue;
+                };
+                if !primed {
+                    primed = true;
+                    continue;
+                }
+                let metrics = ProcessMetrics {
+                    cpu_utilization: (f64::from(process.cpu_usage()) / (100.0 * cpu_count))
+                        .clamp(0.0, 1.0),
+                    memory_bytes: process.memory(),
+                };
+                let _ = sender.try_send(TelemetrySignal::Metrics(metrics));
+            }
+        })
+        .expect("failed to start process metrics worker");
+}
+
+fn resource_attributes() -> serde_json::Value {
+    json!([
+        { "key": "service.name", "value": { "stringValue": "gitty-desktop" } },
+        { "key": "service.version", "value": { "stringValue": env!("CARGO_PKG_VERSION") } },
+        { "key": "deployment.environment.name", "value": { "stringValue": if cfg!(debug_assertions) { "development" } else { "production" } } },
+        { "key": "os.type", "value": { "stringValue": std::env::consts::OS } },
+        { "key": "host.arch", "value": { "stringValue": std::env::consts::ARCH } }
+    ])
+}
+
+fn log_payload(record: TelemetryRecord) -> serde_json::Value {
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos()
+        .to_string();
+    let mut attributes = vec![json!({
+        "key": "telemetry.sdk.language",
+        "value": { "stringValue": "rust" }
+    })];
+    if let Some(event_name) = record.event_name {
+        attributes.push(json!({
+            "key": "event.name",
+            "value": { "stringValue": event_name }
+        }));
+    }
+    let payload = json!({
+        "resourceLogs": [{
+            "resource": { "attributes": resource_attributes() },
+            "scopeLogs": [{
+                "scope": { "name": "gitty.telemetry" },
+                "logRecords": [{
+                    "timeUnixNano": timestamp,
+                    "observedTimeUnixNano": timestamp,
+                    "severityNumber": record.severity_number,
+                    "severityText": record.severity,
+                    "body": { "stringValue": record.body },
+                    "attributes": attributes
+                }]
+            }]
+        }]
+    });
+    payload
+}
+
+fn span_payload(mut span: FrontendSpan) -> serde_json::Value {
+    if span.name.len() > 128 {
+        span.name.truncate(128);
+    }
+    let start = u128::from(span.started_at_ms) * 1_000_000;
+    let duration = (span.duration_ms.max(0.0) * 1_000_000.0) as u128;
+    let attributes = vec![
+        json!({ "key": "rpc.system", "value": { "stringValue": "tauri" } }),
+        json!({ "key": "rpc.method", "value": { "stringValue": span.name } }),
+    ];
+    json!({
+        "resourceSpans": [{
+            "resource": { "attributes": resource_attributes() },
+            "scopeSpans": [{
+                "scope": { "name": "gitty.tauri", "version": env!("CARGO_PKG_VERSION") },
+                "spans": [{
+                    "traceId": span.trace_id,
+                    "spanId": span.span_id,
+                    "name": format!("tauri.{}", span.name),
+                    "kind": 1,
+                    "startTimeUnixNano": start.to_string(),
+                    "endTimeUnixNano": (start + duration).to_string(),
+                    "attributes": attributes,
+                    "status": {
+                        "code": if span.success { 1 } else { 2 },
+                        "message": if span.success { "" } else { "Tauri command failed" }
+                    }
+                }]
+            }]
+        }]
+    })
+}
+
+fn metrics_payload(metrics: ProcessMetrics) -> serde_json::Value {
+    let timestamp = SystemTime::now()
+        .duration_since(UNIX_EPOCH)
+        .unwrap_or_default()
+        .as_nanos()
+        .to_string();
+    json!({
+        "resourceMetrics": [{
+            "resource": { "attributes": resource_attributes() },
+            "scopeMetrics": [{
+                "scope": { "name": "gitty.process", "version": env!("CARGO_PKG_VERSION") },
+                "metrics": [
+                    {
+                        "name": "process.cpu.utilization",
+                        "description": "Normalized CPU utilization of the Gitty process",
+                        "unit": "1",
+                        "gauge": { "dataPoints": [{
+                            "timeUnixNano": timestamp,
+                            "asDouble": metrics.cpu_utilization,
+                            "attributes": []
+                        }] }
+                    },
+                    {
+                        "name": "process.memory.usage",
+                        "description": "Resident memory used by the Gitty process",
+                        "unit": "By",
+                        "gauge": { "dataPoints": [{
+                            "timeUnixNano": timestamp,
+                            "asInt": metrics.memory_bytes.to_string(),
+                            "attributes": []
+                        }] }
+                    }
+                ]
+            }]
+        }]
+    })
+}
+
+fn export(
+    client: &reqwest::blocking::Client,
+    endpoint: &str,
+    payload: &serde_json::Value,
+    export_warning_shown: &mut bool,
+) {
+    match client.post(endpoint).json(payload).send() {
+        Ok(response) if response.status().is_success() => {
+            if response
+                .headers()
+                .get(reqwest::header::CONTENT_TYPE)
+                .and_then(|value| value.to_str().ok())
+                .is_some_and(|value| value.starts_with("text/html"))
+                && !*export_warning_shown
+            {
+                eprintln!(
+                    "[WARN] [gitty::telemetry] OTLP endpoint returned HTML; configure the collector endpoint with GITTY_OTLP_LOGS_ENDPOINT"
+                );
+                *export_warning_shown = true;
+            }
+        }
+        Ok(response) if !*export_warning_shown => {
+            eprintln!(
+                "[WARN] [gitty::telemetry] OTLP export failed with status {}",
+                response.status()
+            );
+            *export_warning_shown = true;
+        }
+        Err(error) if !*export_warning_shown => {
+            eprintln!("[WARN] [gitty::telemetry] OTLP export failed: {error}");
+            *export_warning_shown = true;
+        }
+        _ => {}
+    }
+}
+
+fn emit(record: TelemetryRecord) {
+    if !ENABLED.load(Ordering::Relaxed) {
+        return;
+    }
+    if let Some(sender) = SENDER.get() {
+        let _ = sender.try_send(TelemetrySignal::Log(record));
+    }
+}
+
+#[tauri::command]
+pub fn set_telemetry_enabled(enabled: bool) {
+    ENABLED.store(enabled, Ordering::Relaxed);
+    if enabled {
+        emit(TelemetryRecord {
+            severity: "INFO",
+            severity_number: 9,
+            body: "Telemetry enabled".into(),
+            event_name: Some("telemetry.enabled".into()),
+        });
+    }
+}
+
+#[tauri::command]
+pub fn emit_frontend_log(log: FrontendLog) {
+    let (severity, severity_number) = match log.level.as_str() {
+        "error" => ("ERROR", 17),
+        "warn" => ("WARN", 13),
+        _ => ("INFO", 9),
+    };
+    let mut body = log.message;
+    if body.len() > MAX_BODY_BYTES {
+        body.truncate(MAX_BODY_BYTES);
+    }
+    emit(TelemetryRecord {
+        severity,
+        severity_number,
+        body,
+        event_name: log.event_name,
+    });
+}
+
+#[tauri::command]
+pub fn emit_frontend_span(span: FrontendSpan) {
+    if !ENABLED.load(Ordering::Relaxed) {
+        return;
+    }
+    if span.trace_id.len() != 32
+        || span.span_id.len() != 16
+        || !span.trace_id.bytes().all(|byte| byte.is_ascii_hexdigit())
+        || !span.span_id.bytes().all(|byte| byte.is_ascii_hexdigit())
+    {
+        return;
+    }
+    if let Some(sender) = SENDER.get() {
+        let _ = sender.try_send(TelemetrySignal::Span(span));
+    }
+}

src-tauri/tauri.conf.json

@@ -1,25 +1,38 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
-  "productName": "GitLite",
-  "version": "2026.7.7",
-  "identifier": "com.git-lite",
+  "productName": "Gitty",
+  "version": "2026.9.3",
+  "identifier": "com.gitty",
   "build": {
-    "beforeDevCommand": "npm run dev",
+    "beforeDevCommand": "npm run prepare:lfs && npm run dev",
     "devUrl": "http://127.0.0.1:1420",
-    "beforeBuildCommand": "npm run build",
+    "beforeBuildCommand": "npm run prepare:lfs && npm run build",
     "frontendDist": "../dist"
   },
   "app": {
     "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,19 +41,36 @@
   },
   "bundle": {
     "active": true,
-    "targets": ["nsis"],
-    "icon": ["icons/icon.ico"],
+    "externalBin": [
+      "binaries/git-lfs"
+    ],
+    "resources": [
+      "binaries/git-lfs-LICENSE.txt"
+    ],
+    "targets": [
+      "nsis"
+    ],
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ],
     "createUpdaterArtifacts": true,
     "windows": {
       "nsis": {
-        "installMode": "currentUser"
+        "installMode": "currentUser",
+        "installerIcon": "icons/icon.ico",
+        "installerHooks": "nsis-hooks.nsh"
       }
     }
   },
   "plugins": {
     "updater": {
       "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IDdDNEJGRTZERTREOTc5QjkKUldTNWVkbmtiZjVMZk02YzdpenVLOVltREJpRkFrc2F4dUwzaTV5M3pacFRVR0tmd25xSGtjK1MK",
-      "endpoints" : [
+      "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"]
+  }
+}