Function handleWorkTreeDiffPatch

projects/electron/src/modules/code/git.ts:747–818

* Generate diff patch for worktree against a specific commit (supports subdirectories) * Diffs against the working tree (includes uncommitted changes) * Excludes binary files and truncates large patches

(params: WorkTreeDiffPatchParams)

 * Excludes binary files and truncates large patches
 */
async function handleWorkTreeDiffPatch(params: WorkTreeDiffPatchParams): Promise<WorkTreeDiffPatchResponse> {
    const startTime = Date.now()
    logger.info("[Git:workTreeDiffPatch] Generating diff patch", JSON.stringify({
        repoDir: params.repoDir,
        workTreeId: params.workTreeId,
        compareToCommit: params.compareToCommit,
    }))

    try {
        validateRepoDir(params.repoDir)
        validateWorkTreeId(params.workTreeId)

        // Resolve git info (handles subdirectories)
        const { repoRoot } = await resolveGitInfo(params.repoDir)

        const worktreePath = getWorktreePath(params.workTreeId)
        logger.info("[Git:workTreeDiffPatch] Worktree path resolved", JSON.stringify({ worktreePath, exists: fs.existsSync(worktreePath) }))

        // Validate worktree exists
        if (!fs.existsSync(worktreePath)) {
            throw new Error(`Worktree does not exist: ${worktreePath}`)
        }

        // Validate worktree is in git's list using repo root
        const listResult = await execGit(["worktree", "list", "--porcelain"], repoRoot)
        if (listResult.success) {
            const worktrees = parseWorktreeList(listResult.stdout)
            const exists = worktrees.some((wt) => wt.path === worktreePath)
            if (!exists) {
                throw new Error(`Worktree not registered in git: ${worktreePath}`)
            }
        }

        // Verify the commit exists and is accessible
        const verifyResult = await execGit(["cat-file", "-t", params.compareToCommit], worktreePath)
        logger.info("[Git:workTreeDiffPatch] Verified commit", JSON.stringify({
            commit: params.compareToCommit,
            exists: verifyResult.success,
            type: verifyResult.stdout.trim(),
            stderr: verifyResult.stderr,
        }))

        if (!verifyResult.success) {
            throw new Error(`Commit not accessible in worktree: ${params.compareToCommit}`)
        }

        // Generate diff patch against working tree (includes uncommitted changes)
        // Using just "git diff <commit>" diffs the commit against the working tree
        // By default, git diff shows "Binary files differ" for binary files without content
        const diffArgs = ["diff", params.compareToCommit]
        logger.info("[Git:workTreeDiffPatch] Running git diff", JSON.stringify({ args: diffArgs, cwd: worktreePath }))
        const diffResult = await execGit(diffArgs, worktreePath)

        if (!diffResult.success) {
            logger.error("[Git:workTreeDiffPatch] Git diff failed", JSON.stringify({ stderr: diffResult.stderr, args: diffArgs }))
            throw new Error(`Failed to generate diff: ${diffResult.stderr}`)
        }