Merge pull request #469 from reorproject/file-sidebar-cleanup

File sidebar cleanup

Author: samlhuillier

electron/main/common/windowManager.ts

@@ -87,7 +87,18 @@ class WindowsManager {
   }
 
   appendNewErrorToDisplayInWindow(errorString: string) {
-    this.errorStringsToSendWindow.push(errorString)
+    let errorSent = false
+    const activeWindows = BrowserWindow.getAllWindows()
+    activeWindows.forEach((window) => {
+      if (!window.webContents.isLoading()) {
+        window.webContents.send('error-to-display-in-window', errorString)
+        errorSent = true
+      }
+    })
+
+    if (!errorSent) {
+      this.errorStringsToSendWindow.push(errorString)
+    }
   }
 
   getAndClearErrorStrings(): string[] {

electron/main/filesystem/filesystem.ts

@@ -1,5 +1,4 @@
 import * as fs from 'fs'
-import * as fsPromises from 'fs/promises'
 import * as path from 'path'
 
 import chokidar from 'chokidar'
@@ -178,28 +177,6 @@ export function readFile(filePath: string): string {
   return data
 }
 
-export const moveFileOrDirectoryInFileSystem = async (sourcePath: string, destinationPath: string): Promise<string> => {
-  await fsPromises.access(sourcePath)
-
-  let destinationStats
-  try {
-    destinationStats = await fsPromises.lstat(destinationPath)
-  } catch (error) {
-    // Error means destination path does not exist, which is fine
-  }
-  let resolvedDestinationPath = destinationPath
-  if (destinationStats && destinationStats.isFile()) {
-    resolvedDestinationPath = path.dirname(destinationPath)
-  }
-
-  await fsPromises.mkdir(resolvedDestinationPath, { recursive: true })
-
-  const newPath = path.join(resolvedDestinationPath, path.basename(sourcePath))
-  await fsPromises.rename(sourcePath, newPath)
-
-  return newPath
-}
-
 export function splitDirectoryPathIntoBaseAndRepo(fullPath: string) {
   const normalizedPath = path.normalize(fullPath)
 

electron/main/filesystem/ipcHandlers.ts

@@ -1,21 +1,14 @@
 import * as fs from 'fs'
 import * as path from 'path'
 
-import { ipcMain, BrowserWindow, dialog } from 'electron'
+import { ipcMain, dialog } from 'electron'
 import Store from 'electron-store'
 
 import WindowsManager from '../common/windowManager'
 import { StoreSchema } from '../electron-store/storeConfig'
-import { orchestrateEntryMove, updateFileInTable } from '../vector-database/tableHelperFunctions'
-
-import {
-  GetFilesInfoTree,
-  createFileRecursive,
-  isHidden,
-  GetFilesInfoListForListOfPaths,
-  startWatchingDirectory,
-  updateFileListForRenderer,
-} from './filesystem'
+import { handleFileRename, updateFileInTable } from '../vector-database/tableHelperFunctions'
+
+import { GetFilesInfoTree, createFileRecursive, isHidden, GetFilesInfoListForListOfPaths } from './filesystem'
 import { FileInfoTree, WriteFileProps, RenameFileProps, FileInfoWithContent } from './types'
 
 const registerFileHandlers = (store: Store<StoreSchema>, _windowsManager: WindowsManager) => {
@@ -91,36 +84,7 @@ const registerFileHandlers = (store: Store<StoreSchema>, _windowsManager: Window
       throw new Error('Window info not found.')
     }
 
-    windowsManager.watcher?.unwatch(windowInfo?.vaultDirectoryForWindow)
-
-    if (process.platform === 'win32') {
-      windowsManager.watcher?.close().then(() => {
-        fs.rename(renameFileProps.oldFilePath, renameFileProps.newFilePath, (err) => {
-          if (err) {
-            throw err
-          }
-
-          // Re-start watching all paths in array
-          const win = BrowserWindow.fromWebContents(event.sender)
-          if (win) {
-            windowsManager.watcher = startWatchingDirectory(win, windowInfo.vaultDirectoryForWindow)
-            updateFileListForRenderer(win, windowInfo.vaultDirectoryForWindow)
-          }
-        })
-      })
-    } else {
-      // On non-Windows platforms, directly perform the rename operation
-      fs.rename(renameFileProps.oldFilePath, renameFileProps.newFilePath, (err) => {
-        if (err) {
-          throw err
-        }
-        // Re-watch the vault directory after renaming
-        windowsManager.watcher?.add(windowInfo?.vaultDirectoryForWindow)
-      })
-    }
-
-    // then need to trigger reindexing of folder
-    windowInfo.dbTableClient.updateDBItemsWithNewFilePath(renameFileProps.oldFilePath, renameFileProps.newFilePath)
+    await handleFileRename(windowsManager, windowInfo, renameFileProps, event.sender)
   })
 
   ipcMain.handle('index-file-in-database', async (event, filePath: string) => {
@@ -151,14 +115,6 @@ const registerFileHandlers = (store: Store<StoreSchema>, _windowsManager: Window
     }
   })
 
-  ipcMain.handle('move-file-or-dir', async (event, sourcePath: string, destinationPath: string) => {
-    const windowInfo = windowsManager.getWindowInfoForContents(event.sender)
-    if (!windowInfo) {
-      throw new Error('Window info not found.')
-    }
-    orchestrateEntryMove(windowInfo.dbTableClient, sourcePath, destinationPath)
-  })
-
   ipcMain.handle('get-files', async (_event, filePaths: string[]): Promise<FileInfoWithContent[]> => {
     const fileItems = GetFilesInfoListForListOfPaths(filePaths)
     const fileContents = fileItems.map((fileItem) => fs.readFileSync(fileItem.path, 'utf-8'))

electron/main/path/ipcHandlers.ts

@@ -13,7 +13,7 @@ const registerPathHandlers = () => {
 
   ipcMain.handle('join-path', (event, ...args) => path.join(...args))
 
-  ipcMain.handle('path-dirname', (event, pathString: string) => path.dirname(pathString) + path.sep)
+  ipcMain.handle('path-dirname', (event, pathString: string) => path.dirname(pathString))
 
   ipcMain.handle('path-relative', (event, from: string, to: string) => path.relative(from, to))
 

electron/main/vector-database/tableHelperFunctions.ts

@@ -1,17 +1,20 @@
 import * as fs from 'fs'
+import * as fsPromises from 'fs/promises'
 
+import { BrowserWindow } from 'electron'
 import { chunkMarkdownByHeadingsAndByCharsIfBig } from '../common/chunking'
 import {
   GetFilesInfoList,
-  GetFilesInfoTree,
   flattenFileInfoTree,
-  moveFileOrDirectoryInFileSystem,
   readFile,
+  updateFileListForRenderer,
+  startWatchingDirectory,
 } from '../filesystem/filesystem'
-import { FileInfo, FileInfoTree } from '../filesystem/types'
+import { FileInfo, FileInfoTree, RenameFileProps } from '../filesystem/types'
 
 import LanceDBTableWrapper, { convertRecordToDBType } from './lanceTableWrapper'
 import { DBEntry, DatabaseFields } from './schema'
+import WindowsManager from '../common/windowManager'
 
 const convertFileTypeToDBType = async (file: FileInfo): Promise<DBEntry[]> => {
   const fileContent = readFile(file.path)
@@ -27,6 +30,58 @@ const convertFileTypeToDBType = async (file: FileInfo): Promise<DBEntry[]> => {
   return entries
 }
 
+export const handleFileRename = async (
+  windowsManager: WindowsManager,
+  windowInfo: { vaultDirectoryForWindow: string; dbTableClient: any },
+  renameFileProps: RenameFileProps,
+  sender: Electron.WebContents,
+): Promise<void> => {
+  windowsManager.watcher?.unwatch(windowInfo.vaultDirectoryForWindow)
+
+  try {
+    await fsPromises.access(renameFileProps.newFilePath)
+    throw new Error(`A file already exists at destination: ${renameFileProps.newFilePath}`)
+  } catch (error) {
+    // If error is ENOENT (file doesn't exist), proceed with rename
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+      throw error
+    }
+  }
+
+  if (process.platform === 'win32') {
+    await windowsManager.watcher?.close()
+    await new Promise<void>((resolve, reject) => {
+      fs.rename(renameFileProps.oldFilePath, renameFileProps.newFilePath, (err) => {
+        if (err) {
+          reject(err)
+          return
+        }
+
+        const win = BrowserWindow.fromWebContents(sender)
+        if (win) {
+          // eslint-disable-next-line no-param-reassign
+          windowsManager.watcher = startWatchingDirectory(win, windowInfo.vaultDirectoryForWindow)
+          updateFileListForRenderer(win, windowInfo.vaultDirectoryForWindow)
+        }
+        resolve()
+      })
+    })
+  } else {
+    await new Promise<void>((resolve, reject) => {
+      fs.rename(renameFileProps.oldFilePath, renameFileProps.newFilePath, (err) => {
+        if (err) {
+          reject(err)
+          return
+        }
+        windowsManager.watcher?.add(windowInfo.vaultDirectoryForWindow)
+        resolve()
+      })
+    })
+  }
+
+  await windowInfo.dbTableClient.updateDBItemsWithNewFilePath(renameFileProps.oldFilePath, renameFileProps.newFilePath)
+}
+
 export const convertFileInfoListToDBItems = async (filesInfoList: FileInfo[]): Promise<DBEntry[][]> => {
   const promises = filesInfoList.map(convertFileTypeToDBType)
   const filesAsChunksToAddToDB = await Promise.all(promises)
@@ -157,16 +212,6 @@ export const addFileTreeToDBTable = async (dbTable: LanceDBTableWrapper, fileTre
   await dbTable.add(dbEntries)
 }
 
-export const orchestrateEntryMove = async (table: LanceDBTableWrapper, sourcePath: string, destinationPath: string) => {
-  const fileSystemTree = GetFilesInfoTree(sourcePath)
-  await removeFileTreeFromDBTable(table, fileSystemTree)
-  moveFileOrDirectoryInFileSystem(sourcePath, destinationPath).then((newDestinationPath) => {
-    if (newDestinationPath) {
-      addFileTreeToDBTable(table, GetFilesInfoTree(newDestinationPath))
-    }
-  })
-}
-
 export function formatTimestampForLanceDB(date: Date): string {
   const year = date.getFullYear()
   const month = date.getMonth() + 1 // getMonth() is zero-based

electron/preload/index.ts

@@ -90,7 +90,6 @@ const fileSystem = {
   createDirectory: createIPCHandler<(dirPath: string) => Promise<void>>('create-directory'),
   checkFileExists: createIPCHandler<(filePath: string) => Promise<boolean>>('check-file-exists'),
   deleteFile: createIPCHandler<(filePath: string) => Promise<void>>('delete-file'),
-  moveFileOrDir: createIPCHandler<(sourcePath: string, destinationPath: string) => Promise<void>>('move-file-or-dir'),
   getAllFilenamesInDirectory: createIPCHandler<(dirName: string) => Promise<string[]>>('get-files-in-directory'),
   getFiles: createIPCHandler<(filePaths: string[]) => Promise<FileInfoWithContent[]>>('get-files'),
 }

src/components/Common/Modal.tsx

@@ -36,11 +36,11 @@ const ReorModal: React.FC<ModalProps> = ({
 
   const modalContent = (
     <div
-      className={`fixed inset-0 flex h-screen w-screen items-center justify-center bg-black/40 ${tailwindStylesOnBackground}`}
+      className={`fixed inset-0 z-[9999] flex h-screen w-screen items-center justify-center bg-black/40 ${tailwindStylesOnBackground}`}
     >
       <div
         ref={modalRef}
-        className="flex flex-col items-center justify-center rounded-lg border border-solid border-gray-700 bg-dark-gray-c-three shadow-xl"
+        className="relative flex flex-col items-center justify-center rounded-lg border border-solid border-gray-700 bg-dark-gray-c-three shadow-xl"
       >
         <div className="z-50 h-0 w-full items-end">
           {!hideCloseButton && (

src/components/File/NewDirectory.tsx

@@ -14,14 +14,37 @@ interface NewDirectoryComponentProps {
 }
 
 const NewDirectoryComponent: React.FC<NewDirectoryComponentProps> = ({ isOpen, onClose, parentDirectoryPath }) => {
-  const [directoryName, setDirectoryName] = useState<string>('')
+  const [directoryRelativePath, setDirectoryRelativePath] = useState<string>('')
   const [errorMessage, setErrorMessage] = useState<string | null>(null)
 
-  const { currentlyOpenFilePath } = useFileContext()
+  const { selectedDirectory } = useFileContext()
+
+  useEffect(() => {
+    const setupInitialPath = async () => {
+      const vaultDirectory = await window.electronStore.getVaultDirectoryForWindow()
+
+      let fullPath = ''
+      if (parentDirectoryPath) {
+        fullPath = parentDirectoryPath
+      } else if (selectedDirectory) {
+        fullPath = selectedDirectory
+      }
+
+      if (fullPath) {
+        const relativePath = await window.path.relative(vaultDirectory, fullPath)
+        const pathWithSeparator = relativePath ? `${relativePath}${await window.path.pathSep()}` : ''
+        setDirectoryRelativePath(pathWithSeparator)
+      }
+    }
+
+    if (isOpen) {
+      setupInitialPath()
+    }
+  }, [isOpen, parentDirectoryPath, selectedDirectory])
 
   useEffect(() => {
     if (!isOpen) {
-      setDirectoryName('')
+      setDirectoryRelativePath('')
       setErrorMessage(null)
     }
   }, [isOpen])
@@ -39,24 +62,25 @@ const NewDirectoryComponent: React.FC<NewDirectoryComponentProps> = ({ isOpen, o
   const handleNameChange = async (e: React.ChangeEvent<HTMLInputElement>) => {
     const newName = e.target.value
     await handleValidName(newName)
-    setDirectoryName(newName)
+    setDirectoryRelativePath(newName)
   }
 
-  const sendNewDirectoryMsg = async () => {
-    const validName = await handleValidName(directoryName)
-    if (!directoryName || errorMessage || !validName) return
+  const createNewDirectory = async () => {
+    const validName = await handleValidName(directoryRelativePath)
+    if (!directoryRelativePath || errorMessage || !validName) return
 
-    let directoryPath: string
+    // let directoryPath: string
+    const directoryPath = await window.electronStore.getVaultDirectoryForWindow()
 
-    if (parentDirectoryPath) {
-      directoryPath = parentDirectoryPath
-    } else if (currentlyOpenFilePath && currentlyOpenFilePath !== '') {
-      directoryPath = await window.path.dirname(currentlyOpenFilePath)
-    } else {
-      directoryPath = await window.electronStore.getVaultDirectoryForWindow()
-    }
+    // if (parentDirectoryPath) {
+    //   directoryPath = parentDirectoryPath
+    // } else if (currentlyOpenFilePath && currentlyOpenFilePath !== '') {
+    //   directoryPath = await window.path.dirname(currentlyOpenFilePath)
+    // } else {
+    //   directoryPath = await window.electronStore.getVaultDirectoryForWindow()
+    // }
 
-    const finalPath = await window.path.join(directoryPath, directoryName)
+    const finalPath = await window.path.join(directoryPath, directoryRelativePath)
     window.fileSystem.createDirectory(finalPath)
     posthog.capture('created_new_directory_from_new_directory_modal')
     onClose()
@@ -69,11 +93,11 @@ const NewDirectoryComponent: React.FC<NewDirectoryComponentProps> = ({ isOpen, o
         <input
           type="text"
           className=" block w-full rounded-md border border-gray-300 px-3 py-2 transition duration-150 ease-in-out focus:border-blue-300 focus:outline-none"
-          value={directoryName}
+          value={directoryRelativePath}
           onChange={handleNameChange}
           onKeyDown={(e: React.KeyboardEvent<HTMLInputElement>) => {
             if (e.key === 'Enter') {
-              sendNewDirectoryMsg()
+              createNewDirectory()
             }
           }}
           placeholder="Directory Name"
@@ -84,7 +108,7 @@ const NewDirectoryComponent: React.FC<NewDirectoryComponentProps> = ({ isOpen, o
         <div className="flex items-center gap-3">
           <Button
             className="mb-2 mt-3 h-10 w-[80px] cursor-pointer border-none bg-blue-500 px-2 py-0 text-center hover:bg-blue-600"
-            onClick={sendNewDirectoryMsg}
+            onClick={createNewDirectory}
             placeholder=""
           >
             Create