gitxelectron 1.2.2 → 1.2.4

package/out/main/index.js

@@ -576,7 +576,14 @@ function initGit(sessionId, baseDir) {
     baseDir,
     binary: "git",
     maxConcurrentProcesses: 6,
-    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true },
+    progress: ({ method, stage, progress }) => {
+      try {
+        const wc = electron.webContents.fromId(sessionId);
+        if (wc) wc.send("git-progress", { method, stage, progress });
+      } catch (e) {
+      }
+    }
   };
   const git = simpleGit.simpleGit(options).env({
     ...process.env,
@@ -586,11 +593,19 @@ function initGit(sessionId, baseDir) {
   });
   gitSessions.set(sessionId, { git, repoPath: baseDir });
 }
-function createSafeGit(baseDir) {
+function createSafeGit(baseDir, sessionId) {
   const options = {
     binary: "git",
     maxConcurrentProcesses: 6,
-    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true },
+    progress: ({ method, stage, progress }) => {
+      if (!sessionId) return;
+      try {
+        const wc = electron.webContents.fromId(sessionId);
+        if (wc) wc.send("git-progress", { method, stage, progress });
+      } catch (e) {
+      }
+    }
   };
   if (baseDir) {
     options.baseDir = baseDir;
@@ -712,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;
 }
@@ -1169,7 +1184,7 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
   }
   try {
     if (destExists && destHasGit) {
-      const existingGit = createSafeGit(destPath);
+      const existingGit = createSafeGit(destPath, sessionId);
       try {
         await existingGit.raw(["config", "--global", "--add", "safe.directory", destPath]);
         const remotes = await existingGit.getRemotes();
@@ -1191,10 +1206,10 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
       }
     }
     if (destExists && destIsEmpty) {
-      const emptyDirGit = createSafeGit(destPath);
+      const emptyDirGit = createSafeGit(destPath, sessionId);
       await emptyDirGit.raw(["-c", "credential.helper=", "clone", authUrl, "."]);
       try {
-        await createSafeGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
+        await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
       } catch (e) {
       }
       return destPath;
@@ -1206,10 +1221,10 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
     }
     const baseDir = path__namespace.dirname(destPath);
     const targetDirName = path__namespace.basename(destPath);
-    const parentGit = createSafeGit(baseDir);
+    const parentGit = createSafeGit(baseDir, sessionId);
     await parentGit.raw(["-c", "credential.helper=", "clone", authUrl, targetDirName]);
     try {
-      await createSafeGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
+      await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
     } catch (e) {
     }
     return destPath;
@@ -1333,6 +1348,142 @@ ${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:
+<type>: <short summary>
+
+<detailed description>
+
+Do not wrap it in JSON or code blocks. Return just the plain text of the commit message.
+If the diff is empty or invalid, return "Auto-sync: update files".`;
+  const truncatedDiff = diffStr.length > 1e4 ? diffStr.substring(0, 1e4) + "\n...[diff truncated]" : diffStr;
+  const prompt = `GIT DIFF:
+${truncatedDiff}`;
+  let keys = "".split(",").map((k) => k.trim()).filter((k) => k);
+  if (!keys.length && provider === "gemini") {
+    keys = ["AQ.Ab8RN6LFu9vxQBWCSzE72V4CG2ILxnreqAP4AZQzSmXZ_1vphw"];
+  }
+  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: systemPrompt },
+          { role: "user", content: prompt }
+        ]
+      });
+      const content = response.choices[0].message.content?.trim();
+      if (content) return content;
+    } catch (e) {
+      console.warn(`[AI Service] GitHub Copilot fallback for commit gen failed: ${e.message}`);
+    }
+  }
+  for (const apiKey of keys) {
+    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: systemPrompt }, { text: prompt }]);
+        return result.response.text().trim();
+      }
+    } catch (e) {
+      console.warn(`[AI Service] Provider ${provider} commit gen failed: ${e.message}`);
+    }
+  }
+  return "Auto-sync: update files";
+}
 const getConfigPath = () => path__namespace.join(electron.app.getPath("userData"), "gitx-config.json");
 const saveLastWorkspace = async (workspacePath) => {
   try {
@@ -1362,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;
@@ -1393,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) {
@@ -1419,16 +1577,141 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
     await stageFiles(sessionId, existingFiles);
     const status = await getStatus(sessionId);
     const branch = status.current || "main";
-    const commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
-    onLog(`Committing: "${commitMsg}"...`);
+    onLog("Generating AI commit message...");
+    let commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
+    try {
+      const diffStr = await getFileDiff(sessionId, "", true);
+      if (diffStr && diffStr.trim() !== "") {
+        const githubToken = getToken(sessionId) || void 0;
+        const aiMsg = await generateCommitMessage("gemini", "", diffStr, githubToken);
+        if (aiMsg) {
+          commitMsg = aiMsg;
+        }
+      }
+    } catch (aiErr) {
+      console.warn("AI commit generation failed, falling back to default", aiErr);
+    }
+    onLog(`Committing: "${commitMsg.split("\n")[0]}"...`);
     await commitChanges(sessionId, commitMsg);
     onLog(`Pushing to ${branch}...`);
     await pushToRemote(sessionId, "origin", branch);
     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({
@@ -1786,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

@@ -6,6 +6,10 @@ const api = {
   onSetCliRepo: (callback) => {
     electron.ipcRenderer.on("set-cli-repo", (_event, repoPath) => callback(repoPath));
   },
+  onGitProgress: (callback) => {
+    electron.ipcRenderer.removeAllListeners("git-progress");
+    electron.ipcRenderer.on("git-progress", (_event, data) => callback(data));
+  },
   selectDirectory: () => electron.ipcRenderer.invoke("select-directory"),
   setRepoPath: (path) => electron.ipcRenderer.invoke("set-repo-path", path),
   initRepo: (path) => electron.ipcRenderer.invoke("init-repo", path),
@@ -33,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),
@@ -79,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),