lula2 0.6.6-nightly.0 → 0.7.0

package/dist/cli/server/index.js

@@ -2437,13 +2437,10 @@ var init_yamlDiff = __esm({
 });
 
 // cli/server/infrastructure/gitHistory.ts
-var gitHistory_exports = {};
-__export(gitHistory_exports, {
-  GitHistoryUtil: () => GitHistoryUtil
-});
 import * as fs2 from "fs";
 import * as git from "isomorphic-git";
 import { relative } from "path";
+import { execSync } from "child_process";
 var GitHistoryUtil;
 var init_gitHistory = __esm({
   "cli/server/infrastructure/gitHistory.ts"() {
@@ -2451,8 +2448,30 @@ var init_gitHistory = __esm({
     init_yamlDiff();
     GitHistoryUtil = class {
       baseDir;
-      constructor(baseDir) {
+      execSync;
+      constructor(baseDir, execSyncFn) {
         this.baseDir = baseDir;
+        this.execSync = execSyncFn || execSync;
+      }
+      /**
+       * Execute a git command using native git binary with credentials support
+       */
+      async executeGitCommand(command, cwd) {
+        try {
+          const workingDir = cwd || await git.findRoot({ fs: fs2, filepath: process.cwd() });
+          const output = this.execSync(command, {
+            cwd: workingDir,
+            encoding: "utf8",
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          return { success: true, output: output.toString() };
+        } catch (error) {
+          return {
+            success: false,
+            output: "",
+            error: error.stderr?.toString() || error.message
+          };
+        }
       }
       /**
        * Check if the directory is a git repository
@@ -2636,7 +2655,7 @@ var init_gitHistory = __esm({
           }
           const currentLines = currentContent ? currentContent.split("\n") : [];
           const parentLines = parentContent ? parentContent.split("\n") : [];
-          const diff = this.createSimpleDiff(parentLines, currentLines, relativePath);
+          const diff = await this.createSimpleDiff(parentLines, currentLines, relativePath);
           const { insertions, deletions } = this.countChanges(parentLines, currentLines);
           const isMappingFile = relativePath.includes("-mappings.yaml");
           const yamlDiff = createYamlDiff(parentContent || "", currentContent || "", isMappingFile);
@@ -2668,7 +2687,7 @@ var init_gitHistory = __esm({
       /**
        * Create a simple unified diff between two file versions
        */
-      createSimpleDiff(oldLines, newLines, filepath) {
+      async createSimpleDiff(oldLines, newLines, filepath) {
         const diffLines = [];
         diffLines.push(`--- a/${filepath}`);
         diffLines.push(`+++ b/${filepath}`);
@@ -2750,6 +2769,227 @@ var init_gitHistory = __esm({
           };
         }
       }
+      /**
+       * Get current branch name
+       */
+      async getCurrentBranch() {
+        try {
+          const isGitRepo = await this.isGitRepository();
+          if (!isGitRepo) {
+            return null;
+          }
+          const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+          const branch = await git.currentBranch({ fs: fs2, dir: gitRoot });
+          return branch || null;
+        } catch (error) {
+          console.error("Error getting current branch:", error);
+          return null;
+        }
+      }
+      /**
+       * Get git status information
+       */
+      async getGitStatus() {
+        try {
+          const isGitRepo = await this.isGitRepository();
+          if (!isGitRepo) {
+            return {
+              isGitRepository: false,
+              currentBranch: null,
+              branchInfo: null,
+              canPull: false,
+              canPush: false
+            };
+          }
+          const currentBranch2 = await this.getCurrentBranch();
+          if (!currentBranch2) {
+            return {
+              isGitRepository: true,
+              currentBranch: null,
+              branchInfo: null,
+              canPull: false,
+              canPush: false
+            };
+          }
+          const branchInfo = await this.getBranchInfo(currentBranch2);
+          return {
+            isGitRepository: true,
+            currentBranch: currentBranch2,
+            branchInfo,
+            canPull: branchInfo?.isBehind || false,
+            canPush: branchInfo?.isAhead || false
+          };
+        } catch (error) {
+          console.error("Error getting git status:", error);
+          return {
+            isGitRepository: false,
+            currentBranch: null,
+            branchInfo: null,
+            canPull: false,
+            canPush: false
+          };
+        }
+      }
+      /**
+       * Get branch comparison information
+       */
+      async getBranchInfo(branchName) {
+        try {
+          const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+          const localCommits = await git.log({ fs: fs2, dir: gitRoot, ref: branchName });
+          try {
+            const remotes = await git.listRemotes({ fs: fs2, dir: gitRoot });
+            for (const remote of remotes) {
+              try {
+                const fetchResult = await this.executeGitCommand(`git fetch ${remote.remote}`, gitRoot);
+                if (!fetchResult.success) {
+                  console.warn(`Could not fetch from remote ${remote.remote}:`, fetchResult.error);
+                }
+              } catch (fetchError) {
+                console.warn(`Could not fetch from remote ${remote.remote}:`, fetchError);
+              }
+            }
+            let remoteCommits = [];
+            let foundRemote = false;
+            for (const remote of remotes) {
+              const remoteBranchRef = `${remote.remote}/${branchName}`;
+              try {
+                remoteCommits = await git.log({ fs: fs2, dir: gitRoot, ref: remoteBranchRef });
+                foundRemote = true;
+                break;
+              } catch (error) {
+                console.warn(`Could not get commits for ${remoteBranchRef}: ${error}`);
+              }
+            }
+            if (!foundRemote || remoteCommits.length === 0) {
+              const lastCommit2 = localCommits[0];
+              return {
+                currentBranch: branchName,
+                isAhead: false,
+                isBehind: false,
+                aheadCount: 0,
+                behindCount: 0,
+                lastCommitDate: lastCommit2 ? new Date(lastCommit2.commit.author.timestamp * 1e3).toISOString() : null,
+                lastCommitMessage: lastCommit2?.commit.message || null,
+                hasUnpushedChanges: false
+              };
+            }
+            const localHashes = new Set(localCommits.map((c) => c.oid));
+            const remoteHashes = new Set(remoteCommits.map((c) => c.oid));
+            const aheadCount = localCommits.filter((c) => !remoteHashes.has(c.oid)).length;
+            const behindCount = remoteCommits.filter((c) => !localHashes.has(c.oid)).length;
+            const lastCommit = localCommits[0];
+            return {
+              currentBranch: branchName,
+              isAhead: aheadCount > 0,
+              isBehind: behindCount > 0,
+              aheadCount,
+              behindCount,
+              lastCommitDate: lastCommit ? new Date(lastCommit.commit.author.timestamp * 1e3).toISOString() : null,
+              lastCommitMessage: lastCommit?.commit.message || null,
+              hasUnpushedChanges: aheadCount > 0
+            };
+          } catch {
+            const lastCommit = localCommits[0];
+            return {
+              currentBranch: branchName,
+              isAhead: false,
+              isBehind: false,
+              aheadCount: 0,
+              behindCount: 0,
+              lastCommitDate: lastCommit ? new Date(lastCommit.commit.author.timestamp * 1e3).toISOString() : null,
+              lastCommitMessage: lastCommit?.commit.message || null,
+              hasUnpushedChanges: false
+            };
+          }
+        } catch (error) {
+          console.error("Error getting branch info:", error);
+          return null;
+        }
+      }
+      /**
+       * Fetch updates from remote repositories using native git command
+       */
+      async fetchFromRemotes() {
+        try {
+          const isGitRepo = await this.isGitRepository();
+          if (!isGitRepo) {
+            return { success: false, message: "Not a git repository", details: [] };
+          }
+          const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+          const remotes = await git.listRemotes({ fs: fs2, dir: gitRoot });
+          if (remotes.length === 0) {
+            return { success: true, message: "No remotes configured", details: [] };
+          }
+          const details = [];
+          let hasErrors = false;
+          for (const remote of remotes) {
+            try {
+              const fetchResult = await this.executeGitCommand(`git fetch ${remote.remote}`, gitRoot);
+              if (fetchResult.success) {
+                details.push(`Fetched from ${remote.remote}`);
+              } else {
+                details.push(`Failed to fetch from ${remote.remote}: ${fetchResult.error}`);
+                hasErrors = true;
+              }
+            } catch (error) {
+              details.push(`Error fetching from ${remote.remote}: ${error}`);
+              hasErrors = true;
+            }
+          }
+          return {
+            success: !hasErrors,
+            message: hasErrors ? "Fetch completed with some errors" : "Successfully fetched from all remotes",
+            details
+          };
+        } catch (error) {
+          console.error("Error fetching from remotes:", error);
+          return {
+            success: false,
+            message: error instanceof Error ? error.message : "Unknown error occurred",
+            details: []
+          };
+        }
+      }
+      /**
+       * Pull changes from remote using native git command
+       */
+      async pullChanges() {
+        try {
+          const isGitRepo = await this.isGitRepository();
+          if (!isGitRepo) {
+            return { success: false, message: "Not a git repository" };
+          }
+          const currentBranch2 = await this.getCurrentBranch();
+          if (!currentBranch2) {
+            return { success: false, message: "No current branch found" };
+          }
+          const gitRoot = await git.findRoot({ fs: fs2, filepath: process.cwd() });
+          const remotes = await git.listRemotes({ fs: fs2, dir: gitRoot });
+          if (remotes.length === 0) {
+            return { success: false, message: "No remotes configured" };
+          }
+          const targetRemote = remotes[0].remote;
+          const pullCommand = `git pull ${targetRemote} ${currentBranch2}`;
+          const pullResult = await this.executeGitCommand(pullCommand, gitRoot);
+          if (!pullResult.success) {
+            return {
+              success: false,
+              message: `Failed to pull changes: ${pullResult.error}`
+            };
+          }
+          return {
+            success: true,
+            message: pullResult.output || "Successfully pulled changes"
+          };
+        } catch (error) {
+          console.error("Error pulling changes:", error);
+          return {
+            success: false,
+            message: error instanceof Error ? error.message : "Unknown error occurred"
+          };
+        }
+      }
     };
   }
 });
@@ -3600,6 +3840,7 @@ var init_spreadsheetRoutes = __esm({
     "use strict";
     init_debug();
     init_serverState();
+    init_gitHistory();
     MAX_HEADER_CANDIDATES = 5;
     PREVIEW_COLUMNS = 4;
     router = express.Router();
@@ -3919,6 +4160,32 @@ var init_spreadsheetRoutes = __esm({
         res.status(500).json({ error: "Failed to get sheet previews" });
       }
     });
+    router.get("/git-status", async (req, res) => {
+      try {
+        const state = getServerState();
+        const gitUtil = new GitHistoryUtil(state.CONTROL_SET_DIR);
+        const gitStatus = await gitUtil.getGitStatus();
+        res.json(gitStatus);
+      } catch (error) {
+        console.error("Error getting git status:", error);
+        res.status(500).json({ error: "Failed to get git status" });
+      }
+    });
+    router.post("/git-pull", async (req, res) => {
+      try {
+        const state = getServerState();
+        const gitUtil = new GitHistoryUtil(state.CONTROL_SET_DIR);
+        const result = await gitUtil.pullChanges();
+        if (result.success) {
+          res.json(result);
+        } else {
+          res.status(400).json(result);
+        }
+      } catch (error) {
+        console.error("Error pulling changes:", error);
+        res.status(500).json({ error: "Failed to pull changes" });
+      }
+    });
     spreadsheetRoutes_default = router;
   }
 });
@@ -4795,6 +5062,7 @@ import { readFileSync as readFileSync4 } from "fs";
 init_debug();
 init_controlHelpers();
 init_serverState();
+init_gitHistory();
 import * as yaml5 from "js-yaml";
 import { join as join5 } from "path";
 import { WebSocket, WebSocketServer } from "ws";
@@ -4958,8 +5226,7 @@ var WebSocketManager = class {
               if (!control.id) {
                 control.id = controlId;
               }
-              const { GitHistoryUtil: GitHistoryUtil2 } = await Promise.resolve().then(() => (init_gitHistory(), gitHistory_exports));
-              const { execSync } = await import("child_process");
+              const { execSync: execSync2 } = await import("child_process");
               let timeline = null;
               try {
                 const currentPath2 = getCurrentControlSetPath();
@@ -4999,7 +5266,7 @@ var WebSocketManager = class {
                   console.error(`Could not find file for control ${control.id}`);
                   timeline = null;
                 } else {
-                  const gitUtil = new GitHistoryUtil2(currentPath2);
+                  const gitUtil = new GitHistoryUtil(currentPath2);
                   const controlHistory = await gitUtil.getFileHistory(controlPath);
                   debug(`Git history for ${control.id}:`, {
                     path: controlPath,
@@ -5020,12 +5287,12 @@ var WebSocketManager = class {
                   let hasPendingChanges = false;
                   try {
                     try {
-                      execSync(`git ls-files --error-unmatch "${controlPath}"`, {
+                      execSync2(`git ls-files --error-unmatch "${controlPath}"`, {
                         encoding: "utf8",
                         cwd: process.cwd(),
                         stdio: "pipe"
                       });
-                      const gitStatus = execSync(`git status --porcelain "${controlPath}"`, {
+                      const gitStatus = execSync2(`git status --porcelain "${controlPath}"`, {
                         encoding: "utf8",
                         cwd: process.cwd()
                       }).trim();
@@ -5044,12 +5311,12 @@ var WebSocketManager = class {
                   if (existsSync5(mappingPath)) {
                     try {
                       try {
-                        execSync(`git ls-files --error-unmatch "${mappingPath}"`, {
+                        execSync2(`git ls-files --error-unmatch "${mappingPath}"`, {
                           encoding: "utf8",
                           cwd: process.cwd(),
                           stdio: "pipe"
                         });
-                        const gitStatus = execSync(`git status --porcelain "${mappingPath}"`, {
+                        const gitStatus = execSync2(`git status --porcelain "${mappingPath}"`, {
                           encoding: "utf8",
                           cwd: process.cwd()
                         }).trim();