lula2 0.6.6-nightly.0 → 0.7.0

package/dist/cli/server/spreadsheetRoutes.js

@@ -7,7 +7,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { glob } from "glob";
 import * as yaml4 from "js-yaml";
 import multer from "multer";
-import { dirname, join as join2, relative } from "path";
+import { dirname, join as join2, relative as relative2 } from "path";
 
 // cli/utils/debug.ts
 var debugEnabled = false;
@@ -27,10 +27,803 @@ import * as yaml2 from "js-yaml";
 import * as yaml from "js-yaml";
 
 // cli/server/infrastructure/gitHistory.ts
+import * as fs 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";
+function createYamlDiff(oldYaml, newYaml, isArrayFile = false) {
+  try {
+    const emptyDefault = isArrayFile ? "[]" : "{}";
+    const oldData = yaml3.load(oldYaml || emptyDefault);
+    const newData = yaml3.load(newYaml || emptyDefault);
+    const changes = compareValues(oldData, newData, "");
+    return {
+      hasChanges: changes.length > 0,
+      changes,
+      summary: generateSummary(changes)
+    };
+  } catch (error) {
+    console.error("Error parsing YAML for diff:", error);
+    return {
+      hasChanges: false,
+      changes: [],
+      summary: "Error parsing YAML content"
+    };
+  }
+}
+function compareValues(oldValue, newValue, basePath) {
+  const changes = [];
+  if (oldValue === null || oldValue === void 0) {
+    if (newValue !== null && newValue !== void 0) {
+      changes.push({
+        type: "added",
+        path: basePath || "root",
+        newValue,
+        description: `Added ${basePath || "content"}`
+      });
+    }
+    return changes;
+  }
+  if (newValue === null || newValue === void 0) {
+    changes.push({
+      type: "removed",
+      path: basePath || "root",
+      oldValue,
+      description: `Removed ${basePath || "content"}`
+    });
+    return changes;
+  }
+  if (Array.isArray(oldValue) || Array.isArray(newValue)) {
+    return compareArrays(oldValue, newValue, basePath);
+  }
+  if (typeof oldValue === "object" && typeof newValue === "object") {
+    return compareObjects(oldValue, newValue, basePath);
+  }
+  if (oldValue !== newValue) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue,
+      newValue,
+      description: `Changed ${basePath || "value"}`
+    });
+  }
+  return changes;
+}
+function compareObjects(oldObj, newObj, basePath) {
+  const changes = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(oldObj), ...Object.keys(newObj)]);
+  for (const key of allKeys) {
+    const currentPath = basePath ? `${basePath}.${key}` : key;
+    const oldValue = oldObj[key];
+    const newValue = newObj[key];
+    if (!(key in oldObj)) {
+      changes.push({
+        type: "added",
+        path: currentPath,
+        newValue,
+        description: `Added ${key}`
+      });
+    } else if (!(key in newObj)) {
+      changes.push({
+        type: "removed",
+        path: currentPath,
+        oldValue,
+        description: `Removed ${key}`
+      });
+    } else if (!deepEqual(oldValue, newValue)) {
+      if (typeof oldValue === "object" && typeof newValue === "object") {
+        changes.push(...compareValues(oldValue, newValue, currentPath));
+      } else {
+        changes.push({
+          type: "modified",
+          path: currentPath,
+          oldValue,
+          newValue,
+          description: `Changed ${key}`
+        });
+      }
+    }
+  }
+  return changes;
+}
+function compareArrays(oldArr, newArr, basePath) {
+  const changes = [];
+  if (!Array.isArray(oldArr) && Array.isArray(newArr)) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Changed ${basePath || "value"} from non-array to array`
+    });
+    return changes;
+  }
+  if (Array.isArray(oldArr) && !Array.isArray(newArr)) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Changed ${basePath || "value"} from array to non-array`
+    });
+    return changes;
+  }
+  const oldArray = oldArr;
+  const newArray = newArr;
+  if (isMappingArray(oldArray) || isMappingArray(newArray)) {
+    return compareMappingArrays(oldArray, newArray, basePath);
+  }
+  if (oldArray.length !== newArray.length) {
+    changes.push({
+      type: "modified",
+      path: basePath || "root",
+      oldValue: oldArray,
+      newValue: newArray,
+      description: `Array ${basePath || "items"} changed from ${oldArray.length} to ${newArray.length} items`
+    });
+  } else {
+    for (let i = 0; i < oldArray.length; i++) {
+      const elementPath = `${basePath}[${i}]`;
+      if (!deepEqual(oldArray[i], newArray[i])) {
+        changes.push(...compareValues(oldArray[i], newArray[i], elementPath));
+      }
+    }
+  }
+  return changes;
+}
+function isMappingArray(arr) {
+  if (!Array.isArray(arr) || arr.length === 0) return false;
+  const firstItem = arr[0];
+  return typeof firstItem === "object" && firstItem !== null && "control_id" in firstItem && "uuid" in firstItem;
+}
+function compareMappingArrays(oldArr, newArr, basePath) {
+  const changes = [];
+  const oldMappings = /* @__PURE__ */ new Map();
+  const newMappings = /* @__PURE__ */ new Map();
+  for (const item of oldArr) {
+    if (typeof item === "object" && item !== null && "uuid" in item) {
+      oldMappings.set(item.uuid, item);
+    }
+  }
+  for (const item of newArr) {
+    if (typeof item === "object" && item !== null && "uuid" in item) {
+      newMappings.set(item.uuid, item);
+    }
+  }
+  for (const [uuid, mapping] of newMappings) {
+    if (!oldMappings.has(uuid)) {
+      changes.push({
+        type: "added",
+        path: `mapping`,
+        newValue: mapping,
+        description: `Added mapping`
+      });
+    }
+  }
+  for (const [uuid, mapping] of oldMappings) {
+    if (!newMappings.has(uuid)) {
+      changes.push({
+        type: "removed",
+        path: `mapping`,
+        oldValue: mapping,
+        description: `Removed mapping`
+      });
+    }
+  }
+  for (const [uuid, oldMapping] of oldMappings) {
+    if (newMappings.has(uuid)) {
+      const newMapping = newMappings.get(uuid);
+      if (!deepEqual(oldMapping, newMapping)) {
+        changes.push({
+          type: "modified",
+          path: `mapping`,
+          oldValue: oldMapping,
+          newValue: newMapping,
+          description: `Modified mapping`
+        });
+      }
+    }
+  }
+  if (changes.length === 0 && oldArr.length !== newArr.length) {
+    changes.push({
+      type: "modified",
+      path: basePath || "mappings",
+      oldValue: oldArr,
+      newValue: newArr,
+      description: `Mappings changed from ${oldArr.length} to ${newArr.length} items`
+    });
+  }
+  return changes;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null) return false;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!bKeys.includes(key)) return false;
+      if (!deepEqual(aObj[key], bObj[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+function generateSummary(changes) {
+  if (changes.length === 0) {
+    return "No changes detected";
+  }
+  const added = changes.filter((c) => c.type === "added").length;
+  const removed = changes.filter((c) => c.type === "removed").length;
+  const modified = changes.filter((c) => c.type === "modified").length;
+  const parts = [];
+  if (added > 0) parts.push(`${added} added`);
+  if (removed > 0) parts.push(`${removed} removed`);
+  if (modified > 0) parts.push(`${modified} modified`);
+  return parts.join(", ");
+}
+
+// cli/server/infrastructure/gitHistory.ts
+var GitHistoryUtil = class {
+  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, 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
+   */
+  async isGitRepository() {
+    try {
+      const gitDir = await git.findRoot({ fs, filepath: process.cwd() });
+      return !!gitDir;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get git history for a specific file
+   */
+  async getFileHistory(filePath, limit = 50) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return {
+        filePath,
+        commits: [],
+        totalCommits: 0,
+        firstCommit: null,
+        lastCommit: null
+      };
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      const commits = await git.log({
+        fs,
+        dir: gitRoot,
+        filepath: relativePath,
+        depth: limit
+      });
+      if (!commits || commits.length === 0) {
+        return {
+          filePath,
+          commits: [],
+          totalCommits: 0,
+          firstCommit: null,
+          lastCommit: null
+        };
+      }
+      const gitCommits = await this.convertIsomorphicCommits(commits, relativePath, gitRoot);
+      return {
+        filePath,
+        commits: gitCommits,
+        totalCommits: gitCommits.length,
+        firstCommit: gitCommits[gitCommits.length - 1] || null,
+        lastCommit: gitCommits[0] || null
+      };
+    } catch (error) {
+      const err = error;
+      if (err?.code === "NotFoundError" || err?.message?.includes("Could not find file")) {
+        return {
+          filePath,
+          commits: [],
+          totalCommits: 0,
+          firstCommit: null,
+          lastCommit: null
+        };
+      }
+      console.error(`Unexpected error getting git history for ${filePath}:`, error);
+      return {
+        filePath,
+        commits: [],
+        totalCommits: 0,
+        firstCommit: null,
+        lastCommit: null
+      };
+    }
+  }
+  /**
+   * Get the total number of commits for a file
+   */
+  async getFileCommitCount(filePath) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return 0;
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      const commits = await git.log({
+        fs,
+        dir: gitRoot,
+        filepath: relativePath
+      });
+      return commits.length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get the latest commit info for a file
+   */
+  async getLatestCommit(filePath) {
+    const history = await this.getFileHistory(filePath, 1);
+    return history.lastCommit;
+  }
+  /**
+   * Get file content at a specific commit (public method)
+   */
+  async getFileContentAtCommit(filePath, commitHash) {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return null;
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs, filepath: process.cwd() });
+      const relativePath = relative(gitRoot, filePath);
+      return await this.getFileAtCommit(commitHash, relativePath, gitRoot);
+    } catch (error) {
+      console.error(`Error getting file content at commit ${commitHash}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Convert isomorphic-git commits to our GitCommit format
+   */
+  async convertIsomorphicCommits(commits, relativePath, gitRoot) {
+    const gitCommits = [];
+    for (let i = 0; i < commits.length; i++) {
+      const commit = commits[i];
+      const includeDiff = i < 5;
+      let changes = { insertions: 0, deletions: 0, files: 1 };
+      let diff;
+      let yamlDiff;
+      if (includeDiff) {
+        try {
+          const diffResult = await this.getCommitDiff(commit.oid, relativePath, gitRoot);
+          changes = diffResult.changes;
+          diff = diffResult.diff;
+          yamlDiff = diffResult.yamlDiff;
+        } catch {
+        }
+      }
+      gitCommits.push({
+        hash: commit.oid,
+        shortHash: commit.oid.substring(0, 7),
+        author: commit.commit.author.name,
+        authorEmail: commit.commit.author.email,
+        date: new Date(commit.commit.author.timestamp * 1e3).toISOString(),
+        message: commit.commit.message,
+        changes,
+        ...diff && { diff },
+        ...yamlDiff && { yamlDiff }
+      });
+    }
+    return gitCommits;
+  }
+  /**
+   * Get diff for a specific commit and file
+   */
+  async getCommitDiff(commitOid, relativePath, gitRoot) {
+    try {
+      const commit = await git.readCommit({ fs, dir: gitRoot, oid: commitOid });
+      const parentOid = commit.commit.parent.length > 0 ? commit.commit.parent[0] : null;
+      if (!parentOid) {
+        const currentContent2 = await this.getFileAtCommit(commitOid, relativePath, gitRoot);
+        if (currentContent2) {
+          const lines = currentContent2.split("\n");
+          const isMappingFile2 = relativePath.includes("-mappings.yaml");
+          const yamlDiff2 = createYamlDiff("", currentContent2, isMappingFile2);
+          return {
+            changes: { insertions: lines.length, deletions: 0, files: 1 },
+            diff: `--- /dev/null
++++ b/${relativePath}
+@@ -0,0 +1,${lines.length} @@
+` + lines.map((line) => "+" + line).join("\n"),
+            yamlDiff: yamlDiff2
+          };
+        }
+        return { changes: { insertions: 0, deletions: 0, files: 1 } };
+      }
+      const currentContent = await this.getFileAtCommit(commitOid, relativePath, gitRoot);
+      const parentContent = await this.getFileAtCommit(parentOid, relativePath, gitRoot);
+      if (!currentContent && !parentContent) {
+        return { changes: { insertions: 0, deletions: 0, files: 1 } };
+      }
+      const currentLines = currentContent ? currentContent.split("\n") : [];
+      const parentLines = parentContent ? parentContent.split("\n") : [];
+      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);
+      return {
+        changes: { insertions, deletions, files: 1 },
+        diff,
+        yamlDiff
+      };
+    } catch {
+      return { changes: { insertions: 0, deletions: 0, files: 1 } };
+    }
+  }
+  /**
+   * Get file content at a specific commit
+   */
+  async getFileAtCommit(commitOid, filepath, gitRoot) {
+    try {
+      const { blob } = await git.readBlob({
+        fs,
+        dir: gitRoot,
+        oid: commitOid,
+        filepath
+      });
+      return new TextDecoder().decode(blob);
+    } catch (_error) {
+      return null;
+    }
+  }
+  /**
+   * Create a simple unified diff between two file versions
+   */
+  async createSimpleDiff(oldLines, newLines, filepath) {
+    const diffLines = [];
+    diffLines.push(`--- a/${filepath}`);
+    diffLines.push(`+++ b/${filepath}`);
+    const oldCount = oldLines.length;
+    const newCount = newLines.length;
+    diffLines.push(`@@ -1,${oldCount} +1,${newCount} @@`);
+    let i = 0, j = 0;
+    while (i < oldLines.length || j < newLines.length) {
+      if (i < oldLines.length && j < newLines.length && oldLines[i] === newLines[j]) {
+        diffLines.push(` ${oldLines[i]}`);
+        i++;
+        j++;
+      } else if (i < oldLines.length && (j >= newLines.length || oldLines[i] !== newLines[j])) {
+        diffLines.push(`-${oldLines[i]}`);
+        i++;
+      } else if (j < newLines.length) {
+        diffLines.push(`+${newLines[j]}`);
+        j++;
+      }
+    }
+    return diffLines.join("\n");
+  }
+  /**
+   * Count insertions and deletions between two file versions
+   */
+  countChanges(oldLines, newLines) {
+    let insertions = 0;
+    let deletions = 0;
+    const maxLines = Math.max(oldLines.length, newLines.length);
+    for (let i = 0; i < maxLines; i++) {
+      const oldLine = i < oldLines.length ? oldLines[i] : null;
+      const newLine = i < newLines.length ? newLines[i] : null;
+      if (oldLine === null) {
+        insertions++;
+      } else if (newLine === null) {
+        deletions++;
+      } else if (oldLine !== newLine) {
+        insertions++;
+        deletions++;
+      }
+    }
+    return { insertions, deletions };
+  }
+  /**
+   * Get git stats for the entire repository
+   */
+  async getRepositoryStats() {
+    const isGitRepo = await this.isGitRepository();
+    if (!isGitRepo) {
+      return {
+        totalCommits: 0,
+        contributors: 0,
+        lastCommitDate: null,
+        firstCommitDate: null
+      };
+    }
+    try {
+      const gitRoot = await git.findRoot({ fs, filepath: process.cwd() });
+      const commits = await git.log({ fs, dir: gitRoot });
+      const contributorEmails = /* @__PURE__ */ new Set();
+      commits.forEach((commit) => {
+        contributorEmails.add(commit.commit.author.email);
+      });
+      const firstCommit = commits[commits.length - 1];
+      const lastCommit = commits[0];
+      return {
+        totalCommits: commits.length,
+        contributors: contributorEmails.size,
+        lastCommitDate: lastCommit ? new Date(lastCommit.commit.author.timestamp * 1e3).toISOString() : null,
+        firstCommitDate: firstCommit ? new Date(firstCommit.commit.author.timestamp * 1e3).toISOString() : null
+      };
+    } catch (error) {
+      console.error("Error getting repository stats:", error);
+      return {
+        totalCommits: 0,
+        contributors: 0,
+        lastCommitDate: null,
+        firstCommitDate: null
+      };
+    }
+  }
+  /**
+   * Get current branch name
+   */
+  async getCurrentBranch() {
+    try {
+      const isGitRepo = await this.isGitRepository();
+      if (!isGitRepo) {
+        return null;
+      }
+      const gitRoot = await git.findRoot({ fs, filepath: process.cwd() });
+      const branch = await git.currentBranch({ fs, 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, filepath: process.cwd() });
+      const localCommits = await git.log({ fs, dir: gitRoot, ref: branchName });
+      try {
+        const remotes = await git.listRemotes({ fs, 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, 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, filepath: process.cwd() });
+      const remotes = await git.listRemotes({ fs, 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, filepath: process.cwd() });
+      const remotes = await git.listRemotes({ fs, 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
 var serverState = void 0;
@@ -66,7 +859,7 @@ async function scanControlSets() {
   const controlSets = files.map((file) => {
     const fullPath = join2(baseDir, file);
     const dirPath = dirname(fullPath);
-    const relativePath = relative(baseDir, dirPath) || ".";
+    const relativePath = relative2(baseDir, dirPath) || ".";
     try {
       const content = readFileSync(fullPath, "utf8");
       const data = yaml4.load(content);
@@ -1076,6 +1869,32 @@ router.post("/parse-excel-sheet-previews", upload.single("file"), async (req, re
     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" });
+  }
+});
 var spreadsheetRoutes_default = router;
 export {
   applyNamingConvention,