diff --git a/api/_lib/researchAnalysis.ts b/api/_lib/researchAnalysis.ts index b4f6711..4a1a016 100644 --- a/api/_lib/researchAnalysis.ts +++ b/api/_lib/researchAnalysis.ts @@ -12,16 +12,23 @@ import Anthropic from '@anthropic-ai/sdk' import { z } from 'zod' import type { ResearchItem } from './researchSources.js' -import type { ResearchLead } from '../../src/domain/researchLead.js' +import type { ResearchLead, TemporalClass } from '../../src/domain/researchLead.js' +import { passtZeitlich } from '../../src/lib/temporalFilter.js' /** - * Der Beurteilungsauftrag (§12). + * Der Beurteilungsauftrag (§12, erweitert in Runde 10 §§2.9/2.13). * - * Bewusst kurz. Zwei Sätze tragen die eigentliche Arbeit: der Relevanzbegriff - * und das Verbot, etwas hinzuzuerfinden. Alles Weitere wäre Ausschmückung, die - * das Modell eher zu geschmeidigen als zu belegten Antworten verleitet. + * Bewusst kurz gehalten. Drei Dinge tragen die eigentliche Arbeit: der + * Relevanzbegriff, das Verbot, etwas hinzuzuerfinden, und die Trennung von + * Publikationsdatum und Ereigniszeit. + * + * Eine Funktion und keine Konstante, weil der Auftrag das heutige Datum + * enthält: «in drei Wochen» lässt sich nur gegen ein Heute beurteilen, und das + * Modell kennt seines nicht verlässlich. */ -const SYSTEM_PROMPT = `Du bist Livia, Research & Market Intelligence Agent für professionelle Schweizer Gewerbeimmobilien-Bewirtschaftungen. +function systemPrompt(): string { + const heute = new Date().toISOString().slice(0, 10) + return `Du bist Livia, Research & Market Intelligence Agent für professionelle Schweizer Gewerbeimmobilien-Bewirtschaftungen. Analysiere die bereitgestellten Unternehmensmeldungen. @@ -32,13 +39,35 @@ Allgemeine Unternehmensnachrichten ohne plausiblen Immobilienbezug sind IRRELEVA Bewerte konservativ. Erfinde keine Informationen, die nicht in der Quelle stehen. Wenn eine Meldung keinen Firmennamen nennt, schreibe in "company" das, was die Quelle tatsächlich benennt — erfinde keinen Namen. Antworte ausschliesslich mit einem JSON-Objekt der Form: -{"results":[{"index":0,"company":"...","eventType":"EXPANSION","headline":"...","location":"...","summary":"...","relevance":"high","confidence":0.8,"reason":"...","recommendedAction":"..."}]} +{"results":[{"index":0,"company":"...","eventType":"EXPANSION","headline":"...","location":"...","summary":"...","relevance":"high","confidence":0.8,"reason":"...","recommendedAction":"...","temporalClass":"future","temporalEvidence":"...","eventDate":"2026-11","semanticSearchProfile":"..."}]} Gib für JEDEN Eingabeeintrag genau ein Ergebnis mit dem passenden "index" zurück. eventType ist einer von: EXPANSION, NEW_LOCATION, HEADCOUNT_GROWTH, INVESTMENT, M_AND_A, RESTRUCTURING, SITE_CLOSURE, NEW_COMPANY, IRRELEVANT. relevance ist "high", "medium" oder "low". confidence ist eine Zahl zwischen 0 und 1. + +ZEITLICHE EINORDNUNG ("temporalClass"): +Beurteile, WANN die beschriebene Veränderung stattfindet — nicht, wann der Artikel erschienen ist. +Das Publikationsdatum ist dafür irrelevant. Heute ist ${heute}. +- "past": Die Veränderung ist bereits abgeschlossen (Umzug erfolgt, Standort eröffnet oder geschlossen, Transaktion vollzogen). +- "current": Die Veränderung läuft gerade oder steht innerhalb der nächsten 8 Wochen bevor. +- "future": Die Veränderung liegt mehr als 8 Wochen voraus ODER ist angekündigt ohne kurzfristige Umsetzung. +- "unknown": Die Quelle erlaubt keine belastbare zeitliche Aussage. Erfinde dann KEIN Datum. +Beispiel: Ein Bericht aus Q1 kündigt einen Standort für Q3 an => "future". +Beispiel: Ein heute erschienener Artikel beschreibt einen Umzug vom letzten Frühling => "past". + +"temporalEvidence": die Textstelle oder Formulierung aus der Quelle, auf die sich deine Einordnung stützt. Ein Satz. +"eventDate": nur setzen, wenn die Quelle ein Datum oder einen Zeitraum nennt (z. B. "2026-11" oder "2026-11-15"). Sonst weglassen. + +SEMANTISCHES SUCHPROFIL ("semanticSearchProfile"): +Nur bei EXPANSION, NEW_LOCATION, HEADCOUNT_GROWTH, INVESTMENT und NEW_COMPANY — also dort, wo Flächenbedarf entstehen könnte. +Formuliere ein zusammenhängendes Nachfrageprofil in ganzen Sätzen (4–8 Sätze), das beschreibt, welche Fläche dieses Unternehmen vermutlich sucht. +Nenne, soweit aus der Quelle ableitbar: Unternehmen, Anlass, wahrscheinliche Nutzungsart, geografischer Suchraum, Flächenbedarf, zeitlicher Horizont, Standort- und Infrastrukturanforderungen, Erreichbarkeit. +Schliesse mit einem Satz, der ausdrücklich benennt, was aus der Quelle NICHT ableitbar ist. +Erfinde nichts. Was die Quelle nicht hergibt, gehört in den Unsicherheitssatz — nicht ins Profil. + Deutsch, Schweizer Rechtschreibung (ss statt ß). Keine langen Analysen.` +} const AnalysisSchema = z.object({ results: z.array(z.object({ @@ -55,6 +84,12 @@ const AnalysisSchema = z.object({ confidence: z.number().min(0).max(1), reason: z.string().min(1), recommendedAction: z.string().optional(), + // Fehlt die zeitliche Einordnung, gilt «unknown» — das ist die ehrliche + // Antwort und nicht ein aus dem Publikationsdatum geratener Wert. + temporalClass: z.enum(['past', 'current', 'future', 'unknown']).default('unknown'), + temporalEvidence: z.string().default(''), + eventDate: z.string().optional(), + semanticSearchProfile: z.string().optional(), })), }) @@ -64,6 +99,8 @@ export interface AnalysisOutcome { discarded: number /** Beobachtungswürdig, aber ohne bestätigten Flächenbezug. */ watchlist: number + /** Aussortiert, weil die Ereigniszeit ausserhalb der gewählten Zeitfenster lag (§2.9). */ + temporalFiltered: number } /** Das erste JSON-Objekt aus der Antwort — falls das Modell doch etwas drumherum schreibt. */ @@ -164,7 +201,7 @@ async function analyzeBatch( const response = await client.messages.create({ model: MODEL, max_tokens: 8000, - system: SYSTEM_PROMPT, + system: systemPrompt(), // Einordnen ist bei fünf Einträgen eine Routineaufgabe — die niedrige Stufe // spart Zeit und Kosten. Nur die grossen Modelle kennen den Schalter; bei // den kleineren wird die Anfrage sonst abgewiesen (siehe SUPPORTS_EFFORT). @@ -187,8 +224,12 @@ async function analyzeBatch( .map(r => ({ item: batch[r.index], r })) } -export async function analyzeResearchItems(items: ResearchItem[]): Promise { - if (items.length === 0) return { leads: [], discarded: 0, watchlist: 0 } +export async function analyzeResearchItems( + items: ResearchItem[], + /** Erlaubte Ereigniszeiten; leer bedeutet «keine Einschränkung». */ + temporalFilter: TemporalClass[] = [], +): Promise { + if (items.length === 0) return { leads: [], discarded: 0, watchlist: 0, temporalFiltered: 0 } const apiKey = process.env.ANTHROPIC_API_KEY if (!apiKey) { @@ -240,6 +281,7 @@ export async function analyzeResearchItems(items: ResearchItem[]): Promise (a.relevance === b.relevance ? b.confidence - a.confidence : a.relevance === 'high' ? -1 : 1)) - return { leads, discarded, watchlist } + return { leads, discarded, watchlist, temporalFiltered } } diff --git a/api/_lib/researchSources.ts b/api/_lib/researchSources.ts index f7e1d82..9d29b3f 100644 --- a/api/_lib/researchSources.ts +++ b/api/_lib/researchSources.ts @@ -336,3 +336,105 @@ export async function fetchZefixResearch(): Promise { aggregate: true, }] } + +// ── Frei angebundene Quellen (Runde 10, §2.3) ───────────────────────────────── + +/** + * Adressbereiche, die eine serverlose Funktion niemals abrufen soll. + * + * Der Nutzer gibt die Adresse frei ein, und die Funktion ruft sie mit den + * Rechten des Rechenzentrums ab. Ohne diese Sperre wäre das Eingabefeld ein + * Weg, interne Dienste des Hosters anzusprechen. Geprüft wird der Hostname, + * weil eine serverlose Funktion keine Namensauflösung vorab machen kann — + * das deckt die versehentlichen Fälle und die offensichtlichen Versuche ab. + */ +const PRIVATE_HOSTS = + /^(localhost$|127\.|0\.0\.0\.0$|10\.|192\.168\.|169\.254\.|172\.(1[6-9]|2\d|3[01])\.|\[?::1\]?$|.*\.local$|.*\.internal$)/i + +export interface QuellenAdresse { + id: string + name: string + url: string +} + +/** Wirft mit einer Meldung, die so in der Oberfläche stehen darf. */ +export function pruefeQuellenAdresse(url: string): URL { + let parsed: URL + try { + parsed = new URL(url) + } catch { + throw new Error('Keine gültige Adresse.') + } + if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') { + throw new Error('Nur http- und https-Adressen können gelesen werden.') + } + if (PRIVATE_HOSTS.test(parsed.hostname)) { + throw new Error('Adressen im internen Netz werden nicht abgerufen.') + } + return parsed +} + +/** Höchstzahl Artikel je frei angebundener Quelle — bewusst kleiner als bei den gepflegten drei. */ +const GENERIC_MAX_ARTICLES = 10 + +/** + * Eine beliebige Seite als Recherchequelle lesen. + * + * Bewusst kein Spider: Es wird genau eine Übersichtsseite geholt. Führt sie + * Links auf Unterseiten desselben Hosts, werden bis zu zehn davon gelesen — + * sonst zählt der Text der Seite selbst als einziger Eintrag. Das reicht für + * eine Newsseite und kostet nie mehr als elf Abrufe. + * + * Was hier ausdrücklich nicht passiert: keine zweite Ebene, keine Warteschlange, + * kein Zeitplan, kein Browser. Eine frei angebundene Quelle liefert damit + * weniger als die drei gepflegten — das ist der ehrliche Preis dafür, dass + * niemand für sie einen eigenen Leser geschrieben hat. + */ +export async function fetchGenericSource(quelle: QuellenAdresse): Promise { + const basis = pruefeQuellenAdresse(quelle.url) + const html = await getText(quelle.url) + + const $ = cheerio.load(html) + $('script, style, nav, header, footer, noscript, form').remove() + + // Kandidaten: Links auf denselben Host, mindestens zwei Pfadsegmente tief. + // Eine Startseite verlinkt so ihre Artikel; Impressum und Kontakt liegen + // typischerweise flacher und fallen dadurch von selbst heraus. + const links: Artikellink[] = [] + const gesehen = new Set() + $('a[href]').each((_, el) => { + const href = $(el).attr('href') + if (!href) return + let ziel: URL + try { + ziel = new URL(href, basis) + } catch { + return + } + if (ziel.hostname !== basis.hostname) return + if (ziel.pathname.split('/').filter(Boolean).length < 2) return + const url = `${ziel.origin}${ziel.pathname}` + if (url === `${basis.origin}${basis.pathname}` || gesehen.has(url)) return + const title = $(el).text().replace(/\s+/g, ' ').trim() + if (title.length < 12) return + gesehen.add(url) + links.push({ url, title }) + }) + + if (links.length > 0) { + const items = await ladeArtikel(links.slice(0, GENERIC_MAX_ARTICLES), quelle.name) + if (items.length > 0) return items + } + + // Kein brauchbarer Unterseiten-Fund: die Seite selbst ist der Eintrag. + const text = extractArticleText(html) + if (text.length < 120) { + throw new Error('Die Seite lieferte zu wenig lesbaren Text.') + } + return [{ + source: quelle.name, + title: cleanTitle($('h1').first().text().replace(/\s+/g, ' ').trim()) || quelle.name, + url: quelle.url, + text, + }] +} diff --git a/api/livia/research/refresh.ts b/api/livia/research/refresh.ts index 1dcfdc0..8ebbc7d 100644 --- a/api/livia/research/refresh.ts +++ b/api/livia/research/refresh.ts @@ -19,10 +19,15 @@ import { fetchZhkResearch, fetchGreaterZurichResearch, fetchZefixResearch, + fetchGenericSource, } from '../../_lib/researchSources.js' import type { ResearchItem } from '../../_lib/researchSources.js' import { MODEL, analyzeResearchItems } from '../../_lib/researchAnalysis.js' -import type { ResearchRefreshResult, ResearchSourceResult } from '../../../src/domain/researchLead.js' +import type { + ResearchRefreshResult, + ResearchSourceResult, + TemporalClass, +} from '../../../src/domain/researchLead.js' interface Quelle { id: string @@ -31,12 +36,97 @@ interface Quelle { laden: () => Promise } -const QUELLEN: Quelle[] = [ +/** + * Für diese drei Adressen gibt es einen eigens geschriebenen Leser. + * + * Der Schlüssel ist die Adresse und nicht die Kennung: Ein Zugang, den der + * Nutzer im Personalblatt anlegt, bekommt eine eigene Kennung, zeigt aber + * vielleicht auf dieselbe Seite. Dann soll er den guten Leser bekommen und + * nicht den allgemeinen. + */ +const SPEZIALLESER = new Map Promise>([ + [SOURCES.ZHK.url, fetchZhkResearch], + [SOURCES.GZA.url, fetchGreaterZurichResearch], + [SOURCES.ZEFIX.url, fetchZefixResearch], +]) + +/** Die gepflegten drei — Rückfall, wenn die Anfrage keine Quellen mitbringt. */ +const STANDARDQUELLEN: Quelle[] = [ { ...SOURCES.ZHK, laden: fetchZhkResearch }, { ...SOURCES.GZA, laden: fetchGreaterZurichResearch }, { ...SOURCES.ZEFIX, laden: fetchZefixResearch }, ] +/** Was die Oberfläche mitschickt (Runde 10, §§2.3/2.6/2.9). */ +interface RefreshBody { + sources?: { id: string; name: string; url: string }[] + documents?: { id: string; name: string; text: string }[] + temporalClasses?: TemporalClass[] +} + +/** Höchstzahl frei angebundener Quellen je Lauf — schützt Laufzeit und Kosten. */ +const MAX_SOURCES = 8 +/** Höchstzahl abgelegter Dokumente je Lauf. */ +const MAX_DOCUMENTS = 12 +/** Wie viel Text ein abgelegtes Dokument beisteuert. */ +const DOC_TEXT_LIMIT = 12_000 + +async function leseBody(req: IncomingMessage): Promise { + const stuecke: Buffer[] = [] + for await (const chunk of req) stuecke.push(chunk as Buffer) + if (stuecke.length === 0) return {} + try { + return JSON.parse(Buffer.concat(stuecke).toString('utf8')) as RefreshBody + } catch { + // Ein unlesbarer Rumpf ist kein Grund, den Lauf abzubrechen — dann gelten + // eben die gepflegten Standardquellen. + return {} + } +} + +/** + * Aus den übergebenen Adressen die Leseaufträge bauen. + * + * Genau hier wird die Quellenregistry dynamisch: Was das Personalblatt als + * aktiven Lesezugang mit Adresse führt, landet in dieser Liste — mit dem + * spezialisierten Leser, wenn es einen gibt, und sonst mit dem allgemeinen. + */ +function baueQuellen(body: RefreshBody): Quelle[] { + const angefragt = (body.sources ?? []).filter(q => q.url && q.name).slice(0, MAX_SOURCES) + if (angefragt.length === 0) return STANDARDQUELLEN + + return angefragt.map((q): Quelle => { + const speziell = SPEZIALLESER.get(q.url) + return { + id: q.id, + name: q.name, + url: q.url, + laden: speziell ?? (() => fetchGenericSource(q)), + } + }) +} + +/** + * Abgelegte Dokumente als Einträge — dieselbe Beurteilung wie bei den Seiten. + * + * Das ist der ganze Mechanismus aus §2.6: Ein hochgeladenes PDF unterscheidet + * sich für die Analyse in nichts von einem gelesenen Artikel, sobald sein Text + * extrahiert ist. Ein zweiter Analysepfad dafür wäre eine zweite Stelle, an der + * sich die Beurteilung ändern könnte. + */ +function dokumenteAlsEintraege(body: RefreshBody): ResearchItem[] { + return (body.documents ?? []) + .filter(d => typeof d.text === 'string' && d.text.trim().length > 120) + .slice(0, MAX_DOCUMENTS) + .map(d => ({ + source: 'Manuell abgelegtes Dokument', + title: d.name, + // Es gibt keine Webadresse — die Kennung des Dokuments tritt an ihre Stelle. + url: `dokument:${d.id}`, + text: d.text.slice(0, DOC_TEXT_LIMIT), + })) +} + export default async function handler(req: IncomingMessage, res: ServerResponse): Promise { res.setHeader('Content-Type', 'application/json; charset=utf-8') // Ein Live-Lauf soll nie aus einem Zwischenspeicher beantwortet werden. @@ -48,9 +138,13 @@ export default async function handler(req: IncomingMessage, res: ServerResponse) return } - // Alle drei parallel: eine langsame Quelle soll die beiden anderen nicht aufhalten. + const body = await leseBody(req) + const quellen = baueQuellen(body) + const dokumente = dokumenteAlsEintraege(body) + + // Alle parallel: eine langsame Quelle soll die anderen nicht aufhalten. const ergebnisse = await Promise.all( - QUELLEN.map(async (q): Promise<{ meta: ResearchSourceResult; items: ResearchItem[] }> => { + quellen.map(async (q): Promise<{ meta: ResearchSourceResult; items: ResearchItem[] }> => { try { const items = await q.laden() return { @@ -71,13 +165,27 @@ export default async function handler(req: IncomingMessage, res: ServerResponse) ) const sources = ergebnisse.map(e => e.meta) - const items = ergebnisse.flatMap(e => e.items) + + // Abgelegte Dokumente erscheinen als eigene Zeile in der Quellenübersicht — + // wer sie hochgeladen hat, soll sehen, dass sie tatsächlich gelesen wurden. + if (dokumente.length > 0) { + sources.push({ + id: 'dokumente', + name: `Manuell abgelegte Dokumente (${dokumente.length})`, + url: '', + ok: true, + itemCount: dokumente.length, + }) + } + + const items = [...ergebnisse.flatMap(e => e.items), ...dokumente] const basis: ResearchRefreshResult = { sources, analyzed: items.length, discarded: 0, watchlist: 0, + temporalFiltered: 0, leads: [], refreshedAt: new Date().toISOString(), model: MODEL, @@ -87,15 +195,16 @@ export default async function handler(req: IncomingMessage, res: ServerResponse) res.statusCode = 200 res.end(JSON.stringify({ ...basis, - analysisError: 'Keine der drei Quellen lieferte Einträge.', + analysisError: 'Keine der angebundenen Quellen lieferte Einträge.', })) return } try { - const { leads, discarded, watchlist } = await analyzeResearchItems(items) + const { leads, discarded, watchlist, temporalFiltered } = + await analyzeResearchItems(items, body.temporalClasses ?? []) res.statusCode = 200 - res.end(JSON.stringify({ ...basis, leads, discarded, watchlist })) + res.end(JSON.stringify({ ...basis, leads, discarded, watchlist, temporalFiltered })) } catch (err) { // Gelesen wurde trotzdem — das sagen wir offen, statt eine leere Liste als // «nichts gefunden» auszugeben. diff --git a/src/components/market-leads/LeadDetail.tsx b/src/components/market-leads/LeadDetail.tsx index 95c0d33..f5adcfc 100644 --- a/src/components/market-leads/LeadDetail.tsx +++ b/src/components/market-leads/LeadDetail.tsx @@ -1,10 +1,10 @@ import { useMemo } from 'react' -import { Alert, Box, Chip, Divider, Typography } from '@mui/material' -import { CheckCircle2, ExternalLink, MapPin, Ruler } from 'lucide-react' +import { Alert, Box, Button, Chip, Divider, Typography } from '@mui/material' +import { CheckCircle2, ExternalLink, MapPin, Ruler, Target } from 'lucide-react' import type { MarketLead } from '../../hooks/useMarketLeads' import { AgentAvatar, ObjectDeepLink } from '../team' import { agentWorkspaceById } from '../../lib/agentWorkspaces' -import { SOURCE_TYPE_LABELS } from '../../lib/constants' +import { SOURCE_TYPE_LABELS, TEMPORAL_CLASS_LABELS } from '../../lib/constants' import { isRisiko, leadSignalTypeOf, signalRationaleOf } from '../../lib/leadSignal' import { MIN_MATCH_PCT, areaFitPct, confirmableContacts } from './marketLeadHelpers' import { LeadSignalTypeBadge } from './LeadSignalTypeBadge' @@ -31,6 +31,12 @@ interface LeadDetailProps { lead: MarketLead /** Matching-Block anzeigen. Bei Nora ja, bei Livia nein (§1). */ showMatching?: boolean + /** + * Übergabe an Nora (Runde 10, §2.14). Nur gesetzt, wo der Knopf hingehört — + * auf Noras eigener Seite wäre «Matching starten» hier ein zweiter Weg zu + * derselben Handlung, die dort schon im Kopf des Matching-Bereichs steht. + */ + onStartMatching?: (signalId: string) => void } /** @@ -39,11 +45,22 @@ interface LeadDetailProps { * Ein neues Signal ist damit eine neue Komponente und startet mit frischem * Zustand, statt ihn in einem Effekt zurücksetzen zu müssen. */ -function LeadDetail({ lead, showMatching = true }: LeadDetailProps) { - return +function LeadDetail({ lead, showMatching = true, onStartMatching }: LeadDetailProps) { + return ( + + ) } -function LeadDetailBody({ lead, showMatching }: { lead: MarketLead; showMatching: boolean }) { +function LeadDetailBody({ lead, showMatching, onStartMatching }: { + lead: MarketLead + showMatching: boolean + onStartMatching?: (signalId: string) => void +}) { const { signal, matchingProperties } = lead const sourceLabel = SOURCE_TYPE_LABELS[signal.source.type] ?? signal.source.type const companyName = signal.companyName ?? signal.locationHint @@ -133,19 +150,95 @@ function LeadDetailBody({ lead, showMatching }: { lead: MarketLead; showMatching - {/* Bei Risiko: das betroffene Mietverhältnis benennen (§2) */} - {risiko && (signal.affectedTenant || signal.propertyId) && ( + {/* + Bei Risiko: das betroffene Mietverhältnis benennen (§2, Runde 10 §2.13A). + Seit Runde 10 steht der Kasten auch dann, wenn nichts zuordenbar ist — + mit genau diesem Satz. Ein fehlender Kasten liesse offen, ob niemand + nachgesehen hat oder ob nichts betroffen ist; eine beliebige + Mock-Immobilie zu zeigen wäre die schlechtere Antwort von beiden. + */} + {risiko && ( - Betroffenes Mietverhältnis + Betroffenes Objekt {signal.affectedTenant && ( {signal.affectedTenant} )} - {signal.propertyId && ( + {signal.propertyId ? ( + ) : ( + !signal.affectedTenant && ( + + Kein internes Objekt eindeutig zugeordnet. + + ) + )} + + )} + + {/* Zeitliche Einordnung mit Fundstelle (Runde 10, §2.9) */} + {signal.temporalClass && ( + + + Zeitliche Relevanz + + + + {signal.eventDate && ( + + Ereigniszeit laut Quelle: {signal.eventDate} + + )} + + {signal.temporalEvidence && ( + + {signal.temporalEvidence} + + )} + + )} + + {/* + Semantisches Suchprofil (Runde 10, §§2.13B/2.14). + + Es steht nur bei Chance-Leads, weil es einen Flächenbedarf beschreibt — + bei einem Risiko gibt es keinen Nachfrager, für den man suchen könnte. + Der Text ist derselbe, den Nora abgleicht; erzeugt wird er einmal, von + Livia. Ein zweiter Text an dieser Stelle wären zwei Aussagen über + denselben Bedarf. + */} + {!risiko && signal.semanticSearchProfile && ( + + + Semantisches Suchprofil + + + {signal.semanticSearchProfile} + + + {/* + «Matching starten» übergibt denselben Lead an Nora — über die + Lead-ID, nicht über eine Kopie. Das Kennzeichen im Zustand sagt + Nora, dass der Lauf sofort starten darf; wer den Lead später + normal öffnet, löst nichts von selbst aus (§2.14). + */} + {onStartMatching && ( + )} )} diff --git a/src/components/research/ResearchWorkspace.tsx b/src/components/research/ResearchWorkspace.tsx index 608fbd6..68e5daa 100644 --- a/src/components/research/ResearchWorkspace.tsx +++ b/src/components/research/ResearchWorkspace.tsx @@ -1,30 +1,45 @@ import { useCallback, useMemo, useState } from 'react' +import { useNavigate } from 'react-router' import { Alert, Box, Button, CircularProgress, Drawer, Typography, useMediaQuery, useTheme } from '@mui/material' import { RefreshCw } from 'lucide-react' import { LeadDetail, UnifiedLeadList } from '../market-leads' import { ResearchSourcesPanel } from './ResearchSourcesPanel' -import { ResearchLeadCard } from './ResearchLeadCard' import { useUnifiedLeads } from '../../hooks/useUnifiedLeads' import { useLiviaResearch } from '../../hooks/useLiviaResearch' +import { useResearchDocuments } from '../../hooks/useResearchDocuments' +import { useTeamAgent } from '../../hooks/useTeamAgents' +import { leseQuellenAus } from '../../lib/agentSystems' import { LeadChannel } from '../../domain/unifiedLead' import type { UnifiedLead } from '../../domain/unifiedLead' import { LeadSignalType } from '../../domain/futureSignal' +import { TemporalClass } from '../../domain/researchLead' +import type { TemporalClass as TemporalClassValue } from '../../domain/researchLead' +import { ROUTES } from '../../lib/constants' import { DS_SLATE, DS_TEXT } from '../../lib/ds' +/** Kennung der Einstellung, die die erlaubten Ereigniszeiten führt (§2.9). */ +const TEMPORAL_SETTING_ID = 'livia-set-temporal-relevance' + +const GUELTIGE_KLASSEN = new Set(Object.values(TemporalClass)) + /** - * Livias Recherche-Arbeitsplatz (Runde 8, §1; Research-PoC §15). + * Livias Recherche-Arbeitsplatz (Runde 8, §1; Research-PoC §15; Runde 10, §2.12). * - * Zwei Bestände nebeneinander, bewusst getrennt gehalten: + * Seit Runde 10 gibt es hier **eine** Leadliste. Bis dahin standen die frisch + * gelesenen Leads als eigene Karten über dem erfassten Bestand — technisch + * sauber getrennt, in der Benutzung aber unbrauchbar: Dieselbe Firma sah oben + * anders aus als unten, die Filter griffen nur auf der einen Hälfte, und Nora + * bekam die neuen Leads gar nicht zu sehen. * - * 1. **Live-Recherche** — was Livia beim Knopfdruck aus den drei realen - * Quellen gelesen und beurteilt hat. Diese Leads sind nicht gespeichert; - * sie leben im Zustand dieser Komponente, bis der nächste Lauf sie ersetzt. - * 2. **Erfasste Leads** — der bestehende Signalbestand, den Nora abgleicht. + * Jetzt wandert ein Lauf direkt in den zentralen Signalbestand. Was oben steht, + * ist nur noch der Bericht über den Lauf selbst: welche Quellen antworteten, + * wie viel gelesen und wie viel verworfen wurde. Die Leads stehen dort, wo alle + * Leads stehen. * - * Die Trennung ist Absicht: ein live gelesener Artikel ist etwas anderes als - * ein redaktionell erfasster Lead, und beides in eine Liste zu mischen würde - * genau diesen Unterschied verwischen. Die Liste unten ist dieselbe Komponente - * wie bei Nora — mit `showMatching={false}`, weil das Matching ihre Arbeit ist. + * Welche Quellen abgerufen werden, entscheidet nicht diese Komponente, sondern + * Livias Personalblatt: jeder aktive Lesezugang mit Adresse, dazu die manuell + * abgelegten Dokumente. Damit ist die Anzeige unter «Systeme» keine Behauptung, + * sondern die Eingabe des Laufs. */ export function ResearchWorkspace() { const theme = useTheme() @@ -32,6 +47,8 @@ export function ResearchWorkspace() { const [selected, setSelected] = useState(null) const { data: leads, isLoading } = useUnifiedLeads() + const { data: livia } = useTeamAgent('livia') + const { data: dokumente = [] } = useResearchDocuments() const refresh = useLiviaResearch() const ergebnis = refresh.data @@ -49,18 +66,53 @@ export function ResearchWorkspace() { return { research: rows, chancen: c, risiken: r } }, [leads]) + /** Die Lesequellen kommen aus dem gespeicherten Stand, nicht aus einer festen Liste. */ + const quellen = useMemo(() => leseQuellenAus(livia?.systems ?? []), [livia?.systems]) + + /** Die erlaubten Ereigniszeiten stehen als Einstellung am Personalblatt. */ + const zeitfenster = useMemo((): TemporalClassValue[] => { + const wert = livia?.settings.find(s => s.id === TEMPORAL_SETTING_ID)?.value + if (!Array.isArray(wert)) return [] + return wert.filter((v): v is TemporalClassValue => GUELTIGE_KLASSEN.has(v)) + }, [livia?.settings]) + + const navigate = useNavigate() + + /** + * Übergabe an Nora (Runde 10, §2.14). + * + * Weitergereicht wird nur die Lead-ID — Nora liest denselben Eintrag aus + * demselben Bestand, es entsteht keine Kopie. Das Kennzeichen `matching=1` + * sagt ihr, dass der Lauf sofort starten darf; ohne dieses Kennzeichen läuft + * beim normalen Öffnen nichts von selbst. + * + * Beides steht in der Adresse und nicht im Navigationszustand: So überlebt + * die Übergabe ein Neuladen, und der Link lässt sich weitergeben. + */ + const handleStartMatching = useCallback( + (signalId: string) => { + navigate(`${ROUTES.SUPPLY.AGENT_NORA}?lead=${encodeURIComponent(signalId)}&matching=1`) + }, + [navigate], + ) + const closeDetail = useCallback(() => setSelected(null), []) - const starten = useCallback(() => refresh.mutate(), [refresh]) + const starten = useCallback( + () => refresh.mutate({ sources: quellen, documents: dokumente, temporalClasses: zeitfenster }), + [refresh, quellen, dokumente, zeitfenster], + ) + + const keineQuellen = quellen.length === 0 && dokumente.length === 0 return ( - {/* ── Live-Recherche ──────────────────────────────────────────────── */} + {/* ── Der Lauf ────────────────────────────────────────────────────── */} + + PDF oder Word (.docx), höchstens {RESEARCH_DOCUMENT_MAX_BYTES / 1024 / 1024} MB je Datei + + + + {isLoading ? ( + Dokumente werden geladen … + ) : dokumente.length === 0 ? ( + + Noch nichts abgelegt. Abgelegte Dokumente gehen zusammen mit den aktiven Lesequellen in den + nächsten Recherchelauf. + + ) : ( + + {dokumente.map(doc => ( + + ))} + + )} + + ) +} diff --git a/src/domain/futureSignal.ts b/src/domain/futureSignal.ts index 82ebda6..0a406c8 100644 --- a/src/domain/futureSignal.ts +++ b/src/domain/futureSignal.ts @@ -1,4 +1,5 @@ import type { SignalType, RiskLevel, ReviewStatus } from './enums' +import type { TemporalClass } from './researchLead' export type ContactType = 'EMAIL' | 'PHONE' | 'WEBSITE' | 'LINKEDIN' | 'CONTACT_PERSON' export type ContactConfidence = 'HIGH' | 'MEDIUM' | 'LOW' @@ -87,6 +88,38 @@ export interface FutureSignal { affectedTenant?: string /** Externe Quellen, aus denen Livia den Lead verdichtet hat. */ researchSources?: SignalSource[] + + // ── Runde 10 ──────────────────────────────────────────────────────────────── + + /** + * Wann die beschriebene Veränderung stattfindet (§2.9). + * + * Ausdrücklich nicht dasselbe wie `source.publishedAt` und auch nicht + * dasselbe wie `timeHorizonMonths`: Der Horizont ist eine Schätzung in + * Monaten, diese Klasse eine belegte Einordnung mit Fundstelle. Optional, + * weil Bestandssignale sie nicht tragen — fehlt sie, gilt der Lead als + * zeitlich nicht eingeordnet und fällt durch keinen Zeitfilter. + */ + temporalClass?: TemporalClass + /** Die Textstelle, die die zeitliche Einordnung trägt. Ohne sie ist sie nicht prüfbar. */ + temporalEvidence?: string + /** Nur gesetzt, wenn die Quelle ein Datum nennt. Nie geschätzt. */ + eventDate?: string + /** + * Ausformuliertes Nachfrageprofil (§2.13B). + * + * Einzige Wahrheit für Livia und Nora: Livia erstellt es, Nora gleicht es + * gegen den Bestand ab. Nora erzeugt bewusst keinen eigenen Text — zwei + * Fassungen desselben Profils wären zwei Aussagen über denselben Bedarf. + */ + semanticSearchProfile?: string + /** + * Herkunft des Signals. `RESEARCH_RUN` markiert Leads, die ein + * Recherchelauf erzeugt hat — sie stehen in derselben Liste wie die + * erfassten und unterscheiden sich nur durch dieses Feld, nicht durch eine + * eigene Ablage (§2.12). + */ + origin?: 'SEED' | 'RESEARCH_RUN' } // ── Chance / Risiko (Runde 8, §2) ──────────────────────────────────────────── diff --git a/src/domain/researchDocument.ts b/src/domain/researchDocument.ts new file mode 100644 index 0000000..dde7834 --- /dev/null +++ b/src/domain/researchDocument.ts @@ -0,0 +1,55 @@ +/** + * Property On — manuell abgelegte Newsquellen (Runde 10, §2.6). + * + * Nicht jede Quelle ist eine Webseite. Ein Geschäftsbericht, ein + * Verbandsrundschreiben, ein Protokoll aus einer Gemeindeversammlung — das + * kommt als PDF oder Word-Datei auf den Tisch und hat keine Adresse, die + * Livia abrufen könnte. + * + * Solche Dokumente sind deshalb kein eigener Datentyp mit eigener Behandlung, + * sondern eine zweite Art, Text in denselben Recherchelauf zu geben. Was am + * Ende beurteilt wird, ist in beiden Fällen Text mit einem Namen und einer + * Herkunft. + */ + +export const ResearchDocumentKind = { + PDF: 'PDF', + DOCX: 'DOCX', +} as const +export type ResearchDocumentKind = typeof ResearchDocumentKind[keyof typeof ResearchDocumentKind] + +export const RESEARCH_DOCUMENT_LABELS: Record = { + PDF: 'PDF', + DOCX: 'Word', +} + +/** Was von einem abgelegten Dokument geführt wird. */ +export interface ResearchDocument { + id: string + /** Dateiname, wie er beim Ablegen hiess — die einzige Bezeichnung, die der Nutzer wiedererkennt. */ + name: string + kind: ResearchDocumentKind + /** Grösse in Bytes; wird angezeigt, damit ein leeres Dokument auffällt. */ + size: number + uploadedAt: string + /** + * Der extrahierte Text. + * + * Er wird beim Ablegen einmal gewonnen und danach nie wieder — die + * Extraktion ist der teure Teil, und ihn bei jedem Lauf zu wiederholen + * würde denselben Text ein zweites Mal ergeben. + */ + text: string + /** + * Gesetzt, wenn aus der Datei kein brauchbarer Text zu holen war (etwa ein + * gescanntes PDF ohne Textebene). Das Dokument bleibt in der Liste — mit + * Hinweis, statt stillschweigend nichts beizutragen. + */ + extractionNote?: string +} + +/** Obergrenze je Datei. Grössere Dateien sprengen den Speicher des Browsers. */ +export const RESEARCH_DOCUMENT_MAX_BYTES = 15 * 1024 * 1024 + +/** Ab wie vielen Zeichen ein extrahierter Text als brauchbar gilt. */ +export const RESEARCH_DOCUMENT_MIN_CHARS = 200 diff --git a/src/domain/researchLead.ts b/src/domain/researchLead.ts index 8e49143..98de51d 100644 --- a/src/domain/researchLead.ts +++ b/src/domain/researchLead.ts @@ -46,6 +46,24 @@ export interface ResearchLead { /** Die tatsächlich gelesene Originalquelle — muss anklickbar sein (§2). */ sourceUrl: string publishedAt?: string + + // ── Runde 10 ──────────────────────────────────────────────────────────────── + + /** Zeitliche Dimension der beschriebenen Veränderung (§2.9). */ + temporalClass: TemporalClass + /** Der Satz aus der Quelle, der die Einordnung trägt — ohne ihn ist sie nicht prüfbar. */ + temporalEvidence: string + /** Nur gesetzt, wenn die Quelle ein Datum nennt. Nie geschätzt. */ + eventDate?: string + /** + * Ausformuliertes Nachfrageprofil für Chance-Leads (§2.13B). + * + * Kein Stichwortfeld: Nora gleicht es gegen den Objektbestand ab, und dafür + * muss darin stehen, was die Quelle hergibt — einschliesslich dessen, was sie + * nicht hergibt. Ein Profil, das Lücken verschweigt, führt zu Treffern, die + * niemand belegen kann. + */ + semanticSearchProfile?: string } /** Ergebnis je abgerufener Quelle — auch im Fehlerfall (§21). */ @@ -68,6 +86,8 @@ export interface ResearchRefreshResult { discarded: number /** Beobachtungswürdig, aber ohne bestätigten Flächenbezug. */ watchlist: number + /** Aussortiert, weil die Ereigniszeit ausserhalb der gewählten Fenster lag (§2.9). */ + temporalFiltered: number /** Nur `high` und `medium` erscheinen hier. */ leads: ResearchLead[] /** Zeitpunkt des Laufs, ISO. */ @@ -87,3 +107,44 @@ export interface ResearchRefreshResult { */ analysisError?: string } + +// ── Zeitliche Relevanz (Runde 10, §2.9) ─────────────────────────────────────── + +/** + * Wann die beschriebene Veränderung stattfindet — **nicht**, wann der Artikel + * erschienen ist. + * + * Das ist der ganze Punkt dieser Klassifikation: Ein Jahresbericht vom Januar + * kann einen Standort für das dritte Quartal ankündigen (`FUTURE`), und eine + * Meldung von heute kann einen Umzug vom Frühling beschreiben (`PAST`). Wer + * nach Publikationsdatum filtert, bekommt in beiden Fällen das Gegenteil + * dessen, was er sucht. + * + * `UNKNOWN` ist ausdrücklich erlaubt. Wenn die Quelle keine belastbare + * zeitliche Aussage enthält, ist «weiss ich nicht» die richtige Antwort — + * ein erfundenes Datum wäre die falsche. + */ +export const TemporalClass = { + PAST: 'past', + CURRENT: 'current', + FUTURE: 'future', + UNKNOWN: 'unknown', +} as const +export type TemporalClass = typeof TemporalClass[keyof typeof TemporalClass] + +/** Reihenfolge im Einstellungsbereich — von abgeschlossen nach angekündigt. */ +export const TEMPORAL_FILTER_ORDER: TemporalClass[] = [ + TemporalClass.PAST, + TemporalClass.CURRENT, + TemporalClass.FUTURE, +] + +/** + * Die Grenze zwischen «jetzt» und «später», in Wochen. + * + * Acht Wochen sind keine willkürliche Zahl: Sie entsprechen ungefähr der + * Vorlaufzeit, die eine Bewirtschaftung braucht, um auf einen Flächenbedarf + * überhaupt noch mit einem Angebot zu reagieren. Alles darunter ist ein + * laufender Vorgang, alles darüber eine Planung. + */ +export const TEMPORAL_CURRENT_WEEKS = 8 diff --git a/src/domain/teamAgent.ts b/src/domain/teamAgent.ts index 09404a7..a504894 100644 --- a/src/domain/teamAgent.ts +++ b/src/domain/teamAgent.ts @@ -120,6 +120,19 @@ export interface AgentSystem { * die Zugänge ohne Schalter führt — fehlt das Feld, gilt der Zugang als aktiv. */ enabled?: boolean + /** + * Eigener Titel der Quelle (Runde 10, §2.1). Der Katalog benennt seine + * Zugänge über `type`; selbst angebundene Quellen haben keinen passenden + * Typ und tragen ihren Namen deshalb hier. Fehlt der Titel, gilt das Label + * des Typs — so bleiben die Katalogeinträge unverändert. + */ + title?: string + /** + * Adresse der Quelle. Bei einer aktiven Lesequelle ist das die Seite, die + * Livias Recherchelauf tatsächlich abruft — der angezeigte Link und der + * gelesene Link sind damit derselbe Wert. + */ + url?: string /** Wofür der Agent dieses System nutzt — in Alltagssprache, ohne KI-Jargon. */ usage: string /** Klartext zur Berechtigung, z. B. «Schreibt erst nach Freigabe». */ @@ -149,6 +162,18 @@ export const AgentSettingKind = { MULTI_SELECT: 'MULTI_SELECT', BOOLEAN: 'BOOLEAN', TIME: 'TIME', + /** + * Mehrfachauswahl als Chips, jeder einzeln entfernbar (Runde 10, §§2.7–2.9). + * + * Der Unterschied zu `MULTI_SELECT` ist nicht bloss die Darstellung: Ein + * Auswahlfeld kann nur anbieten, was jemand vorher als Option hinterlegt + * hat. Quellentypen und Beobachtungsräume sind aber genau das, was sich von + * Haus zu Haus unterscheidet — sie brauchen ein Feld, in das man schreiben + * kann, was man meint. + */ + CHIPS: 'CHIPS', + /** Abgelegte Dokumente als Datenbasis der Recherche (Runde 10, §2.6). */ + DOCUMENTS: 'DOCUMENTS', } as const export type AgentSettingKind = typeof AgentSettingKind[keyof typeof AgentSettingKind] @@ -179,6 +204,21 @@ export interface AgentSetting { /** Fachlich nicht abschaltbar — z. B. Sinas Quellenzwang. */ locked?: boolean lockedReason?: string + /** + * Erklärt auf Knopfdruck, wie ein Wert zustande kommt (Runde 10, §2.10). + * + * Gehört ans Datenmodell und nicht in die Komponente: Was ein Schwellenwert + * bedeutet, weiss das Personalblatt, nicht das Eingabefeld. Und ein Text, + * der eine Berechnung beschreibt, muss neben der Berechnung stehen, damit + * beide zusammen geändert werden. + */ + infoText?: string + /** + * Nur bei `CHIPS`: ob eigene Werte erfasst werden dürfen. Bei einer + * fachlich abgeschlossenen Liste — etwa den drei Zeitfenstern — bleibt es + * aus, sonst entstünde ein vierter Wert, den niemand auswerten kann. + */ + allowCustom?: boolean } // ── Kennzahlen & Profil ─────────────────────────────────────────────────────── diff --git a/src/hooks/useLiviaResearch.ts b/src/hooks/useLiviaResearch.ts index ec89b33..ead769d 100644 --- a/src/hooks/useLiviaResearch.ts +++ b/src/hooks/useLiviaResearch.ts @@ -1,8 +1,23 @@ -import { useMutation } from '@tanstack/react-query' -import type { ResearchRefreshResult } from '../domain/researchLead' +import { useMutation, useQueryClient } from '@tanstack/react-query' +import type { ResearchRefreshResult, TemporalClass } from '../domain/researchLead' +import type { ResearchSourceDescriptor } from '../lib/researchSources' import { RESEARCH_REFRESH_ENDPOINT } from '../lib/researchSources' +import { futureSignalService } from '../services/futureSignalService' +import { agentProtocolService } from '../services/agentProtocolService' +import { AgentProtocolEventType, AgentProtocolStatus } from '../domain/agentProtocol' +import type { ResearchDocument } from '../domain/researchDocument' import { useToastStore } from '../stores/toastStore' +/** Was ein Lauf mitbekommt — alles aus dem gespeicherten Stand, nichts hartcodiert. */ +export interface ResearchRunInput { + /** Aktive Lesezugänge mit Adresse, abgeleitet aus Livias Systemen (§2.3). */ + sources: ResearchSourceDescriptor[] + /** Manuell abgelegte Dokumente mit bereits extrahiertem Text (§2.6). */ + documents: ResearchDocument[] + /** Erlaubte Ereigniszeiten; leer bedeutet «keine Einschränkung» (§2.9). */ + temporalClasses: TemporalClass[] +} + /** * «Research aktualisieren» — der eine Aufruf des PoC. * @@ -11,15 +26,33 @@ import { useToastStore } from '../stores/toastStore' * `staleTime` und keine Zwischenspeicherung — wer auf den Knopf drückt, will * den Stand von jetzt und nicht den von vorhin. * - * Das Ergebnis lebt im Zustand der Komponente. Für den Machbarkeitsnachweis - * ist keine Persistenz nötig (§17). + * Seit Runde 10 endet der Lauf nicht mit der Antwort. Drei Dinge passieren + * danach, und zwar hier, weil sie zusammengehören (§§2.5/2.12): + * + * 1. Die gefundenen Leads gehen in den **zentralen** Signalbestand — es gibt + * keine zweite Ergebnisliste mehr. + * 2. Der Lauf erzeugt einen **echten** Protokolleintrag mit der Zahl der + * gelesenen Quellen und der gefundenen Leads. + * 3. Die Leadliste wird neu geladen, damit das Ergebnis sofort dort steht, wo + * es hingehört. */ export function useLiviaResearch() { const showToast = useToastStore(s => s.showToast) + const queryClient = useQueryClient() - return useMutation({ - mutationFn: async () => { - const res = await fetch(RESEARCH_REFRESH_ENDPOINT, { method: 'POST' }) + return useMutation({ + mutationFn: async ({ sources, documents, temporalClasses }) => { + const res = await fetch(RESEARCH_REFRESH_ENDPOINT, { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ + sources: sources.map(q => ({ id: q.id, name: q.name, url: q.url })), + // Nur der extrahierte Text geht an den Server; die Datei selbst + // bleibt im Browser. Sie hochzuladen wäre Datenversand ohne Nutzen. + documents: documents.map(d => ({ id: d.id, name: d.name, text: d.text })), + temporalClasses, + }), + }) // Ohne laufende Serverfunktion liefert der Hoster die Anwendung selbst // zurück — dann steht hier HTML statt JSON. Das ist der häufigste Fall @@ -35,6 +68,32 @@ export function useLiviaResearch() { return await res.json() as ResearchRefreshResult }, + + onSuccess: async (ergebnis) => { + if (ergebnis.leads.length > 0) { + await futureSignalService.importResearchLeads(ergebnis.leads, ergebnis.refreshedAt) + await queryClient.invalidateQueries({ queryKey: ['futureSignals'] }) + } + + // Der Eintrag trägt die Zahlen des Laufs, nicht einen festen Text — + // ein Protokoll, das immer dasselbe sagt, protokolliert nichts (§2.5). + const gelesen = ergebnis.sources.filter(s => s.ok).length + await agentProtocolService.logUserAction({ + agentId: 'livia', + eventType: AgentProtocolEventType.TASK_RUN, + title: 'Research aktualisiert', + description: + `${gelesen} von ${ergebnis.sources.length} ${ergebnis.sources.length === 1 ? 'Quelle' : 'Quellen'} gelesen · ` + + `${ergebnis.analyzed} ${ergebnis.analyzed === 1 ? 'Eintrag' : 'Einträge'} beurteilt · ` + + `${ergebnis.leads.length} ${ergebnis.leads.length === 1 ? 'Lead' : 'Leads'} in die Leadliste übernommen` + + (ergebnis.temporalFiltered > 0 + ? ` · ${ergebnis.temporalFiltered} wegen der zeitlichen Relevanz ausgeschlossen` + : ''), + status: ergebnis.analysisError ? AgentProtocolStatus.WARNING : AgentProtocolStatus.SUCCESS, + }) + await queryClient.invalidateQueries({ queryKey: ['agentProtocol'] }) + }, + onError: (err) => { showToast(err.message, 'error') }, diff --git a/src/hooks/useResearchDocuments.ts b/src/hooks/useResearchDocuments.ts new file mode 100644 index 0000000..d9474ec --- /dev/null +++ b/src/hooks/useResearchDocuments.ts @@ -0,0 +1,50 @@ +import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query' +import { researchDocumentService } from '../services/researchDocumentService' +import { STALE_SIGNALS } from '../lib/constants' +import { useToastStore } from '../stores/toastStore' + +const KEY = ['researchDocuments'] + +/** Die manuell abgelegten Newsquellen (Runde 10, §2.6). */ +export function useResearchDocuments() { + return useQuery({ + queryKey: KEY, + queryFn: () => researchDocumentService.getAll(), + staleTime: STALE_SIGNALS, + select: (res) => res.data, + }) +} + +export function useUploadResearchDocument() { + const queryClient = useQueryClient() + return useMutation({ + mutationFn: (file: File) => researchDocumentService.upload(file), + onSuccess: (res) => { + void queryClient.invalidateQueries({ queryKey: KEY }) + // Ein Dokument ohne brauchbaren Text wird abgelegt, trägt aber nichts + // bei — das muss beim Ablegen gesagt werden und nicht erst, wenn der + // Lauf keine Leads daraus findet. + if (res.data.extractionNote) { + useToastStore.getState().showToast(res.data.extractionNote, 'warning') + } else { + useToastStore.getState().showToast(`«${res.data.name}» abgelegt.`, 'success') + } + }, + onError: (err: Error) => { + useToastStore.getState().showToast(err.message, 'error') + }, + }) +} + +export function useRemoveResearchDocument() { + const queryClient = useQueryClient() + return useMutation({ + mutationFn: (id: string) => researchDocumentService.remove(id), + onSuccess: () => { + void queryClient.invalidateQueries({ queryKey: KEY }) + }, + onError: () => { + useToastStore.getState().showToast('Das Dokument konnte nicht entfernt werden.', 'error') + }, + }) +} diff --git a/src/lib/__tests__/agentSystems.test.ts b/src/lib/__tests__/agentSystems.test.ts new file mode 100644 index 0000000..e93bd40 --- /dev/null +++ b/src/lib/__tests__/agentSystems.test.ts @@ -0,0 +1,94 @@ +/** + * Welche Systemzugänge ein Recherchelauf tatsächlich abruft (Runde 10, §2.3). + * + * Der Test hält die Zusage fest, die das Personalblatt dem Nutzer gibt: Was + * dort als aktive Lesequelle mit Adresse steht, wird gelesen — und nichts sonst. + */ + +import { describe, expect, it } from 'vitest' +import { istAktiv, istSchreibend, leseQuellenAus, systemTitel } from '../agentSystems' +import { + AgentAccessLevel, + AgentConnectionStatus, + AgentSystemType, +} from '../../domain/teamAgent' +import type { AgentSystem } from '../../domain/teamAgent' + +function system(overrides: Partial = {}): AgentSystem { + return { + id: 'sys-1', + type: AgentSystemType.PUBLIC_WEB, + access: AgentAccessLevel.READ, + status: AgentConnectionStatus.CONNECTED, + usage: 'Regionale Unternehmensmeldungen.', + permissionNote: '', + title: 'Beispielquelle', + url: 'https://www.beispiel.ch/news', + ...overrides, + } +} + +describe('istAktiv', () => { + it('gilt ohne Feld als aktiv — der Katalog führt seine Zugänge ohne Schalter', () => { + expect(istAktiv(system({ enabled: undefined }))).toBe(true) + }) + + it('ist nur bei ausdrücklichem false abgeschaltet', () => { + expect(istAktiv(system({ enabled: false }))).toBe(false) + expect(istAktiv(system({ enabled: true }))).toBe(true) + }) +}) + +describe('istSchreibend', () => { + it('zählt READ_WRITE als schreibend', () => { + expect(istSchreibend(system({ access: AgentAccessLevel.READ_WRITE }))).toBe(true) + expect(istSchreibend(system({ access: AgentAccessLevel.WRITE }))).toBe(true) + expect(istSchreibend(system({ access: AgentAccessLevel.READ }))).toBe(false) + }) +}) + +describe('systemTitel', () => { + it('nimmt den eigenen Titel, wenn einer gesetzt ist', () => { + expect(systemTitel(system({ title: 'Handelskammer' }))).toBe('Handelskammer') + }) + + it('fällt auf das Katalog-Label zurück', () => { + expect(systemTitel(system({ title: undefined, type: AgentSystemType.ZEFIX }))).toBe('Zefix') + }) + + it('ignoriert einen Titel aus lauter Leerzeichen', () => { + expect(systemTitel(system({ title: ' ', type: AgentSystemType.ZEFIX }))).toBe('Zefix') + }) +}) + +describe('leseQuellenAus', () => { + it('nimmt aktive Lesezugänge mit Adresse auf', () => { + const quellen = leseQuellenAus([system()]) + + expect(quellen).toHaveLength(1) + expect(quellen[0]).toMatchObject({ id: 'sys-1', name: 'Beispielquelle', url: 'https://www.beispiel.ch/news' }) + }) + + it('lässt abgeschaltete Zugänge weg', () => { + expect(leseQuellenAus([system({ enabled: false })])).toHaveLength(0) + }) + + it('lässt schreibende Zugänge weg', () => { + expect(leseQuellenAus([system({ access: AgentAccessLevel.READ_WRITE })])).toHaveLength(0) + }) + + it('lässt Zugänge ohne Adresse weg — es gibt nichts zu holen', () => { + expect(leseQuellenAus([system({ url: undefined })])).toHaveLength(0) + expect(leseQuellenAus([system({ url: ' ' })])).toHaveLength(0) + }) + + it('behält die Reihenfolge des Personalblatts', () => { + const quellen = leseQuellenAus([ + system({ id: 'a', title: 'Erste' }), + system({ id: 'b', title: 'Zweite' }), + system({ id: 'c', title: 'Dritte', enabled: false }), + ]) + + expect(quellen.map(q => q.name)).toEqual(['Erste', 'Zweite']) + }) +}) diff --git a/src/lib/__tests__/researchLeadMapper.test.ts b/src/lib/__tests__/researchLeadMapper.test.ts new file mode 100644 index 0000000..331a88c --- /dev/null +++ b/src/lib/__tests__/researchLeadMapper.test.ts @@ -0,0 +1,112 @@ +/** + * Vom Recherche-Lead zum Signal im zentralen Bestand (Runde 10, §2.12). + * + * Der Schwerpunkt liegt auf zwei Zusagen, die die Anwendung sonst still + * brechen würde: Ein erneuter Lauf über denselben Artikel darf keine Dublette + * erzeugen, und das Publikationsdatum darf die zeitliche Einordnung nicht + * überschreiben. + */ + +import { describe, expect, it } from 'vitest' +import { researchLeadId, researchLeadToSignal } from '../researchLeadMapper' +import { ResearchEventType, TemporalClass } from '../../domain/researchLead' +import type { ResearchLead } from '../../domain/researchLead' +import { LeadSignalType } from '../../domain/futureSignal' + +const LAUF = '2026-09-12T08:00:00.000Z' + +function lead(overrides: Partial = {}): ResearchLead { + return { + company: 'Muster AG', + eventType: ResearchEventType.EXPANSION, + headline: 'Muster AG eröffnet zweiten Standort', + location: 'Zürich', + summary: 'Die Muster AG plant einen zusätzlichen Standort im Raum Zürich.', + relevance: 'high', + confidence: 0.8, + reason: 'Konkrete Standortankündigung mit Flächenbezug.', + source: 'Zürcher Handelskammer', + sourceUrl: 'https://www.zhk.ch/de/news/muster-ag', + temporalClass: TemporalClass.FUTURE, + temporalEvidence: 'Die Eröffnung ist für das dritte Quartal angekündigt.', + ...overrides, + } +} + +describe('researchLeadId', () => { + it('vergibt für denselben Artikel dieselbe Kennung', () => { + expect(researchLeadId(lead())).toBe(researchLeadId(lead())) + }) + + it('unterscheidet zwei Artikel derselben Quelle', () => { + const a = researchLeadId(lead()) + const b = researchLeadId(lead({ headline: 'Muster AG schliesst Werk Nord' })) + + expect(a).not.toBe(b) + }) + + it('unterscheidet denselben Titel aus zwei Quellen', () => { + const a = researchLeadId(lead()) + const b = researchLeadId(lead({ sourceUrl: 'https://www.greaterzuricharea.com/de/news/muster' })) + + expect(a).not.toBe(b) + }) +}) + +describe('researchLeadToSignal', () => { + it('macht aus einer Expansion eine Chance in Nachfragerichtung', () => { + const signal = researchLeadToSignal(lead(), LAUF) + + expect(signal.leadSignalType).toBe(LeadSignalType.CHANCE) + expect(signal.signalDirection).toBe('DEMAND') + expect(signal.origin).toBe('RESEARCH_RUN') + }) + + it('macht aus einer Standortschliessung ein Risiko', () => { + const signal = researchLeadToSignal(lead({ eventType: ResearchEventType.SITE_CLOSURE }), LAUF) + + expect(signal.leadSignalType).toBe(LeadSignalType.RISIKO) + }) + + it('übernimmt die zeitliche Einordnung samt Fundstelle', () => { + const signal = researchLeadToSignal(lead(), LAUF) + + expect(signal.temporalClass).toBe(TemporalClass.FUTURE) + expect(signal.temporalEvidence).toContain('dritte') + }) + + it('leitet den Zeithorizont aus der Ereigniszeit ab, nicht aus dem Publikationsdatum', () => { + // Heute publiziert, Ereignis aber abgeschlossen: kein Horizont in der Zukunft. + const vergangen = researchLeadToSignal( + lead({ temporalClass: TemporalClass.PAST, publishedAt: LAUF }), + LAUF, + ) + const zukuenftig = researchLeadToSignal( + lead({ temporalClass: TemporalClass.FUTURE, publishedAt: '2026-01-05' }), + LAUF, + ) + + expect(vergangen.timeHorizonMonths).toBe(0) + expect(zukuenftig.timeHorizonMonths).toBeGreaterThan(vergangen.timeHorizonMonths) + }) + + it('erfindet kein Ereignisdatum, wenn die Quelle keines nennt', () => { + const signal = researchLeadToSignal(lead({ temporalClass: TemporalClass.UNKNOWN }), LAUF) + + expect(signal.eventDate).toBeUndefined() + }) + + it('reicht das semantische Suchprofil unverändert weiter', () => { + const profil = 'Für die Muster AG wird ein Gewerbestandort im Raum Zürich gesucht. Nicht ableitbar ist die Fläche.' + const signal = researchLeadToSignal(lead({ semanticSearchProfile: profil }), LAUF) + + expect(signal.semanticSearchProfile).toBe(profil) + }) + + it('behält die Originalquelle als anklickbaren Beleg', () => { + const signal = researchLeadToSignal(lead(), LAUF) + + expect(signal.source.url).toBe('https://www.zhk.ch/de/news/muster-ag') + expect(signal.evidence?.sourceUrls).toEqual(['https://www.zhk.ch/de/news/muster-ag']) + }) +}) diff --git a/src/lib/__tests__/temporalFilter.test.ts b/src/lib/__tests__/temporalFilter.test.ts new file mode 100644 index 0000000..bec5314 --- /dev/null +++ b/src/lib/__tests__/temporalFilter.test.ts @@ -0,0 +1,73 @@ +/** + * Der harte Zeitfilter (Runde 10, §2.9). + * + * Die Fälle stammen aus der Anforderung selbst: eine bereits erfolgte + * Eröffnung, eine in drei Wochen, eine in vier Monaten — und der Fall, der den + * ganzen Filter begründet: ein heute erschienener Artikel über ein Ereignis von + * vor einem halben Jahr. + */ + +import { describe, expect, it } from 'vitest' +import { passtZeitlich } from '../temporalFilter' +import { TemporalClass } from '../../domain/researchLead' + +const ALLE = [TemporalClass.PAST, TemporalClass.CURRENT, TemporalClass.FUTURE] + +describe('passtZeitlich', () => { + it('lässt ohne Auswahl alles durch — keine Auswahl ist keine Einschränkung', () => { + for (const klasse of [...ALLE, TemporalClass.UNKNOWN]) { + expect(passtZeitlich(klasse, [])).toBe(true) + } + }) + + it('lässt nur die gewählten Fenster durch', () => { + expect(passtZeitlich(TemporalClass.FUTURE, [TemporalClass.FUTURE])).toBe(true) + expect(passtZeitlich(TemporalClass.PAST, [TemporalClass.FUTURE])).toBe(false) + expect(passtZeitlich(TemporalClass.CURRENT, [TemporalClass.FUTURE])).toBe(false) + }) + + it('wirkt bei mehreren Fenstern als Oder', () => { + const gewaehlt = [TemporalClass.CURRENT, TemporalClass.FUTURE] + + expect(passtZeitlich(TemporalClass.CURRENT, gewaehlt)).toBe(true) + expect(passtZeitlich(TemporalClass.FUTURE, gewaehlt)).toBe(true) + expect(passtZeitlich(TemporalClass.PAST, gewaehlt)).toBe(false) + }) + + it('verwirft einen Lead ohne belegbare Ereigniszeit nicht', () => { + // Ein erfundenes Datum wäre die schlechtere Antwort als ein sichtbarer Lead + // mit dem Vermerk, dass die Ereigniszeit offen ist. + expect(passtZeitlich(TemporalClass.UNKNOWN, [TemporalClass.FUTURE])).toBe(true) + }) + + it('behandelt ein Bestandssignal ohne Einordnung wie «unbekannt»', () => { + expect(passtZeitlich(undefined, [TemporalClass.PAST])).toBe(true) + }) + + describe('die Fälle aus der Anforderung', () => { + it('bereits erfolgte Eröffnung gehört zu «Vergangene Leads»', () => { + expect(passtZeitlich(TemporalClass.PAST, [TemporalClass.PAST])).toBe(true) + expect(passtZeitlich(TemporalClass.PAST, [TemporalClass.CURRENT, TemporalClass.FUTURE])).toBe(false) + }) + + it('Eröffnung in drei Wochen gehört zu «Aktuelle Leads»', () => { + expect(passtZeitlich(TemporalClass.CURRENT, [TemporalClass.CURRENT])).toBe(true) + expect(passtZeitlich(TemporalClass.CURRENT, [TemporalClass.PAST, TemporalClass.FUTURE])).toBe(false) + }) + + it('angekündigte Eröffnung in vier Monaten gehört zu «Zukünftige Leads»', () => { + expect(passtZeitlich(TemporalClass.FUTURE, [TemporalClass.FUTURE])).toBe(true) + expect(passtZeitlich(TemporalClass.FUTURE, [TemporalClass.PAST, TemporalClass.CURRENT])).toBe(false) + }) + + it('heute publiziert, Ereignis vor sechs Monaten — das ist vergangen, nicht aktuell', () => { + // Der Filter kennt nur die Klasse; dass sie aus der Ereigniszeit und + // nicht aus dem Publikationsdatum stammt, sichert der Auftrag an das + // Modell. Hier wird festgehalten, was daraus folgen muss. + const klasse = TemporalClass.PAST + + expect(passtZeitlich(klasse, [TemporalClass.PAST])).toBe(true) + expect(passtZeitlich(klasse, [TemporalClass.CURRENT])).toBe(false) + }) + }) +}) diff --git a/src/lib/agentSystems.ts b/src/lib/agentSystems.ts new file mode 100644 index 0000000..259f06e --- /dev/null +++ b/src/lib/agentSystems.ts @@ -0,0 +1,55 @@ +/** + * Property On — was sich aus einem Systemzugang ablesen lässt (Runde 10, §§2.1–2.3). + * + * Diese Ableitungen stehen bewusst ausserhalb der Reiter-Komponenten: Das + * Personalblatt zeigt sie an, und Livias Recherchelauf entscheidet nach + * denselben Regeln, welche Adresse er tatsächlich abruft. Zwei Fassungen + * derselben Regel wären die Stelle, an der Anzeige und Abruf auseinanderlaufen — + * und genau deren Übereinstimmung ist der Zweck der Anzeige. + */ + +import { AgentAccessLevel } from '../domain/teamAgent' +import type { AgentSystem } from '../domain/teamAgent' +import { AGENT_SYSTEM_LABELS } from './constants' +import type { ResearchSourceDescriptor } from './researchSources' + +/** Ohne Feld gilt ein Zugang als aktiv — der Katalog führt die Zugänge ohne Schalter. */ +export function istAktiv(system: AgentSystem): boolean { + return system.enabled !== false +} + +/** Eigener Titel schlägt das Katalog-Label; nur so lassen sich freie Quellen benennen. */ +export function systemTitel(system: AgentSystem): string { + return system.title?.trim() || AGENT_SYSTEM_LABELS[system.type] || system.type +} + +/** Schreibend ist alles, was nicht ausschliesslich liest. */ +export function istSchreibend(system: AgentSystem): boolean { + return system.access !== AgentAccessLevel.READ +} + +/** + * Die Systemzugänge, die ein Recherchelauf tatsächlich abruft. + * + * Drei Bedingungen, alle drei sichtbar im Personalblatt: der Zugang ist + * aktiv, er liest, und er hat eine Adresse. Ein Zugang ohne Adresse — etwa + * die Objektdatenbank — wird nicht abgerufen, weil es nichts zu holen gibt; + * ihn trotzdem als Quelle zu zählen, wäre eine hartcodierte Statusanzeige + * ohne Deckung im Datenmodell. + */ +export function leseQuellenAus(systems: AgentSystem[]): ResearchSourceDescriptor[] { + const quellen: ResearchSourceDescriptor[] = [] + for (const system of systems) { + if (!istAktiv(system)) continue + if (istSchreibend(system)) continue + const url = system.url?.trim() + if (!url) continue + quellen.push({ + id: system.id, + name: systemTitel(system), + url, + purpose: system.usage, + }) + } + return quellen +} diff --git a/src/lib/constants.ts b/src/lib/constants.ts index 2324e49..8383992 100644 --- a/src/lib/constants.ts +++ b/src/lib/constants.ts @@ -634,3 +634,17 @@ export const FIT_OUT_LABELS: Record = { FULL: 'Ausgebaut · CAT B', PREMIUM: 'Vollausgebaut · Plug & Play', } + +/** + * Zeitliche Relevanz eines Leads (Runde 10, §2.9). + * + * Die Begriffe beschreiben die Ereigniszeit der Veränderung, nicht das + * Publikationsdatum — deshalb «Veränderung abgeschlossen» und nicht + * «älterer Artikel». + */ +export const TEMPORAL_CLASS_LABELS: Record = { + past: 'Veränderung abgeschlossen', + current: 'Läuft oder steht kurz bevor', + future: 'Angekündigt, später', + unknown: 'Ereigniszeit nicht belegbar', +} diff --git a/src/lib/documentText.ts b/src/lib/documentText.ts new file mode 100644 index 0000000..894f652 --- /dev/null +++ b/src/lib/documentText.ts @@ -0,0 +1,233 @@ +/** + * Property On — Text aus abgelegten Dokumenten gewinnen (Runde 10, §2.6). + * + * Bewusst ohne neue Abhängigkeit. Der Browser bringt mit `DecompressionStream` + * bereits alles mit, was für beide Formate nötig ist: + * + * - **DOCX** ist ein ZIP-Archiv. Darin liegt `word/document.xml`, und der + * sichtbare Text steht in ``-Elementen. Mehr braucht es nicht. + * - **PDF** trägt seinen Text in Inhaltsströmen, meist mit Flate gepackt. Die + * Operatoren `Tj` und `TJ` setzen ihn. + * + * Was diese Datei ausdrücklich **nicht** ist: ein vollwertiger Dokumentenleser. + * Sie kennt keine Schriftkodierungen jenseits der üblichen, keine Tabellen, kein + * Layout und keine gescannten Seiten. Für die Beurteilung durch ein Sprachmodell + * genügt Fliesstext in der richtigen Reihenfolge — und wo sie scheitert, sagt + * sie das, statt eine leere Zeichenkette als «Dokument ohne Inhalt» auszugeben. + * + * Eine Bibliothek wie pdf.js würde mehr können. Sie wäre auch rund ein Megabyte + * gross, und der Machbarkeitsnachweis steht und fällt nicht an der Frage, ob + * ein zweispaltiges PDF sauber ausgelesen wird. + */ + +import { + RESEARCH_DOCUMENT_MIN_CHARS, + ResearchDocumentKind, +} from '../domain/researchDocument' + +export interface ExtractionResult { + text: string + /** Gesetzt, wenn der Text nicht brauchbar ist — die Datei bleibt trotzdem abgelegt. */ + note?: string +} + +// ── Gemeinsames ─────────────────────────────────────────────────────────────── + +async function inflate(bytes: Uint8Array, format: 'deflate' | 'deflate-raw'): Promise { + const stream = new Blob([bytes as BlobPart]).stream().pipeThrough(new DecompressionStream(format)) + const puffer = await new Response(stream).arrayBuffer() + return new Uint8Array(puffer) +} + +function normalisiere(text: string): string { + return text + .replace(/\r\n?/g, '\n') + .replace(/[ \t]+/g, ' ') + .replace(/\n{3,}/g, '\n\n') + .trim() +} + +// ── DOCX ────────────────────────────────────────────────────────────────────── + +/** + * Eine Datei aus einem ZIP-Archiv holen. + * + * Gelesen wird über das zentrale Verzeichnis am Dateiende — das ist der einzige + * Ort im ZIP-Format, an dem die Einträge verlässlich vollständig stehen. Die + * lokalen Kopfzeilen davor lassen Grössenangaben offen, wenn das Archiv im + * Datenstrom geschrieben wurde, und genau das tun viele Textverarbeitungen. + */ +async function zipEintrag(bytes: Uint8Array, pfad: string): Promise { + const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength) + + // Ende des zentralen Verzeichnisses suchen (Signatur 0x06054b50), von hinten. + let eocd = -1 + for (let i = bytes.length - 22; i >= 0 && i > bytes.length - 65_557; i--) { + if (view.getUint32(i, true) === 0x06054b50) { eocd = i; break } + } + if (eocd === -1) return null + + const anzahl = view.getUint16(eocd + 10, true) + let offset = view.getUint32(eocd + 16, true) + + const encoder = new TextDecoder() + for (let n = 0; n < anzahl; n++) { + if (view.getUint32(offset, true) !== 0x02014b50) return null + const methode = view.getUint16(offset + 10, true) + const gepackt = view.getUint32(offset + 20, true) + const nameLen = view.getUint16(offset + 28, true) + const extraLen = view.getUint16(offset + 30, true) + const kommentarLen = view.getUint16(offset + 32, true) + const lokal = view.getUint32(offset + 42, true) + const name = encoder.decode(bytes.subarray(offset + 46, offset + 46 + nameLen)) + + if (name === pfad) { + // Die lokale Kopfzeile sagt, wie lang Name und Zusatzfeld dort sind — + // sie dürfen von den Angaben im Verzeichnis abweichen. + const lokalNameLen = view.getUint16(lokal + 26, true) + const lokalExtraLen = view.getUint16(lokal + 28, true) + const start = lokal + 30 + lokalNameLen + lokalExtraLen + const daten = bytes.subarray(start, start + gepackt) + return methode === 0 ? daten : await inflate(daten, 'deflate-raw') + } + + offset += 46 + nameLen + extraLen + kommentarLen + } + return null +} + +async function ausDocx(bytes: Uint8Array): Promise { + const xmlBytes = await zipEintrag(bytes, 'word/document.xml') + if (!xmlBytes) { + return { text: '', note: 'Die Datei konnte nicht als Word-Dokument gelesen werden.' } + } + + const xml = new TextDecoder().decode(xmlBytes) + const absaetze: string[] = [] + // Je Absatz den Text seiner Textläufe zusammensetzen — sonst klebt der ganze + // Text in einer einzigen Zeile und das Modell verliert die Gliederung. + for (const [, inhalt] of xml.matchAll(/]*>([\s\S]*?)<\/w:p>/g)) { + const teile = [...inhalt.matchAll(/]*>([\s\S]*?)<\/w:t>/g)].map(m => m[1]) + if (teile.length === 0) continue + const zeile = teile + .join('') + .replace(/</g, '<').replace(/>/g, '>') + .replace(/"/g, '"').replace(/'/g, "'") + .replace(/&/g, '&') + .trim() + if (zeile) absaetze.push(zeile) + } + + return { text: normalisiere(absaetze.join('\n')) } +} + +// ── PDF ─────────────────────────────────────────────────────────────────────── + +/** Zeichenfolgen aus den Textoperatoren eines Inhaltsstroms. */ +function pdfTextAusStrom(strom: string): string { + const zeilen: string[] = [] + + // `(…) Tj` und `[(…) -250 (…)] TJ` — beide setzen sichtbaren Text. + const muster = /(\[(?:[^\][\\]|\\.)*\]|\((?:[^\\()]|\\.)*\))\s*(TJ|Tj)/g + for (const treffer of strom.matchAll(muster)) { + const block = treffer[1] + const stuecke: string[] = [] + for (const s of block.matchAll(/\(((?:[^\\()]|\\.)*)\)/g)) { + stuecke.push( + s[1] + .replace(/\\([nrtbf])/g, (_, c: string) => + ({ n: '\n', r: '\n', t: ' ', b: '', f: '\n' }[c] ?? '')) + .replace(/\\(\d{1,3})/g, (_, o: string) => String.fromCharCode(parseInt(o, 8))) + .replace(/\\(.)/g, '$1'), + ) + } + const zeile = stuecke.join('').trim() + if (zeile) zeilen.push(zeile) + } + + return zeilen.join('\n') +} + +async function ausPdf(bytes: Uint8Array): Promise { + // Die Datei als Latin-1 lesen: So bleibt jedes Byte ein Zeichen, und die + // Byte-Offsets der Ströme stimmen mit den Zeichen-Offsets überein. + const roh = new TextDecoder('latin1').decode(bytes) + const teile: string[] = [] + + const streamMuster = /stream\r?\n?/g + let m: RegExpExecArray | null + while ((m = streamMuster.exec(roh)) !== null) { + const start = m.index + m[0].length + const ende = roh.indexOf('endstream', start) + if (ende === -1) break + streamMuster.lastIndex = ende + + const inhalt = roh.slice(start, ende) + // Vor dem Strom steht das Objektwörterbuch — es sagt, ob gepackt wurde. + const kopf = roh.slice(Math.max(0, m.index - 400), m.index) + + let text: string + if (/FlateDecode/.test(kopf)) { + try { + const gepackt = Uint8Array.from(inhalt, c => c.charCodeAt(0) & 0xff) + text = new TextDecoder('latin1').decode(await inflate(gepackt, 'deflate')) + } catch { + // Bilder und Schriftdateien sind ebenfalls Flate-Ströme und scheitern + // hier reihenweise — das ist kein Fehler, sondern der Normalfall. + continue + } + } else if (/Image|Font|XObject/.test(kopf)) { + continue + } else { + text = inhalt + } + + const gefunden = pdfTextAusStrom(text) + if (gefunden) teile.push(gefunden) + } + + const text = normalisiere(teile.join('\n')) + if (text.length < RESEARCH_DOCUMENT_MIN_CHARS) { + return { + text, + note: + 'Aus diesem PDF liess sich kein zusammenhängender Text gewinnen — vermutlich ein Scan ohne Textebene. ' + + 'Das Dokument fliesst deshalb nicht in die Recherche ein.', + } + } + return { text } +} + +// ── Einstieg ────────────────────────────────────────────────────────────────── + +export function kindOf(fileName: string): ResearchDocumentKind | null { + const lower = fileName.toLowerCase() + if (lower.endsWith('.pdf')) return ResearchDocumentKind.PDF + if (lower.endsWith('.docx')) return ResearchDocumentKind.DOCX + return null +} + +export async function extractDocumentText( + file: File, + kind: ResearchDocumentKind, +): Promise { + const bytes = new Uint8Array(await file.arrayBuffer()) + try { + const ergebnis = kind === ResearchDocumentKind.PDF + ? await ausPdf(bytes) + : await ausDocx(bytes) + + if (!ergebnis.note && ergebnis.text.length < RESEARCH_DOCUMENT_MIN_CHARS) { + return { + text: ergebnis.text, + note: 'Das Dokument enthält zu wenig Text, um daraus einen Lead abzuleiten.', + } + } + return ergebnis + } catch (err) { + return { + text: '', + note: `Die Datei liess sich nicht lesen: ${err instanceof Error ? err.message : 'unbekannter Fehler'}.`, + } + } +} diff --git a/src/lib/researchLeadMapper.ts b/src/lib/researchLeadMapper.ts new file mode 100644 index 0000000..02f661b --- /dev/null +++ b/src/lib/researchLeadMapper.ts @@ -0,0 +1,140 @@ +/** + * Property On — aus einem Recherche-Lead wird ein Signal im zentralen Bestand + * (Runde 10, §2.12). + * + * Bis Runde 9 standen die frisch gelesenen Leads in einer eigenen Liste neben + * den erfassten. Das war zwar ehrlich — live gelesen ist etwas anderes als + * redaktionell erfasst —, aber es hatte einen Preis: Nora konnte mit ihnen + * nichts anfangen, die Filter griffen nicht, und derselbe Sachverhalt sah je + * nach Liste anders aus. + * + * Seit Runde 10 gibt es deshalb genau einen Leadbestand. Die Herkunft geht + * dabei nicht verloren, sie steht am Signal (`origin: 'RESEARCH_RUN'`) — + * unterschieden wird über ein Feld, nicht über eine zweite Ablage. + */ + +import { RiskLevel, SignalType } from '../domain/enums' +import { LeadSignalType } from '../domain/futureSignal' +import type { FutureSignal } from '../domain/futureSignal' +import { ResearchEventType } from '../domain/researchLead' +import type { ResearchLead, ResearchRelevance } from '../domain/researchLead' + +/** + * Welcher Signaltyp zu welchem Ereignis gehört. + * + * Die Recherche kennt neun Ereignisarten, der Bestand sieben Signaltypen — + * die Zuordnung ist deshalb nicht eins zu eins und steht hier explizit, statt + * irgendwo geraten zu werden. + */ +const SIGNAL_TYPE_BY_EVENT: Record = { + [ResearchEventType.EXPANSION]: SignalType.EXPANSION, + [ResearchEventType.NEW_LOCATION]: SignalType.EXPANSION, + [ResearchEventType.HEADCOUNT_GROWTH]: SignalType.EXPANSION, + [ResearchEventType.INVESTMENT]: SignalType.PROJECT_DEVELOPMENT, + [ResearchEventType.NEW_COMPANY]: SignalType.EXPANSION, + [ResearchEventType.M_AND_A]: SignalType.SPACE_CONSOLIDATION, + [ResearchEventType.RESTRUCTURING]: SignalType.RESTRUCTURING, + [ResearchEventType.SITE_CLOSURE]: SignalType.POSSIBLE_MOVE_OUT, + // Irrelevantes wird nie zum Lead; der Eintrag hält die Abbildung vollständig. + [ResearchEventType.IRRELEVANT]: SignalType.EXPANSION, +} + +/** Ereignisse, aus denen Flächenbedarf entsteht — alles andere betrifft Bestehendes. */ +const CHANCE_EVENTS = new Set([ + ResearchEventType.EXPANSION, + ResearchEventType.NEW_LOCATION, + ResearchEventType.HEADCOUNT_GROWTH, + ResearchEventType.INVESTMENT, + ResearchEventType.NEW_COMPANY, +]) + +/** + * Zeithorizont in Monaten aus der Ereigniszeit. + * + * Bewusst grob und bewusst nicht aus dem Publikationsdatum gerechnet: Der + * Horizont ist eine Anzeigegrösse der Liste, die belastbare Aussage steht in + * `temporalClass` und `temporalEvidence`. Eine Nachkommastelle würde hier eine + * Genauigkeit vortäuschen, die die Quelle nicht hergibt. + */ +const HORIZON_MONTHS: Record = { + past: 0, + current: 2, + future: 9, + unknown: 6, +} + +const RELEVANCE_SCORE: Record = { + high: 85, + medium: 65, + low: 40, +} + +/** + * Eine stabile Kennung für denselben Sachverhalt. + * + * Sie muss über Läufe hinweg gleich bleiben: Wer zweimal auf «Research + * aktualisieren» drückt, soll denselben Artikel nicht zweimal in der Liste + * finden. Grundlage sind Quelladresse und Überschrift — beides ändert sich + * nicht, solange es derselbe Artikel ist. + */ +export function researchLeadId(lead: ResearchLead): string { + const roh = `${lead.sourceUrl}|${lead.headline}` + let hash = 0 + for (let i = 0; i < roh.length; i++) { + hash = (hash * 31 + roh.charCodeAt(i)) | 0 + } + return `research-${(hash >>> 0).toString(36)}` +} + +export function researchLeadToSignal(lead: ResearchLead, laufZeitpunkt: string): FutureSignal { + const istChance = CHANCE_EVENTS.has(lead.eventType) + const relevanz = RELEVANCE_SCORE[lead.relevance] + + return { + id: researchLeadId(lead), + signalType: SIGNAL_TYPE_BY_EVENT[lead.eventType], + companyName: lead.company, + locationHint: lead.location ?? 'Ort nicht genannt', + probability: lead.confidence, + confidenceScore: lead.confidence, + timeHorizonMonths: HORIZON_MONTHS[lead.temporalClass] ?? 6, + + source: { + type: 'PRESS', + url: lead.sourceUrl, + publishedAt: lead.publishedAt, + // Eine namentlich genannte, direkt verlinkte Quelle ist belastbar; die + // Unsicherheit der Einordnung steckt in `confidenceScore`, nicht hier. + credibility: 'HIGH', + }, + sensitivityLevel: 'PUBLIC', + disclaimer: + 'Aus einer öffentlich zugänglichen Quelle abgeleitet. Vor jeder Ansprache am Original prüfen.', + riskLevel: istChance ? RiskLevel.LOW : RiskLevel.MEDIUM, + relevanceScore: relevanz, + isVerified: false, + createdAt: laufZeitpunkt, + updatedAt: laufZeitpunkt, + + title: lead.headline, + aiSummary: lead.summary, + evidence: { + summary: lead.summary, + sourceUrls: [lead.sourceUrl], + extractedAt: laufZeitpunkt, + }, + + // Chance-Leads zeigen in die Nachfragerichtung — nur so nimmt die + // gemeinsame Leadliste sie auf. Risiken kommen über `leadSignalType` hinein. + signalDirection: istChance ? 'DEMAND' : 'SUPPLY', + leadSignalType: istChance ? LeadSignalType.CHANCE : LeadSignalType.RISIKO, + signalRationale: lead.reason, + recommendedAction: lead.recommendedAction, + + temporalClass: lead.temporalClass, + temporalEvidence: lead.temporalEvidence || undefined, + eventDate: lead.eventDate, + semanticSearchProfile: lead.semanticSearchProfile, + origin: 'RESEARCH_RUN', + } +} diff --git a/src/lib/temporalFilter.ts b/src/lib/temporalFilter.ts new file mode 100644 index 0000000..ca98756 --- /dev/null +++ b/src/lib/temporalFilter.ts @@ -0,0 +1,28 @@ +/** + * Property On — der harte Zeitfilter (Runde 10, §2.9). + * + * Die Regel steht hier und nicht nur in der serverlosen Funktion, weil sie an + * zwei Stellen gilt: Der Lauf wendet sie an, damit unpassende Leads gar nicht + * erst entstehen, und die Anzeige wendet sie auf den bereits erfassten Bestand + * an. Zwei Fassungen derselben Regel wären zwei unterschiedliche Antworten auf + * dieselbe Frage. + * + * Zur Deutung von `unknown`: Ein Lead ohne belastbare zeitliche Aussage fällt + * **nicht** durch. Das ist eine bewusste Entscheidung — die Alternative wäre, + * ihn anhand des Publikationsdatums einzusortieren, und genau das ist der + * Fehler, den dieser Filter verhindern soll. Sichtbar bleibt er mit dem + * Vermerk, dass seine Ereigniszeit offen ist. + */ + +import type { TemporalClass } from '../domain/researchLead' + +export function passtZeitlich( + klasse: TemporalClass | undefined, + erlaubt: TemporalClass[], +): boolean { + // Keine Auswahl heisst keine Einschränkung — nicht «nichts anzeigen». + if (erlaubt.length === 0) return true + // Ein Bestandssignal ohne Einordnung verhält sich wie «unknown». + if (klasse === undefined || klasse === 'unknown') return true + return erlaubt.includes(klasse) +} diff --git a/src/mock-data/agents/livia.ts b/src/mock-data/agents/livia.ts index 9d34b85..cc477e4 100644 --- a/src/mock-data/agents/livia.ts +++ b/src/mock-data/agents/livia.ts @@ -24,6 +24,7 @@ import { AgentSettingGroup, AgentAvatarTone, } from '../../domain/teamAgent' +import { RESEARCH_SOURCES } from '../../lib/researchSources' export const liviaAgent: TeamAgent = { id: 'livia', @@ -90,36 +91,6 @@ export const liviaAgent: TeamAgent = { requiresApproval: false, dependsOnSystem: AgentSystemType.PUBLIC_WEB, }, - { - id: 'livia-task-02', - title: 'Geschäfts- und Jahresberichte auswerten', - description: - 'Liest publizierte Geschäfts- und Jahresberichte auf Aussagen zu Standorten, Kapazitäten, Investitionen und Personalbestand. Zahlen werden mit Berichtsjahr und Fundstelle übernommen, nicht als Trend interpretiert.', - enabled: true, - schedule: 'wöchentlich, montags 06:30', - requiresApproval: false, - dependsOnSystem: AgentSystemType.PUBLIC_WEB, - }, - { - id: 'livia-task-03', - title: 'Handelsregister- und Unternehmensinformationen verfolgen', - description: - 'Verfolgt Mutationen im Handelsregister: Neugründungen, Sitzverlegungen, Zweckänderungen, Fusionen und Liquidationen. Eine Sitzverlegung ist der belastbarste Hinweis auf einen Standortwechsel, den es öffentlich gibt.', - enabled: true, - schedule: 'täglich 06:15', - requiresApproval: false, - dependsOnSystem: AgentSystemType.ZEFIX, - }, - { - id: 'livia-task-04', - title: 'Amtliche Publikationen sichten', - description: - 'Sichtet amtliche Publikationen zu Baugesuchen, Zonenänderungen und Arealentwicklungen und prüft, ob ein Unternehmen aus dem Beobachtungsbereich betroffen ist.', - enabled: true, - schedule: 'täglich 06:20', - requiresApproval: false, - dependsOnSystem: AgentSystemType.SHAB, - }, { id: 'livia-task-05', title: 'Wachstumssignale erkennen', @@ -129,15 +100,6 @@ export const liviaAgent: TeamAgent = { schedule: 'im Anschluss an jeden Quellenlauf', requiresApproval: false, }, - { - id: 'livia-task-06', - title: 'Negative Entwicklungen erkennen', - description: - 'Erkennt M&A-Aktivitäten, Restrukturierungen, Standortschliessungen und die Einstellung von Geschäftstätigkeiten. Diese Signale sind die wertvollsten, weil sie bestehende Mietverhältnisse betreffen und Vorlauf verschaffen.', - enabled: true, - schedule: 'im Anschluss an jeden Quellenlauf', - requiresApproval: false, - }, { id: 'livia-task-07', title: 'Lead als Chance oder Risiko einordnen', @@ -184,6 +146,16 @@ export const liviaAgent: TeamAgent = { requiresApproval: false, dependsOnChannel: AgentChannelType.WORKSPACE_CHAT, }, + { + id: 'livia-task-14', + title: 'Unsichere Signale in Review Queue legen', + description: + 'Liegt die Konfidenz unter der eingestellten Schwelle oder widersprechen sich die Quellen, legt Livia den Lead in die Review-Queue der Marktbeobachtung. Solche Leads erscheinen nicht in der Lead-Liste, bevor jemand sie geprüft hat. Die Aufgabe gehörte bis Runde 10 zu Nora — sie beurteilt die Quellenlage, und die kennt Livia, nicht das Matching.', + enabled: true, + schedule: 'sobald die Konfidenz unter der Review-Schwelle liegt', + requiresApproval: false, + dependsOnSystem: AgentSystemType.WORKSPACE, + }, { id: 'livia-task-12', title: 'Doppelmeldungen unterdrücken', @@ -193,16 +165,6 @@ export const liviaAgent: TeamAgent = { schedule: 'vor jeder Übergabe', requiresApproval: false, }, - { - id: 'livia-task-13', - title: 'Wochenüberblick zustellen', - description: - 'Stellt der Bewirtschaftung montags einen Überblick der Leads der Vorwoche zu, getrennt nach Chance und Risiko, mit den jeweils empfohlenen Handlungen.', - enabled: true, - schedule: 'montags 07:00', - requiresApproval: false, - dependsOnChannel: AgentChannelType.EMAIL, - }, ], channels: [ @@ -239,13 +201,33 @@ export const liviaAgent: TeamAgent = { ], systems: [ + /* + * Die drei realen Quellen stehen seit Runde 10 (§2.3) einzeln hier statt + * gesammelt hinter einem Eintrag «Öffentliche Webquellen». Der Grund ist + * nicht Kosmetik: Der Recherchelauf liest genau diese Liste. Was hier als + * aktiver Lesezugang mit Adresse steht, wird abgerufen — und nur das. + * Ein Sammeleintrag ohne eigene Adresse wäre eine Statusanzeige ohne + * Deckung im Datenmodell. + */ { - id: 'livia-sys-public-web', + id: 'livia-sys-zhk', type: AgentSystemType.PUBLIC_WEB, access: AgentAccessLevel.READ, status: AgentConnectionStatus.CONNECTED, - usage: - 'Verknüpfte Newsseiten und Wirtschaftsnachrichten, Geschäfts- und Jahresberichte, Mitteilungen von Handelskammern und Branchenverbänden sowie Unternehmensmeldungen. Die konkreten Adressen stehen in der Einstellung «Verknüpfte Newsquellen».', + title: RESEARCH_SOURCES.ZHK.name, + url: RESEARCH_SOURCES.ZHK.url, + usage: RESEARCH_SOURCES.ZHK.purpose, + permissionNote: + 'Nur lesend. Livia ruft ausschliesslich frei zugängliche Seiten ab und meldet sich nirgends an.', + }, + { + id: 'livia-sys-gza', + type: AgentSystemType.PUBLIC_WEB, + access: AgentAccessLevel.READ, + status: AgentConnectionStatus.CONNECTED, + title: RESEARCH_SOURCES.GZA.name, + url: RESEARCH_SOURCES.GZA.url, + usage: RESEARCH_SOURCES.GZA.purpose, permissionNote: 'Nur lesend. Livia ruft ausschliesslich frei zugängliche Seiten ab und meldet sich nirgends an.', }, @@ -254,19 +236,11 @@ export const liviaAgent: TeamAgent = { type: AgentSystemType.ZEFIX, access: AgentAccessLevel.READ, status: AgentConnectionStatus.CONNECTED, - usage: - 'Handelsregister- und Unternehmensinformationen: Neugründungen, Sitzverlegungen, Zweckänderungen, Fusionen und Liquidationen.', + title: RESEARCH_SOURCES.ZEFIX.name, + url: RESEARCH_SOURCES.ZEFIX.url, + usage: RESEARCH_SOURCES.ZEFIX.purpose, permissionNote: 'Nur lesend. Einträge werden als Quelle mit Publikationsdatum übernommen.', }, - { - id: 'livia-sys-shab', - type: AgentSystemType.SHAB, - access: AgentAccessLevel.READ, - status: AgentConnectionStatus.CONNECTED, - usage: - 'Amtliche Publikationen zu Baugesuchen, Zonenänderungen, Arealentwicklungen und Firmenmutationen.', - permissionNote: 'Nur lesend. Meldungen werden als Quelle mit Publikationsdatum übernommen.', - }, { id: 'livia-sys-immotop2', type: AgentSystemType.IMMOTOP2, @@ -301,35 +275,21 @@ export const liviaAgent: TeamAgent = { settings: [ { - id: 'livia-set-news-sources', - label: 'Verknüpfte Newsquellen', + id: 'livia-set-news-documents', + label: 'Newsquellen manuell ablegen', description: - 'Newsseiten und Portale, die Livia täglich abgeht. Weitere Adressen lassen sich hier ergänzen — es braucht keine zweite Quellenverwaltung.', - kind: AgentSettingKind.MULTI_SELECT, + 'Geschäftsberichte, Rundschreiben und andere Unterlagen als PDF oder Word. Ihr Text geht zusammen mit den aktiven Lesequellen aus «Systeme» in denselben Recherchelauf. Die Datei bleibt im Browser — an die Beurteilung geht nur ihr Text.', + kind: AgentSettingKind.DOCUMENTS, group: AgentSettingGroup.SPECIFIC, - value: [ - 'https://www.handelszeitung.ch', - 'https://www.nzz.ch/wirtschaft', - 'https://www.finanzundwirtschaft.ch', - 'https://www.shab.ch', - ], - options: [ - { value: 'https://www.handelszeitung.ch', label: 'Handelszeitung' }, - { value: 'https://www.nzz.ch/wirtschaft', label: 'NZZ Wirtschaft' }, - { value: 'https://www.finanzundwirtschaft.ch', label: 'Finanz und Wirtschaft' }, - { value: 'https://www.shab.ch', label: 'SHAB — Amtliche Publikationen' }, - { value: 'https://www.zefix.ch', label: 'Zefix — Handelsregister' }, - { value: 'https://www.cash.ch/news', label: 'cash — Unternehmensnachrichten' }, - { value: 'https://www.zhk.ch', label: 'Zürcher Handelskammer' }, - { value: 'https://www.hkbb.ch', label: 'Handelskammer beider Basel' }, - { value: 'https://www.moneyhouse.ch', label: 'Moneyhouse — Unternehmensdaten' }, - ], + value: [], }, { id: 'livia-set-source-types', label: 'Relevante Quellentypen', - description: 'Welche Arten von Quellen Livia für die Leaderzeugung heranzieht.', - kind: AgentSettingKind.MULTI_SELECT, + description: + 'Welche Arten von Quellen Livia für die Leaderzeugung heranzieht. Eigene Typen lassen sich frei erfassen.', + kind: AgentSettingKind.CHIPS, + allowCustom: true, group: AgentSettingGroup.SPECIFIC, value: [ 'geschaeftsberichte', @@ -393,8 +353,10 @@ export const liviaAgent: TeamAgent = { { id: 'livia-set-observation-area', label: 'Beobachtungsraum', - description: 'Wirtschaftsräume, für die Livia Meldungen als relevant einstuft.', - kind: AgentSettingKind.MULTI_SELECT, + description: + 'Wirtschaftsräume, für die Livia Meldungen als relevant einstuft. Eigene Räume lassen sich frei erfassen.', + kind: AgentSettingKind.CHIPS, + allowCustom: true, group: AgentSettingGroup.SPECIFIC, value: ['zuerich', 'basel', 'zentralschweiz', 'ostschweiz', 'bern'], options: [ @@ -407,6 +369,36 @@ export const liviaAgent: TeamAgent = { { value: 'tessin', label: 'Tessin' }, ], }, + { + /* + * Der harte Zeitfilter (Runde 10, §2.9). + * + * Er steht bewusst zwischen Beobachtungsraum und Mindestrelevanz: Beide + * schränken ein, aber unterschiedlich. Der Raum sagt «wo», dieser Filter + * «wann» — und die Relevanz danach «wie stark». Alle drei aktiv zu + * lassen ist die Vorgabe, damit ein bestehender Demo-Stand nicht + * unbemerkt Ergebnisse verliert. + */ + id: 'livia-set-temporal-relevance', + label: 'Zeitliche Relevanz', + description: + 'Welche Ereigniszeiten ein Lead haben darf. Massgeblich ist, wann die beschriebene Veränderung stattfindet — nicht, wann der Artikel erschienen ist.', + kind: AgentSettingKind.CHIPS, + allowCustom: false, + group: AgentSettingGroup.SPECIFIC, + value: ['past', 'current', 'future'], + options: [ + { value: 'past', label: 'Vergangene Leads' }, + { value: 'current', label: 'Aktuelle Leads' }, + { value: 'future', label: 'Zukünftige Leads' }, + ], + infoText: + 'Vergangen: Die Veränderung ist abgeschlossen — das Unternehmen ist umgezogen, der Standort eröffnet oder geschlossen. ' + + 'Aktuell: Sie läuft gerade oder steht innerhalb von acht Wochen bevor. ' + + 'Zukünftig: Sie liegt weiter voraus oder wurde ohne kurzfristige Umsetzung angekündigt. ' + + 'Massgeblich ist immer die Ereigniszeit, nie das Publikationsdatum: Ein Jahresbericht vom Januar kann einen Standort für das dritte Quartal ankündigen — das ist ein zukünftiger Lead. ' + + 'Lässt eine Quelle keine belastbare zeitliche Aussage zu, wird kein Datum erfunden; der Lead erscheint mit dem Vermerk, dass die Ereigniszeit offen ist.', + }, { id: 'livia-set-min-relevance', label: 'Mindestrelevanz für einen Lead', @@ -418,6 +410,13 @@ export const liviaAgent: TeamAgent = { unit: '%', min: 0, max: 100, + infoText: + 'Die KI bewertet, wie stark der Inhalt auf eine für Property Match relevante räumliche oder geschäftliche Veränderung hinweist. ' + + 'Berücksichtigt werden insbesondere die Eindeutigkeit des Signals, der Bezug zu Standort beziehungsweise Flächenbedarf, ' + + 'die Passung zum definierten Beobachtungsraum und den Quellentypen sowie die Qualität und Konkretheit der verfügbaren Informationen. ' + + 'Die zeitliche Relevanz wird separat als harter Filter angewendet und verändert den Relevanzwert nicht. ' + + 'Im aktuellen Stand vergibt die Beurteilung drei Stufen — hoch, mittel und tief. Leads der tiefen Stufe erscheinen nicht in der Liste, ' + + 'sondern zählen als Beobachtungsposten. Eine Gewichtung einzelner Kriterien in Prozent gibt es nicht.', }, { id: 'livia-set-tonality', diff --git a/src/mock-data/agents/nora.ts b/src/mock-data/agents/nora.ts index 22e47ca..7d6c562 100644 --- a/src/mock-data/agents/nora.ts +++ b/src/mock-data/agents/nora.ts @@ -101,16 +101,6 @@ export const noraAgent: TeamAgent = { schedule: 'bei jeder Klassifizierung', requiresApproval: false, }, - { - id: 'nora-task-04', - title: 'unsichere Signale in eine Review-Queue legen', - description: - 'Liegt die Konfidenz unter der eingestellten Review-Schwelle oder widersprechen sich die Quellen, legt Nora das Signal in die Review-Queue der Marktbeobachtung. Solche Signale erscheinen weder in der Wochen-Mail noch in der Lead-Liste, bevor jemand sie geprüft hat.', - enabled: true, - schedule: 'sobald die Konfidenz unter der Review-Schwelle liegt', - requiresApproval: false, - dependsOnSystem: AgentSystemType.WORKSPACE, - }, { id: 'nora-task-05', title: 'Signale Regionen und Objekten zuordnen', diff --git a/src/provider/IFutureSignalProvider.ts b/src/provider/IFutureSignalProvider.ts index 57a8c31..9d2f7bc 100644 --- a/src/provider/IFutureSignalProvider.ts +++ b/src/provider/IFutureSignalProvider.ts @@ -17,4 +17,9 @@ export interface IFutureSignalProvider { getByProperty(propertyId: string): Promise verify(id: string, verifiedBy: string): Promise updateReviewStatus(id: string, status: ReviewStatus): Promise + /** + * Leads eines Recherchelaufs in den Bestand aufnehmen (Runde 10, §2.12). + * Gibt zurück, wie viele erzeugte Leads danach insgesamt geführt werden. + */ + addResearchSignals(signals: FutureSignal[]): Promise } diff --git a/src/provider/IResearchDocumentProvider.ts b/src/provider/IResearchDocumentProvider.ts new file mode 100644 index 0000000..ae68826 --- /dev/null +++ b/src/provider/IResearchDocumentProvider.ts @@ -0,0 +1,18 @@ +import type { ResearchDocument } from '../domain/researchDocument' + +/** + * Ablage der manuell hinterlegten Newsquellen (Runde 10, §2.6). + * + * Eine eigene Schnittstelle, obwohl die übrigen Demo-Bestände im Local Storage + * liegen: Dokumente sind um Grössenordnungen grösser als eine Konfiguration, + * und der Local Storage ist bei rund fünf Megabyte zu Ende. Eine PDF-Ablage + * dort hinein zu zwingen hiesse, beim dritten Dokument stillschweigend nichts + * mehr zu speichern. + */ +export interface IResearchDocumentProvider { + getAll(): Promise + add(doc: ResearchDocument, blob: Blob): Promise + remove(id: string): Promise + /** Die Originaldatei — für das Herunterladen aus der Liste. */ + getBlob(id: string): Promise +} diff --git a/src/provider/IndexedDbResearchDocumentProvider.ts b/src/provider/IndexedDbResearchDocumentProvider.ts new file mode 100644 index 0000000..894966d --- /dev/null +++ b/src/provider/IndexedDbResearchDocumentProvider.ts @@ -0,0 +1,80 @@ +/** + * Property On — die abgelegten Dokumente liegen in IndexedDB (Runde 10, §2.6). + * + * Keine Mockup-Variante und kein zweiter Backend-Dienst: Die Anwendung läuft + * im Browser, und der Browser hat eine Ablage, die auch Dateien verträgt. Ein + * Server nur für die Dateihaltung wäre Infrastruktur für einen einzigen Zweck. + * + * Aufgeteilt in zwei Speicher: die Metadaten samt extrahiertem Text in `meta`, + * die Originaldatei in `blobs`. So kann die Liste aufgebaut werden, ohne dass + * zwanzig Megabyte PDF durch den Speicher wandern — gebraucht wird die Datei + * erst, wenn jemand sie herunterlädt. + */ + +import type { IResearchDocumentProvider } from './IResearchDocumentProvider' +import type { ResearchDocument } from '../domain/researchDocument' + +const DB_NAME = 'property-on' +const DB_VERSION = 1 +const STORE_META = 'research-document-meta' +const STORE_BLOBS = 'research-document-blobs' + +function openDb(): Promise { + return new Promise((resolve, reject) => { + const req = indexedDB.open(DB_NAME, DB_VERSION) + req.onupgradeneeded = () => { + const db = req.result + if (!db.objectStoreNames.contains(STORE_META)) db.createObjectStore(STORE_META, { keyPath: 'id' }) + if (!db.objectStoreNames.contains(STORE_BLOBS)) db.createObjectStore(STORE_BLOBS) + } + req.onsuccess = () => resolve(req.result) + req.onerror = () => reject(req.error ?? new Error('IndexedDB liess sich nicht öffnen.')) + }) +} + +/** Eine Transaktion als Versprechen — IndexedDB spricht sonst nur in Ereignissen. */ +function alsVersprechen( + req: IDBRequest, + tx: IDBTransaction, +): Promise { + return new Promise((resolve, reject) => { + req.onsuccess = () => resolve(req.result) + req.onerror = () => reject(req.error ?? new Error('Zugriff auf die Dokumentenablage fehlgeschlagen.')) + tx.onabort = () => reject(tx.error ?? new Error('Die Dokumentenablage brach die Transaktion ab.')) + }) +} + +export const IndexedDbResearchDocumentProvider: IResearchDocumentProvider = { + async getAll() { + const db = await openDb() + const tx = db.transaction(STORE_META, 'readonly') + const alle = await alsVersprechen(tx.objectStore(STORE_META).getAll() as IDBRequest, tx) + db.close() + // Neuestes zuerst — wer eben etwas abgelegt hat, sucht es oben. + return alle.sort((a, b) => b.uploadedAt.localeCompare(a.uploadedAt)) + }, + + async add(doc, blob) { + const db = await openDb() + const tx = db.transaction([STORE_META, STORE_BLOBS], 'readwrite') + tx.objectStore(STORE_META).put(doc) + await alsVersprechen(tx.objectStore(STORE_BLOBS).put(blob, doc.id), tx) + db.close() + }, + + async remove(id) { + const db = await openDb() + const tx = db.transaction([STORE_META, STORE_BLOBS], 'readwrite') + tx.objectStore(STORE_META).delete(id) + await alsVersprechen(tx.objectStore(STORE_BLOBS).delete(id), tx) + db.close() + }, + + async getBlob(id) { + const db = await openDb() + const tx = db.transaction(STORE_BLOBS, 'readonly') + const blob = await alsVersprechen(tx.objectStore(STORE_BLOBS).get(id) as IDBRequest, tx) + db.close() + return blob ?? null + }, +} diff --git a/src/provider/MockupFutureSignalProvider.ts b/src/provider/MockupFutureSignalProvider.ts index 9815d67..a7c1dcb 100644 --- a/src/provider/MockupFutureSignalProvider.ts +++ b/src/provider/MockupFutureSignalProvider.ts @@ -2,14 +2,27 @@ import type { IFutureSignalProvider, FutureSignalFilters } from './IFutureSignal import type { FutureSignal } from '../domain/futureSignal' import type { ReviewStatus } from '../domain/enums' import { mockFutureSignals } from '../mock-data/futureSignals' +import { TEAM_STORAGE_KEYS, loadVersioned, persistVersioned } from './teamPersistence' // Mutation overrides — applied on top of the live mockFutureSignals import. // Reading directly from mockFutureSignals (not a copied store) ensures that // Vite HMR changes to the mock data are always reflected immediately. const mutationOverrides = new Map>() +/** + * Leads aus Rechercheläufen (Runde 10, §2.12). + * + * Sie liegen in derselben Ablage wie der Seed und werden von `resolve()` in + * dieselbe Liste gegeben — es gibt bewusst keinen zweiten Bestand, den Nora + * separat abfragen müsste. Getrennt ist nur die Persistenz: der Seed steht im + * Code, die erzeugten Leads im Local Storage, damit ein Reload sie behält. + */ +let researchSignals: FutureSignal[] = + loadVersioned(TEAM_STORAGE_KEYS.RESEARCH_LEADS) ?? [] + function resolve(): FutureSignal[] { - return mockFutureSignals.map(s => { + // Erzeugte Leads zuerst: der jüngste Lauf steht oben, wo man ihn sucht. + return [...researchSignals, ...mockFutureSignals].map(s => { const override = mutationOverrides.get(s.id) return override ? { ...s, ...override } : s }) @@ -43,4 +56,20 @@ export const MockupFutureSignalProvider: IFutureSignalProvider = { mutationOverrides.set(id, { ...existing, reviewStatus: status, updatedAt: new Date().toISOString() }) return resolve().find(s => s.id === id)! }, + + /** + * Leads eines Recherchelaufs aufnehmen. + * + * Gleiche Kennung heisst gleicher Sachverhalt: Ein zweiter Lauf über + * denselben Artikel ersetzt den bestehenden Eintrag, statt ihn zu + * verdoppeln. Sonst wüchse die Liste bei jedem Knopfdruck um Dubletten, und + * niemand könnte mehr sagen, welcher Stand gilt. + */ + async addResearchSignals(signals: FutureSignal[]) { + const bekannt = new Map(researchSignals.map(s => [s.id, s])) + for (const s of signals) bekannt.set(s.id, s) + researchSignals = [...bekannt.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt)) + persistVersioned(TEAM_STORAGE_KEYS.RESEARCH_LEADS, researchSignals) + return researchSignals.length + }, } diff --git a/src/provider/teamPersistence.ts b/src/provider/teamPersistence.ts index 081b228..76cb72e 100644 --- a/src/provider/teamPersistence.ts +++ b/src/provider/teamPersistence.ts @@ -17,6 +17,10 @@ export const TEAM_STORAGE_KEYS = { WORK_ITEMS: `${PREFIX}work-items`, PROTOCOL: `${PREFIX}protocol`, CONNECTIONS: `${PREFIX}connections`, + /** Von einem Recherchelauf erzeugte Leads (Runde 10, §2.12). */ + RESEARCH_LEADS: `${PREFIX}research-leads`, + /** Manuell abgelegte Newsquellen als Dokumente (Runde 10, §2.6). */ + RESEARCH_DOCUMENTS: `${PREFIX}research-documents`, } as const export type TeamStorageKey = typeof TEAM_STORAGE_KEYS[keyof typeof TEAM_STORAGE_KEYS] @@ -51,7 +55,7 @@ export function persist(key: TeamStorageKey, value: T): void { * unter `src/domain/` ändert — sonst überlagert ein alter Local-Storage-Eintrag * die neuen Mockdaten und die Demo zeigt stillschweigend veraltete Inhalte. */ -export const TEAM_SCHEMA_VERSION = 1 +export const TEAM_SCHEMA_VERSION = 2 interface PersistedEnvelope { version: number diff --git a/src/services/futureSignalService.ts b/src/services/futureSignalService.ts index 03e85d7..792c12d 100644 --- a/src/services/futureSignalService.ts +++ b/src/services/futureSignalService.ts @@ -5,6 +5,8 @@ import type { ReviewStatus } from '../domain/enums' import type { FutureSignalSummary } from '../domain/dashboard' import type { ListResponse, ItemResponse } from './types' import { throwServiceError } from './errors' +import { researchLeadToSignal } from '../lib/researchLeadMapper' +import type { ResearchLead } from '../domain/researchLead' const provider = MockupFutureSignalProvider @@ -50,6 +52,28 @@ export const futureSignalService = { } }, + /** + * Die Leads eines Recherchelaufs in den zentralen Bestand übernehmen + * (Runde 10, §2.12). + * + * Die Umwandlung von Recherche-Lead zu Signal passiert bewusst hier und + * nicht in der Komponente: Sie ist fachliche Logik, und sie muss für jeden + * künftigen Auslöser eines Laufs — Knopfdruck, Zeitplan, Chat — dieselbe + * sein. + */ + async importResearchLeads( + leads: ResearchLead[], + refreshedAt: string, + ): Promise> { + try { + const signals = leads.map(l => researchLeadToSignal(l, refreshedAt)) + const total = await provider.addResearchSignals(signals) + return { data: { imported: signals.length, total } } + } catch (err) { + throwServiceError(err) + } + }, + async getSignalsForProperty(propertyId: string): Promise> { try { const data = await provider.getByProperty(propertyId) diff --git a/src/services/researchDocumentService.ts b/src/services/researchDocumentService.ts new file mode 100644 index 0000000..dfedd3b --- /dev/null +++ b/src/services/researchDocumentService.ts @@ -0,0 +1,65 @@ +/** + * Property On — manuell abgelegte Newsquellen (Runde 10, §2.6). + * + * Der Dienst nimmt die Datei entgegen, gewinnt einmal ihren Text und legt + * beides ab. Die Textextraktion gehört hierher und nicht in die Komponente: + * Sie ist fachliche Arbeit, und sie soll für jeden künftigen Weg ins System — + * Upload, Mailanhang, Ablageordner — dieselbe sein. + */ + +import { IndexedDbResearchDocumentProvider } from '../provider/IndexedDbResearchDocumentProvider' +import type { ResearchDocument } from '../domain/researchDocument' +import { RESEARCH_DOCUMENT_MAX_BYTES } from '../domain/researchDocument' +import { extractDocumentText, kindOf } from '../lib/documentText' +import type { ListResponse, ItemResponse } from './types' +import { throwServiceError } from './errors' + +const provider = IndexedDbResearchDocumentProvider + +export const researchDocumentService = { + async getAll(): Promise> { + try { + const data = await provider.getAll() + return { data, meta: { total: data.length, page: 1, pageSize: data.length, hasMore: false } } + } catch (err) { + throwServiceError(err) + } + }, + + async upload(file: File): Promise> { + const kind = kindOf(file.name) + if (!kind) { + throw new Error('Nur PDF- und Word-Dateien (.pdf, .docx) können abgelegt werden.') + } + if (file.size > RESEARCH_DOCUMENT_MAX_BYTES) { + throw new Error( + `Die Datei ist zu gross (${Math.round(file.size / 1024 / 1024)} MB). Höchstens ${RESEARCH_DOCUMENT_MAX_BYTES / 1024 / 1024} MB.`, + ) + } + + try { + const { text, note } = await extractDocumentText(file, kind) + const doc: ResearchDocument = { + id: `doc-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`, + name: file.name, + kind, + size: file.size, + uploadedAt: new Date().toISOString(), + text, + ...(note ? { extractionNote: note } : {}), + } + await provider.add(doc, file) + return { data: doc } + } catch (err) { + throwServiceError(err) + } + }, + + async remove(id: string): Promise { + try { + await provider.remove(id) + } catch (err) { + throwServiceError(err) + } + }, +}