gitxelectron 1.2.6 → 1.2.8

package/out/main/index.js

@@ -4,6 +4,8 @@ const path = require("path");
 const fs = require("fs/promises");
 const simpleGit = require("simple-git");
 const crypto = require("crypto");
+const child_process = require("child_process");
+const readline = require("readline");
 const generativeAi = require("@google/generative-ai");
 const OpenAI = require("openai");
 const chokidar = require("chokidar");
@@ -26,6 +28,7 @@ function _interopNamespaceDefault(e) {
 }
 const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
 const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const readline__namespace = /* @__PURE__ */ _interopNamespaceDefault(readline);
 const GITHUB_CLIENT_ID = "Ov23livWfiaPADGiwSXq";
 let accounts = [];
 const activeSessions = /* @__PURE__ */ new Map();
@@ -690,9 +693,56 @@ async function initializeRepo(sessionId, dir) {
   }
 }
 async function getStatus(sessionId) {
-  const { git } = getGitSession(sessionId);
-  const status = await git.status();
-  return JSON.parse(JSON.stringify(status));
+  const { git, repoPath } = getGitSession(sessionId);
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn("git", ["status", "--porcelain"], { cwd: repoPath });
+    let count = 0;
+    let isMassive = false;
+    child.stdout.on("data", (chunk) => {
+      for (let i = 0; i < chunk.length; ++i) {
+        if (chunk[i] === 10) {
+          count++;
+          if (count > 1e4) {
+            isMassive = true;
+            child.kill();
+            break;
+          }
+        }
+      }
+    });
+    child.on("close", async () => {
+      if (isMassive) {
+        resolve({
+          not_added: [],
+          created: [],
+          deleted: [],
+          modified: [],
+          conflicted: [],
+          renamed: [],
+          staged: [],
+          files: [],
+          current: "main",
+          ahead: 0,
+          behind: 0,
+          tracking: null,
+          isMassive: true,
+          totalChanges: count
+        });
+      } else {
+        try {
+          const status = await git.status();
+          const result = JSON.parse(JSON.stringify(status));
+          result.isMassive = false;
+          result.totalChanges = count;
+          if (!result.staged) result.staged = [];
+          resolve(result);
+        } catch (e) {
+          reject(e);
+        }
+      }
+    });
+    child.on("error", reject);
+  });
 }
 async function stageFiles(sessionId, files) {
   const { git, repoPath } = getGitSession(sessionId);
@@ -727,7 +777,15 @@ 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(["--force", ...chunk]);
+    try {
+      await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--force", ...chunk]);
+    } catch (e) {
+      if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
+        console.warn("Ignored CRLF warning during stage");
+      } else {
+        throw e;
+      }
+    }
   }
   return true;
 }
@@ -779,6 +837,123 @@ function injectAuthToken(sessionId, remoteUrl) {
   }
   return remoteUrl;
 }
+async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3, onProgress, onDetailedProgress) {
+  const { repoPath } = getGitSession(sessionId);
+  if (onProgress) onProgress("Starting rapid file count to prepare massive chunking...");
+  const totalFiles = await new Promise((resolve) => {
+    const child2 = child_process.spawn("git", ["status", "--porcelain"], { cwd: repoPath });
+    let count = 0;
+    child2.stdout.on("data", (chunk) => {
+      for (let i = 0; i < chunk.length; ++i) {
+        if (chunk[i] === 10) count++;
+      }
+    });
+    child2.on("close", () => resolve(count));
+    child2.on("error", () => resolve(0));
+  });
+  if (totalFiles === 0) {
+    if (onProgress) onProgress("No files to push.");
+    return true;
+  }
+  if (onProgress) onProgress(`Total files to push: ${totalFiles}. Starting chunked upload...`);
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  if (onProgress) onProgress("Starting massive repository push...");
+  await git.addConfig("http.postBuffer", "1048576000");
+  await git.addConfig("core.safecrlf", "false");
+  await git.addConfig("core.autocrlf", "false");
+  let authUrl = remote;
+  if (remoteObj && remoteObj.refs.push) {
+    authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
+  }
+  const child = child_process.spawn("git", ["status", "--porcelain"], { cwd: repoPath });
+  const rl = readline__namespace.createInterface({
+    input: child.stdout,
+    crlfDelay: Infinity
+  });
+  let currentChunk = [];
+  let chunkCount = 0;
+  let processedFiles = 0;
+  const startTime = Date.now();
+  const processChunk = async (chunk) => {
+    chunkCount++;
+    processedFiles += chunk.length;
+    const percentage = Math.min(100, processedFiles / totalFiles * 100);
+    const elapsedMs = Date.now() - startTime;
+    const msPerFile = elapsedMs / processedFiles;
+    const remainingFiles = totalFiles - processedFiles;
+    const etaMs = msPerFile * remainingFiles;
+    const formatEta = (ms) => {
+      if (!isFinite(ms) || ms < 0) return "calculating...";
+      const totalSec = Math.floor(ms / 1e3);
+      const min = Math.floor(totalSec / 60);
+      const sec = totalSec % 60;
+      if (min > 0) return `${min}m ${sec}s left`;
+      return `${sec}s left`;
+    };
+    const etaStr = formatEta(etaMs);
+    if (onProgress) onProgress(`Processing chunk ${chunkCount} (${chunk.length} files)... ETA: ${etaStr}`);
+    if (onDetailedProgress) {
+      onDetailedProgress({
+        processed: processedFiles,
+        total: totalFiles,
+        percentage,
+        eta: etaStr
+      });
+    }
+    const tempFile = path__namespace.join(repoPath, ".git", "massive_chunk.txt");
+    await fs__namespace.writeFile(tempFile, chunk.join("\n"), "utf-8");
+    try {
+      await git.raw(["-c", "core.safecrlf=false", "add", "--force", "--pathspec-from-file=" + tempFile]);
+    } catch (e) {
+      if (e.message && e.message.includes("fatal:")) {
+        throw e;
+      }
+    } finally {
+      try {
+        await fs__namespace.unlink(tempFile);
+      } catch (e) {
+      }
+    }
+    try {
+      await git.commit(`Auto-sync chunk ${chunkCount} (Massive Push)`);
+    } catch (e) {
+    }
+    try {
+      await git.raw(["-c", "credential.helper=", "push", authUrl, branch]);
+    } catch (err) {
+      if (err.message && (err.message.includes("non-fast-forward") || err.message.includes("fetch first") || err.message.includes("branch is behind"))) {
+        await git.pull(authUrl, branch, { "--rebase": null, "--autostash": null });
+        await git.raw(["-c", "credential.helper=", "push", authUrl, branch]);
+      } else {
+        if (err.message && !err.message.includes("nothing to commit")) {
+          throw err;
+        }
+      }
+    }
+  };
+  for await (const line of rl) {
+    if (line.length < 3) continue;
+    let file = line.substring(3).trim();
+    if (file.startsWith('"') && file.endsWith('"')) {
+      file = file.substring(1, file.length - 1);
+    }
+    if (!file) continue;
+    currentChunk.push(file);
+    if (currentChunk.length >= chunkSize) {
+      rl.pause();
+      await processChunk(currentChunk);
+      currentChunk = [];
+      rl.resume();
+    }
+  }
+  if (currentChunk.length > 0) {
+    await processChunk(currentChunk);
+  }
+  if (onProgress) onProgress("✅ Massive push completed successfully!");
+  return true;
+}
 async function pushToRemote(sessionId, remote, branch) {
   const remotes = await getRemotes(sessionId);
   const remoteObj = remotes.find((r) => r.name === remote);
@@ -1127,7 +1302,15 @@ async function commitUniversalWorkspace(workspacePath, message, branch) {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "echo"
   });
-  await git.add(["--sparse", "."]);
+  try {
+    await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--sparse", "."]);
+  } catch (e) {
+    if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
+      console.warn("Ignored CRLF warning in universal workspace");
+    } else {
+      throw e;
+    }
+  }
   await git.commit(message);
   try {
     await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
@@ -1193,11 +1376,11 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
         } else {
           await existingGit.raw(["remote", "add", "origin", authUrl]);
         }
-        await existingGit.raw(["-c", "credential.helper=", "fetch", "origin"]);
+        await existingGit.raw(["-c", "credential.helper=", "fetch", "--progress", "origin"]);
         const st = await existingGit.status();
         const branch = st.current || "main";
         try {
-          await existingGit.raw(["-c", "credential.helper=", "pull", "origin", branch]);
+          await existingGit.raw(["-c", "credential.helper=", "pull", "--progress", "origin", branch]);
         } catch (e) {
         }
         return destPath;
@@ -1207,7 +1390,7 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
     }
     if (destExists && destIsEmpty) {
       const emptyDirGit = createSafeGit(destPath, sessionId);
-      await emptyDirGit.raw(["-c", "credential.helper=", "clone", authUrl, "."]);
+      await emptyDirGit.raw(["-c", "credential.helper=", "clone", "--progress", authUrl, "."]);
       try {
         await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
       } catch (e) {
@@ -1222,7 +1405,7 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
     const baseDir = path__namespace.dirname(destPath);
     const targetDirName = path__namespace.basename(destPath);
     const parentGit = createSafeGit(baseDir, sessionId);
-    await parentGit.raw(["-c", "credential.helper=", "clone", authUrl, targetDirName]);
+    await parentGit.raw(["-c", "credential.helper=", "clone", "--progress", authUrl, targetDirName]);
     try {
       await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
     } catch (e) {
@@ -1243,6 +1426,16 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
     throw new Error(cleanMsg);
   }
 }
+async function removeGitMetadata(_sessionId, repoPath) {
+  try {
+    const gitDir = path__namespace.join(repoPath, ".git");
+    await fs__namespace.rm(gitDir, { recursive: true, force: true });
+    return true;
+  } catch (e) {
+    console.error("Failed to remove git metadata:", e);
+    return false;
+  }
+}
 const SYSTEM_PROMPT = `You are an autonomous Git Healer Agent for the "GitElectron" app. 
 The user has encountered a Git error during a push, pull, or merge operation and you are executing as a background process to silently fix it.
 You will receive the Git Status and the Raw Error Message.
@@ -1517,13 +1710,15 @@ let isResolving = false;
 let globalOnLog = null;
 let globalOnErrorApproval = null;
 let globalOnResolveComplete = null;
+let globalOnMassiveProgress = null;
 const DEBOUNCE_MS = 3e3;
 const changedFiles = /* @__PURE__ */ new Set();
-function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, onResolveComplete) {
+function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, onResolveComplete, onMassiveProgress) {
   isAutoSyncEnabled = enabled;
   globalOnLog = onLog;
   if (onErrorApproval) globalOnErrorApproval = onErrorApproval;
   if (onResolveComplete) globalOnResolveComplete = onResolveComplete;
+  if (onMassiveProgress) globalOnMassiveProgress = onMassiveProgress;
   if (currentWatcher) {
     currentWatcher.close();
     currentWatcher = null;
@@ -1553,7 +1748,11 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
   currentWatcher.on("all", (_event, filePath) => {
     if (!isAutoSyncEnabled || isResolving) return;
     const relativePath = path__namespace.relative(repoPath, filePath).replace(/\\/g, "/");
-    changedFiles.add(relativePath);
+    if (changedFiles.size < 1e4) {
+      changedFiles.add(relativePath);
+    } else if (!changedFiles.has("__MASSIVE__")) {
+      changedFiles.add("__MASSIVE__");
+    }
     if (syncTimeout) {
       clearTimeout(syncTimeout);
     }
@@ -1574,9 +1773,29 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
       onLog("No valid files to sync (temp files filtered).");
       return;
     }
-    await stageFiles(sessionId, existingFiles);
+    if (changedFiles.has("__MASSIVE__")) {
+      onLog("Massive file changes detected in watcher. Checking status...");
+    }
     const status = await getStatus(sessionId);
-    const branch = status.current || "main";
+    if (status.isMassive) {
+      onLog(`🚨 Massive repository change detected! Engaging chunked sync mode...`);
+      const branch2 = status.current || "main";
+      const success = await pushMassiveRepository(
+        sessionId,
+        "origin",
+        branch2,
+        5e3,
+        onLog,
+        globalOnMassiveProgress || void 0
+      );
+      if (success) {
+        onLog(`✅ Successfully pushed massive repository sync!`);
+      }
+      return;
+    }
+    await stageFiles(sessionId, existingFiles);
+    const finalStatus = await getStatus(sessionId);
+    const branch = finalStatus.current || "main";
     onLog("Generating AI commit message...");
     let commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
     try {
@@ -1688,7 +1907,15 @@ async function applyAiFixAndResume(sessionId, resolvedCode) {
     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.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--force", file]);
+        } catch (e) {
+          if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
+            console.warn("Ignored CRLF warning during AI fix apply");
+          } else {
+            throw e;
+          }
+        }
       }
     }
     try {
@@ -1851,6 +2078,17 @@ electron.app.whenReady().then(async () => {
     return await commitChanges(event.sender.id, message);
   });
   electron.ipcMain.handle("push-to-remote", async (event, remote, branch) => {
+    const status = await getStatus(event.sender.id);
+    if (status.isMassive) {
+      return await pushMassiveRepository(
+        event.sender.id,
+        remote,
+        branch,
+        5e3,
+        void 0,
+        (data) => event.sender.send("massive-push-progress", data)
+      );
+    }
     return await pushToRemote(event.sender.id, remote, branch);
   });
   electron.ipcMain.handle("pull-from-remote", async (event, remote, branch) => {
@@ -2040,6 +2278,9 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("clone-repository", async (event, remoteUrl, destPath) => {
     return await cloneRepository(event.sender.id, remoteUrl, destPath);
   });
+  electron.ipcMain.handle("remove-git-metadata", async (event, repoPath) => {
+    return await removeGitMetadata(event.sender.id, repoPath);
+  });
   electron.ipcMain.handle("check-path-exists", async (_event, targetPath) => {
     if (!targetPath) return false;
     try {
@@ -2073,15 +2314,10 @@ electron.app.whenReady().then(async () => {
       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");
-      }
+      (msg) => event.sender.send("auto-sync-log", msg),
+      (payload) => event.sender.send("auto-sync-error-approval", payload),
+      () => event.sender.send("auto-sync-resolved"),
+      (data) => event.sender.send("massive-push-progress", data)
     );
   });
   electron.ipcMain.handle("approve-ai-fix", async (event, resolvedCode) => {

package/out/preload/index.js

@@ -13,6 +13,7 @@ const api = {
   selectDirectory: () => electron.ipcRenderer.invoke("select-directory"),
   setRepoPath: (path) => electron.ipcRenderer.invoke("set-repo-path", path),
   initRepo: (path) => electron.ipcRenderer.invoke("init-repo", path),
+  removeGitMetadata: (repoPath) => electron.ipcRenderer.invoke("remove-git-metadata", repoPath),
   getStatus: () => electron.ipcRenderer.invoke("get-status"),
   stageFiles: (files) => electron.ipcRenderer.invoke("stage-files", files),
   unstageFiles: (files) => electron.ipcRenderer.invoke("unstage-files", files),
@@ -93,6 +94,10 @@ const api = {
     electron.ipcRenderer.removeAllListeners("auto-sync-resolved");
     electron.ipcRenderer.on("auto-sync-resolved", () => callback());
   },
+  onMassivePushProgress: (callback) => {
+    electron.ipcRenderer.removeAllListeners("massive-push-progress");
+    electron.ipcRenderer.on("massive-push-progress", (_event, data) => callback(data));
+  },
   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),