diffstalker 0.1.5 → 0.1.7

package/dist/git/status.js

@@ -1,5 +1,269 @@
-import{simpleGit as c}from"simple-git";import*as x from"node:fs";import*as k from"node:path";export function parseNumstat(n){const e=new Map;for(const i of n.trim().split(`
-`)){if(!i)continue;const s=i.split("	");if(s.length>=3){const a=s[0]==="-"?0:parseInt(s[0],10),r=s[1]==="-"?0:parseInt(s[1],10),d=s.slice(2).join("	");e.set(d,{insertions:a,deletions:r})}}return e}async function y(n,e){try{const i=k.join(n,e);return(await x.promises.readFile(i,"utf-8")).split(`
-`).filter(a=>a.length>0).length}catch{return 0}}async function S(n,e){if(e.length===0)return new Set;try{const i=new Set,s=100;for(let a=0;a<e.length;a+=s){const r=e.slice(a,a+s);try{const l=(await n.raw(["check-ignore",...r])).trim().split(`
-`).filter(u=>u.length>0);for(const u of l)i.add(u)}catch{}}return i}catch{return new Set}}export function parseStatusCode(n){switch(n){case"M":return"modified";case"A":return"added";case"D":return"deleted";case"?":return"untracked";case"R":return"renamed";case"C":return"copied";default:return"modified"}}export async function getStatus(n){const e=c(n);try{if(!await e.checkIsRepo())return{files:[],branch:{current:"",ahead:0,behind:0},isRepo:!1};const s=await e.status(),a=[];for(const t of s.staged)a.push({path:t,status:"added",staged:!0});for(const t of s.modified)a.find(g=>g.path===t&&g.staged)||a.push({path:t,status:"modified",staged:!1});for(const t of s.deleted)a.push({path:t,status:"deleted",staged:!1});for(const t of s.not_added)a.push({path:t,status:"untracked",staged:!1});for(const t of s.renamed)a.push({path:t.to,originalPath:t.from,status:"renamed",staged:!0});const r=[],d=new Set,l=s.files.filter(t=>t.working_dir==="?").map(t=>t.path),u=await S(e,l);for(const t of s.files){if(t.index==="!"||t.working_dir==="!"||u.has(t.path))continue;const o=`${t.path}-${t.index!==" "&&t.index!=="?"}`;d.has(o)||(d.add(o),t.index&&t.index!==" "&&t.index!=="?"&&r.push({path:t.path,status:parseStatusCode(t.index),staged:!0}),t.working_dir&&t.working_dir!==" "&&r.push({path:t.path,status:t.working_dir==="?"?"untracked":parseStatusCode(t.working_dir),staged:!1}))}const[h,p]=await Promise.all([e.diff(["--cached","--numstat"]).catch(()=>""),e.diff(["--numstat"]).catch(()=>"")]),m=parseNumstat(h),w=parseNumstat(p);for(const t of r){const o=t.staged?m.get(t.path):w.get(t.path);o&&(t.insertions=o.insertions,t.deletions=o.deletions)}const f=r.filter(t=>t.status==="untracked");if(f.length>0){const t=await Promise.all(f.map(o=>y(n,o.path)));for(let o=0;o<f.length;o++)f[o].insertions=t[o],f[o].deletions=0}return{files:r,branch:{current:s.current||"HEAD",tracking:s.tracking||void 0,ahead:s.ahead,behind:s.behind},isRepo:!0}}catch{return{files:[],branch:{current:"",ahead:0,behind:0},isRepo:!1}}}export async function stageFile(n,e){await c(n).add(e)}export async function unstageFile(n,e){await c(n).reset(["HEAD","--",e])}export async function stageAll(n){await c(n).add("-A")}export async function unstageAll(n){await c(n).reset(["HEAD"])}export async function discardChanges(n,e){await c(n).checkout(["--",e])}export async function commit(n,e,i=!1){await c(n).commit(e,void 0,i?{"--amend":null}:void 0)}export async function getHeadMessage(n){const e=c(n);try{return(await e.log({n:1})).latest?.message||""}catch{return""}}export async function getCommitHistory(n,e=50){const i=c(n);try{return(await i.log({n:e})).all.map(a=>({hash:a.hash,shortHash:a.hash.slice(0,7),message:a.message.split(`
-`)[0],author:a.author_name,date:new Date(a.date),refs:a.refs||""}))}catch{return[]}}
+import { simpleGit } from 'simple-git';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// Parse git diff --numstat output into a map of path -> stats
+export function parseNumstat(output) {
+    const stats = new Map();
+    for (const line of output.trim().split('\n')) {
+        if (!line)
+            continue;
+        const parts = line.split('\t');
+        if (parts.length >= 3) {
+            const insertions = 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
+            stats.set(filepath, { insertions, deletions });
+        }
+    }
+    return stats;
+}
+// Count lines in a file (for untracked files which don't show in numstat)
+async function countFileLines(repoPath, filePath) {
+    try {
+        const fullPath = path.join(repoPath, filePath);
+        const content = await fs.promises.readFile(fullPath, 'utf-8');
+        // Count non-empty lines
+        return content.split('\n').filter((line) => line.length > 0).length;
+    }
+    catch {
+        return 0;
+    }
+}
+// Check which files from a list are ignored by git
+async function getIgnoredFiles(git, files) {
+    if (files.length === 0)
+        return new Set();
+    try {
+        // git check-ignore returns the list of ignored files (one per line)
+        // Pass files as arguments (limit batch size to avoid command line length issues)
+        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;
+    }
+    catch {
+        // If check-ignore fails entirely, return empty set
+        return new Set();
+    }
+}
+export function parseStatusCode(code) {
+    switch (code) {
+        case 'M':
+            return 'modified';
+        case 'A':
+            return 'added';
+        case 'D':
+            return 'deleted';
+        case '?':
+            return 'untracked';
+        case 'R':
+            return 'renamed';
+        case 'C':
+            return 'copied';
+        default:
+            return 'modified';
+    }
+}
+export async function getStatus(repoPath) {
+    const git = simpleGit(repoPath);
+    try {
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return {
+                files: [],
+                branch: { current: '', ahead: 0, behind: 0 },
+                isRepo: false,
+            };
+        }
+        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
+        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(git, 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;
+            }
+            const key = `${file.path}-${file.index !== ' ' && file.index !== '?'}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            // Staged changes (index column)
+            if (file.index && file.index !== ' ' && file.index !== '?') {
+                processedFiles.push({
+                    path: file.path,
+                    status: parseStatusCode(file.index),
+                    staged: true,
+                });
+            }
+            // Unstaged changes (working_dir column)
+            if (file.working_dir && file.working_dir !== ' ') {
+                processedFiles.push({
+                    path: file.path,
+                    status: file.working_dir === '?' ? 'untracked' : parseStatusCode(file.working_dir),
+                    staged: false,
+                });
+            }
+        }
+        // Fetch line stats for staged and unstaged files
+        const [stagedNumstat, unstagedNumstat] = await Promise.all([
+            git.diff(['--cached', '--numstat']).catch(() => ''),
+            git.diff(['--numstat']).catch(() => ''),
+        ]);
+        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) {
+                file.insertions = stats.insertions;
+                file.deletions = stats.deletions;
+            }
+        }
+        // Count lines for untracked files (not in numstat output)
+        const untrackedFiles = processedFiles.filter((f) => f.status === 'untracked');
+        if (untrackedFiles.length > 0) {
+            const lineCounts = await Promise.all(untrackedFiles.map((f) => countFileLines(repoPath, f.path)));
+            for (let i = 0; i < untrackedFiles.length; i++) {
+                untrackedFiles[i].insertions = lineCounts[i];
+                untrackedFiles[i].deletions = 0;
+            }
+        }
+        return {
+            files: processedFiles,
+            branch: {
+                current: status.current || 'HEAD',
+                tracking: status.tracking || undefined,
+                ahead: status.ahead,
+                behind: status.behind,
+            },
+            isRepo: true,
+        };
+    }
+    catch {
+        return {
+            files: [],
+            branch: { current: '', ahead: 0, behind: 0 },
+            isRepo: false,
+        };
+    }
+}
+export async function stageFile(repoPath, filePath) {
+    const git = simpleGit(repoPath);
+    await git.add(filePath);
+}
+export async function unstageFile(repoPath, filePath) {
+    const git = simpleGit(repoPath);
+    await git.reset(['HEAD', '--', filePath]);
+}
+export async function stageAll(repoPath) {
+    const git = simpleGit(repoPath);
+    await git.add('-A');
+}
+export async function unstageAll(repoPath) {
+    const git = simpleGit(repoPath);
+    await git.reset(['HEAD']);
+}
+export async function discardChanges(repoPath, filePath) {
+    const git = simpleGit(repoPath);
+    // Restore the file to its state in HEAD (discard working directory changes)
+    await git.checkout(['--', filePath]);
+}
+export async function commit(repoPath, message, amend = false) {
+    const git = simpleGit(repoPath);
+    await git.commit(message, undefined, amend ? { '--amend': null } : undefined);
+}
+export async function getHeadMessage(repoPath) {
+    const git = simpleGit(repoPath);
+    try {
+        const log = await git.log({ n: 1 });
+        return log.latest?.message || '';
+    }
+    catch {
+        return '';
+    }
+}
+export async function getCommitHistory(repoPath, count = 50) {
+    const git = simpleGit(repoPath);
+    try {
+        const log = await git.log({ n: count });
+        return log.all.map((entry) => ({
+            hash: entry.hash,
+            shortHash: entry.hash.slice(0, 7),
+            message: entry.message.split('\n')[0], // First line only
+            author: entry.author_name,
+            date: new Date(entry.date),
+            refs: entry.refs || '',
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/hooks/useCommitFlow.js

@@ -1 +1,66 @@
-import{useState as o,useCallback as i,useEffect as M}from"react";import{validateCommit as S,formatCommitMessage as b}from"../services/commitService.js";export function useCommitFlow(C){const{stagedCount:l,onCommit:m,onSuccess:c,getHeadMessage:f}=C,[s,n]=o(""),[t,r]=o(!1),[p,u]=o(!1),[h,a]=o(null),[v,d]=o(!1);M(()=>{t&&f().then(e=>{e&&!s&&n(e)})},[t,f]);const y=i(()=>{r(e=>!e)},[]),E=i(async()=>{const e=S(s,l,t);if(!e.valid){a(e.error);return}u(!0),a(null);try{await m(b(s),t),n(""),r(!1),c()}catch(g){a(g instanceof Error?g.message:"Commit failed")}finally{u(!1)}},[s,l,t,m,c]),F=i(()=>{n(""),r(!1),a(null),d(!1)},[]);return{message:s,amend:t,isCommitting:p,error:h,inputFocused:v,setMessage:n,toggleAmend:y,setInputFocused:d,handleSubmit:E,reset:F}}
+import { useState, useCallback, useEffect } from 'react';
+import { validateCommit, formatCommitMessage } from '../services/commitService.js';
+/**
+ * Hook that manages the commit flow state and logic.
+ * Extracted from CommitPanel to separate concerns.
+ */
+export function useCommitFlow(options) {
+    const { stagedCount, onCommit, onSuccess, getHeadMessage } = options;
+    const [message, setMessage] = useState('');
+    const [amend, setAmend] = useState(false);
+    const [isCommitting, setIsCommitting] = useState(false);
+    const [error, setError] = useState(null);
+    const [inputFocused, setInputFocused] = useState(false);
+    // Load HEAD message when amend is toggled
+    useEffect(() => {
+        if (amend) {
+            getHeadMessage().then((msg) => {
+                if (msg && !message) {
+                    setMessage(msg);
+                }
+            });
+        }
+    }, [amend, getHeadMessage]);
+    const toggleAmend = useCallback(() => {
+        setAmend((prev) => !prev);
+    }, []);
+    const handleSubmit = useCallback(async () => {
+        const validation = validateCommit(message, stagedCount, amend);
+        if (!validation.valid) {
+            setError(validation.error);
+            return;
+        }
+        setIsCommitting(true);
+        setError(null);
+        try {
+            await onCommit(formatCommitMessage(message), amend);
+            setMessage('');
+            setAmend(false);
+            onSuccess();
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Commit failed');
+        }
+        finally {
+            setIsCommitting(false);
+        }
+    }, [message, stagedCount, amend, onCommit, onSuccess]);
+    const reset = useCallback(() => {
+        setMessage('');
+        setAmend(false);
+        setError(null);
+        setInputFocused(false);
+    }, []);
+    return {
+        message,
+        amend,
+        isCommitting,
+        error,
+        inputFocused,
+        setMessage,
+        toggleAmend,
+        setInputFocused,
+        handleSubmit,
+        reset,
+    };
+}

package/dist/hooks/useCompareState.js

@@ -1 +1,123 @@
-import{useState as r,useEffect as g,useCallback as o,useMemo as b,useRef as X}from"react";import{getCompareItemIndexFromRow as Y,getFileScrollOffset as Z,getCompareDiffTotalRows as _}from"../utils/rowCalculations.js";export function useCompareState({repoPath:a,isActive:e,compareDiff:n,refreshCompareDiff:k,getCandidateBaseBranches:R,setCompareBaseBranch:C,selectCompareCommit:T,topPaneHeight:U,compareScrollOffset:c,setCompareScrollOffset:m,setDiffScrollOffset:l,status:F}){const[d,M]=r(!0),[y,h]=r(null),[u,x]=r(0),i=X(!1),[z,E]=r([]),[L,w]=r(!1);g(()=>{a&&e&&k(d)},[a,e,F,k,d]),g(()=>{a&&e&&R().then(E)},[a,e,R]),g(()=>{e&&(i.current=!1,h(null),l(0))},[e,l]),g(()=>{if(e&&n&&i.current){const t=n.commits.length,s=n.files.length;if(u<t)h({type:"commit",index:u}),T(u),l(0);else if(u<t+s){const I=u-t;h({type:"file",index:I});const W=Z(n,I);l(W)}}},[e,n,u,T,l]);const B=b(()=>n?n.commits.length+n.files.length:0,[n]),j=b(()=>_(n),[n]),q=o(()=>{M(t=>!t)},[]),G=o(()=>{w(!0)},[]),J=o(()=>{w(!1)},[]),K=o(t=>{w(!1),C(t,d)},[C,d]),N=o(()=>{i.current=!0},[]),P=o(()=>{i.current=!0,x(t=>{const s=Math.max(0,t-1);return s<c&&m(s),s})},[c,m]),Q=o(()=>{i.current=!0,x(t=>{const s=Math.min(B-1,t+1),I=c+U-2;return s>=I&&m(c+1),s})},[B,c,U,m]),V=o(t=>n?Y(t,n.commits.length,n.files.length):-1,[n]);return{includeUncommitted:d,compareListSelection:y,compareSelectedIndex:u,baseBranchCandidates:z,showBaseBranchPicker:L,compareTotalItems:B,compareDiffTotalRows:j,setCompareSelectedIndex:x,toggleIncludeUncommitted:q,openBaseBranchPicker:G,closeBaseBranchPicker:J,selectBaseBranch:K,navigateCompareUp:P,navigateCompareDown:Q,markSelectionInitialized:N,getItemIndexFromRow:V}}
+import { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import { getCompareItemIndexFromRow, getFileScrollOffset } from '../utils/rowCalculations.js';
+import { buildCompareDisplayRows, getDisplayRowsLineNumWidth, getWrappedRowCount, } from '../utils/displayRows.js';
+export function useCompareState({ repoPath, isActive, compareDiff, refreshCompareDiff, getCandidateBaseBranches, setCompareBaseBranch, selectCompareCommit, topPaneHeight, compareScrollOffset, setCompareScrollOffset, setDiffScrollOffset, status, wrapMode, terminalWidth, }) {
+    const [includeUncommitted, setIncludeUncommitted] = useState(true);
+    const [compareListSelection, setCompareListSelection] = useState(null);
+    const [compareSelectedIndex, setCompareSelectedIndex] = useState(0);
+    const compareSelectionInitialized = useRef(false);
+    const [baseBranchCandidates, setBaseBranchCandidates] = useState([]);
+    const [showBaseBranchPicker, setShowBaseBranchPicker] = useState(false);
+    // Fetch compare diff when tab becomes active
+    useEffect(() => {
+        if (repoPath && isActive) {
+            refreshCompareDiff(includeUncommitted);
+        }
+    }, [repoPath, isActive, status, refreshCompareDiff, includeUncommitted]);
+    // Fetch base branch candidates when entering compare view
+    useEffect(() => {
+        if (repoPath && isActive) {
+            getCandidateBaseBranches().then(setBaseBranchCandidates);
+        }
+    }, [repoPath, isActive, getCandidateBaseBranches]);
+    // Reset compare selection state when entering compare tab
+    useEffect(() => {
+        if (isActive) {
+            compareSelectionInitialized.current = false;
+            setCompareListSelection(null);
+            setDiffScrollOffset(0);
+        }
+    }, [isActive, setDiffScrollOffset]);
+    // Update compare selection when compareSelectedIndex changes (only after user interaction)
+    useEffect(() => {
+        if (isActive && compareDiff && compareSelectionInitialized.current) {
+            const commitCount = compareDiff.commits.length;
+            const fileCount = compareDiff.files.length;
+            if (compareSelectedIndex < commitCount) {
+                setCompareListSelection({ type: 'commit', index: compareSelectedIndex });
+                selectCompareCommit(compareSelectedIndex);
+                setDiffScrollOffset(0);
+            }
+            else if (compareSelectedIndex < commitCount + fileCount) {
+                const fileIndex = compareSelectedIndex - commitCount;
+                setCompareListSelection({ type: 'file', index: fileIndex });
+                const scrollTo = getFileScrollOffset(compareDiff, fileIndex);
+                setDiffScrollOffset(scrollTo);
+            }
+        }
+    }, [isActive, compareDiff, compareSelectedIndex, selectCompareCommit, setDiffScrollOffset]);
+    // Computed values
+    const compareTotalItems = useMemo(() => {
+        if (!compareDiff)
+            return 0;
+        return compareDiff.commits.length + compareDiff.files.length;
+    }, [compareDiff]);
+    // When wrap mode is enabled, account for wrapped lines
+    const compareDiffTotalRows = useMemo(() => {
+        const displayRows = buildCompareDisplayRows(compareDiff);
+        if (!wrapMode)
+            return displayRows.length;
+        const lineNumWidth = getDisplayRowsLineNumWidth(displayRows);
+        const contentWidth = terminalWidth - lineNumWidth - 5;
+        return getWrappedRowCount(displayRows, contentWidth, true);
+    }, [compareDiff, wrapMode, terminalWidth]);
+    // Handlers
+    const toggleIncludeUncommitted = useCallback(() => {
+        setIncludeUncommitted((prev) => !prev);
+    }, []);
+    const openBaseBranchPicker = useCallback(() => {
+        setShowBaseBranchPicker(true);
+    }, []);
+    const closeBaseBranchPicker = useCallback(() => {
+        setShowBaseBranchPicker(false);
+    }, []);
+    const selectBaseBranch = useCallback((branch) => {
+        setShowBaseBranchPicker(false);
+        setCompareBaseBranch(branch, includeUncommitted);
+    }, [setCompareBaseBranch, includeUncommitted]);
+    const markSelectionInitialized = useCallback(() => {
+        compareSelectionInitialized.current = true;
+    }, []);
+    const navigateCompareUp = useCallback(() => {
+        compareSelectionInitialized.current = true;
+        setCompareSelectedIndex((prev) => {
+            const newIndex = Math.max(0, prev - 1);
+            if (newIndex < compareScrollOffset)
+                setCompareScrollOffset(newIndex);
+            return newIndex;
+        });
+    }, [compareScrollOffset, setCompareScrollOffset]);
+    const navigateCompareDown = useCallback(() => {
+        compareSelectionInitialized.current = true;
+        setCompareSelectedIndex((prev) => {
+            const newIndex = Math.min(compareTotalItems - 1, prev + 1);
+            const visibleEnd = compareScrollOffset + topPaneHeight - 2;
+            if (newIndex >= visibleEnd)
+                setCompareScrollOffset(compareScrollOffset + 1);
+            return newIndex;
+        });
+    }, [compareTotalItems, compareScrollOffset, topPaneHeight, setCompareScrollOffset]);
+    const getItemIndexFromRow = useCallback((visualRow) => {
+        if (!compareDiff)
+            return -1;
+        return getCompareItemIndexFromRow(visualRow, compareDiff.commits.length, compareDiff.files.length);
+    }, [compareDiff]);
+    return {
+        includeUncommitted,
+        compareListSelection,
+        compareSelectedIndex,
+        baseBranchCandidates,
+        showBaseBranchPicker,
+        compareTotalItems,
+        compareDiffTotalRows,
+        setCompareSelectedIndex,
+        toggleIncludeUncommitted,
+        openBaseBranchPicker,
+        closeBaseBranchPicker,
+        selectBaseBranch,
+        navigateCompareUp,
+        navigateCompareDown,
+        markSelectionInitialized,
+        getItemIndexFromRow,
+    };
+}