v0.1.0-alpha

.claude/settings.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npm view *)",
+      "Bash(npm search *)"
+    ]
+  }
+}

.github/workflows/ci.yml

@@ -111,23 +111,29 @@ jobs:
                 per_page: 100,
               });
               const artifactByName = new Map(artifacts.map((artifact) => [artifact.name, artifact]));
+              const fmtSize = (bytes) => `${(bytes / 1_048_576).toFixed(1)} MB`;
+              const fmtDate = (iso) => {
+                const d = new Date(iso);
+                return d.toISOString().replace('T', ' ').slice(0, 16) + ' UTC';
+              };
               const artifactLines = artifactNames.map((name) => {
                 const artifact = artifactByName.get(name);
                 const label = name.replace('gitpilot-', '');
                 if (!artifact) {
-                  return `- ${label}: \`${name}\` (open [workflow run](${runUrl}) to download)`;
+                  return `- **${label}**: \`${name}\` — (open [workflow run](${runUrl}) to download)`;
                 }
                 const artifactUrl = `${runUrl}/artifacts/${artifact.id}`;
-                return `- ${label}: [\`${name}\`](${artifactUrl})`;
+                const size = fmtSize(artifact.size_in_bytes);
+                const updated = fmtDate(artifact.updated_at);
+                return `- **${label}**: [\`${name}\`](${artifactUrl}) — ${size} · updated ${updated}`;
               });
 
+              const now = new Date().toISOString().replace('T', ' ').slice(0, 16) + ' UTC';
               const body = [
                 marker,
                 '### GitPilot build artifacts are ready',
                 '',
-                `One CI workflow run built all 3 desktop apps: [open workflow run](${runUrl}).`,
-                '',
-                'Download links:',
+                `Built all 3 desktop apps — [workflow run](${runUrl}) · _last updated ${now}_`,
                 '',
                 ...artifactLines,
               ].join('\n');

.github/workflows/release.yml

@@ -0,0 +1,114 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release:
+    permissions:
+      contents: write
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - platform: windows-latest
+            args: '--target x86_64-pc-windows-msvc'
+          - platform: macos-latest
+            args: '--target aarch64-apple-darwin'
+          - platform: macos-latest
+            args: '--target x86_64-apple-darwin'
+          - platform: ubuntu-22.04
+            args: ''
+
+    runs-on: ${{ matrix.platform }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Detect pre-release
+        id: meta
+        shell: bash
+        run: |
+          TAG="${{ github.ref_name }}"
+          VERSION="${TAG#v}"
+          # MSI requires numeric-only pre-release — strip suffix for bundle version
+          APP_VERSION="${VERSION%%-*}"
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "app_version=$APP_VERSION" >> $GITHUB_OUTPUT
+          if [[ "$TAG" =~ -(alpha|beta|rc) ]]; then
+            echo "prerelease=true" >> $GITHUB_OUTPUT
+          else
+            echo "prerelease=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Sync version into tauri.conf.json
+        shell: bash
+        run: |
+          node -e "
+            const fs = require('fs');
+            const p = 'src-tauri/tauri.conf.json';
+            const c = JSON.parse(fs.readFileSync(p, 'utf8'));
+            c.version = '${{ steps.meta.outputs.app_version }}';
+            fs.writeFileSync(p, JSON.stringify(c, null, 2) + '\n');
+          "
+
+      - name: Install dependencies (Ubuntu)
+        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:
+          node-version: 20
+          cache: npm
+
+      - name: Setup Rust
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.platform == 'macos-latest' && 'aarch64-apple-darwin,x86_64-apple-darwin' || '' }}
+
+      - name: Rust cache
+        uses: swatinem/rust-cache@v2
+        with:
+          workspaces: ./src-tauri -> target
+
+      - name: Install frontend deps
+        run: npm install
+
+      - name: Build & release
+        uses: tauri-apps/tauri-action@v0
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
+          TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
+        with:
+          tagName: ${{ github.ref_name }}
+          releaseName: 'GitPilot ${{ github.ref_name }}'
+          releaseBody: |
+            See the assets below to download and install this version of GitPilot.
+          releaseDraft: false
+          prerelease: ${{ steps.meta.outputs.prerelease }}
+          args: ${{ matrix.args }}
+          includeUpdaterJson: true
+
+      # For pre-releases: push latest.json to beta-channel so beta users get update notifications.
+      - name: Publish to beta-channel (pre-release only, one runner)
+        if: steps.meta.outputs.prerelease == 'true' && matrix.platform == 'ubuntu-22.04'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          gh release download ${{ github.ref_name }} --pattern latest.json --output /tmp/latest.json
+
+          if gh release view beta-channel &>/dev/null; then
+            gh release upload beta-channel /tmp/latest.json --clobber
+          else
+            gh release create beta-channel /tmp/latest.json \
+              --title "Beta Channel (auto-updated)" \
+              --notes "This release is automatically updated to the latest pre-release build. Do not install manually — use the in-app update system." \
+              --prerelease
+          fi

CONTRIBUTING.md

@@ -0,0 +1,73 @@
+# Contributing to GitPilot
+
+## Stack
+
+- **Frontend**: React 18, TypeScript, Tailwind CSS, Zustand, Monaco Editor
+- **Backend**: Tauri v2, Rust (`std::process::Command` — no shell strings for git operations)
+- **Build**: Vite
+
+## Setup
+
+```bash
+npm install
+npm run tauri dev
+```
+
+## Build
+
+```bash
+npm run tauri build
+```
+
+## Project layout
+
+```
+src/
+  components/      React UI components
+  store/           Zustand store (gitStore.ts)
+  services/        IPC wrappers (gitService.ts)
+  types/           Shared TypeScript types (git.ts)
+  utils/           Helpers (repoConfig, etc.)
+
+src-tauri/
+  src/commands/    Tauri commands exposed to frontend
+  src/services/    Rust git service logic
+  src/models/      Serde models (git.rs, settings.rs)
+```
+
+## Store shape
+
+| Field | Type | Purpose |
+| --- | --- | --- |
+| `busy` | `boolean` | Any operation in flight |
+| `refreshing` | `boolean` | Explicit refresh only (drives Refresh button spinner) |
+| `runningOp` | `string \| null` | Label of active operation (drives per-button spinners) |
+| `undoStack` | `UndoEntry[]` | Undo history, max 20 entries |
+| `redoStack` | `UndoEntry[]` | Redo history |
+
+### `run(label, fn, refreshMode?, undoable?)`
+
+Sets `busy + runningOp`, calls `fn`, optionally pushes to undo stack, then calls `refresh(silent=true)`.
+
+### `refresh(silent?)`
+
+`silent=true` skips the `refreshing` flag so the Refresh button spinner does not fire during background refreshes triggered by `run()`.
+
+## Commit graph virtualization
+
+`GitGraph` uses a `ResizeObserver` attached via a **callback ref** (`useState` + `useCallback`) so the observer re-registers whenever the list DOM element mounts or changes. `svgH = rows.length * ROW_H + ROW_H` adds a one-row buffer so lane lines of the last loaded commit do not clip at the SVG boundary.
+
+## Release process
+
+Tags matching `v*` trigger the GitHub Actions release workflow:
+
+- Detects pre-release from tag suffix (`-alpha`, `-beta`, `-rc`)
+- Syncs version from tag into `tauri.conf.json`
+- Builds for Windows x64, macOS arm64, macOS x64, Linux
+- `includeUpdaterJson: true` on all builds
+- Alpha builds push `latest.json` to the permanent `alpha-channel` release via `gh release upload --clobber`
+
+Update channels:
+
+- **Stable**: `releases/latest/download/latest.json`
+- **Alpha**: `releases/download/alpha-channel/latest.json`

README.md

@@ -1,49 +1,79 @@
 # GitPilot
 
-GitPilot is a desktop Git GUI client built with Tauri v2, Rust, React, TypeScript, Tailwind CSS, Zustand, and Monaco Editor.
+A desktop Git GUI client built with Tauri v2 + Rust + React.
+
+<img width="1919" height="1029" alt="image" src="https://github.com/user-attachments/assets/2bffb8f2-a8be-4930-9af1-fc0fa4553ee9" />
+
 
 ## Features
 
-- Repository management with validation, current branch display, and recent repositories.
-- Git status from `git status --porcelain=v1 -b` grouped as staged, unstaged, untracked, and conflicted.
-- Stage, unstage, discard, delete untracked files, stage all, and unstage all.
-- Monaco side-by-side and inline diff viewer with binary-file handling.
-- Commit staged files, amend last commit, and generate command output.
-- Branch, remote, history, graph, merge, rebase, stash, tag, validation, AI assistant, settings, and keyboard shortcut support.
-- 3-pane merge conflict resolver with conflict marker parsing and save + git add workflow.
+### Repository management
+
+- Recent-repository list with quick switching
+- Per-repo auto-fetch interval override (Sidebar › Repositories › ⚙)
+- Open, clone, or init repositories from the top bar or native menu
+- Tab-based multi-repo interface
+
+### History & commit graph
+
+- Virtualized commit graph with branch lanes, bezier merge curves, and HEAD indicator
+- Filter by branch, author, date range, file path, or free-text search
+- Dim/hide merge commits toggle; load-more pagination
+- Commit details: author `name <email>`, date, SHA, parents — click any field to copy
+- Right-click commit: checkout, cherry-pick, rebase, reset (soft/mixed/hard), revert, create branch/tag/worktree, copy SHA, create patch
+
+### Branch management
+
+- Branch switcher with right-click context menu: Pull, Push, Rename, Delete, Copy, Create tag
+- Sidebar branch list with full context menu: Checkout, Merge, Rebase, Reset, Push, Pull, Fetch, Delete, Rename
+- Correct display of branch names containing dots (e.g. `feature/v1.2.0`)
+
+### Working directory & commits
+
+- Stage, unstage, discard, delete untracked; stage all / unstage all
+- Monaco side-by-side and inline diff viewer with binary-file handling
+- Commit with message, amend last commit
+- Commit is undoable — Undo runs `git reset HEAD~1 --soft`; Redo re-commits
+
+### Undo / Redo
+
+- Dedicated Undo and Redo buttons in the top bar (separate from Refresh)
+- 20-entry undo/redo history
+
+### Conflict resolution & rebase
 
-## Install
+- 3-pane merge conflict resolver (current / incoming / result) with accept-current, accept-incoming, accept-both, and manual edit
+- Rebase: start, continue, abort, skip; interactive todo editor for pick, reword, edit, squash, fixup, drop, reorder
+- Cherry-pick: apply commit, abort in-progress cherry-pick
 
-```bash
-npm install
-```
+### Stash, tags, worktrees
 
-## Run development app
+- Stash: list, push, pop, apply, drop
+- Tags: list, create lightweight and annotated, delete
+- Worktrees: list, create from branch or commit, remove
 
-```bash
-npm run tauri dev
-```
+### AI assistant
 
-## Build desktop app
+- Configurable provider (Ollama, OpenAI, Anthropic, Groq), API key, and model
+- Generate commit message from staged diff; explain diff in natural language
 
-```bash
-npm run tauri build
-```
+### Auto-updates
 
-## Architecture
+- **Stable channel**: official releases only
+- **Alpha channel**: opt-in in Settings › General › Update Channel for early test builds
+- In-app update dialog with download progress and one-click install + relaunch
 
-Rust commands live in `src-tauri/src/commands`, shared services in `src-tauri/src/services`, and serialized models in `src-tauri/src/models`. The backend uses native Git CLI through `std::process::Command` with argument arrays; shell strings are not used for Git operations.
+### Settings
 
-React UI lives in `src/components`, state in `src/store/gitStore.ts`, IPC services in `src/services/gitService.ts`, and shared TypeScript types in `src/types/git.ts`.
+- General: global auto-fetch interval, update channel
+- Git: custom git binary path
+- AI: provider, API key, model, default target branch
+- About: version info
 
-## GitPilot feature coverage
+## Download
 
-GitPilot now includes first-pass production workflows for the highest-priority Git operations:
+See [Releases](https://github.com/ePlus-DEV/GitPilot/releases) for the latest build.
 
-- Visual conflict resolution parses conflict markers, presents current/incoming/result panes, supports accept-current, accept-incoming, accept-both, manual edits, and stages files after all markers are removed.
-- Rebase tooling supports normal rebase, paused-state detection, continue, abort, skip, and an interactive todo editor for pick, reword, edit, squash, fixup, drop, and reorder operations.
-- Cherry-pick commands support applying a selected commit and aborting an in-progress cherry-pick so conflicts can route through the same resolver.
-- Stash management supports list, push, apply, pop, drop, and rename from the stash panel.
-- Productivity primitives are available for blame, fuzzy smart search, and worktree list/create/remove commands.
+## License
 
-Some larger roadmap items, such as provider-backed pull-request review, CI aggregation, enterprise telemetry, and release signing, are intentionally exposed as modular command/service seams for follow-up hardening rather than hard-coded into the UI.
+[MIT](LICENSE)