codeant-cli 0.1.5 → 0.1.6

package/src/utils/gitDiffHelper.js

@@ -1,774 +0,0 @@
-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._getLastNCommitDiff(1);
-
-      case 'last-n-commits':
-        const n = config.commits || 1;
-        return this._getLastNCommitDiff(n);
-
-      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 _getLastNCommitDiff(n) {
-    if (!this.gitRoot) {
-      throw new Error('GitDiffHelper not initialized. Call init() first.');
-    }
-
-    // Clamp n between 1 and 5
-    n = Math.min(Math.max(1, n), 5);
-
-    // First check if there are any commits
-    try {
-      await execAsync('git rev-parse HEAD', { cwd: this.gitRoot });
-    } catch (err) {
-      // No commits at all
-      return [];
-    }
-
-    const originalBaseCommit = this.baseCommit;
-
-    try {
-      // Check if HEAD~n exists (more than n commits)
-      await execAsync(`git rev-parse HEAD~${n}`, { cwd: this.gitRoot });
-
-      const { stdout: changedFiles } = await execAsync(
-        `git diff --name-only HEAD~${n} HEAD`,
-        { cwd: this.gitRoot }
-      );
-
-      const files = changedFiles
-        .split('\n')
-        .map(f => f.trim())
-        .filter(Boolean);
-
-      if (files.length === 0) {
-        return [];
-      }
-
-      this.baseCommit = `HEAD~${n}`;
-
-      const diffs = await Promise.all(
-        files.map(fp => this.getDiffInfoForFile(fp))
-      );
-
-      this.baseCommit = originalBaseCommit;
-      return diffs.flat();
-    } catch (err) {
-      // HEAD~n doesn't exist - fewer than n commits, include all available
-      try {
-        const emptyTree = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
-        const { stdout: changedFiles } = await execAsync(
-          `git diff --name-only ${emptyTree} HEAD`,
-          { cwd: this.gitRoot }
-        );
-
-        const files = changedFiles
-          .split('\n')
-          .map(f => f.trim())
-          .filter(Boolean);
-
-        if (files.length === 0) {
-          return [];
-        }
-
-        // Compare against empty tree to capture all commits
-        this.baseCommit = emptyTree;
-
-        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);
-        this.baseCommit = originalBaseCommit;
-        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 originalBaseCommit = this.baseCommit;
-    this.baseCommit = 'HEAD';
-
-    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
-      }
-    }
-
-    this.baseCommit = originalBaseCommit;
-    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);
-      }
-    }
-
-    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;