lula2 0.6.6-nightly.0 → 0.7.0

package/dist/cli/server/server.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();

package/dist/cli/server/serverState.js

@@ -608,6 +608,7 @@ var FileStore = class {
 import * as fs2 from "fs";
 import * as git from "isomorphic-git";
 import { relative } from "path";
+import { execSync } from "child_process";
 
 // cli/server/infrastructure/yamlDiff.ts
 import * as yaml3 from "js-yaml";
@@ -858,8 +859,30 @@ function generateSummary(changes) {
 // cli/server/infrastructure/gitHistory.ts
 var 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
@@ -1043,7 +1066,7 @@ var GitHistoryUtil = class {
       }
       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);
@@ -1075,7 +1098,7 @@ var GitHistoryUtil = class {
   /**
    * 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}`);
@@ -1157,6 +1180,227 @@ var GitHistoryUtil = class {
       };
     }
   }
+  /**
+   * 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"
+      };
+    }
+  }
 };
 
 // cli/server/serverState.ts