difit 3.1.18 → 4.0.1

package/dist/cli/index.js

@@ -6,7 +6,8 @@ import pkg from '../../package.json' with { type: 'json' };
 import { startServer } from '../server/server.js';
 import { DiffMode } from '../types/watch.js';
 import { DEFAULT_DIFF_VIEW_MODE, normalizeDiffViewMode } from '../utils/diffMode.js';
-import { shouldReadStdin, findUntrackedFiles, markFilesIntentToAdd, promptUser, validateDiffArguments, getPrPatch, getGitRoot, } from './utils.js';
+import { shouldReadStdin, findUntrackedFiles, markFilesIntentToAdd, promptUser, parseCommentOptions, validateDiffArguments, getGitRoot, } from './utils.js';
+import { getPrPatch, getPrCommentImports } from './github.js';
 function isSpecialArg(arg) {
     return arg === 'working' || arg === 'staged' || arg === '.';
 }
@@ -39,15 +40,32 @@ program
     .option('--host <host>', 'host address to bind', '')
     .option('--no-open', 'do not automatically open browser')
     .option('--mode <mode>', 'diff mode (split or unified)', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
+    .option('--comment <json>', 'inject initial review comments (repeatable, accepts a JSON object or array)', (value, previous = []) => [...previous, value], [])
     .option('--tui', 'use terminal UI instead of web interface')
     .option('--pr <url>', 'GitHub PR URL to review (e.g., https://github.com/owner/repo/pull/123)')
     .option('--clean', 'start with a clean slate by clearing all existing comments')
     .option('--include-untracked', 'automatically include untracked files in diff')
     .option('--keep-alive', 'keep server running even after browser disconnects')
+    .option('--context <lines>', 'number of context lines shown around each change', parseInt)
     .action(async (commitish, compareWith, options) => {
     try {
         let stdinDiff;
         let stdinReviewLabel = 'diff from stdin';
+        let manualCommentImports = [];
+        let commentImports = [];
+        if (options.context !== undefined &&
+            (!Number.isInteger(options.context) || options.context < 0)) {
+            console.error('Error: --context must be a non-negative integer');
+            process.exit(1);
+        }
+        try {
+            manualCommentImports = parseCommentOptions(options.comment);
+            commentImports = manualCommentImports;
+        }
+        catch (error) {
+            console.error(`Error: ${error instanceof Error ? error.message : 'Invalid --comment value'}`);
+            process.exit(1);
+        }
         if (options.pr) {
             if (commitish !== 'HEAD' || compareWith) {
                 console.error('Error: --pr option cannot be used with positional arguments');
@@ -57,6 +75,10 @@ program
                 console.error('Error: --pr option cannot be used with --tui');
                 process.exit(1);
             }
+            if (options.context !== undefined) {
+                console.error('Error: --context option cannot be used with --pr');
+                process.exit(1);
+            }
             try {
                 stdinDiff = getPrPatch(options.pr);
                 stdinReviewLabel = options.pr;
@@ -65,6 +87,13 @@ program
                 console.error(`Error resolving PR: ${error instanceof Error ? error.message : 'Unknown error'}`);
                 process.exit(1);
             }
+            try {
+                const prCommentImports = await getPrCommentImports(options.pr);
+                commentImports = [...prCommentImports, ...manualCommentImports];
+            }
+            catch (error) {
+                console.warn(`Warning: Failed to load PR review comments: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
         }
         else {
             // Check if we should read from stdin
@@ -75,6 +104,10 @@ program
                 hasTuiOption: Boolean(options.tui),
             });
             if (readFromStdin) {
+                if (options.context !== undefined) {
+                    console.error('Error: --context option cannot be used with stdin diff');
+                    process.exit(1);
+                }
                 // Read unified diff from stdin
                 stdinDiff = await readStdin();
                 if (!stdinDiff.trim()) {
@@ -93,6 +126,7 @@ program
                 mode: options.mode,
                 clearComments: options.clean,
                 keepAlive: options.keepAlive,
+                ...(commentImports.length > 0 ? { commentImports } : {}),
             });
             console.log(`\n🚀 difit server started on ${url}`);
             console.log(`📋 Reviewing: ${stdinReviewLabel}`);
@@ -136,6 +170,10 @@ program
             await handleUntrackedFiles(git, options.includeUntracked);
         }
         if (options.tui) {
+            if (commentImports.length > 0) {
+                console.error('Error: --comment option cannot be used with --tui');
+                process.exit(1);
+            }
             // Check if we're in a TTY environment
             if (!process.stdin.isTTY) {
                 console.error('Error: TUI mode requires an interactive terminal (TTY).');
@@ -150,6 +188,7 @@ program
                 baseCommitish,
                 mode: options.mode,
                 repoPath,
+                contextLines: options.context,
             }));
             return;
         }
@@ -167,8 +206,10 @@ program
             mode: options.mode,
             clearComments: options.clean,
             keepAlive: options.keepAlive,
+            contextLines: options.context,
             diffMode: determineDiffMode(targetCommitish, compareWith),
             repoPath,
+            ...(commentImports.length > 0 ? { commentImports } : {}),
         });
         console.log(`\n🚀 difit server started on ${url}`);
         console.log(`📋 Reviewing: ${targetCommitish}`);

package/dist/cli/index.test.js

@@ -14,12 +14,16 @@ vi.mock('./utils.js', async () => {
         promptUser: vi.fn(),
         findUntrackedFiles: vi.fn(),
         markFilesIntentToAdd: vi.fn(),
-        getPrPatch: vi.fn(),
     };
 });
+vi.mock('./github.js', () => ({
+    getPrPatch: vi.fn(),
+    getPrCommentImports: vi.fn(),
+}));
 const { simpleGit } = await import('simple-git');
 const { startServer } = await import('../server/server.js');
-const { promptUser, findUntrackedFiles, markFilesIntentToAdd, getPrPatch } = await import('./utils.js');
+const { promptUser, findUntrackedFiles, markFilesIntentToAdd, parseCommentOptions, shouldReadStdin, } = await import('./utils.js');
+const { getPrPatch, getPrCommentImports } = await import('./github.js');
 describe('CLI index.ts', () => {
     let mockGit;
     let mockStartServer;
@@ -27,9 +31,12 @@ describe('CLI index.ts', () => {
     let mockFindUntrackedFiles;
     let mockMarkFilesIntentToAdd;
     let mockGetPrPatch;
+    let mockGetPrCommentImports;
+    let actualParseCommentOptions;
     // Store original console methods
     let originalConsoleLog;
     let originalConsoleError;
+    let originalConsoleWarn;
     let originalProcessExit;
     beforeEach(() => {
         // Setup mocks
@@ -48,12 +55,17 @@ describe('CLI index.ts', () => {
         mockFindUntrackedFiles = vi.mocked(findUntrackedFiles);
         mockMarkFilesIntentToAdd = vi.mocked(markFilesIntentToAdd);
         mockGetPrPatch = vi.mocked(getPrPatch);
+        mockGetPrCommentImports = vi.mocked(getPrCommentImports);
+        mockGetPrCommentImports.mockResolvedValue([]);
+        actualParseCommentOptions = parseCommentOptions;
         // Mock console and process.exit
         originalConsoleLog = console.log;
         originalConsoleError = console.error;
+        originalConsoleWarn = console.warn;
         originalProcessExit = process.exit;
         console.log = vi.fn();
         console.error = vi.fn();
+        console.warn = vi.fn();
         process.exit = vi.fn();
         // Reset all mocks
         vi.clearAllMocks();
@@ -62,6 +74,7 @@ describe('CLI index.ts', () => {
         // Restore original methods
         console.log = originalConsoleLog;
         console.error = originalConsoleError;
+        console.warn = originalConsoleWarn;
         process.exit = originalProcessExit;
     });
     describe('CLI argument processing', () => {
@@ -200,6 +213,11 @@ describe('CLI index.ts', () => {
                 args: ['--keep-alive'],
                 expectedOptions: { keepAlive: true },
             },
+            {
+                name: '--context option',
+                args: ['--context', '5'],
+                expectedOptions: { context: 5 },
+            },
         ])('$name', async ({ args, expectedOptions }) => {
             mockFindUntrackedFiles.mockResolvedValue([]);
             const program = new Command();
@@ -214,6 +232,7 @@ describe('CLI index.ts', () => {
                 .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')
+                .option('--context <lines>', 'context', parseInt)
                 .action(async (commitish, _compareWith, options) => {
                 let targetCommitish = commitish;
                 let baseCommitish = commitish + '^';
@@ -226,6 +245,7 @@ describe('CLI index.ts', () => {
                     mode: options.mode,
                     clearComments: options.clean,
                     keepAlive: options.keepAlive,
+                    contextLines: options.context,
                 });
             });
             await program.parseAsync([...args], { from: 'user' });
@@ -238,10 +258,91 @@ describe('CLI index.ts', () => {
                 mode: expectedOptions.mode || 'split',
                 clearComments: expectedOptions.clean,
                 keepAlive: expectedOptions.keepAlive,
+                contextLines: expectedOptions.context,
             };
             expect(mockStartServer).toHaveBeenCalledWith(expectedCall);
         });
     });
+    describe('--context option', () => {
+        it('rejects negative values', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--context <lines>', 'context', parseInt)
+                .action(async (commitish, _compareWith, options) => {
+                if (options.context !== undefined &&
+                    (!Number.isInteger(options.context) || options.context < 0)) {
+                    console.error('Error: --context must be a non-negative integer');
+                    process.exit(1);
+                    return;
+                }
+                await startServer({
+                    targetCommitish: commitish,
+                    baseCommitish: `${commitish}^`,
+                    contextLines: options.context,
+                });
+            });
+            await program.parseAsync(['--context', '-1'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --context must be a non-negative integer');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+        it('rejects --context with --pr', async () => {
+            const prUrl = 'https://github.com/owner/repo/pull/123';
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--context <lines>', 'context', parseInt)
+                .option('--pr <url>', 'pr')
+                .action(async (_commitish, _compareWith, options) => {
+                if (options.pr && options.context !== undefined) {
+                    console.error('Error: --context option cannot be used with --pr');
+                    process.exit(1);
+                    return;
+                }
+                await startServer({
+                    stdinDiff: getPrPatch(options.pr),
+                    contextLines: options.context,
+                });
+            });
+            await program.parseAsync(['--pr', prUrl, '--context', '3'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --context option cannot be used with --pr');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockGetPrPatch).not.toHaveBeenCalled();
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+        it('rejects --context with stdin diff', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--context <lines>', 'context', parseInt)
+                .option('--tui', 'tui')
+                .action(async (commitish, _compareWith, options) => {
+                const readFromStdin = shouldReadStdin({
+                    commitish,
+                    hasPositionalArgs: program.args.length > 0,
+                    hasPrOption: false,
+                    hasTuiOption: Boolean(options.tui),
+                });
+                if (readFromStdin && options.context !== undefined) {
+                    console.error('Error: --context option cannot be used with stdin diff');
+                    process.exit(1);
+                    return;
+                }
+                await startServer({
+                    stdinDiff: 'diff --git a/file.ts b/file.ts',
+                    contextLines: options.context,
+                });
+            });
+            await program.parseAsync(['-', '--context', '3'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --context option cannot be used with stdin diff');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+    });
     describe('Version option', () => {
         it('supports --version flag', async () => {
             const program = new Command();
@@ -409,14 +510,38 @@ describe('CLI index.ts', () => {
         });
     });
     describe('GitHub PR integration', () => {
-        it('loads PR patch with gh and starts server with stdin diff', async () => {
+        it('loads PR patch, appends manual comments after PR imports, and starts server with stdin diff', async () => {
             const prUrl = 'https://github.com/owner/repo/pull/123';
             const prPatch = 'diff --git a/file.ts b/file.ts\nindex 1111111..2222222 100644\n';
+            const prCommentImports = [
+                {
+                    type: 'thread',
+                    id: 'PR_COMMENT_1',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported PR thread',
+                    author: 'octocat',
+                    createdAt: '2026-03-25T09:00:00Z',
+                    updatedAt: '2026-03-25T09:05:00Z',
+                },
+                {
+                    type: 'reply',
+                    id: 'PR_COMMENT_2',
+                    filePath: 'src/example.ts',
+                    position: { side: 'new', line: 10 },
+                    body: 'Imported PR reply',
+                    author: 'hubot',
+                    createdAt: '2026-03-25T09:10:00Z',
+                    updatedAt: '2026-03-25T09:12:00Z',
+                },
+            ];
             mockGetPrPatch.mockReturnValue(prPatch);
+            mockGetPrCommentImports.mockResolvedValue(prCommentImports);
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
                 .argument('[compare-with]', 'compare-with')
+                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
                 .option('--port <port>', 'port', parseInt)
                 .option('--host <host>', 'host', '')
                 .option('--no-open', 'no-open')
@@ -424,11 +549,15 @@ describe('CLI index.ts', () => {
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
+                const manualCommentImports = actualParseCommentOptions(options.comment);
+                let commentImports = manualCommentImports;
                 if (options.pr) {
                     if (commitish !== 'HEAD' || _compareWith) {
                         console.error('Error: --pr option cannot be used with positional arguments');
                         process.exit(1);
                     }
+                    const importedPrComments = await getPrCommentImports(options.pr);
+                    commentImports = [...importedPrComments, ...manualCommentImports];
                 }
                 await startServer({
                     stdinDiff: getPrPatch(options.pr),
@@ -436,10 +565,82 @@ describe('CLI index.ts', () => {
                     host: options.host,
                     openBrowser: options.open,
                     mode: options.mode,
+                    commentImports,
                 });
             });
-            await program.parseAsync(['--pr', prUrl], { from: 'user' });
+            await program.parseAsync([
+                '--pr',
+                prUrl,
+                '--comment',
+                '{"type":"reply","filePath":"src/example.ts","position":{"side":"new","line":10},"body":"Manual reply"}',
+            ], { from: 'user' });
             expect(mockGetPrPatch).toHaveBeenCalledWith(prUrl);
+            expect(mockGetPrCommentImports).toHaveBeenCalledWith(prUrl);
+            expect(mockStartServer).toHaveBeenCalledWith({
+                stdinDiff: prPatch,
+                preferredPort: undefined,
+                host: '',
+                openBrowser: true,
+                mode: 'split',
+                commentImports: [
+                    ...prCommentImports,
+                    {
+                        type: 'reply',
+                        id: undefined,
+                        filePath: 'src/example.ts',
+                        position: { side: 'new', line: 10 },
+                        body: 'Manual reply',
+                        author: undefined,
+                        createdAt: undefined,
+                        updatedAt: undefined,
+                        codeSnapshot: undefined,
+                    },
+                ],
+            });
+        });
+        it('continues with patch only when PR comment import fetch fails', async () => {
+            const prUrl = 'https://github.com/owner/repo/pull/123';
+            const prPatch = 'diff --git a/file.ts b/file.ts\nindex 1111111..2222222 100644\n';
+            mockGetPrPatch.mockReturnValue(prPatch);
+            mockGetPrCommentImports.mockRejectedValue(new Error('gh api graphql failed'));
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .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')
+                .action(async (commitish, _compareWith, options) => {
+                const manualCommentImports = actualParseCommentOptions(options.comment);
+                let commentImports = manualCommentImports;
+                if (options.pr) {
+                    if (commitish !== 'HEAD' || _compareWith) {
+                        console.error('Error: --pr option cannot be used with positional arguments');
+                        process.exit(1);
+                    }
+                    try {
+                        const importedPrComments = await getPrCommentImports(options.pr);
+                        commentImports = [...importedPrComments, ...manualCommentImports];
+                    }
+                    catch (error) {
+                        console.warn(`Warning: Failed to load PR review comments: ${error instanceof Error ? error.message : 'Unknown error'}`);
+                    }
+                }
+                await startServer({
+                    stdinDiff: getPrPatch(options.pr),
+                    preferredPort: options.port,
+                    host: options.host,
+                    openBrowser: options.open,
+                    mode: options.mode,
+                    ...(commentImports.length > 0 ? { commentImports } : {}),
+                });
+            });
+            await program.parseAsync(['--pr', prUrl], { from: 'user' });
+            expect(console.warn).toHaveBeenCalledWith('Warning: Failed to load PR review comments: gh api graphql failed');
             expect(mockStartServer).toHaveBeenCalledWith({
                 stdinDiff: prPatch,
                 preferredPort: undefined,
@@ -503,6 +704,95 @@ describe('CLI index.ts', () => {
             expect(mockStartServer).not.toHaveBeenCalled();
         });
     });
+    describe('--comment option', () => {
+        it('passes parsed comment imports to startServer', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--port <port>', 'port', parseInt)
+                .option('--host <host>', 'host', '')
+                .option('--no-open', 'no-open')
+                .option('--mode <mode>', 'mode', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
+                .action(async (commitish, options) => {
+                const commentImports = actualParseCommentOptions(options.comment);
+                await startServer({
+                    targetCommitish: commitish,
+                    baseCommitish: `${commitish}^`,
+                    preferredPort: options.port,
+                    host: options.host,
+                    openBrowser: options.open,
+                    mode: options.mode,
+                    commentImports,
+                });
+            });
+            await program.parseAsync([
+                '--comment',
+                '{"type":"thread","filePath":"src/example.ts","position":{"side":"new","line":10},"body":"Imported comment"}',
+            ], { from: 'user' });
+            expect(mockStartServer).toHaveBeenCalledWith({
+                targetCommitish: 'HEAD',
+                baseCommitish: 'HEAD^',
+                preferredPort: undefined,
+                host: '',
+                openBrowser: true,
+                mode: 'split',
+                commentImports: [
+                    {
+                        type: 'thread',
+                        id: undefined,
+                        filePath: 'src/example.ts',
+                        position: { side: 'new', line: 10 },
+                        body: 'Imported comment',
+                        author: undefined,
+                        createdAt: undefined,
+                        updatedAt: undefined,
+                        codeSnapshot: undefined,
+                    },
+                ],
+            });
+        });
+        it('rejects --comment with --tui', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--tui', 'tui')
+                .action(async (_commitish, options) => {
+                const commentImports = actualParseCommentOptions(options.comment);
+                if (options.tui && commentImports.length > 0) {
+                    console.error('Error: --comment option cannot be used with --tui');
+                    process.exit(1);
+                }
+            });
+            await program.parseAsync([
+                '--tui',
+                '--comment',
+                '{"type":"thread","filePath":"src/example.ts","position":{"side":"new","line":10},"body":"Imported comment"}',
+            ], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --comment option cannot be used with --tui');
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('reports invalid comment json before starting the server', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .action(async (_commitish, options) => {
+                try {
+                    actualParseCommentOptions(options.comment);
+                }
+                catch (error) {
+                    console.error(`Error: ${error instanceof Error ? error.message : 'Invalid --comment value'}`);
+                    process.exit(1);
+                }
+            });
+            await program.parseAsync(['--comment', '{'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: Invalid --comment JSON');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+    });
     describe('Clean flag functionality', () => {
         it('displays clean message when flag is used', async () => {
             mockFindUntrackedFiles.mockResolvedValue([]);
@@ -872,6 +1162,42 @@ describe('CLI index.ts', () => {
                 },
             });
         });
+        it('passes context option to TUI app', async () => {
+            mockFindUntrackedFiles.mockResolvedValue([]);
+            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('--context <lines>', 'context', parseInt)
+                .option('--tui', 'tui')
+                .option('--pr <url>', 'pr')
+                .action(async (commitish, _compareWith, options) => {
+                if (options.tui) {
+                    const { render } = await import('ink');
+                    const { default: TuiApp } = await import('../tui/App.js');
+                    render(React.createElement(TuiApp, {
+                        targetCommitish: commitish,
+                        baseCommitish: commitish + '^',
+                        mode: options.mode,
+                        contextLines: options.context,
+                    }));
+                }
+            });
+            await program.parseAsync(['--tui', '--context', '2'], { from: 'user' });
+            expect(mockRender).toHaveBeenCalledWith({
+                component: mockTuiApp,
+                props: {
+                    targetCommitish: 'HEAD',
+                    baseCommitish: 'HEAD^',
+                    mode: 'split',
+                    contextLines: 2,
+                },
+            });
+        });
         it('passes mode option to TUI app', async () => {
             mockFindUntrackedFiles.mockResolvedValue([]);
             const program = new Command();

package/dist/cli/utils.d.ts

@@ -1,5 +1,6 @@
 import { type Stats } from 'node:fs';
 import type { SimpleGit } from 'simple-git';
+import type { CommentImport } from '../types/diff.js';
 type StdinStat = Pick<Stats, 'isFIFO' | 'isFile' | 'isSocket'>;
 type StdinSource = 'pipe' | 'file' | 'socket' | 'tty';
 export declare function detectStdinSource(stdinStat?: StdinStat): StdinSource;
@@ -15,14 +16,7 @@ export declare function getGitRoot(): string;
 export declare function validateCommitish(commitish: string): boolean;
 export declare function shortHash(hash: string): string;
 export declare function createCommitRangeString(baseHash: string, targetHash: string): string;
-interface PullRequestInfo {
-    owner: string;
-    repo: string;
-    pullNumber: number;
-    hostname: string;
-}
-export declare function parseGitHubPrUrl(url: string): PullRequestInfo | null;
-export declare function getPrPatch(prArg: string): string;
+export declare function parseCommentOptions(commentValues: string[]): CommentImport[];
 export declare function validateDiffArguments(targetCommitish: string, baseCommitish?: string): {
     valid: boolean;
     error?: string;

package/dist/cli/utils.js

@@ -1,6 +1,7 @@
-import { execFileSync, execSync } from 'child_process';
+import { execSync } from 'child_process';
 import { fstatSync } from 'node:fs';
 import { createInterface } from 'readline/promises';
+import { parseCommentImportValue } from '../utils/commentImports.js';
 export function detectStdinSource(stdinStat = fstatSync(0)) {
     if (stdinStat.isFIFO()) {
         return 'pipe';
@@ -129,48 +130,8 @@ export function shortHash(hash) {
 export function createCommitRangeString(baseHash, targetHash) {
     return `${baseHash}...${targetHash}`;
 }
-export function parseGitHubPrUrl(url) {
-    try {
-        const urlObj = new URL(url);
-        // Allow any hostname for GitHub Enterprise support
-        // Just validate the path structure
-        const pathParts = urlObj.pathname.split('/').filter(Boolean);
-        if (pathParts.length < 4 || pathParts[2] !== 'pull') {
-            return null;
-        }
-        const owner = pathParts[0];
-        const repo = pathParts[1];
-        const pullNumber = parseInt(pathParts[3], 10);
-        if (isNaN(pullNumber)) {
-            return null;
-        }
-        return { owner, repo, pullNumber, hostname: urlObj.hostname };
-    }
-    catch {
-        return null;
-    }
-}
-export function getPrPatch(prArg) {
-    try {
-        const patch = execFileSync('gh', ['pr', 'diff', prArg], {
-            encoding: 'utf8',
-            stdio: ['ignore', 'pipe', 'pipe'],
-        });
-        if (!patch.trim()) {
-            throw new Error('No diff content returned from gh pr diff');
-        }
-        return patch;
-    }
-    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`);
-    }
+export function parseCommentOptions(commentValues) {
+    return commentValues.flatMap((value) => parseCommentImportValue(value));
 }
 export function validateDiffArguments(targetCommitish, baseCommitish) {
     // Validate target commitish format