diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..b007ef6 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,81 @@ +# Hinweise für Coding-Agenten + +Regeln für die Arbeit an MindSift, die nicht aus dem Code selbst hervorgehen. Aufbau und Technik stehen in [Doku/](Doku/README.md), vor allem [architecture.md](Doku/architecture.md). + +## Sprache und Stil + +- **Deutsch:** Oberflächentexte, Fehlermeldungen für Nutzer, E-Mails, `CHANGELOG.md`, `README.md`, `Doku/`. +- **Englisch:** Code-Kommentare und Commit-Nachrichten. +- **Commit-Nachrichten** im Stil `feat(bereich): …`, `fix(bereich): …`, `docs: …`, `style(bereich): …`. Am Ende die Zeile `Co-Authored-By: …` des jeweiligen Agenten. +- Neuer Code richtet sich nach dem umgebenden Code: Benennung, Kommentardichte, vorhandene Helfer statt neuer Varianten. + +## Umgebung + +Auf dem Entwicklungsrechner sind weder Node noch Go installiert. Alles läuft in Containern (podman): + +```bash +# Frontend: Typen, Lint, Tests +podman run --rm -v "$PWD/frontend":/app:Z -w /app docker.io/library/node:22-alpine \ + sh -c "npx tsc --noEmit && npx eslint src/… && npx vitest run" + +# Backend: vet und Tests +podman run --rm -v "$PWD":/src:Z -w /src docker.io/library/golang:1.24-alpine \ + sh -c "go vet ./... && go test ./internal/..." +``` + +Die Linter-Warnungen `react-hooks/exhaustive-deps` gibt es schon länger; neuer Code soll keine zusätzlichen Warnungen bringen. + +## Prüfen während der Arbeit + +- **Gezielt prüfen:** `tsc`, die betroffenen Frontend-Tests, `go vet` und `go test`. Den vollen Build macht nur der Server (siehe Release-Ablauf); ein kompletter `podman build .` vorher ist doppelte Arbeit. +- **Oberfläche im Browser ansehen**, besonders Handy-Ansichten: Image bauen, im Demo-Modus starten, mit Playwright aus dem `e2e/`-Ordner prüfen (Vorbild: `e2e/screenshots.sh`). Handy-Emulation mit `isMobile: true, hasTouch: true`; Finger-Gesten lassen sich über das Chrome DevTools Protocol (`Input.dispatchTouchEvent`) nachstellen. + + ```bash + podman build -q -t mindsift-check . + podman run -d --rm --name ms-check --network host -e PORT=18555 -e MINDA_DEMO=true \ + -e DEMO_RESET_MINUTES=0 -e JWT_SECRET=check-only mindsift-check + # Demo-Anmeldung: admin/admin bzw. user/user + ``` +- **Zeitabhängiger Code** (Alarme, Tageszusammenfassung, Begrüßungen, Termine): nie `time.Now()` dort, wo eine übergebene Zeit gemeint ist. Die betroffenen Go-Tests zusätzlich mit verschiedenen `TZ`-Werten laufen lassen (z. B. `Europe/Berlin`, `America/Los_Angeles`, `Asia/Tokyo`). Ein uhrzeitabhängiger Test hat schon einmal einen Release verhindert, weil er nur vormittags grün war. + +## Release-Ablauf + +**Committen** ist jederzeit erlaubt. **Jeder Push ist ein Release**, also mit Version und CHANGELOG-Eintrag. + +1. **Version erhöhen** (SemVer: Fehlerbehebung → Patch, neue Funktion → Minor): + - `frontend/package.json` (Feld `version`) + - `frontend/package-lock.json`: nur die beiden Versionszeilen von MindSift selbst (Zeile 3 und 9), nicht die gleichlautenden Versionen von Abhängigkeiten + - Versions-Badge oben in `README.md` +2. **CHANGELOG:** neuer Abschnitt `## [x.y.z] - JJJJ-MM-TT` unter `## [Unreleased]` (Format *Keep a Changelog*, Abschnitte Added/Changed/Fixed), unten die Vergleichslinks `[Unreleased]` und `[x.y.z]` anpassen. Einträge auf Deutsch und aus Sicht der Nutzer. +3. **Doku nachziehen**, wenn sich Verhalten oder API ändern (`README.md`, `Doku/api/rest.md`, `Doku/architecture.md`). +4. Committen, dann **nur nach `dev` pushen**. +5. **Warten, bis der `dev`-Build auf dem Server grün ist.** Schlägt er fehl: auf `dev` beheben, nicht nach `main` mergen. +6. Nach `main` mergen (`git merge --no-ff dev -m "Merge dev into main (vx.y.z)"`) und pushen. +7. **Warten, bis der `main`-Build grün ist.** Erst dann gilt das Release als draußen. + +Ist ein Release nie gebaut worden (CI fehlgeschlagen), bleibt die Versionsnummer, und die Korrektur kommt in denselben CHANGELOG-Abschnitt. + +**Git-Tags nur auf ausdrücklichen Wunsch.** Tags lassen zusätzliche Images bauen; genutzt werden nur `:dev` und `:latest`. Wenn gewünscht: `git tag -a vx.y.z -m "MindSift vx.y.z"` auf den Merge-Commit in `main` und den Tag pushen. + +Fremde Branches (z. B. von anderen Agenten) werden vor dem Mergen geprüft. + +### CI auf dem Git-Server + +- Workflow: `.gitea/workflows/build-and-publish.yaml`, Entscheidung in `.gitea/scripts/build-plan.sh`. +- `dev` → Image `:dev`, mit allen Tests (Dockerfile: tsc, Lint, Frontend-Tests, `go vet`, Go-Tests). +- `main` → Image `:latest` mit `APP_VERSION=v`; überspringt die Tests, wenn `:dev` aus demselben Code gebaut wurde. Deshalb erst nach grünem `dev`-Build mergen. +- Tag `v*` → `:vx.y.z` und `:stable`. +- Status der letzten Läufe: + + ```bash + curl -s "https://git.dsit.me/api/v1/repos/sandrodach/MindSift/actions/tasks?limit=4" + # workflow_runs[].head_branch / .status (success|failure|…) / .display_title + ``` + +## Oberfläche + +- **Einheitliche Bedienelemente:** Personen-Suche, Profilbild-Stapel, Zähler und weitere Muster stehen in [Doku/ui-patterns.md](Doku/ui-patterns.md). Vorhandene Komponenten verwenden statt neuer Varianten; neue gemeinsame Muster dort ergänzen. +- **Handy und Desktop:** Unter `sm` ist Handy-Layout, ab `lg` die volle Desktop-Ansicht (z. B. Seitenleiste neben der Notiz). Wird nur das Handy geändert, bleiben die Werte ab `sm`/`lg` exakt wie vorher. +- **Antippen am Handy:** Ziele mindestens 44 px hoch (`h-11 sm:h-…`). Auf reinen Touch-Geräten gibt es kein HTML5-Drag-&-Drop; Kanban nutzt dafür `useKanbanTouchDrag`, die Notizen die Leiste über der Tastatur (`MobileOutlineBar`). +- **Themes:** Farben nur über die Theme-Variablen bzw. Klassen (`bg-panel`, `bg-canvas`, `text-main`, `text-muted`, `border-border`, `bg-accent` …), keine festen Farben. Rahmen mit `bg-panel`/`bg-canvas` bekommen die Ecken des Themes automatisch; liegt darin ein Kopfbereich mit eigenem Hintergrund, braucht der Rahmen `overflow-hidden`, sonst ragen bei runden Ecken die Kanten heraus. +- **Installierte App (PWA):** Manifest-Änderungen (Farben, Verknüpfungen) übernimmt Android erst, wenn es die App aktualisiert (bis etwa einen Tag) oder nach Neuinstallation; normaler App-Code kommt beim nächsten Start. Ändert sich der Cache-Inhalt des Service Workers, `VERSION` in `frontend/public/sw.js` erhöhen. diff --git a/CHANGELOG.md b/CHANGELOG.md index fe2ad8e..4ba724f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -6,6 +6,14 @@ Das Format folgt [Keep a Changelog](https://keepachangelog.com/de/1.1.0/), die V ## [Unreleased] +## [0.22.2] - 2026-10-31 + +### Fixed +- Spracheingabe über den Browser (ohne Whisper-Server): In Chrome auf Android wurde ein Satz mehrfach übernommen („TestTestTestTest 1 2 3“ statt „Test 1 2 3“), weil Android jeden Zwischenstand als eigenes Ergebnis liefert. Fortsetzungen ersetzen jetzt den vorherigen Stand. + +### Added +- `AGENTS.md` mit Regeln für Coding-Agenten (Sprache, Prüfen, Release-Ablauf über die CI) und ein Plan für Registrierung mit Freigabe/E-Mail-Endungen und Anmeldung per OpenID Connect (`Doku/plans/`). + ## [0.22.1] - 2026-10-31 ### Fixed @@ -465,7 +473,8 @@ Das Format folgt [Keep a Changelog](https://keepachangelog.com/de/1.1.0/), die V - Geteilte Listen (Einkaufs-, Pack- und Checklisten) mit `#Kategorie`-Gruppierung, Mengenangaben und Echtzeit-Abhaken. - Benutzer-, Gruppen- und Admin-Verwaltung (Ersteinrichtungs-Assistent, Einladungscodes, Profilbilder, persönliche API-Keys & Webhook-Ingest `/api/v1/webhooks/ingest`, JSON-Datenexport) sowie CSS-Theme-Engine mit 4 Themes (`Dark`, `Light`, `High Contrast`, `Soft`) und PWA-Unterstützung. -[Unreleased]: https://git.dsit.me/sandrodach/MindSift/compare/v0.22.1...dev +[Unreleased]: https://git.dsit.me/sandrodach/MindSift/compare/v0.22.2...dev +[0.22.2]: https://git.dsit.me/sandrodach/MindSift/compare/v0.22.1...v0.22.2 [0.22.1]: https://git.dsit.me/sandrodach/MindSift/compare/v0.22.0...v0.22.1 [0.22.0]: https://git.dsit.me/sandrodach/MindSift/compare/v0.21.0...v0.22.0 [0.21.0]: https://git.dsit.me/sandrodach/MindSift/compare/v0.20.0...v0.21.0 diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..43c994c --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +@AGENTS.md diff --git a/Doku/plans/registrierung-und-login.md b/Doku/plans/registrierung-und-login.md new file mode 100644 index 0000000..ae388a3 --- /dev/null +++ b/Doku/plans/registrierung-und-login.md @@ -0,0 +1,102 @@ +# Plan: Registrierung und Anmeldung (Entwurf) + +Stand 2026-10-31, noch nicht umgesetzt. Ziel: ein Zwischending zwischen „jeder darf sich registrieren“ und „für jede Person einen Einladungscode erzeugen“, dazu bequemere Anmeldung. + +## Heute + +- `ALLOW_REGISTRATION` bzw. Admin-Schalter „offene Registrierung“: jeder kann ein Konto anlegen. +- Sonst nur mit Einladungscode (optional an eine E-Mail-Adresse und eine Organisation gebunden, einmal verwendbar, mit Ablaufdatum). +- Anmeldung nur mit E-Mail/Benutzername und Passwort (dazu API-Keys für Webhooks). + +## 1. Registrierungsmodus statt Ja/Nein + +Ein Modus ersetzt den Schalter „offene Registrierung“: + +| Modus | Verhalten | +|---|---| +| `closed` | Nur mit Einladungscode (wie heute ohne offene Registrierung). | +| `approval` | Jeder kann sich registrieren, das Konto ist aber **gesperrt, bis ein Admin es freigibt**. | +| `domain` | Registrierung nur mit E-Mail-Adressen bestimmter Endungen (z. B. `@firma.de, @familie-dach.de`), sofort aktiv. | +| `domain+approval` | Erlaubte Endungen sofort aktiv, alle anderen warten auf Freigabe. | +| `open` | Jeder, sofort aktiv (wie heute). | + +Einladungscodes funktionieren in jedem Modus und überspringen Freigabe und Endungsprüfung. + +**Freigabe durch Admin** +- Neue Konten im Modus `approval` werden mit `is_active = 0` und einem Status „wartet auf Freigabe“ angelegt (eigenes Feld, damit „gesperrt“ und „wartet“ unterscheidbar bleiben). +- Die Person sieht nach der Registrierung: „Dein Konto wird geprüft. Du bekommst eine E-Mail, sobald es freigeschaltet ist.“ Anmelden geht bis dahin nicht (gleiche Meldung). +- Admins bekommen eine Benachrichtigung über die vorhandenen Kanäle (E-Mail/Push, neues Ereignis „Registrierung wartet“) und sehen in der Benutzerverwaltung oben eine Liste **„Wartet auf Freigabe“** mit Freigeben / Ablehnen. Ablehnen löscht das Konto. +- Bei Freigabe geht eine E-Mail im bekannten Layout an die Person („Dein Konto ist freigeschaltet“ mit Knopf zur App). +- Ohne SMTP funktioniert alles, nur ohne E-Mails. + +**E-Mail-Endungen** +- Liste von Domains, Vergleich ohne Groß-/Kleinschreibung auf den Teil nach `@` (keine Subdomains, außer ausdrücklich `*.firma.de`). +- Optional: **E-Mail-Adresse bestätigen** per Link (wie Passwort vergessen, gleiche Token-Technik), bevor das Konto aktiv wird. Sonst kann jeder `chef@firma.de` eintippen. Bei `domain` sollte die Bestätigung Pflicht sein, wenn SMTP eingerichtet ist. + +**Missbrauch** +- Gleiche Bremse wie beim Login (Anfragen pro IP), dazu höchstens N wartende Registrierungen gleichzeitig (z. B. 50), danach „gerade keine Registrierung möglich“. +- In der Demo bleibt Registrierung aus. + +## 2. Einstellungen: Admin-Oberfläche oder Umgebungsvariablen + +Damit die Admin-Einstellungen nicht überladen werden: + +- **Admin-Oberfläche:** nur der Modus (Auswahlfeld) und darunter, je nach Modus, das Feld für die erlaubten Endungen. Die Liste „Wartet auf Freigabe“ steht in der Benutzerverwaltung, nicht in den Einstellungen. +- **Umgebungsvariablen** (gewinnen, wenn gesetzt; das Feld in der Oberfläche ist dann gesperrt mit Hinweis „über die Umgebung festgelegt“ – so wie heute bei SMTP): + + ```env + REGISTRATION_MODE=domain+approval # closed | approval | domain | domain+approval | open + REGISTRATION_DOMAINS=firma.de,familie-dach.de + REGISTRATION_VERIFY_EMAIL=true # Bestätigungslink vor Aktivierung + ``` +- `ALLOW_REGISTRATION=true` bleibt als Alias für `REGISTRATION_MODE=open` erhalten. + +## 3. Anmelden mit anderen Konten + +### a) OpenID Connect (empfohlen statt „nur Google“) + +Ein allgemeiner OIDC-Login deckt Google, Microsoft, Apple und vor allem **selbst gehostete Anbieter** ab: Authentik, Keycloak, Authelia – und **Gitea/Forgejo selbst** kann OIDC-Anbieter sein. Für ein Homelab ist das meist nützlicher als Google. + +- Konfiguration nur per Umgebung (Geheimnisse gehören nicht in die Datenbank-Oberfläche): + ```env + OIDC_ISSUER=https://git.dsit.me/ # oder https://accounts.google.com + OIDC_CLIENT_ID=… + OIDC_CLIENT_SECRET=… + OIDC_BUTTON_LABEL=Mit Gitea anmelden + OIDC_ALLOWED_DOMAINS=firma.de # optional, sonst gilt der Registrierungsmodus + OIDC_AUTO_CREATE=true # neues Konto beim ersten Login anlegen (Modus/Freigabe gelten) + ``` +- Ablauf: Authorization Code Flow mit PKCE, `state` und `nonce`; Rückkehr auf `BASE_URL/api/v1/auth/oidc/callback`. Konten werden über `iss`+`sub` verknüpft (neue Tabelle), nicht nur über die E-Mail. +- Besteht schon ein Konto mit derselben, vom Anbieter **bestätigten** E-Mail, wird es nach Passwortabfrage verknüpft (kein stilles Übernehmen fremder Konten). +- Danach normale MindSift-Sitzung (wie heute), Abmelden bleibt lokal. +- Passwort-Login bleibt daneben möglich; optional `PASSWORD_LOGIN=false`, wenn nur noch OIDC gewünscht ist (Admin-Notzugang beachten). + +### b) Anmeldung über den Mailserver (wie die SMTP-Quelle in Gitea) + +Gitea prüft dabei E-Mail und Passwort, indem es sich damit am Mailserver anmeldet (SMTP AUTH). Klappt das, ist die Person echt; das Konto wird beim ersten Mal angelegt. + +- Konfiguration per Umgebung: + ```env + MAIL_LOGIN_HOST=mail.firma.de + MAIL_LOGIN_PORT=587 # STARTTLS oder 465 mit TLS – nie unverschlüsselt + MAIL_LOGIN_DOMAINS=firma.de # nur diese Adressen werden am Mailserver geprüft + ``` +- Für solche Konten speichert MindSift **kein** Passwort; jede Anmeldung fragt den Mailserver. Ändert sich das Mailpasswort, gilt automatisch das neue. +- Nachteile: Das Mailpasswort läuft durch MindSift (nur über TLS, nie loggen); fällt der Mailserver aus, kann sich niemand anmelden; Login-Bremse ist Pflicht, damit MindSift nicht zum Passwort-Rateautomaten für den Mailserver wird. Viele Anbieter (Google, Microsoft 365) erlauben SMTP AUTH mit dem normalen Passwort gar nicht mehr – sinnvoll ist das vor allem mit einem eigenen Mailserver. +- Technisch klein: Der SMTP-Code für den Versand (`internal/api/mail.go`, inkl. PLAIN/LOGIN) existiert schon. + +Empfehlung: **erst OIDC**, Mailserver-Login nur wenn ein eigener Mailserver ohne OIDC-Anbieter das Ziel ist. + +## Reihenfolge und Aufwand (grob) + +1. Registrierungsmodus mit Freigabe und Endungen, Umgebungsvariablen, Admin-Liste „Wartet auf Freigabe“, E-Mails – mittel. +2. E-Mail-Bestätigung per Link – klein (Technik wie Passwort vergessen). +3. OIDC-Login – mittel (Bibliothek `coreos/go-oidc` + `golang.org/x/oauth2`, neue Tabelle für verknüpfte Konten, Knopf auf der Anmeldeseite). +4. Mailserver-Login – klein bis mittel, optional. + +## Offene Fragen + +- Sollen Admins bei jeder wartenden Registrierung benachrichtigt werden oder reicht ein Zähler in der Benutzerverwaltung? +- Neue Konten per Endung automatisch einer Organisation zuordnen (z. B. `@firma.de` → Organisation „Firma“)? +- Welcher OIDC-Anbieter zuerst: Gitea, Google, Authentik …? +- Soll ein abgelehnter Antrag gesperrt bleiben (gleiche Adresse kann es nicht erneut versuchen) oder einfach gelöscht werden? diff --git a/README.md b/README.md index 56fa12a..26cdd2e 100644 --- a/README.md +++ b/README.md @@ -6,7 +6,7 @@ [![Self-Hosted](https://img.shields.io/badge/100%25-Self--Hosted-2563eb?style=flat-square)](#) [![Docker](https://img.shields.io/badge/Deployment-Single%20Container-2496ed?style=flat-square&logo=docker&logoColor=white)](#-schnellstart) [![SQLite](https://img.shields.io/badge/Daten-SQLite-003b57?style=flat-square&logo=sqlite&logoColor=white)](#-deine-daten-gehören-dir) -[![Version](https://img.shields.io/badge/Version-v0.22.1-16a34a?style=flat-square)](CHANGELOG.md) +[![Version](https://img.shields.io/badge/Version-v0.22.2-16a34a?style=flat-square)](CHANGELOG.md) **MindSift** ist eine selbst gehostete Schaltstelle für spontane Gedanken, Aufgaben mit Kanban-Board, hierarchische Outliner-Notizen, die mehrere Personen gleichzeitig bearbeiten können, und gemeinsame Listen. Alles läuft als ein einzelner Container mit eingebetteter SQLite-Datenbank, auf deinem eigenen Server. diff --git a/frontend/package-lock.json b/frontend/package-lock.json index bca35c6..3970401 100644 --- a/frontend/package-lock.json +++ b/frontend/package-lock.json @@ -1,12 +1,12 @@ { "name": "mindsift-frontend", - "version": "0.22.1", + "version": "0.22.2", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "mindsift-frontend", - "version": "0.22.1", + "version": "0.22.2", "license": "Unlicense", "dependencies": { "@fontsource-variable/inter": "5.3.0", diff --git a/frontend/package.json b/frontend/package.json index 802eaad..a6389c1 100644 --- a/frontend/package.json +++ b/frontend/package.json @@ -1,7 +1,7 @@ { "name": "mindsift-frontend", "private": true, - "version": "0.22.1", + "version": "0.22.2", "license": "Unlicense", "type": "module", "scripts": { diff --git a/frontend/src/lib/__tests__/voice.join.test.ts b/frontend/src/lib/__tests__/voice.join.test.ts new file mode 100644 index 0000000..c4118ce --- /dev/null +++ b/frontend/src/lib/__tests__/voice.join.test.ts @@ -0,0 +1,21 @@ +import { describe, it, expect } from 'vitest'; +import { joinSpeechResults } from '../voice'; + +describe('joinSpeechResults (browser speech recognition)', () => { + it('Android: growing interim states of one phrase count once', () => { + expect(joinSpeechResults(['Test', 'Test', 'Test', 'Test', 'Test', 'Test 1 2 3'])).toBe('Test 1 2 3'); + expect(joinSpeechResults(['Test', 'Test 1', 'Test 1 2', 'Test 1 2 3'])).toBe('Test 1 2 3'); + }); + + it('desktop: consecutive pieces are joined', () => { + expect(joinSpeechResults(['Milch kaufen', ' und Brot'])).toBe('Milch kaufen und Brot'); + }); + + it('Android: a new phrase after a finished one is appended', () => { + expect(joinSpeechResults(['Milch', 'Milch kaufen', ' und Brot', ' und Brot holen'])).toBe('Milch kaufen und Brot holen'); + }); + + it('ignores empty results and earlier shorter states', () => { + expect(joinSpeechResults(['', 'Test 1 2', 'Test 1', ''])).toBe('Test 1 2'); + }); +}); diff --git a/frontend/src/lib/useVoiceInput.ts b/frontend/src/lib/useVoiceInput.ts index 783d683..f44fe75 100644 --- a/frontend/src/lib/useVoiceInput.ts +++ b/frontend/src/lib/useVoiceInput.ts @@ -1,6 +1,6 @@ import { useCallback, useEffect, useRef, useState } from 'react'; import { api } from './api'; -import { browserRecognition, currentVoiceConfig, EffectiveVoiceMode, loadVoiceConfig, VoiceRecorder } from './voice'; +import { browserRecognition, currentVoiceConfig, EffectiveVoiceMode, joinSpeechResults, loadVoiceConfig, VoiceRecorder } from './voice'; export type VoiceState = 'idle' | 'listening' | 'transcribing'; @@ -234,8 +234,9 @@ export function useVoiceInput({ onText, onError, continuous = false, live = fals recognition.interimResults = true; recognition.continuous = continuous || live; recognition.onresult = (event: any) => { - let sessionText = ''; - for (let i = 0; i < event.results.length; i++) sessionText += event.results[i][0].transcript; + const parts: string[] = []; + for (let i = 0; i < event.results.length; i++) parts.push(event.results[i][0].transcript); + const sessionText = joinSpeechResults(parts); if (live && baseTranscriptRef.current) { const base = baseTranscriptRef.current.trimEnd(); const next = sessionText.trimStart(); diff --git a/frontend/src/lib/voice.ts b/frontend/src/lib/voice.ts index 8e447f4..40a4903 100644 --- a/frontend/src/lib/voice.ts +++ b/frontend/src/lib/voice.ts @@ -186,3 +186,27 @@ export class VoiceRecorder { this.analyser = null; } } + +/** + * Text of one speech recognition session from its results. Desktop browsers deliver consecutive + * pieces ("Test 1 2 3", " und weiter"); Chrome on Android also keeps the growing interim states of + * the same phrase as results of their own ("Test", "Test", "Test 1 2 3"). A result that only + * continues the one before it therefore replaces it instead of being appended. + */ +export function joinSpeechResults(transcripts: string[]): string { + const norm = (s: string) => s.trim().toLowerCase(); + let text = ''; + let last = ''; + for (const t of transcripts) { + if (!t) continue; + if (last && norm(t).startsWith(norm(last))) { + text = text.slice(0, text.length - last.length) + t; // grown version of the same phrase + } else if (last && norm(last).startsWith(norm(t))) { + continue; // an earlier, shorter state of it + } else { + text += t; + } + last = t; + } + return text; +}