gitxelectron 1.2.7 → 1.2.9

package/out/main/index.js

@@ -5,7 +5,6 @@ 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");
@@ -28,7 +27,6 @@ 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();
@@ -867,11 +865,8 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   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
-  });
+  const child = child_process.spawn("git", ["status", "--porcelain", "-z"], { cwd: repoPath });
+  let buffer = "";
   let currentChunk = [];
   let chunkCount = 0;
   let processedFiles = 0;
@@ -902,10 +897,34 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
         eta: etaStr
       });
     }
+    const LARGE_FILE_LIMIT = 50 * 1024 * 1024;
+    const largeFiles = [];
+    await Promise.all(chunk.map(async (file) => {
+      try {
+        const stats = await fs__namespace.stat(path__namespace.join(repoPath, file));
+        if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
+          largeFiles.push(file);
+        }
+      } catch (e) {
+      }
+    }));
+    if (largeFiles.length > 0) {
+      try {
+        await git.raw(["lfs", "install"]);
+        for (const file of largeFiles) {
+          await git.raw(["lfs", "track", file]);
+        }
+        if (!chunk.includes(".gitattributes")) {
+          chunk.push(".gitattributes");
+        }
+      } catch (e) {
+        console.warn("Git LFS failed:", e);
+      }
+    }
     const tempFile = path__namespace.join(repoPath, ".git", "massive_chunk.txt");
-    await fs__namespace.writeFile(tempFile, chunk.join("\n"), "utf-8");
+    await fs__namespace.writeFile(tempFile, chunk.join("\0") + "\0", "utf-8");
     try {
-      await git.raw(["-c", "core.safecrlf=false", "add", "--force", "--pathspec-from-file=" + tempFile]);
+      await git.raw(["-c", "core.safecrlf=false", "add", "--force", "--pathspec-from-file=" + tempFile, "--pathspec-file-nul"]);
     } catch (e) {
       if (e.message && e.message.includes("fatal:")) {
         throw e;
@@ -916,41 +935,49 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
       } 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();
+  for await (const chunkData of child.stdout) {
+    buffer += chunkData.toString("utf-8");
+    let nullIdx;
+    while ((nullIdx = buffer.indexOf("\0")) !== -1) {
+      const entry = buffer.slice(0, nullIdx);
+      buffer = buffer.slice(nullIdx + 1);
+      if (entry.length < 3) continue;
+      const file = entry.substring(3);
+      if (!file) continue;
+      currentChunk.push(file);
+      if (currentChunk.length >= chunkSize) {
+        child.stdout.pause();
+        await processChunk(currentChunk);
+        currentChunk = [];
+        child.stdout.resume();
+      }
     }
   }
   if (currentChunk.length > 0) {
     await processChunk(currentChunk);
   }
+  if (onProgress) onProgress("Committing all files...");
+  try {
+    await git.commit(`Auto-sync (Massive Push)`);
+  } catch (e) {
+  }
+  if (onProgress) onProgress("Pushing to remote...");
+  const pushArgs = ["-c", "credential.helper=", "-c", "pack.windowMemory=256m", "-c", "pack.packSizeLimit=500m", "-c", "http.postBuffer=524288000", "-c", "lfs.concurrenttransfers=8", "push", "--progress", "--no-verify"];
+  try {
+    await git.raw([...pushArgs, authUrl, branch]);
+  } catch (err) {
+    if (err.message && (err.message.includes("non-fast-forward") || err.message.includes("fetch first") || err.message.includes("branch is behind"))) {
+      if (onProgress) onProgress("Remote branch is ahead. Pulling changes...");
+      await git.pull(authUrl, branch, { "--rebase": null, "--autostash": null });
+      if (onProgress) onProgress("Pushing to remote after pull...");
+      await git.raw([...pushArgs, authUrl, branch]);
+    } else {
+      if (err.message && !err.message.includes("nothing to commit")) {
+        throw err;
+      }
+    }
+  }
   if (onProgress) onProgress("✅ Massive push completed successfully!");
   return true;
 }
@@ -964,11 +991,12 @@ async function pushToRemote(sessionId, remote, branch) {
     GIT_ASKPASS: "echo"
   });
   const doPush = async () => {
+    const pushArgs = ["-c", "credential.helper=", "-c", "pack.windowMemory=256m", "-c", "pack.packSizeLimit=500m", "-c", "http.postBuffer=524288000", "-c", "lfs.concurrenttransfers=8", "push", "--progress", "--no-verify"];
     if (remoteObj && remoteObj.refs.push) {
       const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
-      return await tempGit.raw(["-c", "credential.helper=", "push", authUrl, branch]);
+      return await tempGit.raw([...pushArgs, authUrl, branch]);
     }
-    return await tempGit.raw(["-c", "credential.helper=", "push", remote, branch]);
+    return await tempGit.raw([...pushArgs, remote, branch]);
   };
   try {
     return await doPush();
@@ -1376,11 +1404,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;
@@ -1390,7 +1418,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) {
@@ -1405,7 +1433,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) {
@@ -1426,6 +1454,85 @@ 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;
+  }
+}
+async function getDirectoryGitInfo(dir) {
+  try {
+    const isRepo = await isGitRepo(dir);
+    if (!isRepo) return { isRepo: false, remotes: [] };
+    const tempGit = createSafeGit(dir);
+    let rootPath = void 0;
+    try {
+      rootPath = (await tempGit.revparse(["--show-toplevel"])).trim();
+      if (rootPath) rootPath = path__namespace.normalize(rootPath);
+    } catch {
+    }
+    const remotes = await tempGit.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin") || remotes[0];
+    let repoName = void 0;
+    let remoteUrl = void 0;
+    if (origin && origin.refs && (origin.refs.fetch || origin.refs.push)) {
+      remoteUrl = origin.refs.fetch || origin.refs.push;
+      const match = remoteUrl.match(/\/([^/]+?)(?:\.git)?$/);
+      if (match) {
+        repoName = match[1];
+      }
+    }
+    return {
+      isRepo: true,
+      rootPath: rootPath || dir,
+      remotes: JSON.parse(JSON.stringify(remotes)),
+      repoName,
+      remoteUrl
+    };
+  } catch {
+    return { isRepo: false, remotes: [] };
+  }
+}
+async function scanForRepoFolder(repoName, candidateBaseDirs) {
+  const cleanName = repoName.toLowerCase().trim();
+  const visited = /* @__PURE__ */ new Set();
+  for (const base of candidateBaseDirs) {
+    if (!base || visited.has(base.toLowerCase())) continue;
+    visited.add(base.toLowerCase());
+    try {
+      const directCandidate = path__namespace.join(base, repoName);
+      try {
+        const stat = await fs__namespace.stat(directCandidate);
+        if (stat.isDirectory()) {
+          const info = await getDirectoryGitInfo(directCandidate);
+          if (info.isRepo) {
+            if (!info.repoName || info.repoName.toLowerCase() === cleanName) {
+              return directCandidate;
+            }
+          }
+        }
+      } catch {
+      }
+      const entries = await fs__namespace.readdir(base, { withFileTypes: true }).catch(() => []);
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const childPath = path__namespace.join(base, entry.name);
+        if (entry.name.toLowerCase() === cleanName) {
+          const info = await getDirectoryGitInfo(childPath);
+          if (info.isRepo) {
+            return childPath;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 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.
@@ -2027,11 +2134,15 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("get-cli-repo", () => {
     return initialRepo;
   });
-  electron.ipcMain.handle("select-directory", async (event) => {
+  electron.ipcMain.handle("select-directory", async (event, defaultPath) => {
     const sessionId = event.sender.id;
-    const result = await electron.dialog.showOpenDialog({
+    const options = {
       properties: ["openDirectory"]
-    });
+    };
+    if (defaultPath) {
+      options.defaultPath = defaultPath;
+    }
+    const result = await electron.dialog.showOpenDialog(options);
     if (result.canceled || result.filePaths.length === 0) {
       return null;
     }
@@ -2068,6 +2179,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) => {
@@ -2257,6 +2379,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 {
@@ -2266,6 +2391,17 @@ electron.app.whenReady().then(async () => {
       return false;
     }
   });
+  electron.ipcMain.handle("get-directory-git-info", async (_event, dirPath) => {
+    if (!dirPath) return { isRepo: false, remotes: [] };
+    return await getDirectoryGitInfo(dirPath);
+  });
+  electron.ipcMain.handle(
+    "scan-for-repo-folder",
+    async (_event, repoName, candidateDirs) => {
+      if (!repoName || !candidateDirs || !candidateDirs.length) return null;
+      return await scanForRepoFolder(repoName, candidateDirs);
+    }
+  );
   electron.ipcMain.handle("upload-files-to-repo", async (event, repoPath) => {
     const window = electron.BrowserWindow.fromWebContents(event.sender);
     if (!repoPath) throw new Error("No repository path specified");

package/out/preload/index.js

@@ -10,9 +10,10 @@ const api = {
     electron.ipcRenderer.removeAllListeners("git-progress");
     electron.ipcRenderer.on("git-progress", (_event, data) => callback(data));
   },
-  selectDirectory: () => electron.ipcRenderer.invoke("select-directory"),
+  selectDirectory: (defaultPath) => electron.ipcRenderer.invoke("select-directory", defaultPath),
   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),
@@ -77,6 +78,8 @@ const api = {
   getUniversalDiff: (workspacePath, file) => electron.ipcRenderer.invoke("get-universal-diff", workspacePath, file),
   cloneRepository: (remoteUrl, destPath) => electron.ipcRenderer.invoke("clone-repository", remoteUrl, destPath),
   checkPathExists: (targetPath) => electron.ipcRenderer.invoke("check-path-exists", targetPath),
+  getDirectoryGitInfo: (dirPath) => electron.ipcRenderer.invoke("get-directory-git-info", dirPath),
+  scanForRepoFolder: (repoName, candidateDirs) => electron.ipcRenderer.invoke("scan-for-repo-folder", repoName, candidateDirs),
   uploadFilesToRepo: (repoPath) => electron.ipcRenderer.invoke("upload-files-to-repo", repoPath),
   commitUniversalWorkspace: (workspacePath, msg, branch) => electron.ipcRenderer.invoke("commit-universal-workspace", workspacePath, msg, branch),
   cleanupUniversalWorkspace: (workspacePath) => electron.ipcRenderer.invoke("cleanup-universal-workspace", workspacePath),