From 345dd011476854c3934504395055e3116248cd3b Mon Sep 17 00:00:00 2001 From: hauke Date: Fri, 6 Nov 2026 11:17:40 +0100 Subject: [PATCH] feat #14740: merge speakers and name calls Co-Authored-By: Claude Opus 5.5 (1M context) --- crates/core/src/call_view.rs | 149 ++++++++++++- crates/core/src/merge.rs | 234 ++++++++++++++++++++ crates/core/src/model.rs | 2 + crates/core/src/retention.rs | 1 + crates/core/src/store.rs | 358 +++++++++++++++++++++++++++++-- src-tauri/src/commands.rs | 40 ++++ src-tauri/src/lib.rs | 3 + src-tauri/src/state.rs | 144 ++++++++++++- ui/src/lib/CallList.svelte | 13 +- ui/src/lib/TranscriptView.svelte | 162 +++++++++++++- ui/src/lib/api.ts | 19 ++ ui/src/routes/Main.svelte | 117 +++++++++- 12 files changed, 1213 insertions(+), 29 deletions(-) diff --git a/crates/core/src/call_view.rs b/crates/core/src/call_view.rs index 0dda02d..53c5db7 100644 --- a/crates/core/src/call_view.rs +++ b/crates/core/src/call_view.rs @@ -7,7 +7,7 @@ use chrono::{DateTime, Local}; use serde::Serialize; use crate::merge; -use crate::model::{Call, CallId, CallStatus, Segment}; +use crate::model::{Call, CallId, CallStatus, Segment, Speaker}; /// A row of the call list. #[derive(Serialize, Clone, Debug, PartialEq)] @@ -19,6 +19,8 @@ pub struct CallListItem { pub duration_secs: i64, pub status: CallStatus, pub interrupted: bool, + /// The name the user gave the call, if any. + pub title: Option, } impl CallListItem { @@ -30,6 +32,7 @@ impl CallListItem { duration_secs: duration_secs(call), status: call.status, interrupted: call.interrupted, + title: call.title.clone(), } } } @@ -62,19 +65,43 @@ pub struct SegmentView { pub text: String, } +/// A merged speaker: "Sprecher 2 → Frau Beispiel zusammengeführt". +#[derive(Serialize, Clone, Debug, PartialEq)] +pub struct MergeView { + pub from_key: String, + /// The source's default label: its own rename is not in effect while + /// it is merged. + pub from_label: String, + /// The speaker the source's lines now belong to (the end of a chain of + /// merges). + pub into_key: String, + pub into_label: String, +} + /// Everything the detail pane shows about one call. #[derive(Serialize, Clone, Debug, PartialEq)] pub struct CallDetail { pub call: CallHeader, + /// The transcript with speaker merges applied + /// ([`merge::apply_merges`]). pub segments: Vec, /// Renamed speakers by key; speakers not in here keep their default /// label. pub speaker_names: BTreeMap, + /// The call's speaker merges, by source speaker number. + pub merges: Vec, } impl CallDetail { - pub fn of(call: &Call, segments: &[Segment], speaker_names: BTreeMap) -> Self { - let segments = segments + /// `segments` are the stored ones; `merges` the stored speaker merges + /// (source key → target key). + pub fn of( + call: &Call, + segments: &[Segment], + speaker_names: BTreeMap, + merges: &BTreeMap, + ) -> Self { + let segments = merge::apply_merges(segments, merges) .iter() .map(|segment| SegmentView { speaker_key: segment.speaker.key(), @@ -91,11 +118,37 @@ impl CallDetail { account_id: call.account_id.clone(), }, segments, + merges: merge_views(merges, &speaker_names), speaker_names, } } } +fn merge_views( + merges: &BTreeMap, + speaker_names: &BTreeMap, +) -> Vec { + let mut views: Vec<(u32, MergeView)> = merge::resolve_merges(merges) + .into_iter() + .filter_map(|(from_key, into_key)| { + let (Some(Speaker::Remote(n)), Some(into)) = + (Speaker::from_key(&from_key), Speaker::from_key(&into_key)) + else { + return None; + }; + let view = MergeView { + from_label: Speaker::Remote(n).default_label(), + into_label: merge::label(&into, speaker_names), + from_key, + into_key, + }; + Some((n, view)) + }) + .collect(); + views.sort_by_key(|(n, _)| *n); + views.into_iter().map(|(_, view)| view).collect() +} + #[cfg(test)] mod tests { use std::path::PathBuf; @@ -124,6 +177,7 @@ mod tests { transcribed_at: None, audio_deleted: false, account_id: None, + title: None, } } @@ -161,8 +215,12 @@ mod tests { duration_secs: 60, status: CallStatus::AwaitingDecision, interrupted: true, + title: None, } ); + + c.title = Some("Angebot Rioja".into()); + assert_eq!(CallListItem::of(&c).title.as_deref(), Some("Angebot Rioja")); } #[test] @@ -176,7 +234,12 @@ mod tests { names.insert("remote:1".to_string(), "Frau Beispiel".to_string()); names.insert("remote:2".to_string(), " ".to_string()); - let detail = CallDetail::of(&call(Some(at(10, 15, 0))), &segments, names.clone()); + let detail = CallDetail::of( + &call(Some(at(10, 15, 0))), + &segments, + names.clone(), + &BTreeMap::new(), + ); let lines: Vec<_> = detail .segments @@ -194,6 +257,72 @@ mod tests { assert_eq!(detail.segments[1].start, 2.5); assert_eq!(detail.segments[1].end, 4.5); assert_eq!(detail.speaker_names, names); + assert_eq!(detail.merges, []); + } + + fn keys(pairs: &[(&str, &str)]) -> BTreeMap { + pairs + .iter() + .map(|(a, b)| (a.to_string(), b.to_string())) + .collect() + } + + #[test] + fn detail_shows_merged_speakers_under_their_target() { + let segments = [ + segment(Speaker::Remote(1), 0.0, "Guten Tag,"), + segment(Speaker::Remote(2), 2.5, "hier Weingut Beispiel."), + segment(Speaker::Me, 5.0, "Hallo."), + segment(Speaker::Remote(3), 7.5, "Zur Lieferung:"), + segment(Speaker::Remote(4), 10.0, "Moin."), + ]; + let names = keys(&[("remote:1", "Frau Beispiel"), ("remote:2", "Herr Probe")]); + let merges = keys(&[ + ("remote:3", "remote:2"), + ("remote:2", "remote:1"), + ("remote:10", "remote:4"), + ]); + + let detail = CallDetail::of(&call(Some(at(10, 15, 0))), &segments, names, &merges); + + let lines: Vec<_> = detail + .segments + .iter() + .map(|s| (s.speaker_key.as_str(), s.label.as_str(), s.text.as_str())) + .collect(); + assert_eq!( + lines, + [ + ( + "remote:1", + "Frau Beispiel", + "Guten Tag, hier Weingut Beispiel." + ), + ("me", "Ich", "Hallo."), + ("remote:1", "Frau Beispiel", "Zur Lieferung:"), + ("remote:4", "Sprecher 4", "Moin."), + ] + ); + let merge_lines: Vec<_> = detail + .merges + .iter() + .map(|m| { + ( + m.from_key.as_str(), + m.from_label.as_str(), + m.into_key.as_str(), + m.into_label.as_str(), + ) + }) + .collect(); + assert_eq!( + merge_lines, + [ + ("remote:2", "Sprecher 2", "remote:1", "Frau Beispiel"), + ("remote:3", "Sprecher 3", "remote:1", "Frau Beispiel"), + ("remote:10", "Sprecher 10", "remote:4", "Sprecher 4"), + ] + ); } #[test] @@ -202,8 +331,11 @@ mod tests { c.status = CallStatus::Failed; c.error = Some("Netzwerkfehler".into()); c.account_id = Some("mock-2".into()); + c.title = Some("Reklamation".into()); + let merges = keys(&[("remote:2", "remote:1")]); - let value = serde_json::to_value(CallDetail::of(&c, &[], BTreeMap::new())).unwrap(); + let value = + serde_json::to_value(CallDetail::of(&c, &[], BTreeMap::new(), &merges)).unwrap(); assert_eq!( value, @@ -215,11 +347,18 @@ mod tests { "duration_secs": 60, "status": "failed", "interrupted": false, + "title": "Reklamation", "error": "Netzwerkfehler", "account_id": "mock-2", }, "segments": [], "speaker_names": {}, + "merges": [{ + "from_key": "remote:2", + "from_label": "Sprecher 2", + "into_key": "remote:1", + "into_label": "Sprecher 1", + }], }) ); } diff --git a/crates/core/src/merge.rs b/crates/core/src/merge.rs index 9270d88..8f3e953 100644 --- a/crates/core/src/merge.rs +++ b/crates/core/src/merge.rs @@ -7,6 +7,8 @@ use std::cmp::Ordering; use std::collections::BTreeMap; +use thiserror::Error; + use crate::model::{Segment, Speaker, Word}; /// Longest gap, in seconds, that still belongs to the same segment. A gap @@ -94,6 +96,103 @@ pub fn label(speaker: &Speaker, names: &BTreeMap) -> String { } } +/// Why a speaker merge (`from` → `into`) was refused. +#[derive(Debug, Clone, PartialEq, Eq, Error)] +pub enum MergeError { + #[error("Unbekannter Sprecher: {0}")] + UnknownSpeaker(String), + #[error("„Ich“ kann nicht zusammengeführt werden")] + Me, + #[error("Ein Sprecher kann nicht mit sich selbst zusammengeführt werden")] + SameSpeaker, + #[error("Diese Zuordnung würde eine Schleife ergeben")] + Cycle, +} + +/// Checks whether `from_key` may be merged into `into_key` on top of the +/// call's existing `merges` (source key → target key): both must be +/// distinct remote speakers, and with the new merge in place (replacing +/// `from_key`'s own, if any) following the targets must not run in a loop. +pub fn check_merge( + merges: &BTreeMap, + from_key: &str, + into_key: &str, +) -> Result<(), MergeError> { + for key in [from_key, into_key] { + match Speaker::from_key(key) { + Some(Speaker::Remote(_)) => {} + Some(Speaker::Me) => return Err(MergeError::Me), + None => return Err(MergeError::UnknownSpeaker(key.to_string())), + } + } + if from_key == into_key { + return Err(MergeError::SameSpeaker); + } + let mut proposed: BTreeMap<&str, &str> = merges + .iter() + .map(|(from, into)| (from.as_str(), into.as_str())) + .collect(); + proposed.insert(from_key, into_key); + match final_target(&proposed, from_key) { + Some(_) => Ok(()), + None => Err(MergeError::Cycle), + } +} + +/// Resolves stored merges (source key → target key) to each source's final +/// target, following chains (3 → 2 and 2 → 1 give 3 → 1). Merges involving +/// anything but two remote speakers, and merges caught in a cycle, are +/// ignored; [`check_merge`] keeps both from being stored. +pub fn resolve_merges(merges: &BTreeMap) -> BTreeMap { + let is_remote = |key: &str| matches!(Speaker::from_key(key), Some(Speaker::Remote(_))); + let usable: BTreeMap<&str, &str> = merges + .iter() + .filter(|(from, into)| is_remote(from) && is_remote(into)) + .map(|(from, into)| (from.as_str(), into.as_str())) + .collect(); + + usable + .keys() + .filter_map(|&from| Some((from.to_string(), final_target(&usable, from)?.to_string()))) + .collect() +} + +/// Follows `merges` from `key` to a speaker that is not merged itself, or +/// `None` if the chain runs in a cycle. +fn final_target<'a>(merges: &BTreeMap<&'a str, &'a str>, key: &'a str) -> Option<&'a str> { + let mut current = key; + for _ in 0..=merges.len() { + match merges.get(current) { + Some(&next) => current = next, + None => return Some(current), + } + } + None +} + +/// The call's transcript as the user sees it after merging speakers: +/// every segment of a merged source is attributed to its final target (see +/// [`resolve_merges`]), then segments left adjacent with the same speaker +/// are joined under the same 1.5 s gap rule as step 4 of [`merge`]. The +/// stored segments stay untouched, so removing a merge restores them. +pub fn apply_merges(segments: &[Segment], merges: &BTreeMap) -> Vec { + let resolved = resolve_merges(merges); + let mapped = segments + .iter() + .map(|segment| { + let speaker = resolved + .get(&segment.speaker.key()) + .and_then(|target| Speaker::from_key(target)) + .unwrap_or(segment.speaker); + Segment { + speaker, + ..segment.clone() + } + }) + .collect(); + merge_adjacent(mapped) +} + /// Orders by `start` (NaN treated as `0.0`), then — for ties — puts the mic /// first and orders remote speakers by ascending number. fn cmp_for_merge_order(a: &Segment, b: &Segment) -> Ordering { @@ -238,6 +337,141 @@ fn join_text(a: &str, b: &str) -> String { } } +#[cfg(test)] +mod speaker_merge_tests { + use super::{apply_merges, check_merge, label, resolve_merges, MergeError}; + use crate::model::{Segment, Speaker}; + use std::collections::BTreeMap; + + fn merges(pairs: &[(&str, &str)]) -> BTreeMap { + pairs + .iter() + .map(|(from, into)| (from.to_string(), into.to_string())) + .collect() + } + + fn seg(speaker: Speaker, start: f64, end: f64, text: &str) -> Segment { + Segment { + speaker, + start, + end, + text: text.to_string(), + } + } + + #[test] + fn chains_resolve_to_the_final_speaker() { + let resolved = resolve_merges(&merges(&[ + ("remote:3", "remote:2"), + ("remote:2", "remote:1"), + ])); + assert_eq!( + resolved, + merges(&[("remote:2", "remote:1"), ("remote:3", "remote:1")]) + ); + } + + #[test] + fn a_stored_cycle_or_a_mapping_involving_me_is_ignored() { + let resolved = resolve_merges(&merges(&[ + ("remote:1", "remote:2"), + ("remote:2", "remote:1"), + ("remote:3", "me"), + ("me", "remote:4"), + ("remote:5", "remote:4"), + ])); + assert_eq!(resolved, merges(&[("remote:5", "remote:4")])); + } + + #[test] + fn a_merge_that_closes_a_cycle_is_rejected() { + let existing = merges(&[("remote:3", "remote:2"), ("remote:2", "remote:1")]); + assert_eq!( + check_merge(&existing, "remote:1", "remote:3"), + Err(MergeError::Cycle) + ); + assert_eq!( + MergeError::Cycle.to_string(), + "Diese Zuordnung würde eine Schleife ergeben" + ); + assert_eq!(check_merge(&existing, "remote:4", "remote:3"), Ok(())); + // Re-pointing an existing merge replaces it instead of chaining. + assert_eq!(check_merge(&existing, "remote:2", "remote:4"), Ok(())); + } + + #[test] + fn me_is_never_merged() { + let none = BTreeMap::new(); + assert_eq!(check_merge(&none, "me", "remote:1"), Err(MergeError::Me)); + assert_eq!(check_merge(&none, "remote:1", "me"), Err(MergeError::Me)); + } + + #[test] + fn a_speaker_is_not_merged_into_itself_or_an_unknown_key() { + let none = BTreeMap::new(); + assert_eq!( + check_merge(&none, "remote:1", "remote:1"), + Err(MergeError::SameSpeaker) + ); + assert_eq!( + check_merge(&none, "remote:x", "remote:1"), + Err(MergeError::UnknownSpeaker("remote:x".into())) + ); + assert_eq!( + MergeError::UnknownSpeaker("remote:x".into()).to_string(), + "Unbekannter Sprecher: remote:x" + ); + } + + #[test] + fn applied_merges_rejoin_adjacent_segments_and_keep_others_apart() { + let segments = [ + seg(Speaker::Remote(1), 0.0, 2.0, "Guten Tag,"), + seg(Speaker::Remote(2), 2.5, 4.0, "hier ist das Weingut."), + seg(Speaker::Me, 4.5, 6.0, "Hallo."), + seg(Speaker::Remote(2), 6.5, 7.0, "Also,"), + // 2 s after the previous line: adjacent, but too far apart. + seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."), + ]; + + let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")])); + + assert_eq!( + merged, + [ + seg( + Speaker::Remote(1), + 0.0, + 4.0, + "Guten Tag, hier ist das Weingut." + ), + seg(Speaker::Me, 4.5, 6.0, "Hallo."), + seg(Speaker::Remote(1), 6.5, 7.0, "Also,"), + seg(Speaker::Remote(1), 9.0, 10.0, "die Lieferung."), + ] + ); + } + + #[test] + fn merged_speakers_take_the_targets_name_and_undo_restores_them() { + let segments = [ + seg(Speaker::Remote(1), 0.0, 1.0, "Eins."), + seg(Speaker::Me, 1.5, 2.0, "Ja."), + seg(Speaker::Remote(2), 2.5, 3.0, "Zwei."), + ]; + let names = merges(&[("remote:1", "Frau Beispiel"), ("remote:2", "Herr Probe")]); + + let merged = apply_merges(&segments, &merges(&[("remote:2", "remote:1")])); + let labels: Vec<_> = merged.iter().map(|s| label(&s.speaker, &names)).collect(); + assert_eq!(labels, ["Frau Beispiel", "Ich", "Frau Beispiel"]); + + // Undo: without the merge, the original segments and names return. + let restored = apply_merges(&segments, &BTreeMap::new()); + assert_eq!(restored, segments); + assert_eq!(label(&restored[2].speaker, &names), "Herr Probe"); + } +} + #[cfg(test)] mod tests { use super::{label, merge}; diff --git a/crates/core/src/model.rs b/crates/core/src/model.rs index 6f92577..1b0f4bf 100644 --- a/crates/core/src/model.rs +++ b/crates/core/src/model.rs @@ -38,6 +38,8 @@ pub struct Call { pub transcribed_at: Option>, pub audio_deleted: bool, pub account_id: Option, + /// The name the user gave the call, if any. + pub title: Option, } /// A single transcribed word with its timing and speaker attribution. diff --git a/crates/core/src/retention.rs b/crates/core/src/retention.rs index a3feea9..9ff1965 100644 --- a/crates/core/src/retention.rs +++ b/crates/core/src/retention.rs @@ -89,6 +89,7 @@ mod tests { transcribed_at: None, audio_deleted: false, account_id: None, + title: None, } } diff --git a/crates/core/src/store.rs b/crates/core/src/store.rs index b5c0497..04eb3cf 100644 --- a/crates/core/src/store.rs +++ b/crates/core/src/store.rs @@ -6,11 +6,15 @@ use std::path::{Path, PathBuf}; use std::sync::Mutex; use chrono::{DateTime, Local}; -use rusqlite::{params, Connection, Row}; +use rusqlite::{params, Connection, Row, TransactionBehavior}; use thiserror::Error; +use crate::merge::{self, MergeError}; use crate::model::{Call, CallId, CallStatus, Segment, Speaker, Summary}; +/// Longest call title, in characters. +const MAX_TITLE_CHARS: usize = 120; + /// Errors a [`Store`] operation can fail with. #[derive(Debug, Error)] pub enum StoreError { @@ -22,6 +26,13 @@ pub enum StoreError { /// speaker key or malformed summary JSON. #[error("corrupt stored value: {0}")] Corrupt(String), + + /// A speaker merge that [`merge::check_merge`] refused. + #[error(transparent)] + Merge(#[from] MergeError), + + #[error("Titel zu lang (max. 120 Zeichen)")] + TitleTooLong, } pub type Result = std::result::Result; @@ -40,7 +51,8 @@ pub struct RecoveryReport { pub failed: Vec, } -const SCHEMA_SQL: &str = " +/// Version 1: the first release. +const SCHEMA_V1_SQL: &str = " CREATE TABLE IF NOT EXISTS calls ( id INTEGER PRIMARY KEY AUTOINCREMENT, app TEXT NOT NULL, @@ -88,6 +100,22 @@ CREATE TABLE IF NOT EXISTS remote_jobs ( ); "; +/// Version 2: call titles and reversible speaker merges. +const SCHEMA_V2_SQL: &str = " +ALTER TABLE calls ADD COLUMN title TEXT; + +CREATE TABLE speaker_merges ( + call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE, + from_key TEXT NOT NULL, + into_key TEXT NOT NULL, + PRIMARY KEY (call_id, from_key) +); +"; + +/// Schema steps by `PRAGMA user_version`: entry `i` takes a database from +/// version `i` to `i + 1`. A new database runs all of them. +const MIGRATIONS: &[&str] = &[SCHEMA_V1_SQL, SCHEMA_V2_SQL]; + /// SQLite-backed store for calls and everything derived from them. pub struct Store { conn: Mutex, @@ -106,15 +134,9 @@ impl Store { Self::init(conn) } - fn init(conn: Connection) -> Result { + fn init(mut conn: Connection) -> Result { conn.execute_batch("PRAGMA foreign_keys = ON;")?; - - let user_version: i64 = conn.query_row("PRAGMA user_version", [], |row| row.get(0))?; - if user_version < 1 { - conn.execute_batch(SCHEMA_SQL)?; - conn.execute_batch("PRAGMA user_version = 1;")?; - } - + migrate(&mut conn)?; Ok(Store { conn: Mutex::new(conn), }) @@ -309,6 +331,55 @@ impl Store { Ok(names) } + /// Merges remote speaker `from_key` into `into_key` for call `id`, + /// replacing an earlier merge of `from_key`. Refused (see + /// [`merge::check_merge`]) for "me", a speaker merged into itself, and a + /// merge that would make the call's merges loop. + pub fn set_speaker_merge(&self, id: CallId, from_key: &str, into_key: &str) -> Result<()> { + let mut conn = self.conn.lock().unwrap(); + let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?; + merge::check_merge(&merges_of(&tx, id)?, from_key, into_key)?; + tx.execute( + "INSERT INTO speaker_merges (call_id, from_key, into_key) VALUES (?1, ?2, ?3) \ + ON CONFLICT(call_id, from_key) DO UPDATE SET into_key = excluded.into_key", + params![id, from_key, into_key], + )?; + tx.commit()?; + Ok(()) + } + + /// Undoes the merge of `from_key`. Not an error if it was not merged. + pub fn remove_speaker_merge(&self, id: CallId, from_key: &str) -> Result<()> { + let conn = self.conn.lock().unwrap(); + conn.execute( + "DELETE FROM speaker_merges WHERE call_id = ?1 AND from_key = ?2", + params![id, from_key], + )?; + Ok(()) + } + + /// The call's speaker merges, source key → target key as stored (chains + /// are resolved by [`merge::resolve_merges`]). + pub fn speaker_merges(&self, id: CallId) -> Result> { + let conn = self.conn.lock().unwrap(); + merges_of(&conn, id) + } + + /// Names the call. The title is trimmed; an empty or missing one clears + /// it. Longer than 120 characters is refused. + pub fn set_title(&self, id: CallId, title: Option<&str>) -> Result<()> { + let title = title.map(str::trim).filter(|t| !t.is_empty()); + if title.is_some_and(|t| t.chars().count() > MAX_TITLE_CHARS) { + return Err(StoreError::TitleTooLong); + } + let conn = self.conn.lock().unwrap(); + conn.execute( + "UPDATE calls SET title = ?1 WHERE id = ?2", + params![title, id], + )?; + Ok(()) + } + pub fn mark_transcribed(&self, id: CallId, at: DateTime) -> Result<()> { let conn = self.conn.lock().unwrap(); conn.execute( @@ -328,13 +399,14 @@ impl Store { } /// Deletes a call and every row derived from it (segments, summary, - /// speaker names, remote jobs). + /// speaker names and merges, remote jobs). pub fn delete_call(&self, id: CallId) -> Result<()> { let mut conn = self.conn.lock().unwrap(); let tx = conn.transaction()?; tx.execute("DELETE FROM segments WHERE call_id = ?1", params![id])?; tx.execute("DELETE FROM summaries WHERE call_id = ?1", params![id])?; tx.execute("DELETE FROM speaker_names WHERE call_id = ?1", params![id])?; + tx.execute("DELETE FROM speaker_merges WHERE call_id = ?1", params![id])?; tx.execute("DELETE FROM remote_jobs WHERE call_id = ?1", params![id])?; tx.execute("DELETE FROM calls WHERE id = ?1", params![id])?; tx.commit()?; @@ -436,6 +508,34 @@ impl Store { } } +/// Brings the schema to the newest version in one transaction, so a failed +/// upgrade leaves the database as it was. Running it on an up-to-date +/// database changes nothing. +fn migrate(conn: &mut Connection) -> Result<()> { + let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?; + let version: i64 = tx.query_row("PRAGMA user_version", [], |row| row.get(0))?; + let done = usize::try_from(version).unwrap_or(0); + if done < MIGRATIONS.len() { + for step in &MIGRATIONS[done..] { + tx.execute_batch(step)?; + } + tx.execute_batch(&format!("PRAGMA user_version = {};", MIGRATIONS.len()))?; + } + tx.commit()?; + Ok(()) +} + +fn merges_of(conn: &Connection, id: CallId) -> Result> { + let mut stmt = + conn.prepare("SELECT from_key, into_key FROM speaker_merges WHERE call_id = ?1")?; + let mut rows = stmt.query(params![id])?; + let mut merges = BTreeMap::new(); + while let Some(row) = rows.next()? { + merges.insert(row.get(0)?, row.get(1)?); + } + Ok(merges) +} + /// Ids of calls currently in `status`, ordered by id (insertion order). fn ids_with_status(conn: &rusqlite::Connection, status: CallStatus) -> Result> { let mut stmt = conn.prepare("SELECT id FROM calls WHERE status = ?1 ORDER BY id ASC")?; @@ -447,9 +547,9 @@ fn ids_with_status(conn: &rusqlite::Connection, status: CallStatus) -> Result Result { let id: CallId = row.get(0)?; @@ -464,6 +564,7 @@ fn row_to_call(row: &Row) -> Result { let transcribed_at: Option = row.get(9)?; let audio_deleted: bool = row.get(10)?; let account_id: Option = row.get(11)?; + let title: Option = row.get(12)?; Ok(Call { id, @@ -478,6 +579,7 @@ fn row_to_call(row: &Row) -> Result { transcribed_at: opt_dt_from_str(transcribed_at)?, audio_deleted, account_id, + title, }) } @@ -540,6 +642,234 @@ mod tests { }; use crate::store::Store; + /// The schema of user_version 1, exactly as the first release created + /// it, so the upgrade runs against what users have on disk. + const RELEASED_V1_SCHEMA_SQL: &str = " +CREATE TABLE IF NOT EXISTS calls ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + app TEXT NOT NULL, + started_at TEXT NOT NULL, + ended_at TEXT, + status TEXT NOT NULL, + interrupted INTEGER NOT NULL, + error TEXT, + mic_path TEXT NOT NULL, + out_path TEXT NOT NULL, + transcribed_at TEXT, + audio_deleted INTEGER NOT NULL, + account_id TEXT +); + +CREATE TABLE IF NOT EXISTS segments ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE, + seq INTEGER NOT NULL, + speaker TEXT NOT NULL, + start_ts REAL NOT NULL, + end_ts REAL NOT NULL, + text TEXT NOT NULL +); +CREATE INDEX IF NOT EXISTS segments_call_id_idx ON segments(call_id); + +CREATE TABLE IF NOT EXISTS summaries ( + call_id INTEGER PRIMARY KEY REFERENCES calls(id) ON DELETE CASCADE, + json TEXT NOT NULL, + edited INTEGER NOT NULL +); + +CREATE TABLE IF NOT EXISTS speaker_names ( + call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE, + speaker_key TEXT NOT NULL, + name TEXT NOT NULL, + PRIMARY KEY (call_id, speaker_key) +); + +CREATE TABLE IF NOT EXISTS remote_jobs ( + call_id INTEGER NOT NULL REFERENCES calls(id) ON DELETE CASCADE, + track TEXT NOT NULL, + remote_id TEXT NOT NULL, + PRIMARY KEY (call_id, track, remote_id) +); +"; + + fn user_version(path: &Path) -> i64 { + rusqlite::Connection::open(path) + .unwrap() + .query_row("PRAGMA user_version", [], |row| row.get(0)) + .unwrap() + } + + fn new_call(store: &Store) -> CallId { + store + .create_call("teams.exe", Local::now(), Path::new(""), Path::new("")) + .unwrap() + } + + fn merge_map(pairs: &[(&str, &str)]) -> BTreeMap { + pairs + .iter() + .map(|(from, into)| (from.to_string(), into.to_string())) + .collect() + } + + #[test] + fn a_new_database_starts_at_version_2() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("calls.sqlite"); + let store = Store::open(&path).unwrap(); + let id = new_call(&store); + store.set_title(id, Some("Angebot")).unwrap(); + store.set_speaker_merge(id, "remote:2", "remote:1").unwrap(); + drop(store); + + assert_eq!(user_version(&path), 2); + } + + #[test] + fn a_version_1_database_is_upgraded_keeping_its_data() { + let dir = tempfile::tempdir().unwrap(); + let path = dir.path().join("calls.sqlite"); + let started = "2026-11-05T10:14:00+01:00"; + { + let conn = rusqlite::Connection::open(&path).unwrap(); + conn.execute_batch(RELEASED_V1_SCHEMA_SQL).unwrap(); + conn.execute_batch("PRAGMA user_version = 1;").unwrap(); + conn.execute( + "INSERT INTO calls (app, started_at, ended_at, status, interrupted, error, mic_path, out_path, transcribed_at, audio_deleted, account_id) \ + VALUES ('Microsoft Teams', ?1, ?1, 'done', 0, NULL, '/rec/1-mic.wav', '/rec/1-out.wav', ?1, 0, 'mock-2')", + rusqlite::params![started], + ) + .unwrap(); + conn.execute_batch( + "INSERT INTO segments (call_id, seq, speaker, start_ts, end_ts, text) VALUES \ + (1, 0, 'me', 0.0, 1.5, 'Guten Tag.'), \ + (1, 1, 'remote:2', 2.0, 3.0, 'Hallo.'); \ + INSERT INTO speaker_names (call_id, speaker_key, name) VALUES (1, 'remote:2', 'Frau Probe');", + ) + .unwrap(); + } + + let store = Store::open(&path).unwrap(); + + let call = store.get_call(1).unwrap().expect("call kept"); + assert_eq!(call.app, "Microsoft Teams"); + assert_eq!(call.status, CallStatus::Done); + assert_eq!(call.account_id.as_deref(), Some("mock-2")); + assert_eq!(call.mic_path, PathBuf::from("/rec/1-mic.wav")); + assert_eq!(call.title, None); + let texts: Vec<_> = store + .segments(1) + .unwrap() + .into_iter() + .map(|s| (s.speaker, s.text)) + .collect(); + assert_eq!( + texts, + [ + (Speaker::Me, "Guten Tag.".to_string()), + (Speaker::Remote(2), "Hallo.".to_string()) + ] + ); + assert_eq!( + store.speaker_names(1).unwrap(), + merge_map(&[("remote:2", "Frau Probe")]) + ); + assert_eq!(store.speaker_merges(1).unwrap(), BTreeMap::new()); + + // The new column and table work, and opening again changes nothing. + store.set_title(1, Some("Lieferung März")).unwrap(); + store.set_speaker_merge(1, "remote:2", "remote:1").unwrap(); + drop(store); + assert_eq!(user_version(&path), 2); + let store = Store::open(&path).unwrap(); + let call = store.get_call(1).unwrap().unwrap(); + assert_eq!(call.title.as_deref(), Some("Lieferung März")); + assert_eq!( + store.speaker_merges(1).unwrap(), + merge_map(&[("remote:2", "remote:1")]) + ); + assert_eq!(store.list_calls().unwrap().len(), 1); + } + + #[test] + fn speaker_merges_are_set_replaced_and_removed() { + let store = Store::open_in_memory().unwrap(); + let id = new_call(&store); + let other = new_call(&store); + assert_eq!(store.speaker_merges(id).unwrap(), BTreeMap::new()); + + store.set_speaker_merge(id, "remote:3", "remote:2").unwrap(); + store.set_speaker_merge(id, "remote:2", "remote:1").unwrap(); + store + .set_speaker_merge(other, "remote:1", "remote:2") + .unwrap(); + assert_eq!( + store.speaker_merges(id).unwrap(), + merge_map(&[("remote:2", "remote:1"), ("remote:3", "remote:2")]) + ); + + store.set_speaker_merge(id, "remote:3", "remote:1").unwrap(); + store.remove_speaker_merge(id, "remote:2").unwrap(); + store.remove_speaker_merge(id, "remote:9").unwrap(); // never merged + assert_eq!( + store.speaker_merges(id).unwrap(), + merge_map(&[("remote:3", "remote:1")]) + ); + assert_eq!( + store.speaker_merges(other).unwrap(), + merge_map(&[("remote:1", "remote:2")]) + ); + } + + #[test] + fn a_merge_that_would_loop_or_involve_me_is_not_stored() { + let store = Store::open_in_memory().unwrap(); + let id = new_call(&store); + store.set_speaker_merge(id, "remote:2", "remote:1").unwrap(); + + let err = store + .set_speaker_merge(id, "remote:1", "remote:2") + .unwrap_err(); + assert_eq!( + err.to_string(), + "Diese Zuordnung würde eine Schleife ergeben" + ); + assert!(store.set_speaker_merge(id, "me", "remote:1").is_err()); + assert!(store.set_speaker_merge(id, "remote:1", "me").is_err()); + assert_eq!( + store.speaker_merges(id).unwrap(), + merge_map(&[("remote:2", "remote:1")]) + ); + } + + #[test] + fn the_title_is_trimmed_cleared_when_empty_and_limited_to_120_chars() { + let store = Store::open_in_memory().unwrap(); + let id = new_call(&store); + let title = |store: &Store| store.get_call(id).unwrap().unwrap().title; + assert_eq!(title(&store), None); + + store.set_title(id, Some(" Angebot Rioja ")).unwrap(); + assert_eq!(title(&store).as_deref(), Some("Angebot Rioja")); + assert_eq!( + store.list_calls().unwrap()[0].title.as_deref(), + Some("Angebot Rioja") + ); + + store.set_title(id, Some(" ")).unwrap(); + assert_eq!(title(&store), None); + store.set_title(id, Some("Angebot")).unwrap(); + store.set_title(id, None).unwrap(); + assert_eq!(title(&store), None); + + let longest = "ä".repeat(120); + store.set_title(id, Some(&longest)).unwrap(); + assert_eq!(title(&store), Some(longest.clone())); + let err = store.set_title(id, Some(&"ä".repeat(121))).unwrap_err(); + assert_eq!(err.to_string(), "Titel zu lang (max. 120 Zeichen)"); + assert_eq!(title(&store), Some(longest)); + } + #[test] fn create_and_finish_call() { let store = Store::open_in_memory().unwrap(); @@ -853,6 +1183,7 @@ mod tests { ) .unwrap(); store.set_speaker_name(id, "me", "Ich").unwrap(); + store.set_speaker_merge(id, "remote:2", "remote:1").unwrap(); store .record_remote_job(id, "deepscript", "job-123") .unwrap(); @@ -864,6 +1195,7 @@ mod tests { assert_eq!(store.summary(id).unwrap(), None); assert_eq!(store.speaker_names(id).unwrap(), BTreeMap::new()); assert_eq!(store.remote_jobs(id).unwrap(), Vec::new()); + assert_eq!(store.speaker_merges(id).unwrap(), BTreeMap::new()); } #[test] diff --git a/src-tauri/src/commands.rs b/src-tauri/src/commands.rs index 38e402b..750b79f 100644 --- a/src-tauri/src/commands.rs +++ b/src-tauri/src/commands.rs @@ -146,6 +146,46 @@ pub fn rename_speaker( Ok(()) } +/// Merges remote speaker `from_key` into `into_key` (undone by +/// [`unmerge_speaker`]). +#[tauri::command] +pub fn merge_speakers( + app: AppHandle, + state: State<'_, AppState>, + id: CallId, + from_key: String, + into_key: String, +) -> CmdResult<()> { + state.merge_speakers(id, &from_key, &into_key)?; + processing::emit_updated(&app, id); + Ok(()) +} + +#[tauri::command] +pub fn unmerge_speaker( + app: AppHandle, + state: State<'_, AppState>, + id: CallId, + from_key: String, +) -> CmdResult<()> { + state.unmerge_speaker(id, &from_key)?; + processing::emit_updated(&app, id); + Ok(()) +} + +/// Names a call (an empty or missing title restores the default heading). +#[tauri::command] +pub fn rename_call( + app: AppHandle, + state: State<'_, AppState>, + id: CallId, + title: Option, +) -> CmdResult<()> { + state.rename_call(id, title.as_deref())?; + processing::emit_updated(&app, id); + Ok(()) +} + #[tauri::command] pub fn list_accounts() -> Vec { accounts::list() diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs index 252eb07..92699d4 100644 --- a/src-tauri/src/lib.rs +++ b/src-tauri/src/lib.rs @@ -115,6 +115,9 @@ pub fn run() { commands::list_calls, commands::get_call, commands::rename_speaker, + commands::merge_speakers, + commands::unmerge_speaker, + commands::rename_call, commands::list_accounts, commands::set_account, ]) diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rs index cb86767..43c323d 100644 --- a/src-tauri/src/state.rs +++ b/src-tauri/src/state.rs @@ -441,12 +441,14 @@ impl AppState { Ok(calls.iter().map(CallListItem::of).collect()) } - /// The selected call with its transcript and speaker names. + /// The selected call with its transcript (speaker merges applied) and + /// speaker names. pub fn call_detail(&self, id: CallId) -> Result { let call = self.find_call(id)?; let segments = self.store.segments(id).map_err(|e| e.to_string())?; let names = self.store.speaker_names(id).map_err(|e| e.to_string())?; - Ok(CallDetail::of(&call, &segments, names)) + let merges = self.store.speaker_merges(id).map_err(|e| e.to_string())?; + Ok(CallDetail::of(&call, &segments, names, &merges)) } /// Renames a speaker of call `id`; a blank `name` restores the default @@ -465,6 +467,35 @@ impl AppState { result.map_err(|e| format!("Name konnte nicht gespeichert werden: {e}")) } + /// Merges remote speaker `from_key` of call `id` into `into_key`; both + /// must speak in the call's transcript. + pub fn merge_speakers(&self, id: CallId, from_key: &str, into_key: &str) -> Result<(), String> { + self.find_call(id)?; + let segments = self.store.segments(id).map_err(|e| e.to_string())?; + for key in [from_key, into_key] { + if !segments.iter().any(|s| s.speaker.key() == key) { + return Err(format!("Unbekannter Sprecher: {key}")); + } + } + self.store + .set_speaker_merge(id, from_key, into_key) + .map_err(|e| e.to_string()) + } + + /// Undoes the merge of speaker `from_key` of call `id`. + pub fn unmerge_speaker(&self, id: CallId, from_key: &str) -> Result<(), String> { + self.find_call(id)?; + self.store + .remove_speaker_merge(id, from_key) + .map_err(|e| format!("Zusammenführung konnte nicht aufgehoben werden: {e}")) + } + + /// Names call `id`; an empty or missing title clears the name. + pub fn rename_call(&self, id: CallId, title: Option<&str>) -> Result<(), String> { + self.find_call(id)?; + self.store.set_title(id, title).map_err(|e| e.to_string()) + } + /// Assigns call `id` to one of the [`accounts`], or to none. pub fn set_account(&self, id: CallId, account_id: Option<&str>) -> Result<(), String> { if account_id.is_some_and(|account| !accounts::exists(account)) { @@ -1072,6 +1103,115 @@ mod tests { assert!(f.state.store.speaker_names(id).unwrap().is_empty()); } + /// A finished call whose transcript has "Ich" and remote speakers 1 and 2. + fn transcribed_call(f: &Fixture) -> CallId { + let (id, _, _) = finished_call(f, "a"); + let line = |speaker, start: f64, text: &str| Segment { + speaker, + start, + end: start + 1.0, + text: text.into(), + }; + f.state + .store + .save_segments( + id, + &[ + line(Speaker::Remote(1), 0.0, "Guten Tag,"), + line(Speaker::Remote(2), 1.5, "hier Weingut Beispiel."), + line(Speaker::Me, 3.0, "Hallo."), + ], + ) + .unwrap(); + id + } + + fn transcript(f: &Fixture, id: CallId) -> Vec<(String, String)> { + f.state + .call_detail(id) + .unwrap() + .segments + .into_iter() + .map(|s| (s.label, s.text)) + .collect() + } + + #[test] + fn merging_speakers_joins_their_lines_until_undone() { + let f = fixture(); + let id = transcribed_call(&f); + let before = transcript(&f, id); + + f.state.merge_speakers(id, "remote:2", "remote:1").unwrap(); + assert_eq!( + transcript(&f, id), + [ + ( + "Sprecher 1".into(), + "Guten Tag, hier Weingut Beispiel.".into() + ), + ("Ich".into(), "Hallo.".into()), + ] + ); + assert_eq!(f.state.call_detail(id).unwrap().merges.len(), 1); + + f.state.unmerge_speaker(id, "remote:2").unwrap(); + assert_eq!(transcript(&f, id), before); + assert!(f.state.call_detail(id).unwrap().merges.is_empty()); + } + + #[test] + fn merging_needs_a_known_call_and_speakers_of_the_call() { + let f = fixture(); + let id = transcribed_call(&f); + let merge = |from, into| f.state.merge_speakers(id, from, into); + + assert_eq!( + f.state.merge_speakers(id + 1, "remote:2", "remote:1"), + Err("Gespräch nicht gefunden".to_string()) + ); + assert_eq!( + merge("remote:x", "remote:1"), + Err("Unbekannter Sprecher: remote:x".to_string()) + ); + assert_eq!( + merge("remote:2", "remote:3"), + Err("Unbekannter Sprecher: remote:3".to_string()) + ); + assert!(merge("me", "remote:1").is_err()); + merge("remote:2", "remote:1").unwrap(); + assert_eq!( + merge("remote:1", "remote:2"), + Err("Diese Zuordnung würde eine Schleife ergeben".to_string()) + ); + assert!(f.state.unmerge_speaker(id + 1, "remote:2").is_err()); + assert_eq!(f.state.store.speaker_merges(id).unwrap().len(), 1); + } + + #[test] + fn a_call_is_named_and_the_name_cleared() { + let f = fixture(); + let (id, _, _) = finished_call(&f, "a"); + let title = |f: &Fixture| f.state.call_list().unwrap()[0].title.clone(); + + f.state.rename_call(id, Some(" Angebot Rioja ")).unwrap(); + assert_eq!(title(&f).as_deref(), Some("Angebot Rioja")); + assert_eq!( + f.state.call_detail(id).unwrap().call.item.title.as_deref(), + Some("Angebot Rioja") + ); + assert_eq!( + f.state.rename_call(id, Some(&"x".repeat(121))), + Err("Titel zu lang (max. 120 Zeichen)".to_string()) + ); + f.state.rename_call(id, Some("")).unwrap(); + assert_eq!(title(&f), None); + assert_eq!( + f.state.rename_call(id + 1, Some("Test")), + Err("Gespräch nicht gefunden".to_string()) + ); + } + #[test] fn the_account_is_set_and_cleared() { let f = fixture(); diff --git a/ui/src/lib/CallList.svelte b/ui/src/lib/CallList.svelte index a3a28c4..57236d8 100644 --- a/ui/src/lib/CallList.svelte +++ b/ui/src/lib/CallList.svelte @@ -9,6 +9,11 @@ onselect, }: { calls: CallListItem[]; selectedId: CallId | null; onselect: (id: CallId) => void } = $props() + + /** "Microsoft Teams · 32 min" (no duration while recording). */ + function appLine(call: CallListItem): string { + return call.status === 'recording' ? call.app : `${call.app} · ${formatMinutes(call.duration_secs)}` + } {#if calls.length === 0} @@ -23,11 +28,11 @@ aria-current={call.id === selectedId} onclick={() => onselect(call.id)} > - - {call.app}{#if call.status !== 'recording'} · {formatMinutes(call.duration_secs)}{/if} - + {call.title ?? appLine(call)} - {formatListTime(call.started_at)} + + {call.title ? `${appLine(call)} · ` : ''}{formatListTime(call.started_at)} + diff --git a/ui/src/lib/TranscriptView.svelte b/ui/src/lib/TranscriptView.svelte index 858d15d..b16ce78 100644 --- a/ui/src/lib/TranscriptView.svelte +++ b/ui/src/lib/TranscriptView.svelte @@ -1,14 +1,23 @@ + (mergeMenu = null)} onkeydown={onwindowkeydown} /> + {#if segments.length === 0}

Keine Sprache erkannt.

{:else} @@ -90,6 +132,33 @@ {label} + {#if key !== 'me' && remoteSpeakers.length > 1} + + {/if} + {/if} + {#if mergeMenu === key} + + + {/if} {/each} @@ -100,6 +169,20 @@ {#if error}
{error}
{/if} + {#if merges.length > 0} +
    + {#each merges as merge (merge.from_key)} +
  • + {merge.from_label} → {merge.into_label} zusammengeführt + +
  • + {/each} +
+ {/if}
{#each segments as segment, i (i)} @@ -120,6 +203,7 @@ } .chip { + position: relative; display: inline-flex; align-items: center; gap: 6px; @@ -147,10 +231,84 @@ padding: 0 4px; } - .edit:hover { + .edit:hover:not(:disabled) { color: var(--primary); } + .edit:disabled { + cursor: default; + opacity: 0.5; + } + + .menu { + position: absolute; + top: calc(100% + 4px); + left: 0; + z-index: 10; + display: flex; + flex-direction: column; + min-width: 180px; + padding: 4px; + border: 1px solid var(--border); + border-radius: 8px; + background: var(--surface); + box-shadow: 0 4px 14px rgb(0 0 0 / 0.12); + font-weight: 400; + } + + .menu-title { + padding: 4px 8px 6px; + color: var(--muted); + white-space: nowrap; + } + + .menu button { + display: flex; + align-items: center; + gap: 6px; + padding: 5px 8px; + border: none; + border-radius: 6px; + background: none; + font: inherit; + font-weight: 600; + color: inherit; + text-align: left; + cursor: pointer; + } + + .menu button:hover { + background: var(--primary-soft); + } + + .merges { + list-style: none; + margin: 10px 0 0; + padding: 0; + color: var(--muted); + font-size: 12px; + } + + .merges li + li { + margin-top: 2px; + } + + .link { + margin-left: 4px; + padding: 0; + border: none; + background: none; + font: inherit; + color: var(--primary); + text-decoration: underline; + cursor: pointer; + } + + .link:disabled { + cursor: default; + opacity: 0.5; + } + .rename { width: 160px; padding: 1px 6px; diff --git a/ui/src/lib/api.ts b/ui/src/lib/api.ts index 7701ee6..ed5a8c6 100644 --- a/ui/src/lib/api.ts +++ b/ui/src/lib/api.ts @@ -65,6 +65,8 @@ export interface CallListItem { duration_secs: number status: CallStatus interrupted: boolean + /** The name the user gave the call, if any. */ + title: string | null } /** A transcript line; `speaker_key` is "me" or "remote:". */ @@ -76,11 +78,21 @@ export interface SegmentView { text: string } +/** A merged speaker: its lines now belong to `into_key`. */ +export interface SpeakerMerge { + from_key: string + from_label: string + into_key: string + into_label: string +} + export interface CallDetail { call: CallListItem & { error: string | null; account_id: string | null } + /** The transcript with speaker merges applied. */ segments: SegmentView[] /** Renamed speakers by key. */ speaker_names: Record + merges: SpeakerMerge[] } export interface Account { @@ -115,6 +127,13 @@ export const getCall = (id: CallId) => invoke('get_call', { id }) /** An empty name restores the default label. */ export const renameSpeaker = (id: CallId, speakerKey: string, name: string) => invoke('rename_speaker', { id, speakerKey, name }) +export const mergeSpeakers = (id: CallId, fromKey: string, intoKey: string) => + invoke('merge_speakers', { id, fromKey, intoKey }) +export const unmergeSpeaker = (id: CallId, fromKey: string) => + invoke('unmerge_speaker', { id, fromKey }) +/** `null` or an empty title restores the default heading. */ +export const renameCall = (id: CallId, title: string | null) => + invoke('rename_call', { id, title }) export const listAccounts = () => invoke('list_accounts') export const setAccount = (id: CallId, accountId: string | null) => invoke('set_account', { id, accountId }) diff --git a/ui/src/routes/Main.svelte b/ui/src/routes/Main.svelte index b02f923..87b6bf8 100644 --- a/ui/src/routes/Main.svelte +++ b/ui/src/routes/Main.svelte @@ -6,14 +6,17 @@ getCall, listAccounts, listCalls, + mergeSpeakers, onCallEnded, onCallUpdated, onPromptChanged, onRecordingState, + renameCall, renameSpeaker, retryCall, setAccount, transcribeCall, + unmergeSpeaker, type Account, type CallDetail, type CallId, @@ -36,6 +39,11 @@ let busy = $state(false) let tab = $state<'summary' | 'transcript'>('transcript') + let editingTitle = $state(false) + let titleDraft = $state('') + let savingTitle = $state(false) + let titleError = $state('') + // Answers can arrive out of order; only the newest request is applied. let listRequest = 0 let detailRequest = 0 @@ -84,6 +92,8 @@ detail = null detailError = '' actionError = '' + editingTitle = false + titleError = '' refreshDetail() } @@ -92,6 +102,8 @@ detail = null detailError = '' actionError = '' + editingTitle = false + titleError = '' } onMount(() => { @@ -155,8 +167,51 @@ await refreshDetail() } + async function merge(fromKey: string, intoKey: string) { + if (!detail) return + await mergeSpeakers(detail.call.id, fromKey, intoKey) + await refreshDetail() + } + + async function unmerge(fromKey: string) { + if (!detail) return + await unmergeSpeaker(detail.call.id, fromKey) + await refreshDetail() + } + + function startTitleEdit() { + titleDraft = detail?.call.title ?? '' + titleError = '' + editingTitle = true + } + + /** Enter saves the title (empty restores the default), Esc cancels. */ + async function titleKeydown(event: KeyboardEvent) { + if (event.key === 'Escape') { + editingTitle = false + titleError = '' + } else if (event.key === 'Enter' && detail && !savingTitle) { + savingTitle = true + titleError = '' + try { + await renameCall(detail.call.id, titleDraft.trim() || null) + editingTitle = false + await Promise.all([refreshList(), refreshDetail()]) + } catch (err) { + titleError = errorText(err) + } finally { + savingTitle = false + } + } + } + + function focus(node: HTMLInputElement) { + node.focus() + node.select() + } + /** "Microsoft Teams · heute 10:14 · 32 min" (no duration while recording). */ - function title(call: CallListItem): string { + function defaultTitle(call: CallListItem): string { const parts = [call.app, formatDetailTime(call.started_at)] if (call.status !== 'recording') parts.push(formatMinutes(call.duration_secs)) return parts.join(' · ') @@ -195,9 +250,32 @@ {@const call = detail.call}
-

{title(call)}

+ {#if editingTitle} + + {:else} +

+ {call.title ?? defaultTitle(call)} + +

+ {/if}
+ {#if editingTitle} +

Enter speichert, Esc bricht ab. Leer = Standardtitel.

+ {:else if call.title} +

{defaultTitle(call)}

+ {/if} + {#if titleError} +

{titleError}

+ {/if}
{/if} @@ -348,6 +432,33 @@ .heading h1 { font-size: 18px; + overflow-wrap: anywhere; + } + + .edit-title { + border: none; + background: none; + color: var(--muted); + cursor: pointer; + font-size: 14px; + padding: 0 4px; + vertical-align: middle; + } + + .edit-title:hover { + color: var(--primary); + } + + .title-input { + flex: 1 1 260px; + max-width: 520px; + font-size: 16px; + font-weight: 600; + } + + .subline { + margin: 4px 0 0; + font-size: 12px; } .toolbar {