diffstalker 0.2.1 → 0.2.3

package/dist/core/GitStateManager.js

@@ -5,8 +5,8 @@ import { watch } from 'chokidar';
 import { EventEmitter } from 'node:events';
 import ignore from 'ignore';
 import { getQueueForRepo, removeQueueForRepo } from './GitOperationQueue.js';
-import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, getHeadMessage, getCommitHistory, } from '../git/status.js';
-import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, } from '../git/diff.js';
+import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, getHeadMessage, getCommitHistory, stageHunk as gitStageHunk, unstageHunk as gitUnstageHunk, push as gitPush, fetchRemote as gitFetchRemote, pullRebase as gitPullRebase, getStashList as gitGetStashList, stashSave as gitStashSave, stashPop as gitStashPop, getLocalBranches as gitGetLocalBranches, switchBranch as gitSwitchBranch, createBranch as gitCreateBranch, softResetHead as gitSoftResetHead, cherryPick as gitCherryPick, revertCommit as gitRevertCommit, } from '../git/status.js';
+import { getDiff, getDiffForUntracked, getStagedDiff, getDefaultBaseBranch, getCandidateBaseBranches, getDiffBetweenRefs, getCompareDiffWithUncommitted, getCommitDiff, countHunksPerFile, } from '../git/diff.js';
 import { getCachedBaseBranch, setCachedBaseBranch } from '../utils/baseBranchCache.js';
 /**
  * GitStateManager manages git state independent of React.
@@ -23,9 +23,12 @@ export class GitStateManager extends EventEmitter {
     _state = {
         status: null,
         diff: null,
+        combinedFileDiffs: null,
         selectedFile: null,
         isLoading: false,
         error: null,
+        hunkCounts: null,
+        stashList: [],
     };
     _compareState = {
         compareDiff: null,
@@ -44,6 +47,12 @@ export class GitStateManager extends EventEmitter {
         index: 0,
         diff: null,
     };
+    _remoteState = {
+        operation: null,
+        inProgress: false,
+        error: null,
+        lastResult: null,
+    };
     constructor(repoPath) {
         super();
         this.repoPath = repoPath;
@@ -61,6 +70,13 @@ export class GitStateManager extends EventEmitter {
     get compareSelectionState() {
         return this._compareSelectionState;
     }
+    get remoteState() {
+        return this._remoteState;
+    }
+    updateRemoteState(partial) {
+        this._remoteState = { ...this._remoteState, ...partial };
+        this.emit('remote-state-change', this._remoteState);
+    }
     updateState(partial) {
         this._state = { ...this._state, ...partial };
         this.emit('state-change', this._state);
@@ -256,34 +272,24 @@ export class GitStateManager extends EventEmitter {
                 });
                 return;
             }
-            // Emit status immediately so the file list updates after a single git spawn
-            this.updateState({ status: newStatus });
-            // Fetch unstaged diff (updates diff view once complete)
-            const allUnstagedDiff = await getDiff(this.repoPath, undefined, false);
+            // Fetch unstaged and staged diffs in parallel
+            const [allUnstagedDiff, allStagedDiff] = await Promise.all([
+                getDiff(this.repoPath, undefined, false),
+                getDiff(this.repoPath, undefined, true),
+            ]);
+            // Count hunks per file for the file list display
+            const hunkCounts = {
+                unstaged: countHunksPerFile(allUnstagedDiff.raw),
+                staged: countHunksPerFile(allStagedDiff.raw),
+            };
             // Determine display diff based on selected file
-            let displayDiff;
-            const currentSelectedFile = this._state.selectedFile;
-            if (currentSelectedFile) {
-                const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged);
-                if (currentFile) {
-                    if (currentFile.status === 'untracked') {
-                        displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
-                    }
-                    else {
-                        displayDiff = await getDiff(this.repoPath, currentFile.path, currentFile.staged);
-                    }
-                }
-                else {
-                    // File no longer exists - clear selection, show unstaged diff
-                    displayDiff = allUnstagedDiff;
-                    this.updateState({ selectedFile: null });
-                }
-            }
-            else {
-                displayDiff = allUnstagedDiff;
-            }
+            const { displayDiff, combinedFileDiffs } = await this.resolveFileDiffs(newStatus, allUnstagedDiff);
+            // Batch status + diffs into a single update to avoid flicker
             this.updateState({
+                status: newStatus,
                 diff: displayDiff,
+                combinedFileDiffs,
+                hunkCounts,
                 isLoading: false,
             });
         }
@@ -294,6 +300,37 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    /**
+     * Resolve display diff and combined diffs for the currently selected file.
+     */
+    async resolveFileDiffs(newStatus, fallbackDiff) {
+        const currentSelectedFile = this._state.selectedFile;
+        if (!currentSelectedFile) {
+            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
+        }
+        // Match by path + staged, falling back to path-only (handles staging state changes)
+        const currentFile = newStatus.files.find((f) => f.path === currentSelectedFile.path && f.staged === currentSelectedFile.staged) ?? newStatus.files.find((f) => f.path === currentSelectedFile.path);
+        if (!currentFile) {
+            this.updateState({ selectedFile: null });
+            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
+        }
+        if (currentFile.status === 'untracked') {
+            const displayDiff = await getDiffForUntracked(this.repoPath, currentFile.path);
+            return {
+                displayDiff,
+                combinedFileDiffs: { unstaged: displayDiff, staged: { raw: '', lines: [] } },
+            };
+        }
+        const [unstagedFileDiff, stagedFileDiff] = await Promise.all([
+            getDiff(this.repoPath, currentFile.path, false),
+            getDiff(this.repoPath, currentFile.path, true),
+        ]);
+        const displayDiff = currentFile.staged ? stagedFileDiff : unstagedFileDiff;
+        return {
+            displayDiff,
+            combinedFileDiffs: { unstaged: unstagedFileDiff, staged: stagedFileDiff },
+        };
+    }
     /**
      * Select a file and update the diff display.
      * The selection highlight updates immediately; the diff fetch is debounced
@@ -323,27 +360,9 @@ export class GitStateManager extends EventEmitter {
         const file = this._state.selectedFile;
         this.queue
             .enqueue(async () => {
-            // Selection changed while queued — skip stale fetch
             if (file !== this._state.selectedFile)
                 return;
-            if (file) {
-                let fileDiff;
-                if (file.status === 'untracked') {
-                    fileDiff = await getDiffForUntracked(this.repoPath, file.path);
-                }
-                else {
-                    fileDiff = await getDiff(this.repoPath, file.path, file.staged);
-                }
-                if (file === this._state.selectedFile) {
-                    this.updateState({ diff: fileDiff });
-                }
-            }
-            else {
-                const allDiff = await getStagedDiff(this.repoPath);
-                if (this._state.selectedFile === null) {
-                    this.updateState({ diff: allDiff });
-                }
-            }
+            await this.doFetchDiffForFile(file);
         })
             .catch((err) => {
             this.updateState({
@@ -351,6 +370,36 @@ export class GitStateManager extends EventEmitter {
             });
         });
     }
+    async doFetchDiffForFile(file) {
+        if (!file) {
+            const allDiff = await getStagedDiff(this.repoPath);
+            if (this._state.selectedFile === null) {
+                this.updateState({ diff: allDiff, combinedFileDiffs: null });
+            }
+            return;
+        }
+        if (file.status === 'untracked') {
+            const fileDiff = await getDiffForUntracked(this.repoPath, file.path);
+            if (file === this._state.selectedFile) {
+                this.updateState({
+                    diff: fileDiff,
+                    combinedFileDiffs: { unstaged: fileDiff, staged: { raw: '', lines: [] } },
+                });
+            }
+            return;
+        }
+        const [unstagedDiff, stagedDiff] = await Promise.all([
+            getDiff(this.repoPath, file.path, false),
+            getDiff(this.repoPath, file.path, true),
+        ]);
+        if (file === this._state.selectedFile) {
+            const displayDiff = file.staged ? stagedDiff : unstagedDiff;
+            this.updateState({
+                diff: displayDiff,
+                combinedFileDiffs: { unstaged: unstagedDiff, staged: stagedDiff },
+            });
+        }
+    }
     /**
      * Stage a file.
      */
@@ -381,6 +430,36 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    /**
+     * Stage a single hunk via patch.
+     */
+    async stageHunk(patch) {
+        try {
+            await this.queue.enqueueMutation(async () => gitStageHunk(this.repoPath, patch));
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to stage hunk: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    /**
+     * Unstage a single hunk via patch.
+     */
+    async unstageHunk(patch) {
+        try {
+            await this.queue.enqueueMutation(async () => gitUnstageHunk(this.repoPath, patch));
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to unstage hunk: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
     /**
      * Discard changes to a file.
      */
@@ -439,6 +518,133 @@ export class GitStateManager extends EventEmitter {
             });
         }
     }
+    // Remote operations
+    /**
+     * Push to remote.
+     */
+    async push() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('push', () => gitPush(this.repoPath));
+    }
+    /**
+     * Fetch from remote.
+     */
+    async fetchRemote() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('fetch', () => gitFetchRemote(this.repoPath));
+    }
+    /**
+     * Pull with rebase from remote.
+     */
+    async pullRebase() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('pull', () => gitPullRebase(this.repoPath));
+    }
+    async runRemoteOperation(operation, fn) {
+        this.updateRemoteState({ operation, inProgress: true, error: null, lastResult: null });
+        try {
+            const result = await this.queue.enqueue(fn);
+            this.updateRemoteState({ inProgress: false, lastResult: result });
+            // Refresh status to pick up new ahead/behind counts
+            this.scheduleRefresh();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.updateRemoteState({ inProgress: false, error: message });
+        }
+    }
+    // Stash operations
+    /**
+     * Load the stash list.
+     */
+    async loadStashList() {
+        try {
+            const stashList = await this.queue.enqueue(() => gitGetStashList(this.repoPath));
+            this.updateState({ stashList });
+        }
+        catch {
+            // Silently ignore — stash list is non-critical
+        }
+    }
+    /**
+     * Save working changes to stash.
+     */
+    async stash(message) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stash', () => gitStashSave(this.repoPath, message));
+        await this.loadStashList();
+    }
+    /**
+     * Pop a stash entry.
+     */
+    async stashPop(index = 0) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stashPop', () => gitStashPop(this.repoPath, index));
+        await this.loadStashList();
+    }
+    // Branch operations
+    /**
+     * Get local branches.
+     */
+    async getLocalBranches() {
+        return this.queue.enqueue(() => gitGetLocalBranches(this.repoPath));
+    }
+    /**
+     * Switch to an existing branch.
+     */
+    async switchBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchSwitch', () => gitSwitchBranch(this.repoPath, name));
+        // Reset compare base branch since it may not exist on the new branch
+        this.updateCompareState({ compareBaseBranch: null });
+    }
+    /**
+     * Create and switch to a new branch.
+     */
+    async createBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchCreate', () => gitCreateBranch(this.repoPath, name));
+        this.updateCompareState({ compareBaseBranch: null });
+    }
+    // Undo operations
+    /**
+     * Soft reset HEAD by count commits.
+     */
+    async softReset(count = 1) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('softReset', () => gitSoftResetHead(this.repoPath, count));
+    }
+    // History actions
+    /**
+     * Cherry-pick a commit.
+     */
+    async cherryPick(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('cherryPick', () => gitCherryPick(this.repoPath, hash));
+    }
+    /**
+     * Revert a commit.
+     */
+    async revertCommit(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('revert', () => gitRevertCommit(this.repoPath, hash));
+    }
+    /**
+     * Clear the remote state (e.g. after auto-clear timeout).
+     */
+    clearRemoteState() {
+        this.updateRemoteState({ operation: null, error: null, lastResult: null });
+    }
     /**
      * Get the HEAD commit message.
      */

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,