diffstalker 0.1.6 → 0.2.0

package/dist/git/diff.js

@@ -1,10 +1,471 @@
-import{execSync as B}from"node:child_process";import{simpleGit as b}from"simple-git";export function parseDiffLine(s){return s.startsWith("diff --git")||s.startsWith("index ")||s.startsWith("---")||s.startsWith("+++")||s.startsWith("new file")||s.startsWith("deleted file")?{type:"header",content:s}:s.startsWith("@@")?{type:"hunk",content:s}:s.startsWith("+")?{type:"addition",content:s}:s.startsWith("-")?{type:"deletion",content:s}:{type:"context",content:s}}export function parseHunkHeader(s){const o=s.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);return o?{oldStart:parseInt(o[1],10),newStart:parseInt(o[2],10)}:null}export function parseDiffWithLineNumbers(s){const o=s.split(`
-`),i=[];let a=0,c=0;for(const n of o)if(n.startsWith("diff --git")||n.startsWith("index ")||n.startsWith("---")||n.startsWith("+++")||n.startsWith("new file")||n.startsWith("deleted file")||n.startsWith("Binary files")||n.startsWith("similarity index")||n.startsWith("rename from")||n.startsWith("rename to"))i.push({type:"header",content:n});else if(n.startsWith("@@")){const l=parseHunkHeader(n);l&&(a=l.oldStart,c=l.newStart),i.push({type:"hunk",content:n})}else n.startsWith("+")?i.push({type:"addition",content:n,newLineNum:c++}):n.startsWith("-")?i.push({type:"deletion",content:n,oldLineNum:a++}):i.push({type:"context",content:n,oldLineNum:a++,newLineNum:c++});return i}export async function getDiff(s,o,i=!1){const a=b(s);try{const c=[];i&&c.push("--cached"),o&&c.push("--",o);const n=await a.diff(c),l=parseDiffWithLineNumbers(n);return{raw:n,lines:l}}catch{return{raw:"",lines:[]}}}export async function getDiffForUntracked(s,o){try{const i=B(`cat "${o}"`,{cwd:s,encoding:"utf-8"}),a=[{type:"header",content:`diff --git a/${o} b/${o}`},{type:"header",content:"new file mode 100644"},{type:"header",content:"--- /dev/null"},{type:"header",content:`+++ b/${o}`}],c=i.split(`
-`);a.push({type:"hunk",content:`@@ -0,0 +1,${c.length} @@`});let n=1;for(const h of c)a.push({type:"addition",content:"+"+h,newLineNum:n++});return{raw:a.map(h=>h.content).join(`
-`),lines:a}}catch{return{raw:"",lines:[]}}}export async function getStagedDiff(s){return getDiff(s,void 0,!0)}export async function getCandidateBaseBranches(s){const o=b(s),i=new Set,a=[];try{const c=await o.raw(["log","--oneline","--decorate=short","--all","-n","200"]),n=/\(([^)]+)\)/g;for(const l of c.split(`
-`)){const h=n.exec(l);if(h){const m=h[1].split(",").map(u=>u.trim());for(const u of m){if(u.startsWith("HEAD")||u.startsWith("tag:")||!u.includes("/"))continue;const d=u.replace(/^.*-> /,"");d.includes("/")&&!i.has(d)&&(i.add(d),a.push(d))}}n.lastIndex=0}a.length>0&&a.sort((l,h)=>{const m=l.split("/").slice(1).join("/"),u=h.split("/").slice(1).join("/"),d=m==="main"||m==="master",g=u==="main"||u==="master";if(d&&!g)return-1;if(!d&&g)return 1;if(d&&g){const w=l.startsWith("origin/"),y=h.startsWith("origin/");if(w&&!y)return 1;if(!w&&y)return-1}return 0})}catch{}return[...new Set(a)]}export async function getDefaultBaseBranch(s){return(await getCandidateBaseBranches(s))[0]??null}export async function getDiffBetweenRefs(s,o){const i=b(s),c=(await i.raw(["merge-base",o,"HEAD"])).trim(),n=await i.raw(["diff","--numstat",`${c}...HEAD`]),l=await i.raw(["diff","--name-status",`${c}...HEAD`]),h=await i.raw(["diff",`${c}...HEAD`]),m=n.trim().split(`
-`).filter(t=>t),u=new Map;for(const t of m){const e=t.split("	");if(e.length>=3){const r=e[0]==="-"?0:parseInt(e[0],10),p=e[1]==="-"?0:parseInt(e[1],10),f=e.slice(2).join("	");u.set(f,{additions:r,deletions:p})}}const d=l.trim().split(`
-`).filter(t=>t),g=new Map;for(const t of d){const e=t.split("	");if(e.length>=2){const r=e[0][0],p=e[e.length-1];let f;switch(r){case"A":f="added";break;case"D":f="deleted";break;case"R":f="renamed";break;default:f="modified"}g.set(p,f)}}const w=[],y=h.split(/(?=^diff --git )/m).filter(t=>t.trim());for(const t of y){const e=t.match(/^diff --git a\/.+ b\/(.+)$/m);if(!e)continue;const r=e[1],p=parseDiffWithLineNumbers(t),f=u.get(r)||{additions:0,deletions:0},D=g.get(r)||"modified";w.push({path:r,status:D,additions:f.additions,deletions:f.deletions,diff:{raw:t,lines:p}})}let x=0,k=0;for(const t of w)x+=t.additions,k+=t.deletions;const I=(await i.status()).files.length,S=(await i.log({from:c,to:"HEAD"})).all.map(t=>({hash:t.hash,shortHash:t.hash.slice(0,7),message:t.message.split(`
-`)[0],author:t.author_name,date:new Date(t.date),refs:t.refs||""}));return{baseBranch:o,stats:{filesChanged:w.length,additions:x,deletions:k},files:w,commits:S,uncommittedCount:I}}export async function getCommitDiff(s,o){const i=b(s);try{const a=await i.raw(["show",o,"--format="]),c=parseDiffWithLineNumbers(a);return{raw:a,lines:c}}catch{return{raw:"",lines:[]}}}export async function getCompareDiffWithUncommitted(s,o){const i=b(s),a=await getDiffBetweenRefs(s,o),c=await i.diff(["--cached","--numstat"]),n=await i.diff(["--numstat"]),l=await i.diff(["--cached"]),h=await i.diff([]),m=new Map;for(const t of c.trim().split(`
-`).filter(e=>e)){const e=t.split("	");if(e.length>=3){const r=e[0]==="-"?0:parseInt(e[0],10),p=e[1]==="-"?0:parseInt(e[1],10),f=e.slice(2).join("	");m.set(f,{additions:r,deletions:p,staged:!0,unstaged:!1})}}for(const t of n.trim().split(`
-`).filter(e=>e)){const e=t.split("	");if(e.length>=3){const r=e[0]==="-"?0:parseInt(e[0],10),p=e[1]==="-"?0:parseInt(e[1],10),f=e.slice(2).join("	"),D=m.get(f);D?(D.additions+=r,D.deletions+=p,D.unstaged=!0):m.set(f,{additions:r,deletions:p,staged:!1,unstaged:!0})}}const u=await i.status(),d=new Map;for(const t of u.files)t.index==="A"||t.working_dir==="?"?d.set(t.path,"added"):t.index==="D"||t.working_dir==="D"?d.set(t.path,"deleted"):t.index==="R"?d.set(t.path,"renamed"):d.set(t.path,"modified");const g=[],y=(l+h).split(/(?=^diff --git )/m).filter(t=>t.trim()),x=new Set;for(const t of y){const e=t.match(/^diff --git a\/.+ b\/(.+)$/m);if(!e)continue;const r=e[1];if(x.has(r))continue;x.add(r);const p=parseDiffWithLineNumbers(t),f=m.get(r)||{additions:0,deletions:0},D=d.get(r)||"modified";g.push({path:r,status:D,additions:f.additions,deletions:f.deletions,diff:{raw:t,lines:p},isUncommitted:!0})}const k=new Set(a.files.map(t=>t.path)),W=[];for(const t of a.files){const e=g.find(r=>r.path===t.path);e?(W.push(t),W.push(e)):W.push(t)}for(const t of g)k.has(t.path)||W.push(t);let I=0,L=0;const S=new Set;for(const t of W)S.has(t.path)||S.add(t.path),I+=t.additions,L+=t.deletions;return{baseBranch:a.baseBranch,stats:{filesChanged:S.size,additions:I,deletions:L},files:W,commits:a.commits,uncommittedCount:a.uncommittedCount}}
+import { execSync } from 'node:child_process';
+import { simpleGit } from 'simple-git';
+export function parseDiffLine(line) {
+    if (line.startsWith('diff --git') ||
+        line.startsWith('index ') ||
+        line.startsWith('---') ||
+        line.startsWith('+++') ||
+        line.startsWith('new file') ||
+        line.startsWith('deleted file')) {
+        return { type: 'header', content: line };
+    }
+    if (line.startsWith('@@')) {
+        return { type: 'hunk', content: line };
+    }
+    if (line.startsWith('+')) {
+        return { type: 'addition', content: line };
+    }
+    if (line.startsWith('-')) {
+        return { type: 'deletion', content: line };
+    }
+    return { type: 'context', content: line };
+}
+/**
+ * Parse a hunk header to extract line numbers.
+ * Format: @@ -oldStart,oldCount +newStart,newCount @@
+ * Example: @@ -1,5 +1,7 @@ or @@ -10 +10,2 @@
+ */
+export function parseHunkHeader(line) {
+    const match = line.match(/^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+    if (match) {
+        return {
+            oldStart: parseInt(match[1], 10),
+            newStart: parseInt(match[2], 10),
+        };
+    }
+    return null;
+}
+/**
+ * Parse diff output with line numbers.
+ * Tracks line numbers through hunks for proper display.
+ */
+export function parseDiffWithLineNumbers(raw) {
+    const lines = raw.split('\n');
+    const result = [];
+    let oldLineNum = 0;
+    let newLineNum = 0;
+    for (const line of lines) {
+        if (line.startsWith('diff --git') ||
+            line.startsWith('index ') ||
+            line.startsWith('---') ||
+            line.startsWith('+++') ||
+            line.startsWith('new file') ||
+            line.startsWith('deleted file') ||
+            line.startsWith('Binary files') ||
+            line.startsWith('similarity index') ||
+            line.startsWith('rename from') ||
+            line.startsWith('rename to')) {
+            result.push({ type: 'header', content: line });
+        }
+        else if (line.startsWith('@@')) {
+            const hunkInfo = parseHunkHeader(line);
+            if (hunkInfo) {
+                oldLineNum = hunkInfo.oldStart;
+                newLineNum = hunkInfo.newStart;
+            }
+            result.push({ type: 'hunk', content: line });
+        }
+        else if (line.startsWith('+')) {
+            result.push({
+                type: 'addition',
+                content: line,
+                newLineNum: newLineNum++,
+            });
+        }
+        else if (line.startsWith('-')) {
+            result.push({
+                type: 'deletion',
+                content: line,
+                oldLineNum: oldLineNum++,
+            });
+        }
+        else {
+            // Context line (starts with space) or empty line
+            result.push({
+                type: 'context',
+                content: line,
+                oldLineNum: oldLineNum++,
+                newLineNum: newLineNum++,
+            });
+        }
+    }
+    return result;
+}
+export async function getDiff(repoPath, file, staged = false) {
+    const git = simpleGit(repoPath);
+    try {
+        const args = [];
+        if (staged) {
+            args.push('--cached');
+        }
+        if (file) {
+            args.push('--', file);
+        }
+        const raw = await git.diff(args);
+        const lines = parseDiffWithLineNumbers(raw);
+        return { raw, lines };
+    }
+    catch {
+        return { raw: '', lines: [] };
+    }
+}
+export async function getDiffForUntracked(repoPath, file) {
+    try {
+        // For untracked files, show the entire file as additions
+        const content = execSync(`cat "${file}"`, { cwd: repoPath, encoding: 'utf-8' });
+        const lines = [
+            { type: 'header', content: `diff --git a/${file} b/${file}` },
+            { type: 'header', content: 'new file mode 100644' },
+            { type: 'header', content: `--- /dev/null` },
+            { type: 'header', content: `+++ b/${file}` },
+        ];
+        const contentLines = content.split('\n');
+        lines.push({ type: 'hunk', content: `@@ -0,0 +1,${contentLines.length} @@` });
+        let lineNum = 1;
+        for (const line of contentLines) {
+            lines.push({ type: 'addition', content: '+' + line, newLineNum: lineNum++ });
+        }
+        const raw = lines.map((l) => l.content).join('\n');
+        return { raw, lines };
+    }
+    catch {
+        return { raw: '', lines: [] };
+    }
+}
+export async function getStagedDiff(repoPath) {
+    return getDiff(repoPath, undefined, true);
+}
+/**
+ * Get candidate base branches for PR comparison.
+ * Uses git log to find branches that appear in recent history (likely PR targets).
+ */
+export async function getCandidateBaseBranches(repoPath) {
+    const git = simpleGit(repoPath);
+    const seen = new Set();
+    const candidates = [];
+    try {
+        // Get recent commits with decorations to find branches in our history
+        const logOutput = await git.raw(['log', '--oneline', '--decorate=short', '--all', '-n', '200']);
+        // Extract remote branch refs from decorations like (origin/main, upstream/feature)
+        const refPattern = /\(([^)]+)\)/g;
+        for (const line of logOutput.split('\n')) {
+            const match = refPattern.exec(line);
+            if (match) {
+                const refs = match[1].split(',').map((r) => r.trim());
+                for (const ref of refs) {
+                    // Skip HEAD, tags, and local branches - only want remote branches
+                    if (ref.startsWith('HEAD') || ref.startsWith('tag:') || !ref.includes('/'))
+                        continue;
+                    // Clean up "origin/main" from things like "HEAD -> origin/main"
+                    const cleaned = ref.replace(/^.*-> /, '');
+                    if (cleaned.includes('/') && !seen.has(cleaned)) {
+                        seen.add(cleaned);
+                        candidates.push(cleaned);
+                    }
+                }
+            }
+            refPattern.lastIndex = 0; // Reset regex state
+        }
+        // If we found candidates, sort main/master to top, prefer non-origin
+        if (candidates.length > 0) {
+            candidates.sort((a, b) => {
+                const aName = a.split('/').slice(1).join('/');
+                const bName = b.split('/').slice(1).join('/');
+                const aIsMain = aName === 'main' || aName === 'master';
+                const bIsMain = bName === 'main' || bName === 'master';
+                // main/master first
+                if (aIsMain && !bIsMain)
+                    return -1;
+                if (!aIsMain && bIsMain)
+                    return 1;
+                // Among main/master, prefer non-origin
+                if (aIsMain && bIsMain) {
+                    const aIsOrigin = a.startsWith('origin/');
+                    const bIsOrigin = b.startsWith('origin/');
+                    if (aIsOrigin && !bIsOrigin)
+                        return 1;
+                    if (!aIsOrigin && bIsOrigin)
+                        return -1;
+                }
+                return 0; // Keep discovery order otherwise
+            });
+        }
+    }
+    catch {
+        // Failed to get branches
+    }
+    // Return unique candidates (Set deduplication)
+    return [...new Set(candidates)];
+}
+/**
+ * Get the best default base branch for PR comparison.
+ */
+export async function getDefaultBaseBranch(repoPath) {
+    const candidates = await getCandidateBaseBranches(repoPath);
+    return candidates[0] ?? null;
+}
+/**
+ * Get diff between HEAD and a base ref (for PR-like view).
+ * Uses three-dot diff (merge-base) to show only changes on current branch.
+ */
+export async function getDiffBetweenRefs(repoPath, baseRef) {
+    const git = simpleGit(repoPath);
+    // Get merge-base for three-dot diff
+    const mergeBase = await git.raw(['merge-base', baseRef, 'HEAD']);
+    const base = mergeBase.trim();
+    // Get per-file stats with --numstat
+    const numstat = await git.raw(['diff', '--numstat', `${base}...HEAD`]);
+    // Get file statuses with --name-status
+    const nameStatus = await git.raw(['diff', '--name-status', `${base}...HEAD`]);
+    // Get full diff
+    const rawDiff = await git.raw(['diff', `${base}...HEAD`]);
+    // Parse numstat: "additions deletions filepath" per line
+    const numstatLines = numstat
+        .trim()
+        .split('\n')
+        .filter((l) => l);
+    const fileStats = new Map();
+    for (const line of numstatLines) {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10);
+            const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10);
+            const filepath = parts.slice(2).join('\t'); // Handle paths with tabs
+            fileStats.set(filepath, { additions, deletions });
+        }
+    }
+    // Parse name-status: "A/M/D/R filepath" per line
+    const nameStatusLines = nameStatus
+        .trim()
+        .split('\n')
+        .filter((l) => l);
+    const fileStatuses = new Map();
+    for (const line of nameStatusLines) {
+        const parts = line.split('\t');
+        if (parts.length >= 2) {
+            const statusChar = parts[0][0];
+            const filepath = parts[parts.length - 1]; // Use last part for renamed files
+            let status;
+            switch (statusChar) {
+                case 'A':
+                    status = 'added';
+                    break;
+                case 'D':
+                    status = 'deleted';
+                    break;
+                case 'R':
+                    status = 'renamed';
+                    break;
+                default:
+                    status = 'modified';
+            }
+            fileStatuses.set(filepath, status);
+        }
+    }
+    // Split raw diff by file headers
+    const fileDiffs = [];
+    const diffChunks = rawDiff.split(/(?=^diff --git )/m).filter((chunk) => chunk.trim());
+    for (const chunk of diffChunks) {
+        // Extract file path from the diff header
+        const match = chunk.match(/^diff --git a\/.+ b\/(.+)$/m);
+        if (!match)
+            continue;
+        const filepath = match[1];
+        const lines = parseDiffWithLineNumbers(chunk);
+        const stats = fileStats.get(filepath) || { additions: 0, deletions: 0 };
+        const status = fileStatuses.get(filepath) || 'modified';
+        fileDiffs.push({
+            path: filepath,
+            status,
+            additions: stats.additions,
+            deletions: stats.deletions,
+            diff: { raw: chunk, lines },
+        });
+    }
+    // Calculate total stats
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const file of fileDiffs) {
+        totalAdditions += file.additions;
+        totalDeletions += file.deletions;
+    }
+    // Get uncommitted count from status
+    const status = await git.status();
+    const uncommittedCount = status.files.length;
+    // Get commits between base and HEAD
+    const log = await git.log({ from: base, to: 'HEAD' });
+    const commits = log.all.map((entry) => ({
+        hash: entry.hash,
+        shortHash: entry.hash.slice(0, 7),
+        message: entry.message.split('\n')[0],
+        author: entry.author_name,
+        date: new Date(entry.date),
+        refs: entry.refs || '',
+    }));
+    return {
+        baseBranch: baseRef,
+        stats: {
+            filesChanged: fileDiffs.length,
+            additions: totalAdditions,
+            deletions: totalDeletions,
+        },
+        files: fileDiffs,
+        commits,
+        uncommittedCount,
+    };
+}
+/**
+ * Get diff for a specific commit.
+ * Shows the changes introduced by that commit.
+ */
+export async function getCommitDiff(repoPath, hash) {
+    const git = simpleGit(repoPath);
+    try {
+        // git show <hash> --format="" gives just the diff without commit metadata
+        const raw = await git.raw(['show', hash, '--format=']);
+        const lines = parseDiffWithLineNumbers(raw);
+        return { raw, lines };
+    }
+    catch {
+        return { raw: '', lines: [] };
+    }
+}
+/**
+ * Get PR diff that includes uncommitted changes (staged + unstaged).
+ * Merges committed diff with working tree changes.
+ */
+export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
+    const git = simpleGit(repoPath);
+    // Get the committed PR diff first
+    const committedDiff = await getDiffBetweenRefs(repoPath, baseRef);
+    // Get uncommitted changes (both staged and unstaged)
+    const stagedRaw = await git.diff(['--cached', '--numstat']);
+    const unstagedRaw = await git.diff(['--numstat']);
+    const stagedDiff = await git.diff(['--cached']);
+    const unstagedDiff = await git.diff([]);
+    // Parse uncommitted file stats
+    const uncommittedFiles = new Map();
+    // Parse staged files
+    for (const line of stagedRaw
+        .trim()
+        .split('\n')
+        .filter((l) => l)) {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10);
+            const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10);
+            const filepath = parts.slice(2).join('\t');
+            uncommittedFiles.set(filepath, { additions, deletions, staged: true, unstaged: false });
+        }
+    }
+    // Parse unstaged files
+    for (const line of unstagedRaw
+        .trim()
+        .split('\n')
+        .filter((l) => l)) {
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const additions = parts[0] === '-' ? 0 : parseInt(parts[0], 10);
+            const deletions = parts[1] === '-' ? 0 : parseInt(parts[1], 10);
+            const filepath = parts.slice(2).join('\t');
+            const existing = uncommittedFiles.get(filepath);
+            if (existing) {
+                existing.additions += additions;
+                existing.deletions += deletions;
+                existing.unstaged = true;
+            }
+            else {
+                uncommittedFiles.set(filepath, { additions, deletions, staged: false, unstaged: true });
+            }
+        }
+    }
+    // Get status for file status detection
+    const status = await git.status();
+    const statusMap = new Map();
+    for (const file of status.files) {
+        if (file.index === 'A' || file.working_dir === '?') {
+            statusMap.set(file.path, 'added');
+        }
+        else if (file.index === 'D' || file.working_dir === 'D') {
+            statusMap.set(file.path, 'deleted');
+        }
+        else if (file.index === 'R') {
+            statusMap.set(file.path, 'renamed');
+        }
+        else {
+            statusMap.set(file.path, 'modified');
+        }
+    }
+    // Split uncommitted diffs by file
+    const uncommittedFileDiffs = [];
+    const combinedDiff = stagedDiff + unstagedDiff;
+    const diffChunks = combinedDiff.split(/(?=^diff --git )/m).filter((chunk) => chunk.trim());
+    // Track files we've already processed (avoid duplicates if file has both staged and unstaged)
+    const processedFiles = new Set();
+    for (const chunk of diffChunks) {
+        const match = chunk.match(/^diff --git a\/.+ b\/(.+)$/m);
+        if (!match)
+            continue;
+        const filepath = match[1];
+        if (processedFiles.has(filepath))
+            continue;
+        processedFiles.add(filepath);
+        const lines = parseDiffWithLineNumbers(chunk);
+        const fileStats = uncommittedFiles.get(filepath) || { additions: 0, deletions: 0 };
+        const fileStatus = statusMap.get(filepath) || 'modified';
+        uncommittedFileDiffs.push({
+            path: filepath,
+            status: fileStatus,
+            additions: fileStats.additions,
+            deletions: fileStats.deletions,
+            diff: { raw: chunk, lines },
+            isUncommitted: true,
+        });
+    }
+    // Merge: keep committed files, add/replace with uncommitted
+    const committedFilePaths = new Set(committedDiff.files.map((f) => f.path));
+    const mergedFiles = [];
+    // Add committed files first
+    for (const file of committedDiff.files) {
+        const uncommittedFile = uncommittedFileDiffs.find((f) => f.path === file.path);
+        if (uncommittedFile) {
+            // If file has both committed and uncommitted changes, combine them
+            // For simplicity, we'll show committed + uncommitted as separate entries
+            // with the uncommitted one marked
+            mergedFiles.push(file);
+            mergedFiles.push(uncommittedFile);
+        }
+        else {
+            mergedFiles.push(file);
+        }
+    }
+    // Add uncommitted-only files (not in committed diff)
+    for (const file of uncommittedFileDiffs) {
+        if (!committedFilePaths.has(file.path)) {
+            mergedFiles.push(file);
+        }
+    }
+    // Calculate new totals including uncommitted
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    const seenPaths = new Set();
+    for (const file of mergedFiles) {
+        // Count unique file paths for stats
+        if (!seenPaths.has(file.path)) {
+            seenPaths.add(file.path);
+        }
+        totalAdditions += file.additions;
+        totalDeletions += file.deletions;
+    }
+    return {
+        baseBranch: committedDiff.baseBranch,
+        stats: {
+            filesChanged: seenPaths.size,
+            additions: totalAdditions,
+            deletions: totalDeletions,
+        },
+        files: mergedFiles,
+        commits: committedDiff.commits,
+        uncommittedCount: committedDiff.uncommittedCount,
+    };
+}

package/dist/git/ignoreUtils.js

@@ -0,0 +1,30 @@
+import { simpleGit } from 'simple-git';
+/**
+ * Check which files from a list are ignored by git.
+ * Uses `git check-ignore` to determine ignored files.
+ */
+export async function getIgnoredFiles(repoPath, files) {
+    if (files.length === 0)
+        return new Set();
+    const git = simpleGit(repoPath);
+    const ignoredFiles = new Set();
+    const batchSize = 100;
+    for (let i = 0; i < files.length; i += batchSize) {
+        const batch = files.slice(i, i + batchSize);
+        try {
+            const result = await git.raw(['check-ignore', ...batch]);
+            const ignored = result
+                .trim()
+                .split('\n')
+                .filter((f) => f.length > 0);
+            for (const f of ignored) {
+                ignoredFiles.add(f);
+            }
+        }
+        catch {
+            // check-ignore exits with code 1 if no files are ignored, which throws
+            // Just continue to next batch
+        }
+    }
+    return ignoredFiles;
+}