feat: improve file grouping, path-mark sync, file renaming and DLsite

File grouping (FileSystemEntryGroupingService + GroupModal):
- Add exact mode (closes #1074)
- Add structure mode (closes #1075)
- Add tier control for similarity mode (closes #1076)
- Improve grouping preview UI (closes #1077)

Path-mark sync:
- Add resync-all-path-marks action (closes #1078)
- Fix media-library association lost when syncing all marks on a path (fixes #1079)

Misc:
- Support batch file/folder selection in FileNameModifier (closes #1080)
- Fix DLsite enhancer returning no data: add category detection, follow 30x redirects, bypass age gate (fixes #1081)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: anobaka

src/apps/Bakabase.Service/Controllers/FileController.cs

@@ -72,13 +72,15 @@ public class FileController : Controller
         private readonly ISystemPlayer _systemPlayer;
         private readonly IFileManager _fileManager;
         private readonly AppService _appService;
+        private readonly Bakabase.Service.Services.FileSystemEntryGroupingService _groupingService;
 
         public FileController(ISpecialTextService specialTextService, IWebHostEnvironment env,
             CompressedFileService compressedFileService, IBOptionsManager<FileSystemOptions> fsOptionsManager,
             IwFsWatcher fileProcessorWatcher, PasswordService passwordService, ILogger<FileController> logger,
             BakabaseLocalizer localizer, BTaskManager taskManager, IGuiAdapter guiAdapter,
             FfMpegService ffMpegService, HardwareAccelerationService hardwareAccelerationService,
-            ISystemPlayer systemPlayer, IFileManager fileManager, AppService appService)
+            ISystemPlayer systemPlayer, IFileManager fileManager, AppService appService,
+            Bakabase.Service.Services.FileSystemEntryGroupingService groupingService)
         {
             _specialTextService = specialTextService;
             _env = env;
@@ -95,6 +97,7 @@ public FileController(ISpecialTextService specialTextService, IWebHostEnvironmen
             _systemPlayer = systemPlayer;
             _fileManager = fileManager;
             _appService = appService;
+            _groupingService = groupingService;
         }
 
         private static bool IsHiddenEntry(string path)
@@ -1790,96 +1793,26 @@ public async Task<ListResponse<FileSystemEntryGroupResultViewModel>> GroupPrevie
                 return ListResponseBuilder<FileSystemEntryGroupResultViewModel>.NotFound;
             }
 
-            var batches = new Dictionary<string, List<string>>();
-
-            if (model.GroupInternal)
-            {
-                foreach (var rootPath in model.Paths)
-                {
-                    if (System.IO.File.Exists(rootPath))
-                    {
-                        continue;
-                    }
-
-                    if (!Directory.Exists(rootPath))
-                    {
-                        return ListResponseBuilder<FileSystemEntryGroupResultViewModel>.NotFound;
-                    }
-
-                    batches[rootPath] = Directory.GetFiles(rootPath).ToList();
-                }
-            }
-            else
-            {
-                foreach (var pg in model.Paths.GroupBy(Path.GetDirectoryName))
-                {
-                    if (pg.Key.IsNotEmpty())
-                    {
-                        foreach (var path in pg)
-                        {
-                            if (System.IO.File.Exists(path) || Directory.Exists(path))
-                            {
-                                batches.GetOrAdd(pg.Key, _ => []).Add(path);
-                            }
-                        }
-                    }
-                }
-            }
-
-            if (!batches.Any())
+            var results = _groupingService.Preview(model);
+            if (results.Count == 0)
             {
                 return ListResponseBuilder<FileSystemEntryGroupResultViewModel>.NotFound;
             }
 
-            var vms = batches.Select(g =>
-            {
-                var rootPath = g.Key.StandardizePath()!;
-                var vm = new FileSystemEntryGroupResultViewModel
-                {
-                    RootPath = rootPath
-                };
-                if (model.SimilarityThreshold == 1.0m)
-                {
-                    vm.Groups = g.Value.GroupBy(Path.GetFileNameWithoutExtension)
-                        .Where(x => x.Key.IsNotEmpty()).Select(x =>
-                            new FileSystemEntryGroupResultViewModel.GroupViewModel
-                            {
-                                DirectoryName = x.Key.StandardizePath()!,
-                                Filenames = x.Select(y => Path.GetFileName(y)!).ToArray()
-                            }).ToArray();
-                }
-                else
-                {
-                    var groups = new Dictionary<string, List<string>>();
-                    foreach (var path in g.Value)
-                    {
-                        var key = Path.GetFileNameWithoutExtension(path);
-                        if (key.IsNotEmpty())
-                        {
-                            var similarKey =
-                                groups.Keys.FirstOrDefault(x => x.IsSimilarTo(key, model.SimilarityThreshold));
-                            if (similarKey.IsNotEmpty())
-                            {
-                                groups[similarKey].Add(path);
-                            }
-                            else
-                            {
-                                groups[key] = [path];
-                            }
-                        }
-                    }
-
-                    vm.Groups = groups.Select(x => new FileSystemEntryGroupResultViewModel.GroupViewModel
-                    {
-                        DirectoryName = x.Value.Select(x => Path.GetFileNameWithoutExtension(x)!).OrderByDescending(y => y.Length).First().StandardizePath()!,
-                        Filenames = x.Value.Select(y => Path.GetFileName(y)!).ToArray()
-                    }).ToArray();
-                }
+            return new ListResponse<FileSystemEntryGroupResultViewModel>(results);
+        }
 
-                return vm;
-            });
+        [HttpPut("group-similarity-breakpoints")]
+        [SwaggerOperation(OperationId = "GetFileSystemEntriesGroupSimilarityBreakpoints")]
+        public async Task<ListResponse<decimal>> GroupSimilarityBreakpoints(
+            [FromBody] FileSystemEntryGroupInputModel model)
+        {
+            if (model.Paths.Length == 0)
+            {
+                return new ListResponse<decimal>(new[] { 0m, 1m });
+            }
 
-            return new ListResponse<FileSystemEntryGroupResultViewModel>(vms);
+            return new ListResponse<decimal>(_groupingService.ComputeSimilarityBreakpoints(model));
         }
 
         [HttpPut("group")]
@@ -1892,24 +1825,7 @@ public async Task<BaseResponse> Group([FromBody] FileSystemEntryGroupInputModel
                 return r;
             }
 
-            var batches = r.Data!;
-
-            foreach (var batch in batches)
-            {
-                foreach (var group in batch.Groups)
-                {
-                    var dirFullname = Path.Combine(batch.RootPath, group.DirectoryName);
-                    Directory.CreateDirectory(dirFullname);
-                    foreach (var f in group.Filenames)
-                    {
-                        var sourceFile = Path.Combine(batch.RootPath, f);
-                        var fileFullname = Path.Combine(dirFullname, f);
-                        // Use quickly way in same drive
-                        System.IO.File.Move(sourceFile, fileFullname, false);
-                    }
-                }
-            }
-
+            _groupingService.Execute(model, r.Data!.ToList());
             return BaseResponseBuilder.Ok;
         }
 

src/apps/Bakabase.Service/Controllers/PathMarkController.cs

@@ -250,6 +250,30 @@ public async Task<BaseResponse> StartSyncByPath([FromQuery] string path)
         return BaseResponseBuilder.Ok;
     }
 
+    /// <summary>
+    /// Force a full re-sync of every existing path mark — re-marks them as Pending
+    /// (except those already PendingDelete or actively Syncing) and triggers a sync.
+    /// Use this to recover from any state where the index of effects has drifted.
+    /// </summary>
+    [HttpPost("sync/force-all")]
+    [SwaggerOperation(OperationId = "ForceResyncAllPathMarks")]
+    public async Task<BaseResponse> ForceResyncAll()
+    {
+        var allMarks = await service.GetAll(m => !m.IsDeleted);
+        var markIds = allMarks
+            .Where(m => m.SyncStatus != PathMarkSyncStatus.Syncing)
+            .Select(m => m.Id)
+            .ToArray();
+
+        if (markIds.Length == 0)
+        {
+            return BaseResponseBuilder.Ok;
+        }
+
+        await syncService.EnqueueSync(markIds);
+        return BaseResponseBuilder.Ok;
+    }
+
     /// <summary>
     /// Start resource synchronization for a specific source (e.g., Steam, DLsite, ExHentai).
     /// This triggers resource discovery from the source, and if new resources are found,

src/apps/Bakabase.Service/Extensions/BakabaseBusinessExtensions.cs

@@ -55,6 +55,7 @@ public static IServiceCollection AddInsideWorldBusinesses(this IServiceCollectio
             services.AddScoped<PasswordService>();
 
             services.TryAddSingleton<IwFsWatcher>();
+            services.AddSingleton<Bakabase.Service.Services.FileSystemEntryGroupingService>();
 
             #region Optimized after V190
 

src/apps/Bakabase.Service/Models/Input/FileSystemEntryGroupInputModel.cs

@@ -1,11 +1,36 @@
-using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations;
 
 namespace Bakabase.Service.Models.Input;
 
+public enum FileSystemEntryGroupStrategyType
+{
+    Similarity = 0,
+    KeyExtraction = 1,
+    Affix = 2,
+}
+
+public enum FileSystemEntryGroupAffixDirection
+{
+    Prefix = 0,
+    Suffix = 1,
+    Both = 2,
+}
+
 public record FileSystemEntryGroupInputModel
 {
     public string[] Paths { get; set; } = [];
     public bool GroupInternal { get; set; }
+    public FileSystemEntryGroupStrategyType StrategyType { get; set; } =
+        FileSystemEntryGroupStrategyType.Similarity;
+
     [Range(0, 1)]
     public decimal SimilarityThreshold { get; set; } = 1.0m;
-}
+
+    public string? KeyExtractionRegex { get; set; }
+
+    public FileSystemEntryGroupAffixDirection AffixDirection { get; set; } =
+        FileSystemEntryGroupAffixDirection.Prefix;
+
+    [Range(1, 1000)]
+    public int AffixMinLength { get; set; } = 3;
+}

src/apps/Bakabase.Service/Models/View/FileSystemEntryGroupResultViewModel.cs

@@ -1,15 +1,29 @@
-using System.Collections.Generic;
-
 namespace Bakabase.Service.Models.View;
 
 public record FileSystemEntryGroupResultViewModel
 {
     public string RootPath { get; set; } = null!;
     public GroupViewModel[] Groups { get; set; } = [];
+    public EntryViewModel[] UntouchedEntries { get; set; } = [];
 
     public record GroupViewModel
     {
         public string DirectoryName { get; set; } = null!;
-        public string[] Filenames { get; set; } = [];
+        public EntryViewModel[] Entries { get; set; } = [];
+        public string? ExistingFolderTarget { get; set; }
+        public string? RenamedSourceName { get; set; }
+    }
+
+    public record EntryViewModel
+    {
+        public string Name { get; set; } = null!;
+        public bool IsDirectory { get; set; }
+        public MatchSpan[] MatchSpans { get; set; } = [];
+    }
+
+    public record MatchSpan
+    {
+        public int Start { get; set; }
+        public int Length { get; set; }
     }
-}
+}