difit 4.0.4 → 4.0.6

package/README.ja.md

@@ -151,6 +151,7 @@ git diff --cached | difit -
 | `--clean`             | false           | 起動時に既存コメントと閲覧済みファイルをすべてクリア                                       |
 | `--include-untracked` | false           | diffにuntrackedファイルを自動的に含める（`.`または`working`のみ有効）                      |
 | `--keep-alive`        | false           | ブラウザ切断後もサーバーを終了せず起動したままにする（Ctrl+Cで手動停止）                   |
+| `--background`        | false           | サーバーをバックグラウンドで起動したままにし、接続情報をJSONで出力                         |
 | `--context <lines>`   | Gitの既定値 (3) | 変更ごとの前後コンテキスト行数を制限（`0` は変更行のみ表示。`--pr` と stdin では使用不可） |
 
 ## 💬 コメントシステム
@@ -197,10 +198,10 @@ npx skills add yoshiko-pg/difit
 - **JavaScript/TypeScript**：`.js`, `.jsx`, `.ts`, `.tsx`
 - **Web技術**：HTML, CSS, JSON, XML, Markdown
 - **シェルスクリプト**：`.sh`, `.bash`, `.zsh`, `.fish`
-- **バックエンド言語**：PHP, SQL, Ruby, Java, Scala, Perl, Elixir
+- **バックエンド言語**：PHP, SQL, Ruby, Java, Scala, Perl, Elixir, Haskell, Clojure
 - **システム言語**：C, C++, C#, Rust, Go
 - **モバイル言語**：Swift, Kotlin, Dart
-- **IaC**：Terraform (HCL)
+- **IaC**：Terraform (HCL), Nix
 - **その他**：Python, Protobuf, YAML, Solidity, Vim Script
 
 ## 🔍 自動折りたたみファイル

package/README.ko.md

@@ -151,6 +151,7 @@ git diff --cached | difit -
 | `--clean`             | false          | 시작 시 모든 기존 코멘트와 열람된 파일 표시 초기화                                            |
 | `--include-untracked` | false          | diff에 untracked 파일 자동 포함 (`.` 또는 `working`에서만 유효)                               |
 | `--keep-alive`        | false          | 브라우저 연결이 끊겨도 서버 유지 (Ctrl+C로 수동 종료)                                         |
+| `--background`        | false          | 서버를 백그라운드에서 계속 실행하고 JSON 연결 정보 출력                                       |
 | `--context <lines>`   | Git 기본값 (3) | 변경 주변의 컨텍스트 줄 수를 제한 (`0`이면 변경된 줄만 표시, `--pr` 및 stdin에서는 사용 불가) |
 
 ## 💬 코멘트 시스템
@@ -197,10 +198,10 @@ npx skills add yoshiko-pg/difit
 - **JavaScript/TypeScript**: `.js`, `.jsx`, `.ts`, `.tsx`
 - **웹 기술**: HTML, CSS, JSON, XML, Markdown
 - **셸 스크립트**: `.sh`, `.bash`, `.zsh`, `.fish`
-- **백엔드 언어**: PHP, SQL, Ruby, Java, Scala, Perl, Elixir
+- **백엔드 언어**: PHP, SQL, Ruby, Java, Scala, Perl, Elixir, Haskell, Clojure
 - **시스템 언어**: C, C++, C#, Rust, Go
 - **모바일 언어**: Swift, Kotlin, Dart
-- **인프라 코드**: Terraform (HCL)
+- **인프라 코드**: Terraform (HCL), Nix
 - **기타**: Python, Protobuf, YAML, Solidity, Vim 스크립트
 
 ## 🔍 자동 접힘 파일

package/README.md

@@ -151,6 +151,7 @@ Stdin mode is selected with intent-first rules:
 | `--clean`             | false           | Clear all existing comments and viewed files on startup                                                 |
 | `--include-untracked` | false           | Automatically include untracked files in diff (only with `.` or `working`)                              |
 | `--keep-alive`        | false           | Keep server running after browser disconnects (stop manually with Ctrl+C)                               |
+| `--background`        | false           | Keep the server running in the background and output JSON connection info                               |
 | `--context <lines>`   | git default (3) | Limit surrounding context lines per change (`0` shows changes only; not available with `--pr` or stdin) |
 
 ## 💬 Comment System
@@ -197,10 +198,10 @@ After code edits or automated review, the agent can start the difit server with
 - **JavaScript/TypeScript**: `.js`, `.jsx`, `.ts`, `.tsx`
 - **Web Technologies**: HTML, CSS, JSON, XML, Markdown
 - **Shell Scripts**: `.sh`, `.bash`, `.zsh`, `.fish`
-- **Backend Languages**: PHP, SQL, Ruby, Java, Scala, Perl, Elixir
+- **Backend Languages**: PHP, SQL, Ruby, Java, Scala, Perl, Elixir, Haskell, Clojure
 - **Systems Languages**: C, C++, C#, Rust, Go
 - **Mobile Languages**: Swift, Kotlin, Dart
-- **Infrastructure as Code**: Terraform (HCL)
+- **Infrastructure as Code**: Terraform (HCL), Nix
 - **Others**: Python, Protobuf, YAML, Solidity, Vim script
 
 ## 🔍 Auto-collapsed Files

package/README.zh.md

@@ -151,6 +151,7 @@ git diff --cached | difit -
 | `--clean`             | false          | 启动时清除所有现有评论和已查看的文件                                              |
 | `--include-untracked` | false          | 自动将 untracked 文件包含在 diff 中（仅在 `.` 或 `working` 时有效）               |
 | `--keep-alive`        | false          | 浏览器断开后保持服务器运行（使用 Ctrl+C 手动停止）                                |
+| `--background`        | false          | 在后台保持服务器运行，并输出 JSON 连接信息                                        |
 | `--context <lines>`   | Git 默认值 (3) | 限制每处变更周围的上下文行数（`0` 仅显示变更行；不可与 `--pr` 或 stdin 一起使用） |
 
 ## 💬 评论系统
@@ -197,10 +198,10 @@ npx skills add yoshiko-pg/difit
 - **JavaScript/TypeScript**：`.js`, `.jsx`, `.ts`, `.tsx`
 - **Web 技术**：HTML, CSS, JSON, XML, Markdown
 - **Shell 脚本**：`.sh`, `.bash`, `.zsh`, `.fish`
-- **后端语言**：PHP, SQL, Ruby, Java, Scala, Perl, Elixir
+- **后端语言**：PHP, SQL, Ruby, Java, Scala, Perl, Elixir, Haskell, Clojure
 - **系统语言**：C, C++, C#, Rust, Go
 - **移动语言**：Swift, Kotlin, Dart
-- **基础设施即代码**：Terraform (HCL)
+- **基础设施即代码**：Terraform (HCL), Nix
 - **其他**：Python, Protobuf, YAML, Solidity, Vim Script
 
 ## 🔍 自动折叠文件

package/dist/cli/comment.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function createCommentCommand(): Command;

package/dist/cli/comment.js

@@ -0,0 +1,91 @@
+import { Command, Option } from 'commander';
+import { parseCommentImportValue } from '../utils/commentImports.js';
+import { detectStdinSource, readStdin } from './utils.js';
+async function parseCommentAddInput(json) {
+    if (typeof json === 'string') {
+        return json;
+    }
+    if (detectStdinSource() === 'tty') {
+        throw new Error('Provide comment JSON as an argument or via stdin');
+    }
+    const stdin = await readStdin();
+    if (!stdin.trim()) {
+        throw new Error('No comment JSON received from stdin');
+    }
+    return stdin;
+}
+export function createCommentCommand() {
+    const comment = new Command('comment').description('Add or retrieve comments on a running difit server');
+    comment
+        .command('add')
+        .description('Add comments to a running difit server')
+        .argument('[json]', 'comment import JSON (object or array)')
+        .requiredOption('--port <port>', 'port of the running difit server', parseInt)
+        .action(async (json, opts) => {
+        try {
+            const input = await parseCommentAddInput(json);
+            const imports = parseCommentImportValue(input);
+            const response = await fetch(`http://localhost:${opts.port}/api/comment-imports`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(imports),
+            });
+            if (!response.ok) {
+                const errorBody = (await response.json().catch(() => ({})));
+                console.error(`Error: ${errorBody.error ?? 'Failed to add comments'}`);
+                process.exit(1);
+            }
+            const result = (await response.json());
+            console.log(JSON.stringify({
+                success: result.success ?? true,
+                importId: result.importId,
+                count: result.count ?? imports.length,
+                warnings: result.warnings ?? [],
+            }));
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch failed')) {
+                console.error(`Error: Cannot connect to difit server on port ${opts.port}. Is the server running?`);
+            }
+            else {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            process.exit(1);
+        }
+    });
+    comment
+        .command('get')
+        .description('Retrieve comments from a running difit server')
+        .requiredOption('--port <port>', 'port of the running difit server', parseInt)
+        .addOption(new Option('--format <format>', 'output format').choices(['text', 'json']).default('text'))
+        .action(async (opts) => {
+        try {
+            const endpoint = opts.format === 'json' ? '/api/comments-json' : '/api/comments-output';
+            const response = await fetch(`http://localhost:${opts.port}${endpoint}`);
+            if (!response.ok) {
+                console.error('Error: Failed to retrieve comments');
+                process.exit(1);
+            }
+            if (opts.format === 'json') {
+                const data = await response.json();
+                console.log(JSON.stringify(data));
+            }
+            else {
+                const text = await response.text();
+                if (text.trim()) {
+                    console.log(text);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof TypeError && error.message.includes('fetch failed')) {
+                console.error(`Error: Cannot connect to difit server on port ${opts.port}. Is the server running?`);
+            }
+            else {
+                console.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+            process.exit(1);
+        }
+    });
+    return comment;
+}

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

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

package/dist/cli/comment.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createCommentCommand } from './comment.js';
+describe('createCommentCommand', () => {
+    const command = createCommentCommand();
+    it('creates a command named "comment"', () => {
+        expect(command.name()).toBe('comment');
+    });
+    it('has "add" and "get" subcommands', () => {
+        const subcommandNames = command.commands.map((c) => c.name());
+        expect(subcommandNames).toContain('add');
+        expect(subcommandNames).toContain('get');
+    });
+    describe('add subcommand', () => {
+        const addCommand = command.commands.find((c) => c.name() === 'add');
+        it('requires --port option', () => {
+            const portOption = addCommand.options.find((o) => o.long === '--port');
+            expect(portOption).toBeDefined();
+            expect(portOption?.mandatory).toBe(true);
+        });
+        it('accepts optional json argument', () => {
+            const args = addCommand.registeredArguments;
+            expect(args).toHaveLength(1);
+            expect(args[0].name()).toBe('json');
+            expect(args[0].required).toBe(false);
+        });
+    });
+    describe('get subcommand', () => {
+        const getCommand = command.commands.find((c) => c.name() === 'get');
+        it('requires --port option', () => {
+            const portOption = getCommand.options.find((o) => o.long === '--port');
+            expect(portOption).toBeDefined();
+            expect(portOption?.mandatory).toBe(true);
+        });
+        it('has --format option with choices', () => {
+            const formatOption = getCommand.options.find((o) => o.long === '--format');
+            expect(formatOption).toBeDefined();
+            expect(formatOption?.defaultValue).toBe('text');
+            expect(formatOption?.argChoices).toEqual(['text', 'json']);
+        });
+    });
+});
+function jsonResponse(body, status = 200) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+function textResponse(body, status = 200) {
+    return new Response(body, {
+        status,
+        headers: { 'Content-Type': 'text/plain' },
+    });
+}
+describe('comment subcommand integration', () => {
+    const originalFetch = globalThis.fetch;
+    let mockFetch;
+    let originalProcessExit;
+    let consoleOutput;
+    let consoleErrors;
+    beforeEach(() => {
+        mockFetch = vi.fn();
+        globalThis.fetch = mockFetch;
+        originalProcessExit = process.exit;
+        process.exit = vi.fn();
+        consoleOutput = [];
+        consoleErrors = [];
+        vi.spyOn(console, 'log').mockImplementation((...args) => {
+            consoleOutput.push(args.join(' '));
+        });
+        vi.spyOn(console, 'error').mockImplementation((...args) => {
+            consoleErrors.push(args.join(' '));
+        });
+    });
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+        process.exit = originalProcessExit;
+        vi.restoreAllMocks();
+    });
+    describe('add', () => {
+        it('sends comment imports to the server', async () => {
+            mockFetch.mockResolvedValue(jsonResponse({ success: true, importId: 'abc123', count: 1 }));
+            const command = createCommentCommand();
+            await command.parseAsync([
+                'node',
+                'difit',
+                'add',
+                '--port',
+                '4966',
+                '{"type":"thread","filePath":"test.ts","position":{"side":"new","line":1},"body":"Test"}',
+            ]);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:4966/api/comment-imports', expect.objectContaining({
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+            }));
+            expect(consoleOutput[0]).toContain('"success":true');
+        });
+        it('validates JSON before sending', async () => {
+            const command = createCommentCommand();
+            await command.parseAsync(['node', 'difit', 'add', '--port', '4966', 'not-valid-json']);
+            expect(mockFetch).not.toHaveBeenCalled();
+            expect(consoleErrors[0]).toContain('Error:');
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('handles server error response', async () => {
+            mockFetch.mockResolvedValue(jsonResponse({ error: 'Bad request' }, 400));
+            const command = createCommentCommand();
+            await command.parseAsync([
+                'node',
+                'difit',
+                'add',
+                '--port',
+                '4966',
+                '{"type":"thread","filePath":"test.ts","position":{"side":"new","line":1},"body":"Test"}',
+            ]);
+            expect(consoleErrors[0]).toContain('Bad request');
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('handles connection error', async () => {
+            const fetchError = new TypeError('fetch failed');
+            mockFetch.mockRejectedValue(fetchError);
+            const command = createCommentCommand();
+            await command.parseAsync([
+                'node',
+                'difit',
+                'add',
+                '--port',
+                '9999',
+                '{"type":"thread","filePath":"test.ts","position":{"side":"new","line":1},"body":"Test"}',
+            ]);
+            expect(consoleErrors[0]).toContain('Cannot connect');
+            expect(consoleErrors[0]).toContain('9999');
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+    });
+    describe('get', () => {
+        it('fetches comments in text format by default', async () => {
+            mockFetch.mockResolvedValue(textResponse('Comments output text'));
+            const command = createCommentCommand();
+            await command.parseAsync(['node', 'difit', 'get', '--port', '4966']);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:4966/api/comments-output');
+            expect(consoleOutput[0]).toBe('Comments output text');
+        });
+        it('fetches comments in json format', async () => {
+            mockFetch.mockResolvedValue(jsonResponse({ threads: [{ id: '1' }] }));
+            const command = createCommentCommand();
+            await command.parseAsync(['node', 'difit', 'get', '--port', '4966', '--format', 'json']);
+            expect(mockFetch).toHaveBeenCalledWith('http://localhost:4966/api/comments-json');
+            expect(consoleOutput[0]).toContain('"threads"');
+        });
+        it('handles connection error', async () => {
+            mockFetch.mockRejectedValue(new TypeError('fetch failed'));
+            const command = createCommentCommand();
+            await command.parseAsync(['node', 'difit', 'get', '--port', '9999']);
+            expect(consoleErrors[0]).toContain('Cannot connect');
+            expect(process.exit).toHaveBeenCalledWith(1);
+        });
+        it('handles empty text output silently', async () => {
+            mockFetch.mockResolvedValue(textResponse('  '));
+            const command = createCommentCommand();
+            await command.parseAsync(['node', 'difit', 'get', '--port', '4966']);
+            expect(consoleOutput).toHaveLength(0);
+        });
+    });
+});

package/dist/cli/index.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawn } from 'child_process';
 import { Command } from 'commander';
 import React from 'react';
 import { simpleGit } from 'simple-git';
@@ -7,7 +8,8 @@ import { startServer } from '../server/server.js';
 import { createDiffSelection } from '../utils/diffSelection.js';
 import { DiffMode } from '../types/watch.js';
 import { DEFAULT_DIFF_VIEW_MODE, normalizeDiffViewMode } from '../utils/diffMode.js';
-import { shouldReadStdin, findUntrackedFiles, markFilesIntentToAdd, promptUser, parseCommentOptions, validateDiffArguments, getGitRoot, } from './utils.js';
+import { shouldReadStdin, findUntrackedFiles, markFilesIntentToAdd, promptUser, parseCommentOptions, validateDiffArguments, getGitRoot, readStdin, } from './utils.js';
+import { createCommentCommand } from './comment.js';
 import { getPrPatch, getPrCommentImports } from './github.js';
 import { warnAboutTuiDeprecation } from './tuiDeprecation.js';
 function isSpecialArg(arg) {
@@ -48,27 +50,99 @@ function determineDiffMode(selection, compareWith) {
     // Default mode: HEAD^ vs HEAD or HEAD vs other commits (watch for HEAD changes)
     return DiffMode.DEFAULT;
 }
+async function startBackgroundProcess() {
+    const scriptPath = process.argv[1];
+    if (!scriptPath) {
+        throw new Error('Unable to determine difit entrypoint for background process');
+    }
+    const childArgs = process.argv.slice(2).filter((arg) => arg !== '--background');
+    if (!childArgs.includes('--keep-alive')) {
+        childArgs.push('--keep-alive');
+    }
+    if (!childArgs.includes('--no-open')) {
+        childArgs.push('--no-open');
+    }
+    const child = spawn(process.execPath, [scriptPath, ...childArgs], {
+        detached: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            [BACKGROUND_CHILD_ENV]: '1',
+        },
+    });
+    child.stdout.setEncoding('utf8');
+    child.stderr.setEncoding('utf8');
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            reject(new Error('Timed out while starting background difit server'));
+        }, 10_000);
+        let stderr = '';
+        let settled = false;
+        const finish = (callback) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            callback();
+        };
+        child.stdout.on('data', (chunk) => {
+            const line = chunk
+                .split(/\r?\n/u)
+                .map((value) => value.trim())
+                .find((value) => value.length > 0);
+            if (!line) {
+                return;
+            }
+            finish(() => {
+                console.log(line);
+                child.unref();
+                resolve();
+            });
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+        });
+        child.once('error', (error) => {
+            finish(() => {
+                reject(error);
+            });
+        });
+        child.once('exit', (code) => {
+            finish(() => {
+                const trimmedStderr = stderr.trim();
+                reject(new Error(trimmedStderr || `Background difit server exited early (code ${code ?? 'unknown'})`));
+            });
+        });
+    });
+}
+const BACKGROUND_CHILD_ENV = 'DIFIT_BACKGROUND_CHILD';
 const program = new Command();
 program
     .name('difit')
     .description('A lightweight Git diff viewer with GitHub-like interface')
     .version(pkg.version, '-v, --version', 'output the version number')
+    .enablePositionalOptions()
+    .addCommand(createCommentCommand())
     .argument('[commit-ish]', 'Git commit, tag, branch, HEAD~n reference, or "working"/"staged"/"."', 'HEAD')
     .argument('[compare-with]', 'Optional: Compare with this commit/branch (shows diff between commit-ish and compare-with)')
     .option('--port <port>', 'preferred port (auto-assigned if occupied)', parseInt)
     .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('--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('--background', 'keep the server running in the background and output JSON info')
     .option('--context <lines>', 'number of context lines shown around each change', parseInt)
     .option('--merge-base', 'resolve the base revision with git merge-base before diffing (Git revision mode only)')
     .action(async (commitish, compareWith, options) => {
     try {
+        const isBackgroundChild = process.env[BACKGROUND_CHILD_ENV] === '1';
+        const backgroundMode = options.background || isBackgroundChild;
         let stdinDiff;
         let stdinReviewLabel = 'diff from stdin';
         let manualCommentImports = [];
@@ -78,6 +152,10 @@ program
             console.error('Error: --context must be a non-negative integer');
             process.exit(1);
         }
+        if (options.background && !isBackgroundChild) {
+            await startBackgroundProcess();
+            return;
+        }
         try {
             manualCommentImports = parseCommentOptions(options.comment);
             commentImports = manualCommentImports;
@@ -86,6 +164,10 @@ program
             console.error(`Error: ${error instanceof Error ? error.message : 'Invalid --comment value'}`);
             process.exit(1);
         }
+        if (backgroundMode) {
+            options.keepAlive = true;
+            options.open = false;
+        }
         if (options.pr) {
             if (commitish !== 'HEAD' || compareWith) {
                 console.error('Error: --pr option cannot be used with positional arguments');
@@ -146,7 +228,7 @@ program
         }
         if (stdinDiff) {
             // Start server with stdin diff (including --pr patch)
-            const { url } = await startServer({
+            const { url, port } = await startServer({
                 stdinDiff,
                 preferredPort: options.port,
                 host: options.host,
@@ -156,6 +238,10 @@ program
                 keepAlive: options.keepAlive,
                 ...(commentImports.length > 0 ? { commentImports } : {}),
             });
+            if (backgroundMode) {
+                console.log(JSON.stringify({ port, url, pid: process.pid }));
+                return;
+            }
             console.log(`\n🚀 difit server started on ${url}`);
             console.log(`📋 Reviewing: ${stdinReviewLabel}`);
             if (options.keepAlive) {
@@ -180,9 +266,18 @@ program
         }
         if (selection.targetCommitish === 'working' || selection.targetCommitish === '.') {
             const git = simpleGit(repoPath);
-            await handleUntrackedFiles(git, options.includeUntracked);
+            if (isBackgroundChild && !options.includeUntracked) {
+                // Skip interactive prompts in detached background mode.
+            }
+            else {
+                await handleUntrackedFiles(git, options.includeUntracked);
+            }
         }
         if (options.tui) {
+            if (backgroundMode) {
+                console.error('Error: --background option cannot be used with --tui');
+                process.exit(1);
+            }
             if (commentImports.length > 0) {
                 console.error('Error: --comment option cannot be used with --tui');
                 process.exit(1);
@@ -223,6 +318,10 @@ program
             repoPath,
             ...(commentImports.length > 0 ? { commentImports } : {}),
         });
+        if (backgroundMode) {
+            console.log(JSON.stringify({ port, url, pid: process.pid }));
+            return;
+        }
         console.log(`\n🚀 difit server started on ${url}`);
         console.log(`📋 Reviewing: ${selection.targetCommitish}`);
         if (options.keepAlive) {
@@ -264,15 +363,7 @@ program
         process.exit(1);
     }
 });
-program.parse();
-// Check for untracked files and prompt user to add them for diff visibility
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
+void program.parseAsync();
 async function handleUntrackedFiles(git, addAutomatically) {
     const files = await findUntrackedFiles(git);
     if (files.length === 0) {

package/dist/cli/index.test.js

@@ -640,7 +640,7 @@ describe('CLI index.ts', () => {
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
                 .argument('[compare-with]', 'compare-with')
-                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--comment <json>', 'comment', (value, previous) => [...previous, value], [])
                 .option('--port <port>', 'port', parseInt)
                 .option('--host <host>', 'host', '')
                 .option('--no-open', 'no-open')
@@ -706,7 +706,7 @@ describe('CLI index.ts', () => {
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
                 .argument('[compare-with]', 'compare-with')
-                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--comment <json>', 'comment', (value, previous) => [...previous, value], [])
                 .option('--port <port>', 'port', parseInt)
                 .option('--host <host>', 'host', '')
                 .option('--no-open', 'no-open')
@@ -808,7 +808,7 @@ describe('CLI index.ts', () => {
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
-                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--comment <json>', 'comment', (value, previous) => [...previous, value], [])
                 .option('--port <port>', 'port', parseInt)
                 .option('--host <host>', 'host', '')
                 .option('--no-open', 'no-open')
@@ -853,7 +853,7 @@ describe('CLI index.ts', () => {
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
-                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--comment <json>', 'comment', (value, previous) => [...previous, value], [])
                 .option('--tui', 'tui')
                 .action(async (_commitish, options) => {
                 const commentImports = actualParseCommentOptions(options.comment);
@@ -874,7 +874,7 @@ describe('CLI index.ts', () => {
             const program = new Command();
             program
                 .argument('[commit-ish]', 'commit-ish', 'HEAD')
-                .option('--comment <json>', 'comment', (value, previous = []) => [...previous, value], [])
+                .option('--comment <json>', 'comment', (value, previous) => [...previous, value], [])
                 .action(async (_commitish, options) => {
                 try {
                     actualParseCommentOptions(options.comment);

package/dist/cli/utils.d.ts

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

package/dist/cli/utils.js

@@ -212,3 +212,10 @@ export async function waitForEnter(message) {
         rl.close();
     }
 }
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}