difit 3.1.8 → 3.1.10

package/dist/cli/index.test.js

@@ -13,19 +13,19 @@ vi.mock('./utils.js', async () => {
         promptUser: vi.fn(),
         findUntrackedFiles: vi.fn(),
         markFilesIntentToAdd: vi.fn(),
-        resolvePrCommits: vi.fn(),
+        getPrPatch: vi.fn(),
     };
 });
 const { simpleGit } = await import('simple-git');
 const { startServer } = await import('../server/server.js');
-const { promptUser, findUntrackedFiles, markFilesIntentToAdd, resolvePrCommits } = await import('./utils.js');
+const { promptUser, findUntrackedFiles, markFilesIntentToAdd, getPrPatch } = await import('./utils.js');
 describe('CLI index.ts', () => {
     let mockGit;
     let mockStartServer;
     let mockPromptUser;
     let mockFindUntrackedFiles;
     let mockMarkFilesIntentToAdd;
-    let mockResolvePrCommits;
+    let mockGetPrPatch;
     // Store original console methods
     let originalConsoleLog;
     let originalConsoleError;
@@ -46,7 +46,7 @@ describe('CLI index.ts', () => {
         mockPromptUser = vi.mocked(promptUser);
         mockFindUntrackedFiles = vi.mocked(findUntrackedFiles);
         mockMarkFilesIntentToAdd = vi.mocked(markFilesIntentToAdd);
-        mockResolvePrCommits = vi.mocked(resolvePrCommits);
+        mockGetPrPatch = vi.mocked(getPrPatch);
         // Mock console and process.exit
         originalConsoleLog = console.log;
         originalConsoleError = console.error;
@@ -194,6 +194,11 @@ describe('CLI index.ts', () => {
                 args: ['--clean'],
                 expectedOptions: { clean: true },
             },
+            {
+                name: '--keep-alive option',
+                args: ['--keep-alive'],
+                expectedOptions: { keepAlive: true },
+            },
         ])('$name', async ({ args, expectedOptions }) => {
             mockFindUntrackedFiles.mockResolvedValue([]);
             const program = new Command();
@@ -207,6 +212,7 @@ describe('CLI index.ts', () => {
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
                 .option('--clean', 'start with a clean slate by clearing all existing comments')
+                .option('--keep-alive', 'keep server running even after browser disconnects')
                 .action(async (commitish, _compareWith, options) => {
                 let targetCommitish = commitish;
                 let baseCommitish = commitish + '^';
@@ -218,6 +224,7 @@ describe('CLI index.ts', () => {
                     openBrowser: options.open,
                     mode: options.mode,
                     clearComments: options.clean,
+                    keepAlive: options.keepAlive,
                 });
             });
             await program.parseAsync([...args], { from: 'user' });
@@ -229,6 +236,7 @@ describe('CLI index.ts', () => {
                 openBrowser: expectedOptions.open !== false,
                 mode: expectedOptions.mode || 'split',
                 clearComments: expectedOptions.clean,
+                keepAlive: expectedOptions.keepAlive,
             };
             expect(mockStartServer).toHaveBeenCalledWith(expectedCall);
         });
@@ -372,13 +380,10 @@ describe('CLI index.ts', () => {
         });
     });
     describe('GitHub PR integration', () => {
-        it('resolves PR commits correctly', async () => {
+        it('loads PR patch with gh and starts server with stdin diff', async () => {
             const prUrl = 'https://github.com/owner/repo/pull/123';
-            const prCommits = {
-                targetCommitish: 'abc123',
-                baseCommitish: 'def456',
-            };
-            mockResolvePrCommits.mockResolvedValue(prCommits);
+            const prPatch = 'diff --git a/file.ts b/file.ts\nindex 1111111..2222222 100644\n';
+            mockGetPrPatch.mockReturnValue(prPatch);
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
@@ -390,23 +395,14 @@ describe('CLI index.ts', () => {
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
-                let targetCommitish = commitish;
-                let baseCommitish;
                 if (options.pr) {
                     if (commitish !== 'HEAD' || _compareWith) {
                         console.error('Error: --pr option cannot be used with positional arguments');
                         process.exit(1);
                     }
-                    const prCommits = await resolvePrCommits(options.pr);
-                    targetCommitish = prCommits.targetCommitish;
-                    baseCommitish = prCommits.baseCommitish;
-                }
-                else {
-                    baseCommitish = commitish + '^';
                 }
                 await startServer({
-                    targetCommitish,
-                    baseCommitish,
+                    stdinDiff: getPrPatch(options.pr),
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -414,10 +410,9 @@ describe('CLI index.ts', () => {
                 });
             });
             await program.parseAsync(['--pr', prUrl], { from: 'user' });
-            expect(mockResolvePrCommits).toHaveBeenCalledWith(prUrl);
+            expect(mockGetPrPatch).toHaveBeenCalledWith(prUrl);
             expect(mockStartServer).toHaveBeenCalledWith({
-                targetCommitish: 'abc123',
-                baseCommitish: 'def456',
+                stdinDiff: prPatch,
                 preferredPort: undefined,
                 host: '',
                 openBrowser: true,
@@ -449,13 +444,8 @@ describe('CLI index.ts', () => {
             expect(console.error).toHaveBeenCalledWith('Error: --pr option cannot be used with positional arguments');
             expect(process.exit).toHaveBeenCalledWith(1);
         });
-        it('resolves GitHub Enterprise PR commits correctly', async () => {
-            const prUrl = 'https://github.enterprise.com/owner/repo/pull/456';
-            const prCommits = {
-                targetCommitish: 'xyz789',
-                baseCommitish: 'uvw012',
-            };
-            mockResolvePrCommits.mockResolvedValue(prCommits);
+        it('rejects PR option with --tui', async () => {
+            const prUrl = 'https://github.com/owner/repo/pull/123';
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
@@ -467,39 +457,21 @@ describe('CLI index.ts', () => {
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
-                let targetCommitish = commitish;
-                let baseCommitish;
                 if (options.pr) {
                     if (commitish !== 'HEAD' || _compareWith) {
                         console.error('Error: --pr option cannot be used with positional arguments');
                         process.exit(1);
                     }
-                    const prCommits = await resolvePrCommits(options.pr);
-                    targetCommitish = prCommits.targetCommitish;
-                    baseCommitish = prCommits.baseCommitish;
-                }
-                else {
-                    baseCommitish = commitish + '^';
+                    if (options.tui) {
+                        console.error('Error: --pr option cannot be used with --tui');
+                        process.exit(1);
+                    }
                 }
-                await startServer({
-                    targetCommitish,
-                    baseCommitish,
-                    preferredPort: options.port,
-                    host: options.host,
-                    openBrowser: options.open,
-                    mode: options.mode,
-                });
-            });
-            await program.parseAsync(['--pr', prUrl], { from: 'user' });
-            expect(mockResolvePrCommits).toHaveBeenCalledWith(prUrl);
-            expect(mockStartServer).toHaveBeenCalledWith({
-                targetCommitish: 'xyz789',
-                baseCommitish: 'uvw012',
-                preferredPort: undefined,
-                host: '',
-                openBrowser: true,
-                mode: 'split',
             });
+            await program.parseAsync(['--pr', prUrl, '--tui'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --pr option cannot be used with --tui');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
         });
     });
     describe('Clean flag functionality', () => {
@@ -584,6 +556,92 @@ describe('CLI index.ts', () => {
             expect(console.log).not.toHaveBeenCalledWith('🧹 Starting with a clean slate - all existing comments will be cleared');
         });
     });
+    describe('Keep-alive flag functionality', () => {
+        it('displays keep-alive message when flag is used', async () => {
+            mockFindUntrackedFiles.mockResolvedValue([]);
+            mockStartServer.mockResolvedValue({
+                port: 4966,
+                url: 'http://localhost:4966',
+                isEmpty: false,
+            });
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--port <port>', 'port', parseInt)
+                .option('--host <host>', 'host', '')
+                .option('--no-open', 'no-open')
+                .option('--mode <mode>', 'mode', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
+                .option('--tui', 'tui')
+                .option('--pr <url>', 'pr')
+                .option('--clean', 'start with a clean slate by clearing all existing comments')
+                .option('--keep-alive', 'keep server running even after browser disconnects')
+                .action(async (commitish, _compareWith, options) => {
+                const { url } = await startServer({
+                    targetCommitish: commitish,
+                    baseCommitish: commitish + '^',
+                    preferredPort: options.port,
+                    host: options.host,
+                    openBrowser: options.open,
+                    mode: options.mode,
+                    clearComments: options.clean,
+                    keepAlive: options.keepAlive,
+                });
+                console.log(`\n🚀 difit server started on ${url}`);
+                console.log(`📋 Reviewing: ${commitish}`);
+                if (options.keepAlive) {
+                    console.log('🔒 Keep-alive mode: server will stay running after browser disconnects');
+                }
+            });
+            await program.parseAsync(['--keep-alive'], { from: 'user' });
+            expect(mockStartServer).toHaveBeenCalledWith(expect.objectContaining({
+                keepAlive: true,
+            }));
+            expect(console.log).toHaveBeenCalledWith('🔒 Keep-alive mode: server will stay running after browser disconnects');
+        });
+        it('does not display keep-alive message when flag is not used', async () => {
+            mockFindUntrackedFiles.mockResolvedValue([]);
+            mockStartServer.mockResolvedValue({
+                port: 4966,
+                url: 'http://localhost:4966',
+                isEmpty: false,
+            });
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--port <port>', 'port', parseInt)
+                .option('--host <host>', 'host', '')
+                .option('--no-open', 'no-open')
+                .option('--mode <mode>', 'mode', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
+                .option('--tui', 'tui')
+                .option('--pr <url>', 'pr')
+                .option('--clean', 'start with a clean slate by clearing all existing comments')
+                .option('--keep-alive', 'keep server running even after browser disconnects')
+                .action(async (commitish, _compareWith, options) => {
+                const { url } = await startServer({
+                    targetCommitish: commitish,
+                    baseCommitish: commitish + '^',
+                    preferredPort: options.port,
+                    host: options.host,
+                    openBrowser: options.open,
+                    mode: options.mode,
+                    clearComments: options.clean,
+                    keepAlive: options.keepAlive,
+                });
+                console.log(`\n🚀 difit server started on ${url}`);
+                console.log(`📋 Reviewing: ${commitish}`);
+                if (options.keepAlive) {
+                    console.log('🔒 Keep-alive mode: server will stay running after browser disconnects');
+                }
+            });
+            await program.parseAsync([], { from: 'user' });
+            expect(mockStartServer).toHaveBeenCalledWith(expect.objectContaining({
+                keepAlive: undefined,
+            }));
+            expect(console.log).not.toHaveBeenCalledWith('🔒 Keep-alive mode: server will stay running after browser disconnects');
+        });
+    });
     describe('Console output', () => {
         it('displays server startup message with correct URL', async () => {
             mockFindUntrackedFiles.mockResolvedValue([]);

package/dist/cli/utils.d.ts

@@ -1,4 +1,16 @@
+import { type Stats } from 'node:fs';
 import type { SimpleGit } from 'simple-git';
+type StdinStat = Pick<Stats, 'isFIFO' | 'isFile' | 'isSocket'>;
+export type StdinSource = 'pipe' | 'file' | 'socket' | 'tty';
+export declare function detectStdinSource(stdinStat?: StdinStat): StdinSource;
+export interface ShouldReadStdinOptions {
+    commitish: string;
+    hasPositionalArgs: boolean;
+    hasPrOption: boolean;
+    hasTuiOption: boolean;
+    stdinSource?: StdinSource;
+}
+export declare function shouldReadStdin(options: ShouldReadStdinOptions): boolean;
 export declare function getGitRoot(): string;
 export declare function validateCommitish(commitish: string): boolean;
 export declare function shortHash(hash: string): string;
@@ -10,10 +22,7 @@ export interface PullRequestInfo {
     hostname: string;
 }
 export declare function parseGitHubPrUrl(url: string): PullRequestInfo | null;
-export declare function resolvePrCommits(prUrl: string): Promise<{
-    targetCommitish: string;
-    baseCommitish: string;
-}>;
+export declare function getPrPatch(prArg: string): string;
 export declare function validateDiffArguments(targetCommitish: string, baseCommitish?: string): {
     valid: boolean;
     error?: string;
@@ -21,3 +30,4 @@ export declare function validateDiffArguments(targetCommitish: string, baseCommi
 export declare function findUntrackedFiles(git: SimpleGit): Promise<string[]>;
 export declare function markFilesIntentToAdd(git: SimpleGit, files: string[]): Promise<void>;
 export declare function promptUser(message: string): Promise<boolean>;
+export {};

package/dist/cli/utils.js

@@ -1,6 +1,28 @@
-import { execSync } from 'child_process';
+import { execFileSync, execSync } from 'child_process';
+import { fstatSync } from 'node:fs';
 import { createInterface } from 'readline/promises';
-import { Octokit } from '@octokit/rest';
+export function detectStdinSource(stdinStat = fstatSync(0)) {
+    if (stdinStat.isFIFO()) {
+        return 'pipe';
+    }
+    if (stdinStat.isFile()) {
+        return 'file';
+    }
+    if (stdinStat.isSocket()) {
+        return 'socket';
+    }
+    return 'tty';
+}
+export function shouldReadStdin(options) {
+    if (options.commitish === '-') {
+        return true;
+    }
+    if (options.hasPositionalArgs || options.hasPrOption || options.hasTuiOption) {
+        return false;
+    }
+    const stdinSource = options.stdinSource ?? detectStdinSource();
+    return stdinSource === 'pipe' || stdinSource === 'file' || stdinSource === 'socket';
+}
 export function getGitRoot() {
     try {
         const result = execSync('git rev-parse --show-toplevel', { encoding: 'utf8', stdio: 'pipe' });
@@ -99,107 +121,27 @@ export function parseGitHubPrUrl(url) {
         return null;
     }
 }
-function getGitHubToken() {
-    // Try to get token from environment variable first
-    if (process.env.GITHUB_TOKEN) {
-        return process.env.GITHUB_TOKEN;
-    }
-    // Try to get token from GitHub CLI
-    try {
-        const result = execSync('gh auth token', { encoding: 'utf8', stdio: 'pipe' });
-        return result.trim();
-    }
-    catch {
-        // GitHub CLI not available or not authenticated
-        return undefined;
-    }
-}
-async function fetchPrDetails(prInfo) {
-    const token = getGitHubToken();
-    const octokitOptions = {
-        auth: token,
-    };
-    // For GitHub Enterprise, set the base URL
-    if (prInfo.hostname !== 'github.com') {
-        octokitOptions.baseUrl = `https://${prInfo.hostname}/api/v3`;
-    }
-    const octokit = new Octokit(octokitOptions);
+export function getPrPatch(prArg) {
     try {
-        const { data: pr } = await octokit.rest.pulls.get({
-            owner: prInfo.owner,
-            repo: prInfo.repo,
-            pull_number: prInfo.pullNumber,
+        const patch = execFileSync('gh', ['pr', 'diff', prArg, '--patch'], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe'],
         });
-        return {
-            baseSha: pr.base.sha,
-            headSha: pr.head.sha,
-            baseRef: pr.base.ref,
-            headRef: pr.head.ref,
-        };
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            let authHint = '';
-            // Provide more specific error messages for authentication issues
-            if (error.message.includes('Bad credentials')) {
-                if (prInfo.hostname !== 'github.com') {
-                    authHint = `\n\nFor GitHub Enterprise Server (${prInfo.hostname}):
-1. Generate a token on YOUR Enterprise Server: https://${prInfo.hostname}/settings/tokens
-2. Set it as GITHUB_TOKEN environment variable
-3. Tokens from github.com will NOT work on Enterprise servers`;
-                }
-                else {
-                    authHint = '\n\nTry: gh auth login or set GITHUB_TOKEN environment variable';
-                }
-            }
-            else if (!token) {
-                authHint = ' (Try: gh auth login or set GITHUB_TOKEN environment variable)';
-            }
-            throw new Error(`Failed to fetch PR details: ${error.message}${authHint}`);
+        if (!patch.trim()) {
+            throw new Error('No patch content returned from gh pr diff --patch');
         }
-        throw new Error('Failed to fetch PR details: Unknown error');
+        return patch;
     }
-}
-function resolveCommitInLocalRepo(sha, context) {
-    try {
-        // Verify if the commit exists locally
-        execSync(`git cat-file -e ${sha}`, { stdio: 'ignore' });
-        return sha;
-    }
-    catch {
-        // If commit doesn't exist, try to fetch from remote
-        try {
-            execSync('git fetch origin', { stdio: 'ignore' });
-            execSync(`git cat-file -e ${sha}`, { stdio: 'ignore' });
-            return sha;
-        }
-        catch {
-            const errorMessage = [
-                `Commit ${sha} not found in local repository.`,
-                '',
-                'Common causes:',
-                '  • Are you running this command in the correct repository directory?',
-                context ? `    • Expected repository: ${context.owner}/${context.repo}` : '',
-                '  • Is this PR from a fork?',
-                '    • Try: git remote add upstream <original-repo-url> && git fetch upstream',
-                '    • Try: git fetch --all to fetch from all remotes',
-            ]
-                .filter(Boolean)
-                .join('\n');
-            throw new Error(errorMessage);
-        }
-    }
-}
-export async function resolvePrCommits(prUrl) {
-    const prInfo = parseGitHubPrUrl(prUrl);
-    if (!prInfo) {
-        throw new Error('Invalid GitHub PR URL format. Expected: https://github.com/owner/repo/pull/123 or https://github.enterprise.com/owner/repo/pull/123');
+    catch (error) {
+        const stderr = error.stderr;
+        const stderrText = typeof stderr === 'string'
+            ? stderr.trim()
+            : Buffer.isBuffer(stderr)
+                ? stderr.toString('utf8').trim()
+                : '';
+        const message = stderrText || (error instanceof Error ? error.message : 'Unknown error while running gh');
+        throw new Error(`${message}\nTry: gh auth login`);
     }
-    const prDetails = await fetchPrDetails(prInfo);
-    const context = { owner: prInfo.owner, repo: prInfo.repo };
-    const targetCommitish = resolveCommitInLocalRepo(prDetails.headSha, context);
-    const baseCommitish = resolveCommitInLocalRepo(prDetails.baseSha, context);
-    return { targetCommitish, baseCommitish };
 }
 export function validateDiffArguments(targetCommitish, baseCommitish) {
     // Validate target commitish format

package/dist/cli/utils.test.js

@@ -1,6 +1,104 @@
 import { describe, it, expect } from 'vitest';
-import { validateCommitish, validateDiffArguments, shortHash, parseGitHubPrUrl } from './utils';
+import { detectStdinSource, parseGitHubPrUrl, shortHash, shouldReadStdin, validateCommitish, validateDiffArguments, } from './utils';
 describe('CLI Utils', () => {
+    describe('stdin detection', () => {
+        it('detects pipe from stdin stat', () => {
+            expect(detectStdinSource({
+                isFIFO: () => true,
+                isFile: () => false,
+                isSocket: () => false,
+            })).toBe('pipe');
+        });
+        it('detects file from stdin stat', () => {
+            expect(detectStdinSource({
+                isFIFO: () => false,
+                isFile: () => true,
+                isSocket: () => false,
+            })).toBe('file');
+        });
+        it('detects socket from stdin stat', () => {
+            expect(detectStdinSource({
+                isFIFO: () => false,
+                isFile: () => false,
+                isSocket: () => true,
+            })).toBe('socket');
+        });
+        it('detects tty for character device stdin stat', () => {
+            expect(detectStdinSource({
+                isFIFO: () => false,
+                isFile: () => false,
+                isSocket: () => false,
+            })).toBe('tty');
+        });
+        it('reads stdin when commitish is explicit stdin marker', () => {
+            expect(shouldReadStdin({
+                commitish: '-',
+                hasPositionalArgs: true,
+                hasPrOption: true,
+                hasTuiOption: true,
+                stdinSource: 'tty',
+            })).toBe(true);
+        });
+        it('does not read stdin when positional args are explicitly passed', () => {
+            expect(shouldReadStdin({
+                commitish: '.',
+                hasPositionalArgs: true,
+                hasPrOption: false,
+                hasTuiOption: false,
+                stdinSource: 'pipe',
+            })).toBe(false);
+        });
+        it('does not read stdin when --pr is specified', () => {
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: true,
+                hasTuiOption: false,
+                stdinSource: 'pipe',
+            })).toBe(false);
+        });
+        it('does not read stdin when --tui is specified', () => {
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: false,
+                hasTuiOption: true,
+                stdinSource: 'pipe',
+            })).toBe(false);
+        });
+        it('auto-detects stdin for pipe/file/socket only when no explicit git mode is selected', () => {
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: false,
+                hasTuiOption: false,
+                stdinSource: 'pipe',
+            })).toBe(true);
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: false,
+                hasTuiOption: false,
+                stdinSource: 'file',
+            })).toBe(true);
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: false,
+                hasTuiOption: false,
+                stdinSource: 'socket',
+            })).toBe(true);
+        });
+        it('does not auto-read stdin for tty source', () => {
+            expect(shouldReadStdin({
+                commitish: 'HEAD',
+                hasPositionalArgs: false,
+                hasPrOption: false,
+                hasTuiOption: false,
+                stdinSource: 'tty',
+            })).toBe(false);
+        });
+    });
     describe('validateCommitish', () => {
         it('should validate full SHA hashes', () => {
             expect(validateCommitish('a1b2c3d4e5f6789012345678901234567890abcd')).toBe(true);