@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/core/notifications.js

@@ -0,0 +1,173 @@
+import { NotFoundError } from "./errors.js";
+/**
+ * Notifications (assignation, commentaire) et préférences. Les notifications
+ * sont créées par le store dans la transaction de l'événement ; leurs e-mails
+ * partent après la validation, et l'issue de chaque envoi est enregistrée.
+ */
+const asUser = (userId) => ({ type: "user", userId });
+/** Longueur maximale de l'extrait d'un commentaire. */
+const EXCERPT_LENGTH = 120;
+/** Nom de l'agent dans les phrases des notifications. */
+const AGENT_NAME = "L'agent";
+function publicBase(publicUrl) {
+    return publicUrl?.trim().replace(/\/+$/, "") || null;
+}
+/** Raison pour laquelle les e-mails de notification ne partent pas, ou null s'ils peuvent partir. */
+export function notificationEmailBlocker(deps) {
+    if (!deps.mailer.enabled)
+        return deps.mailer.disabledReason;
+    if (!publicBase(deps.publicUrl)) {
+        return "E-mail non envoyé : ORGANIZER_PUBLIC_URL n'est pas défini dans la configuration du site, le lien vers la tâche ne peut pas figurer dans le message.";
+    }
+    return null;
+}
+/** Première ligne d'un texte, abrégée. */
+function excerpt(text) {
+    const line = text.trim().split(/\r?\n/)[0].trim();
+    return line.length > EXCERPT_LENGTH ? `${line.slice(0, EXCERPT_LENGTH - 1)}…` : line;
+}
+function actorName(store, notification) {
+    if (notification.actorType === "agent" || notification.actorId === null)
+        return null;
+    const actor = store.findUser(notification.actorId);
+    return actor ? (actor.displayName ?? actor.email) : null;
+}
+/**
+ * Envoi des e-mails de notification. Abonné au store, il reçoit les
+ * notifications dont le destinataire veut un e-mail après la validation de
+ * la mutation qui les a créées, envoie chaque e-mail et enregistre son issue
+ * (`emailedAt` ou `emailError`).
+ */
+export class NotificationMailer {
+    store;
+    deps;
+    inFlight = new Set();
+    constructor(store, deps) {
+        this.store = store;
+        this.deps = deps;
+    }
+    /** Abonne l'envoi aux mutations du store. */
+    attach() {
+        this.store.setEmailListener((ids) => this.enqueue(ids));
+        return this;
+    }
+    /** Attend la fin des envois en cours. */
+    async flush() {
+        while (this.inFlight.size > 0)
+            await Promise.all([...this.inFlight]);
+    }
+    enqueue(ids) {
+        const delivery = this.deliver(ids).finally(() => this.inFlight.delete(delivery));
+        this.inFlight.add(delivery);
+    }
+    async deliver(ids) {
+        for (const id of ids) {
+            try {
+                const notification = this.store.findNotification(id);
+                if (!notification)
+                    continue;
+                const outcome = await this.send(notification);
+                // La notification disparaît avec sa tâche ou son commentaire, éventuellement supprimés pendant l'envoi.
+                if (!this.store.findNotification(id))
+                    continue;
+                this.store.mutate(asUser(notification.userId), (tx) => tx.recordNotificationEmail(id, outcome));
+            }
+            catch (err) {
+                this.deps.logError(`E-mail of notification ${id} failed: ${err?.stack ?? err}`);
+            }
+        }
+    }
+    async send(notification) {
+        const blocker = notificationEmailBlocker(this.deps);
+        if (blocker)
+            return { sent: false, reason: blocker };
+        const recipient = this.store.getUser(notification.userId);
+        const outcome = await this.deps.mailer.send(this.message(notification, recipient.email));
+        return outcome.sent ? { sent: true } : { sent: false, reason: outcome.reason };
+    }
+    message(notification, to) {
+        const task = this.store.getTask(notification.taskId);
+        const space = this.store.getSpace(task.spaceId);
+        const key = `${space.keyPrefix}-${task.number}`;
+        const who = actorName(this.store, notification) ?? AGENT_NAME;
+        const url = `${publicBase(this.deps.publicUrl)}/#/task/${encodeURIComponent(task.id)}`;
+        const footer = `\n\nOuvrir la tâche : ${url}\n\nCes e-mails se désactivent dans les Paramètres de mcp-organizer.\n`;
+        if (notification.type === "assigned") {
+            return {
+                to,
+                subject: `${who} vous a assigné « ${task.title} »`,
+                text: `${who} vous a assigné la tâche ${key} « ${task.title} » dans l'espace « ${space.name} ».${footer}`,
+            };
+        }
+        const comment = notification.commentId === null ? null : this.store.findComment(notification.commentId);
+        return {
+            to,
+            subject: `${who} a commenté « ${task.title} »`,
+            text: `${who} a commenté la tâche ${key} « ${task.title} » dans l'espace « ${space.name} » :\n\n${comment?.body ?? ""}${footer}`,
+        };
+    }
+}
+// --- API ------------------------------------------------------------------------
+function notificationView(store, notification) {
+    const task = store.getTask(notification.taskId);
+    const space = store.getSpace(task.spaceId);
+    const comment = notification.commentId === null ? null : store.findComment(notification.commentId);
+    return {
+        id: notification.id,
+        type: notification.type,
+        taskId: task.id,
+        taskKey: `${space.keyPrefix}-${task.number}`,
+        taskTitle: task.title,
+        actorType: notification.actorType,
+        actorId: notification.actorId,
+        actorName: actorName(store, notification),
+        commentExcerpt: comment ? excerpt(comment.body) : null,
+        createdAt: notification.createdAt,
+        readAt: notification.readAt,
+        emailedAt: notification.emailedAt,
+        emailError: notification.emailError,
+    };
+}
+/** Notifications de l'utilisateur, non lues d'abord, par page. */
+export function listNotifications(store, userId, query) {
+    const page = store.listNotifications(userId, query.limit + 1, query.offset);
+    return {
+        notifications: page.slice(0, query.limit).map((notification) => notificationView(store, notification)),
+        unreadCount: store.countUnreadNotifications(userId),
+        hasMore: page.length > query.limit,
+    };
+}
+export function unreadCount(store, userId) {
+    return { unreadCount: store.countUnreadNotifications(userId) };
+}
+/** Marque lue une notification de l'utilisateur ; celle d'un autre est introuvable. */
+export function markNotificationRead(store, userId, notificationId) {
+    const notification = store.findNotification(notificationId);
+    if (!notification || notification.userId !== userId || !notification.inApp)
+        throw new NotFoundError("Notification introuvable.");
+    store.mutate(asUser(userId), (tx) => tx.markNotificationRead(notificationId));
+    return unreadCount(store, userId);
+}
+export function markAllNotificationsRead(store, userId) {
+    store.mutate(asUser(userId), (tx) => tx.markAllNotificationsRead());
+    return unreadCount(store, userId);
+}
+function settingsView(store, deps, userId) {
+    const { notifyAssignApp, notifyAssignEmail, notifyCommentApp, notifyCommentEmail } = store.getUserSettings(userId);
+    const reason = notificationEmailBlocker(deps);
+    return {
+        notifyAssignApp,
+        notifyAssignEmail,
+        notifyCommentApp,
+        notifyCommentEmail,
+        email: { enabled: reason === null, reason },
+        transcription: { enabled: deps.transcriber.enabled, reason: deps.transcriber.disabledReason },
+    };
+}
+export function getSettings(store, deps, userId) {
+    return settingsView(store, deps, userId);
+}
+export function updateSettings(store, deps, userId, patch) {
+    store.mutate(asUser(userId), (tx) => tx.updateUserSettings(userId, patch));
+    return settingsView(store, deps, userId);
+}

package/dist/src/core/project-root.d.ts

@@ -0,0 +1,2 @@
+/** Racine du package : premier dossier contenant un package.json en remontant depuis `startDir`. */
+export declare function findProjectRoot(startDir: string): string;

package/dist/src/core/project-root.js

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Racine du package : premier dossier contenant un package.json en remontant depuis `startDir`. */
+export function findProjectRoot(startDir) {
+    let current = startDir;
+    while (!fs.existsSync(path.join(current, "package.json"))) {
+        const parent = path.dirname(current);
+        if (parent === current)
+            throw new Error(`No package.json found above ${startDir}: the mcp-organizer package is incomplete, reinstall it.`);
+        current = parent;
+    }
+    return current;
+}

package/dist/src/core/requests.d.ts

@@ -0,0 +1,50 @@
+import type { Store } from "./store.js";
+import type { AgentAction, AgentRequest } from "../../shared/schemas/entities.schema.js";
+import type { RequestKind } from "../../shared/schemas/enums.schema.js";
+import type { AgentActionView, RequestListResponse, RequestView } from "../../shared/schemas/agent-api.schema.js";
+/**
+ * File de l'agent vue de la GUI : dépôt d'une demande, modification et
+ * annulation tant qu'elle attend, libération d'une demande prise, liste par
+ * espace, annulation des actions de l'agent.
+ *
+ * Une demande vise l'espace où elle est écrite. Droits : les membres de cet
+ * espace la voient, la modifient et l'annulent tant qu'elle est en attente,
+ * la libèrent quand l'agent l'a prise, voient et annulent les actions de son
+ * lot. Les droits sont vérifiés dans la transaction de l'écriture.
+ */
+/** Nombre maximal de demandes renvoyées pour un espace. */
+export declare const REQUESTS_PAGE_SIZE = 200;
+export declare function actionView(store: Store, action: AgentAction): AgentActionView;
+export declare function requestView(store: Store, userId: string, request: AgentRequest): RequestView;
+/** Entrée d'une demande déposée par la GUI ou par une review de test. */
+export interface NewRequestInput {
+    kind: RequestKind;
+    text: string;
+    contextTaskId?: string | null;
+    contextIdeaId?: string | null;
+}
+/**
+ * Dépose une demande de l'utilisateur, écrite dans l'espace `spaceId`, qui
+ * est aussi l'espace où l'agent agira. La tâche de contexte appartient à cet
+ * espace ; une promotion d'idée porte une idée de cet espace.
+ */
+export declare function createRequest(store: Store, userId: string, spaceId: string, input: NewRequestInput): RequestView;
+export declare function updateRequest(store: Store, userId: string, requestId: string, text: string): RequestView;
+export declare function cancelRequest(store: Store, userId: string, requestId: string): RequestView;
+/**
+ * Libère une demande que l'agent a prise sans la terminer : elle redevient
+ * `pending` et un agent pourra la reprendre. Les actions déjà faites restent
+ * dans son lot. Réservé aux membres de l'espace cible.
+ */
+export declare function releaseRequest(store: Store, userId: string, requestId: string): RequestView;
+export declare function getRequest(store: Store, userId: string, requestId: string): RequestView;
+/**
+ * Demandes d'un espace, avec le nombre de demandes en attente et les jetons
+ * actifs qui couvrent l'espace, chacun avec son dernier usage et la présence
+ * de son veilleur de notifications.
+ */
+export declare function listRequests(store: Store, userId: string, spaceId: string, now?: Date): RequestListResponse;
+/** Annule une action de l'agent. */
+export declare function undoAction(store: Store, userId: string, actionId: string): RequestView;
+/** Annule toutes les actions non annulées d'un lot, de la plus récente à la plus ancienne : tout le lot ou rien. */
+export declare function undoRequest(store: Store, userId: string, requestId: string): RequestView;

package/dist/src/core/requests.js

@@ -0,0 +1,240 @@
+import { InvariantError, NotFoundError, OrganizerError } from "./errors.js";
+import { requireMember } from "./spaces.js";
+import { requireTask } from "./tasks.js";
+import { undoAgentAction } from "./history.js";
+import { taskIdOfAction } from "./snapshots.js";
+import { tokenState } from "./agent-tokens.js";
+/**
+ * File de l'agent vue de la GUI : dépôt d'une demande, modification et
+ * annulation tant qu'elle attend, libération d'une demande prise, liste par
+ * espace, annulation des actions de l'agent.
+ *
+ * Une demande vise l'espace où elle est écrite. Droits : les membres de cet
+ * espace la voient, la modifient et l'annulent tant qu'elle est en attente,
+ * la libèrent quand l'agent l'a prise, voient et annulent les actions de son
+ * lot. Les droits sont vérifiés dans la transaction de l'écriture.
+ */
+/** Nombre maximal de demandes renvoyées pour un espace. */
+export const REQUESTS_PAGE_SIZE = 200;
+const asUser = (userId) => ({ type: "user", userId });
+function userName(store, userId) {
+    if (userId === null)
+        return null;
+    const user = store.findUser(userId);
+    return user ? (user.displayName ?? user.email) : null;
+}
+// --- Vues -----------------------------------------------------------------------
+/** Jeton d'agent désigné par son nom et celui de son propriétaire. */
+function agentRef(store, token) {
+    return { tokenId: token.id, name: token.name, ownerName: userName(store, token.userId) ?? "" };
+}
+/** Libellé de la tâche concernée par une action : `ORG-41`, « Idée » pour une idée. */
+function actionLabel(store, action) {
+    if (action.entityType === "idea")
+        return "Idée";
+    if (action.entityType === "task") {
+        const snapshot = (action.after ?? action.before);
+        const space = store.findSpace(snapshot.spaceId);
+        return space ? `${space.keyPrefix}-${snapshot.number}` : "";
+    }
+    const taskId = taskIdOfAction(action);
+    const task = taskId === null ? null : store.findTask(taskId);
+    return task ? `${store.getSpace(task.spaceId).keyPrefix}-${task.number}` : "";
+}
+export function actionView(store, action) {
+    const taskId = taskIdOfAction(action);
+    return {
+        id: action.id,
+        seq: action.seq,
+        entityType: action.entityType,
+        operation: action.operation,
+        label: actionLabel(store, action),
+        summary: action.summary,
+        taskId: taskId !== null && store.findTask(taskId) ? taskId : null,
+        createdAt: action.createdAt,
+        undoneAt: action.undoneAt,
+        undoneByName: userName(store, action.undoneBy),
+    };
+}
+const RESULT_WORDS = [
+    ["ok", "OK"],
+    ["ko", "KO"],
+    ["blocked", "bloqué"],
+];
+/** Ligne d'une demande dans la file. */
+function requestTitle(store, request) {
+    const task = request.contextTaskId === null ? null : store.findTask(request.contextTaskId);
+    if (request.kind === "test_review" && task) {
+        const key = `${store.getSpace(task.spaceId).keyPrefix}-${task.number}`;
+        const results = store.listTestResults(task.id).filter((result) => result.testerId === request.authorId);
+        const counts = RESULT_WORDS.map(([value, word]) => [results.filter((result) => result.result === value).length, word]).filter(([n]) => n > 0);
+        return counts.length > 0 ? `Review de test ${key} : ${counts.map(([n, word]) => `${n} ${word}`).join(", ")}` : `Review de test ${key}`;
+    }
+    if (request.kind === "idea_promotion") {
+        const idea = request.contextIdeaId === null ? null : store.findIdea(request.contextIdeaId);
+        return idea ? `Promouvoir l'idée « ${idea.text.trim().split(/\r?\n/)[0]} »` : request.text;
+    }
+    return request.text;
+}
+export function requestView(store, userId, request) {
+    const author = store.getUser(request.authorId);
+    const target = store.getSpace(request.targetSpaceId);
+    const task = request.contextTaskId === null ? null : store.findTask(request.contextTaskId);
+    const member = store.isMember(request.targetSpaceId, userId);
+    const actions = member ? store.listAgentActions(request.id).map((action) => actionView(store, action)) : [];
+    const claimer = request.claimedByTokenId === null ? null : store.findAgentToken(request.claimedByTokenId);
+    return {
+        id: request.id,
+        kind: request.kind,
+        status: request.status,
+        text: request.text,
+        title: requestTitle(store, request),
+        authorId: author.id,
+        authorName: author.displayName ?? author.email,
+        authorEmail: author.email,
+        targetSpaceId: target.id,
+        targetSpaceName: target.name,
+        contextTask: task ? { id: task.id, key: `${store.getSpace(task.spaceId).keyPrefix}-${task.number}`, title: task.title } : null,
+        reply: request.reply,
+        failureReason: request.failureReason,
+        createdAt: request.createdAt,
+        updatedAt: request.updatedAt,
+        claimedAt: request.claimedAt,
+        agent: claimer ? agentRef(store, claimer) : null,
+        completedAt: request.completedAt,
+        cancelledByName: userName(store, request.cancelledBy),
+        canEdit: request.status === "pending" && member,
+        canRelease: request.status === "processing" && member,
+        canUndo: member && (request.status === "done" || request.status === "failed"),
+        actions,
+    };
+}
+// --- Demandes -------------------------------------------------------------------
+/** Demande visible par l'utilisateur : membre de son espace. */
+function requireVisibleRequest(store, userId, requestId) {
+    const request = store.findAgentRequest(requestId);
+    if (!request || !store.isMember(request.targetSpaceId, userId)) {
+        throw new NotFoundError("Demande introuvable, ou vous n'êtes pas membre de l'espace où elle a été écrite.");
+    }
+    return request;
+}
+const EDIT_ACTIONS = {
+    edit: "Impossible de modifier cette demande",
+    cancel: "Impossible d'annuler cette demande",
+};
+/** Demande en attente qu'un membre de son espace modifie ou annule. */
+function requireEditableRequest(store, userId, requestId, action) {
+    const request = requireVisibleRequest(store, userId, requestId);
+    const impossible = EDIT_ACTIONS[action];
+    if (request.status !== "pending") {
+        const why = request.status === "cancelled" ? "elle est annulée" : "l'agent l'a déjà prise";
+        throw new InvariantError(`${impossible} : ${why}.`);
+    }
+    return request;
+}
+/**
+ * Dépose une demande de l'utilisateur, écrite dans l'espace `spaceId`, qui
+ * est aussi l'espace où l'agent agira. La tâche de contexte appartient à cet
+ * espace ; une promotion d'idée porte une idée de cet espace.
+ */
+export function createRequest(store, userId, spaceId, input) {
+    const request = store.mutate(asUser(userId), (tx) => {
+        requireMember(tx.store, spaceId, userId);
+        const contextTaskId = input.contextTaskId ?? null;
+        if (contextTaskId !== null) {
+            const { task } = requireTask(tx.store, contextTaskId, userId);
+            if (task.spaceId !== spaceId)
+                throw new OrganizerError("La tâche de contexte doit appartenir à l'espace où la demande est écrite.");
+        }
+        const contextIdeaId = input.contextIdeaId ?? null;
+        if (input.kind === "idea_promotion") {
+            const idea = contextIdeaId === null ? null : tx.store.findIdea(contextIdeaId);
+            if (!idea || idea.spaceId !== spaceId)
+                throw new OrganizerError("Une promotion d'idée porte une idée de l'espace où elle est demandée.");
+        }
+        return tx.createAgentRequest({ targetSpaceId: spaceId, kind: input.kind, text: input.text, contextTaskId, contextIdeaId });
+    });
+    return requestView(store, userId, request);
+}
+export function updateRequest(store, userId, requestId, text) {
+    const request = store.mutate(asUser(userId), (tx) => {
+        requireEditableRequest(tx.store, userId, requestId, "edit");
+        return tx.updateAgentRequestText(requestId, text);
+    });
+    return requestView(store, userId, request);
+}
+export function cancelRequest(store, userId, requestId) {
+    const request = store.mutate(asUser(userId), (tx) => {
+        requireEditableRequest(tx.store, userId, requestId, "cancel");
+        return tx.cancelAgentRequest(requestId);
+    });
+    return requestView(store, userId, request);
+}
+/**
+ * Libère une demande que l'agent a prise sans la terminer : elle redevient
+ * `pending` et un agent pourra la reprendre. Les actions déjà faites restent
+ * dans son lot. Réservé aux membres de l'espace cible.
+ */
+export function releaseRequest(store, userId, requestId) {
+    const request = store.mutate(asUser(userId), (tx) => {
+        const request = requireVisibleRequest(tx.store, userId, requestId);
+        if (request.status !== "processing") {
+            throw new InvariantError("Seule une demande en cours de traitement se libère : celle-ci n'a pas été prise par l'agent, ou elle est terminée.");
+        }
+        return tx.releaseAgentRequest(requestId);
+    });
+    return requestView(store, userId, request);
+}
+export function getRequest(store, userId, requestId) {
+    return requestView(store, userId, requireVisibleRequest(store, userId, requestId));
+}
+/**
+ * Demandes d'un espace, avec le nombre de demandes en attente et les jetons
+ * actifs qui couvrent l'espace, chacun avec son dernier usage et la présence
+ * de son veilleur de notifications.
+ */
+export function listRequests(store, userId, spaceId, now = new Date()) {
+    requireMember(store, spaceId, userId);
+    const requests = store.listAgentRequestsOfSpace(spaceId, REQUESTS_PAGE_SIZE).map((request) => requestView(store, userId, request));
+    const agents = store
+        .listAgentTokensOfSpace(spaceId)
+        .filter((token) => tokenState(store, token, now) === "active")
+        .map((token) => ({ ...agentRef(store, token), lastUsedAt: token.lastUsedAt, listening: store.watchers.status(token.id).armed }));
+    return { requests, pendingCount: store.countPendingRequestsOfSpace(spaceId), agents };
+}
+// --- Annulation -----------------------------------------------------------------
+/**
+ * Demande visible dont l'utilisateur peut annuler les actions : l'agent l'a
+ * terminée. Les membres de son espace (le propriétaire seul pour un espace
+ * personnel) annulent ses actions.
+ */
+function requireUndoableRequest(request) {
+    if (request.status === "processing")
+        throw new InvariantError("L'agent traite encore cette demande : attendez qu'il ait terminé pour annuler ses actions.");
+}
+/** Annule une action de l'agent. */
+export function undoAction(store, userId, actionId) {
+    const requestId = store.mutate(asUser(userId), (tx) => {
+        const action = tx.store.findAgentAction(actionId);
+        if (!action)
+            throw new NotFoundError("Action introuvable.");
+        const request = requireVisibleRequest(tx.store, userId, action.requestId);
+        requireUndoableRequest(request);
+        undoAgentAction(tx, action);
+        return request.id;
+    });
+    return requestView(store, userId, store.getAgentRequest(requestId));
+}
+/** Annule toutes les actions non annulées d'un lot, de la plus récente à la plus ancienne : tout le lot ou rien. */
+export function undoRequest(store, userId, requestId) {
+    store.mutate(asUser(userId), (tx) => {
+        const request = requireVisibleRequest(tx.store, userId, requestId);
+        requireUndoableRequest(request);
+        const remaining = tx.store.listAgentActions(requestId).filter((action) => action.undoneAt === null);
+        if (remaining.length === 0)
+            throw new InvariantError("Toutes les actions de ce lot sont déjà annulées.");
+        for (const action of remaining.reverse())
+            undoAgentAction(tx, tx.store.getAgentAction(action.id));
+    });
+    return requestView(store, userId, store.getAgentRequest(requestId));
+}

package/dist/src/core/snapshots.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import type { Store } from "./store.js";
+import type { EntityType } from "../../shared/schemas/enums.schema.js";
+import { type AgentAction, type ChecklistItem, type Comment, type Idea, type TaskSnapshot } from "../../shared/schemas/entities.schema.js";
+/** Instantanés des entités que l'agent modifie : l'état avant et après chaque action de son lot. */
+/** Point de vérification avec les résultats saisis dessus. */
+export declare const CheckpointSnapshotSchema: z.ZodObject<{
+    id: z.ZodString;
+    taskId: z.ZodString;
+    text: z.ZodString;
+    position: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        checkpointId: z.ZodString;
+        testerId: z.ZodString;
+        result: z.ZodEnum<{
+            blocked: "blocked";
+            ko: "ko";
+            ok: "ok";
+            untested: "untested";
+        }>;
+        comment: z.ZodString;
+        updatedAt: z.ZodISODateTime;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CheckpointSnapshot = z.infer<typeof CheckpointSnapshotSchema>;
+/** Entités dont l'agent enregistre l'état avant et après chaque action. */
+export type TrackedEntityType = "task" | "checklist_item" | "test_checkpoint" | "comment" | "idea";
+export declare function isTracked(entityType: EntityType): entityType is TrackedEntityType;
+/** Instantané courant d'une entité, ou null si elle n'existe pas. */
+export declare function snapshotOf(store: Store, entityType: TrackedEntityType, entityId: string): TaskSnapshot | ChecklistItem | CheckpointSnapshot | Comment | Idea | null;
+/** Tâche concernée par une action : la tâche elle-même, ou celle qui porte l'élément ; null pour une idée. */
+export declare function taskIdOfAction(action: Pick<AgentAction, "entityType" | "entityId" | "before" | "after">): string | null;

package/dist/src/core/snapshots.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { TestCheckpointSchema, TestResultSchema } from "../../shared/schemas/entities.schema.js";
+/** Instantanés des entités que l'agent modifie : l'état avant et après chaque action de son lot. */
+/** Point de vérification avec les résultats saisis dessus. */
+export const CheckpointSnapshotSchema = TestCheckpointSchema.extend({ results: z.array(TestResultSchema) });
+const TRACKED = new Set(["task", "checklist_item", "test_checkpoint", "comment", "idea"]);
+export function isTracked(entityType) {
+    return TRACKED.has(entityType);
+}
+/** Instantané courant d'une entité, ou null si elle n'existe pas. */
+export function snapshotOf(store, entityType, entityId) {
+    switch (entityType) {
+        case "task":
+            return store.findTask(entityId) ? store.taskSnapshot(entityId) : null;
+        case "checklist_item":
+            return store.findChecklistItem(entityId);
+        case "test_checkpoint": {
+            const checkpoint = store.findCheckpoint(entityId);
+            if (!checkpoint)
+                return null;
+            return { ...checkpoint, results: store.listTestResults(checkpoint.taskId).filter((result) => result.checkpointId === entityId) };
+        }
+        case "comment":
+            return store.findComment(entityId);
+        case "idea":
+            return store.findIdea(entityId);
+    }
+}
+/** Tâche concernée par une action : la tâche elle-même, ou celle qui porte l'élément ; null pour une idée. */
+export function taskIdOfAction(action) {
+    if (action.entityType === "task")
+        return action.entityId;
+    const snapshot = (action.after ?? action.before);
+    return typeof snapshot?.taskId === "string" ? snapshot.taskId : null;
+}

package/dist/src/core/spaces.d.ts

@@ -0,0 +1,66 @@
+import type { AttachmentStorage } from "./attachments.js";
+import type { Mailer } from "./mail.js";
+import type { Store } from "./store.js";
+import type { InviteResponse, MembersResponse, ReceivedInvitationsResponse, ResendInvitationResponse, SpaceSummary } from "../../shared/schemas/api.schema.js";
+import type { Membership, Space } from "../../shared/schemas/entities.schema.js";
+/**
+ * Espaces, membres et invitations, avec les droits de la GUI : un membre lit
+ * l'espace ; seul le propriétaire invite, révoque, retire un membre, renomme
+ * ou supprime l'espace ; un membre peut quitter un espace commun ; le
+ * destinataire d'une invitation l'accepte ou la refuse. Les droits sont
+ * vérifiés dans la transaction de l'écriture.
+ */
+/** Dépendances de l'envoi des invitations. */
+export interface InvitationDeps {
+    mailer: Mailer;
+    /** URL publique de la GUI (`ORGANIZER_PUBLIC_URL`), base des liens envoyés par e-mail. */
+    publicUrl: string | undefined;
+    now?: () => Date;
+}
+/** Espace dont `userId` est membre ; un non-membre reçoit la même réponse qu'un espace inexistant. */
+export declare function requireMember(store: Store, spaceId: string, userId: string): {
+    space: Space;
+    membership: Membership;
+};
+/** Espace commun dont `userId` est le propriétaire. */
+export declare function requireOwner(store: Store, spaceId: string, userId: string, action: string): Space;
+/** Espaces de l'utilisateur : son espace personnel d'abord, puis les espaces communs par nom. */
+export declare function listSpaces(store: Store, userId: string): SpaceSummary[];
+/** Crée un espace commun dont l'utilisateur est propriétaire ; le préfixe est dérivé du nom s'il est omis. */
+export declare function createSharedSpace(store: Store, userId: string, input: {
+    name: string;
+    keyPrefix?: string;
+}): SpaceSummary;
+export declare function renameSpace(store: Store, userId: string, spaceId: string, name: string): SpaceSummary;
+/** Supprime un espace commun, son contenu et les fichiers de ses pièces jointes. */
+export declare function deleteSpace(store: Store, storage: AttachmentStorage, userId: string, spaceId: string): void;
+/** Membres (propriétaire d'abord) et invitations en attente d'un espace, pour un de ses membres. */
+export declare function listMembers(store: Store, userId: string, spaceId: string, now?: Date): MembersResponse;
+/** Le propriétaire retire un membre d'un espace commun. */
+export declare function removeMember(store: Store, userId: string, spaceId: string, memberId: string): void;
+/** Un membre quitte un espace commun ; le propriétaire ne le peut pas. */
+export declare function leaveSpace(store: Store, userId: string, spaceId: string): void;
+/**
+ * Le propriétaire invite une adresse. Un compte actif devient membre
+ * directement ; une adresse inconnue reçoit un compte `invited` ; un compte
+ * `invited` reçoit l'invitation en plus des siennes. Dans ces deux derniers
+ * cas, un lien d'activation propre à cette invitation est émis, renvoyé à
+ * l'invitant et envoyé par e-mail ; les liens des autres invitations du compte
+ * restent valables.
+ */
+export declare function inviteToSpace(store: Store, deps: InvitationDeps, userId: string, spaceId: string, rawEmail: string): Promise<InviteResponse>;
+/**
+ * Renvoie une invitation avec une nouvelle échéance. Un compte encore à
+ * activer reçoit un nouveau lien, qui remplace le lien précédent de cette
+ * invitation seulement ; un compte déjà actif retrouve l'invitation dans ses
+ * « Invitations reçues », sans lien.
+ */
+export declare function resendInvitation(store: Store, deps: InvitationDeps, userId: string, spaceId: string, invitationId: string): Promise<ResendInvitationResponse>;
+/** Révoque une invitation ; son lien d'activation ne fonctionne plus. */
+export declare function revokeInvitation(store: Store, userId: string, spaceId: string, invitationId: string): void;
+/** Invitations en attente et non expirées adressées à l'utilisateur, par date. */
+export declare function listReceivedInvitations(store: Store, userId: string, now?: Date): ReceivedInvitationsResponse;
+/** L'utilisateur accepte une invitation qui lui est adressée et rejoint l'espace. */
+export declare function acceptReceivedInvitation(store: Store, userId: string, invitationId: string, now?: Date): SpaceSummary;
+/** L'utilisateur refuse une invitation qui lui est adressée. */
+export declare function declineReceivedInvitation(store: Store, userId: string, invitationId: string): void;