GenAI Anbindung

This commit is contained in:
Lars committed 2026-07-07 11:14:00 +02:00
1 parent 9c68c414d8
commit 1a1f3bb33f
14 files changed
+719 -186

No files matched your search

+53 -1
View File
@@ -1,4 +1,4 @@
import type { FeedbackRating } from '../db'
import type { FeedbackRating } from '../db/types'
export const BRAND_COLOR = '#0070AD'
@@ -34,6 +34,58 @@ export const AI_CONFIG = {
localStorageKeyModel: 'ai_model',
defaultModel: 'openai/gpt-4o-mini',
openRouterBaseUrl: 'https://openrouter.ai/api/v1',
defaultDimensionPromptTemplate: `Du bist Führungskraft und Mentor bei Capgemini. Erstelle einen professionellen, konstruktiven Beitrag zum Performance-Feedback für einen Berater/Trainee, beschränkt auf die Dimension "{{DIMENSION_NAME}}", auf Basis der folgenden Beobachtungsdaten aus echten Kundenterminen.
BERATER: {{BERATER_NAME}}
ASSIGNMENT: {{ASSIGNMENT_TITEL}} | Kunde: {{ASSIGNMENT_KUNDE}}
FÜLLWÖRTER GESAMT: {{FUELLWOERTER_GESAMT}}
KATEGORIEN DIESER DIMENSION:
{{KATEGORIEN_STRUKTUR}}
BEOBACHTETE KRITERIEN UND SCORES (0-4):
{{KRITERIEN_SCORES}}
MANUELLE KATEGORIE-BEWERTUNGEN:
{{KATEGORIE_BEWERTUNGEN}}
ENTWICKLUNG ÜBER DIE LAUFZEIT (chronologisch je Kategorie):
{{ENTWICKLUNG_VERLAUF}}
ALLGEMEINE MEETING-NOTIZEN (Berater-unabhängig, chronologisch):
{{NOTIZEN_ALLGEMEIN_MEETING}}
NICHT EINEM KRITERIUM ZUGEORDNETE PROTOKOLL-NOTIZEN DIESES BERATERS (chronologisch, Notation: + gut, ! negativ, > Kundeninput):
{{PROTOKOLL_UNZUGEORDNET}}
Schreibe für JEDE der oben gelisteten Kategorien einen kurzen Bewertungstext (2-3 Sätze, konkret, auf Beobachtungen gestützt) sowie abschließend einen Achievements-Absatz (2-4 Sätze, anerkennend) und einen Development-Needs-Absatz (2-4 Sätze, konstruktiv, handlungsorientiert) für die gesamte Dimension. Falls eine Kategorie aus den Daten nicht beurteilbar ist, schreibe "n/a". Beziehe erkennbare Verbesserungen/Verschlechterungen aus der Entwicklung über die Laufzeit ein. Schreibe direkt und persönlich (du-Form), vermeide generische Phrasen.
Antworte AUSSCHLIESSLICH in exakt diesem Format, ohne zusätzliche Erklärungen, ohne Markdown-Formatierung:
KATEGORIE: <Name der ersten Kategorie>
<Bewertungstext>
KATEGORIE: <Name der zweiten Kategorie>
<Bewertungstext>
ACHIEVEMENTS:
<Text>
DEVELOPMENT_NEEDS:
<Text>`,
dimensionPromptPlaceholders: [
{ token: '{{BERATER_NAME}}', description: 'Vor- und Nachname des Institutee' },
{ token: '{{ASSIGNMENT_TITEL}}', description: 'Titel des Assignments' },
{ token: '{{ASSIGNMENT_KUNDE}}', description: 'Kundenname des Assignments' },
{ token: '{{DIMENSION_NAME}}', description: 'Name der aktuellen Dimension' },
{ token: '{{KATEGORIEN_STRUKTUR}}', description: 'Liste der Kategorienamen dieser Dimension' },
{ token: '{{KRITERIEN_SCORES}}', description: 'Kriterien mit Ø-Score und zusammengeführten Notizen, gruppiert nach Kategorie' },
{ token: '{{KATEGORIE_BEWERTUNGEN}}', description: 'Manuell gesetzte Kategorie-Bewertungen (Not/Partially/Nearly/Fully)' },
{ token: '{{ENTWICKLUNG_VERLAUF}}', description: 'Chronologischer Bewertungs-Trend je Kategorie über die Meetings' },
{ token: '{{NOTIZEN_ALLGEMEIN_MEETING}}', description: 'Allgemeine, Berater-unabhängige Notizen je Meeting, chronologisch' },
{ token: '{{PROTOKOLL_UNZUGEORDNET}}', description: 'Nicht getaggte Protokollzeilen dieses Beraters, chronologisch je Meeting' },
{ token: '{{FUELLWOERTER_GESAMT}}', description: 'Füllwörter-Summe dieses Beraters über alle Meetings' },
],
} as const
/** Numerische Gewichte für Rating-Aggregation. N/A wird aus Berechnungen ausgeschlossen. */
+15 -1
View File
@@ -1,5 +1,7 @@
import { rpc } from '../rpcClient'
import type { FeedbackDraft, AssignmentFeedback, FeedbackCategoryRating, FeedbackDimensionText } from '../types'
import type {
FeedbackDraft, AssignmentFeedback, FeedbackCategoryRating, FeedbackDimensionText, FeedbackCategoryText,
} from '../types'
export const getFeedbackDraft = (assignmentId: number, instituteeId: number): Promise<FeedbackDraft | undefined> =>
rpc('assignmentFeedback', 'getFeedbackDraft', assignmentId, instituteeId)
@@ -39,3 +41,15 @@ export const addFeedbackDimensionText = (t: Omit<FeedbackDimensionText, 'id'>):
rpc('assignmentFeedback', 'addFeedbackDimensionText', t)
export const updateFeedbackDimensionText = (id: number, patch: Partial<FeedbackDimensionText>): Promise<number> =>
rpc('assignmentFeedback', 'updateFeedbackDimensionText', id, patch)
export const listFeedbackCategoryTexts = (assignmentFeedbackId: number): Promise<FeedbackCategoryText[]> =>
rpc('assignmentFeedback', 'listFeedbackCategoryTexts', assignmentFeedbackId)
export const getFeedbackCategoryText = (
assignmentFeedbackId: number,
feedbackCategoryId: number,
): Promise<FeedbackCategoryText | undefined> =>
rpc('assignmentFeedback', 'getFeedbackCategoryText', assignmentFeedbackId, feedbackCategoryId)
export const addFeedbackCategoryText = (t: Omit<FeedbackCategoryText, 'id'>): Promise<number> =>
rpc('assignmentFeedback', 'addFeedbackCategoryText', t)
export const updateFeedbackCategoryText = (id: number, patch: Partial<FeedbackCategoryText>): Promise<number> =>
rpc('assignmentFeedback', 'updateFeedbackCategoryText', id, patch)
+9 -1
View File
@@ -1,5 +1,5 @@
import { rpc } from '../rpcClient'
import type { FeedbackDimension, FeedbackCategory, FeedbackCriterionItem } from '../types'
import type { FeedbackDimension, FeedbackCategory, FeedbackCriterionItem, FeedbackDimensionPrompt } from '../types'
export interface FeedbackStructure {
dimensions: FeedbackDimension[]
@@ -54,3 +54,11 @@ export const addFeedbackCriterionItem = (i: Omit<FeedbackCriterionItem, 'id'>):
export const updateFeedbackCriterionItem = (id: number, patch: Partial<FeedbackCriterionItem>): Promise<number> =>
rpc('feedbackStructure', 'updateFeedbackCriterionItem', id, patch)
export const deleteFeedbackCriterionItem = (id: number): Promise<void> => rpc('feedbackStructure', 'deleteFeedbackCriterionItem', id)
export const listFeedbackDimensionPrompts = (): Promise<FeedbackDimensionPrompt[]> =>
rpc('feedbackStructure', 'listFeedbackDimensionPrompts')
/** Selbstheilend — legt serverseitig bei Bedarf eine fehlende Prompt-Zeile mit Default-Template an. */
export const getFeedbackDimensionPrompt = (dimensionId: number): Promise<FeedbackDimensionPrompt> =>
rpc('feedbackStructure', 'getFeedbackDimensionPrompt', dimensionId)
export const updateFeedbackDimensionPrompt = (id: number, patch: Partial<FeedbackDimensionPrompt>): Promise<number> =>
rpc('feedbackStructure', 'updateFeedbackDimensionPrompt', id, patch)
+18
View File
@@ -190,6 +190,24 @@ export interface FeedbackDimensionText {
feedbackDimensionId: number
achievements: string
developmentNeeds: string
suggestedAchievements?: string
suggestedDevelopmentNeeds?: string
}
// ─── KI-Prompt-Konfiguration & Kategorie-Texte ────────────────────────────────
export interface FeedbackDimensionPrompt {
id?: number
dimensionId: number
promptTemplate: string
}
export interface FeedbackCategoryText {
id?: number
assignmentFeedbackId: number
feedbackCategoryId: number
text: string
suggestedText?: string
}
// ─── Legacy-Mappings ──────────────────────────────────────────────────────────
+116
View File
@@ -0,0 +1,116 @@
import { useEffect, useRef, useState } from 'react'
import {
type FeedbackDimension, type FeedbackDimensionPrompt,
loadFeedbackStructure, listFeedbackDimensionPrompts, updateFeedbackDimensionPrompt,
} from '../db'
import { AI_CONFIG } from '../config/constants'
export default function AiPromptConfig() {
const [dimensions, setDimensions] = useState<FeedbackDimension[]>([])
const [prompts, setPrompts] = useState<FeedbackDimensionPrompt[]>([])
const [expanded, setExpanded] = useState<Set<number>>(new Set())
const [savedDimId, setSavedDimId] = useState<number | null>(null)
const saveTimer = useRef<Map<number, ReturnType<typeof setTimeout>>>(new Map())
const load = async () => {
const [structure, promptRows] = await Promise.all([
loadFeedbackStructure(),
listFeedbackDimensionPrompts(),
])
setDimensions([...structure.dimensions].sort((a, b) => a.order - b.order))
setPrompts(promptRows)
}
useEffect(() => { load() }, [])
const getPrompt = (dimId: number) => prompts.find(p => p.dimensionId === dimId)
const saveTemplate = (dimId: number, value: string) => {
setPrompts(prev => prev.map(p => p.dimensionId === dimId ? { ...p, promptTemplate: value } : p))
const prevTimer = saveTimer.current.get(dimId)
if (prevTimer) clearTimeout(prevTimer)
saveTimer.current.set(dimId, setTimeout(async () => {
const existing = getPrompt(dimId)
if (!existing?.id) return
await updateFeedbackDimensionPrompt(existing.id, { promptTemplate: value })
setSavedDimId(dimId)
setTimeout(() => setSavedDimId(null), 2000)
}, 600))
}
const resetToDefault = async (dimId: number) => {
const existing = getPrompt(dimId)
if (!existing?.id) return
await updateFeedbackDimensionPrompt(existing.id, { promptTemplate: AI_CONFIG.defaultDimensionPromptTemplate })
setPrompts(prev => prev.map(p => p.dimensionId === dimId ? { ...p, promptTemplate: AI_CONFIG.defaultDimensionPromptTemplate } : p))
}
return (
<div className="space-y-4">
<div>
<h2 className="text-lg font-bold text-gray-800">KI-Prompts je Dimension</h2>
<p className="text-sm text-gray-500 mt-1">
Jede Dimension bekommt bei der KI-Feedback-Generierung einen eigenen, separaten Call. Der Prompt-Text
ist frei editierbar und wird bei neuen Dimensionen automatisch mit einem Standard-Prompt vorbelegt.
</p>
</div>
{/* Platzhalter-Legende */}
<div className="bg-gray-50 rounded-xl border border-gray-100 p-4 space-y-2">
<div className="text-xs font-semibold text-gray-500 uppercase tracking-wide">Verfügbare Platzhalter</div>
<div className="grid gap-1.5">
{AI_CONFIG.dimensionPromptPlaceholders.map(p => (
<div key={p.token} className="text-xs text-gray-600 flex gap-2">
<code className="bg-white border border-gray-200 rounded px-1.5 py-0.5 text-brand font-mono flex-shrink-0">{p.token}</code>
<span>{p.description}</span>
</div>
))}
</div>
</div>
{/* Dimensionen */}
{dimensions.map(dim => {
const isOpen = expanded.has(dim.id!)
const prompt = getPrompt(dim.id!)
return (
<div key={dim.id} className="bg-white rounded-xl border border-gray-100 shadow-sm overflow-hidden">
<button
onClick={() => setExpanded(prev => {
const next = new Set(prev)
if (next.has(dim.id!)) next.delete(dim.id!); else next.add(dim.id!)
return next
})}
className="w-full flex items-center justify-between p-3 bg-gray-50 border-b border-gray-100 text-left">
<span className="font-semibold text-sm text-gray-800">{dim.name}</span>
<span className="text-xs text-gray-400">{isOpen ? '▲' : '▼'}</span>
</button>
{isOpen && (
<div className="p-3 space-y-2">
<textarea
className="w-full border border-gray-200 rounded-lg px-3 py-2 text-xs font-mono focus:outline-none focus:border-brand min-h-[320px]"
value={prompt?.promptTemplate ?? ''}
onChange={e => saveTemplate(dim.id!, e.target.value)}
/>
<div className="flex items-center gap-2">
<button onClick={() => resetToDefault(dim.id!)}
className="text-xs bg-gray-100 hover:bg-gray-200 text-gray-600 px-3 py-1.5 rounded-lg font-medium">
Auf Standard zurücksetzen
</button>
{savedDimId === dim.id && (
<span className="text-xs text-green-600 font-medium">Gespeichert.</span>
)}
</div>
</div>
)}
</div>
)
})}
{dimensions.length === 0 && (
<div className="text-sm text-gray-400 text-center py-6">
Noch keine Dimensionen angelegt — siehe Tab „Feedback".
</div>
)}
</div>
)
}
+238 -175
View File
@@ -9,22 +9,25 @@ import {
type AssignmentFeedback,
type FeedbackCategoryRating,
type FeedbackDimensionText,
type FeedbackCategoryText,
type FeedbackRating,
type MeetingInstance,
type Assessment,
type ConversationEntry,
getAssignment, getConsultant,
loadFeedbackStructure,
listMeetingInstancesForAssignment, listDoneMeetingsChronological,
listDoneMeetingsChronological,
listAssessmentsForMeetings, listConversationEntriesForMeetings,
getRatingTrendWeightStep,
getOrCreateAssignmentFeedback, updateAssignmentFeedback,
listFeedbackCategoryRatings, addFeedbackCategoryRating, updateFeedbackCategoryRating,
listFeedbackDimensionTexts, getFeedbackDimensionText, addFeedbackDimensionText, updateFeedbackDimensionText,
listFeedbackCategoryTexts, getFeedbackCategoryText, addFeedbackCategoryText, updateFeedbackCategoryText,
getFeedbackDimensionPrompt,
} from '../db'
import { RATING_OPTIONS, RATING_NUM_MAP, AI_CONFIG } from '../config/constants'
import { RATING_OPTIONS, AI_CONFIG } from '../config/constants'
import { buildGroupMeetingScores, computeTrend, numberToRating, type TrendResult } from '../utils/ratingTrend'
import { splitNoteLines } from '../utils/notationParser'
const ratingToNum = (r: FeedbackRating | null | undefined): number =>
r ? (RATING_NUM_MAP[r] ?? 0) : 0
import { buildDimensionPromptContext, renderDimensionPrompt, parseDimensionAiResponse } from '../utils/aiPrompt'
const ratingColor = (r: FeedbackRating | undefined) =>
RATING_OPTIONS.find(x => x.value === r)?.color ?? 'bg-gray-50 text-gray-400 border-gray-200'
@@ -47,125 +50,24 @@ function saveAiSettings(apiKey: string, model: string) {
localStorage.setItem(AI_CONFIG.localStorageKeyModel, model)
}
// ── Prompt-Builder ────────────────────────────────────────────────────────────
async function buildAiPrompt(
institutee: Consultant,
assignment: Assignment,
dimensions: FeedbackDimension[],
categories: FeedbackCategory[],
items: FeedbackCriterionItem[],
ratings: FeedbackCategoryRating[],
catTrends: Map<number, TrendResult>,
): Promise<string> {
const meetings = await listMeetingInstancesForAssignment(assignment.id!)
const meetingIds = meetings.map(m => m.id!)
const [allAssessments, allEntries] = await Promise.all([
listAssessmentsForMeetings(meetingIds),
listConversationEntriesForMeetings(meetingIds),
])
const instAssessments = allAssessments.filter(a => a.instituteeId === institutee.id)
const instEntries = allEntries.filter(e => e.instituteeId === institutee.id)
const allLineTags = instEntries.flatMap(e => e.lineTags ?? [])
const critIds = [...new Set([
...instAssessments.map(a => a.criteriaId),
...allLineTags.map(t => t.criterionItemId),
])]
const crits = items.filter(i => critIds.includes(i.id!))
const scoreLines = crits.map(c => {
const scores = instAssessments.filter(a => a.criteriaId === c.id && a.score !== null && a.score !== 'na')
const avg = scores.length > 0
? (scores.reduce((s, a) => s + ratingToNum(a.score), 0) / scores.length).toFixed(1)
: '—'
const notes = [
...instAssessments.filter(a => a.criteriaId === c.id && a.note).map(a => a.note),
...allLineTags.filter(t => t.criterionItemId === c.id).map(t => t.text),
]
return ` ${c.name}: ${avg}/5${notes.length > 0 ? ` | Notizen: ${notes.join('; ')}` : ''}`
}).join('\n')
const fillerTotal = instEntries.reduce((s, e) => s + (e.fillerCount ?? 0), 0)
const protocolLines = instEntries
.flatMap(e => splitNoteLines(e.note).map(line => ({
line, tagged: (e.lineTags ?? []).some(t => t.text === line),
})))
.filter(x => !x.tagged)
.map(x => ` - ${x.line}`)
.join('\n')
// Kategorie-Ratings
const ratingLines = dimensions.map(dim => {
const dimCats = categories.filter(c => c.dimensionId === dim.id)
const lines = dimCats.map(cat => {
const r = ratings.find(r => r.feedbackCategoryId === cat.id)
const rating = RATING_OPTIONS.find(x => x.value === r?.rating)?.label ?? 'nicht bewertet'
return ` ${cat.name}: ${rating}`
}).join('\n')
return ` Dimension "${dim.name}":\n${lines}`
}).join('\n')
// Entwicklung über die Laufzeit (zeitgewichteter Trend pro Kategorie)
const trendLines = dimensions.map(dim => {
const dimCats = categories.filter(c => c.dimensionId === dim.id)
const lines = dimCats.map(cat => {
const t = catTrends.get(cat.id!)
if (!t || t.history.length === 0) return ` ${cat.name}: keine Verlaufsdaten`
const seq = t.history.map(h => h.score.toFixed(1)).join(' → ')
const trendLabel = t.trend === 'up' ? 'Verbesserung über die Laufzeit'
: t.trend === 'down' ? 'Verschlechterung über die Laufzeit'
: t.trend === 'stable' ? 'stabil'
: 'nur ein Meeting, kein Trend ableitbar'
return ` ${cat.name}: Verlauf ${seq} (${trendLabel})`
}).join('\n')
return ` Dimension "${dim.name}":\n${lines}`
}).join('\n')
// Feedback-Struktur für Output
const dimStructure = dimensions.map((dim, i) =>
`${i + 1}. ${dim.name}`
).join('\n')
return `Du bist Führungskraft und Mentor bei Capgemini. Erstelle ein professionelles, konstruktives Performance-Feedback für einen Berater/Trainee auf Basis der folgenden Beobachtungsdaten aus echten Kundenterminen.
BERATER: ${institutee.firstName} ${institutee.lastName}
ASSIGNMENT: ${assignment.title} | Kunde: ${assignment.client}
MEETINGS: ${meetings.length} Kundentermin(e)
FÜLLWÖRTER GESAMT: ${fillerTotal}
BEOBACHTETE KRITERIEN UND SCORES (1-5):
${scoreLines || '(keine Scores erfasst)'}
PROTOKOLL-NOTIZEN, KEINEM KRITERIUM ZUGEORDNET (Notation: + gut, ! negativ, > Kundeninput):
${protocolLines || '(keine nicht zugeordneten Protokolleinträge)'}
KATEGORIE-BEWERTUNGEN:
${ratingLines}
ENTWICKLUNG ÜBER DIE LAUFZEIT (chronologische Kategorie-Scores aus den Meetings, Skala 0-4):
${trendLines}
Generiere für jede der folgenden ${dimensions.length} Dimensionen je einen kurzen Absatz "Achievements" (2-4 Sätze, konkret, anerkennend) und "Development Needs" (2-4 Sätze, konstruktiv, handlungsorientiert). Falls eine Dimension aus den Daten nicht beurteilbar ist, schreibe "n/a". Erwähne eine erkennbare Verbesserung im Achievements-Absatz und eine erkennbare Verschlechterung im Development-Needs-Absatz der jeweiligen Dimension.
Ausgabe als JSON:
{
"dimensions": [
{
"name": "<Dimensionsname>",
"achievements": "<Text>",
"developmentNeeds": "<Text>"
}
]
}
DIMENSIONEN:
${dimStructure}
Wichtig: Beziehe dich auf konkrete Beobachtungen aus den Daten. Schreibe direkt und persönlich (du-Form). Vermeide generische Phrasen.`
/** Klein gehaltene KI-Vorschlag-Box mit Übernehmen/Verwerfen — gleiche Bedienlogik überall im Feedback. */
function AiSuggestionBox({ text, onAccept, onDiscard }: { text: string; onAccept: () => void; onDiscard: () => void }) {
return (
<div className="bg-blue-50 border border-blue-200 rounded-lg p-2.5 space-y-1.5">
<div className="text-xs font-semibold text-blue-700">✦ KI-Vorschlag</div>
<div className="text-sm text-blue-900 whitespace-pre-wrap">{text}</div>
<div className="flex gap-1.5">
<button onClick={onAccept}
className="text-xs bg-blue-600 text-white px-2 py-1 rounded-lg font-medium hover:bg-blue-700">
Übernehmen
</button>
<button onClick={onDiscard}
className="text-xs bg-gray-100 text-gray-600 px-2 py-1 rounded-lg font-medium hover:bg-gray-200">
Verwerfen
</button>
</div>
</div>
)
}
// ─── Komponente ───────────────────────────────────────────────────────────────
@@ -184,13 +86,16 @@ export default function AssignmentFeedbackPage() {
const [feedback, setFeedback] = useState<AssignmentFeedback | null>(null)
const [ratings, setRatings] = useState<FeedbackCategoryRating[]>([])
const [dimTexts, setDimTexts] = useState<FeedbackDimensionText[]>([])
const [categoryTexts, setCategoryTexts] = useState<FeedbackCategoryText[]>([])
const [expanded, setExpanded] = useState<Set<number>>(new Set())
const [catTrends, setCatTrends] = useState<Map<number, TrendResult>>(new Map())
const [showAiSettings, setShowAiSettings] = useState(false)
const [aiKey, setAiKey] = useState(getAiSettings().apiKey)
const [aiModel, setAiModel] = useState(getAiSettings().model)
const [generating, setGenerating] = useState(false)
const [generationProgress, setGenerationProgress] = useState('')
const [aiError, setAiError] = useState('')
const [dimensionErrors, setDimensionErrors] = useState<Record<number, string>>({})
const saveTimer = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map())
const load = useCallback(async () => {
@@ -204,7 +109,7 @@ export default function AssignmentFeedbackPage() {
setDimensions(structure.dimensions)
setCategories(structure.categories)
setItems(structure.items)
const { dimensions: dims, categories: cats, items: itms } = structure
const { categories: cats, items: itms } = structure
const meetings = await listDoneMeetingsChronological(assignmentId)
const meetingIds = meetings.map(m => m.id!)
@@ -228,16 +133,18 @@ export default function AssignmentFeedbackPage() {
setFeedback(fb ?? null)
if (fb?.id) {
const [rs, txts] = await Promise.all([
const [rs, txts, catTxts] = await Promise.all([
listFeedbackCategoryRatings(fb.id),
listFeedbackDimensionTexts(fb.id),
listFeedbackCategoryTexts(fb.id),
])
setRatings(rs)
setDimTexts(txts)
setCategoryTexts(catTxts)
}
// Alle Dimensionen initial expandiert
setExpanded(new Set(dims.map(d => d.id!)))
setExpanded(new Set(structure.dimensions.map(d => d.id!)))
}, [assignmentId, instId])
useEffect(() => { load() }, [load])
@@ -261,7 +168,7 @@ export default function AssignmentFeedbackPage() {
const getRating = (categoryId: number): FeedbackRating | undefined =>
ratings.find(r => r.feedbackCategoryId === categoryId)?.rating
// ── Text speichern (debounced) ────────────────────────────────────────────
// ── Dimension-Text speichern (debounced) ──────────────────────────────────
const saveDimText = (dimId: number, field: 'achievements' | 'developmentNeeds', value: string) => {
setDimTexts(prev => {
@@ -269,7 +176,7 @@ export default function AssignmentFeedbackPage() {
if (existing) return prev.map(t => t.feedbackDimensionId === dimId ? { ...t, [field]: value } : t)
return [...prev, { assignmentFeedbackId: feedback?.id ?? 0, feedbackDimensionId: dimId, achievements: '', developmentNeeds: '', [field]: value }]
})
const key = `${dimId}-${field}`
const key = `dim-${dimId}-${field}`
const prev = saveTimer.current.get(key)
if (prev) clearTimeout(prev)
saveTimer.current.set(key, setTimeout(async () => {
@@ -302,56 +209,161 @@ export default function AssignmentFeedbackPage() {
saveDimText(dimId, field, existing ? `${existing}\n${sentence}` : sentence)
}
// ── KI-Generierung ────────────────────────────────────────────────────────
const acceptDimSuggestion = (dimId: number, field: 'achievements' | 'developmentNeeds') => {
const t = getDimText(dimId)
const sugField = field === 'achievements' ? 'suggestedAchievements' : 'suggestedDevelopmentNeeds'
const value = t?.[sugField]
if (!value) return
saveDimText(dimId, field, value)
discardDimSuggestion(dimId, field)
}
const generateWithAi = async () => {
const discardDimSuggestion = async (dimId: number, field: 'achievements' | 'developmentNeeds') => {
const sugField = field === 'achievements' ? 'suggestedAchievements' : 'suggestedDevelopmentNeeds'
setDimTexts(prev => prev.map(t => t.feedbackDimensionId === dimId ? { ...t, [sugField]: '' } : t))
if (!feedback?.id) return
const existing = await getFeedbackDimensionText(feedback.id, dimId)
if (existing?.id) await updateFeedbackDimensionText(existing.id, { [sugField]: '' })
}
// ── Kategorie-Text speichern (debounced) ──────────────────────────────────
const getCategoryText = (catId: number) => categoryTexts.find(t => t.feedbackCategoryId === catId)
const saveCategoryText = (catId: number, value: string) => {
setCategoryTexts(prev => {
const existing = prev.find(t => t.feedbackCategoryId === catId)
if (existing) return prev.map(t => t.feedbackCategoryId === catId ? { ...t, text: value } : t)
return [...prev, { assignmentFeedbackId: feedback?.id ?? 0, feedbackCategoryId: catId, text: value }]
})
const key = `cat-${catId}`
const prev = saveTimer.current.get(key)
if (prev) clearTimeout(prev)
saveTimer.current.set(key, setTimeout(async () => {
if (!feedback?.id) return
const existing = await getFeedbackCategoryText(feedback.id, catId)
if (existing?.id) {
await updateFeedbackCategoryText(existing.id, { text: value })
} else {
await addFeedbackCategoryText({ assignmentFeedbackId: feedback.id, feedbackCategoryId: catId, text: value })
}
}, 600))
}
const acceptCategorySuggestion = (catId: number) => {
const value = getCategoryText(catId)?.suggestedText
if (!value) return
saveCategoryText(catId, value)
discardCategorySuggestion(catId)
}
const discardCategorySuggestion = async (catId: number) => {
setCategoryTexts(prev => prev.map(t => t.feedbackCategoryId === catId ? { ...t, suggestedText: '' } : t))
if (!feedback?.id) return
const existing = await getFeedbackCategoryText(feedback.id, catId)
if (existing?.id) await updateFeedbackCategoryText(existing.id, { suggestedText: '' })
}
// ── KI-Generierung: ein Call pro Dimension ────────────────────────────────
const generateOneDimension = async (
dim: FeedbackDimension,
meetings: MeetingInstance[],
instAssessments: Assessment[],
instEntries: ConversationEntry[],
settings: { apiKey: string; model: string },
) => {
if (!institutee || !assignment || !feedback?.id) return
const dimCategories = categories.filter(c => c.dimensionId === dim.id)
const dimItems = items.filter(i => dimCategories.some(c => c.id === i.categoryId))
const promptCfg = await getFeedbackDimensionPrompt(dim.id!)
const template = promptCfg?.promptTemplate ?? AI_CONFIG.defaultDimensionPromptTemplate
const context = buildDimensionPromptContext({
institutee, assignment, dimension: dim, dimCategories, dimItems,
ratings, catTrends, instAssessments, instEntries, meetings,
})
const prompt = renderDimensionPrompt(template, context)
const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${settings.apiKey}`,
'Content-Type': 'application/json',
'HTTP-Referer': window.location.origin,
'X-Title': 'Assignment Monitor',
},
body: JSON.stringify({
model: settings.model,
messages: [{ role: 'user', content: prompt }],
}),
})
if (!res.ok) throw new Error(`API-Fehler: ${res.status} ${res.statusText}`)
const data = await res.json()
const text = data.choices?.[0]?.message?.content ?? ''
const parsed = parseDimensionAiResponse(text)
const existingDimText = await getFeedbackDimensionText(feedback.id, dim.id!)
if (existingDimText?.id) {
await updateFeedbackDimensionText(existingDimText.id, {
suggestedAchievements: parsed.achievements,
suggestedDevelopmentNeeds: parsed.developmentNeeds,
})
} else {
await addFeedbackDimensionText({
assignmentFeedbackId: feedback.id,
feedbackDimensionId: dim.id!,
achievements: '', developmentNeeds: '',
suggestedAchievements: parsed.achievements,
suggestedDevelopmentNeeds: parsed.developmentNeeds,
})
}
for (const ct of parsed.categoryTexts) {
const cat = dimCategories.find(c => c.name === ct.name || ct.name.includes(c.name) || c.name.includes(ct.name))
if (!cat?.id) continue
const existing = await getFeedbackCategoryText(feedback.id, cat.id)
if (existing?.id) {
await updateFeedbackCategoryText(existing.id, { suggestedText: ct.text })
} else {
await addFeedbackCategoryText({ assignmentFeedbackId: feedback.id, feedbackCategoryId: cat.id, text: '', suggestedText: ct.text })
}
}
}
/** Sequenziell mit Fortschrittsanzeige — Fehler einzelner Dimensionen stoppen den Lauf nicht. */
const runDimensionBatch = async (dimsToRun: FeedbackDimension[]) => {
if (!institutee || !assignment || !feedback?.id || dimsToRun.length === 0) return
const settings = getAiSettings()
if (!settings.apiKey) { setShowAiSettings(true); return }
setGenerating(true)
setAiError('')
setDimensionErrors(prev => {
const next = { ...prev }
for (const d of dimsToRun) delete next[d.id!]
return next
})
try {
const prompt = await buildAiPrompt(institutee, assignment, dimensions, categories, items, ratings, catTrends)
const meetings = await listDoneMeetingsChronological(assignmentId)
const meetingIds = meetings.map(m => m.id!)
const [allAssessments, allEntries] = await Promise.all([
listAssessmentsForMeetings(meetingIds),
listConversationEntriesForMeetings(meetingIds),
])
const instAssessments = allAssessments.filter(a => a.instituteeId === institutee.id)
const instEntries = allEntries.filter(e => e.instituteeId === institutee.id)
const res = await fetch('https://openrouter.ai/api/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${settings.apiKey}`,
'Content-Type': 'application/json',
'HTTP-Referer': window.location.origin,
'X-Title': 'Assignment Monitor',
},
body: JSON.stringify({
model: settings.model,
messages: [{ role: 'user', content: prompt }],
response_format: { type: 'json_object' },
}),
})
if (!res.ok) throw new Error(`API Error: ${res.status} ${res.statusText}`)
const data = await res.json()
const text = data.choices?.[0]?.message?.content ?? ''
const parsed = JSON.parse(text) as { dimensions: { name: string; achievements: string; developmentNeeds: string }[] }
// Texte in DB schreiben
for (const item of parsed.dimensions) {
const dim = dimensions.find(d => d.name === item.name || item.name.includes(d.name.split(',')[0]))
if (!dim?.id) continue
const existing = await getFeedbackDimensionText(feedback.id, dim.id)
if (existing?.id) {
await updateFeedbackDimensionText(existing.id, {
achievements: item.achievements,
developmentNeeds: item.developmentNeeds,
})
} else {
await addFeedbackDimensionText({
assignmentFeedbackId: feedback.id,
feedbackDimensionId: dim.id,
achievements: item.achievements,
developmentNeeds: item.developmentNeeds,
})
for (let i = 0; i < dimsToRun.length; i++) {
const dim = dimsToRun[i]
setGenerationProgress(`Generiere Dimension ${i + 1}/${dimsToRun.length}: ${dim.name}…`)
try {
await generateOneDimension(dim, meetings, instAssessments, instEntries, settings)
} catch (e) {
setDimensionErrors(prev => ({ ...prev, [dim.id!]: e instanceof Error ? e.message : 'Unbekannter Fehler' }))
}
}
await updateAssignmentFeedback(feedback.id, { aiModel: settings.model, updatedAt: new Date().toISOString() })
@@ -360,9 +372,16 @@ export default function AssignmentFeedbackPage() {
setAiError(e instanceof Error ? e.message : 'Unbekannter Fehler')
} finally {
setGenerating(false)
setGenerationProgress('')
}
}
const generateAllDimensions = () => runDimensionBatch(dimensions)
const retryFailedDimensions = () => {
const failedIds = new Set(Object.keys(dimensionErrors).map(Number))
runDimensionBatch(dimensions.filter(d => failedIds.has(d.id!)))
}
const toggleFinal = async () => {
if (!feedback?.id) return
const next = feedback.status === 'final' ? 'draft' : 'final'
@@ -440,14 +459,14 @@ export default function AssignmentFeedbackPage() {
{/* KI-Generieren Button */}
<div className="flex items-center gap-3">
<button
onClick={generateWithAi}
onClick={generateAllDimensions}
disabled={generating}
className={`flex-1 py-3 rounded-xl text-sm font-medium transition ${
generating
? 'bg-gray-200 text-gray-400 cursor-not-allowed'
: 'bg-brand text-white hover:bg-brand-dark'
}`}>
{generating ? 'Generiere Entwurf…' : '✦ KI-Feedback-Entwurf generieren'}
{generating ? (generationProgress || 'Generiere…') : '✦ KI-Feedback-Entwurf generieren'}
</button>
</div>
{aiError && (
@@ -455,6 +474,18 @@ export default function AssignmentFeedbackPage() {
{aiError}
</div>
)}
{!generating && Object.keys(dimensionErrors).length > 0 && (
<div className="text-xs text-red-600 bg-red-50 border border-red-200 rounded-lg px-3 py-2 space-y-1.5">
<div className="font-medium">Fehler bei {Object.keys(dimensionErrors).length} Dimension(en):</div>
{Object.entries(dimensionErrors).map(([dimId, msg]) => (
<div key={dimId}>• {dimensions.find(d => d.id === Number(dimId))?.name}: {msg}</div>
))}
<button onClick={retryFailedDimensions}
className="text-xs bg-red-100 text-red-700 px-2 py-1 rounded-lg font-medium hover:bg-red-200">
Fehlgeschlagene Dimensionen erneut versuchen
</button>
</div>
)}
{/* Dimensionen */}
{dimensions.map(dim => {
@@ -499,6 +530,7 @@ export default function AssignmentFeedbackPage() {
{dimCats.map(cat => {
const catItems = items.filter(i => i.categoryId === cat.id)
const currentRating = getRating(cat.id!)
const catText = getCategoryText(cat.id!)
return (
<div key={cat.id} className="space-y-2">
<div className="font-medium text-sm text-gray-700">{cat.name}</div>
@@ -556,13 +588,30 @@ export default function AssignmentFeedbackPage() {
))}
</div>
)}
{/* Kategorie-Notiz */}
<div className="space-y-1.5">
<textarea
className="w-full border border-gray-200 rounded-lg px-3 py-2 text-sm focus:outline-none focus:border-brand min-h-[50px]"
placeholder="Kurze Einschätzung zu dieser Kategorie…"
value={catText?.text ?? ''}
onChange={e => saveCategoryText(cat.id!, e.target.value)}
/>
{catText?.suggestedText && (
<AiSuggestionBox
text={catText.suggestedText}
onAccept={() => acceptCategorySuggestion(cat.id!)}
onDiscard={() => discardCategorySuggestion(cat.id!)}
/>
)}
</div>
</div>
)
})}
{/* Textfelder */}
<div className="space-y-3 pt-2 border-t border-gray-50">
<div>
<div className="space-y-1.5">
<label className="text-xs font-semibold text-green-700 uppercase tracking-wide block mb-1.5">
Achievements
</label>
@@ -572,8 +621,15 @@ export default function AssignmentFeedbackPage() {
value={text?.achievements ?? ''}
onChange={e => saveDimText(dim.id!, 'achievements', e.target.value)}
/>
{text?.suggestedAchievements && (
<AiSuggestionBox
text={text.suggestedAchievements}
onAccept={() => acceptDimSuggestion(dim.id!, 'achievements')}
onDiscard={() => discardDimSuggestion(dim.id!, 'achievements')}
/>
)}
</div>
<div>
<div className="space-y-1.5">
<label className="text-xs font-semibold text-amber-700 uppercase tracking-wide block mb-1.5">
Development Needs
</label>
@@ -583,6 +639,13 @@ export default function AssignmentFeedbackPage() {
value={text?.developmentNeeds ?? ''}
onChange={e => saveDimText(dim.id!, 'developmentNeeds', e.target.value)}
/>
{text?.suggestedDevelopmentNeeds && (
<AiSuggestionBox
text={text.suggestedDevelopmentNeeds}
onAccept={() => acceptDimSuggestion(dim.id!, 'developmentNeeds')}
onDiscard={() => discardDimSuggestion(dim.id!, 'developmentNeeds')}
/>
)}
</div>
</div>
</div>
+7 -1
View File
@@ -2,10 +2,11 @@ import { useRef, useState } from 'react'
import FeedbackStructureConfig from './FeedbackStructureConfig'
import AssignmentTypeConfig from './AssignmentTypeConfig'
import RatingWeightConfig from './RatingWeightConfig'
import AiPromptConfig from './AiPromptConfig'
import { exportFullBackup, importFullBackup } from '../utils/dbBackup'
export default function Configuration() {
const [tab, setTab] = useState<'feedback' | 'types' | 'weighting' | 'backup'>('feedback')
const [tab, setTab] = useState<'feedback' | 'types' | 'weighting' | 'aiPrompts' | 'backup'>('feedback')
const [backupStatus, setBackupStatus] = useState<{ type: 'success' | 'error'; msg: string } | null>(null)
const [restoreConfirm, setRestoreConfirm] = useState(false)
const [importing, setImporting] = useState(false)
@@ -53,6 +54,10 @@ export default function Configuration() {
className={`flex-1 py-2 rounded-lg text-sm font-medium transition ${tab === 'weighting' ? 'bg-white text-brand shadow-sm' : 'text-gray-500'}`}>
Gewichtung
</button>
<button onClick={() => setTab('aiPrompts')}
className={`flex-1 py-2 rounded-lg text-sm font-medium transition ${tab === 'aiPrompts' ? 'bg-white text-brand shadow-sm' : 'text-gray-500'}`}>
KI-Prompts
</button>
<button onClick={() => setTab('backup')}
className={`flex-1 py-2 rounded-lg text-sm font-medium transition ${tab === 'backup' ? 'bg-white text-brand shadow-sm' : 'text-gray-500'}`}>
Backup
@@ -71,6 +76,7 @@ export default function Configuration() {
{tab === 'feedback' && <FeedbackStructureConfig />}
{tab === 'types' && <AssignmentTypeConfig />}
{tab === 'weighting' && <RatingWeightConfig />}
{tab === 'aiPrompts' && <AiPromptConfig />}
{tab === 'backup' && (
<div className="space-y-4">
+175
View File
@@ -0,0 +1,175 @@
import type {
Consultant, Assignment, FeedbackDimension, FeedbackCategory, FeedbackCriterionItem,
FeedbackCategoryRating, Assessment, ConversationEntry, MeetingInstance, FeedbackRating,
} from '../db/types'
import { RATING_OPTIONS, RATING_NUM_MAP } from '../config/constants'
import { splitNoteLines } from './notationParser'
import type { TrendResult } from './ratingTrend'
const ratingToNum = (r: FeedbackRating | null | undefined): number =>
r ? (RATING_NUM_MAP[r] ?? 0) : 0
export interface DimensionPromptInput {
institutee: Consultant
assignment: Assignment
dimension: FeedbackDimension
dimCategories: FeedbackCategory[]
dimItems: FeedbackCriterionItem[]
ratings: FeedbackCategoryRating[]
catTrends: Map<number, TrendResult>
/** Bereits auf diesen Berater gefiltert. */
instAssessments: Assessment[]
/** Bereits auf diesen Berater gefiltert. */
instEntries: ConversationEntry[]
/** Alle `done`-Meetings des Assignments, chronologisch — siehe `listDoneMeetingsChronological`. */
meetings: MeetingInstance[]
}
/**
* Baut die Platzhalter-Werte für EINE Dimension. Kriterien/Kategorien werden vom Aufrufer
* bereits auf die Dimension gefiltert übergeben, siehe CLAUDE.md „Mehrstufiges Prompt-System".
*/
export function buildDimensionPromptContext(input: DimensionPromptInput): Record<string, string> {
const {
institutee, assignment, dimension, dimCategories, dimItems,
ratings, catTrends, instAssessments, instEntries, meetings,
} = input
const allLineTags = instEntries.flatMap(e => e.lineTags ?? [])
const fillerTotal = instEntries.reduce((s, e) => s + (e.fillerCount ?? 0), 0)
const kategorienStruktur = dimCategories
.map((c, i) => `${i + 1}. ${c.name}`)
.join('\n') || '(keine Kategorien)'
const kriterienScores = dimCategories.map(cat => {
const catItems = dimItems.filter(i => i.categoryId === cat.id)
const lines = catItems.map(c => {
const scores = instAssessments.filter(a => a.criteriaId === c.id && a.score !== null && a.score !== 'na')
const avg = scores.length > 0
? (scores.reduce((s, a) => s + ratingToNum(a.score), 0) / scores.length).toFixed(1)
: '—'
const notes = [
...instAssessments.filter(a => a.criteriaId === c.id && a.note).map(a => a.note),
...allLineTags.filter(t => t.criterionItemId === c.id).map(t => t.text),
]
return ` ${c.name}: ${avg}/4${notes.length > 0 ? ` | Notizen: ${notes.join('; ')}` : ''}`
}).join('\n')
return ` ${cat.name}:\n${lines || ' (keine Kriterien)'}`
}).join('\n') || '(keine Scores erfasst)'
const kategorieBewertungen = dimCategories.map(cat => {
const r = ratings.find(r => r.feedbackCategoryId === cat.id)
const rating = RATING_OPTIONS.find(x => x.value === r?.rating)?.label ?? 'nicht bewertet'
return ` ${cat.name}: ${rating}`
}).join('\n') || '(keine Kategorien)'
const entwicklungVerlauf = dimCategories.map(cat => {
const t = catTrends.get(cat.id!)
if (!t || t.history.length === 0) return ` ${cat.name}: keine Verlaufsdaten`
const seq = t.history.map(h => h.score.toFixed(1)).join(' → ')
const trendLabel = t.trend === 'up' ? 'Verbesserung über die Laufzeit'
: t.trend === 'down' ? 'Verschlechterung über die Laufzeit'
: t.trend === 'stable' ? 'stabil'
: 'nur ein Meeting, kein Trend ableitbar'
return ` ${cat.name}: Verlauf ${seq} (${trendLabel})`
}).join('\n') || '(keine Kategorien)'
const notizenAllgemeinMeeting = meetings
.filter(m => m.generalNotes && m.generalNotes.trim() !== '')
.map(m => ` [${m.date}] ${m.generalNotes}`)
.join('\n') || '(keine allgemeinen Meeting-Notizen)'
const protokollUnzugeordnet = meetings
.map(m => {
const meetingEntries = instEntries.filter(e => e.meetingInstanceId === m.id)
const lines = meetingEntries
.flatMap(e => splitNoteLines(e.note).map(line => ({
line, tagged: (e.lineTags ?? []).some(t => t.text === line),
})))
.filter(x => !x.tagged)
.map(x => ` - ${x.line}`)
if (lines.length === 0) return null
return ` [${m.date}]\n${lines.join('\n')}`
})
.filter((x): x is string => x !== null)
.join('\n') || '(keine nicht zugeordneten Protokolleinträge)'
return {
'{{BERATER_NAME}}': `${institutee.firstName} ${institutee.lastName}`,
'{{ASSIGNMENT_TITEL}}': assignment.title,
'{{ASSIGNMENT_KUNDE}}': assignment.client,
'{{DIMENSION_NAME}}': dimension.name,
'{{KATEGORIEN_STRUKTUR}}': kategorienStruktur,
'{{KRITERIEN_SCORES}}': kriterienScores,
'{{KATEGORIE_BEWERTUNGEN}}': kategorieBewertungen,
'{{ENTWICKLUNG_VERLAUF}}': entwicklungVerlauf,
'{{NOTIZEN_ALLGEMEIN_MEETING}}': notizenAllgemeinMeeting,
'{{PROTOKOLL_UNZUGEORDNET}}': protokollUnzugeordnet,
'{{FUELLWOERTER_GESAMT}}': String(fillerTotal),
}
}
export function renderDimensionPrompt(template: string, context: Record<string, string>): string {
let result = template
for (const [token, value] of Object.entries(context)) {
result = result.split(token).join(value)
}
return result
}
export interface ParsedDimensionResponse {
categoryTexts: { name: string; text: string }[]
achievements: string
developmentNeeds: string
}
/**
* Entfernt vorsorglich Markdown-Codefences (manche Provider ignorieren die Format-Anweisung im
* Prompt trotzdem) und parst dann per Zeilen-Scan auf die festen KATEGORIE:/ACHIEVEMENTS:/
* DEVELOPMENT_NEEDS:-Marker. Siehe CLAUDE.md — löst den früheren response_format-Bug strukturell.
*/
export function parseDimensionAiResponse(raw: string): ParsedDimensionResponse {
const cleaned = raw.trim().replace(/^```[a-z]*\n?/i, '').replace(/```$/, '').trim()
const lines = cleaned.split('\n')
const categoryTexts: { name: string; text: string }[] = []
let achievements = ''
let developmentNeeds = ''
let mode: 'none' | 'category' | 'achievements' | 'development' = 'none'
let currentName = ''
let buffer: string[] = []
const flush = () => {
const text = buffer.join('\n').trim()
if (mode === 'category' && currentName) categoryTexts.push({ name: currentName, text })
else if (mode === 'achievements') achievements = text
else if (mode === 'development') developmentNeeds = text
buffer = []
}
for (const line of lines) {
const catMatch = line.match(/^KATEGORIE:\s*(.+)$/i)
const achMatch = line.match(/^ACHIEVEMENTS:\s*$/i)
const devMatch = line.match(/^DEVELOPMENT_NEEDS:\s*$/i)
if (catMatch) {
flush()
mode = 'category'
currentName = catMatch[1].trim()
} else if (achMatch) {
flush()
mode = 'achievements'
currentName = ''
} else if (devMatch) {
flush()
mode = 'development'
currentName = ''
} else {
buffer.push(line)
}
}
flush()
return { categoryTexts, achievements, developmentNeeds }
}