Add comprehensive debugging to track bulk repository add issue

Author: punkouter25

src/PoRepoLineTracker.Api/Program.cs

@@ -341,14 +341,32 @@ public static WebApplication CreateWebApplication(string[] args)
             {
                 try
                 {
-                    Log.Information("Adding {Count} repositories via bulk endpoint.", repositories?.Count() ?? 0);
+                    Log.Information("=== BULK REPOSITORY ADD ENDPOINT CALLED ===");
+                    Log.Information("Request body received: {IsNull}", repositories == null ? "NULL" : "NOT NULL");
+                    
+                    var repoList = repositories?.ToList() ?? new List<PoRepoLineTracker.Application.Models.BulkRepositoryDto>();
+                    Log.Information("Number of repositories in request: {Count}", repoList.Count);
+                    
+                    // Log each repository in detail
+                    for (int i = 0; i < repoList.Count; i++)
+                    {
+                        var repo = repoList[i];
+                        Log.Information("API Request Repo [{Index}]: Owner='{Owner}', RepoName='{RepoName}', CloneUrl='{CloneUrl}'",
+                            i, repo?.Owner ?? "NULL", repo?.RepoName ?? "NULL", repo?.CloneUrl ?? "NULL");
+                    }
 
+                    Log.Information("Sending AddMultipleRepositoriesCommand to MediatR with {Count} repositories", repoList.Count);
                     var addedRepositories = await mediator.Send(new PoRepoLineTracker.Application.Features.Repositories.Commands.AddMultipleRepositoriesCommand(repositories ?? Enumerable.Empty<PoRepoLineTracker.Application.Models.BulkRepositoryDto>()));
+                    
+                    var addedList = addedRepositories.ToList();
+                    Log.Information("MediatR returned {Count} repositories", addedList.Count);
+                    Log.Information("Repositories returned: {Repos}", string.Join(", ", addedList.Select(r => $"{r.Owner}/{r.Name}")));
+                    
                     return Results.Ok(addedRepositories);
                 }
                 catch (Exception ex)
                 {
-                    Log.Error(ex, "Error adding multiple repositories");
+                    Log.Error(ex, "EXCEPTION in bulk repository endpoint: {Message}. Stack: {StackTrace}", ex.Message, ex.StackTrace);
                     return Results.Problem($"Error adding repositories: {ex.Message}", statusCode: (int)HttpStatusCode.InternalServerError);
                 }
             })

src/PoRepoLineTracker.Application/Features/Repositories/Commands/AddMultipleRepositoriesCommandHandler.cs

@@ -23,24 +23,52 @@ public AddMultipleRepositoriesCommandHandler(
 
     public async Task<IEnumerable<GitHubRepository>> Handle(AddMultipleRepositoriesCommand request, CancellationToken cancellationToken)
     {
-        _logger.LogInformation("Adding {Count} repositories to the system.", request.Repositories.Count());
+        _logger.LogInformation("=== START AddMultipleRepositoriesCommandHandler ===");
+        _logger.LogInformation("Received request to add {Count} repositories", request.Repositories.Count());
+        
+        // Log each repository in the request
+        var repoList = request.Repositories.ToList();
+        for (int i = 0; i < repoList.Count; i++)
+        {
+            var repo = repoList[i];
+            _logger.LogInformation("Repository [{Index}]: Owner='{Owner}', Name='{RepoName}', CloneUrl='{CloneUrl}'", 
+                i, repo.Owner ?? "NULL", repo.RepoName ?? "NULL", repo.CloneUrl ?? "NULL");
+        }
 
         var addedRepositories = new List<GitHubRepository>();
 
         foreach (var repo in request.Repositories)
         {
             try
             {
+                _logger.LogInformation("Processing repository: {Owner}/{Name}", repo.Owner, repo.RepoName);
+                
+                // Validate repository data
+                if (string.IsNullOrWhiteSpace(repo.Owner))
+                {
+                    _logger.LogWarning("Skipping repository with empty Owner. RepoName={RepoName}", repo.RepoName ?? "NULL");
+                    continue;
+                }
+                
+                if (string.IsNullOrWhiteSpace(repo.RepoName))
+                {
+                    _logger.LogWarning("Skipping repository with empty RepoName. Owner={Owner}", repo.Owner ?? "NULL");
+                    continue;
+                }
+                
                 // Check if repository already exists
+                _logger.LogInformation("Checking if repository {Owner}/{Name} already exists...", repo.Owner, repo.RepoName);
                 var existingRepo = await _repositoryDataService.GetRepositoryByOwnerAndNameAsync(repo.Owner, repo.RepoName);
                 if (existingRepo != null)
                 {
-                    _logger.LogInformation("Repository {Owner}/{Name} already exists, skipping.", repo.Owner, repo.RepoName);
+                    _logger.LogInformation("Repository {Owner}/{Name} already exists with ID {Id}, adding to result list.", 
+                        repo.Owner, repo.RepoName, existingRepo.Id);
                     addedRepositories.Add(existingRepo);
                     continue;
                 }
 
                 // Create new repository
+                _logger.LogInformation("Creating new repository entity for {Owner}/{Name}", repo.Owner, repo.RepoName);
                 var newRepo = new GitHubRepository
                 {
                     Id = Guid.NewGuid(),
@@ -50,25 +78,35 @@ public async Task<IEnumerable<GitHubRepository>> Handle(AddMultipleRepositoriesC
                     LastAnalyzedCommitDate = DateTime.MinValue // Default value
                 };
 
+                _logger.LogInformation("Saving repository {Owner}/{Name} to database with ID {Id}", 
+                    newRepo.Owner, newRepo.Name, newRepo.Id);
                 await _repositoryDataService.AddRepositoryAsync(newRepo);
+                
+                _logger.LogInformation("Successfully saved repository {Owner}/{Name}. Adding to result list.", 
+                    newRepo.Owner, newRepo.Name);
                 addedRepositories.Add(newRepo);
 
-                _logger.LogInformation("Successfully added repository {Owner}/{Name} with ID {Id}. Dispatching AnalyzeRepositoryCommitsCommand.",
+                _logger.LogInformation("Dispatching AnalyzeRepositoryCommitsCommand for repository {Owner}/{Name} (ID: {Id})",
                     newRepo.Owner, newRepo.Name, newRepo.Id);
 
                 // Dispatch command to analyze the newly added repository
                 await _mediator.Send(new AnalyzeRepositoryCommitsCommand(newRepo.Id), cancellationToken);
+                
+                _logger.LogInformation("Analysis command dispatched for repository {Owner}/{Name}", newRepo.Owner, newRepo.Name);
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Failed to add repository {Owner}/{Name}: {Message}",
-                    repo.Owner, repo.RepoName, ex.Message);
+                _logger.LogError(ex, "EXCEPTION while adding repository {Owner}/{Name}: {Message}. Stack: {StackTrace}",
+                    repo.Owner ?? "NULL", repo.RepoName ?? "NULL", ex.Message, ex.StackTrace);
                 // Continue with other repositories even if one fails
             }
         }
 
-        _logger.LogInformation("Successfully added {Count} out of {Total} repositories.",
+        _logger.LogInformation("=== COMPLETED AddMultipleRepositoriesCommandHandler ===");
+        _logger.LogInformation("Final result: Successfully added {Count} out of {Total} repositories.",
             addedRepositories.Count, request.Repositories.Count());
+        _logger.LogInformation("Repository IDs added: {Ids}", 
+            string.Join(", ", addedRepositories.Select(r => $"{r.Owner}/{r.Name} ({r.Id})")));
 
         return addedRepositories;
     }

src/PoRepoLineTracker.Client/Pages/AddRepository.razor

@@ -245,6 +245,17 @@
 
         try
         {
+            Logger.LogInformation("=== START AddSelectedRepositories ===");
+            Logger.LogInformation("Number of selected repositories: {Count}", pageState.SelectedRepositories.Count);
+            
+            // Log each selected repository
+            for (int i = 0; i < pageState.SelectedRepositories.Count; i++)
+            {
+                var repo = pageState.SelectedRepositories[i];
+                Logger.LogInformation("Selected Repo [{Index}]: FullName='{FullName}', CloneUrl='{CloneUrl}'", 
+                    i, repo.FullName, repo.CloneUrl);
+            }
+            
             // Step 1: Prepare repository data (25%)
             pageState.SetProgress($"Preparing {pageState.SelectedRepositories.Count} repositories...", 25);
             StateHasChanged();
@@ -253,6 +264,9 @@
             var repositoriesToAdd = pageState.SelectedRepositories.Select(repo =>
             {
                 var fullNameParts = repo.FullName.Split('/');
+                Logger.LogInformation("Splitting FullName '{FullName}' into Owner='{Owner}' and RepoName='{RepoName}'",
+                    repo.FullName, fullNameParts[0], fullNameParts[1]);
+                    
                 return new BulkRepositoryDto
                 {
                     Owner = fullNameParts[0],
@@ -261,14 +275,21 @@
                 };
             }).ToList();
 
-            Logger.LogInformation("About to add {Count} repositories: {Repositories}", 
-                repositoriesToAdd.Count, 
-                string.Join(", ", repositoriesToAdd.Select(r => $"{r.Owner}/{r.RepoName}")));
+            Logger.LogInformation("Prepared {Count} repositories for API call", repositoriesToAdd.Count);
+            
+            // Log detailed info about what we're sending
+            for (int i = 0; i < repositoriesToAdd.Count; i++)
+            {
+                var repo = repositoriesToAdd[i];
+                Logger.LogInformation("Sending Repo [{Index}]: Owner='{Owner}', RepoName='{RepoName}', CloneUrl='{CloneUrl}'",
+                    i, repo.Owner, repo.RepoName, repo.CloneUrl);
+            }
 
             // Step 2: Adding to database (50%)
             pageState.SetProgress("Adding repositories to database...", 50);
             StateHasChanged();
 
+            Logger.LogInformation("Making POST request to /api/repositories/bulk with {Count} repositories", repositoriesToAdd.Count);
             var response = await Http.PostAsJsonAsync("/api/repositories/bulk", repositoriesToAdd);
 
             Logger.LogInformation("Bulk repository add response: Status={StatusCode}", response.StatusCode);
@@ -280,8 +301,25 @@
                 StateHasChanged();
                 await Task.Delay(500);
 
+                Logger.LogInformation("Reading response content as JSON...");
                 var addedRepos = await response.Content.ReadFromJsonAsync<List<GitHubRepository>>();
 
+                Logger.LogInformation("API returned {Count} repositories", addedRepos?.Count ?? 0);
+                
+                if (addedRepos != null && addedRepos.Any())
+                {
+                    for (int i = 0; i < addedRepos.Count; i++)
+                    {
+                        var repo = addedRepos[i];
+                        Logger.LogInformation("Returned Repo [{Index}]: {Owner}/{Name} (ID: {Id})",
+                            i, repo.Owner, repo.Name, repo.Id);
+                    }
+                }
+                else
+                {
+                    Logger.LogWarning("API returned ZERO repositories! This is the problem!");
+                }
+                
                 // Step 4: Complete (100%)
                 pageState.SetProgress("Complete! Repositories are now being analyzed.", 100);
                 StateHasChanged();