gitxelectron 1.1.0

package/README.md

@@ -0,0 +1,84 @@
+# GitElectron (formerly GitQuickPush)
+
+GitElectron is a clean, modern, and intelligent desktop application and CLI tool designed to completely automate your Git workflow. Built with the philosophy **"I just write code. GitElectron takes care of Git,"** the tool removes the manual burden of `add`, `commit`, and `push`, silently synchronizing your work with GitHub while you focus on coding.
+
+## Features
+
+- **Universal Installation:** Works seamlessly as a standalone desktop executable (.exe) or as a globally installed NPM package.
+- **Context-Aware CLI Integration:** Run `gitelectron open` from any integrated terminal (VS Code, Cursor, Antigravity) to instantly launch the desktop app automatically hooked into that specific project directory.
+- **Universal Push Wizard:** Drag-and-drop any folder from your computer to push it directly to any GitHub repository or branch, even if the folder isn't a Git repository! (Utilizes a hyper-optimized `--sparse` checkout engine in the background).
+- **Collaboration & Invitations:** Manage GitHub repository collaborators directly from the UI. Accept or decline incoming repository invitations, and see a beautiful overlapping avatar stack of active collaborators in the top bar.
+- **Invisible Auto-Sync Daemon:**
+  - Automatically monitors your code folders using an intelligent debounced file watcher.
+  - Senses when you stop typing/saving (3-second debounce).
+  - Automatically stages modified files, generates clean commit messages, and pushes to GitHub in the background.
+  - Silently fetches remote changes so your UI always knows if you are behind/ahead of the remote!
+- **First-Run Authentication & PIN Lock:** Instantly hooks into your GitHub account using secure OAuth Device Flow. Secure your app with a custom Lockscreen PIN and Daily Auth.
+- **Built-in Auto-Updater:** Never run a terminal command to update again. GitElectron checks the NPM registry on the lockscreen and provides a 1-click silent update button.
+- **Beautiful & Dynamic Interface:**
+  - **iOS Glassmorphism Toasts:** All system notifications slide in beautifully using iOS-style translucent blur UI.
+  - **Theming & Audio:** Multiple themes equipped with authentic sound effects and globally adaptive custom scrollbars.
+- **Terminal Pushing:** Need to manually push a file fast? Use the built-in `gitelectron push -f <file>` CLI command.
+- **Visual Git Management:** If you prefer manual control, the beautiful React UI allows you to visually inspect diffs, stage files, resolve conflicts, and switch branches.
+
+## Installation
+
+### Method 1: NPM (Recommended for Developers)
+
+If you have Node.js installed, GitElectron is built to be a seamless global utility.
+
+```bash
+npm install -g gitelectron
+```
+
+Upon installation, GitElectron will automatically launch the desktop application, prompt you for GitHub authorization, and initialize your environment.
+
+### Method 2: Standalone Executable
+
+Download the latest `.exe` installer from the Releases page and run it. The application will guide you through connecting your GitHub account.
+
+## Usage
+
+### Auto-Sync (The Magic)
+
+Once logged in, simply open any Git repository in GitElectron. The **Auto-Sync** feature is enabled by default. Minimize the app.
+As you edit and save files in VS Code or your editor of choice, GitElectron will detect the changes, wait 3 seconds for you to finish, and push them directly to GitHub.
+
+### CLI Commands
+
+- **Open Contextually:** Open your terminal inside your project folder and run:
+
+  ```bash
+  gitelectron open
+  ```
+
+  The desktop app will instantly pop up and initialize that exact folder.
+
+- **Manual Push:** Push a single file quickly:
+  ```bash
+  gitelectron push -f src/index.js -m "Updated logic"
+  ```
+
+## Development Setup
+
+To build and run GitElectron locally:
+
+1. Clone the repository and install dependencies:
+   ```bash
+   npm install
+   ```
+2. Start the development server (Hot Module Replacement enabled):
+   ```bash
+   npm run dev
+   ```
+3. To build the production binary:
+   ```bash
+   npm run build:win
+   ```
+
+## Architecture
+
+- **Renderer (`src/renderer`):** A modern React + TailwindCSS interface running inside an Electron Window.
+- **Main (`src/main`):** Node.js backend handling system files (`chokidar` for watching), secure credentials, single-instance locking, and Git automation via `simple-git`.
+- **Preload (`src/preload`):** A secure ContextBridge tying the UI strictly to safe IPC handlers.
+- **CLI (`bin/cli.js`):** A Commander-based Node script that transparently spawns the packaged Electron executable, merging NPM utility with Desktop power.

package/bin/cli.js

@@ -0,0 +1,213 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander')
+const { spawn, execSync } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+const os = require('os')
+const readline = require('readline')
+
+function getConfigPath() {
+  return path.join(os.homedir(), '.gitelectron-cli-config.json')
+}
+function getAiConfig() {
+  try {
+    if (fs.existsSync(getConfigPath())) {
+      return JSON.parse(fs.readFileSync(getConfigPath(), 'utf8'))
+    }
+  } catch (e) {}
+  return { provider: 'gemini', apiKey: '' }
+}
+function setAiConfig(config) {
+  fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2))
+}
+
+function promptUser(query) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) =>
+    rl.question(query, (ans) => {
+      rl.close()
+      resolve(ans)
+    })
+  )
+}
+
+async function analyzeErrorWithAI(errorMsg, gitStatusStr) {
+  let config = getAiConfig()
+  if (!config.apiKey) {
+    config = {
+      provider: 'gemini',
+      apiKey:
+        'AQ.Ab8RN6IVl_GqoM0dDg6VoC6ru59Q5TBFNqRjueF-5eLms0ZqDQ,AQ.Ab8RN6Lvygx3fB2a7G8xIjjTIqjvxHER9rZmtLQaeiUkkUY3UA'
+    }
+  }
+
+  console.log(`\n🤖 Analyzing error with ${config.provider}...`)
+
+  const systemPrompt = `You are an expert Git Auto-Fixer for GitElectron CLI. 
+The user encountered a Git error.
+GIT STATUS: ${gitStatusStr}
+ERROR MESSAGE: ${errorMsg}
+
+Provide:
+1. Short explanation.
+2. Terminal commands to fix it.
+Return ONLY valid JSON (no markdown): {"explanation":"...", "commandsToRun":["git ..."]}`
+
+  const keys = config.apiKey
+    .split(',')
+    .map((k) => k.trim())
+    .filter((k) => k)
+  let lastError = null
+
+  for (const key of keys) {
+    try {
+      let responseText = ''
+      if (config.provider === 'gemini') {
+        const { GoogleGenerativeAI } = require('@google/generative-ai')
+        const genAI = new GoogleGenerativeAI(key)
+        const model = genAI.getGenerativeModel({ model: 'gemini-1.5-flash' })
+        const result = await model.generateContent([systemPrompt])
+        responseText = result.response.text()
+      } else {
+        const OpenAI = require('openai').default
+        const openai = new OpenAI({ apiKey: key, baseURL: 'https://router.huggingface.co/v1' })
+        const response = await openai.chat.completions.create({
+          model: 'deepseek-ai/DeepSeek-V4-Flash:novita',
+          messages: [{ role: 'system', content: systemPrompt }],
+          response_format: { type: 'json_object' }
+        })
+        responseText = response.choices[0].message.content || '{}'
+      }
+
+      const parsed = JSON.parse(
+        responseText
+          .replace(/```json/g, '')
+          .replace(/```/g, '')
+          .trim()
+      )
+      return parsed
+    } catch (e) {
+      console.error(
+        `[AI Service] Failed with key ${key.substring(0, 5)}... Trying next if available.`
+      )
+      lastError = e
+    }
+  }
+
+  console.error('AI Analysis failed after trying all keys:', lastError?.message)
+  return null
+}
+
+const program = new Command()
+
+// The Electron executable is provided by the 'electron' package
+let electronPath = ''
+try {
+  electronPath = require('electron')
+} catch (e) {
+  console.error('GitElectron is missing its electron dependency. Run npm install.')
+  process.exit(1)
+}
+
+// Path to the application root (where package.json and out/ exist)
+const appPath = path.resolve(__dirname, '..')
+
+program
+  .name('gitelectron')
+  .description('GitElectron - Lightweight, flexible Git automation tool')
+  .version('1.0.0')
+
+program
+  .command('open')
+  .description('Open GitElectron desktop application')
+  .action(() => {
+    console.log('Opening GitElectron...')
+
+    // Spawn the electron process and pass the current working directory
+    const child = spawn(electronPath, [appPath, '--cwd', process.cwd()], {
+      detached: true,
+      stdio: 'ignore'
+    })
+
+    // Unref so the CLI exits immediately and leaves the app running
+    child.unref()
+  })
+
+program
+  .command('push')
+  .description('Push a file directly to GitHub from the terminal')
+  .requiredOption('-f, --file <path>', 'File or directory to push')
+  .option('-m, --message <msg>', 'Commit message')
+  .option('-b, --branch <branch>', 'Branch to push to')
+  .action(async (options) => {
+    // For push command, we could either implement simple-git logic here
+    // or we can pass args to the electron app to handle it (like an invisible window).
+    // Let's implement basic push right here for speed, matching the old CLI.
+    try {
+      const simpleGit = require('simple-git')
+      const targetPath = path.resolve(process.cwd(), options.file)
+      if (!fs.existsSync(targetPath)) {
+        console.error(`Error: File or directory ${targetPath} does not exist.`)
+        process.exit(1)
+      }
+
+      const git = simpleGit(process.cwd())
+      const isRepo = await git.checkIsRepo()
+      if (!isRepo) {
+        console.error('Error: Current directory is not a git repository.')
+        process.exit(1)
+      }
+
+      console.log(`Staging ${options.file}...`)
+      await git.add(targetPath)
+
+      const commitMsg = options.message || `Update ${path.basename(targetPath)}`
+      console.log(`Committing with message: "${commitMsg}"...`)
+      await git.commit(commitMsg)
+
+      let branch = options.branch
+      if (!branch) {
+        const status = await git.status()
+        branch = status.current || 'main'
+      }
+
+      console.log(`Pushing to branch ${branch}...`)
+      await git.push('origin', branch, { '--set-upstream': null })
+
+      console.log('Successfully pushed! 🚀')
+    } catch (error) {
+      console.log('\n🔄 Git issue detected. Initiating AI Auto-Heal in the background...')
+
+      try {
+        const simpleGit = require('simple-git')
+        const git = simpleGit(process.cwd())
+        const status = await git.status()
+
+        const aiResponse = await analyzeErrorWithAI(error.message, JSON.stringify(status, null, 2))
+
+        if (aiResponse && aiResponse.commandsToRun.length > 0) {
+          for (const cmd of aiResponse.commandsToRun) {
+            execSync(cmd, { stdio: 'ignore' })
+          }
+
+          let branch = options.branch
+          if (!branch) {
+            branch = status.current || 'main'
+          }
+
+          console.log(`✅ AI fix applied. Retrying push to branch ${branch}...`)
+          await git.push('origin', branch, { '--set-upstream': null })
+          console.log('🚀 Successfully pushed after Auto-Healing!')
+        } else {
+          console.error('\n❌ An error occurred and AI Auto-Heal failed:', error.message)
+          process.exit(1)
+        }
+      } catch (e) {
+        console.error('\n❌ An error occurred and AI Auto-Heal failed:', error.message)
+        process.exit(1)
+      }
+    }
+  })
+
+program.parse()

package/bin/postinstall.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process')
+const path = require('path')
+
+console.log('Installing GitElectron dependencies...')
+
+// Run electron-builder install-app-deps (only fails if not in dev mode, so we wrap it)
+try {
+  const isGlobal = process.env.npm_config_global === 'true'
+
+  if (!isGlobal) {
+    const { execSync } = require('child_process')
+    execSync('npx electron-builder install-app-deps', { stdio: 'inherit' })
+  } else {
+    // If installed globally via NPM, spawn the app to prompt for login
+    let electronPath
+    try {
+      electronPath = require('electron')
+    } catch (e) {
+      console.error('Electron binary not found. Skipping auto-launch.')
+      process.exit(0)
+    }
+
+    console.log('First time setup: Launching GitElectron for authentication...')
+    const appPath = path.resolve(__dirname, '..')
+    const child = spawn(electronPath, [appPath], {
+      detached: true,
+      stdio: 'ignore'
+    })
+    child.unref()
+
+    // Create a Desktop Shortcut for easy access
+    if (process.platform === 'win32') {
+      try {
+        const os = require('os')
+        const desktopPath = path.join(os.homedir(), 'Desktop', 'GitElectron.lnk')
+        
+        const psCommand = `
+          $WshShell = New-Object -comObject WScript.Shell;
+          $Shortcut = $WshShell.CreateShortcut("${desktopPath}");
+          $Shortcut.TargetPath = "${electronPath}";
+          $Shortcut.Arguments = "\\"${appPath}\\"";
+          $Shortcut.Save();
+        `;
+        const { execSync } = require('child_process');
+        execSync(`powershell -NoProfile -Command "${psCommand}"`, { stdio: 'ignore' });
+        console.log('✅ Desktop shortcut created successfully!');
+      } catch (err) {
+        console.log('Failed to create Desktop shortcut.');
+      }
+    }
+  }
+} catch (e) {
+  // Ignore errors on postinstall
+  console.log('Postinstall step completed.')
+}

package/bin/preuninstall.js

@@ -0,0 +1,22 @@
+const { execSync } = require('child_process');
+const os = require('os');
+
+console.log('Preparing GitElectron for update... Safely closing any active instances.');
+
+try {
+    if (os.platform() === 'win32') {
+        execSync('taskkill /IM GitElectron.exe /F', { stdio: 'ignore' });
+    } else {
+        execSync('pkill -f GitElectron', { stdio: 'ignore' });
+    }
+} catch (e) {
+    // Process might not be running, which is completely fine.
+}
+
+// Block for 1.5 seconds to ensure the OS fully releases all file locks
+const start = Date.now();
+while (Date.now() - start < 1500) {
+    // Wait
+}
+
+process.exit(0);