difit 3.1.18 → 4.0.1

package/dist/server/generated-file-check.js

@@ -1,57 +1,114 @@
+const EXACT_FILENAMES = new Set([
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'Gemfile.lock',
+    'Pipfile.lock',
+    'composer.lock',
+    'Cargo.lock',
+    'poetry.lock',
+    'go.sum',
+    'go.mod',
+    'pubspec.lock',
+    'flake.lock',
+    'Package.resolved',
+    'packages.lock.json',
+    '.terraform.lock.hcl',
+    'bun.lockb',
+    'gradle.lockfile',
+    'uv.lock',
+    'pdm.lock',
+]);
+const FILENAME_SUFFIXES = [
+    '.min.js',
+    '.min.css',
+    '.bundle.js',
+    '.bundle.css',
+    '-min.js',
+    '.map',
+    '.pb.go',
+    '.pb.rb',
+    '.pb.py',
+    '.pb.js',
+    '.pb.cc',
+    '.pb.h',
+    '.pb2.py',
+    '_pb2.py',
+    '.grpc.pb.go',
+    '_string.go',
+    '.graphql.ts',
+    '.graphql.js',
+    '.openapi.ts',
+    '.openapi.js',
+    '.msw.ts',
+    '.zod.ts',
+    '.api.ts',
+    '.g.dart',
+    '.freezed.dart',
+    '.g.cs',
+    '.designer.cs',
+    '_ide_helper.php',
+];
+const ROOT_PATH_PREFIXES = ['vendor/', 'node_modules/', 'dist/', 'build/', 'out/'];
+const PATH_SEGMENTS = ['/generated/', '/gen/', '/__generated__/'];
+function matchesAnySuffix(fileName, suffixes) {
+    return suffixes.some((suffix) => fileName.endsWith(suffix));
+}
+function isWordCharacter(char) {
+    const code = char.charCodeAt(0);
+    return ((code >= 48 && code <= 57) ||
+        (code >= 65 && code <= 90) ||
+        (code >= 97 && code <= 122) ||
+        code === 95);
+}
+function isWordString(text) {
+    if (text.length === 0) {
+        return false;
+    }
+    for (const char of text) {
+        if (!isWordCharacter(char)) {
+            return false;
+        }
+    }
+    return true;
+}
+function hasGeneratedSuffix(fileName, marker) {
+    const markerIndex = fileName.lastIndexOf(marker);
+    if (markerIndex === -1) {
+        return false;
+    }
+    return isWordString(fileName.slice(markerIndex + marker.length));
+}
 // Layer 1: Path/Filename Patterns
-const PATH_PATTERNS = [
-    // Lock files (all languages)
-    /package-lock\.json$/,
-    /pnpm-lock\.yaml$/,
-    /yarn\.lock$/,
-    /Gemfile\.lock$/,
-    /Pipfile\.lock$/,
-    /composer\.lock$/,
-    /Cargo\.lock$/,
-    /poetry\.lock$/,
-    /go\.sum$/,
-    /go\.mod$/,
-    /pubspec\.lock$/,
-    /flake\.lock$/,
-    /Package\.resolved$/,
-    /packages\.lock\.json$/,
-    /\.terraform\.lock\.hcl$/,
-    /bun\.lockb$/,
-    /gradle\.lockfile$/,
-    /uv\.lock$/,
-    /pdm\.lock$/,
-    // Minified / Bundled
-    /\.min\.(js|css)$/,
-    /\.bundle\.(js|css)$/,
-    /-min\.js$/,
-    /\.map$/,
-    // Generated naming conventions
-    /\.generated\.\w+$/,
-    /\.gen\.\w+$/,
-    /\.pb\.(go|rb|py|js|cc|h)$/, // protobuf
-    /\.pb2\.py$/, // protobuf python
-    /_pb2\.py$/,
-    /\.grpc\.pb\.go$/,
-    /_string\.go$/, // go generate stringer
-    /\.graphql\.(ts|js)$/, // GraphQL codegen
-    /\.openapi\.(ts|js)$/,
-    /mock_.*\.go$/, // mockgen
-    /mocks\/.*\.go$/,
-    /\.msw\.ts$/,
-    /\.zod\.ts$/,
-    /\.api\.ts$/,
-    /\.g\.dart$/,
-    /\.freezed\.dart$/,
-    /\.g\.cs$/,
-    /\.designer\.cs$/,
-    /_ide_helper\.php$/,
-    // Directories
-    /^vendor\//,
-    /^node_modules\//,
-    /^(dist|build|out)\//,
-    /\/generated\//,
-    /\/gen\//,
-    /\/__generated__\//, // Relay
+const PATH_MATCHERS = [
+    {
+        description: 'exact-filename',
+        matches: (_parsedPath, fileName) => EXACT_FILENAMES.has(fileName),
+    },
+    {
+        description: 'minified-or-generated-suffix',
+        matches: (_parsedPath, fileName) => matchesAnySuffix(fileName, FILENAME_SUFFIXES),
+    },
+    {
+        description: 'generated-extension',
+        matches: (_parsedPath, fileName) => hasGeneratedSuffix(fileName, '.generated.') || hasGeneratedSuffix(fileName, '.gen.'),
+    },
+    {
+        description: 'mockgen-go',
+        matches: (_parsedPath, fileName) => fileName.startsWith('mock_') && fileName.endsWith('.go'),
+    },
+    {
+        description: 'mocks-go-directory',
+        matches: (parsedPath, fileName) => parsedPath.includes('mocks/') && fileName.endsWith('.go'),
+    },
+    {
+        description: 'root-generated-directory',
+        matches: (parsedPath) => ROOT_PATH_PREFIXES.some((prefix) => parsedPath.startsWith(prefix)),
+    },
+    {
+        description: 'generated-path-segment',
+        matches: (parsedPath) => PATH_SEGMENTS.some((segment) => parsedPath.includes(segment)),
+    },
 ];
 // Layer 2: Universal Header Patterns
 const UNIVERSAL_PATTERNS = [
@@ -172,14 +229,12 @@ export function isGeneratedFile(parsedPath, getHeaderLines) {
     // We check if the filename matches any known generated patterns
     // or if the path is in a known generated directory
     const fileName = parsedPath.split('/').pop() || '';
-    for (const pattern of PATH_PATTERNS) {
-        // Some patterns match the whole path (directories), others just the filename
-        const textToCheck = pattern.source.includes('/') ? parsedPath : fileName;
-        if (pattern.test(textToCheck)) {
+    for (const matcher of PATH_MATCHERS) {
+        if (matcher.matches(parsedPath, fileName)) {
             return {
                 isGenerated: true,
                 reason: 'path',
-                matchedPattern: pattern.source,
+                matchedPattern: matcher.description,
             };
         }
     }

package/dist/server/generated-file-check.test.js

@@ -20,6 +20,8 @@ describe('isGeneratedFile', () => {
             expect(isGeneratedFile('api.gen.go').isGenerated).toBe(true);
             expect(isGeneratedFile('service.pb.go').isGenerated).toBe(true);
             expect(isGeneratedFile('schema.graphql.ts').isGenerated).toBe(true);
+            expect(isGeneratedFile('mock_service.go').isGenerated).toBe(true);
+            expect(isGeneratedFile('src/mocks/service.go').isGenerated).toBe(true);
         });
         it('detects generated directories', () => {
             expect(isGeneratedFile('node_modules/package/index.js').isGenerated).toBe(true);

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

@@ -1,2 +1,2 @@
 import type { FileDiff } from '../types/diff.js';
-export declare function loadGitDiff(targetCommitish: string, baseCommitish: string, repoPath?: string): Promise<FileDiff[]>;
+export declare function loadGitDiff(targetCommitish: string, baseCommitish: string, repoPath?: string, contextLines?: number): Promise<FileDiff[]>;

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

@@ -6,7 +6,8 @@ export declare class GitDiffParser {
     private static readonly RESOLVED_COMMIT_CACHE_TTL_MS;
     private static readonly GENERATED_HEADER_SCAN_BYTES;
     constructor(repoPath?: string);
-    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean): Promise<DiffResponse>;
+    private normalizeRepositoryRelativePath;
+    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean, contextLines?: number): Promise<DiffResponse>;
     private parseUnifiedDiff;
     private decodeGitPath;
     private extractPathFromLine;
@@ -26,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;
@@ -36,6 +38,7 @@ export declare class GitDiffParser {
             shortHash: string;
             message: string;
         }>;
+        originDefaultBranch?: string;
         resolvedBase?: string;
         resolvedTarget?: string;
     }>;

package/dist/server/git-diff.js

@@ -1,4 +1,5 @@
 import { simpleGit } from 'simple-git';
+import { isAbsolute, resolve, sep } from 'path';
 import { validateDiffArguments, shortHash, createCommitRangeString } from '../cli/utils.js';
 import { isGeneratedFile } from './generated-file-check.js';
 export class GitDiffParser {
@@ -11,7 +12,23 @@ export class GitDiffParser {
         this.repoPath = repoPath;
         this.git = simpleGit(repoPath);
     }
-    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false) {
+    normalizeRepositoryRelativePath(filepath) {
+        if (filepath.length === 0) {
+            throw new Error('Invalid file path');
+        }
+        const normalizedFilepath = filepath.replace(/\\/g, '/');
+        const hasParentTraversal = normalizedFilepath.split('/').some((segment) => segment === '..');
+        if (isAbsolute(filepath) || normalizedFilepath.startsWith('/') || hasParentTraversal) {
+            throw new Error('File path outside repository');
+        }
+        const repositoryPath = resolve(this.repoPath);
+        const resolvedPath = resolve(repositoryPath, normalizedFilepath);
+        if (resolvedPath !== repositoryPath && !resolvedPath.startsWith(`${repositoryPath}${sep}`)) {
+            throw new Error('File path outside repository');
+        }
+        return normalizedFilepath;
+    }
+    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false, contextLines) {
         try {
             // Validate arguments
             const validation = validateDiffArguments(targetCommitish, baseCommitish);
@@ -48,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');
@@ -339,12 +359,18 @@ export class GitDiffParser {
             // For working directory, read directly from filesystem
             if (ref === 'working' || ref === '.') {
                 const fs = await import('fs');
-                const path = await import('path');
-                const absolutePath = path.isAbsolute(filepath)
-                    ? filepath
-                    : path.resolve(this.repoPath, filepath);
+                if (filepath.length === 0) {
+                    throw new Error('Invalid file path');
+                }
+                const repositoryPath = fs.realpathSync(resolve(this.repoPath));
+                const repositoryRoot = `${repositoryPath}${sep}`;
+                const absolutePath = fs.realpathSync(resolve(repositoryRoot, filepath.replace(/\\/g, '/')));
+                if (!absolutePath.startsWith(repositoryRoot)) {
+                    throw new Error('File path outside repository');
+                }
                 return fs.readFileSync(absolutePath);
             }
+            const normalizedFilepath = this.normalizeRepositoryRelativePath(filepath);
             // For git refs, we need to use child_process to execute git cat-file
             // to properly handle binary data
             const { execFileSync } = await import('child_process');
@@ -352,14 +378,14 @@ export class GitDiffParser {
             if (ref === 'staged') {
                 // For staged files, use git show :filepath
                 // Using execFileSync to prevent command injection
-                const buffer = execFileSync('git', ['show', `:${filepath}`], {
+                const buffer = execFileSync('git', ['show', `:${normalizedFilepath}`], {
                     maxBuffer: 10 * 1024 * 1024, // 10MB limit
                 });
                 return buffer;
             }
             // First, get the blob hash for the file at the given ref
             // Using execFileSync to prevent command injection
-            const blobHash = execFileSync('git', ['rev-parse', `${ref}:${filepath}`], {
+            const blobHash = execFileSync('git', ['rev-parse', `${ref}:${normalizedFilepath}`], {
                 encoding: 'utf8',
                 maxBuffer: 10 * 1024 * 1024,
             }).trim();
@@ -376,6 +402,10 @@ export class GitDiffParser {
                 (error.message.includes('ENOBUFS') || error.message.includes('maxBuffer'))) {
                 throw new Error(`Image file ${filepath} is too large to display (over 10MB limit)`);
             }
+            if (error instanceof Error &&
+                (error.message === 'Invalid file path' || error.message === 'File path outside repository')) {
+                throw error;
+            }
             throw new Error(`Failed to get blob content for ${filepath} at ${ref}: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
@@ -451,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,
@@ -499,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

@@ -23,12 +23,14 @@ vi.mock('fs', async (importOriginal) => {
     return {
         ...actual,
         readFileSync: vi.fn(),
+        realpathSync: vi.fn((path) => path),
     };
 });
 describe('GitDiffParser', () => {
     let parser;
     let mockExecFileSync;
     let mockReadFileSync;
+    let mockRealpathSync;
     beforeEach(async () => {
         parser = new GitDiffParser('/test/repo');
         vi.clearAllMocks();
@@ -37,6 +39,8 @@ describe('GitDiffParser', () => {
         const fs = await import('fs');
         mockExecFileSync = childProcess.execFileSync;
         mockReadFileSync = fs.readFileSync;
+        mockRealpathSync = fs.realpathSync;
+        mockRealpathSync.mockImplementation((path) => path);
     });
     afterEach(() => {
         vi.restoreAllMocks();
@@ -102,6 +106,28 @@ describe('GitDiffParser', () => {
             });
             await expect(parser.getBlobContent('missing.txt', 'HEAD')).rejects.toThrow('Failed to get blob content for missing.txt at HEAD: fatal: Path does not exist');
         });
+        it('rejects working tree paths outside the repository', async () => {
+            await expect(parser.getBlobContent('../outside.txt', 'working')).rejects.toThrow('File path outside repository');
+            expect(mockReadFileSync).not.toHaveBeenCalled();
+        });
+        it('rejects absolute working tree paths', async () => {
+            await expect(parser.getBlobContent('/etc/passwd', 'working')).rejects.toThrow('File path outside repository');
+            expect(mockReadFileSync).not.toHaveBeenCalled();
+        });
+        it('rejects working tree symlinks that resolve outside the repository', async () => {
+            mockRealpathSync.mockImplementation((path) => {
+                if (path === '/test/repo/link.txt') {
+                    return '/etc/passwd';
+                }
+                return path;
+            });
+            await expect(parser.getBlobContent('link.txt', 'working')).rejects.toThrow('File path outside repository');
+            expect(mockReadFileSync).not.toHaveBeenCalled();
+        });
+        it('rejects git ref paths outside the repository before invoking git', async () => {
+            await expect(parser.getBlobContent('../outside.txt', 'HEAD')).rejects.toThrow('File path outside repository');
+            expect(mockExecFileSync).not.toHaveBeenCalled();
+        });
     });
     describe('parseFileBlock with binary files', () => {
         it('parses added binary file correctly', () => {
@@ -1045,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

@@ -1,5 +1,6 @@
 import { type Server } from 'http';
 import { type DiffMode } from '../types/watch.js';
+import { type CommentImport } from '@/types/diff.js';
 interface ServerOptions {
     targetCommitish?: string;
     baseCommitish?: string;
@@ -10,9 +11,11 @@ interface ServerOptions {
     mode?: string;
     ignoreWhitespace?: boolean;
     clearComments?: boolean;
+    commentImports?: CommentImport[];
     keepAlive?: boolean;
     diffMode?: DiffMode;
     repoPath?: string;
+    contextLines?: number;
 }
 export declare function startServer(options: ServerOptions): Promise<{
     port: number;