difit 4.0.0 → 4.0.1

package/dist/server/git-diff-tui.js

@@ -1,6 +1,6 @@
 import simpleGit from 'simple-git';
 import { validateDiffArguments, createCommitRangeString } from '../cli/utils.js';
-export async function loadGitDiff(targetCommitish, baseCommitish, repoPath) {
+export async function loadGitDiff(targetCommitish, baseCommitish, repoPath, contextLines) {
     // Validate arguments
     const validation = validateDiffArguments(targetCommitish, baseCommitish);
     if (!validation.valid) {
@@ -44,34 +44,36 @@ export async function loadGitDiff(targetCommitish, baseCommitish, repoPath) {
         const path = pathParts.join('\t');
         return { status, path };
     });
+    const contextArgs = contextLines !== undefined ? [`-U${contextLines}`] : [];
     // Get diff for each file individually
     const fileDiffs = await Promise.all(fileChanges.map(async ({ status, path }) => {
         let fileDiff = '';
         // Handle individual file diffs (base is always a regular commit)
         if (targetCommitish === 'working') {
             // Show unstaged changes (working vs staged)
-            fileDiff = await git.diff(['--', path]);
+            fileDiff = await git.diff([...contextArgs, '--', path]);
         }
         else if (targetCommitish === 'staged') {
             // Show staged changes against base commit
-            fileDiff = await git.diff(['--cached', baseCommitish, '--', path]);
+            fileDiff = await git.diff(['--cached', baseCommitish, ...contextArgs, '--', path]);
         }
         else if (targetCommitish === '.') {
             // Show all uncommitted changes against base commit
-            fileDiff = await git.diff([baseCommitish, '--', path]);
+            fileDiff = await git.diff([baseCommitish, ...contextArgs, '--', path]);
         }
         else {
             try {
                 // Both are regular commits: standard commit-to-commit comparison
                 fileDiff = await git.diff([
                     createCommitRangeString(baseCommitish, targetCommitish),
+                    ...contextArgs,
                     '--',
                     path,
                 ]);
             }
             catch {
                 // For new files or if parent doesn't exist
-                fileDiff = await git.diff([targetCommitish, '--', path]);
+                fileDiff = await git.diff([targetCommitish, ...contextArgs, '--', path]);
             }
         }
         const lines = fileDiff.split('\n');

package/dist/server/git-diff-tui.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/server/git-diff-tui.test.js

@@ -0,0 +1,60 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { loadGitDiff } from './git-diff-tui.js';
+const mockDiff = vi.hoisted(() => vi.fn());
+const mockSimpleGit = vi.hoisted(() => vi.fn(() => ({ diff: mockDiff })));
+vi.mock('simple-git', () => ({
+    default: mockSimpleGit,
+}));
+describe('loadGitDiff', () => {
+    beforeEach(() => {
+        mockDiff.mockReset();
+        mockSimpleGit.mockClear();
+    });
+    it.each([
+        {
+            name: 'working tree diffs',
+            targetCommitish: 'working',
+            baseCommitish: 'staged',
+            expectedListArgs: ['--name-status'],
+            expectedFileArgs: ['-U5', '--', 'src/file.ts'],
+        },
+        {
+            name: 'staged diffs',
+            targetCommitish: 'staged',
+            baseCommitish: 'HEAD',
+            expectedListArgs: ['--cached', 'HEAD', '--name-status'],
+            expectedFileArgs: ['--cached', 'HEAD', '-U5', '--', 'src/file.ts'],
+        },
+        {
+            name: 'working tree against a base commit',
+            targetCommitish: '.',
+            baseCommitish: 'HEAD',
+            expectedListArgs: ['HEAD', '--name-status'],
+            expectedFileArgs: ['HEAD', '-U5', '--', 'src/file.ts'],
+        },
+        {
+            name: 'commit comparisons',
+            targetCommitish: 'HEAD',
+            baseCommitish: 'HEAD^',
+            expectedListArgs: ['HEAD^...HEAD', '--name-status'],
+            expectedFileArgs: ['HEAD^...HEAD', '-U5', '--', 'src/file.ts'],
+        },
+    ])('passes context lines for $name', async ({ targetCommitish, baseCommitish, expectedListArgs, expectedFileArgs }) => {
+        mockDiff
+            .mockResolvedValueOnce('M\tsrc/file.ts')
+            .mockResolvedValueOnce('@@ -1 +1 @@\n-old line\n+new line\n');
+        const result = await loadGitDiff(targetCommitish, baseCommitish, '/repo', 5);
+        expect(mockSimpleGit).toHaveBeenCalledWith('/repo');
+        expect(mockDiff).toHaveBeenNthCalledWith(1, expectedListArgs);
+        expect(mockDiff).toHaveBeenNthCalledWith(2, expectedFileArgs);
+        expect(result).toEqual([
+            {
+                path: 'src/file.ts',
+                status: 'M',
+                diff: '@@ -1 +1 @@\n-old line\n+new line\n',
+                additions: 1,
+                deletions: 1,
+            },
+        ]);
+    });
+});

package/dist/server/git-diff.d.ts

@@ -7,7 +7,7 @@ export declare class GitDiffParser {
     private static readonly GENERATED_HEADER_SCAN_BYTES;
     constructor(repoPath?: string);
     private normalizeRepositoryRelativePath;
-    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean): Promise<DiffResponse>;
+    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean, contextLines?: number): Promise<DiffResponse>;
     private parseUnifiedDiff;
     private decodeGitPath;
     private extractPathFromLine;
@@ -27,6 +27,7 @@ export declare class GitDiffParser {
     resolveCommitish(commitish: string): Promise<string>;
     clearResolvedCommitCache(): void;
     getDefaultBranch(): Promise<string | null>;
+    getOriginDefaultBranch(): Promise<string | null>;
     getRevisionOptions(currentBase?: string, currentTarget?: string): Promise<{
         branches: Array<{
             name: string;
@@ -37,6 +38,7 @@ export declare class GitDiffParser {
             shortHash: string;
             message: string;
         }>;
+        originDefaultBranch?: string;
         resolvedBase?: string;
         resolvedTarget?: string;
     }>;

package/dist/server/git-diff.js

@@ -28,7 +28,7 @@ export class GitDiffParser {
         }
         return normalizedFilepath;
     }
-    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false) {
+    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false, contextLines) {
         try {
             // Validate arguments
             const validation = validateDiffArguments(targetCommitish, baseCommitish);
@@ -65,6 +65,9 @@ export class GitDiffParser {
             if (ignoreWhitespace) {
                 diffArgs.push('-w');
             }
+            if (contextLines !== undefined) {
+                diffArgs.push(`-U${contextLines}`);
+            }
             // Ignore external diff-tools to unify output.
             // https://github.com/yoshiko-pg/difit/issues/19
             diffArgs.push('--no-ext-diff', '--color=never');
@@ -478,11 +481,39 @@ export class GitDiffParser {
         }
         return null;
     }
+    async getOriginDefaultBranch() {
+        try {
+            const result = await this.git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
+            const match = result.trim().match(/refs\/remotes\/origin\/(.+)/);
+            if (match) {
+                return `origin/${match[1]}`;
+            }
+        }
+        catch {
+            const commonDefaults = ['main', 'master'];
+            for (const defaultName of commonDefaults) {
+                try {
+                    await this.git.raw([
+                        'show-ref',
+                        '--verify',
+                        '--quiet',
+                        `refs/remotes/origin/${defaultName}`,
+                    ]);
+                    return `origin/${defaultName}`;
+                }
+                catch {
+                    // Ignore missing refs and continue checking common defaults.
+                }
+            }
+        }
+        return null;
+    }
     async getRevisionOptions(currentBase, currentTarget) {
-        const [branchResult, logResult, defaultBranch] = await Promise.all([
+        const [branchResult, logResult, defaultBranch, originDefaultBranch] = await Promise.all([
             this.git.branchLocal(),
             this.git.log({ maxCount: 20 }),
             this.getDefaultBranch(),
+            this.getOriginDefaultBranch(),
         ]);
         const branches = Object.entries(branchResult.branches).map(([name, data]) => ({
             name,
@@ -526,6 +557,12 @@ export class GitDiffParser {
                 // If resolution fails, leave undefined
             }
         }
-        return { branches, commits, resolvedBase, resolvedTarget };
+        return {
+            branches,
+            commits,
+            originDefaultBranch: originDefaultBranch ?? undefined,
+            resolvedBase,
+            resolvedTarget,
+        };
     }
 }

package/dist/server/git-diff.test.js

@@ -1071,6 +1071,26 @@ index abc123..def456 100644
         });
     });
     describe('parseDiff', () => {
+        it('passes context lines through to git diff', async () => {
+            const gitDiff = parser.git.diff;
+            const gitRevparse = parser.git.revparse;
+            gitRevparse
+                .mockResolvedValueOnce('1234567890abcdef1234567890abcdef12345678')
+                .mockResolvedValueOnce('abcdef1234567890abcdef1234567890abcdef12');
+            gitDiff.mockResolvedValue('');
+            const response = await parser.parseDiff('HEAD', 'HEAD~1', false, 5);
+            expect(gitDiff).toHaveBeenCalledWith([
+                'abcdef1...1234567',
+                '-U5',
+                '--no-ext-diff',
+                '--color=never',
+            ]);
+            expect(response).toEqual({
+                commit: 'abcdef1...1234567',
+                files: [],
+                isEmpty: true,
+            });
+        });
         it('accepts branch refs with revision suffixes', async () => {
             const gitDiff = parser.git.diff;
             const gitRevparse = parser.git.revparse;

package/dist/server/server.d.ts

@@ -15,6 +15,7 @@ interface ServerOptions {
     keepAlive?: boolean;
     diffMode?: DiffMode;
     repoPath?: string;
+    contextLines?: number;
 }
 export declare function startServer(options: ServerOptions): Promise<{
     port: number;

package/dist/server/server.js

@@ -51,7 +51,7 @@ export async function startServer(options) {
         diffDataCache = parser.parseStdinDiff(options.stdinDiff);
     }
     else {
-        diffDataCache = await parser.parseDiff(options.targetCommitish ?? '', options.baseCommitish ?? '', currentIgnoreWhitespace);
+        diffDataCache = await parser.parseDiff(options.targetCommitish ?? '', options.baseCommitish ?? '', currentIgnoreWhitespace, options.contextLines);
     }
     // Function to invalidate cache when file changes are detected
     const invalidateCache = () => {
@@ -92,7 +92,7 @@ export async function startServer(options) {
             currentIgnoreWhitespace = ignoreWhitespace;
             currentBaseCommitish = requestedBase;
             currentTargetCommitish = requestedTarget;
-            diffDataCache = await parser.parseDiff(requestedTarget, requestedBase, ignoreWhitespace);
+            diffDataCache = await parser.parseDiff(requestedTarget, requestedBase, ignoreWhitespace, options.contextLines);
             generatedStatusCache.clear();
         }
         // Resolve symbolic refs like HEAD/HEAD^ to actual hashes for the UI
@@ -179,7 +179,7 @@ export async function startServer(options) {
             return;
         }
         try {
-            const { branches, commits, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentBaseCommitish, currentTargetCommitish);
+            const { branches, commits, originDefaultBranch, resolvedBase, resolvedTarget } = await parser.getRevisionOptions(currentBaseCommitish, currentTargetCommitish);
             const response = {
                 specialOptions: [
                     { value: '.', label: 'All Uncommitted Changes' },
@@ -188,6 +188,7 @@ export async function startServer(options) {
                 ],
                 branches,
                 commits,
+                originDefaultBranch,
                 resolvedBase,
                 resolvedTarget,
             };

package/dist/server/server.test.js

@@ -5,6 +5,7 @@ import { startServer } from './server.js';
 // Add fetch polyfill for Node.js test environment
 const { fetch } = await import('undici');
 globalThis.fetch = fetch;
+const parserInstances = vi.hoisted(() => []);
 // Helper function to get available port
 async function getAvailablePort(preferredPort) {
     let port = preferredPort;
@@ -25,6 +26,9 @@ async function getAvailablePort(preferredPort) {
 // Mock GitDiffParser
 vi.mock('./git-diff.js', () => {
     class GitDiffParserMock {
+        constructor() {
+            parserInstances.push(this);
+        }
         validateCommit = vi.fn().mockResolvedValue(true);
         parseDiff = vi.fn().mockResolvedValue({
             targetCommit: 'abc123',
@@ -68,6 +72,7 @@ vi.mock('./git-diff.js', () => {
         getRevisionOptions = vi.fn().mockResolvedValue({
             branches: [{ name: 'main', current: true }],
             commits: [{ hash: 'abc1234', shortHash: 'abc1234', message: 'Test commit' }],
+            originDefaultBranch: 'origin/main',
             resolvedBase: 'abc1234',
             resolvedTarget: 'def5678',
         });
@@ -167,6 +172,7 @@ describe('Server Integration Tests', () => {
         // Mock process.exit to prevent tests from actually exiting
         originalProcessExit = process.exit;
         process.exit = vi.fn();
+        parserInstances.length = 0;
     });
     afterEach(async () => {
         // Restore process.exit
@@ -226,6 +232,17 @@ describe('Server Integration Tests', () => {
             servers.push(result.server);
             expect(result.url).toContain('http://localhost:'); // Display host conversion
         });
+        it('passes context lines to the initial diff load', async () => {
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9025,
+                contextLines: 4,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            expect(parser?.parseDiff).toHaveBeenCalledWith('HEAD', 'HEAD^', false, 4);
+        });
     });
     describe('API endpoints', () => {
         let port;
@@ -256,6 +273,20 @@ describe('Server Integration Tests', () => {
             expect(response.ok).toBe(true);
             expect(data).toHaveProperty('ignoreWhitespace', true);
         });
+        it('GET /api/diff preserves context lines when recalculating revisions', async () => {
+            const result = await startServer({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: 9031,
+                contextLines: 2,
+            });
+            servers.push(result.server);
+            const parser = parserInstances.at(-1);
+            parser?.parseDiff.mockClear();
+            const response = await fetch(`http://localhost:${result.port}/api/diff?base=main&target=feature&ignoreWhitespace=true`);
+            expect(response.ok).toBe(true);
+            expect(parser?.parseDiff).toHaveBeenCalledWith('feature', 'main', true, 2);
+        });
         it('GET /api/diff returns comment import payload when configured', async () => {
             const importedComments = [
                 {
@@ -565,6 +596,7 @@ describe('Server Integration Tests', () => {
             expect(data.commits).toEqual([
                 { hash: 'abc1234', shortHash: 'abc1234', message: 'Test commit' },
             ]);
+            expect(data.originDefaultBranch).toBe('origin/main');
             expect(data.resolvedBase).toBe('abc1234');
             expect(data.resolvedTarget).toBe('def5678');
         });

package/dist/tui/App.d.ts

@@ -4,6 +4,7 @@ interface AppProps {
     baseCommitish: string;
     mode?: string;
     repoPath?: string;
+    contextLines?: number;
 }
 declare const App: React.FC<AppProps>;
 export default App;

package/dist/tui/App.js

@@ -6,7 +6,7 @@ import DiffViewer from './components/DiffViewer.js';
 import FileList from './components/FileList.js';
 import SideBySideDiffViewer from './components/SideBySideDiffViewer.js';
 import StatusBar from './components/StatusBar.js';
-const App = ({ targetCommitish, baseCommitish, mode, repoPath }) => {
+const App = ({ targetCommitish, baseCommitish, mode, repoPath, contextLines, }) => {
     const [files, setFiles] = useState([]);
     const [selectedFileIndex, setSelectedFileIndex] = useState(0);
     const [loading, setLoading] = useState(true);
@@ -17,7 +17,7 @@ const App = ({ targetCommitish, baseCommitish, mode, repoPath }) => {
         setLoading(true);
         setError(null);
         try {
-            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish, repoPath);
+            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish, repoPath, contextLines);
             setFiles(fileDiffs);
             setLoading(false);
         }

package/dist/types/diff.d.ts

@@ -177,6 +177,7 @@ export interface RevisionsResponse {
     specialOptions: RevisionOption[];
     branches: BranchInfo[];
     commits: CommitInfo[];
+    originDefaultBranch?: string;
     resolvedBase?: string;
     resolvedTarget?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "difit",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "A lightweight command-line tool that spins up a local web server to display Git commit diffs in a GitHub-like Files changed view",
   "keywords": [
     "cli",

package/dist/client/assets/channel-cZXsTJxA.js

@@ -1 +0,0 @@
-import{V as a,W as n}from"./mermaid.core-DV5JJ1Ie.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-VBA2DB6C-B_coIPEy.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-Cn7a6CO3.js";import{_ as i}from"./mermaid.core-DV5JJ1Ie.js";import"./chunk-FMBD7UC4-CrKv7ndg.js";import"./chunk-JSJVCQXG-DyBDhAEM.js";import"./chunk-55IACEB6-CrZL3qv9.js";import"./chunk-KX2RTZJC-By5mkZmU.js";import"./index-BLNN1bfE.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/client/assets/classDiagram-v2-RAHNMMFH-B_coIPEy.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-Cn7a6CO3.js";import{_ as i}from"./mermaid.core-DV5JJ1Ie.js";import"./chunk-FMBD7UC4-CrKv7ndg.js";import"./chunk-JSJVCQXG-DyBDhAEM.js";import"./chunk-55IACEB6-CrZL3qv9.js";import"./chunk-KX2RTZJC-By5mkZmU.js";import"./index-BLNN1bfE.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/client/assets/clone-BjaT2HOk.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-tbL7nVvN.js";var e=4;function a(o){return r(o,e)}export{a as c};

package/dist/client/assets/stateDiagram-v2-FVOUBMTO-CMw3xNha.js

@@ -1 +0,0 @@
-import{s as e,b as r,a,S as s}from"./chunk-NQ4KR5QH-C30p9xRx.js";import{_ as i}from"./mermaid.core-DV5JJ1Ie.js";import"./chunk-55IACEB6-CrZL3qv9.js";import"./chunk-KX2RTZJC-By5mkZmU.js";import"./index-BLNN1bfE.js";var p={parser:a,get db(){return new s(2)},renderer:r,styles:e,init:i(t=>{t.state||(t.state={}),t.state.arrowMarkerAbsolute=t.arrowMarkerAbsolute},"init")};export{p as diagram};