gitxelectron 1.2.8 → 1.3.0

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();
@@ -1377,39 +1405,122 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
           await existingGit.raw(["remote", "add", "origin", authUrl]);
         }
         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", "--progress", "origin", branch]);
-        } catch (e) {
-        }
+        await new Promise((resolve) => {
+          const child = child_process.spawn(
+            "git",
+            ["-c", "core.longpaths=true", "-c", "filter.lfs.required=false", "-c", "filter.lfs.smudge=", "checkout", "-f"],
+            {
+              cwd: destPath,
+              env: { ...process.env, GIT_LFS_SKIP_SMUDGE: "1" }
+            }
+          );
+          child.on("close", () => resolve());
+          child.on("error", () => resolve());
+        });
         return destPath;
       } catch (err) {
         console.warn("Re-using existing repo failed, falling through to clone attempt:", err);
       }
     }
-    if (destExists && destIsEmpty) {
-      const emptyDirGit = createSafeGit(destPath, sessionId);
-      await emptyDirGit.raw(["-c", "credential.helper=", "clone", "--progress", authUrl, "."]);
-      try {
-        await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
-      } catch (e) {
-      }
-      return destPath;
-    }
     if (destExists && !destIsEmpty && !destHasGit) {
       throw new Error(
         `The folder '${path__namespace.basename(destPath)}' already contains files. Please select an empty folder or a different location to clone.`
       );
     }
-    const baseDir = path__namespace.dirname(destPath);
-    const targetDirName = path__namespace.basename(destPath);
-    const parentGit = createSafeGit(baseDir, sessionId);
-    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) {
+    const wc = electron.webContents.fromId(sessionId);
+    const cloneArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "core.longpaths=true",
+      "-c",
+      "filter.lfs.required=false",
+      "-c",
+      "filter.lfs.smudge=",
+      "-c",
+      "http.postBuffer=524288000",
+      "-c",
+      "core.compression=0",
+      "-c",
+      "pack.windowMemory=256m",
+      "clone",
+      "--progress",
+      authUrl
+    ];
+    let cwd;
+    if (destExists && destIsEmpty) {
+      cloneArgs.push(".");
+      cwd = destPath;
+    } else {
+      cloneArgs.push(path__namespace.basename(destPath));
+      cwd = path__namespace.dirname(destPath);
     }
+    await new Promise((resolve, reject) => {
+      const child = child_process.spawn("git", cloneArgs, {
+        cwd,
+        env: {
+          ...process.env,
+          GIT_LFS_SKIP_SMUDGE: "1",
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      const errorLines = [];
+      child.stderr.on("data", (data) => {
+        const text = data.toString();
+        const match = text.match(
+          /(Receiving objects|Resolving deltas|Counting objects|Compressing objects):\s+(\d+)%/i
+        );
+        if (match && wc) {
+          const stage = match[1];
+          const progress = parseInt(match[2], 10);
+          try {
+            wc.send("git-progress", { method: "clone", stage, progress });
+          } catch {
+          }
+        }
+        const lines = text.split(/[\r\n]+/).map((l) => l.trim()).filter(Boolean);
+        for (const line of lines) {
+          if (!line.startsWith("Receiving objects:") && !line.startsWith("Resolving deltas:") && !line.startsWith("Counting objects:") && !line.startsWith("Compressing objects:") && !line.startsWith("Cloning into") && !line.startsWith("remote:")) {
+            errorLines.push(line);
+            if (errorLines.length > 10) errorLines.shift();
+          }
+        }
+      });
+      child.on("error", (err) => reject(err));
+      child.on("close", async (code) => {
+        if (code === 0) {
+          try {
+            await createSafeGit(void 0, sessionId).raw([
+              "config",
+              "--global",
+              "--add",
+              "safe.directory",
+              destPath
+            ]);
+          } catch {
+          }
+          resolve();
+        } else {
+          const token = getToken(sessionId);
+          let errorMsg = errorLines.join("\n") || `Git clone failed (exit code ${code})`;
+          if (token) {
+            errorMsg = errorMsg.split(token).join("***");
+          }
+          errorMsg = errorMsg.replace(/https:\/\/[^@]+@github\.com/g, "https://github.com");
+          if (errorMsg.includes("terminal prompts disabled") || errorMsg.includes("Authentication failed") || errorMsg.includes("could not read Username")) {
+            reject(
+              new Error(
+                "Authentication failed for GitHub repository. Please verify your account is logged in and has access to this repository."
+              )
+            );
+          } else {
+            reject(new Error(errorMsg));
+          }
+        }
+      });
+    });
     return destPath;
   } catch (err) {
     const token = getToken(sessionId);
@@ -1436,6 +1547,75 @@ async function removeGitMetadata(_sessionId, repoPath) {
     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.
@@ -2037,11 +2217,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;
     }
@@ -2290,6 +2474,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,7 +10,7 @@ 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),
@@ -78,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),