diffstalker 0.2.1 → 0.2.2

package/dist/git/diff.js

@@ -41,6 +41,11 @@ export function parseHunkHeader(line) {
  */
 export function parseDiffWithLineNumbers(raw) {
     const lines = raw.split('\n');
+    // Remove trailing empty string from the final newline in git output,
+    // otherwise it gets parsed as a phantom context line on the last hunk
+    if (lines.length > 1 && lines[lines.length - 1] === '') {
+        lines.pop();
+    }
     const result = [];
     let oldLineNum = 0;
     let newLineNum = 0;
@@ -91,6 +96,96 @@ export function parseDiffWithLineNumbers(raw) {
     }
     return result;
 }
+/**
+ * Count the number of hunks in a raw diff string.
+ * A hunk starts with a line beginning with '@@'.
+ */
+export function countHunks(rawDiff) {
+    if (!rawDiff)
+        return 0;
+    let count = 0;
+    for (const line of rawDiff.split('\n')) {
+        if (line.startsWith('@@'))
+            count++;
+    }
+    return count;
+}
+/**
+ * Extract a valid single-hunk patch from a raw diff.
+ * Includes all file headers (diff --git, index, new file mode,
+ * rename from/to, ---, +++) plus the Nth @@ hunk and its lines
+ * (including '' markers).
+ * Returns null if hunkIndex is out of range.
+ */
+export function extractHunkPatch(rawDiff, hunkIndex) {
+    if (!rawDiff)
+        return null;
+    const lines = rawDiff.split('\n');
+    // Collect file headers (everything before the first @@)
+    const headers = [];
+    let firstHunkLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith('@@')) {
+            firstHunkLine = i;
+            break;
+        }
+        headers.push(lines[i]);
+    }
+    if (firstHunkLine === -1)
+        return null;
+    // Find the Nth @@ line
+    let hunkCount = -1;
+    let hunkStart = -1;
+    for (let i = firstHunkLine; i < lines.length; i++) {
+        if (lines[i].startsWith('@@')) {
+            hunkCount++;
+            if (hunkCount === hunkIndex) {
+                hunkStart = i;
+                break;
+            }
+        }
+    }
+    if (hunkStart === -1)
+        return null;
+    // Collect from that @@ until the next @@ or end-of-content
+    const hunkLines = [lines[hunkStart]];
+    for (let i = hunkStart + 1; i < lines.length; i++) {
+        if (lines[i].startsWith('@@') || lines[i].startsWith('diff --git'))
+            break;
+        hunkLines.push(lines[i]);
+    }
+    // Remove trailing empty line if present (artifact of split)
+    while (hunkLines.length > 1 && hunkLines[hunkLines.length - 1] === '') {
+        hunkLines.pop();
+    }
+    const patch = [...headers, ...hunkLines].join('\n') + '\n';
+    return patch;
+}
+/**
+ * Count the number of hunks per file in a multi-file raw diff string.
+ * Returns a map of file path -> hunk count.
+ */
+export function countHunksPerFile(rawDiff) {
+    const result = new Map();
+    if (!rawDiff)
+        return result;
+    let currentFile = null;
+    for (const line of rawDiff.split('\n')) {
+        if (line.startsWith('diff --git')) {
+            const match = line.match(/^diff --git a\/.+ b\/(.+)$/);
+            if (match) {
+                currentFile = match[1];
+                if (!result.has(currentFile)) {
+                    result.set(currentFile, 0);
+                }
+            }
+        }
+        else if (line.startsWith('@@') && currentFile) {
+            result.set(currentFile, (result.get(currentFile) ?? 0) + 1);
+        }
+    }
+    return result;
+}
 export async function getDiff(repoPath, file, staged = false) {
     const git = simpleGit(repoPath);
     try {
@@ -338,16 +433,13 @@ export async function getCommitDiff(repoPath, hash) {
  */
 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
+    // Parse uncommitted file stats from numstat output
     const uncommittedFiles = new Map();
-    // Parse staged files
     for (const line of stagedRaw
         .trim()
         .split('\n')
@@ -360,7 +452,6 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
             uncommittedFiles.set(filepath, { additions, deletions, staged: true, unstaged: false });
         }
     }
-    // Parse unstaged files
     for (const line of unstagedRaw
         .trim()
         .split('\n')
@@ -381,7 +472,7 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
             }
         }
     }
-    // Get status for file status detection
+    // Build status map from git status
     const status = await git.status();
     const statusMap = new Map();
     for (const file of status.files) {
@@ -402,7 +493,6 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
     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);
@@ -427,13 +517,9 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
     // 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);
         }
@@ -441,25 +527,20 @@ export async function getCompareDiffWithUncommitted(repoPath, baseRef) {
             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
+    // Calculate totals
     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);
-        }
+        seenPaths.add(file.path);
         totalAdditions += file.additions;
         totalDeletions += file.deletions;
     }
-    // Sort files alphabetically by path
     mergedFiles.sort((a, b) => a.path.localeCompare(b.path));
     return {
         baseBranch: committedDiff.baseBranch,

package/dist/git/status.js

@@ -1,4 +1,5 @@
 import { simpleGit } from 'simple-git';
+import { execFileSync } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getIgnoredFiles } from './ignoreUtils.js';
@@ -60,62 +61,12 @@ export async function getStatus(repoPath) {
             };
         }
         const status = await git.status();
-        const files = [];
-        // Process staged files
-        for (const file of status.staged) {
-            files.push({
-                path: file,
-                status: 'added',
-                staged: true,
-            });
-        }
-        // Process modified staged files
-        for (const file of status.modified) {
-            // Check if it's in the index (staged)
-            const existingStaged = files.find((f) => f.path === file && f.staged);
-            if (!existingStaged) {
-                files.push({
-                    path: file,
-                    status: 'modified',
-                    staged: false,
-                });
-            }
-        }
-        // Process deleted files
-        for (const file of status.deleted) {
-            files.push({
-                path: file,
-                status: 'deleted',
-                staged: false,
-            });
-        }
-        // Process untracked files
-        for (const file of status.not_added) {
-            files.push({
-                path: file,
-                status: 'untracked',
-                staged: false,
-            });
-        }
-        // Process renamed files
-        for (const file of status.renamed) {
-            files.push({
-                path: file.to,
-                originalPath: file.from,
-                status: 'renamed',
-                staged: true,
-            });
-        }
-        // Use the files array from status for more accurate staging info
-        // The status.files array has detailed index/working_dir info
+        // Build processed file list, filtering ignored files
         const processedFiles = [];
         const seen = new Set();
-        // Collect untracked files to check if they're ignored
         const untrackedPaths = status.files.filter((f) => f.working_dir === '?').map((f) => f.path);
-        // Get the set of ignored files
         const ignoredFiles = await getIgnoredFiles(repoPath, untrackedPaths);
         for (const file of status.files) {
-            // Skip ignored files (marked with '!' in either column, or detected by check-ignore)
             if (file.index === '!' || file.working_dir === '!' || ignoredFiles.has(file.path)) {
                 continue;
             }
@@ -123,7 +74,6 @@ export async function getStatus(repoPath) {
             if (seen.has(key))
                 continue;
             seen.add(key);
-            // Staged changes (index column)
             if (file.index && file.index !== ' ' && file.index !== '?') {
                 processedFiles.push({
                     path: file.path,
@@ -131,7 +81,6 @@ export async function getStatus(repoPath) {
                     staged: true,
                 });
             }
-            // Unstaged changes (working_dir column)
             if (file.working_dir && file.working_dir !== ' ') {
                 processedFiles.push({
                     path: file.path,
@@ -147,7 +96,6 @@ export async function getStatus(repoPath) {
         ]);
         const stagedStats = parseNumstat(stagedNumstat);
         const unstagedStats = parseNumstat(unstagedNumstat);
-        // Apply stats to files
         for (const file of processedFiles) {
             const stats = file.staged ? stagedStats.get(file.path) : unstagedStats.get(file.path);
             if (stats) {
@@ -218,6 +166,20 @@ export async function getHeadMessage(repoPath) {
         return '';
     }
 }
+export function stageHunk(repoPath, patch) {
+    execFileSync('git', ['apply', '--cached', '--unidiff-zero'], {
+        cwd: repoPath,
+        input: patch,
+        encoding: 'utf-8',
+    });
+}
+export function unstageHunk(repoPath, patch) {
+    execFileSync('git', ['apply', '--cached', '--reverse', '--unidiff-zero'], {
+        cwd: repoPath,
+        input: patch,
+        encoding: 'utf-8',
+    });
+}
 export async function getCommitHistory(repoPath, count = 50) {
     const git = simpleGit(repoPath);
     try {

package/dist/git/test-helpers.js

@@ -0,0 +1,67 @@
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+const FIXTURES_DIR = path.resolve(import.meta.dirname, '../../test-fixtures');
+/**
+ * Create a fixture git repo with initial config.
+ */
+export function createFixtureRepo(name) {
+    const repoPath = path.join(FIXTURES_DIR, name);
+    fs.mkdirSync(repoPath, { recursive: true });
+    gitExec(repoPath, 'init --initial-branch=main');
+    gitExec(repoPath, 'config user.email "test@test.com"');
+    gitExec(repoPath, 'config user.name "Test User"');
+    return repoPath;
+}
+/**
+ * Remove a fixture repo directory.
+ */
+export function removeFixtureRepo(name) {
+    const repoPath = path.join(FIXTURES_DIR, name);
+    fs.rmSync(repoPath, { recursive: true, force: true });
+}
+/**
+ * Write a file inside a fixture repo, creating parent directories as needed.
+ */
+export function writeFixtureFile(repoPath, filePath, content) {
+    const fullPath = path.join(repoPath, filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+}
+/**
+ * Run a git command in a fixture repo.
+ */
+export function gitExec(repoPath, command) {
+    return execSync(`git ${command}`, {
+        cwd: repoPath,
+        encoding: 'utf-8',
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+}
+/**
+ * Create a bare remote repo and a cloned working repo for branch comparison tests.
+ * Returns { remotePath, repoPath }.
+ */
+export function createRepoWithRemote(name) {
+    const remotePath = path.join(FIXTURES_DIR, `${name}-remote`);
+    const repoPath = path.join(FIXTURES_DIR, name);
+    // Create bare remote
+    fs.mkdirSync(remotePath, { recursive: true });
+    gitExec(remotePath, 'init --bare --initial-branch=main');
+    // Clone it
+    execSync(`git clone "${remotePath}" "${repoPath}"`, {
+        encoding: 'utf-8',
+        env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+    });
+    // Configure cloned repo
+    gitExec(repoPath, 'config user.email "test@test.com"');
+    gitExec(repoPath, 'config user.name "Test User"');
+    return { remotePath, repoPath };
+}
+/**
+ * Clean up both a repo and its remote.
+ */
+export function removeRepoWithRemote(name) {
+    removeFixtureRepo(name);
+    removeFixtureRepo(`${name}-remote`);
+}