gitxelectron 1.2.3 → 1.2.5

package/out/main/index.js

@@ -727,7 +727,7 @@ async function stageFiles(sessionId, files) {
   const chunkSize = 50;
   for (let i = 0; i < fileArray.length; i += chunkSize) {
     const chunk = fileArray.slice(i, i + chunkSize);
-    await git.add(chunk);
+    await git.add(["--force", ...chunk]);
   }
   return true;
 }
@@ -1348,6 +1348,93 @@ ${errorMsg}
     `AI Analysis failed after trying all provided keys. Last error: ${lastError?.message}`
   );
 }
+const AUTO_SYNC_SYSTEM_PROMPT = `You are an autonomous Git Healer Agent for the "GitQuickPush" app.
+The user's Auto-Push process failed (likely due to remote changes or a merge conflict).
+You will receive the Git Status, the Raw Error Message, and optionally the contents of any Conflicted Files.
+
+Your job is to analyze the issue and return a JSON object with this exact shape:
+{
+  "reason": "A clear, user-friendly explanation of why the push failed.",
+  "proposedFix": "A clear explanation of what specific changes you will make to fix it (e.g. 'I will run git pull --rebase and resolve the merge conflict in app.js by keeping both changes.')",
+  "resolvedCode": {
+    "path/to/file.ts": "THE_FULL_RESOLVED_FILE_CONTENT_HERE"
+  }
+}
+
+Guidelines:
+- If there are conflicted files provided, you MUST include the "resolvedCode" object. The keys must be the exact file paths, and the values must be the ENTIRE file content with all \`<<<<<<< HEAD\` conflict markers cleanly resolved.
+- If there are no conflicted files (e.g. just a standard rejection that a pull will fix), omit "resolvedCode".
+- Return ONLY valid JSON. No markdown code block wrappers.`;
+async function analyzePushErrorForAutoSync(provider, apiKeyInput, errorMsg, gitStatus, _repoPath, conflictedFilesContext, githubToken) {
+  if (!apiKeyInput && provider === "gemini") {
+    apiKeyInput = "AQ.Ab8RN6LFu9vxQBWCSzE72V4CG2ILxnreqAP4AZQzSmXZ_1vphw";
+  }
+  const keys = apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k);
+  let prompt = `
+GIT STATUS:
+${JSON.stringify(gitStatus, null, 2)}
+
+RAW ERROR MESSAGE:
+${errorMsg}
+`;
+  if (conflictedFilesContext && Object.keys(conflictedFilesContext).length > 0) {
+    prompt += `
+CONFLICTED FILES CONTENT (Resolve these markers):
+`;
+    for (const [filePath, content] of Object.entries(conflictedFilesContext)) {
+      prompt += `
+--- FILE: ${filePath} ---
+${content}
+--------------------------
+`;
+    }
+  }
+  let lastError = null;
+  if (githubToken) {
+    try {
+      const openai = new OpenAI({
+        apiKey: githubToken,
+        baseURL: "https://models.inference.ai.azure.com"
+      });
+      const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+          { role: "system", content: AUTO_SYNC_SYSTEM_PROMPT },
+          { role: "user", content: prompt }
+        ],
+        response_format: { type: "json_object" }
+      });
+      let responseText = response.choices[0].message.content || "{}";
+      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+      const parsed = JSON.parse(responseText);
+      if (parsed.reason && parsed.proposedFix) {
+        return parsed;
+      }
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  for (const apiKey of keys) {
+    let responseText = "";
+    try {
+      if (provider === "gemini") {
+        const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
+        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const result = await model.generateContent([{ text: AUTO_SYNC_SYSTEM_PROMPT }, { text: prompt }]);
+        responseText = result.response.text();
+      }
+      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+      const parsed = JSON.parse(responseText);
+      if (!parsed.reason || !parsed.proposedFix) {
+        throw new Error("AI returned an invalid response format.");
+      }
+      return parsed;
+    } catch (e) {
+      lastError = e;
+    }
+  }
+  throw new Error(`AI Analysis failed. Last error: ${lastError?.message}`);
+}
 async function generateCommitMessage(provider, apiKeyInput, diffStr, githubToken) {
   const systemPrompt = `You are an expert developer. Generate a concise, clear Git commit message based on the provided git diff.
 Format your response exactly like a standard Git commit message:
@@ -1426,10 +1513,17 @@ const getLastWorkspace = async () => {
 let currentWatcher = null;
 let syncTimeout = null;
 let isAutoSyncEnabled = false;
+let isResolving = false;
+let globalOnLog = null;
+let globalOnErrorApproval = null;
+let globalOnResolveComplete = null;
 const DEBOUNCE_MS = 3e3;
 const changedFiles = /* @__PURE__ */ new Set();
-function toggleAutoSync(sessionId, repoPath, enabled, onLog) {
+function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, onResolveComplete) {
   isAutoSyncEnabled = enabled;
+  globalOnLog = onLog;
+  if (onErrorApproval) globalOnErrorApproval = onErrorApproval;
+  if (onResolveComplete) globalOnResolveComplete = onResolveComplete;
   if (currentWatcher) {
     currentWatcher.close();
     currentWatcher = null;
@@ -1457,7 +1551,7 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog) {
     ignoreInitial: true
   });
   currentWatcher.on("all", (_event, filePath) => {
-    if (!isAutoSyncEnabled) return;
+    if (!isAutoSyncEnabled || isResolving) return;
     const relativePath = path__namespace.relative(repoPath, filePath).replace(/\\/g, "/");
     changedFiles.add(relativePath);
     if (syncTimeout) {
@@ -1504,8 +1598,120 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
     onLog(`✅ Successfully pushed auto-sync commit!`);
   } catch (error) {
     onLog(`❌ Auto-sync failed: ${error.message}`);
+    if (globalOnErrorApproval && !isResolving) {
+      isResolving = true;
+      onLog("Attempting to resolve push failure...");
+      handleAutoSyncError(sessionId, error.message, onLog).catch(
+        (err) => onLog(`Resolution failed: ${err.message}`)
+      );
+    }
+  }
+}
+async function handleAutoSyncError(sessionId, errorMsg, onLog) {
+  const { git, repoPath } = getGitSession(sessionId);
+  if (!repoPath) {
+    isResolving = false;
+    return;
+  }
+  try {
+    onLog("Pulling remote changes with rebase...");
+    await git.pull("origin", void 0, { "--rebase": "true" });
+    onLog("Pull successful, attempting push again...");
+    const status2 = await getStatus(sessionId);
+    await pushToRemote(sessionId, "origin", status2.current || "main");
+    onLog("✅ Error resolved and push resumed!");
+    isResolving = false;
+    if (globalOnResolveComplete) globalOnResolveComplete();
+    return;
+  } catch (pullErr) {
+    onLog(`Pull failed (possible conflict): ${pullErr.message}`);
+  }
+  const status = await getStatus(sessionId);
+  if (status.conflicted.length === 0) {
+    onLog("No conflicts found but resolution failed. Giving up.");
+    isResolving = false;
+    if (globalOnErrorApproval) {
+      globalOnErrorApproval({
+        reason: "Failed to resolve error automatically. No file conflicts found.",
+        proposedFix: "Manual intervention required.",
+        files: []
+      });
+    }
+    return;
+  }
+  onLog("Analyzing conflicts with AI...");
+  const conflictedFilesContext = {};
+  for (const f of status.conflicted) {
+    try {
+      const content = await fs__namespace.readFile(path__namespace.join(repoPath, f), "utf-8");
+      conflictedFilesContext[f] = content;
+    } catch (e) {
+    }
+  }
+  try {
+    const githubToken = getToken(sessionId) || void 0;
+    const aiResponse = await analyzePushErrorForAutoSync(
+      "gemini",
+      "",
+      errorMsg,
+      status,
+      repoPath,
+      conflictedFilesContext,
+      githubToken
+    );
+    if (globalOnErrorApproval) {
+      globalOnErrorApproval({
+        reason: aiResponse.reason,
+        proposedFix: aiResponse.proposedFix,
+        files: status.conflicted,
+        resolvedCode: aiResponse.resolvedCode,
+        sessionId
+      });
+    }
+  } catch (err) {
+    onLog(`AI analysis failed: ${err.message}`);
+    isResolving = false;
+    if (globalOnErrorApproval) {
+      globalOnErrorApproval({
+        reason: "AI analysis failed.",
+        proposedFix: "Manual intervention required.",
+        files: status.conflicted
+      });
+    }
   }
 }
+async function applyAiFixAndResume(sessionId, resolvedCode) {
+  const { git, repoPath } = getGitSession(sessionId);
+  if (!repoPath) return false;
+  if (globalOnLog) globalOnLog("Applying AI resolution to conflicted files...");
+  try {
+    if (resolvedCode) {
+      for (const [file, content] of Object.entries(resolvedCode)) {
+        await fs__namespace.writeFile(path__namespace.join(repoPath, file), content, "utf-8");
+        await git.add(["--force", file]);
+      }
+    }
+    try {
+      await git.rebase({ "--continue": null });
+    } catch (e) {
+      await git.commit("Auto-resolved merge conflict by AI");
+    }
+    const status = await getStatus(sessionId);
+    if (globalOnLog) globalOnLog("Pushing AI-resolved changes...");
+    await pushToRemote(sessionId, "origin", status.current || "main");
+    if (globalOnLog) globalOnLog("✅ Push successful!");
+    isResolving = false;
+    if (globalOnResolveComplete) globalOnResolveComplete();
+    return true;
+  } catch (err) {
+    if (globalOnLog) globalOnLog(`AI resolution failed: ${err.message}`);
+    isResolving = false;
+    return false;
+  }
+}
+function cancelAiFix() {
+  isResolving = false;
+}
 const icon = path.join(__dirname, "../../resources/icon.png");
 function createWindow(initialPath) {
   const mainWindow = new electron.BrowserWindow({
@@ -1863,9 +2069,26 @@ electron.app.whenReady().then(async () => {
     return { success: true, count: copiedFiles.length, files: copiedFiles };
   });
   electron.ipcMain.on("toggle-auto-sync", (event, repoPath, enabled) => {
-    toggleAutoSync(event.sender.id, repoPath, enabled, (msg) => {
-      event.sender.send("auto-sync-log", msg);
-    });
+    toggleAutoSync(
+      event.sender.id,
+      repoPath,
+      enabled,
+      (msg) => {
+        event.sender.send("auto-sync-log", msg);
+      },
+      (payload) => {
+        event.sender.send("auto-sync-error-approval", payload);
+      },
+      () => {
+        event.sender.send("auto-sync-resolved");
+      }
+    );
+  });
+  electron.ipcMain.handle("approve-ai-fix", async (event, resolvedCode) => {
+    return await applyAiFixAndResume(event.sender.id, resolvedCode);
+  });
+  electron.ipcMain.on("reject-ai-fix", () => {
+    cancelAiFix();
   });
   electron.ipcMain.handle("get-app-version", () => {
     return electron.app.getVersion();

package/out/preload/index.js

@@ -37,6 +37,8 @@ const api = {
   setGitConfig: (key, value, global = false) => electron.ipcRenderer.invoke("set-git-config", key, value, global),
   readFile: (file) => electron.ipcRenderer.invoke("read-file", file),
   writeFile: (file, content) => electron.ipcRenderer.invoke("write-file", file, content),
+  approveAiFix: (resolvedCode) => electron.ipcRenderer.invoke("approve-ai-fix", resolvedCode),
+  rejectAiFix: () => electron.ipcRenderer.send("reject-ai-fix"),
   executeRawGit: (args) => electron.ipcRenderer.invoke("execute-raw-git", args),
   // NEW: Multi-Account & Window
   newWindow: (repoPath) => electron.ipcRenderer.invoke("new-window", repoPath),
@@ -83,6 +85,14 @@ const api = {
     electron.ipcRenderer.removeAllListeners("auto-sync-log");
     electron.ipcRenderer.on("auto-sync-log", (_event, msg) => callback(msg));
   },
+  onAutoSyncErrorApproval: (callback) => {
+    electron.ipcRenderer.removeAllListeners("auto-sync-error-approval");
+    electron.ipcRenderer.on("auto-sync-error-approval", (_event, payload) => callback(payload));
+  },
+  onAutoSyncResolved: (callback) => {
+    electron.ipcRenderer.removeAllListeners("auto-sync-resolved");
+    electron.ipcRenderer.on("auto-sync-resolved", () => callback());
+  },
   getAppVersion: () => electron.ipcRenderer.invoke("get-app-version"),
   // AI Fixer API
   askAi: (provider, apiKey, errorMsg, gitStatus, repoPath) => electron.ipcRenderer.invoke("ask-ai", provider, apiKey, errorMsg, gitStatus, repoPath),