Archive summary refinements and profile switching

2026-05-27 23:11:21 +02:00
parent c12febe029
commit 7777b349a5
37 changed files with 3190 additions and 121 deletions
@@ -41,6 +41,94 @@ public sealed class SpeakerIdentityService : ISpeakerIdentificationService
        return await ProcessTranscriptAsync(request, mode: SpeakerIdentityProcessingMode.LiveReadOnly, cancellationToken);
    }

+    public async Task<SpeakerIdentificationResult> IdentifyFinishedSpeakersAsync(
+        SpeakerIdentificationRequest request,
+        CancellationToken cancellationToken)
+    {
+        return await ProcessTranscriptAsync(request, mode: SpeakerIdentityProcessingMode.LiveReadOnly, cancellationToken);
+    }
+
+    public async Task ApplySpeakerOverrideAsync(
+        SpeakerIdentificationRequest request,
+        string sourceSpeaker,
+        string targetSpeaker,
+        CancellationToken cancellationToken)
+    {
+        if (!options.Enabled ||
+            string.IsNullOrWhiteSpace(sourceSpeaker) ||
+            string.IsNullOrWhiteSpace(targetSpeaker) ||
+            string.Equals(sourceSpeaker, targetSpeaker, StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        var sourceLabel = sourceSpeaker.Trim();
+        var targetName = targetSpeaker.Trim();
+        await using var context = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await SpeakerIdentitySchema.EnsureCreatedOrUpdatedAsync(context, cancellationToken);
+
+        var now = DateTimeOffset.UtcNow;
+        var meetingReference = CreateReference(request.MeetingNote, now);
+        var snippet = await ResolveOverrideSnippetAsync(request, sourceLabel, cancellationToken);
+        var target = await FindIdentityByAcceptedNameAsync(context, targetName, cancellationToken);
+        var sourceCandidate = await FindCurrentRunCandidateAsync(
+            context,
+            meetingReference,
+            targetName,
+            cancellationToken);
+
+        if (target is null)
+        {
+            target = sourceCandidate ?? new SpeakerIdentity
+            {
+                CreatedAt = now,
+                CandidateNames = []
+            };
+            if (target.Id == 0)
+            {
+                context.SpeakerIdentities.Add(target);
+            }
+        }
+        else if (sourceCandidate is not null && sourceCandidate.Id != target.Id)
+        {
+            MergeOverrideCandidate(target, sourceCandidate);
+            context.SpeakerIdentities.Remove(sourceCandidate);
+        }
+
+        target.CanonicalName = targetName;
+        target.UpdatedAt = now;
+        ResetCandidates(target, [targetName]);
+        AddMeetingReference(target, meetingReference);
+        AddSnippetIfNeeded(target, snippet);
+        await context.SaveChangesAsync(cancellationToken);
+        await SpeakerIdentityTranscriptAudit.AppendIdentifiedAsync(
+            target.References,
+            sourceLabel,
+            targetName,
+            cancellationToken);
+    }
+
+    public async Task DeleteSpeakerIdentityAsync(
+        string identity,
+        CancellationToken cancellationToken)
+    {
+        if (!options.Enabled || string.IsNullOrWhiteSpace(identity))
+        {
+            return;
+        }
+
+        await using var context = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        await SpeakerIdentitySchema.EnsureCreatedOrUpdatedAsync(context, cancellationToken);
+        var target = await FindIdentityByAcceptedNameAsync(context, identity.Trim(), cancellationToken);
+        if (target is null)
+        {
+            return;
+        }
+
+        context.SpeakerIdentities.Remove(target);
+        await context.SaveChangesAsync(cancellationToken);
+    }
+
    private async Task<SpeakerIdentificationResult> ProcessTranscriptAsync(
        SpeakerIdentificationRequest request,
        SpeakerIdentityProcessingMode mode,
@@ -250,6 +338,115 @@ public sealed class SpeakerIdentityService : ISpeakerIdentificationService
        return null;
    }

+    private async Task<byte[]> ResolveOverrideSnippetAsync(
+        SpeakerIdentificationRequest request,
+        string sourceSpeaker,
+        CancellationToken cancellationToken)
+    {
+        var sample = request.Samples?
+            .Where(sample => string.Equals(sample.Speaker, sourceSpeaker, StringComparison.OrdinalIgnoreCase))
+            .OrderByDescending(sample => sample.Score)
+            .FirstOrDefault();
+        if (sample is not null)
+        {
+            return sample.WavBytes;
+        }
+
+        var segments = request.Segments
+            .Where(segment => string.Equals(segment.Speaker, sourceSpeaker, StringComparison.OrdinalIgnoreCase))
+            .ToList();
+        return segments.Count == 0
+            ? []
+            : await snippetExtractor.ExtractSnippetAsync(request.AudioPath, segments, cancellationToken);
+    }
+
+    private static async Task<SpeakerIdentity?> FindIdentityByAcceptedNameAsync(
+        SpeakerIdentityDbContext context,
+        string name,
+        CancellationToken cancellationToken)
+    {
+        var identities = await context.SpeakerIdentities
+            .Include(identity => identity.CandidateNames)
+            .Include(identity => identity.Aliases)
+            .Include(identity => identity.Snippets)
+            .Include(identity => identity.References)
+            .ToListAsync(cancellationToken);
+        return identities
+            .Where(identity => GetAcceptedNames(identity).Contains(name))
+            .OrderBy(identity => string.Equals(identity.CanonicalName, name, StringComparison.OrdinalIgnoreCase) ? 0 : 1)
+            .ThenBy(identity => identity.Id)
+            .FirstOrDefault();
+    }
+
+    private static async Task<SpeakerIdentity?> FindCurrentRunCandidateAsync(
+        SpeakerIdentityDbContext context,
+        SpeakerIdentityReference reference,
+        string targetName,
+        CancellationToken cancellationToken)
+    {
+        var candidates = await context.SpeakerIdentities
+            .Include(identity => identity.CandidateNames)
+            .Include(identity => identity.Aliases)
+            .Include(identity => identity.Snippets)
+            .Include(identity => identity.References)
+            .Where(identity => string.IsNullOrWhiteSpace(identity.CanonicalName))
+            .ToListAsync(cancellationToken);
+        return candidates
+            .Where(identity => identity.References.Any(existing => IsSameReference(existing, reference)))
+            .Where(identity => identity.CandidateNames.Any(candidate =>
+                string.Equals(candidate.Name, targetName, StringComparison.OrdinalIgnoreCase)) ||
+                identity.Aliases.Any(alias =>
+                    string.Equals(alias.Name, targetName, StringComparison.OrdinalIgnoreCase)))
+            .OrderBy(identity => identity.Id)
+            .FirstOrDefault();
+    }
+
+    private void MergeOverrideCandidate(
+        SpeakerIdentity target,
+        SpeakerIdentity source)
+    {
+        AddAlias(target, source.CanonicalName);
+        foreach (var alias in source.Aliases)
+        {
+            AddAlias(target, alias.Name);
+        }
+
+        foreach (var candidate in source.CandidateNames)
+        {
+            AddAlias(target, candidate.Name);
+        }
+
+        foreach (var reference in source.References)
+        {
+            SpeakerIdentityReferences.AddIfMissing(target, reference);
+        }
+
+        foreach (var snippet in source.Snippets)
+        {
+            AddSnippetIfNeeded(target, snippet.WavBytes);
+        }
+    }
+
+    private static void AddAlias(SpeakerIdentity identity, string? alias)
+    {
+        if (string.IsNullOrWhiteSpace(alias) ||
+            string.Equals(identity.CanonicalName, alias, StringComparison.OrdinalIgnoreCase) ||
+            identity.Aliases.Any(existing => string.Equals(existing.Name, alias, StringComparison.OrdinalIgnoreCase)))
+        {
+            return;
+        }
+
+        identity.Aliases.Add(new SpeakerAlias { Name = alias.Trim() });
+    }
+
+    private static bool IsSameReference(
+        SpeakerIdentityReference first,
+        SpeakerIdentityReference second)
+    {
+        return string.Equals(first.MeetingNotePath, second.MeetingNotePath, StringComparison.OrdinalIgnoreCase) &&
+            string.Equals(first.TranscriptPath, second.TranscriptPath, StringComparison.OrdinalIgnoreCase);
+    }
+
    private static bool MatchesAcceptedNames(
        SpeakerIdentity identity,
        IReadOnlySet<string> names)