codeant-cli 0.1.0

package/src/utils/gitDiffHelper.js

@@ -0,0 +1,762 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+
+const execAsync = promisify(exec);
+
+class GitDiffHelper {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.gitRoot = null;
+    this.currentBranch = null;
+    this.defaultBranch = null;
+    this.baseCommit = null;
+  }
+
+  /**
+   * Find the git root directory by traversing up from the workspace path
+   */
+  async findGitRoot(directory) {
+    try {
+      // First check current directory
+      const files = await fs.readdir(directory);
+      if (files.includes('.git')) {
+        return directory;
+      }
+
+      // Traverse up to parent directories
+      let currentDir = directory;
+      while (currentDir !== path.dirname(currentDir)) {
+        currentDir = path.dirname(currentDir);
+        try {
+          const parentFiles = await fs.readdir(currentDir);
+          if (parentFiles.includes('.git')) {
+            return currentDir;
+          }
+        } catch (err) {
+          break;
+        }
+      }
+
+      return null;
+    } catch (error) {
+      console.error(`Error finding git root: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Initialize the helper: finds git root, current branch, default branch, and base commit
+   */
+  async init() {
+    // Find git root
+    this.gitRoot = await this.findGitRoot(this.workspacePath);
+    if (!this.gitRoot) {
+      throw new Error('Could not find a .git directory.');
+    }
+
+    try {
+      // Try to fetch origin (silently fails if no remote)
+      await this.fetchOrigin();
+    } catch (err) {
+      // No remote, continue anyway
+    }
+
+    try {
+      // Get current branch
+      const { stdout: branchName } = await execAsync(
+        'git rev-parse --abbrev-ref HEAD',
+        { cwd: this.gitRoot }
+      );
+      this.currentBranch = branchName.trim();
+    } catch (err) {
+      this.currentBranch = 'main';
+    }
+
+    // Determine default branch
+    try {
+      const { stdout: remoteBranch } = await execAsync(
+        'git rev-parse --abbrev-ref origin/HEAD',
+        { cwd: this.gitRoot }
+      );
+      this.defaultBranch = remoteBranch.trim().replace('origin/', '');
+    } catch (err) {
+      this.defaultBranch = 'main';
+    }
+
+    // Find merge base commit or fallback to HEAD
+    try {
+      const { stdout: mergeBase } = await execAsync(
+        `git merge-base ${this.currentBranch} origin/${this.defaultBranch}`,
+        { cwd: this.gitRoot }
+      );
+      this.baseCommit = mergeBase.trim();
+    } catch (err) {
+      // Fallback to HEAD if no merge base found
+      try {
+        const { stdout: head } = await execAsync(
+          'git rev-parse HEAD',
+          { cwd: this.gitRoot }
+        );
+        this.baseCommit = head.trim();
+      } catch (headErr) {
+        // No commits yet - set to empty tree
+        this.baseCommit = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+      }
+    }
+  }
+
+  async fetchOrigin() {
+    try {
+      await execAsync('git fetch origin', { cwd: this.gitRoot });
+    } catch (err) {
+      // Silently continue if fetch fails (e.g., offline)
+    }
+  }
+
+  /**
+   * Get all branches (local and remote)
+   */
+  async getAllBranches() {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const { stdout: branchesStr } = await execAsync(
+      'git branch -a --format="%(refname:short)"',
+      { cwd: this.gitRoot }
+    );
+
+    const branches = branchesStr
+      .split('\n')
+      .map(b => b.trim())
+      .filter(Boolean)
+      .map(b => b.replace('origin/', ''))
+      .filter((value, index, self) => self.indexOf(value) === index);
+
+    return branches;
+  }
+
+  /**
+   * Get recent commits with metadata
+   */
+  async getRecentCommits(limit = 10) {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const { stdout: commitsStr } = await execAsync(
+      `git log --pretty=format:"%H|%s|%an|%ar" -n ${limit}`,
+      { cwd: this.gitRoot }
+    );
+
+    const commits = commitsStr
+      .split('\n')
+      .filter(Boolean)
+      .map(line => {
+        const [hash, message, author, date] = line.split('|');
+        return { hash, message, author, date };
+      });
+
+    return commits;
+  }
+
+  /**
+   * Get files changed since merge base
+   */
+  async getChangedFiles() {
+    if (!this.gitRoot || !this.baseCommit) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const cmd = [
+      `git diff --name-only --diff-filter=ACMRD ${this.baseCommit}`,
+      `git diff --name-only --cached --diff-filter=ACMRD`,
+      `git ls-files --others --exclude-standard`
+    ].join(' && ');
+
+    const { stdout: changedFiles } = await execAsync(cmd, { cwd: this.gitRoot });
+
+    const uniqueFiles = Array.from(new Set(
+      changedFiles
+        .split('\n')
+        .map(f => f.trim())
+        .filter(Boolean)
+    ));
+
+    return uniqueFiles;
+  }
+
+  /**
+   * Get staged files only
+   */
+  async getStagedFiles() {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const { stdout: stagedFiles } = await execAsync(
+      'git diff --name-only --cached',
+      { cwd: this.gitRoot }
+    );
+
+    return stagedFiles
+      .split('\n')
+      .map(f => f.trim())
+      .filter(Boolean);
+  }
+
+  /**
+   * Get diff based on review configuration
+   */
+  async getDiffBasedOnReviewConfig(reviewConfig = null) {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const config = reviewConfig || {
+      type: 'branch-diff',
+      targetBranch: this.defaultBranch,
+      commits: null
+    };
+
+    switch (config.type) {
+      case 'branch-diff':
+        return this.getAllDiffInfo();
+
+      case 'last-commit':
+        return this._getLastCommitDiff();
+
+      case 'select-commits':
+        if (!config.commits || config.commits.length === 0) {
+          return [];
+        }
+        return this._getSpecificCommitsDiff(config.commits);
+
+      case 'uncommitted':
+        return this._getUncommittedChanges();
+
+      case 'staged-only':
+        return this._getStagedChanges();
+
+      case 'unpushed':
+        return this.getUnpushedChangesDiff();
+
+      default:
+        return this.getAllDiffInfo();
+    }
+  }
+
+  async _getLastCommitDiff() {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    // First check if there are any commits
+    try {
+      await execAsync('git rev-parse HEAD', { cwd: this.gitRoot });
+    } catch (err) {
+      // No commits at all
+      return [];
+    }
+
+    try {
+      // Check if HEAD~1 exists (more than one commit)
+      await execAsync('git rev-parse HEAD~1', { cwd: this.gitRoot });
+
+      const { stdout: changedFiles } = await execAsync(
+        'git diff --name-only HEAD~1 HEAD',
+        { cwd: this.gitRoot }
+      );
+
+      const files = changedFiles
+        .split('\n')
+        .map(f => f.trim())
+        .filter(Boolean);
+
+      if (files.length === 0) {
+        return [];
+      }
+
+      const originalBaseCommit = this.baseCommit;
+      this.baseCommit = 'HEAD~1';
+
+      const diffs = await Promise.all(
+        files.map(fp => this.getDiffInfoForFile(fp))
+      );
+
+      this.baseCommit = originalBaseCommit;
+      return diffs.flat();
+    } catch (err) {
+      // HEAD~1 doesn't exist - this is the first commit
+      try {
+        const { stdout: changedFiles } = await execAsync(
+          'git diff-tree --no-commit-id --name-only -r HEAD',
+          { cwd: this.gitRoot }
+        );
+
+        const files = changedFiles
+          .split('\n')
+          .map(f => f.trim())
+          .filter(Boolean);
+
+        if (files.length === 0) {
+          return [];
+        }
+
+        // For first commit, compare against empty tree
+        const originalBaseCommit = this.baseCommit;
+        this.baseCommit = '4b825dc642cb6eb9a060e54bf8d69288fbee4904'; // Git's empty tree hash
+
+        const diffs = await Promise.all(
+          files.map(fp => this.getDiffInfoForFile(fp))
+        );
+
+        this.baseCommit = originalBaseCommit;
+        return diffs.flat();
+      } catch (innerErr) {
+        console.error('Error getting last commit diff:', innerErr.message);
+        return [];
+      }
+    }
+  }
+
+  async _getSpecificCommitsDiff(commitHashes) {
+    const allDiffs = [];
+    const originalBaseCommit = this.baseCommit;
+
+    for (const hash of commitHashes) {
+      try {
+        const { stdout: changedFiles } = await execAsync(
+          `git diff --name-only ${hash}~1 ${hash}`,
+          { cwd: this.gitRoot }
+        );
+
+        const files = changedFiles
+          .split('\n')
+          .map(f => f.trim())
+          .filter(Boolean);
+
+        this.baseCommit = `${hash}~1`;
+        const commitDiffs = await Promise.all(
+          files.map(fp => this.getDiffInfoForFile(fp))
+        );
+
+        allDiffs.push(...commitDiffs.flat());
+      } catch (error) {
+        console.error(`Error processing commit ${hash}:`, error.message);
+      }
+    }
+
+    this.baseCommit = originalBaseCommit;
+    return allDiffs;
+  }
+
+  async _getUncommittedChanges() {
+    const { stdout: allModified } = await execAsync(
+      'git status --porcelain',
+      { cwd: this.gitRoot }
+    );
+
+    const files = allModified
+      .split('\n')
+      .map(line => line.substring(3).trim())
+      .filter(Boolean);
+
+    const diffs = [];
+    for (const file of files) {
+      try {
+        const { stdout: patchStr } = await execAsync(
+          `git diff HEAD -- "${file}"`,
+          { cwd: this.gitRoot }
+        );
+
+        if (patchStr) {
+          const diffInfo = await this.getDiffInfoForFile(file);
+          diffs.push(...diffInfo);
+        }
+      } catch (error) {
+        // Skip files that can't be diffed
+      }
+    }
+
+    return diffs;
+  }
+
+  async _getStagedChanges() {
+    const { stdout: stagedFiles } = await execAsync(
+      'git diff --name-only --cached HEAD',
+      { cwd: this.gitRoot }
+    );
+
+    const files = stagedFiles
+      .split('\n')
+      .map(f => f.trim())
+      .filter(Boolean);
+
+    const diffs = [];
+    const originalBaseCommit = this.baseCommit;
+
+    for (const file of files) {
+      try {
+        this.baseCommit = 'HEAD';
+        const diffInfo = await this.getDiffInfoForFile(file);
+        diffs.push(...diffInfo);
+      } catch (error) {
+        console.error(`Error processing staged file ${file}:`, error.message);
+      } finally {
+        this.baseCommit = originalBaseCommit;
+      }
+    }
+
+    return diffs;
+  }
+
+  async getUnpushedChangesDiff() {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    try {
+      const { stdout: currentBranchRaw } = await execAsync(
+        'git rev-parse --abbrev-ref HEAD',
+        { cwd: this.gitRoot }
+      );
+      const currentBranch = currentBranchRaw.trim();
+
+      let upstream = null;
+
+      try {
+        const { stdout: upstreamRaw } = await execAsync(
+          'git rev-parse --abbrev-ref --symbolic-full-name @{u}',
+          { cwd: this.gitRoot }
+        );
+        upstream = upstreamRaw.trim();
+      } catch (upstreamError) {
+        // Try to find remote branch
+        try {
+          const { stdout: remoteBranches } = await execAsync(
+            'git branch -r',
+            { cwd: this.gitRoot }
+          );
+
+          if (remoteBranches.includes(`origin/${currentBranch}`)) {
+            upstream = `origin/${currentBranch}`;
+          }
+        } catch (error) {
+          // Ignore
+        }
+
+        if (!upstream) {
+          const defaultBranches = ['origin/main', 'origin/master'];
+          for (const branch of defaultBranches) {
+            try {
+              await execAsync(`git rev-parse ${branch}`, { cwd: this.gitRoot });
+              upstream = branch;
+              break;
+            } catch (e) {
+              // Try next
+            }
+          }
+        }
+      }
+
+      if (!upstream) {
+        return this._getUncommittedChanges();
+      }
+
+      // Get unpushed files
+      const { stdout: unpushedFiles } = await execAsync(
+        `git diff --name-only ${upstream}..HEAD`,
+        { cwd: this.gitRoot }
+      );
+      const unpushedFilesList = unpushedFiles.split('\n').map(f => f.trim()).filter(Boolean);
+
+      // Get staged files
+      const { stdout: stagedFiles } = await execAsync(
+        'git diff --name-only --cached',
+        { cwd: this.gitRoot }
+      );
+      const stagedFilesList = stagedFiles.split('\n').map(f => f.trim()).filter(Boolean);
+
+      // Get unstaged files
+      const { stdout: unstagedFiles } = await execAsync(
+        'git diff --name-only',
+        { cwd: this.gitRoot }
+      );
+      const unstagedFilesList = unstagedFiles.split('\n').map(f => f.trim()).filter(Boolean);
+
+      // Combine and deduplicate
+      const uniqueFiles = Array.from(new Set([
+        ...unpushedFilesList,
+        ...stagedFilesList,
+        ...unstagedFilesList
+      ]));
+
+      if (uniqueFiles.length === 0) {
+        return [];
+      }
+
+      const originalBaseCommit = this.baseCommit;
+      try {
+        const { stdout: upstreamCommit } = await execAsync(
+          `git rev-parse ${upstream}`,
+          { cwd: this.gitRoot }
+        );
+        this.baseCommit = upstreamCommit.trim();
+
+        const diffs = await Promise.all(
+          uniqueFiles.map(fp => this.getDiffInfoForFile(fp))
+        );
+
+        return diffs.flat();
+      } finally {
+        this.baseCommit = originalBaseCommit;
+      }
+    } catch (error) {
+      console.error('Error getting unpushed changes:', error.message);
+      return this._getUncommittedChanges();
+    }
+  }
+
+  async getUnpushedCommits() {
+    if (!this.gitRoot) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    try {
+      let upstream;
+      try {
+        const { stdout } = await execAsync(
+          'git rev-parse --abbrev-ref --symbolic-full-name @{u}',
+          { cwd: this.gitRoot }
+        );
+        upstream = stdout.trim();
+      } catch (error) {
+        // Find alternative upstream
+        const { stdout: currentBranch } = await execAsync(
+          'git rev-parse --abbrev-ref HEAD',
+          { cwd: this.gitRoot }
+        );
+
+        const { stdout: remoteBranches } = await execAsync(
+          `git ls-remote --heads origin ${currentBranch.trim()}`,
+          { cwd: this.gitRoot }
+        );
+
+        if (remoteBranches.trim()) {
+          upstream = `origin/${currentBranch.trim()}`;
+        } else {
+          upstream = 'origin/main';
+        }
+      }
+
+      const { stdout: commitsStr } = await execAsync(
+        `git log ${upstream}..HEAD --pretty=format:"%H|%s|%an|%ar"`,
+        { cwd: this.gitRoot }
+      );
+
+      if (!commitsStr.trim()) {
+        return [];
+      }
+
+      return commitsStr
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+          const [hash, message, author, date] = line.split('|');
+          return { hash, message, author, date };
+        });
+    } catch (error) {
+      console.error('Error getting unpushed commits:', error.message);
+      return [];
+    }
+  }
+
+  _generateRandomHash() {
+    return Math.random().toString(36).substring(2, 9) + Math.random().toString(36).substring(2, 9);
+  }
+
+  async getFileDiff(filePath) {
+    if (!this.gitRoot || !this.baseCommit) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    let diff = '';
+
+    try {
+      await execAsync(`git ls-files --error-unmatch "${filePath}"`, {
+        cwd: this.gitRoot,
+      });
+
+      const { stdout } = await execAsync(
+        `git diff ${this.baseCommit} -- "${filePath}"`,
+        { cwd: this.gitRoot }
+      );
+      diff = stdout;
+    } catch (err) {
+      // Handle untracked files
+      try {
+        const absoluteFilePath = path.resolve(this.gitRoot, filePath);
+        const headFileStr = await fs.readFile(absoluteFilePath, 'utf8');
+        const lines = headFileStr.split('\n');
+
+        let patchStr = `diff --git a/${filePath} b/${filePath}\n`;
+        patchStr += `new file mode 100644\n`;
+        patchStr += `index 0000000..${this._generateRandomHash()}\n`;
+        patchStr += `--- /dev/null\n`;
+        patchStr += `+++ b/${filePath}\n`;
+        patchStr += `@@ -0,0 +1,${lines.length} @@\n`;
+
+        lines.forEach(line => {
+          patchStr += `+${line}\n`;
+        });
+
+        diff = patchStr;
+      } catch (manualDiffError) {
+        diff = '';
+      }
+    }
+
+    return diff;
+  }
+
+  async getAllDiffs() {
+    if (!this.gitRoot || !this.baseCommit) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    const { stdout: fullDiff } = await execAsync(
+      `git diff ${this.baseCommit}`,
+      { cwd: this.gitRoot }
+    );
+
+    return fullDiff;
+  }
+
+  async getDiffInfoForFile(filePath) {
+    if (!this.gitRoot || !this.baseCommit) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+
+    // Get base and head file contents
+    const baseFileStr = await execAsync(
+      `git show ${this.baseCommit}:"${filePath}"`,
+      { cwd: this.gitRoot }
+    ).then(r => r.stdout).catch(() => '');
+
+    const headFileStr = await fs.readFile(
+      path.join(this.gitRoot, filePath), 'utf8'
+    ).catch(() => '');
+
+    // Get patch
+    const patchStr = await this.getFileDiff(filePath);
+
+    // Get file status
+    const { stdout: nameStatus } = await execAsync(
+      `git diff --name-status ${this.baseCommit} -- "${filePath}"`,
+      { cwd: this.gitRoot }
+    ).catch(() => ({ stdout: '' }));
+
+    let editTypeStr = 'MODIFIED';
+    let oldFilenameStr = null;
+    let filenameStr = filePath;
+
+    if (nameStatus.trim()) {
+      const [statusCode, oldName, newName] = nameStatus.trim().split(/\t+/);
+      if (statusCode.startsWith('A')) editTypeStr = 'ADDED';
+      else if (statusCode.startsWith('D')) editTypeStr = 'DELETED';
+      else if (statusCode.startsWith('R')) {
+        editTypeStr = 'RENAMED';
+        oldFilenameStr = oldName;
+        filenameStr = newName;
+      }
+    }
+
+    // Get line counts
+    let numPlusLinesStr = '0', numMinusLinesStr = '0';
+    try {
+      const { stdout: ns } = await execAsync(
+        `git diff --numstat ${this.baseCommit} -- "${filePath}"`,
+        { cwd: this.gitRoot }
+      );
+      if (ns.trim()) [numPlusLinesStr, numMinusLinesStr] = ns.split('\t');
+    } catch (_) { /* ignore */ }
+
+    const tokensStr = headFileStr ? String(headFileStr.split(/\s+/).length) : '0';
+
+    // Parse hunks
+    const hunkHeader = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/gm;
+    const results = [];
+    let headerMatch;
+
+    while ((headerMatch = hunkHeader.exec(patchStr)) !== null) {
+      const newStart = Number(headerMatch[1]);
+      const newCount = headerMatch[2] ? Number(headerMatch[2]) : 1;
+      const hunkStartIdx = headerMatch.index;
+
+      const nextHeaderIdx = patchStr.slice(hunkHeader.lastIndex).search(/^@@/m);
+      const hunkEndIdx = nextHeaderIdx === -1
+        ? patchStr.length
+        : hunkHeader.lastIndex + nextHeaderIdx;
+      const singleHunkPatch = patchStr.slice(hunkStartIdx, hunkEndIdx);
+
+      results.push({
+        base_file_str: baseFileStr,
+        head_file_str: headFileStr,
+        patch_str: singleHunkPatch,
+        filename_str: filenameStr,
+        edit_type_str: editTypeStr,
+        old_filename_str: oldFilenameStr,
+        num_plus_lines_str: numPlusLinesStr,
+        num_minus_lines_str: numMinusLinesStr,
+        tokens_str: tokensStr,
+        start_line_str: String(newStart),
+        end_line_str: String(newStart + newCount - 1),
+      });
+    }
+
+    // If no hunks, return single item
+    if (results.length === 0) {
+      results.push({
+        base_file_str: baseFileStr,
+        head_file_str: headFileStr,
+        patch_str: patchStr,
+        filename_str: filenameStr,
+        edit_type_str: editTypeStr,
+        old_filename_str: oldFilenameStr,
+        num_plus_lines_str: numPlusLinesStr,
+        num_minus_lines_str: numMinusLinesStr,
+        tokens_str: tokensStr,
+        start_line_str: '',
+        end_line_str: '',
+      });
+    }
+
+    return results;
+  }
+
+  getLocalBranch() {
+    if (!this.currentBranch) {
+      throw new Error('GitDiffHelper not initialized. Call init() first.');
+    }
+    return this.currentBranch;
+  }
+
+  getGitRoot() {
+    return this.gitRoot;
+  }
+
+  async getAllDiffInfo() {
+    const changedFiles = await this.getChangedFiles();
+
+    const perFileHunks = await Promise.all(
+      changedFiles.map(fp => this.getDiffInfoForFile(fp))
+    );
+
+    return perFileHunks.flat();
+  }
+}
+
+export default GitDiffHelper;