difit 1.1.0 → 1.1.1

package/README.md

@@ -18,59 +18,64 @@ A lightweight command-line tool that spins up a local web server to display Git
 - 🎨 **Syntax Highlighting**: Dynamic language loading for Bash, PHP, SQL, Ruby, Java, and more
 - ✨ **100% vibe coding**: Built with pure coding energy and good vibes
 
-## 📦 Installation
+## ⚡ Quick Start
 
 ```bash
-# use npx (no installation needed)
-npx reviewit <commit-ish>
-
-# or Global install
-npm install -g reviewit
+npx reviewit    # View HEAD commit changes in a beautiful diff viewer
 ```
 
 ## 🚀 Usage
 
+### Basic Usage
+
 ```bash
-# default: HEAD commit changes
-npx reviewit
+npx reviewit <commit-ish>                # View single commit diff
+npx reviewit <commit-ish> [compare-with] # Compare two commits/branches
+```
 
-# Review a specific commit changes
-npx reviewit 6f4a9b7
-npx reviewit HEAD^
-npx reviewit HEAD~3
+### Single commit review
 
-# Special Arguments
-npx reviewit staging  # staging area changes
-npx reviewit working  # working directory changes
-npx reviewit .        # uncommited all changes
+```bash
+npx reviewit 6f4a9b7  # Specific commit
+npx reviewit HEAD^    # Previous commit
+npx reviewit feature  # Latest commit on branch
+```
 
-# Custom port, don't auto-open browser
-npx reviewit 6f4a9b7 --port 4300 --no-open
+### Compare two commits
 
-# Terminal UI mode (no browser)
-npx reviewit --tui
-npx reviewit working --tui
+```bash
+npx reviewit HEAD main      # Compare HEAD with main branch
+npx reviewit feature main   # Compare branches
+npx reviewit . origin/main  # Compare working directory with remote main
 ```
 
-### ⚙️ CLI Options
+### Special Arguments
 
-| Flag           | Default      | Description                                                        |
-| -------------- | ------------ | ------------------------------------------------------------------ |
-| `<commit-ish>` | (required)   | Any Git reference: hash, tag, HEAD~n, branch, or Special Arguments |
-| `--port`       | auto         | Preferred port; falls back if occupied                             |
-| `--no-open`    | false        | Don't automatically open browser                                   |
-| `--mode`       | side-by-side | Diff mode: `inline` or `side-by-side`                              |
-| `--tui`        | false        | Use terminal UI mode instead of web interface                      |
+ReviewIt supports special keywords for common diff scenarios:
 
-### 🔑 Special Arguments
+```bash
+npx reviewit          # HEAD commit changes
+npx reviewit .        # All uncommitted changes (staged + unstaged)
+npx reviewit staged   # Staged changes ready for commit
+npx reviewit working  # Unstaged changes only (cannot use compare-with)
+```
 
-ReviewIt supports special arguments for common diff scenarios:
+| Keyword   | Description                                            | Compare-with Support |
+| --------- | ------------------------------------------------------ | -------------------- |
+| `.`       | Shows all uncommitted changes (both staged & unstaged) | ✅ Yes               |
+| `staged`  | Shows staged changes ready to be committed             | ✅ Yes               |
+| `working` | Shows unstaged changes in your working directory       | ❌ No                |
+
+### ⚙️ CLI Options
 
-| Keyword   | Description                                            |
-| --------- | ------------------------------------------------------ |
-| `working` | Shows unstaged changes in your working directory       |
-| `staged`  | Shows staged changes ready to be committed             |
-| `.`       | Shows all uncommitted changes (both staged & unstaged) |
+| Flag             | Default      | Description                                                         |
+| ---------------- | ------------ | ------------------------------------------------------------------- |
+| `<commit-ish>`   | HEAD         | Any Git reference: hash, tag, HEAD~n, branch, or Special Arguments  |
+| `[compare-with]` | (optional)   | Optional second commit to compare with (shows diff between the two) |
+| `--port`         | auto         | Preferred port; falls back if occupied                              |
+| `--no-open`      | false        | Don't automatically open browser                                    |
+| `--mode`         | side-by-side | Diff mode: `inline` or `side-by-side`                               |
+| `--tui`          | false        | Use terminal UI mode instead of web interface                       |
 
 ## 💬 Comment System
 
@@ -118,15 +123,10 @@ pnpm install
 
 # Start development server (with hot reload)
 # This runs both Vite dev server and CLI with NODE_ENV=development
-pnpm run dev                    # defaults to HEAD
-pnpm run dev HEAD~3            # review HEAD~3
-pnpm run dev main              # review main branch
-
-# For development CLI only (connects to separate Vite server)
-pnpm run dev:cli <commit-ish>
+pnpm run dev
 
 # Build and start production server
-pnpm run start HEAD
+pnpm run start <commit-ish>
 
 # Build for production
 pnpm run build
@@ -143,20 +143,27 @@ pnpm run typecheck
 ### Development Workflow
 
 - **`pnpm run dev`**: Starts both Vite dev server (with hot reload) and CLI server simultaneously
-- **`pnpm run start <commit>`**: Builds everything and starts production server (for testing final build)
+- **`pnpm run start <commit-ish>`**: Builds everything and starts production server (for testing final build)
 - **Development mode**: Uses Vite's dev server for hot reload and fast development
 - **Production mode**: Serves built static files (used by npx and production builds)
 
 ## 🏗️ Architecture
 
-- **CLI**: Commander.js for argument parsing
+- **CLI**: Commander.js for argument parsing with comprehensive validation
 - **Backend**: Express server with simple-git for diff processing
 - **Frontend**: React 18 + TypeScript + Vite
 - **Styling**: Tailwind CSS v4 with GitHub-like dark theme
 - **Syntax Highlighting**: Prism.js with dynamic language loading
-- **Testing**: Vitest for unit tests
+- **Testing**: Vitest for unit tests with co-located test files
 - **Quality**: ESLint, Prettier, lefthook pre-commit hooks
 
+### Key Components
+
+- **Validation System**: Unified validation logic for CLI arguments with comprehensive error handling
+- **Dual Parameter System**: Internal refactoring splits commitish into targetCommitish and baseCommitish for flexibility
+- **Special Argument Support**: Working directory, staging area, and uncommitted changes detection
+- **Hash Utilities**: Consistent short hash generation for commit display
+
 ## 📋 Requirements
 
 - Node.js ≥ 18.0.0

package/dist/cli/index.js

@@ -3,30 +3,38 @@ import { Command } from 'commander';
 import React from 'react';
 import pkg from '../../package.json' with { type: 'json' };
 import { startServer } from '../server/server.js';
-import { validateCommitish } from './utils.js';
+import { validateDiffArguments } from './utils.js';
+function isSpecialArg(arg) {
+    return arg === 'working' || arg === 'staged' || arg === '.';
+}
 const program = new Command();
 program
     .name('reviewit')
     .description('A lightweight Git diff viewer with GitHub-like interface')
     .version(pkg.version)
     .argument('[commit-ish]', 'Git commit, tag, branch, HEAD~n reference, or "working"/"staged"/"." (default: HEAD)', '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('--no-open', 'do not automatically open browser')
     .option('--mode <mode>', 'diff mode (inline only for now)', 'inline')
     .option('--tui', 'use terminal UI instead of web interface')
-    .action(async (commitish, options) => {
+    .action(async (commitish, compareWith, options) => {
     try {
-        // Determine what to show
+        // Determine target and base commitish
         let targetCommitish = commitish;
-        // Handle special arguments
-        if (commitish === 'working') {
-            targetCommitish = 'working';
+        let baseCommitish;
+        if (compareWith) {
+            // If compareWith is provided, use it as base
+            baseCommitish = compareWith;
         }
-        else if (commitish === 'staged') {
-            targetCommitish = 'staged';
-        }
-        else if (commitish === '.') {
-            targetCommitish = '.';
+        else {
+            // Handle special arguments
+            if (isSpecialArg(commitish)) {
+                baseCommitish = 'HEAD';
+            }
+            else {
+                baseCommitish = commitish + '^';
+            }
         }
         if (options.tui) {
             // Check if we're in a TTY environment
@@ -38,15 +46,17 @@ program
             // Dynamic import for TUI mode
             const { render } = await import('ink');
             const { default: TuiApp } = await import('../tui/App.js');
-            render(React.createElement(TuiApp, { commitish: targetCommitish }));
+            render(React.createElement(TuiApp, { targetCommitish, baseCommitish }));
             return;
         }
-        if (!validateCommitish(targetCommitish)) {
-            console.error('Error: Invalid commit-ish format');
+        const validation = validateDiffArguments(targetCommitish, compareWith);
+        if (!validation.valid) {
+            console.error(`Error: ${validation.error}`);
             process.exit(1);
         }
         const { url } = await startServer({
-            commitish: targetCommitish,
+            targetCommitish,
+            baseCommitish,
             preferredPort: options.port,
             openBrowser: options.open,
             mode: options.mode,

package/dist/cli/utils.d.ts

@@ -1 +1,6 @@
 export declare function validateCommitish(commitish: string): boolean;
+export declare function shortHash(hash: string): string;
+export declare function validateDiffArguments(targetCommitish: string, baseCommitish?: string): {
+    valid: boolean;
+    error?: string;
+};

package/dist/cli/utils.js

@@ -20,3 +20,36 @@ export function validateCommitish(commitish) {
     ];
     return validPatterns.some((pattern) => pattern.test(trimmed));
 }
+export function shortHash(hash) {
+    return hash.substring(0, 7);
+}
+export function validateDiffArguments(targetCommitish, baseCommitish) {
+    // Validate target commitish format
+    if (!validateCommitish(targetCommitish)) {
+        return { valid: false, error: 'Invalid target commit-ish format' };
+    }
+    // Validate base commitish format if provided
+    if (baseCommitish !== undefined && !validateCommitish(baseCommitish)) {
+        return { valid: false, error: 'Invalid base commit-ish format' };
+    }
+    // Special arguments are only allowed in target, not base
+    const specialArgs = ['working', 'staged', '.'];
+    if (baseCommitish && specialArgs.includes(baseCommitish)) {
+        return {
+            valid: false,
+            error: `Special arguments (working, staged, .) are only allowed as target, not base. Got base: ${baseCommitish}`,
+        };
+    }
+    // Cannot compare same values
+    if (targetCommitish === baseCommitish) {
+        return { valid: false, error: `Cannot compare ${targetCommitish} with itself` };
+    }
+    // "working" shows unstaged changes and cannot be compared with another commit
+    if (targetCommitish === 'working' && baseCommitish) {
+        return {
+            valid: false,
+            error: '"working" shows unstaged changes and cannot be compared with another commit. Use "." instead to compare all uncommitted changes with a specific commit.',
+        };
+    }
+    return { valid: true };
+}

package/dist/cli/utils.test.js

@@ -1,23 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import { validateCommitish, validateDiffArguments, shortHash, parseGitHubPrUrl } from './utils';
+import { validateCommitish, validateDiffArguments, shortHash } from './utils';
 describe('CLI Utils', () => {
     describe('validateCommitish', () => {
         it('should validate full SHA hashes', () => {
             expect(validateCommitish('a1b2c3d4e5f6789012345678901234567890abcd')).toBe(true);
             expect(validateCommitish('abc123')).toBe(true);
         });
-        it('should validate SHA hashes with parent references', () => {
-            expect(validateCommitish('a1b2c3d4e5f6789012345678901234567890abcd^')).toBe(true);
-            expect(validateCommitish('abc123^')).toBe(true);
-            expect(validateCommitish('abc123^^')).toBe(true);
-            expect(validateCommitish('bd4b7513e075b5b245284c38fd23427b9bd0f42e^')).toBe(true);
-        });
-        it('should validate SHA hashes with ancestor references', () => {
-            expect(validateCommitish('a1b2c3d4e5f6789012345678901234567890abcd~1')).toBe(true);
-            expect(validateCommitish('abc123~5')).toBe(true);
-            expect(validateCommitish('abc123~10')).toBe(true);
-            expect(validateCommitish('bd4b7513e075b5b245284c38fd23427b9bd0f42e~2')).toBe(true);
-        });
         it('should validate HEAD references', () => {
             expect(validateCommitish('HEAD')).toBe(true);
             expect(validateCommitish('HEAD~1')).toBe(true);
@@ -85,12 +73,6 @@ describe('CLI Utils', () => {
                 expect(validateDiffArguments('staged', 'HEAD')).toEqual({ valid: true });
                 expect(validateDiffArguments('.', 'main')).toEqual({ valid: true });
             });
-            it('should allow staged as base only with working target', () => {
-                expect(validateDiffArguments('working', 'staged')).toEqual({ valid: true });
-                const result = validateDiffArguments('HEAD', 'staged');
-                expect(result.valid).toBe(false);
-                expect(result.error).toBe('Special arguments (working, staged, .) are only allowed as target, not base. Got base: staged');
-            });
         });
         describe('same value comparison', () => {
             it('should reject same target and base values', () => {
@@ -115,17 +97,6 @@ describe('CLI Utils', () => {
             it('should allow working without compareWith', () => {
                 expect(validateDiffArguments('working')).toEqual({ valid: true });
             });
-            it('should allow working with staged', () => {
-                expect(validateDiffArguments('working', 'staged')).toEqual({ valid: true });
-            });
-            it('should reject working with other commits', () => {
-                const result1 = validateDiffArguments('working', 'main');
-                expect(result1.valid).toBe(false);
-                expect(result1.error).toBe('"working" shows unstaged changes and cannot be compared with another commit. Use "." instead to compare all uncommitted changes with a specific commit.');
-                const result2 = validateDiffArguments('working', 'abc123');
-                expect(result2.valid).toBe(false);
-                expect(result2.error).toBe('"working" shows unstaged changes and cannot be compared with another commit. Use "." instead to compare all uncommitted changes with a specific commit.');
-            });
             it('should allow other special args with compareWith', () => {
                 expect(validateDiffArguments('staged', 'HEAD')).toEqual({ valid: true });
                 expect(validateDiffArguments('.', 'main')).toEqual({ valid: true });
@@ -143,14 +114,6 @@ describe('CLI Utils', () => {
                     valid: true,
                 });
             });
-            it('should handle SHA hashes with parent/ancestor references', () => {
-                expect(validateDiffArguments('bd4b7513e075b5b245284c38fd23427b9bd0f42e^', 'abc123')).toEqual({ valid: true });
-                expect(validateDiffArguments('abc123', 'def456^')).toEqual({ valid: true });
-                expect(validateDiffArguments('abc123~1', 'def456~2')).toEqual({ valid: true });
-                expect(validateDiffArguments('a1b2c3d4e5f6789012345678901234567890abcd^', 'HEAD')).toEqual({
-                    valid: true,
-                });
-            });
         });
     });
     describe('shortHash', () => {
@@ -164,51 +127,4 @@ describe('CLI Utils', () => {
             expect(shortHash('')).toBe('');
         });
     });
-    describe('parseGitHubPrUrl', () => {
-        it('should parse valid GitHub PR URLs', () => {
-            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/123');
-            expect(result).toEqual({
-                owner: 'owner',
-                repo: 'repo',
-                pullNumber: 123,
-            });
-        });
-        it('should parse GitHub PR URLs with additional path segments', () => {
-            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/456/files');
-            expect(result).toEqual({
-                owner: 'owner',
-                repo: 'repo',
-                pullNumber: 456,
-            });
-        });
-        it('should parse GitHub PR URLs with query parameters', () => {
-            const result = parseGitHubPrUrl('https://github.com/owner/repo/pull/789?tab=files');
-            expect(result).toEqual({
-                owner: 'owner',
-                repo: 'repo',
-                pullNumber: 789,
-            });
-        });
-        it('should handle URLs with hyphens and underscores in owner/repo names', () => {
-            const result = parseGitHubPrUrl('https://github.com/owner-name/repo_name/pull/123');
-            expect(result).toEqual({
-                owner: 'owner-name',
-                repo: 'repo_name',
-                pullNumber: 123,
-            });
-        });
-        it('should return null for invalid URLs', () => {
-            expect(parseGitHubPrUrl('not-a-url')).toBe(null);
-            expect(parseGitHubPrUrl('https://example.com/owner/repo/pull/123')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com/owner/repo/issues/123')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com/owner/repo')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com/owner/repo/pull/abc')).toBe(null);
-        });
-        it('should handle malformed URLs gracefully', () => {
-            expect(parseGitHubPrUrl('')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com/owner')).toBe(null);
-            expect(parseGitHubPrUrl('https://github.com/owner/repo/pull')).toBe(null);
-        });
-    });
 });

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

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

package/dist/server/git-diff-tui.js

@@ -1,25 +1,32 @@
 import simpleGit from 'simple-git';
-export async function loadGitDiff(commitish) {
+import { validateDiffArguments } from '../cli/utils.js';
+export async function loadGitDiff(targetCommitish, baseCommitish) {
+    // Validate arguments
+    const validation = validateDiffArguments(targetCommitish, baseCommitish);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
     const git = simpleGit();
     let diff;
-    if (commitish.toLowerCase() === 'working') {
-        // Show uncommitted changes
+    // Handle target special chars (base is always a regular commit)
+    if (targetCommitish === 'working') {
+        // Show unstaged changes (working vs staged)
         diff = await git.diff(['--name-status']);
     }
-    else if (commitish.toLowerCase() === 'staged') {
-        // Show staged changes
-        diff = await git.diff(['--cached', '--name-status']);
+    else if (targetCommitish === 'staged') {
+        // Show staged changes against base commit
+        diff = await git.diff(['--cached', baseCommitish, '--name-status']);
     }
-    else if (commitish === '.') {
-        // Show all changes (both staged and unstaged) compared to HEAD
-        diff = await git.diff(['HEAD', '--name-status']);
+    else if (targetCommitish === '.') {
+        // Show all uncommitted changes against base commit
+        diff = await git.diff([baseCommitish, '--name-status']);
     }
     else {
-        // Get list of changed files for a specific commit
-        diff = await git.diff([`${commitish}^..${commitish}`, '--name-status']);
+        // Both are regular commits: standard commit-to-commit comparison
+        diff = await git.diff([`${baseCommitish}..${targetCommitish}`, '--name-status']);
         if (!diff.trim()) {
             // Try without parent (for initial commit)
-            const diffInitial = await git.diff([commitish, '--name-status']);
+            const diffInitial = await git.diff([targetCommitish, '--name-status']);
             if (!diffInitial.trim()) {
                 throw new Error('No changes found in this commit');
             }
@@ -37,26 +44,27 @@ export async function loadGitDiff(commitish) {
     // Get diff for each file individually
     const fileDiffs = await Promise.all(fileChanges.map(async ({ status, path }) => {
         let fileDiff = '';
-        if (commitish.toLowerCase() === 'working') {
-            // Get unstaged changes
+        // Handle individual file diffs (base is always a regular commit)
+        if (targetCommitish === 'working') {
+            // Show unstaged changes (working vs staged)
             fileDiff = await git.diff(['--', path]);
         }
-        else if (commitish.toLowerCase() === 'staged') {
-            // Get staged changes
-            fileDiff = await git.diff(['--cached', '--', path]);
+        else if (targetCommitish === 'staged') {
+            // Show staged changes against base commit
+            fileDiff = await git.diff(['--cached', baseCommitish, '--', path]);
         }
-        else if (commitish === '.') {
-            // Get all changes (both staged and unstaged) compared to HEAD
-            fileDiff = await git.diff(['HEAD', '--', path]);
+        else if (targetCommitish === '.') {
+            // Show all uncommitted changes against base commit
+            fileDiff = await git.diff([baseCommitish, '--', path]);
         }
         else {
             try {
-                // Get diff for specific file in commit
-                fileDiff = await git.diff([`${commitish}^..${commitish}`, '--', path]);
+                // Both are regular commits: standard commit-to-commit comparison
+                fileDiff = await git.diff([`${baseCommitish}..${targetCommitish}`, '--', path]);
             }
             catch {
                 // For new files or if parent doesn't exist
-                fileDiff = await git.diff([commitish, '--', path]);
+                fileDiff = await git.diff([targetCommitish, '--', path]);
             }
         }
         const lines = fileDiff.split('\n');

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

@@ -2,7 +2,7 @@ import { type DiffResponse } from '../types/diff.js';
 export declare class GitDiffParser {
     private git;
     constructor(repoPath?: string);
-    parseDiff(commitish: string, ignoreWhitespace?: boolean): Promise<DiffResponse>;
+    parseDiff(targetCommitish: string, baseCommitish: string, ignoreWhitespace?: boolean): Promise<DiffResponse>;
     private parseUnifiedDiff;
     private parseFileBlock;
     private parseChunks;

package/dist/server/git-diff.js

@@ -1,35 +1,42 @@
 import { simpleGit } from 'simple-git';
+import { validateDiffArguments, shortHash } from '../cli/utils.js';
 export class GitDiffParser {
     constructor(repoPath = process.cwd()) {
         this.git = simpleGit(repoPath);
     }
-    async parseDiff(commitish, ignoreWhitespace = false) {
+    async parseDiff(targetCommitish, baseCommitish, ignoreWhitespace = false) {
         try {
+            // Validate arguments
+            const validation = validateDiffArguments(targetCommitish, baseCommitish);
+            if (!validation.valid) {
+                throw new Error(validation.error);
+            }
             let resolvedCommit;
             let diffArgs;
-            if (commitish === '.') {
-                // Show diff between HEAD and working directory (all uncommitted changes)
-                resolvedCommit = 'Working Directory (all uncommitted changes)';
-                diffArgs = ['HEAD'];
-            }
-            else if (commitish === 'working') {
-                // Show only unstaged changes
+            // Handle target special chars (base is always a regular commit)
+            if (targetCommitish === 'working') {
+                // Show unstaged changes (working vs staged)
                 resolvedCommit = 'Working Directory (unstaged changes)';
                 diffArgs = [];
             }
-            else if (commitish === 'staged') {
-                // Show only staged changes
-                resolvedCommit = 'Staging Area (staged changes)';
-                diffArgs = ['--cached'];
+            else if (targetCommitish === 'staged') {
+                // Show staged changes against base commit
+                const baseHash = await this.git.revparse([baseCommitish]);
+                resolvedCommit = `${shortHash(baseHash)} vs Staging Area (staged changes)`;
+                diffArgs = ['--cached', baseCommitish];
+            }
+            else if (targetCommitish === '.') {
+                // Show all uncommitted changes against base commit
+                const baseHash = await this.git.revparse([baseCommitish]);
+                resolvedCommit = `${shortHash(baseHash)} vs Working Directory (all uncommitted changes)`;
+                diffArgs = [baseCommitish];
             }
             else {
-                // Resolve commitish to actual commit hash and get short version
-                const fullHash = await this.git.revparse([commitish]);
-                const shortHash = fullHash.substring(0, 7);
-                const parentHash = await this.git.revparse([`${commitish}^`]);
-                const shortParentHash = parentHash.substring(0, 7);
-                resolvedCommit = `${shortParentHash}..${shortHash}`;
-                diffArgs = [`${commitish}^`, commitish];
+                // Both are regular commits: standard commit-to-commit comparison
+                const targetHash = await this.git.revparse([targetCommitish]);
+                const baseHash = await this.git.revparse([baseCommitish]);
+                resolvedCommit = `${shortHash(baseHash)}..${shortHash(targetHash)}`;
+                diffArgs = [baseCommitish, targetCommitish];
             }
             if (ignoreWhitespace) {
                 diffArgs.push('-w');
@@ -44,7 +51,7 @@ export class GitDiffParser {
             };
         }
         catch (error) {
-            throw new Error(`Failed to parse diff for ${commitish}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to parse diff for ${targetCommitish} vs ${baseCommitish}: ${error instanceof Error ? error.message : 'Unknown error'}`);
         }
     }
     parseUnifiedDiff(diffText, summary) {

package/dist/server/server.d.ts

@@ -1,5 +1,6 @@
 interface ServerOptions {
-    commitish: string;
+    targetCommitish: string;
+    baseCommitish: string;
     preferredPort?: number;
     openBrowser?: boolean;
     mode?: string;

package/dist/server/server.js

@@ -17,16 +17,16 @@ export async function startServer(options) {
         res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept');
         next();
     });
-    const isValidCommit = await parser.validateCommit(options.commitish);
+    const isValidCommit = await parser.validateCommit(options.targetCommitish);
     if (!isValidCommit) {
-        throw new Error(`Invalid or non-existent commit: ${options.commitish}`);
+        throw new Error(`Invalid or non-existent commit: ${options.targetCommitish}`);
     }
-    diffData = await parser.parseDiff(options.commitish, currentIgnoreWhitespace);
+    diffData = await parser.parseDiff(options.targetCommitish, options.baseCommitish, currentIgnoreWhitespace);
     app.get('/api/diff', async (req, res) => {
         const ignoreWhitespace = req.query.ignoreWhitespace === 'true';
         if (ignoreWhitespace !== currentIgnoreWhitespace) {
             currentIgnoreWhitespace = ignoreWhitespace;
-            diffData = await parser.parseDiff(options.commitish, ignoreWhitespace);
+            diffData = await parser.parseDiff(options.targetCommitish, options.baseCommitish, ignoreWhitespace);
         }
         res.json({ ...diffData, ignoreWhitespace });
     });

package/dist/tui/App.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 interface AppProps {
-    commitish: string;
+    targetCommitish: string;
+    baseCommitish: string;
 }
 declare const App: React.FC<AppProps>;
 export default App;

package/dist/tui/App.js

@@ -5,7 +5,7 @@ import FileList from './components/FileList.js';
 import DiffViewer from './components/DiffViewer.js';
 import SideBySideDiffViewer from './components/SideBySideDiffViewer.js';
 import StatusBar from './components/StatusBar.js';
-const App = ({ commitish }) => {
+const App = ({ targetCommitish, baseCommitish }) => {
     const [files, setFiles] = useState([]);
     const [selectedFileIndex, setSelectedFileIndex] = useState(0);
     const [loading, setLoading] = useState(true);
@@ -16,7 +16,7 @@ const App = ({ commitish }) => {
         setLoading(true);
         setError(null);
         try {
-            const fileDiffs = await loadGitDiff(commitish);
+            const fileDiffs = await loadGitDiff(targetCommitish, baseCommitish);
             setFiles(fileDiffs);
             setLoading(false);
         }
@@ -28,7 +28,7 @@ const App = ({ commitish }) => {
     useEffect(() => {
         loadDiff();
         // eslint-disable-next-line react-hooks/exhaustive-deps
-    }, [commitish]);
+    }, [targetCommitish, baseCommitish]);
     useInput((input, key) => {
         if (input === 'q' || (key.ctrl && input === 'c')) {
             exit();
@@ -61,7 +61,7 @@ const App = ({ commitish }) => {
     if (loading) {
         return React.createElement(Text, null,
             "Loading diff for ",
-            commitish,
+            targetCommitish,
             "...");
     }
     if (error) {
@@ -71,16 +71,16 @@ const App = ({ commitish }) => {
     }
     if (files.length === 0) {
         return (React.createElement(Box, { flexDirection: "column" },
-            React.createElement(StatusBar, { commitish: commitish, totalFiles: 0, currentMode: "list" }),
+            React.createElement(StatusBar, { commitish: targetCommitish, totalFiles: 0, currentMode: "list" }),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: "yellow" },
                     "No changes found for ",
-                    commitish)),
+                    targetCommitish)),
             React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { dimColor: true }, "Press 'q' to quit"))));
     }
     return (React.createElement(Box, { flexDirection: "column", height: process.stdout.rows },
-        React.createElement(StatusBar, { commitish: commitish, totalFiles: files.length, currentMode: viewMode }),
+        React.createElement(StatusBar, { commitish: targetCommitish, totalFiles: files.length, currentMode: viewMode }),
         React.createElement(Box, { flexGrow: 1, flexDirection: "column" }, viewMode === 'list' ? (React.createElement(FileList, { files: files, selectedIndex: selectedFileIndex })) : viewMode === 'side-by-side' ? (React.createElement(SideBySideDiffViewer, { files: files, initialFileIndex: selectedFileIndex, onBack: () => setViewMode('list') })) : (React.createElement(DiffViewer, { files: files, initialFileIndex: selectedFileIndex, onBack: () => setViewMode('list') }))),
         React.createElement(Box, { borderStyle: "single", paddingX: 1 },
             React.createElement(Text, { dimColor: true }, viewMode === 'list'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "difit",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A lightweight command-line tool that spins up a local web server to display Git commit diffs in a GitHub-like Files changed view",
   "type": "module",
   "engines": {
@@ -21,17 +21,17 @@
   "scripts": {
     "dev": "node scripts/dev.js",
     "dev:cli": "tsc --project tsconfig.cli.json && NODE_ENV=development node dist/cli/index.js",
-    "build": "pnpm run build:cli && tsc && vite build",
+    "build": "tsc -b && vite build",
     "build:cli": "tsc --project tsconfig.cli.json",
-    "start": "pnpm run build && pnpm run build:cli && node dist/cli/index.js",
+    "start": "pnpm run build && node dist/cli/index.js",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write .",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc -b",
     "test": "vitest run",
     "test:watch": "vitest",
     "prepare": "lefthook install",
-    "prepublishOnly": "NODE_ENV=production pnpm run build && pnpm run build:cli"
+    "prepublishOnly": "NODE_ENV=production pnpm run build"
   },
   "dependencies": {
     "commander": "^11.1.0",