difit 4.0.1 → 4.0.3

package/dist/cli/index.test.js

@@ -82,40 +82,43 @@ describe('CLI index.ts', () => {
             {
                 name: 'default arguments',
                 args: [],
-                expectedTarget: 'HEAD',
-                expectedBase: 'HEAD^',
+                expectedSelection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
             },
             {
                 name: 'single commit argument',
                 args: ['main'],
-                expectedTarget: 'main',
-                expectedBase: 'main^',
+                expectedSelection: { targetCommitish: 'main', baseCommitish: 'main^' },
             },
             {
                 name: 'two commit arguments',
                 args: ['main', 'develop'],
-                expectedTarget: 'main',
-                expectedBase: 'develop',
+                expectedSelection: { targetCommitish: 'main', baseCommitish: 'develop' },
             },
             {
                 name: 'special: working',
                 args: ['working'],
-                expectedTarget: 'working',
-                expectedBase: 'staged',
+                expectedSelection: { targetCommitish: 'working', baseCommitish: 'staged' },
             },
             {
                 name: 'special: staged',
                 args: ['staged'],
-                expectedTarget: 'staged',
-                expectedBase: 'HEAD',
+                expectedSelection: { targetCommitish: 'staged', baseCommitish: 'HEAD' },
             },
             {
                 name: 'special: dot',
                 args: ['.'],
-                expectedTarget: '.',
-                expectedBase: 'HEAD',
+                expectedSelection: { targetCommitish: '.', baseCommitish: 'HEAD' },
             },
-        ])('$name', async ({ args, expectedTarget, expectedBase }) => {
+            {
+                name: 'merge-base comparison',
+                args: ['.', 'origin/main', '--merge-base'],
+                expectedSelection: {
+                    targetCommitish: '.',
+                    baseCommitish: 'origin/main',
+                    baseMode: 'merge-base',
+                },
+            },
+        ])('$name', async ({ args, expectedSelection }) => {
             mockFindUntrackedFiles.mockResolvedValue([]);
             const program = new Command();
             // Simulate command execution
@@ -126,6 +129,7 @@ describe('CLI index.ts', () => {
                 .option('--host <host>', 'host', '')
                 .option('--no-open', 'no-open')
                 .option('--mode <mode>', 'mode', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
+                .option('--merge-base', 'merge-base')
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
@@ -152,8 +156,9 @@ describe('CLI index.ts', () => {
                     // Skip prompt logic for test
                 }
                 await startServer({
-                    targetCommitish,
-                    baseCommitish,
+                    selection: options.mergeBase
+                        ? { targetCommitish, baseCommitish, baseMode: 'merge-base' }
+                        : { targetCommitish, baseCommitish },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -162,8 +167,7 @@ describe('CLI index.ts', () => {
             });
             await program.parseAsync([...args], { from: 'user' });
             expect(mockStartServer).toHaveBeenCalledWith({
-                targetCommitish: expectedTarget,
-                baseCommitish: expectedBase,
+                selection: expectedSelection,
                 preferredPort: undefined,
                 host: '',
                 openBrowser: true,
@@ -218,6 +222,11 @@ describe('CLI index.ts', () => {
                 args: ['--context', '5'],
                 expectedOptions: { context: 5 },
             },
+            {
+                name: '--merge-base option',
+                args: ['--merge-base'],
+                expectedOptions: { mergeBase: true },
+            },
         ])('$name', async ({ args, expectedOptions }) => {
             mockFindUntrackedFiles.mockResolvedValue([]);
             const program = new Command();
@@ -230,6 +239,7 @@ describe('CLI index.ts', () => {
                 .option('--mode <mode>', 'mode', normalizeDiffViewMode, DEFAULT_DIFF_VIEW_MODE)
                 .option('--tui', 'tui')
                 .option('--pr <url>', 'pr')
+                .option('--merge-base', 'merge-base')
                 .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)
@@ -237,8 +247,9 @@ describe('CLI index.ts', () => {
                 let targetCommitish = commitish;
                 let baseCommitish = commitish + '^';
                 await startServer({
-                    targetCommitish,
-                    baseCommitish,
+                    selection: options.mergeBase
+                        ? { targetCommitish, baseCommitish, baseMode: 'merge-base' }
+                        : { targetCommitish, baseCommitish },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -250,8 +261,9 @@ describe('CLI index.ts', () => {
             });
             await program.parseAsync([...args], { from: 'user' });
             const expectedCall = {
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: expectedOptions.mergeBase
+                    ? { targetCommitish: 'HEAD', baseCommitish: 'HEAD^', baseMode: 'merge-base' }
+                    : { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: expectedOptions.port,
                 host: expectedOptions.host || '',
                 openBrowser: expectedOptions.open !== false,
@@ -278,8 +290,7 @@ describe('CLI index.ts', () => {
                     return;
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: `${commitish}^`,
+                    selection: { targetCommitish: commitish, baseCommitish: `${commitish}^` },
                     contextLines: options.context,
                 });
             });
@@ -343,6 +354,98 @@ describe('CLI index.ts', () => {
             expect(mockStartServer).not.toHaveBeenCalled();
         });
     });
+    describe('--merge-base option', () => {
+        it('rejects --merge-base 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('--merge-base', 'merge-base')
+                .option('--pr <url>', 'pr')
+                .action(async (commitish, _compareWith, options) => {
+                if (options.pr && commitish === 'HEAD' && !_compareWith && options.mergeBase) {
+                    console.error('Error: --merge-base option cannot be used with --pr');
+                    process.exit(1);
+                    return;
+                }
+                await startServer({
+                    stdinDiff: getPrPatch(options.pr),
+                });
+            });
+            await program.parseAsync(['--pr', prUrl, '--merge-base'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --merge-base option cannot be used with --pr');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockGetPrPatch).not.toHaveBeenCalled();
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+        it('rejects --merge-base with stdin diff', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--merge-base', 'merge-base')
+                .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.mergeBase) {
+                    console.error('Error: --merge-base option cannot be used with stdin diff');
+                    process.exit(1);
+                    return;
+                }
+                await startServer({
+                    stdinDiff: 'diff --git a/file.ts b/file.ts',
+                });
+            });
+            await program.parseAsync(['-', '--merge-base'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --merge-base option cannot be used with stdin diff');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+        it('rejects --merge-base when the resolved base is a special argument', async () => {
+            const program = new Command();
+            program
+                .argument('[commit-ish]', 'commit-ish', 'HEAD')
+                .argument('[compare-with]', 'compare-with')
+                .option('--merge-base', 'merge-base')
+                .action(async (commitish, _compareWith, options) => {
+                let baseCommitish;
+                if (_compareWith) {
+                    baseCommitish = _compareWith;
+                }
+                else if (commitish === 'working') {
+                    baseCommitish = 'staged';
+                }
+                else if (commitish === 'staged' || commitish === '.') {
+                    baseCommitish = 'HEAD';
+                }
+                else {
+                    baseCommitish = commitish + '^';
+                }
+                const selection = options.mergeBase
+                    ? { targetCommitish: commitish, baseCommitish, baseMode: 'merge-base' }
+                    : { targetCommitish: commitish, baseCommitish };
+                if (options.mergeBase &&
+                    (selection.baseCommitish === 'working' ||
+                        selection.baseCommitish === 'staged' ||
+                        selection.baseCommitish === '.')) {
+                    console.error(`Error: --merge-base requires a commit-ish base, but resolved base was "${selection.baseCommitish}"`);
+                    process.exit(1);
+                    return;
+                }
+                await startServer({ selection });
+            });
+            await program.parseAsync(['working', '--merge-base'], { from: 'user' });
+            expect(console.error).toHaveBeenCalledWith('Error: --merge-base requires a commit-ish base, but resolved base was "staged"');
+            expect(process.exit).toHaveBeenCalledWith(1);
+            expect(mockStartServer).not.toHaveBeenCalled();
+        });
+    });
     describe('Version option', () => {
         it('supports --version flag', async () => {
             const program = new Command();
@@ -394,8 +497,7 @@ describe('CLI index.ts', () => {
                     // Skip prompt logic for test
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: 'staged',
+                    selection: { targetCommitish: commitish, baseCommitish: 'staged' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -424,8 +526,7 @@ describe('CLI index.ts', () => {
                     await findUntrackedFiles(git);
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -459,8 +560,7 @@ describe('CLI index.ts', () => {
                     }
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: 'staged',
+                    selection: { targetCommitish: commitish, baseCommitish: 'staged' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -496,8 +596,7 @@ describe('CLI index.ts', () => {
                     }
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: 'staged',
+                    selection: { targetCommitish: commitish, baseCommitish: 'staged' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -717,8 +816,7 @@ describe('CLI index.ts', () => {
                 .action(async (commitish, options) => {
                 const commentImports = actualParseCommentOptions(options.comment);
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: `${commitish}^`,
+                    selection: { targetCommitish: commitish, baseCommitish: `${commitish}^` },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -731,8 +829,7 @@ describe('CLI index.ts', () => {
                 '{"type":"thread","filePath":"src/example.ts","position":{"side":"new","line":10},"body":"Imported comment"}',
             ], { from: 'user' });
             expect(mockStartServer).toHaveBeenCalledWith({
-                targetCommitish: 'HEAD',
-                baseCommitish: 'HEAD^',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
                 preferredPort: undefined,
                 host: '',
                 openBrowser: true,
@@ -814,8 +911,7 @@ describe('CLI index.ts', () => {
                 .option('--clean', 'start with a clean slate by clearing all existing comments')
                 .action(async (commitish, _compareWith, options) => {
                 const { url } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -854,8 +950,7 @@ describe('CLI index.ts', () => {
                 .option('--clean', 'start with a clean slate by clearing all existing comments')
                 .action(async (commitish, _compareWith, options) => {
                 const { url } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -897,8 +992,7 @@ describe('CLI index.ts', () => {
                 .option('--keep-alive', 'keep server running even after browser disconnects')
                 .action(async (commitish, _compareWith, options) => {
                 const { url } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -939,8 +1033,7 @@ describe('CLI index.ts', () => {
                 .option('--keep-alive', 'keep server running even after browser disconnects')
                 .action(async (commitish, _compareWith, options) => {
                 const { url } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -981,8 +1074,7 @@ describe('CLI index.ts', () => {
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
                 const { url, isEmpty } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1024,8 +1116,7 @@ describe('CLI index.ts', () => {
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
                 const { url, isEmpty } = await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1058,8 +1149,7 @@ describe('CLI index.ts', () => {
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1085,8 +1175,7 @@ describe('CLI index.ts', () => {
                 .option('--pr <url>', 'pr')
                 .action(async (commitish, _compareWith, options) => {
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: commitish + '^',
+                    selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1102,16 +1191,16 @@ describe('CLI index.ts', () => {
     describe('TUI mode', () => {
         let mockRender;
         let mockTuiApp;
-        beforeEach(async () => {
-            // Mock ink and TUI components
+        const expectRenderedTuiProps = (props) => {
+            expect(mockRender).toHaveBeenCalledTimes(1);
+            expect(mockRender).toHaveBeenCalledWith({
+                component: mockTuiApp,
+                props,
+            });
+        };
+        beforeEach(() => {
             mockRender = vi.fn();
             mockTuiApp = vi.fn();
-            vi.doMock('ink', async () => ({
-                render: mockRender,
-            }));
-            vi.doMock('../tui/App.js', async () => ({
-                default: mockTuiApp,
-            }));
             // Mock React.createElement for testing
             vi.spyOn(React, 'createElement').mockImplementation((component, props) => ({ component, props }));
             // Mock process.stdin.isTTY
@@ -1121,8 +1210,6 @@ describe('CLI index.ts', () => {
             });
         });
         afterEach(() => {
-            vi.doUnmock('ink');
-            vi.doUnmock('../tui/App.js');
             vi.restoreAllMocks();
         });
         it('passes arguments to TUI app correctly', async () => {
@@ -1143,23 +1230,18 @@ describe('CLI index.ts', () => {
                         console.error('Error: TUI mode requires an interactive terminal (TTY).');
                         process.exit(1);
                     }
-                    const { render } = await import('ink');
-                    const { default: TuiApp } = await import('../tui/App.js');
+                    const render = mockRender;
+                    const TuiApp = mockTuiApp;
                     render(React.createElement(TuiApp, {
-                        targetCommitish: commitish,
-                        baseCommitish: commitish + '^',
+                        selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                         mode: options.mode,
                     }));
                 }
             });
             await program.parseAsync(['main', '--tui'], { from: 'user' });
-            expect(mockRender).toHaveBeenCalledWith({
-                component: mockTuiApp,
-                props: {
-                    targetCommitish: 'main',
-                    baseCommitish: 'main^',
-                    mode: 'split',
-                },
+            expectRenderedTuiProps({
+                selection: { targetCommitish: 'main', baseCommitish: 'main^' },
+                mode: 'split',
             });
         });
         it('passes context option to TUI app', async () => {
@@ -1177,25 +1259,20 @@ describe('CLI index.ts', () => {
                 .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');
+                    const render = mockRender;
+                    const TuiApp = mockTuiApp;
                     render(React.createElement(TuiApp, {
-                        targetCommitish: commitish,
-                        baseCommitish: commitish + '^',
+                        selection: { 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,
-                },
+            expectRenderedTuiProps({
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
+                mode: 'split',
+                contextLines: 2,
             });
         });
         it('passes mode option to TUI app', async () => {
@@ -1216,23 +1293,18 @@ describe('CLI index.ts', () => {
                         console.error('Error: TUI mode requires an interactive terminal (TTY).');
                         process.exit(1);
                     }
-                    const { render } = await import('ink');
-                    const { default: TuiApp } = await import('../tui/App.js');
+                    const render = mockRender;
+                    const TuiApp = mockTuiApp;
                     render(React.createElement(TuiApp, {
-                        targetCommitish: commitish,
-                        baseCommitish: commitish + '^',
+                        selection: { targetCommitish: commitish, baseCommitish: commitish + '^' },
                         mode: options.mode,
                     }));
                 }
             });
             await program.parseAsync(['--tui', '--mode', 'unified'], { from: 'user' });
-            expect(mockRender).toHaveBeenCalledWith({
-                component: mockTuiApp,
-                props: {
-                    targetCommitish: 'HEAD',
-                    baseCommitish: 'HEAD^',
-                    mode: 'unified',
-                },
+            expectRenderedTuiProps({
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'HEAD^' },
+                mode: 'unified',
             });
         });
         it('handles special arguments with TUI mode', async () => {
@@ -1249,8 +1321,8 @@ describe('CLI index.ts', () => {
                 .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');
+                    const render = mockRender;
+                    const TuiApp = mockTuiApp;
                     let targetCommitish = commitish;
                     let baseCommitish;
                     if (commitish === 'working') {
@@ -1263,20 +1335,15 @@ describe('CLI index.ts', () => {
                         baseCommitish = commitish + '^';
                     }
                     render(React.createElement(TuiApp, {
-                        targetCommitish,
-                        baseCommitish,
+                        selection: { targetCommitish, baseCommitish },
                         mode: options.mode,
                     }));
                 }
             });
             await program.parseAsync(['working', '--tui', '--mode', 'unified'], { from: 'user' });
-            expect(mockRender).toHaveBeenCalledWith({
-                component: mockTuiApp,
-                props: {
-                    targetCommitish: 'working',
-                    baseCommitish: 'staged',
-                    mode: 'unified',
-                },
+            expectRenderedTuiProps({
+                selection: { targetCommitish: 'working', baseCommitish: 'staged' },
+                mode: 'unified',
             });
         });
         it('rejects TUI mode in non-TTY environment', async () => {
@@ -1375,8 +1442,10 @@ describe('CLI index.ts', () => {
                         diffMode = DiffMode.DEFAULT;
                     }
                     await startServer({
-                        targetCommitish: commitish,
-                        baseCommitish: compareWith || commitish + '^',
+                        selection: {
+                            targetCommitish: commitish,
+                            baseCommitish: compareWith || commitish + '^',
+                        },
                         preferredPort: options.port,
                         host: options.host,
                         openBrowser: options.open,
@@ -1421,8 +1490,10 @@ describe('CLI index.ts', () => {
                     diffMode = DiffMode.DEFAULT;
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: compareWith || commitish + '^',
+                    selection: {
+                        targetCommitish: commitish,
+                        baseCommitish: compareWith || commitish + '^',
+                    },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1433,8 +1504,7 @@ describe('CLI index.ts', () => {
             await program.parseAsync(['HEAD', 'main'], { from: 'user' });
             expect(mockStartServer).toHaveBeenCalledWith(expect.objectContaining({
                 diffMode: 'default', // HEAD with comparison is still DEFAULT mode
-                targetCommitish: 'HEAD',
-                baseCommitish: 'main',
+                selection: { targetCommitish: 'HEAD', baseCommitish: 'main' },
             }));
         });
         it('enables watch mode for dot with comparison', async () => {
@@ -1468,8 +1538,10 @@ describe('CLI index.ts', () => {
                     diffMode = DiffMode.DEFAULT;
                 }
                 await startServer({
-                    targetCommitish: commitish,
-                    baseCommitish: compareWith || commitish + '^',
+                    selection: {
+                        targetCommitish: commitish,
+                        baseCommitish: compareWith || commitish + '^',
+                    },
                     preferredPort: options.port,
                     host: options.host,
                     openBrowser: options.open,
@@ -1480,8 +1552,7 @@ describe('CLI index.ts', () => {
             await program.parseAsync(['.', 'origin/main'], { from: 'user' });
             expect(mockStartServer).toHaveBeenCalledWith(expect.objectContaining({
                 diffMode: 'dot', // Dot with comparison should still be DOT mode (watch enabled)
-                targetCommitish: '.',
-                baseCommitish: 'origin/main',
+                selection: { targetCommitish: '.', baseCommitish: 'origin/main' },
             }));
         });
     });

package/dist/cli/tuiDeprecation.d.ts

@@ -0,0 +1,3 @@
+export declare const TUI_DEPRECATION_NOTICE_LINES: string[];
+export declare const TUI_DEPRECATION_PROMPT: string;
+export declare function warnAboutTuiDeprecation(waitForEnterFn?: (message: string) => Promise<void>): Promise<void>;

package/dist/cli/tuiDeprecation.js

@@ -0,0 +1,16 @@
+import { waitForEnter } from './utils.js';
+const TUI_DEPRECATION_ISSUES_URL = 'https://github.com/yoshiko-pg/difit/issues';
+export const TUI_DEPRECATION_NOTICE_LINES = [
+    `⚠️ TUI mode will be removed in the next major release because ongoing implementation of core features is difficult. If you have feedback, please open an issue: ${TUI_DEPRECATION_ISSUES_URL}`,
+    `⚠️ tuiモードは継続的な主要機能の実装が難しいため次回のメジャーリリースで削除予定です。もしご意見がある場合はissueの起票をお願いします。 ${TUI_DEPRECATION_ISSUES_URL}`,
+];
+export const TUI_DEPRECATION_PROMPT = [
+    'Press Enter to start TUI mode.',
+    'Enterを押すとtuiモードを起動します。',
+].join('\n');
+export async function warnAboutTuiDeprecation(waitForEnterFn = waitForEnter) {
+    for (const line of TUI_DEPRECATION_NOTICE_LINES) {
+        console.warn(line);
+    }
+    await waitForEnterFn(`\n${TUI_DEPRECATION_PROMPT}\n`);
+}

package/dist/cli/tuiDeprecation.test.d.ts

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

package/dist/cli/tuiDeprecation.test.js

@@ -0,0 +1,16 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { TUI_DEPRECATION_NOTICE_LINES, TUI_DEPRECATION_PROMPT, warnAboutTuiDeprecation, } from './tuiDeprecation.js';
+describe('TUI deprecation warning', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('shows bilingual warnings and waits for Enter before continuing', async () => {
+        const consoleWarn = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        const waitForEnter = vi.fn().mockResolvedValue(undefined);
+        await warnAboutTuiDeprecation(waitForEnter);
+        expect(consoleWarn).toHaveBeenNthCalledWith(1, TUI_DEPRECATION_NOTICE_LINES[0]);
+        expect(consoleWarn).toHaveBeenNthCalledWith(2, TUI_DEPRECATION_NOTICE_LINES[1]);
+        expect(waitForEnter).toHaveBeenCalledWith(`\n${TUI_DEPRECATION_PROMPT}\n`);
+        expect(consoleWarn.mock.invocationCallOrder[1]).toBeLessThan(waitForEnter.mock.invocationCallOrder[0]);
+    });
+});

package/dist/cli/utils.d.ts

@@ -24,4 +24,5 @@ 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 declare function waitForEnter(message: string): Promise<void>;
 export {};