Check for orphans

frontend/src/components/fileManager/FileHistoryGroup.tsx

@@ -10,7 +10,7 @@ interface FileHistoryGroupProps {
   isExpanded: boolean;
   onDownloadSingle: (file: StirlingFileStub) => void;
   onFileDoubleClick: (file: StirlingFileStub) => void;
-  onFileRemove: (index: number) => void;
+  onHistoryFileRemove: (file: StirlingFileStub) => void;
   isFileSupported: (fileName: string) => boolean;
 }
 
@@ -20,7 +20,7 @@ const FileHistoryGroup: React.FC<FileHistoryGroupProps> = ({
   isExpanded,
   onDownloadSingle,
   onFileDoubleClick,
-  onFileRemove,
+  onHistoryFileRemove,
   isFileSupported,
 }) => {
   const { t } = useTranslation();
@@ -44,14 +44,14 @@ const FileHistoryGroup: React.FC<FileHistoryGroupProps> = ({
         </Group>
 
         <Box ml="md">
-          {sortedHistory.map((historyFile, index) => (
+          {sortedHistory.map((historyFile, _index) => (
             <FileListItem
               key={`history-${historyFile.id}-${historyFile.versionNumber || 1}`}
               file={historyFile}
               isSelected={false} // History files are not selectable
               isSupported={isFileSupported(historyFile.name)}
               onSelect={() => {}} // No selection for history files
-              onRemove={() => onFileRemove(index)} // Pass through remove handler
+              onRemove={() => onHistoryFileRemove(historyFile)} // Remove specific history file
               onDownload={() => onDownloadSingle(historyFile)}
               onDoubleClick={() => onFileDoubleClick(historyFile)}
               isHistoryFile={true} // This enables "Add to Recents" in menu

frontend/src/components/fileManager/FileListArea.tsx

@@ -25,6 +25,7 @@ const FileListArea: React.FC<FileListAreaProps> = ({
     loadedHistoryFiles,
     onFileSelect,
     onFileRemove,
+    onHistoryFileRemove,
     onFileDoubleClick,
     onDownloadSingle,
     isFileSupported,
@@ -78,7 +79,7 @@ const FileListArea: React.FC<FileListAreaProps> = ({
                     isExpanded={isExpanded}
                     onDownloadSingle={onDownloadSingle}
                     onFileDoubleClick={onFileDoubleClick}
-                    onFileRemove={onFileRemove}
+                    onHistoryFileRemove={onHistoryFileRemove}
                     isFileSupported={isFileSupported}
                   />
                 </React.Fragment>

frontend/src/contexts/FileManagerContext.tsx

@@ -24,6 +24,7 @@ interface FileManagerContextValue {
   onLocalFileClick: () => void;
   onFileSelect: (file: StirlingFileStub, index: number, shiftKey?: boolean) => void;
   onFileRemove: (index: number) => void;
+  onHistoryFileRemove: (file: StirlingFileStub) => void;
   onFileDoubleClick: (file: StirlingFileStub) => void;
   onOpenFiles: () => void;
   onSearchChange: (value: string) => void;
@@ -172,7 +173,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
 
   // Helper function to safely determine which files can be deleted
   const getSafeFilesToDelete = useCallback((
-    leafFileIds: string[],
+    fileIds: string[],
     allStoredStubs: StirlingFileStub[]
   ): string[] => {
     const fileMap = new Map(allStoredStubs.map(f => [f.id as string, f]));
@@ -180,7 +181,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     const filesToPreserve = new Set<string>();
 
     // First, identify all files in the lineages of the leaf files being deleted
-    for (const leafFileId of leafFileIds) {
+    for (const leafFileId of fileIds) {
       const currentFile = fileMap.get(leafFileId);
       if (!currentFile) continue;
 
@@ -206,7 +207,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
       const fileOriginalId = file.originalFileId || file.id;
 
       // If this file is a leaf node (not being deleted) and its lineage overlaps with files we want to delete
-      if (file.isLeaf !== false && !leafFileIds.includes(file.id)) {
+      if (file.isLeaf !== false && !fileIds.includes(file.id)) {
         // Find all files in this preserved lineage
         const preservedChainFiles = allStoredStubs.filter((chainFile: StirlingFileStub) =>
           (chainFile.originalFileId || chainFile.id) === fileOriginalId
@@ -218,73 +219,160 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     }
 
     // Final list: files to delete minus files that must be preserved
-    const safeToDelete = Array.from(filesToDelete).filter(fileId => !filesToPreserve.has(fileId));
+    let safeToDelete = Array.from(filesToDelete).filter(fileId => !filesToPreserve.has(fileId));
+
+    // Check for orphaned non-leaf files after main deletion
+    const remainingFiles = allStoredStubs.filter(file => !safeToDelete.includes(file.id as string));
+    const orphanedNonLeafFiles: string[] = [];
+
+    for (const file of remainingFiles) {
+      // Only check non-leaf files (files that have been processed and have children)
+      if (file.isLeaf === false) {
+        const fileOriginalId = file.originalFileId || file.id;
+        
+        // Check if this non-leaf file has any living descendants
+        const hasLivingDescendants = remainingFiles.some(otherFile => {
+          // Check if otherFile is a descendant of this file
+          const otherOriginalId = otherFile.originalFileId || otherFile.id;
+          return (
+            // Direct parent relationship
+            otherFile.parentFileId === file.id ||
+            // Same lineage but different from this file
+            (otherOriginalId === fileOriginalId && otherFile.id !== file.id)
+          );
+        });
+
+        if (!hasLivingDescendants) {
+          orphanedNonLeafFiles.push(file.id as string);
+        }
+      }
+    }
+
+    // Add orphaned non-leaf files to deletion list
+    safeToDelete = [...safeToDelete, ...orphanedNonLeafFiles];
 
     console.log('Deletion analysis:', {
       candidatesForDeletion: Array.from(filesToDelete),
       mustPreserve: Array.from(filesToPreserve),
+      orphanedNonLeafFiles,
       safeToDelete
     });
 
     return safeToDelete;
   }, []);
 
+  // Shared internal delete logic
+  const performFileDelete = useCallback(async (fileToRemove: StirlingFileStub, fileIndex: number) => {
+    const deletedFileId = fileToRemove.id;
+
+    // Get all stored files to analyze lineages
+    const allStoredStubs = await fileStorage.getAllStirlingFileStubs();
+
+    // Get safe files to delete (respecting shared lineages)
+    const filesToDelete = getSafeFilesToDelete([deletedFileId as string], allStoredStubs);
+
+    console.log(`Safely deleting files for ${fileToRemove.name}:`, filesToDelete);
+
+    // Clear from selection immediately
+    setSelectedFileIds(prev => prev.filter(id => !filesToDelete.includes(id)));
+
+    // Clear from expanded state to prevent ghost entries
+    setExpandedFileIds(prev => {
+      const newExpanded = new Set(prev);
+      filesToDelete.forEach(id => newExpanded.delete(id));
+      return newExpanded;
+    });
+
+    // Clear from history cache - remove all files in the chain
+    setLoadedHistoryFiles(prev => {
+      const newCache = new Map(prev);
+
+      // Remove cache entries for all deleted files
+      filesToDelete.forEach(id => newCache.delete(id as FileId));
+
+      // Also remove deleted files from any other file's history cache
+      for (const [mainFileId, historyFiles] of newCache.entries()) {
+        const filteredHistory = historyFiles.filter(histFile => !filesToDelete.includes(histFile.id as string));
+        if (filteredHistory.length !== historyFiles.length) {
+          newCache.set(mainFileId, filteredHistory);
+        }
+      }
+
+      return newCache;
+    });
+
+    // Delete safe files from IndexedDB
+    try {
+      for (const fileId of filesToDelete) {
+        await fileStorage.deleteStirlingFile(fileId as FileId);
+      }
+    } catch (error) {
+      console.error('Failed to delete files from chain:', error);
+    }
+
+    // Call the parent's deletion logic for the main file only
+    onFileRemove(fileIndex);
+
+    // Refresh to ensure consistent state
+    await refreshRecentFiles();
+  }, [getSafeFilesToDelete, setSelectedFileIds, setExpandedFileIds, setLoadedHistoryFiles, onFileRemove, refreshRecentFiles]);
+
   const handleFileRemove = useCallback(async (index: number) => {
     const fileToRemove = filteredFiles[index];
     if (fileToRemove) {
-      const deletedFileId = fileToRemove.id;
+      await performFileDelete(fileToRemove, index);
+    }
+  }, [filteredFiles, performFileDelete]);
 
-      // Get all stored files to analyze lineages
-      const allStoredStubs = await fileStorage.getAllStirlingFileStubs();
+  // Handle deletion by fileId (more robust than index-based)
+  const handleFileRemoveById = useCallback(async (fileId: FileId) => {
+    // Find the file and its index in filteredFiles
+    const fileIndex = filteredFiles.findIndex(file => file.id === fileId);
+    const fileToRemove = filteredFiles[fileIndex];
     
-      // Get safe files to delete (respecting shared lineages)
-      const filesToDelete = getSafeFilesToDelete([deletedFileId as string], allStoredStubs);
+    if (fileToRemove && fileIndex !== -1) {
+      await performFileDelete(fileToRemove, fileIndex);
+    }
+  }, [filteredFiles, performFileDelete]);
 
-      console.log(`Safely deleting files for ${fileToRemove.name}:`, filesToDelete);
+  // Handle deletion of specific history files (not index-based)
+  const handleHistoryFileRemove = useCallback(async (fileToRemove: StirlingFileStub) => {
+    const deletedFileId = fileToRemove.id;
 
-      // Clear from selection immediately
-      setSelectedFileIds(prev => prev.filter(id => !filesToDelete.includes(id)));
+    // Clear from expanded state to prevent ghost entries
+    setExpandedFileIds(prev => {
+      const newExpanded = new Set(prev);
+      newExpanded.delete(deletedFileId);
+      return newExpanded;
+    });
 
-      // Clear from expanded state to prevent ghost entries
-      setExpandedFileIds(prev => {
-        const newExpanded = new Set(prev);
-        filesToDelete.forEach(id => newExpanded.delete(id));
-        return newExpanded;
-      });
+    // Clear from history cache - remove all files in the chain
+    setLoadedHistoryFiles(prev => {
+      const newCache = new Map(prev);
 
-      // Clear from history cache - remove all files in the chain
-      setLoadedHistoryFiles(prev => {
-        const newCache = new Map(prev);
+      // Remove cache entries for all deleted files
+      newCache.delete(deletedFileId);
 
-        // Remove cache entries for all deleted files
-        filesToDelete.forEach(id => newCache.delete(id as FileId));
-
-        // Also remove deleted files from any other file's history cache
-        for (const [mainFileId, historyFiles] of newCache.entries()) {
-          const filteredHistory = historyFiles.filter(histFile => !filesToDelete.includes(histFile.id as string));
-          if (filteredHistory.length !== historyFiles.length) {
-            newCache.set(mainFileId, filteredHistory);
-          }
+      // Also remove deleted files from any other file's history cache
+      for (const [mainFileId, historyFiles] of newCache.entries()) {
+        const filteredHistory = historyFiles.filter(histFile => deletedFileId != histFile.id);
+        if (filteredHistory.length !== historyFiles.length) {
+          newCache.set(mainFileId, filteredHistory);
         }
-
-        return newCache;
-      });
-
-      // Delete safe files from IndexedDB
-      try {
-        for (const fileId of filesToDelete) {
-          await fileStorage.deleteStirlingFile(fileId as FileId);
-        }
-      } catch (error) {
-        console.error('Failed to delete files from chain:', error);
       }
 
-      // Call the parent's deletion logic for the main file only
-      onFileRemove(index);
+      return newCache;
+    });
 
-      // Refresh to ensure consistent state
-      await refreshRecentFiles();
+    // Delete safe files from IndexedDB
+    try {
+        await fileStorage.deleteStirlingFile(deletedFileId);
+    } catch (error) {
+      console.error('Failed to delete files from chain:', error);
     }
+
+    // Refresh to ensure consistent state
+    await refreshRecentFiles();
   }, [filteredFiles, onFileRemove, refreshRecentFiles, getSafeFilesToDelete]);
 
   const handleFileDoubleClick = useCallback((file: StirlingFileStub) => {
@@ -337,53 +425,14 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     if (selectedFileIds.length === 0) return;
 
     try {
-      // Get all stored files to analyze lineages
-      const allStoredStubs = await fileStorage.getAllStirlingFileStubs();
-
-      // Get safe files to delete (respecting shared lineages)
-      const filesToDelete = getSafeFilesToDelete(selectedFileIds, allStoredStubs);
-
-      console.log(`Bulk safely deleting files and their history chains:`, filesToDelete);
-
-      // Update history cache synchronously
-      setLoadedHistoryFiles(prev => {
-        const newCache = new Map(prev);
-
-        // Remove cache entries for all deleted files
-        filesToDelete.forEach(id => newCache.delete(id as FileId));
-
-        // Also remove deleted files from any other file's history cache
-        for (const [mainFileId, historyFiles] of newCache.entries()) {
-          const filteredHistory = historyFiles.filter(histFile => !filesToDelete.includes(histFile.id as string));
-          if (filteredHistory.length !== historyFiles.length) {
-            newCache.set(mainFileId, filteredHistory);
-          }
-        }
-
-        return newCache;
-      });
-
-      // Also clear any expanded state for deleted files to prevent ghost entries
-      setExpandedFileIds(prev => {
-        const newExpanded = new Set(prev);
-        filesToDelete.forEach(id => newExpanded.delete(id));
-        return newExpanded;
-      });
-
-      // Clear selection immediately to prevent ghost selections
-      setSelectedFileIds(prev => prev.filter(id => !filesToDelete.includes(id)));
-
-      // Delete safe files from IndexedDB
-      for (const fileId of filesToDelete) {
-        await fileStorage.deleteStirlingFile(fileId as FileId);
+      // Delete each selected file using the proven single delete logic
+      for (const fileId of selectedFileIds) {
+        await handleFileRemoveById(fileId);
       }
-
-      // Refresh the file list to get updated data
-      await refreshRecentFiles();
     } catch (error) {
       console.error('Failed to delete selected files:', error);
     }
-  }, [selectedFileIds, filteredFiles, refreshRecentFiles, getSafeFilesToDelete]);
+  }, [selectedFileIds, handleFileRemoveById]);
 
 
   const handleDownloadSelected = useCallback(async () => {
@@ -540,6 +589,7 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     onLocalFileClick: handleLocalFileClick,
     onFileSelect: handleFileSelect,
     onFileRemove: handleFileRemove,
+    onHistoryFileRemove: handleHistoryFileRemove,
     onFileDoubleClick: handleFileDoubleClick,
     onOpenFiles: handleOpenFiles,
     onSearchChange: handleSearchChange,
@@ -570,6 +620,8 @@ export const FileManagerProvider: React.FC<FileManagerProviderProps> = ({
     handleLocalFileClick,
     handleFileSelect,
     handleFileRemove,
+    handleFileRemoveById,
+    performFileDelete,
     handleFileDoubleClick,
     handleOpenFiles,
     handleSearchChange,