Charge la Session + les N dernières entrées du journal et les mappe vers + * le Value Object {@link SessionContext}. La limite d'entrées évite de saturer + * la fenêtre de contexte du LLM sur des sessions très longues.
+ */ +@Component +public class SessionStructuralContextBuilder { + + /** + * Plafond du nombre d'entrées remontées au LLM. + * Choisi pour rester dans des limites raisonnables (≈ 5-10k tokens max + * pour des entrées moyennes de 200 chars). Si la session déborde, + * on garde les entrées les plus récentes (fin de chronologie). + */ + private static final int MAX_ENTRIES = 80; + + private final SessionRepository sessionRepository; + private final SessionEntryRepository entryRepository; + + public SessionStructuralContextBuilder(SessionRepository sessionRepository, + SessionEntryRepository entryRepository) { + this.sessionRepository = sessionRepository; + this.entryRepository = entryRepository; + } + + public Optional+ * Orchestre la composition des contextes : + * 1. Charge la Session puis la Campagne associée (weak reference). + * 2. Construit le CampaignStructuralContext (carte narrative + PJ/PNJ). + * 3. Construit le LoreStructuralContext si la campagne est liée à un Lore. + * 4. Construit le GameSystemContext si elle a un système de JDR. + * 5. Construit le SessionContext (journal horodaté, statut). + * 6. Délègue au port {@link AiChatProvider} pour le streaming. + *
+ * + *La conversation est éphémère (pas de persistance) : pendant une partie, + * l'utilité est d'avoir une assistance immédiate, pas de garder un historique. + * Le journal de session joue déjà ce rôle de mémoire persistante.
+ */ +@Service +public class StreamChatForSessionUseCase { + + private final SessionRepository sessionRepository; + private final CampaignRepository campaignRepository; + private final CampaignStructuralContextBuilder campaignContextBuilder; + private final LoreStructuralContextBuilder loreContextBuilder; + private final GameSystemContextBuilder gameSystemContextBuilder; + private final SessionStructuralContextBuilder sessionContextBuilder; + private final AiChatProvider aiChatProvider; + + public StreamChatForSessionUseCase( + SessionRepository sessionRepository, + CampaignRepository campaignRepository, + CampaignStructuralContextBuilder campaignContextBuilder, + LoreStructuralContextBuilder loreContextBuilder, + GameSystemContextBuilder gameSystemContextBuilder, + SessionStructuralContextBuilder sessionContextBuilder, + AiChatProvider aiChatProvider) { + this.sessionRepository = sessionRepository; + this.campaignRepository = campaignRepository; + this.campaignContextBuilder = campaignContextBuilder; + this.loreContextBuilder = loreContextBuilder; + this.gameSystemContextBuilder = gameSystemContextBuilder; + this.sessionContextBuilder = sessionContextBuilder; + this.aiChatProvider = aiChatProvider; + } + + public void execute( + String sessionId, + ListRègle métier : une seule Session peut être active (endedAt null) à la fois + * dans l'application.
+ */ +@Service +public class SessionService { + + private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + + private final SessionRepository sessionRepository; + private final SessionEntryRepository entryRepository; + private final CampaignRepository campaignRepository; + + public SessionService(SessionRepository sessionRepository, + SessionEntryRepository entryRepository, + CampaignRepository campaignRepository) { + this.sessionRepository = sessionRepository; + this.entryRepository = entryRepository; + this.campaignRepository = campaignRepository; + } + + /** + * Lance une nouvelle session sur la campagne donnée. + * Échoue si une session est déjà active ou si la campagne n'existe pas. + */ + public Session startSession(String campaignId) { + if (campaignId == null || campaignId.isBlank()) { + throw new IllegalArgumentException("campaignId est requis pour démarrer une session."); + } + if (!campaignRepository.existsById(campaignId)) { + throw new IllegalArgumentException("Campagne introuvable : " + campaignId); + } + sessionRepository.findActive().ifPresent(s -> { + throw new IllegalStateException("Une session est déjà en cours (id=" + s.getId() + "). Termine-la avant d'en lancer une nouvelle."); + }); + + LocalDateTime now = LocalDateTime.now(); + Session session = Session.builder() + .name(generateDefaultName(now)) + .campaignId(campaignId) + .startedAt(now) + .build(); + return sessionRepository.save(session); + } + + /** Termine la session active si elle correspond à l'id donné. */ + public Session endSession(String id) { + Session session = sessionRepository.findById(id) + .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + id)); + if (!session.isActive()) { + throw new IllegalStateException("Cette session est déjà terminée."); + } + session.setEndedAt(LocalDateTime.now()); + return sessionRepository.save(session); + } + + public Session renameSession(String id, String newName) { + if (newName == null || newName.isBlank()) { + throw new IllegalArgumentException("Le nom de la session ne peut pas être vide."); + } + Session session = sessionRepository.findById(id) + .orElseThrow(() -> new IllegalArgumentException("Session introuvable : " + id)); + session.setName(newName.trim()); + return sessionRepository.save(session); + } + + public OptionalPendant qu'une session se joue, l'IA reçoit en plus du Lore/Campagne/GameSystem : + * le nom de la session, son statut (en cours / terminée) et un résumé chronologique + * des entrées du journal (notes, évènements, jets, actions joueurs).
+ * + *Value Object du Generation Context — record Java immutable.
+ * + * @param sessionName Nom de la session telle qu'affichée au MJ. + * @param active True si la session est en cours, false si terminée. + * @param startedAt Horodatage de démarrage. + * @param entries Entrées du journal triées chronologiquement (anciennes → récentes). + * Limité côté builder pour éviter de saturer le contexte LLM. + */ +public record SessionContext( + String sessionName, + boolean active, + LocalDateTime startedAt, + ListUne Session est une instance jouée d'une Campaign. La Campaign reste + * un scénario générique réutilisable ; la Session capture une partie réelle + * (date, journal, etc.) sans polluer le scénario d'origine.
+ * + *Fait partie du Play Context. Référence la Campaign par weak reference + * (campaignId) pour respecter la séparation des Bounded Contexts.
+ * + *{@code endedAt == null} signifie que la session est en cours. + * Une seule session peut être en cours dans l'application à la fois.
+ */ +@Data +@Builder +public class Session { + + private String id; + private String name; + + /** Weak reference vers Campaign — pas de dépendance directe inter-contexte. */ + private String campaignId; + + private LocalDateTime startedAt; + + /** Null = session en cours ; renseigné = session terminée. */ + private LocalDateTime endedAt; + + private LocalDateTime createdAt; + private LocalDateTime updatedAt; + + public boolean isActive() { + return this.endedAt == null; + } +} diff --git a/core/src/main/java/com/loremind/domain/playcontext/SessionEntry.java b/core/src/main/java/com/loremind/domain/playcontext/SessionEntry.java new file mode 100644 index 0000000..cdc2e2b --- /dev/null +++ b/core/src/main/java/com/loremind/domain/playcontext/SessionEntry.java @@ -0,0 +1,39 @@ +package com.loremind.domain.playcontext; + +import lombok.Builder; +import lombok.Data; + +import java.time.LocalDateTime; + +/** + * Entrée du journal d'une Session. + * Représente un évènement horodaté capturé pendant ou après une partie : + * note libre du MJ, évènement marquant, jet de dés, action de joueur. + * + *Fait partie du Play Context. Référence la Session par weak reference + * (sessionId) — l'orchestration en cascade est gérée par le service applicatif.
+ */ +@Data +@Builder +public class SessionEntry { + + private String id; + + /** Weak reference vers Session (intra-contexte mais reste découplée). */ + private String sessionId; + + private EntryType type; + + /** Contenu texte brut saisi par le MJ. */ + private String content; + + /** + * Horodatage métier de l'évènement. + * Distinct de {@code createdAt} : utile si le MJ rédige a posteriori + * une note rétroactive sur quelque chose qui s'est passé plus tôt. + */ + private LocalDateTime occurredAt; + + private LocalDateTime createdAt; + private LocalDateTime updatedAt; +} diff --git a/core/src/main/java/com/loremind/domain/playcontext/ports/SessionEntryRepository.java b/core/src/main/java/com/loremind/domain/playcontext/ports/SessionEntryRepository.java new file mode 100644 index 0000000..ceb4b9e --- /dev/null +++ b/core/src/main/java/com/loremind/domain/playcontext/ports/SessionEntryRepository.java @@ -0,0 +1,26 @@ +package com.loremind.domain.playcontext.ports; + +import com.loremind.domain.playcontext.SessionEntry; + +import java.util.List; +import java.util.Optional; + +/** + * Port de sortie pour la persistance des entrées de journal de session. + */ +public interface SessionEntryRepository { + + SessionEntry save(SessionEntry entry); + + OptionalAucune session de jeu pour le moment.
+Diffère du {@link AiChatDrawerComponent} : + * - conversation 100% éphémère (le journal joue le rôle de mémoire persistante) + * - intégré dans le panneau latéral, pas en drawer + * - chaque réponse peut être ajoutée au journal en un clic (event {@link saveToJournal})
+ * + *Le backend reçoit le contexte complet via {@code /api/ai/chat/stream-session} : + * lore + campagne + GameSystem + journal — l'IA "sait" tout ce qui s'est passé.
+ */ +@Component({ + selector: 'app-session-ai-chat-panel', + standalone: true, + imports: [CommonModule, FormsModule, LucideAngularModule], + templateUrl: './session-ai-chat-panel.component.html', + styleUrls: ['./session-ai-chat-panel.component.scss'] +}) +export class SessionAiChatPanelComponent implements OnChanges, OnDestroy { + readonly Send = Send; + readonly Sparkles = Sparkles; + readonly Trash2 = Trash2; + readonly BookmarkPlus = BookmarkPlus; + readonly Square = Square; + + @Input() sessionId!: string; + @Input() canSaveToJournal = true; + + /** Émis quand le MJ clique "Ajouter au journal" sur une réponse. */ + @Output() saveToJournal = new EventEmitterAucune entrée pour le moment.
++ Saisis une note, un évènement ou un jet ci-dessus pour commencer le journal. +
+{{ entry.content }}
++ Choisis un dé et lance. +
+ +Chargement…
+ ++ Aucun personnage dans cette campagne. +
+Chargement…
+ ++ Aucun arc narratif. Construis le scénario de ta campagne pour le retrouver ici. +
+ +Charge à la volée les PJ/PNJ et l'arbre de scènes de la campagne associée + * à la session. La navigation vers les fiches s'ouvre dans un nouvel onglet + * pour ne pas casser le flux de la session en cours.
+ * + *Le sous-composant {@link SessionDicePanelComponent} émet un événement + * de jet qui remonte ici puis vers le parent via {@link rolled}.
+ */ +@Component({ + selector: 'app-session-reference-panel', + standalone: true, + imports: [CommonModule, LucideAngularModule, SessionDicePanelComponent, SessionAiChatPanelComponent], + templateUrl: './session-reference-panel.component.html', + styleUrls: ['./session-reference-panel.component.scss'] +}) +export class SessionReferencePanelComponent implements OnChanges { + readonly User = User; + readonly Drama = Drama; + readonly Swords = Swords; + readonly Dices = Dices; + readonly ExternalLink = ExternalLink; + readonly Sparkles = Sparkles; + + @Input() campaignId!: string; + @Input() sessionId!: string; + @Input() canAddToJournal = true; + @Output() rolled = new EventEmitter