Split file operations utility into modular files

- regarding `apps/editor/src/commands/apply-response-command/utils/file-operations.ts`: place each individual function in a separate file in `apps/editor/src/commands/apply-response-command/utils/file-operations...`

└── apps
    └── editor
        └── src
            ├── commands
            │   └── apply-response-command
            │       ├── handlers
            │       │   ├── diff-handler.ts
            │       │   ├── fast-replace-handler.ts
            │       │   ├── restore-preview-handler.ts
            │       │   ├── search-replace-handler.ts
            │       │   └── truncated-handler.ts
            │       ├── response-processor.ts
            │       └── utils
            │           ├── file-operations
            │           │   ├── apply-file-relocations.ts
            │           │   ├── cleanup-rename-source.ts
            │           │   ├── close-file-tabs.ts
            │           │   ├── create-file-if-needed.ts
            │           │   ├── get-rename-source-info.ts
            │           │   ├── handle-deleted-file-item.ts
            │           │   ├── index.ts
            │           │   ├── read-rename-source-file.ts
            │           │   ├── relocate-file.ts
            │           │   ├── remove-directory-if-empty.ts
            │           │   ├── undo-files.ts
            │           │   └── uri-exists.ts
            │           ├── preview
            │           │   └── workspace-listener.ts
            │           └── preview-handler.ts
            └── views
                └── prompt
                    └── backend
                        └── message-handlers
                            └── handle-undo.ts

Author: robertpiosik

apps/editor/src/commands/apply-response-command/utils/file-operations.ts

@@ -0,0 +1,78 @@
+import * as vscode from 'vscode'
+import { OriginalFileState } from '@/commands/apply-response-command/types/original-file-state'
+import { create_safe_path } from '@/utils/path-sanitizer'
+import { uri_exists } from './uri-exists'
+import { relocate_file } from './relocate-file'
+
+export const apply_file_relocations = async (
+  original_states: OriginalFileState[]
+): Promise<void> => {
+  if (
+    !vscode.workspace.workspaceFolders ||
+    vscode.workspace.workspaceFolders.length == 0
+  ) {
+    return
+  }
+
+  const workspace_map = new Map<string, string>()
+  vscode.workspace.workspaceFolders.forEach((folder) => {
+    workspace_map.set(folder.name, folder.uri.fsPath)
+  })
+
+  const default_workspace = vscode.workspace.workspaceFolders[0].uri.fsPath
+
+  for (const state of original_states) {
+    if (
+      state.new_file_path &&
+      (state.new_file_path !== state.file_path ||
+        state.new_workspace_name !== state.workspace_name)
+    ) {
+      let workspace_root = default_workspace
+      if (state.workspace_name && workspace_map.has(state.workspace_name)) {
+        workspace_root = workspace_map.get(state.workspace_name)!
+      }
+
+      let new_workspace_root = workspace_root
+      if (
+        state.new_workspace_name &&
+        workspace_map.has(state.new_workspace_name)
+      ) {
+        new_workspace_root = workspace_map.get(state.new_workspace_name)!
+      }
+
+      const old_safe_path = create_safe_path(workspace_root, state.file_path)
+      const new_safe_path = create_safe_path(
+        new_workspace_root,
+        state.new_file_path
+      )
+
+      if (!old_safe_path || !new_safe_path) continue
+
+      const old_exists = await uri_exists(vscode.Uri.file(old_safe_path))
+      const new_exists = await uri_exists(vscode.Uri.file(new_safe_path))
+
+      let success = false
+      if (old_exists) {
+        success = await relocate_file({
+          old_path: state.file_path,
+          new_path: state.new_file_path,
+          old_workspace_root: workspace_root,
+          new_workspace_root: new_workspace_root
+        })
+      } else if (new_exists) {
+        success = true
+      }
+
+      if (success) {
+        state.file_path_to_restore = state.file_path
+        state.restore_workspace_name = state.workspace_name
+        state.file_path = state.new_file_path
+        if (state.new_workspace_name) {
+          state.workspace_name = state.new_workspace_name
+        }
+        state.new_file_path = undefined
+        state.new_workspace_name = undefined
+      }
+    }
+  }
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/apply-file-relocations.ts

@@ -0,0 +1,16 @@
+import * as vscode from 'vscode'
+import * as path from 'path'
+import { close_file_tabs } from './close-file-tabs'
+import { remove_directory_if_empty } from './remove-directory-if-empty'
+
+export const cleanup_rename_source = async (params: {
+  source_path: string
+  workspace_root: string
+}) => {
+  await close_file_tabs(params.source_path)
+  await vscode.workspace.fs.delete(vscode.Uri.file(params.source_path))
+  await remove_directory_if_empty({
+    dir_path: path.dirname(params.source_path),
+    workspace_root: params.workspace_root
+  })
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/cleanup-rename-source.ts

@@ -0,0 +1,16 @@
+import * as vscode from 'vscode'
+
+export const close_file_tabs = async (file_path: string) => {
+  const tabs_to_close: vscode.Tab[] = []
+  for (const tab_group of vscode.window.tabGroups.all) {
+    tabs_to_close.push(
+      ...tab_group.tabs.filter((tab) => {
+        const tab_uri = (tab.input as any)?.uri as vscode.Uri | undefined
+        return tab_uri && tab_uri.fsPath === file_path
+      })
+    )
+  }
+  if (tabs_to_close.length > 0) {
+    await vscode.window.tabGroups.close(tabs_to_close)
+  }
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/close-file-tabs.ts

@@ -0,0 +1,117 @@
+import * as vscode from 'vscode'
+import * as path from 'path'
+import { Logger } from '@shared/utils/logger'
+import { t } from '@/i18n'
+import { create_safe_path } from '@/utils/path-sanitizer'
+import { uri_exists } from './uri-exists'
+
+export const create_file_if_needed = async (params: {
+  file_path: string
+  content: string
+  workspace_name?: string
+}): Promise<boolean> => {
+  Logger.info({
+    function_name: 'create_file_if_needed',
+    message: 'start',
+    data: { filePath: params.file_path, workspace_name: params.workspace_name }
+  })
+  if (
+    !vscode.workspace.workspaceFolders ||
+    vscode.workspace.workspaceFolders.length == 0
+  ) {
+    vscode.window.showErrorMessage(
+      t('command.apply-response.error.no-workspace-folder')
+    )
+    Logger.warn({
+      function_name: 'create_file_if_needed',
+      message: 'No workspace folder open.'
+    })
+    return false
+  }
+
+  let workspace_folder_path: string | undefined
+
+  if (params.workspace_name) {
+    const target_workspace = vscode.workspace.workspaceFolders.find(
+      (folder) => folder.name == params.workspace_name
+    )
+    if (target_workspace) {
+      workspace_folder_path = target_workspace.uri.fsPath
+    } else {
+      Logger.warn({
+        function_name: 'create_file_if_needed',
+        message: `Workspace named "${params.workspace_name}" not found. Falling back to the first workspace.`,
+        data: params.file_path
+      })
+      workspace_folder_path = vscode.workspace.workspaceFolders[0].uri.fsPath
+    }
+  } else {
+    workspace_folder_path = vscode.workspace.workspaceFolders[0].uri.fsPath
+  }
+
+  const safe_path = create_safe_path(workspace_folder_path, params.file_path)
+
+  if (!safe_path) {
+    vscode.window.showErrorMessage(
+      t('command.apply-response.error.invalid-file-path-traversal', {
+        path: params.file_path
+      })
+    )
+    Logger.error({
+      function_name: 'create_file_if_needed',
+      message: 'Invalid file path',
+      data: params.file_path
+    })
+    return false
+  }
+  const file_uri = vscode.Uri.file(safe_path)
+  const directory_uri = vscode.Uri.file(path.dirname(safe_path))
+
+  if (!(await uri_exists(directory_uri))) {
+    try {
+      await vscode.workspace.fs.createDirectory(directory_uri)
+      Logger.info({
+        function_name: 'create_file_if_needed',
+        message: 'Directory created',
+        data: directory_uri.fsPath
+      })
+    } catch (error) {
+      Logger.error({
+        function_name: 'create_file_if_needed',
+        message: 'Failed to create directory',
+        data: { directory: directory_uri.fsPath, error }
+      })
+      vscode.window.showErrorMessage(
+        t('command.apply-response.error.failed-to-create-directory', {
+          path: directory_uri.fsPath
+        })
+      )
+      return false
+    }
+  }
+
+  try {
+    await vscode.workspace.fs.writeFile(
+      file_uri,
+      Buffer.from(params.content, 'utf8')
+    )
+    Logger.info({
+      function_name: 'create_file_if_needed',
+      message: 'File created',
+      data: safe_path
+    })
+    return true
+  } catch (error) {
+    Logger.error({
+      function_name: 'create_file_if_needed',
+      message: 'Failed to write file',
+      data: { safe_path, error }
+    })
+    vscode.window.showErrorMessage(
+      t('command.apply-response.error.failed-to-write-file', {
+        path: safe_path
+      })
+    )
+  }
+  return false
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/create-file-if-needed.ts

@@ -0,0 +1,40 @@
+import { FileItem } from '../response-parser'
+import { read_rename_source_file } from './read-rename-source-file'
+
+export const get_rename_source_info = async (params: {
+  file: FileItem
+  workspace_map: Map<string, string>
+  default_workspace: string
+}) => {
+  let rename_source_path: string | undefined
+  let rename_source_content: string | undefined
+  let rename_source_workspace_root: string | undefined
+
+  if (params.file.renamed_from) {
+    let old_workspace_root = params.default_workspace
+    if (
+      params.file.renamed_from_workspace &&
+      params.workspace_map.has(params.file.renamed_from_workspace)
+    ) {
+      old_workspace_root = params.workspace_map.get(
+        params.file.renamed_from_workspace
+      )!
+    }
+
+    const source_info = await read_rename_source_file({
+      renamed_from: params.file.renamed_from,
+      workspace_root: old_workspace_root
+    })
+    if (source_info) {
+      rename_source_path = source_info.path
+      rename_source_content = source_info.content
+      rename_source_workspace_root = old_workspace_root
+    }
+  }
+
+  return {
+    rename_source_path,
+    rename_source_content,
+    rename_source_workspace_root
+  }
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/get-rename-source-info.ts

@@ -0,0 +1,72 @@
+import * as vscode from 'vscode'
+import * as path from 'path'
+import * as fs from 'fs'
+import { Logger } from '@shared/utils/logger'
+import { OriginalFileState } from '@/commands/apply-response-command/types/original-file-state'
+import { FileItem } from '../response-parser'
+import { get_rename_source_info } from './get-rename-source-info'
+import { cleanup_rename_source } from './cleanup-rename-source'
+import { close_file_tabs } from './close-file-tabs'
+import { remove_directory_if_empty } from './remove-directory-if-empty'
+
+export const handle_deleted_file_item = async (params: {
+  file: FileItem
+  safe_path: string
+  workspace_root: string
+  workspace_map: Map<string, string>
+  default_workspace: string
+  function_name: string
+}): Promise<{ success: boolean; original_state?: OriginalFileState }> => {
+  await get_rename_source_info({
+    file: params.file,
+    workspace_map: params.workspace_map,
+    default_workspace: params.default_workspace
+  }).then(async (info) => {
+    if (info.rename_source_path && info.rename_source_workspace_root) {
+      await cleanup_rename_source({
+        source_path: info.rename_source_path,
+        workspace_root: info.rename_source_workspace_root
+      })
+    }
+  })
+
+  let original_content = ''
+  if (fs.existsSync(params.safe_path)) {
+    try {
+      const document = await vscode.workspace.openTextDocument(params.safe_path)
+      original_content = document.getText()
+
+      await close_file_tabs(params.safe_path)
+
+      await vscode.workspace.fs.delete(vscode.Uri.file(params.safe_path))
+      await remove_directory_if_empty({
+        dir_path: path.dirname(params.safe_path),
+        workspace_root: params.workspace_root
+      })
+
+      Logger.info({
+        function_name: params.function_name,
+        message: 'File deleted',
+        data: params.safe_path
+      })
+    } catch (error: any) {
+      Logger.error({
+        function_name: params.function_name,
+        message: 'Failed to delete file',
+        data: { error: error.message || error, file_path: params.safe_path }
+      })
+      return { success: false }
+    }
+  }
+
+  const original_state: OriginalFileState = {
+    file_path: params.file.file_path,
+    content: original_content,
+    workspace_name: params.file.workspace_name,
+    file_state: 'deleted',
+    ai_content: params.file.content,
+    proposed_content: ''
+  }
+
+  return { success: true, original_state }
+}

apps/editor/src/commands/apply-response-command/utils/file-operations/handle-deleted-file-item.ts

@@ -0,0 +1,9 @@
+export * from './apply-file-relocations'
+export * from './cleanup-rename-source'
+export * from './close-file-tabs'
+export * from './create-file-if-needed'
+export * from './get-rename-source-info'
+export * from './handle-deleted-file-item'
+export * from './read-rename-source-file'
+export * from './remove-directory-if-empty'
+export * from './undo-files'

apps/editor/src/commands/apply-response-command/utils/file-operations/index.ts

@@ -0,0 +1,32 @@
+import * as vscode from 'vscode'
+import * as fs from 'fs'
+import { Logger } from '@shared/utils/logger'
+import { create_safe_path, sanitize_file_name } from '@/utils/path-sanitizer'
+
+export const read_rename_source_file = async (params: {
+  renamed_from: string
+  workspace_root: string
+}): Promise<{ path: string; content: string } | undefined> => {
+  const sanitized_rename_path = sanitize_file_name(params.renamed_from)
+  const safe_rename_path = create_safe_path(
+    params.workspace_root,
+    sanitized_rename_path
+  )
+
+  if (safe_rename_path && fs.existsSync(safe_rename_path)) {
+    try {
+      const document = await vscode.workspace.openTextDocument(safe_rename_path)
+      return {
+        path: safe_rename_path,
+        content: document.getText()
+      }
+    } catch (e) {
+      Logger.warn({
+        function_name: 'read_rename_source_file',
+        message: 'Failed to read rename source file',
+        data: safe_rename_path
+      })
+    }
+  }
+  return undefined
+}