diffstalker 0.2.2 → 0.2.4

package/dist/core/HistoryManager.js

@@ -0,0 +1,72 @@
+import { EventEmitter } from 'node:events';
+import { getCommitHistory, getHeadMessage } from '../git/status.js';
+import { getCommitDiff } from '../git/diff.js';
+/**
+ * Manages commit history state: loading, selection, and diff display.
+ */
+export class HistoryManager extends EventEmitter {
+    repoPath;
+    queue;
+    _historyState = {
+        commits: [],
+        selectedCommit: null,
+        commitDiff: null,
+        isLoading: false,
+    };
+    constructor(repoPath, queue) {
+        super();
+        this.repoPath = repoPath;
+        this.queue = queue;
+    }
+    get historyState() {
+        return this._historyState;
+    }
+    updateHistoryState(partial) {
+        this._historyState = { ...this._historyState, ...partial };
+        this.emit('history-state-change', this._historyState);
+    }
+    /**
+     * Refresh history if it was previously loaded (has commits).
+     * Called by the cascade refresh after file changes.
+     */
+    async refreshIfLoaded(count = 100) {
+        if (this._historyState.commits.length > 0) {
+            await this.doLoadHistory(count);
+        }
+    }
+    /**
+     * Load commit history for the history view.
+     */
+    async loadHistory(count = 100) {
+        this.updateHistoryState({ isLoading: true });
+        try {
+            await this.queue.enqueue(() => this.doLoadHistory(count));
+        }
+        catch (err) {
+            this.updateHistoryState({ isLoading: false });
+            throw err;
+        }
+    }
+    async doLoadHistory(count = 100) {
+        const commits = await getCommitHistory(this.repoPath, count);
+        this.updateHistoryState({ commits, selectedCommit: null, commitDiff: null, isLoading: false });
+    }
+    /**
+     * Select a commit in history view and load its diff.
+     */
+    async selectHistoryCommit(commit) {
+        this.updateHistoryState({ selectedCommit: commit, commitDiff: null });
+        if (!commit)
+            return;
+        await this.queue.enqueue(async () => {
+            const diff = await getCommitDiff(this.repoPath, commit.hash);
+            this.updateHistoryState({ commitDiff: diff });
+        });
+    }
+    /**
+     * Get the HEAD commit message.
+     */
+    async getHeadCommitMessage() {
+        return this.queue.enqueue(() => getHeadMessage(this.repoPath));
+    }
+}

package/dist/core/RemoteOperationManager.js

@@ -0,0 +1,109 @@
+import { EventEmitter } from 'node:events';
+import { push as gitPush, fetchRemote as gitFetchRemote, pullRebase as gitPullRebase, 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';
+/**
+ * Manages remote operations (push/pull/fetch), stash, branch switching, and undo operations.
+ * Uses callbacks for cross-manager coordination (refresh, stash list, compare reset).
+ */
+export class RemoteOperationManager extends EventEmitter {
+    repoPath;
+    queue;
+    callbacks;
+    _remoteState = {
+        operation: null,
+        inProgress: false,
+        error: null,
+        lastResult: null,
+    };
+    constructor(repoPath, queue, callbacks) {
+        super();
+        this.repoPath = repoPath;
+        this.queue = queue;
+        this.callbacks = callbacks;
+    }
+    get remoteState() {
+        return this._remoteState;
+    }
+    updateRemoteState(partial) {
+        this._remoteState = { ...this._remoteState, ...partial };
+        this.emit('remote-state-change', this._remoteState);
+    }
+    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 });
+            this.callbacks.scheduleRefresh();
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.updateRemoteState({ inProgress: false, error: message });
+        }
+    }
+    /**
+     * Clear the remote state (e.g. after auto-clear timeout).
+     */
+    clearRemoteState() {
+        this.updateRemoteState({ operation: null, error: null, lastResult: null });
+    }
+    // --- Remote operations ---
+    async push() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('push', () => gitPush(this.repoPath));
+    }
+    async fetchRemote() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('fetch', () => gitFetchRemote(this.repoPath));
+    }
+    async pullRebase() {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('pull', () => gitPullRebase(this.repoPath));
+    }
+    // --- Stash operations ---
+    async stash(message) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stash', () => gitStashSave(this.repoPath, message));
+        await this.callbacks.loadStashList();
+    }
+    async stashPop(index = 0) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('stashPop', () => gitStashPop(this.repoPath, index));
+        await this.callbacks.loadStashList();
+    }
+    // --- Branch operations ---
+    async getLocalBranches() {
+        return this.queue.enqueue(() => gitGetLocalBranches(this.repoPath));
+    }
+    async switchBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchSwitch', () => gitSwitchBranch(this.repoPath, name));
+        this.callbacks.resetCompareBaseBranch();
+    }
+    async createBranch(name) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('branchCreate', () => gitCreateBranch(this.repoPath, name));
+        this.callbacks.resetCompareBaseBranch();
+    }
+    // --- Undo operations ---
+    async softReset(count = 1) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('softReset', () => gitSoftResetHead(this.repoPath, count));
+    }
+    async cherryPick(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('cherryPick', () => gitCherryPick(this.repoPath, hash));
+    }
+    async revertCommit(hash) {
+        if (this._remoteState.inProgress)
+            return;
+        await this.runRemoteOperation('revert', () => gitRevertCommit(this.repoPath, hash));
+    }
+}

package/dist/core/WorkingTreeManager.js

@@ -0,0 +1,412 @@
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { watch } from 'chokidar';
+import { EventEmitter } from 'node:events';
+import ignore from 'ignore';
+import * as logger from '../utils/logger.js';
+import { getStatus, stageFile, unstageFile, stageAll as gitStageAll, unstageAll as gitUnstageAll, discardChanges as gitDiscardChanges, commit as gitCommit, stageHunk as gitStageHunk, unstageHunk as gitUnstageHunk, getStashList as gitGetStashList, } from '../git/status.js';
+import { getDiff, getDiffForUntracked, getStagedDiff, countHunksPerFile, } from '../git/diff.js';
+/**
+ * Manages the working tree: file watching, status, diffs, staging, and commits.
+ * Accepts an onRefresh callback for cascading refreshes to history/compare managers.
+ */
+export class WorkingTreeManager extends EventEmitter {
+    repoPath;
+    queue;
+    onRefresh;
+    gitWatcher = null;
+    workingDirWatcher = null;
+    ignorers = new Map();
+    diffDebounceTimer = null;
+    _state = {
+        status: null,
+        diff: null,
+        combinedFileDiffs: null,
+        selectedFile: null,
+        isLoading: false,
+        error: null,
+        hunkCounts: null,
+        stashList: [],
+    };
+    constructor(repoPath, queue, onRefresh) {
+        super();
+        this.repoPath = repoPath;
+        this.queue = queue;
+        this.onRefresh = onRefresh ?? null;
+    }
+    get state() {
+        return this._state;
+    }
+    updateState(partial) {
+        this._state = { ...this._state, ...partial };
+        this.emit('state-change', this._state);
+    }
+    // --- Gitignore loading ---
+    loadGitignores() {
+        const ignorers = new Map();
+        const rootIg = ignore();
+        rootIg.add('.git');
+        const rootGitignorePath = path.join(this.repoPath, '.gitignore');
+        if (fs.existsSync(rootGitignorePath)) {
+            rootIg.add(fs.readFileSync(rootGitignorePath, 'utf-8'));
+        }
+        const excludePath = path.join(this.repoPath, '.git', 'info', 'exclude');
+        if (fs.existsSync(excludePath)) {
+            rootIg.add(fs.readFileSync(excludePath, 'utf-8'));
+        }
+        ignorers.set('', rootIg);
+        try {
+            const output = execFileSync('git', ['ls-files', '-z', '--cached', '--others', '**/.gitignore'], { cwd: this.repoPath, encoding: 'utf-8' });
+            for (const entry of output.split('\0')) {
+                if (!entry || entry === '.gitignore')
+                    continue;
+                if (!entry.endsWith('.gitignore'))
+                    continue;
+                const dir = path.dirname(entry);
+                const absPath = path.join(this.repoPath, entry);
+                try {
+                    const content = fs.readFileSync(absPath, 'utf-8');
+                    const ig = ignore();
+                    ig.add(content);
+                    ignorers.set(dir, ig);
+                }
+                catch (err) {
+                    logger.warn(`Failed to read ${absPath}: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+        }
+        catch {
+            // git ls-files failed — we still have the root ignorer
+        }
+        return ignorers;
+    }
+    // --- File watching ---
+    startWatching() {
+        const gitDir = path.join(this.repoPath, '.git');
+        if (!fs.existsSync(gitDir))
+            return;
+        const indexFile = path.join(gitDir, 'index');
+        const headFile = path.join(gitDir, 'HEAD');
+        const refsDir = path.join(gitDir, 'refs');
+        const gitignorePath = path.join(this.repoPath, '.gitignore');
+        this.gitWatcher = watch([indexFile, headFile, refsDir, gitignorePath], {
+            persistent: true,
+            ignoreInitial: true,
+            usePolling: true,
+            interval: 100,
+        });
+        this.ignorers = this.loadGitignores();
+        this.workingDirWatcher = watch(this.repoPath, {
+            persistent: true,
+            ignoreInitial: true,
+            ignored: (filePath) => {
+                const relativePath = path.relative(this.repoPath, filePath);
+                if (!relativePath)
+                    return false;
+                const parts = relativePath.split('/');
+                for (let depth = 0; depth < parts.length; depth++) {
+                    const dir = depth === 0 ? '' : parts.slice(0, depth).join('/');
+                    const ig = this.ignorers.get(dir);
+                    if (ig) {
+                        const relToDir = depth === 0 ? relativePath : parts.slice(depth).join('/');
+                        if (ig.ignores(relToDir))
+                            return true;
+                    }
+                }
+                return false;
+            },
+            awaitWriteFinish: {
+                stabilityThreshold: 100,
+                pollInterval: 50,
+            },
+        });
+        const scheduleRefresh = () => this.scheduleRefresh();
+        this.gitWatcher.on('change', (filePath) => {
+            if (filePath === gitignorePath) {
+                this.ignorers = this.loadGitignores();
+            }
+            scheduleRefresh();
+        });
+        this.gitWatcher.on('add', scheduleRefresh);
+        this.gitWatcher.on('unlink', scheduleRefresh);
+        this.gitWatcher.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            this.emit('error', `Git watcher error: ${message}`);
+        });
+        this.workingDirWatcher.on('change', scheduleRefresh);
+        this.workingDirWatcher.on('add', scheduleRefresh);
+        this.workingDirWatcher.on('unlink', scheduleRefresh);
+        this.workingDirWatcher.on('error', (err) => {
+            const message = err instanceof Error ? err.message : String(err);
+            this.emit('error', `Working dir watcher error: ${message}`);
+        });
+    }
+    dispose() {
+        if (this.diffDebounceTimer)
+            clearTimeout(this.diffDebounceTimer);
+        this.gitWatcher?.close();
+        this.workingDirWatcher?.close();
+    }
+    // --- Refresh ---
+    scheduleRefresh() {
+        this.queue.scheduleRefresh(async () => {
+            await this.doRefresh();
+            // Cascade refresh to history and compare if loaded
+            if (this.onRefresh) {
+                await this.onRefresh();
+            }
+        });
+    }
+    scheduleStatusRefresh() {
+        this.queue.scheduleRefresh(async () => {
+            const newStatus = await getStatus(this.repoPath);
+            if (!newStatus.isRepo) {
+                this.updateState({
+                    status: newStatus,
+                    diff: null,
+                    isLoading: false,
+                    error: 'Not a git repository',
+                });
+                return;
+            }
+            this.updateState({ status: newStatus, isLoading: false });
+        });
+    }
+    async refresh() {
+        await this.queue.enqueue(() => this.doRefresh());
+    }
+    async doRefresh() {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            const newStatus = await getStatus(this.repoPath);
+            if (!newStatus.isRepo) {
+                this.updateState({
+                    status: newStatus,
+                    diff: null,
+                    isLoading: false,
+                    error: 'Not a git repository',
+                });
+                return;
+            }
+            const [allUnstagedDiff, allStagedDiff] = await Promise.all([
+                getDiff(this.repoPath, undefined, false),
+                getDiff(this.repoPath, undefined, true),
+            ]);
+            const hunkCounts = {
+                unstaged: countHunksPerFile(allUnstagedDiff.raw),
+                staged: countHunksPerFile(allStagedDiff.raw),
+            };
+            const { displayDiff, combinedFileDiffs } = await this.resolveFileDiffs(newStatus, allUnstagedDiff);
+            this.updateState({
+                status: newStatus,
+                diff: displayDiff,
+                combinedFileDiffs,
+                hunkCounts,
+                isLoading: false,
+            });
+        }
+        catch (err) {
+            this.updateState({
+                isLoading: false,
+                error: err instanceof Error ? err.message : 'Unknown error',
+            });
+        }
+    }
+    async resolveFileDiffs(newStatus, fallbackDiff) {
+        const currentSelectedFile = this._state.selectedFile;
+        if (!currentSelectedFile) {
+            return { displayDiff: fallbackDiff, combinedFileDiffs: null };
+        }
+        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 },
+        };
+    }
+    // --- File selection ---
+    selectFile(file) {
+        this.updateState({ selectedFile: file });
+        if (!this._state.status?.isRepo)
+            return;
+        if (this.diffDebounceTimer) {
+            clearTimeout(this.diffDebounceTimer);
+            this.diffDebounceTimer = setTimeout(() => {
+                this.diffDebounceTimer = null;
+                this.fetchDiffForSelection();
+            }, 20);
+        }
+        else {
+            this.fetchDiffForSelection();
+            this.diffDebounceTimer = setTimeout(() => {
+                this.diffDebounceTimer = null;
+            }, 20);
+        }
+    }
+    fetchDiffForSelection() {
+        const file = this._state.selectedFile;
+        this.queue
+            .enqueue(async () => {
+            if (file !== this._state.selectedFile)
+                return;
+            await this.doFetchDiffForFile(file);
+        })
+            .catch((err) => {
+            this.updateState({
+                error: `Failed to load diff: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        });
+    }
+    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 },
+            });
+        }
+    }
+    // --- Staging operations ---
+    async stage(file) {
+        try {
+            await this.queue.enqueueMutation(() => stageFile(this.repoPath, file.path));
+            this.scheduleStatusRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to stage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async unstage(file) {
+        try {
+            await this.queue.enqueueMutation(() => unstageFile(this.repoPath, file.path));
+            this.scheduleStatusRefresh();
+        }
+        catch (err) {
+            await this.refresh();
+            this.updateState({
+                error: `Failed to unstage ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    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)}`,
+            });
+        }
+    }
+    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)}`,
+            });
+        }
+    }
+    async discard(file) {
+        if (file.staged || file.status === 'untracked')
+            return;
+        try {
+            await this.queue.enqueueMutation(() => gitDiscardChanges(this.repoPath, file.path));
+            await this.refresh();
+        }
+        catch (err) {
+            this.updateState({
+                error: `Failed to discard ${file.path}: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async stageAll() {
+        try {
+            await this.queue.enqueueMutation(() => gitStageAll(this.repoPath));
+            await this.refresh();
+        }
+        catch (err) {
+            this.updateState({
+                error: `Failed to stage all: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    async unstageAll() {
+        try {
+            await this.queue.enqueueMutation(() => gitUnstageAll(this.repoPath));
+            await this.refresh();
+        }
+        catch (err) {
+            this.updateState({
+                error: `Failed to unstage all: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // --- Commit ---
+    async commit(message, amend = false) {
+        try {
+            await this.queue.enqueue(() => gitCommit(this.repoPath, message, amend));
+            await this.refresh();
+        }
+        catch (err) {
+            this.updateState({
+                error: `Failed to commit: ${err instanceof Error ? err.message : String(err)}`,
+            });
+        }
+    }
+    // --- 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
+        }
+    }
+}

package/dist/git/status.js

@@ -180,6 +180,30 @@ export function unstageHunk(repoPath, patch) {
         encoding: 'utf-8',
     });
 }
+export async function push(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.push();
+    // Build a summary string from the push result
+    const pushed = result.pushed;
+    if (pushed.length === 0)
+        return 'Everything up-to-date';
+    return pushed.map((p) => `${p.local} → ${p.remote}`).join(', ');
+}
+export async function fetchRemote(repoPath) {
+    const git = simpleGit(repoPath);
+    await git.fetch();
+    return 'Fetch complete';
+}
+export async function pullRebase(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.pull(['--rebase']);
+    if (result.summary.changes === 0 &&
+        result.summary.insertions === 0 &&
+        result.summary.deletions === 0) {
+        return 'Already up-to-date';
+    }
+    return `${result.summary.changes} file(s) changed`;
+}
 export async function getCommitHistory(repoPath, count = 50) {
     const git = simpleGit(repoPath);
     try {
@@ -197,3 +221,74 @@ export async function getCommitHistory(repoPath, count = 50) {
         return [];
     }
 }
+export async function getStashList(repoPath) {
+    const git = simpleGit(repoPath);
+    try {
+        const result = await git.stashList();
+        return result.all.map((entry, i) => ({
+            index: i,
+            message: entry.message,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+export async function stashSave(repoPath, message) {
+    const git = simpleGit(repoPath);
+    const args = ['push'];
+    if (message)
+        args.push('-m', message);
+    await git.stash(args);
+    return 'Stashed';
+}
+export async function stashPop(repoPath, index = 0) {
+    const git = simpleGit(repoPath);
+    await git.stash(['pop', `stash@{${index}}`]);
+    return 'Stash popped';
+}
+export async function getLocalBranches(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.branchLocal();
+    return result.all.map((name) => ({
+        name,
+        current: name === result.current,
+        tracking: result.branches[name]?.label || undefined,
+    }));
+}
+export async function switchBranch(repoPath, name) {
+    const git = simpleGit(repoPath);
+    await git.checkout(name);
+    return `Switched to ${name}`;
+}
+export async function createBranch(repoPath, name) {
+    const git = simpleGit(repoPath);
+    await git.checkoutLocalBranch(name);
+    return `Created ${name}`;
+}
+// Undo operations
+export async function softResetHead(repoPath, count = 1) {
+    const git = simpleGit(repoPath);
+    await git.reset(['--soft', `HEAD~${count}`]);
+    return 'Reset done';
+}
+// History actions
+export async function cherryPick(repoPath, hash) {
+    const git = simpleGit(repoPath);
+    await git.raw(['cherry-pick', hash]);
+    return 'Cherry-picked';
+}
+export async function revertCommit(repoPath, hash) {
+    const git = simpleGit(repoPath);
+    await git.revert(hash);
+    return 'Reverted';
+}
+/**
+ * List all files in the repo: tracked files + untracked (not ignored) files.
+ * Uses git ls-files which is fast (git already has the index in memory).
+ */
+export async function listAllFiles(repoPath) {
+    const git = simpleGit(repoPath);
+    const result = await git.raw(['ls-files', '-z', '--cached', '--others', '--exclude-standard']);
+    return result.split('\0').filter((f) => f.length > 0);
+}