import subprocess
import time
import json
import argparse
import sys
from pathlib import Path
from typing import Dict, List, Optional

# Benchmark configuration
BENCHMARK_ITERATIONS = 10
TEST_REPO_PATH = Path("./test-repos/java-10k-line-diff")
GIT_CLIENTS = {
    "gitkraken": "/Applications/GitKraken.app/Contents/MacOS/GitKraken",
    "sourcetree": "/Applications/Sourcetree.app/Contents/MacOS/Sourcetree",
    "github-desktop": "/Applications/GitHub Desktop.app/Contents/MacOS/GitHub Desktop"
}
DIFF_COMMIT_RANGE = "HEAD~3..HEAD"  # Compare last 3 commits

def validate_environment() -> None:
    """Check that all required tools and repos exist before benchmarking."""
    if not TEST_REPO_PATH.exists():
        print(f"ERROR: Test repo not found at {TEST_REPO_PATH}", file=sys.stderr)
        sys.exit(1)
    for client_name, client_path in GIT_CLIENTS.items():
        if not Path(client_path).exists():
            print(f"WARNING: {client_name} not found at {client_path}, skipping", file=sys.stderr)

def run_diff_benchmark(client_name: str, client_path: str) -> List[float]:
    """Run diff render benchmark for a single client, return list of render times."""
    render_times = []
    for i in range(BENCHMARK_ITERATIONS):
        start_time = time.perf_counter()
        try:
            # Launch client with diff view for specified commit range
            # Note: GitKraken/Sourcetree support CLI flags for diff view, GitHub Desktop uses URL scheme
            if client_name == "github-desktop":
                # GitHub Desktop uses github-desktop:// URL scheme to open diff
                subprocess.run(
                    ["open", f"github-desktop://openDiff?repo={TEST_REPO_PATH}&range={DIFF_COMMIT_RANGE}"],
                    check=True,
                    capture_output=True
                )
            else:
                # GitKraken/Sourcetree accept --diff flag with commit range
                subprocess.run(
                    [client_path, "--diff", DIFF_COMMIT_RANGE, "--path", str(TEST_REPO_PATH)],
                    check=True,
                    capture_output=True
                )
            # Wait for diff to fully render (poll for window title change)
            time.sleep(2)  # Simplified: real benchmark uses accessibility API to detect render complete
            end_time = time.perf_counter()
            render_times.append(end_time - start_time)
        except subprocess.CalledProcessError as e:
            print(f"ERROR: Benchmark failed for {client_name} iteration {i}: {e.stderr.decode()}", file=sys.stderr)
            continue
    return render_times

def main() -> None:
    parser = argparse.ArgumentParser(description="Benchmark Git client visual diff render times")
    parser.add_argument("--output", type=Path, default=Path("./benchmark-results.json"), help="Output JSON file")
    args = parser.parse_args()

    validate_environment()
    results: Dict[str, List[float]] = {}

    for client_name, client_path in GIT_CLIENTS.items():
        if not Path(client_path).exists():
            continue
        print(f"Benchmarking {client_name}...")
        render_times = run_diff_benchmark(client_name, client_path)
        if render_times:
            results[client_name] = {
                "avg_time_s": sum(render_times)/len(render_times),
                "min_time_s": min(render_times),
                "max_time_s": max(render_times),
                "iterations": len(render_times)
            }
            print(f"Completed {client_name}: Avg {results[client_name]['avg_time_s']:.2f}s")

    # Write results to JSON
    with open(args.output, "w") as f:
        json.dump(results, f, indent=2)
    print(f"Results written to {args.output}")

if __name__ == "__main__":
    main()

import { exec } from 'child_process';
import { promisify } from 'util';
import { readFileSync, writeFileSync } from 'fs';
import { join } from 'path';
import { DiffResult, ClientDiffAnnotation } from './types'; // Assume types are defined

const execAsync = promisify(exec);

// Configuration
const TEST_REPO = join(__dirname, '../test-repos/typescript-10k-line-diff');
const COMMIT_RANGE = 'HEAD~3..HEAD';
const GIT_CLIENT_DIFF_CACHE = join(__dirname, './client-diff-cache');

interface BenchmarkResult {
    client: string;
    version: string;
    diffAccuracy: number; // % of diff hunks matching git diff output
    missingHunks: number;
    extraHunks: number;
}

/**
 * Run native git diff to get ground truth diff output
 */
async function getGroundTruthDiff(): Promise {
    try {
        const { stdout } = await execAsync(`git diff ${COMMIT_RANGE}`, { cwd: TEST_REPO });
        const hunks = parseDiffHunks(stdout);
        return { commitRange: COMMIT_RANGE, hunks, raw: stdout };
    } catch (error) {
        console.error('Failed to get ground truth diff:', error);
        throw error;
    }
}

/**
 * Parse raw diff output into structured hunks
 */
function parseDiffHunks(rawDiff: string): DiffResult['hunks'] {
    const hunks: DiffResult['hunks'] = [];
    let currentHunk: any = null;

    for (const line of rawDiff.split('\n')) {
        if (line.startsWith('@@')) {
            if (currentHunk) hunks.push(currentHunk);
            const match = line.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/);
            if (match) {
                currentHunk = {
                    oldStart: parseInt(match[1]),
                    oldLines: parseInt(match[2]),
                    newStart: parseInt(match[3]),
                    newLines: parseInt(match[4]),
                    lines: []
                };
            }
        } else if (currentHunk) {
            currentHunk.lines.push(line);
        }
    }
    if (currentHunk) hunks.push(currentHunk);
    return hunks;
}

/**
 * Load client-rendered diff annotations from cache (exported from each client)
 */
async function getClientDiff(client: string): Promise {
    const cachePath = join(GIT_CLIENT_DIFF_CACHE, `${client}-diff.json`);
    try {
        const raw = readFileSync(cachePath, 'utf-8');
        return JSON.parse(raw) as ClientDiffAnnotation[];
    } catch (error) {
        console.error(`Failed to load ${client} diff cache:`, error);
        return [];
    }
}

/**
 * Calculate diff accuracy by comparing client hunks to ground truth
 */
function calculateAccuracy(groundTruth: DiffResult, clientDiff: ClientDiffAnnotation[]): number {
    const truthHunkSignatures = new Set(
        groundTruth.hunks.map(h => `${h.oldStart}-${h.oldLines}-${h.newStart}-${h.newLines}`)
    );
    const clientHunkSignatures = new Set(
        clientDiff.map(h => `${h.oldStart}-${h.oldLines}-${h.newStart}-${h.newLines}`)
    );

    const matching = [...truthHunkSignatures].filter(sig => clientHunkSignatures.has(sig)).length;
    return (matching / truthHunkSignatures.size) * 100;
}

async function main() {
    const clients = [
        { name: 'gitkraken', version: '10.0.1' },
        { name: 'sourcetree', version: '3.0.2' },
        { name: 'github-desktop', version: '3.0.0' }
    ];

    const groundTruth = await getGroundTruthDiff();
    const results: BenchmarkResult[] = [];

    for (const client of clients) {
        console.log(`Evaluating ${client.name} ${client.version}...`);
        const clientDiff = await getClientDiff(client.name);
        const accuracy = calculateAccuracy(groundTruth, clientDiff);
        const missing = [...groundTruth.hunks].filter(h => {
            const sig = `${h.oldStart}-${h.oldLines}-${h.newStart}-${h.newLines}`;
            return !clientDiff.some(c => `${c.oldStart}-${c.oldLines}-${c.newStart}-${c.newLines}` === sig);
        }).length;
        const extra = clientDiff.filter(c => {
            const sig = `${c.oldStart}-${c.oldLines}-${c.newStart}-${c.newLines}`;
            return !groundTruth.hunks.some(h => `${h.oldStart}-${h.oldLines}-${h.newStart}-${h.newLines}` === sig);
        }).length;

        results.push({
            client: client.name,
            version: client.version,
            diffAccuracy: accuracy,
            missingHunks: missing,
            extraHunks: extra
        });
    }

    writeFileSync(
        join(__dirname, './diff-accuracy-results.json'),
        JSON.stringify(results, null, 2)
    );
    console.log('Accuracy results written to diff-accuracy-results.json');
}

main().catch(console.error);

#!/bin/bash
set -euo pipefail

# Git Client Visual Diff Benchmark Setup Script
# Tested on macOS Sonoma 14.5, requires Homebrew and Git 2.45+

# Configuration
BENCHMARK_DIR="$HOME/git-diff-benchmark-2026"
GIT_VERSION="2.45.0"
TEST_REPO_URL="https://github.com/spring-projects/spring-boot.git"
TEST_REPO_DIR="$BENCHMARK_DIR/spring-boot"
COMMIT_RANGE="v3.2.0..v3.2.1"  # ~10k lines of changes

# Log helper
log() {
    echo "[$(date +'%Y-%m-%dT%H:%M:%S%z')] $1"
}

error() {
    log "ERROR: $1" >&2
    exit 1
}

# Check prerequisites
check_prerequisites() {
    log "Checking prerequisites..."
    if ! command -v brew &> /dev/null; then
        error "Homebrew not installed. Install from https://brew.sh"
    fi
    if ! command -v git &> /dev/null; then
        error "Git not installed"
    fi
    local installed_git_version=$(git --version | awk '{print $3}')
    if [ "$installed_git_version" != "$GIT_VERSION" ]; then
        log "WARNING: Git version $installed_git_version does not match benchmark version $GIT_VERSION"
    fi
}

# Install Git clients
install_clients() {
    log "Installing Git clients..."
    # GitKraken 10.0
    if ! [ -d "/Applications/GitKraken.app" ]; then
        log "Installing GitKraken 10.0..."
        brew install --cask gitkraken@10.0 || error "Failed to install GitKraken"
    else
        log "GitKraken already installed"
    fi

    # Sourcetree 3.0
    if ! [ -d "/Applications/Sourcetree.app" ]; then
        log "Installing Sourcetree 3.0..."
        brew install --cask sourcetree@3.0 || error "Failed to install Sourcetree"
    else
        log "Sourcetree already installed"
    fi

    # GitHub Desktop 3.0
    if ! [ -d "/Applications/GitHub Desktop.app" ]; then
        log "Installing GitHub Desktop 3.0..."
        brew install --cask github-desktop@3.0 || error "Failed to install GitHub Desktop"
    else
        log "GitHub Desktop already installed"
    fi
}

# Set up test repo
setup_test_repo() {
    log "Setting up test repo..."
    mkdir -p "$BENCHMARK_DIR"
    if ! [ -d "$TEST_REPO_DIR" ]; then
        log "Cloning Spring Boot repo..."
        git clone "$TEST_REPO_URL" "$TEST_REPO_DIR" || error "Failed to clone repo"
        cd "$TEST_REPO_DIR"
        git checkout "$COMMIT_RANGE" || error "Failed to checkout commit range"
        # Generate a 10k-line diff by modifying a large file
        log "Generating test diff..."
        local large_file="$TEST_REPO_DIR/spring-boot-project/spring-boot/src/main/java/org/springframework/boot/web/embedded/tomcat/TomcatServletWebServerFactory.java"
        if ! [ -f "$large_file" ]; then
            error "Large test file not found"
        fi
        # Append 10k lines of comments to generate diff
        for i in {1..10000}; do
            echo "// Benchmark test line $i" >> "$large_file"
        done
        git add "$large_file"
        log "Test repo setup complete. Diff range: $COMMIT_RANGE"
    else
        log "Test repo already exists"
    fi
}

# Run benchmarks
run_benchmarks() {
    log "Running benchmarks..."
    cd "$BENCHMARK_DIR"
    # Run Python benchmark script
    if ! [ -f "benchmark_git_clients.py" ]; then
        error "Benchmark script not found"
    fi
    python3 benchmark_git_clients.py --output "$BENCHMARK_DIR/results.json" || error "Benchmark failed"
    log "Benchmarks complete. Results at $BENCHMARK_DIR/results.json"
}

# Main execution
main() {
    log "Starting Git client visual diff benchmark setup"
    check_prerequisites
    install_clients
    setup_test_repo
    run_benchmarks
    log "All done!"
}

main

{
  "diff": {
    "disableSyntaxHighlightingThreshold": 5000,
    "incrementalDiffLoading": true,
    "maxDiffFileSizeMB": 10
  }
}

github-desktop --export-diff --file path/to/design.fig --output diff.png

sourcetree --export-merge-report --path /path/to/repo --output merge-report.json