Refactor checkpoint restoration to use temporary git clones for applying diffs instead of relying on direct workspace git operations, and remove the unused apply_git_diff utility

Author: robertpiosik

packages/vscode/src/commands/apply-chat-response-command/utils/clipboard-parser/test-cases/text-between/1-text.txt

@@ -1 +1,10 @@
-Top. `top.ts`
+I have removed all comments from the provided files.
+
+The changes are:
+
+1.  **`daemon.ts`**: Removed numerous inline comments explaining steps like API calls, file downloads, directory preparation, and cleanup.
+2.  **`src/index.ts`**: Removed the comment explaining the aspect ratio check.
+3.  **`src/tasks/clean-from-people.ts`**: Removed the comment describing the file movement logic after running the tourist filter script.
+4.  **`src/tasks/stitch-dslr-images.ts`**: Removed comments explaining the purpose of checking for `project.pto` and the logic for replacing image path placeholders within the `.pto` file content.
+
+Here are the updated files:

packages/vscode/src/commands/apply-chat-response-command/utils/clipboard-parser/test-cases/text-between/text-between.txt

@@ -1,4 +1,13 @@
-Top. `top.ts`
+I have removed all comments from the provided files.
+
+The changes are:
+
+1.  **`daemon.ts`**: Removed numerous inline comments explaining steps like API calls, file downloads, directory preparation, and cleanup.
+2.  **`src/index.ts`**: Removed the comment explaining the aspect ratio check.
+3.  **`src/tasks/clean-from-people.ts`**: Removed the comment describing the file movement logic after running the tourist filter script.
+4.  **`src/tasks/stitch-dslr-images.ts`**: Removed comments explaining the purpose of checking for `project.pto` and the logic for replacing image path placeholders within the `.pto` file content.
+
+Here are the updated files:
 
 ```ts
 // src/lorem.ts

packages/vscode/src/commands/checkpoints-command/actions/restore-checkpoint.ts

@@ -1,4 +1,7 @@
 import * as vscode from 'vscode'
+import * as path from 'path'
+import * as os from 'os'
+import { execSync } from 'child_process'
 import { TEMPORARY_CHECKPOINT_STATE_KEY } from '../../../constants/state-keys'
 import { WorkspaceProvider } from '../../../context/providers/workspace-provider'
 import type { Checkpoint } from '../types'
@@ -8,8 +11,6 @@ import { delete_checkpoint } from './delete-checkpoint'
 import { get_checkpoints } from './get-checkpoints'
 import { sync_workspace_from_dir } from './sync-workspace-from-dir'
 import { get_checkpoint_path, sync_directory } from '../utils'
-import { apply_git_diff } from '../utils/git-utils'
-import * as path from 'path'
 import { Logger } from '@shared/utils/logger'
 import { PanelProvider } from '@/views/panel/backend/panel-provider'
 import { response_preview_promise_resolve } from '../../apply-chat-response-command/utils/preview'
@@ -22,6 +23,23 @@ export const restore_checkpoint = async (params: {
   panel_provider: PanelProvider
   options?: { skip_confirmation?: boolean }
 }) => {
+  const tab_groups = vscode.window.tabGroups.all
+  const open_files: {
+    uri: vscode.Uri
+    viewColumn: vscode.ViewColumn
+    isActive: boolean
+  }[] = []
+  for (const group of tab_groups) {
+    for (const tab of group.tabs) {
+      if (tab.input instanceof vscode.TabInputText) {
+        open_files.push({
+          uri: (tab.input as vscode.TabInputText).uri,
+          viewColumn: group.viewColumn,
+          isActive: tab.isActive && group.isActive
+        })
+      }
+    }
+  }
   let temp_checkpoint: Checkpoint | undefined
   try {
     if (response_preview_promise_resolve) {
@@ -106,33 +124,119 @@ export const restore_checkpoint = async (params: {
             const git_info = params.checkpoint.git_data[folder_name]
 
             if (git_info) {
-              const diff_file_path = path.join(
-                checkpoint_dir_path,
-                `${folder_name}.diff`
+              const temp_git_clone_path = path.join(
+                os.tmpdir(),
+                `cwc-git-clone-${Date.now()}-${Math.random()
+                  .toString()
+                  .slice(2)}`
               )
+              const temp_git_dir_uri = vscode.Uri.file(temp_git_clone_path)
+
               try {
-                const diff_content = await vscode.workspace.fs.readFile(
-                  vscode.Uri.file(diff_file_path)
+                await vscode.workspace.fs.createDirectory(temp_git_dir_uri)
+                // Clone from local repo to temp dir. This is fast and works offline.
+                execSync(`git clone "${folder.uri.fsPath}" .`, {
+                  cwd: temp_git_clone_path,
+                  stdio: 'pipe'
+                })
+
+                // Checkout the specific commit in the temp repo
+                execSync(`git checkout ${git_info.commit_hash}`, {
+                  cwd: temp_git_clone_path,
+                  stdio: 'pipe'
+                })
+
+                // Remove .git folder from the temporary clone to prevent it from being synced
+                await vscode.workspace.fs.delete(
+                  vscode.Uri.file(path.join(temp_git_clone_path, '.git')),
+                  { recursive: true }
                 )
-                const diff = Buffer.from(diff_content).toString('utf8')
 
-                const success = await apply_git_diff(
-                  folder,
-                  diff,
-                  git_info.commit_hash,
-                  git_info.branch
+                const diff_file_path = path.join(
+                  checkpoint_dir_path,
+                  `${folder_name}.diff`
                 )
 
-                if (!success) {
-                  throw new Error(`Failed to apply git diff for ${folder_name}`)
+                let diff = ''
+                try {
+                  const diff_content = await vscode.workspace.fs.readFile(
+                    vscode.Uri.file(diff_file_path)
+                  )
+                  diff = Buffer.from(diff_content).toString('utf8')
+                } catch (e) {
+                  // diff file might not exist if there were no changes.
                 }
+
+                if (diff.trim().length > 0) {
+                  const temp_diff_path = path.join(
+                    temp_git_clone_path,
+                    'cwc.diff'
+                  )
+                  await vscode.workspace.fs.writeFile(
+                    vscode.Uri.file(temp_diff_path),
+                    Buffer.from(diff, 'utf8')
+                  )
+                  try {
+                    execSync(
+                      `git apply --whitespace=nowarn "${temp_diff_path}"`,
+                      {
+                        cwd: temp_git_clone_path,
+                        stdio: 'pipe'
+                      }
+                    )
+                  } catch (e) {
+                    try {
+                      execSync(
+                        `git apply --reject --whitespace=nowarn "${temp_diff_path}"`,
+                        {
+                          cwd: temp_git_clone_path,
+                          stdio: 'pipe'
+                        }
+                      )
+                      vscode.window.showWarningMessage(
+                        `Some changes for ${folder.name} could not be applied cleanly during checkpoint restore. Check for .rej files in your workspace.`
+                      )
+                    } catch (rejectErr) {
+                      Logger.error({
+                        function_name: 'restore_checkpoint',
+                        message: `Failed to apply git diff even with --reject for ${folder.name}`,
+                        data: rejectErr
+                      })
+                      throw new Error(
+                        `Failed to apply git diff for ${folder.name}`
+                      )
+                    }
+                  } finally {
+                    try {
+                      await vscode.workspace.fs.delete(
+                        vscode.Uri.file(temp_diff_path)
+                      )
+                    } catch {}
+                  }
+                }
+
+                await sync_directory({
+                  source_dir: temp_git_dir_uri,
+                  dest_dir: folder.uri,
+                  root_path: folder.uri.fsPath,
+                  workspace_provider: params.workspace_provider
+                })
               } catch (err) {
                 Logger.error({
                   function_name: 'restore_checkpoint',
-                  message: 'Error restoring git checkpoint',
+                  message: `Error restoring git checkpoint for ${folder.name}`,
                   data: err
                 })
                 throw err
+              } finally {
+                // cleanup temp dir
+                if (temp_git_dir_uri) {
+                  try {
+                    await vscode.workspace.fs.delete(temp_git_dir_uri, {
+                      recursive: true
+                    })
+                  } catch {}
+                }
               }
             } else {
               const source_folder_uri =
@@ -174,6 +278,35 @@ export const restore_checkpoint = async (params: {
       })
     }
 
+    const active_file = open_files.find((f) => f.isActive)
+
+    for (const file of open_files) {
+      if (active_file && file === active_file) {
+        continue
+      }
+      try {
+        await vscode.workspace.fs.stat(file.uri)
+        const doc = await vscode.workspace.openTextDocument(file.uri)
+        await vscode.window.showTextDocument(doc, {
+          viewColumn: file.viewColumn,
+          preserveFocus: true,
+          preview: false
+        })
+      } catch {}
+    }
+
+    if (active_file) {
+      try {
+        await vscode.workspace.fs.stat(active_file.uri)
+        const doc = await vscode.workspace.openTextDocument(active_file.uri)
+        await vscode.window.showTextDocument(doc, {
+          viewColumn: active_file.viewColumn,
+          preserveFocus: false,
+          preview: false
+        })
+      } catch {}
+    }
+
     if (
       params.checkpoint.title == 'Accepted response preview' &&
       params.checkpoint.response_preview_item_created_at &&

packages/vscode/src/commands/checkpoints-command/utils/copy-optimised-recursively.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode'
 import * as path from 'path'
 import * as fs from 'fs/promises'
-import { WorkspaceProvider } from '../../../context/providers/workspace-provider'
+import { WorkspaceProvider } from '@/context/providers/workspace-provider'
 
 const directory_contains_ignored = async (
   dir_uri: vscode.Uri,

packages/vscode/src/commands/checkpoints-command/utils/git-utils.ts

@@ -105,100 +105,6 @@ export const get_git_diff = async (
   }
 }
 
-export const apply_git_diff = async (
-  workspace_folder: vscode.WorkspaceFolder,
-  diff: string,
-  target_commit?: string,
-  target_branch?: string
-): Promise<boolean> => {
-  try {
-    const cwd = workspace_folder.uri.fsPath
-    if (target_commit) {
-      const current_commit = execSync('git rev-parse HEAD', {
-        cwd,
-        encoding: 'utf8'
-      }).trim()
-
-      if (current_commit !== target_commit) {
-        let current_branch: string | undefined
-        try {
-          current_branch = execSync('git rev-parse --abbrev-ref HEAD', {
-            cwd,
-            encoding: 'utf8'
-          }).trim()
-        } catch (err) {
-          // Might be in detached HEAD state
-        }
-
-        if (target_branch && current_branch !== target_branch) {
-          try {
-            execSync(`git checkout ${target_branch}`, { cwd, stdio: 'pipe' })
-          } catch (err) {
-            Logger.warn({
-              function_name: 'apply_git_diff',
-              message: `Could not checkout branch ${target_branch}`,
-              data: err
-            })
-          }
-        }
-
-        const after_branch_commit = execSync('git rev-parse HEAD', {
-          cwd,
-          encoding: 'utf8'
-        }).trim()
-
-        if (after_branch_commit !== target_commit) {
-          execSync(`git reset --hard ${target_commit}`, { cwd })
-        }
-      }
-    }
-
-    execSync('git reset --hard HEAD', { cwd })
-    execSync('git clean -fd', { cwd })
-
-    if (diff && diff.length > 0) {
-      const temp_diff_path = path.join(cwd, '.git', 'checkpoint.diff')
-      await vscode.workspace.fs.writeFile(
-        vscode.Uri.file(temp_diff_path),
-        Buffer.from(diff, 'utf8')
-      )
-
-      try {
-        execSync(`git apply "${temp_diff_path}"`, {
-          cwd,
-          stdio: 'pipe'
-        })
-      } catch (err) {
-        // If git apply fails, try with --reject to apply what we can
-        try {
-          execSync(`git apply --reject "${temp_diff_path}"`, {
-            cwd,
-            stdio: 'pipe'
-          })
-          vscode.window.showWarningMessage(
-            'Some changes could not be applied cleanly. Check .rej files.'
-          )
-        } catch (rejectErr) {
-          throw new Error('Failed to apply diff')
-        }
-      } finally {
-        try {
-          await vscode.workspace.fs.delete(vscode.Uri.file(temp_diff_path))
-        } catch (err) {}
-      }
-    }
-
-    return true
-  } catch (error) {
-    Logger.error({
-      function_name: 'apply_git_diff',
-      message: 'Error applying git diff',
-      data: error
-    })
-    return false
-  }
-}
-
 export const is_git_repository = async (
   workspace_folder: vscode.WorkspaceFolder
 ): Promise<boolean> => {

packages/vscode/src/commands/checkpoints-command/utils/sync-directory.ts

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode'
 import * as path from 'path'
-import { WorkspaceProvider } from '../../../context/providers/workspace-provider'
+import { WorkspaceProvider } from '@/context/providers/workspace-provider'
 
 export const sync_directory = async (params: {
   source_dir: vscode.Uri