@imenam/mcp-organizer 0.0.0-stage → 1.0.2

package/dist/src/core/task-history.d.ts

@@ -0,0 +1,7 @@
+import type { Store } from "./store.js";
+import type { TaskVersionsResponse } from "../../shared/schemas/agent-api.schema.js";
+/** Historique des versions d'une tâche et restauration d'une version, pour les membres de son espace. */
+/** Versions d'une tâche, de la plus récente à la plus ancienne, avec les champs changés par chacune. */
+export declare function listTaskVersions(store: Store, userId: string, taskId: string): TaskVersionsResponse;
+/** Ramène une tâche à l'état d'une de ses versions ; la restauration crée une nouvelle version. */
+export declare function restoreTaskVersion(store: Store, userId: string, taskId: string, version: number): TaskVersionsResponse;

package/dist/src/core/task-history.js

@@ -0,0 +1,41 @@
+import { InvariantError, NotFoundError } from "./errors.js";
+import { changedTaskFields, restoreTaskFields, TASK_FIELD_LABELS } from "./history.js";
+import { requireTask } from "./tasks.js";
+import { TaskSnapshotSchema } from "../../shared/schemas/entities.schema.js";
+/** Historique des versions d'une tâche et restauration d'une version, pour les membres de son espace. */
+/** Versions d'une tâche, de la plus récente à la plus ancienne, avec les champs changés par chacune. */
+export function listTaskVersions(store, userId, taskId) {
+    requireTask(store, taskId, userId);
+    const versions = store.listVersions("task", taskId);
+    let previous = null;
+    const views = [];
+    versions.forEach((version, index) => {
+        const snapshot = version.snapshot === null ? null : TaskSnapshotSchema.parse(version.snapshot);
+        const actor = store.findUser(version.actorId);
+        const changes = previous === null ? ["Création"] : snapshot === null ? ["Suppression"] : changedTaskFields(previous, snapshot).map((field) => TASK_FIELD_LABELS[field]);
+        views.push({
+            version: version.version,
+            createdAt: version.createdAt,
+            actorType: version.actorType,
+            actorName: actor ? (actor.displayName ?? actor.email) : "Ancien membre",
+            requestId: version.requestId,
+            changes,
+            current: index === versions.length - 1,
+        });
+        previous = snapshot;
+    });
+    return { versions: views.reverse() };
+}
+/** Ramène une tâche à l'état d'une de ses versions ; la restauration crée une nouvelle version. */
+export function restoreTaskVersion(store, userId, taskId, version) {
+    store.mutate({ type: "user", userId }, (tx) => {
+        requireTask(tx.store, taskId, userId);
+        const found = tx.store.findVersion("task", taskId, version);
+        if (!found || found.snapshot === null)
+            throw new NotFoundError(`Version ${version} introuvable pour cette tâche.`);
+        const changed = restoreTaskFields(tx, taskId, TaskSnapshotSchema.parse(found.snapshot));
+        if (changed.length === 0)
+            throw new InvariantError(`La tâche est déjà dans l'état de la version ${version}.`);
+    });
+    return listTaskVersions(store, userId, taskId);
+}

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

@@ -0,0 +1,58 @@
+import { NotFoundError } from "./errors.js";
+import type { AttachmentStorage } from "./attachments.js";
+import type { Store } from "./store.js";
+import type { Space, Task } from "../../shared/schemas/entities.schema.js";
+import type { TaskStatus } from "../../shared/schemas/enums.schema.js";
+import { type AttachmentView, type BoardResponse, type ChangesResponse, type ChecklistItemView, type CommentView, type CreateTaskRequest, type TaskDetailResponse, type TaskFilters, type TaskView, type UpdateTaskRequest, type UploadAttachmentRequest } from "../../shared/schemas/tasks-api.schema.js";
+import type { ApiFile } from "../../shared/schemas/gui-api.schema.js";
+/**
+ * Tâches, checklist, commentaires et pièces jointes, avec les droits de la
+ * GUI : tout membre d'un espace lit et modifie ses tâches ; un non-membre
+ * reçoit la même réponse qu'une tâche inexistante. Les droits sont vérifiés
+ * dans la transaction de l'écriture.
+ */
+/** Nombre maximal de changements renvoyés par un appel de `listChanges`. */
+export declare const CHANGES_PAGE_SIZE = 500;
+/** Tâche d'un espace dont `userId` est membre. */
+export declare function requireTask(store: Store, taskId: string, userId: string): {
+    task: Task;
+    space: Space;
+};
+export declare function notFound(): NotFoundError;
+/** Arbre des tâches d'un espace, filtré, avec ses membres et ses tags. */
+export declare function getBoard(store: Store, userId: string, spaceId: string, filters?: TaskFilters): BoardResponse;
+/** Détail d'une tâche : champs, parents, sous-tâches, checklist, commentaires, pièces jointes. */
+export declare function getTaskDetail(store: Store, userId: string, taskId: string): TaskDetailResponse;
+/**
+ * Changements postérieurs à `since` des espaces de l'utilisateur, et numéro à
+ * repasser au prochain appel. Sans `since`, seul ce numéro est renvoyé : c'est
+ * la position de départ du polling.
+ */
+export declare function listChanges(store: Store, userId: string, since: number | null): ChangesResponse;
+export declare function createTask(store: Store, userId: string, spaceId: string, input: CreateTaskRequest): TaskView;
+export declare function updateTask(store: Store, userId: string, taskId: string, patch: UpdateTaskRequest): TaskView;
+/** Supprime une tâche, ses sous-tâches et les fichiers de leurs pièces jointes. */
+export declare function deleteTask(store: Store, storage: AttachmentStorage, userId: string, taskId: string): void;
+export declare function moveTask(store: Store, userId: string, taskId: string, status: TaskStatus, afterId: string | null): TaskView;
+export declare function setAssignees(store: Store, userId: string, taskId: string, userIds: string[]): TaskView;
+export declare function setTags(store: Store, userId: string, taskId: string, names: string[]): TaskView;
+export declare function addChecklistItem(store: Store, userId: string, taskId: string, text: string): ChecklistItemView;
+export declare function updateChecklistItem(store: Store, userId: string, itemId: string, patch: {
+    text?: string;
+    done?: boolean;
+}): ChecklistItemView;
+export declare function deleteChecklistItem(store: Store, userId: string, itemId: string): void;
+export declare function moveChecklistItem(store: Store, userId: string, itemId: string, afterId: string | null): ChecklistItemView;
+export declare function addComment(store: Store, userId: string, taskId: string, body: string): CommentView;
+export declare function updateComment(store: Store, userId: string, commentId: string, body: string): CommentView;
+export declare function deleteComment(store: Store, userId: string, commentId: string): void;
+/**
+ * Enregistre une pièce jointe : le fichier est écrit sous
+ * `<dataDir>/attachments/<id>`, puis la pièce jointe est créée en base, après
+ * vérification des droits dans la même transaction. Un refus efface le
+ * fichier écrit.
+ */
+export declare function uploadAttachment(store: Store, storage: AttachmentStorage, userId: string, taskId: string, input: UploadAttachmentRequest): AttachmentView;
+/** Contenu d'une pièce jointe, avec son type et son nom. */
+export declare function downloadAttachment(store: Store, storage: AttachmentStorage, userId: string, attachmentId: string): ApiFile;
+export declare function deleteAttachment(store: Store, storage: AttachmentStorage, userId: string, attachmentId: string): void;

package/dist/src/core/tasks.js

@@ -0,0 +1,389 @@
+import { NotFoundError, OrganizerError } from "./errors.js";
+import { newId } from "./ids.js";
+import { requireMember } from "./spaces.js";
+import { MAX_ATTACHMENT_BYTES, } from "../../shared/schemas/tasks-api.schema.js";
+import { summarizeTest } from "../../shared/logic/test-summary.js";
+import { testDetail } from "./test-tasks.js";
+/**
+ * Tâches, checklist, commentaires et pièces jointes, avec les droits de la
+ * GUI : tout membre d'un espace lit et modifie ses tâches ; un non-membre
+ * reçoit la même réponse qu'une tâche inexistante. Les droits sont vérifiés
+ * dans la transaction de l'écriture.
+ */
+/** Nombre maximal de changements renvoyés par un appel de `listChanges`. */
+export const CHANGES_PAGE_SIZE = 500;
+const asUser = (userId) => ({ type: "user", userId });
+// --- Droits ---------------------------------------------------------------------
+/** Tâche d'un espace dont `userId` est membre. */
+export function requireTask(store, taskId, userId) {
+    const task = store.findTask(taskId);
+    if (!task || !store.isMember(task.spaceId, userId))
+        throw notFound();
+    return { task, space: store.getSpace(task.spaceId) };
+}
+export function notFound() {
+    return new NotFoundError("Tâche introuvable, ou vous n'êtes pas membre de son espace.");
+}
+// --- Vues -----------------------------------------------------------------------
+function keyOf(space, task) {
+    return `${space.keyPrefix}-${task.number}`;
+}
+function membersOf(store, spaceId) {
+    return store.listMemberships(spaceId).map((membership) => {
+        const user = store.getUser(membership.userId);
+        return { userId: user.id, displayName: user.displayName, email: user.email };
+    });
+}
+function tagsOf(store, spaceId) {
+    return store.listTags(spaceId).map((tag) => ({ id: tag.id, name: tag.name }));
+}
+const STATUS_ORDER = { todo: 0, doing: 1, review: 2, done: 3 };
+/** Ordre d'affichage : colonne, puis rang dans la colonne. */
+function byColumn(a, b) {
+    return STATUS_ORDER[a.status] - STATUS_ORDER[b.status] || a.position - b.position;
+}
+/** Arbre des tâches d'un espace : nœuds de premier niveau, chacun avec ses sous-tâches. */
+function buildForest(store, space) {
+    const tasks = store.listTasks(space.id);
+    const assignees = new Map();
+    for (const { taskId, userId } of store.listAssignmentsInSpace(space.id))
+        assignees.set(taskId, [...(assignees.get(taskId) ?? []), userId]);
+    const tags = new Map();
+    for (const { taskId, tagId } of store.listTaskTagsInSpace(space.id))
+        tags.set(taskId, [...(tags.get(taskId) ?? []), tagId]);
+    const checkpoints = new Map();
+    for (const { id, taskId } of store.listCheckpointsInSpace(space.id))
+        checkpoints.set(taskId, [...(checkpoints.get(taskId) ?? []), id]);
+    const results = new Map();
+    for (const result of store.listTestResultsInSpace(space.id))
+        results.set(result.taskId, [...(results.get(result.taskId) ?? []), result]);
+    const byId = new Map();
+    for (const task of tasks) {
+        byId.set(task.id, {
+            id: task.id,
+            key: keyOf(space, task),
+            parentId: task.parentId,
+            depth: task.depth,
+            type: task.type,
+            title: task.title,
+            status: task.status,
+            priority: task.priority,
+            position: task.position,
+            assigneeIds: assignees.get(task.id) ?? [],
+            tagIds: tags.get(task.id) ?? [],
+            subtasks: { done: 0, total: 0 },
+            test: task.type === "test" ? summarizeTest(checkpoints.get(task.id) ?? [], results.get(task.id) ?? [], assignees.get(task.id) ?? []) : null,
+            children: [],
+        });
+    }
+    const roots = [];
+    for (const node of byId.values()) {
+        const parent = node.parentId === null ? null : byId.get(node.parentId);
+        if (parent) {
+            parent.children.push(node);
+            parent.subtasks.total += 1;
+            if (node.status === "done")
+                parent.subtasks.done += 1;
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    for (const node of byId.values())
+        node.children.sort(byColumn);
+    roots.sort(byColumn);
+    return { roots, byId };
+}
+/** Vrai si la tâche répond à tous les filtres. */
+function matches(node, filters) {
+    return ((filters.type === undefined || node.type === filters.type) &&
+        (filters.priority === undefined || node.priority === filters.priority) &&
+        (filters.assignee === undefined || node.assigneeIds.includes(filters.assignee)) &&
+        (filters.tag === undefined || node.tagIds.includes(filters.tag)));
+}
+/** Garde les tâches qui répondent aux filtres ou dont une sous-tâche y répond. */
+function filterTree(nodes, filters) {
+    const kept = [];
+    for (const node of nodes) {
+        const children = filterTree(node.children, filters);
+        if (matches(node, filters) || children.length > 0)
+            kept.push({ ...node, children });
+    }
+    return kept;
+}
+function taskView(store, space, task) {
+    return {
+        id: task.id,
+        key: keyOf(space, task),
+        spaceId: task.spaceId,
+        parentId: task.parentId,
+        depth: task.depth,
+        type: task.type,
+        title: task.title,
+        description: task.description,
+        status: task.status,
+        priority: task.priority,
+        assigneeIds: store.listAssigneeIds(task.id),
+        tagIds: store.listTagIds(task.id),
+        testedTaskId: task.testedTaskId,
+        createdBy: task.createdBy,
+        createdAt: task.createdAt,
+        updatedAt: task.updatedAt,
+        version: task.version,
+    };
+}
+function attachmentView(attachment) {
+    return {
+        id: attachment.id,
+        filename: attachment.filename,
+        mime: attachment.mime,
+        size: attachment.size,
+        uploaderId: attachment.uploaderId,
+        createdAt: attachment.createdAt,
+    };
+}
+// --- Lecture --------------------------------------------------------------------
+/** Arbre des tâches d'un espace, filtré, avec ses membres et ses tags. */
+export function getBoard(store, userId, spaceId, filters = {}) {
+    const { space } = requireMember(store, spaceId, userId);
+    const { roots } = buildForest(store, space);
+    return { spaceId: space.id, members: membersOf(store, space.id), tags: tagsOf(store, space.id), tasks: filterTree(roots, filters) };
+}
+/** Détail d'une tâche : champs, parents, sous-tâches, checklist, commentaires, pièces jointes. */
+export function getTaskDetail(store, userId, taskId) {
+    const { task, space } = requireTask(store, taskId, userId);
+    const { byId } = buildForest(store, space);
+    const ancestors = [];
+    for (let parentId = task.parentId; parentId !== null;) {
+        const parent = store.getTask(parentId);
+        ancestors.unshift({ id: parent.id, key: keyOf(space, parent), title: parent.title });
+        parentId = parent.parentId;
+    }
+    const checklist = store.listChecklist(task.id).map(({ id, text, done, position }) => ({ id, text, done, position }));
+    const comments = store.listComments(task.id).map((comment) => commentView(store, comment));
+    const tested = task.testedTaskId === null ? null : store.findTask(task.testedTaskId);
+    return {
+        task: taskView(store, space, task),
+        ancestors,
+        testedTask: tested ? { id: tested.id, key: keyOf(space, tested), title: tested.title } : null,
+        children: byId.get(task.id).children,
+        checklist,
+        test: task.type === "test" ? testDetail(store, task) : null,
+        comments,
+        attachments: store.listAttachments(task.id).map(attachmentView),
+        members: membersOf(store, space.id),
+        tags: tagsOf(store, space.id),
+        agentEdit: agentEditOf(store, task.id),
+    };
+}
+/** Dernière modification de la tâche quand sa dernière version vient de l'agent et que l'action correspondante n'est pas annulée. */
+function agentEditOf(store, taskId) {
+    const latest = store.listVersions("task", taskId).at(-1);
+    if (!latest || latest.actorType !== "agent" || latest.requestId === null)
+        return null;
+    const action = store.lastLiveAgentActionOn("task", taskId);
+    if (!action || action.requestId !== latest.requestId)
+        return null;
+    return { actionId: action.id, at: latest.createdAt };
+}
+/**
+ * Changements postérieurs à `since` des espaces de l'utilisateur, et numéro à
+ * repasser au prochain appel. Sans `since`, seul ce numéro est renvoyé : c'est
+ * la position de départ du polling.
+ */
+export function listChanges(store, userId, since) {
+    return store.db.transaction(() => {
+        const last = store.lastChangeSeq();
+        if (since === null)
+            return { seq: last, changes: [] };
+        const changes = store.listChangesForUser(userId, since, CHANGES_PAGE_SIZE);
+        const seq = changes.length === CHANGES_PAGE_SIZE ? changes[changes.length - 1].seq : Math.max(last, since);
+        return { seq, changes };
+    })();
+}
+// --- Tâches ---------------------------------------------------------------------
+export function createTask(store, userId, spaceId, input) {
+    const { space, task } = store.mutate(asUser(userId), (tx) => {
+        const { space } = requireMember(tx.store, spaceId, userId);
+        if (input.parentId)
+            requireTask(tx.store, input.parentId, userId);
+        return { space, task: tx.createTask({ spaceId, ...input }) };
+    });
+    return taskView(store, space, store.getTask(task.id));
+}
+export function updateTask(store, userId, taskId, patch) {
+    const space = store.mutate(asUser(userId), (tx) => {
+        const { space } = requireTask(tx.store, taskId, userId);
+        if (patch.parentId)
+            requireTask(tx.store, patch.parentId, userId);
+        if (patch.testedTaskId)
+            requireTask(tx.store, patch.testedTaskId, userId);
+        tx.updateTask(taskId, patch);
+        return space;
+    });
+    return taskView(store, space, store.getTask(taskId));
+}
+/** Supprime une tâche, ses sous-tâches et les fichiers de leurs pièces jointes. */
+export function deleteTask(store, storage, userId, taskId) {
+    const removed = store.mutate(asUser(userId), (tx) => {
+        requireTask(tx.store, taskId, userId);
+        const attachments = tx.store.listAttachmentsInSubtree(taskId);
+        tx.deleteTask(taskId);
+        return attachments;
+    });
+    storage.remove(removed.map((attachment) => attachment.storagePath));
+}
+export function moveTask(store, userId, taskId, status, afterId) {
+    const space = store.mutate(asUser(userId), (tx) => {
+        const { space } = requireTask(tx.store, taskId, userId);
+        tx.moveTask(taskId, status, afterId);
+        return space;
+    });
+    return taskView(store, space, store.getTask(taskId));
+}
+export function setAssignees(store, userId, taskId, userIds) {
+    const space = store.mutate(asUser(userId), (tx) => {
+        const { space } = requireTask(tx.store, taskId, userId);
+        for (const assignee of userIds) {
+            if (!tx.store.isMember(space.id, assignee))
+                throw new OrganizerError(`Seuls les membres de l'espace « ${space.name} » peuvent être assignés.`);
+        }
+        tx.setAssignees(taskId, userIds);
+        return space;
+    });
+    return taskView(store, space, store.getTask(taskId));
+}
+export function setTags(store, userId, taskId, names) {
+    const space = store.mutate(asUser(userId), (tx) => {
+        const { space } = requireTask(tx.store, taskId, userId);
+        tx.setTags(taskId, names);
+        return space;
+    });
+    return taskView(store, space, store.getTask(taskId));
+}
+// --- Checklist ------------------------------------------------------------------
+/** Tâche qui porte un élément de checklist, pour un membre de son espace. */
+function requireChecklistItem(store, itemId, userId) {
+    const item = store.findChecklistItem(itemId);
+    if (!item)
+        throw notFound();
+    requireTask(store, item.taskId, userId);
+    return item;
+}
+export function addChecklistItem(store, userId, taskId, text) {
+    const { id, done, position } = store.mutate(asUser(userId), (tx) => {
+        requireTask(tx.store, taskId, userId);
+        return tx.addChecklistItem(taskId, text);
+    });
+    return { id, text: text.trim(), done, position };
+}
+export function updateChecklistItem(store, userId, itemId, patch) {
+    const { id, text, done, position } = store.mutate(asUser(userId), (tx) => {
+        requireChecklistItem(tx.store, itemId, userId);
+        return tx.updateChecklistItem(itemId, patch);
+    });
+    return { id, text, done, position };
+}
+export function deleteChecklistItem(store, userId, itemId) {
+    store.mutate(asUser(userId), (tx) => {
+        requireChecklistItem(tx.store, itemId, userId);
+        tx.deleteChecklistItem(itemId);
+    });
+}
+export function moveChecklistItem(store, userId, itemId, afterId) {
+    const { id, text, done, position } = store.mutate(asUser(userId), (tx) => {
+        requireChecklistItem(tx.store, itemId, userId);
+        return tx.moveChecklistItem(itemId, afterId);
+    });
+    return { id, text, done, position };
+}
+// --- Commentaires ---------------------------------------------------------------
+function commentView(store, comment) {
+    const author = store.getUser(comment.authorId);
+    return {
+        id: comment.id,
+        authorId: comment.authorId,
+        authorName: author.displayName ?? author.email,
+        body: comment.body,
+        createdAt: comment.createdAt,
+        editedAt: comment.editedAt,
+        byAgent: comment.requestId !== null,
+    };
+}
+function requireComment(store, commentId, userId) {
+    const comment = store.findComment(commentId);
+    if (!comment)
+        throw notFound();
+    requireTask(store, comment.taskId, userId);
+    return comment;
+}
+export function addComment(store, userId, taskId, body) {
+    const comment = store.mutate(asUser(userId), (tx) => {
+        requireTask(tx.store, taskId, userId);
+        return tx.addComment(taskId, body);
+    });
+    return commentView(store, comment);
+}
+export function updateComment(store, userId, commentId, body) {
+    const comment = store.mutate(asUser(userId), (tx) => {
+        requireComment(tx.store, commentId, userId);
+        return tx.updateComment(commentId, body);
+    });
+    return commentView(store, comment);
+}
+export function deleteComment(store, userId, commentId) {
+    store.mutate(asUser(userId), (tx) => {
+        requireComment(tx.store, commentId, userId);
+        tx.deleteComment(commentId);
+    });
+}
+// --- Pièces jointes -------------------------------------------------------------
+/** Taille lisible d'un nombre d'octets, en Mo. */
+function megabytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+/**
+ * Enregistre une pièce jointe : le fichier est écrit sous
+ * `<dataDir>/attachments/<id>`, puis la pièce jointe est créée en base, après
+ * vérification des droits dans la même transaction. Un refus efface le
+ * fichier écrit.
+ */
+export function uploadAttachment(store, storage, userId, taskId, input) {
+    requireTask(store, taskId, userId);
+    const content = Buffer.from(input.contentBase64, "base64");
+    if (content.length > MAX_ATTACHMENT_BYTES) {
+        throw new OrganizerError(`Fichier trop volumineux (${megabytes(content.length)}) : une pièce jointe ne dépasse pas ${megabytes(MAX_ATTACHMENT_BYTES)}.`);
+    }
+    const id = newId();
+    const storagePath = storage.write(id, content);
+    try {
+        const attachment = store.mutate(asUser(userId), (tx) => {
+            requireTask(tx.store, taskId, userId);
+            return tx.createAttachment({ id, taskId, filename: input.filename, mime: input.mime, size: content.length, storagePath });
+        });
+        return attachmentView(attachment);
+    }
+    catch (err) {
+        storage.remove([storagePath]);
+        throw err;
+    }
+}
+function requireAttachment(store, attachmentId, userId) {
+    const attachment = store.findAttachment(attachmentId);
+    if (!attachment)
+        throw notFound();
+    requireTask(store, attachment.taskId, userId);
+    return attachment;
+}
+/** Contenu d'une pièce jointe, avec son type et son nom. */
+export function downloadAttachment(store, storage, userId, attachmentId) {
+    const attachment = requireAttachment(store, attachmentId, userId);
+    return { contentBase64: storage.read(attachment).toString("base64"), mime: attachment.mime, filename: attachment.filename };
+}
+export function deleteAttachment(store, storage, userId, attachmentId) {
+    const removed = store.mutate(asUser(userId), (tx) => {
+        requireAttachment(tx.store, attachmentId, userId);
+        return tx.deleteAttachment(attachmentId);
+    });
+    storage.remove([removed.storagePath]);
+}

package/dist/src/core/test-tasks.d.ts

@@ -0,0 +1,19 @@
+import type { Store } from "./store.js";
+import type { Task } from "../../shared/schemas/entities.schema.js";
+import type { TestResultValue } from "../../shared/schemas/enums.schema.js";
+import type { CheckpointView, ReviewDraftResponse, SubmittedReviewView, TestDetail, TestResultView } from "../../shared/schemas/tasks-api.schema.js";
+/** Points de vérification, bilan, résultats et brouillon de chaque testeur, anciens testeurs, reviews soumises. */
+export declare function testDetail(store: Store, task: Task): TestDetail;
+export declare function addCheckpoint(store: Store, userId: string, taskId: string, text: string): CheckpointView;
+export declare function updateCheckpoint(store: Store, userId: string, checkpointId: string, text: string): CheckpointView;
+export declare function deleteCheckpoint(store: Store, userId: string, checkpointId: string): void;
+export declare function moveCheckpoint(store: Store, userId: string, checkpointId: string, afterId: string | null): CheckpointView;
+/** Résultat de l'utilisateur, testeur de la tâche, sur un point. */
+export declare function setTestResult(store: Store, userId: string, checkpointId: string, patch: {
+    result?: TestResultValue;
+    comment?: string;
+}): TestResultView;
+/** Enregistre le brouillon de review de l'utilisateur, testeur de la tâche. */
+export declare function saveReviewDraft(store: Store, userId: string, taskId: string, text: string): ReviewDraftResponse;
+/** Soumet la review de l'utilisateur : elle est figée et une demande `test_review` part dans la file de l'agent. */
+export declare function submitReview(store: Store, userId: string, taskId: string, text: string): SubmittedReviewView;

package/dist/src/core/test-tasks.js

@@ -0,0 +1,135 @@
+import { ForbiddenError, InvariantError } from "./errors.js";
+import { notFound, requireTask } from "./tasks.js";
+import { summarizeTest } from "../../shared/logic/test-summary.js";
+/**
+ * Tâches de test, avec les droits de la GUI : tout membre de l'espace gère
+ * les points de vérification ; seul un testeur (assigné de la tâche) saisit
+ * ses propres résultats, son brouillon de review et la soumet. Les résultats
+ * et reviews d'un ancien testeur restent affichés, en lecture seule. Les
+ * droits sont vérifiés dans la transaction de l'écriture.
+ */
+const asUser = (userId) => ({ type: "user", userId });
+// --- Vues -----------------------------------------------------------------------
+function testerName(store, userId) {
+    const user = store.findUser(userId);
+    return user ? (user.displayName ?? user.email) : "Ancien membre";
+}
+function submittedReviewView(store, review) {
+    const request = review.requestId === null ? null : store.findAgentRequest(review.requestId);
+    return {
+        id: review.id,
+        testerId: review.testerId,
+        testerName: testerName(store, review.testerId),
+        text: review.text,
+        submittedAt: review.submittedAt,
+        requestId: review.requestId,
+        requestStatus: request?.status ?? null,
+    };
+}
+function resultView({ checkpointId, result, comment, updatedAt }) {
+    return { checkpointId, result, comment, updatedAt };
+}
+/** Points de vérification, bilan, résultats et brouillon de chaque testeur, anciens testeurs, reviews soumises. */
+export function testDetail(store, task) {
+    const checkpoints = store.listCheckpoints(task.id).map(({ id, text, position }) => ({ id, text, position }));
+    const testerIds = store.listAssigneeIds(task.id);
+    const results = store.listTestResults(task.id);
+    const reviews = store.listTestReviews(task.id);
+    const testers = testerIds.map((userId) => ({
+        userId,
+        results: results.filter((result) => result.testerId === userId).map(resultView),
+        draft: reviews.find((review) => review.testerId === userId && review.submittedAt === null)?.text ?? "",
+    }));
+    const pastIds = [...new Set(results.map((result) => result.testerId))].filter((userId) => !testerIds.includes(userId));
+    const pastTesters = pastIds
+        .map((userId) => ({ userId, name: testerName(store, userId), results: results.filter((result) => result.testerId === userId).map(resultView) }))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    return {
+        checkpoints,
+        summary: summarizeTest(checkpoints.map((checkpoint) => checkpoint.id), results, testerIds),
+        testers,
+        pastTesters,
+        reviews: reviews
+            .filter((review) => review.submittedAt !== null)
+            .reverse()
+            .map((review) => submittedReviewView(store, review)),
+    };
+}
+// --- Droits ---------------------------------------------------------------------
+/** Tâche de test d'un espace dont `userId` est membre. */
+function requireTestTask(store, taskId, userId) {
+    const { task } = requireTask(store, taskId, userId);
+    if (task.type !== "test")
+        throw new InvariantError("Cette tâche n'est pas une tâche de test : elle a une checklist, pas de points de vérification.");
+    return task;
+}
+/** Tâche de test dont `userId` est testeur. */
+function requireTester(store, taskId, userId) {
+    const task = requireTestTask(store, taskId, userId);
+    if (!store.listAssigneeIds(taskId).includes(userId)) {
+        throw new ForbiddenError("Seuls les testeurs de la tâche saisissent des résultats et une review : assignez-vous d'abord la tâche.");
+    }
+    return task;
+}
+/** Point de vérification d'une tâche de test dont `userId` est membre de l'espace. */
+function requireCheckpoint(store, checkpointId, userId) {
+    const checkpoint = store.findCheckpoint(checkpointId);
+    if (!checkpoint)
+        throw notFound();
+    requireTestTask(store, checkpoint.taskId, userId);
+    return checkpoint;
+}
+// --- Points de vérification -----------------------------------------------------
+export function addCheckpoint(store, userId, taskId, text) {
+    const { id, text: saved, position } = store.mutate(asUser(userId), (tx) => {
+        requireTestTask(tx.store, taskId, userId);
+        return tx.addCheckpoint(taskId, text);
+    });
+    return { id, text: saved, position };
+}
+export function updateCheckpoint(store, userId, checkpointId, text) {
+    const { id, text: saved, position } = store.mutate(asUser(userId), (tx) => {
+        requireCheckpoint(tx.store, checkpointId, userId);
+        return tx.updateCheckpoint(checkpointId, text);
+    });
+    return { id, text: saved, position };
+}
+export function deleteCheckpoint(store, userId, checkpointId) {
+    store.mutate(asUser(userId), (tx) => {
+        requireCheckpoint(tx.store, checkpointId, userId);
+        tx.deleteCheckpoint(checkpointId);
+    });
+}
+export function moveCheckpoint(store, userId, checkpointId, afterId) {
+    const { id, text, position } = store.mutate(asUser(userId), (tx) => {
+        requireCheckpoint(tx.store, checkpointId, userId);
+        return tx.moveCheckpoint(checkpointId, afterId);
+    });
+    return { id, text, position };
+}
+// --- Résultats et reviews -------------------------------------------------------
+/** Résultat de l'utilisateur, testeur de la tâche, sur un point. */
+export function setTestResult(store, userId, checkpointId, patch) {
+    const { result, comment, updatedAt } = store.mutate(asUser(userId), (tx) => {
+        const checkpoint = requireCheckpoint(tx.store, checkpointId, userId);
+        requireTester(tx.store, checkpoint.taskId, userId);
+        return tx.setTestResult(checkpointId, patch);
+    });
+    return { checkpointId, result, comment, updatedAt };
+}
+/** Enregistre le brouillon de review de l'utilisateur, testeur de la tâche. */
+export function saveReviewDraft(store, userId, taskId, text) {
+    const review = store.mutate(asUser(userId), (tx) => {
+        requireTester(tx.store, taskId, userId);
+        return tx.saveReviewDraft(taskId, text);
+    });
+    return { draft: review.text };
+}
+/** Soumet la review de l'utilisateur : elle est figée et une demande `test_review` part dans la file de l'agent. */
+export function submitReview(store, userId, taskId, text) {
+    const { review } = store.mutate(asUser(userId), (tx) => {
+        requireTester(tx.store, taskId, userId);
+        return tx.submitReview(taskId, text);
+    });
+    return submittedReviewView(store, review);
+}