@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/core/agent.js

@@ -0,0 +1,358 @@
+import { ForbiddenError, InvariantError, NotFoundError, OrganizerError } from "./errors.js";
+import { PRIORITY_LABELS, STATUS_LABELS, TYPE_LABELS } from "../../shared/logic/labels.js";
+import { summarizeTest } from "../../shared/logic/test-summary.js";
+export function agentActor(agent, requestId) {
+    return { type: "agent", requestId, tokenId: agent.token.id };
+}
+/**
+ * Exécute `fn` dans une mutation de l'agent pour la demande `requestId`. La
+ * demande et tout ce que `fn` lit sont vérifiés et lus dans la transaction
+ * de l'écriture.
+ */
+export function actFor(store, agent, requestId, fn) {
+    requestOfSpace(store, agent, requestId);
+    return store.mutate(agentActor(agent, requestId), (tx) => fn(tx, actingRequest(tx.store, agent, requestId).space));
+}
+/** Demande de l'espace du jeton ; une demande d'un autre espace est introuvable pour l'agent. */
+export function requestOfSpace(store, agent, requestId) {
+    const request = store.findAgentRequest(requestId);
+    if (!request || request.targetSpaceId !== agent.space.id) {
+        throw new NotFoundError(`Request ${requestId} not found in space "${agent.space.name}". Call list_requests to get valid request ids.`);
+    }
+    return request;
+}
+/**
+ * Demande pour laquelle l'agent veut écrire : elle vise l'espace du jeton,
+ * elle est `processing`, prise par ce jeton, et le propriétaire du jeton est
+ * encore membre de l'espace. Vérifié à chaque appel.
+ */
+export function actingRequest(store, agent, requestId) {
+    const request = requestOfSpace(store, agent, requestId);
+    if (request.status === "pending")
+        throw new InvariantError(`Request ${requestId} is pending: call claim_request on it first.`);
+    if (request.status !== "processing") {
+        throw new InvariantError(`Request ${requestId} is ${request.status}, not processing: it is closed. Call list_requests to pick a pending request.`);
+    }
+    if (request.claimedByTokenId !== agent.token.id) {
+        throw new ForbiddenError(`Request ${requestId} was claimed by another agent token: only that agent can act for it. Call list_requests to pick a pending request.`);
+    }
+    const space = store.getSpace(request.targetSpaceId);
+    if (!store.isMember(space.id, agent.user.id)) {
+        throw new ForbiddenError(`The owner of your agent token is no longer a member of "${space.name}": the agent cannot act there.`);
+    }
+    return { request, space };
+}
+// --- Noms et identifiants ---------------------------------------------------------
+export function userLabel(user) {
+    return user.displayName ?? user.email;
+}
+export function taskKey(store, task) {
+    return `${store.getSpace(task.spaceId).keyPrefix}-${task.number}`;
+}
+const KEY_PATTERN = /^([A-Za-z][A-Za-z0-9]{1,9})-(\d+)$/;
+/** Tâche de l'espace désignée par son identifiant ou sa clé (`ORG-41`). */
+export function resolveTask(store, space, ref) {
+    const trimmed = ref.trim();
+    const key = KEY_PATTERN.exec(trimmed);
+    let task;
+    if (key) {
+        if (key[1].toUpperCase() !== space.keyPrefix) {
+            throw new ForbiddenError(`Task ${trimmed} is not in your space "${space.name}" (its tasks are ${space.keyPrefix}-<number>). You can only act in this space.`);
+        }
+        task = store.findTaskByNumber(space.id, Number(key[2]));
+    }
+    else {
+        task = store.findTask(trimmed);
+        if (task && task.spaceId !== space.id)
+            throw new ForbiddenError(`Task ${trimmed} is not in your space "${space.name}". You can only act in this space.`);
+    }
+    if (!task)
+        throw new NotFoundError(`Task ${trimmed} not found in "${space.name}". Call search_tasks to find it.`);
+    return task;
+}
+/** Idée de l'espace. */
+export function resolveIdea(store, space, ideaId) {
+    const idea = store.findIdea(ideaId.trim());
+    if (!idea)
+        throw new NotFoundError(`Idea ${ideaId} not found. The ideas of your space are listed by claim_request and get_context.`);
+    if (idea.spaceId !== space.id)
+        throw new ForbiddenError(`Idea ${ideaId} is not in your space "${space.name}". You can only act in this space.`);
+    return idea;
+}
+/** Membres de l'espace désignés par leur identifiant ou leur adresse e-mail. */
+export function resolveMembers(store, space, refs) {
+    return refs.map((ref) => {
+        const trimmed = ref.trim();
+        const user = store.findUser(trimmed) ?? store.findUserByEmail(trimmed);
+        if (!user || !store.isMember(space.id, user.id)) {
+            const members = store.listMemberships(space.id).map((m) => {
+                const member = store.getUser(m.userId);
+                return `${userLabel(member)} <${member.email}>`;
+            });
+            throw new InvariantError(`${trimmed} is not a member of "${space.name}". Members: ${members.join(", ")}.`);
+        }
+        return user;
+    });
+}
+// --- Contexte -------------------------------------------------------------------
+/** Ligne compacte d'une tâche : clé, statut, priorité, type, titre, assignés. */
+function taskLine(store, space, task, names) {
+    const assignees = store
+        .listAssigneeIds(task.id)
+        .map((id) => names.get(id) ?? id)
+        .sort((a, b) => a.localeCompare(b));
+    const flags = [task.status, task.priority, ...(task.type === "test" ? ["test"] : [])].join(", ");
+    return `${"  ".repeat(task.depth)}- ${space.keyPrefix}-${task.number} [${flags}] ${task.title}${assignees.length > 0 ? ` — ${assignees.join(", ")}` : ""}`;
+}
+const STATUS_RANK = { todo: 0, doing: 1, review: 2, done: 3 };
+/** Arborescence de l'espace : chaque tâche puis ses sous-tâches, par colonne et rang. */
+export function spaceTree(store, space) {
+    const tasks = store.listTasks(space.id);
+    const names = memberNames(store, space);
+    const children = new Map();
+    for (const task of tasks)
+        children.set(task.parentId, [...(children.get(task.parentId) ?? []), task]);
+    for (const list of children.values())
+        list.sort((a, b) => STATUS_RANK[a.status] - STATUS_RANK[b.status] || a.position - b.position);
+    const lines = [];
+    const walk = (parentId) => {
+        for (const task of children.get(parentId) ?? []) {
+            lines.push(taskLine(store, space, task, names));
+            walk(task.id);
+        }
+    };
+    walk(null);
+    return lines;
+}
+function memberNames(store, space) {
+    return new Map(store.listMemberships(space.id).map((m) => [m.userId, userLabel(store.getUser(m.userId))]));
+}
+/** Membres de l'espace : nom, adresse, rôle et identifiant (pour set_assignees). */
+export function memberLines(store, space) {
+    return store.listMemberships(space.id).map((m) => {
+        const user = store.getUser(m.userId);
+        return `- ${userLabel(user)} <${user.email}> (${m.role}, id ${user.id})`;
+    });
+}
+/** Durée écoulée depuis `iso`, en anglais. */
+export function ago(iso, now = new Date()) {
+    const minutes = Math.floor((now.getTime() - Date.parse(iso)) / 60_000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes} min ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours} h ago`;
+    return `${Math.floor(hours / 24)} d ago`;
+}
+/** Nombre d'idées récentes listées dans le contexte d'une demande. */
+const CONTEXT_IDEAS = 15;
+/** Résumé d'une demande pour list_requests. */
+export function requestLine(store, agent, request) {
+    const author = store.getUser(request.authorId);
+    const task = request.contextTaskId === null ? null : store.findTask(request.contextTaskId);
+    const parts = [`- ${request.id} [${request.status}] ${request.kind} by ${userLabel(author)}, ${ago(request.createdAt)}`];
+    if (request.status === "processing")
+        parts.push(request.claimedByTokenId === agent.token.id ? "claimed by you" : "claimed by another agent");
+    if (task)
+        parts.push(`context ${taskKey(store, task)}`);
+    const text = request.text.trim().replace(/\s+/g, " ");
+    return `${parts.join(" — ")}\n  "${text.length > 200 ? `${text.slice(0, 199)}…` : text}"`;
+}
+/** Ce que l'agent doit faire d'une demande selon son type. */
+const KIND_GUIDANCE = {
+    idea: "An idea to classify: attach it to an existing task or sub-task (checklist item, sub-task, comment), create a new task, or put it in the idea box with create_idea, depending on its priority and nature.",
+    remark: "A remark: do whatever is useful with it (update tasks, add a comment, create a task), then report what you did.",
+    message: "A message to you: answer it and perform the actions it asks for.",
+    test_review: "A test review written by a tester of the context task: feed it back into the existing tasks (status, checklist, comments, priorities) or create a task for each problem found.",
+    idea_promotion: "Promote the context idea into a well-formed task (clear title, description, type, priority, parent if relevant) with promote_idea.",
+};
+/** Contexte complet d'une demande, renvoyé par claim_request. */
+export function requestContext(store, agent, request) {
+    const author = store.getUser(request.authorId);
+    const target = store.getSpace(request.targetSpaceId);
+    const lines = [];
+    lines.push(`Request ${request.id} is now processing (kind: ${request.kind}), claimed by your token.`);
+    lines.push(KIND_GUIDANCE[request.kind]);
+    lines.push("");
+    lines.push(`Author: ${userLabel(author)} <${author.email}> (id ${author.id}).`);
+    lines.push(`You act with the rights of ${userLabel(agent.user)} <${agent.user.email}>, the owner of your token.`);
+    lines.push(`Space: "${target.name}" (${target.kind}, task keys ${target.keyPrefix}-<number>). Act only in this space.`);
+    if (request.contextTaskId !== null) {
+        const task = store.findTask(request.contextTaskId);
+        if (task) {
+            const space = store.getSpace(task.spaceId);
+            lines.push(`Context task: ${space.keyPrefix}-${task.number} "${task.title}" [${task.status}, ${task.priority}${task.type === "test" ? ", test" : ""}] (id ${task.id})${space.id !== target.id ? ` in space "${space.name}" (out of your reach)` : ""}.`);
+            if (task.type === "test" && request.kind === "test_review") {
+                const checkpoints = store.listCheckpoints(task.id);
+                const results = store.listTestResults(task.id).filter((result) => result.testerId === request.authorId);
+                const summary = summarizeTest(checkpoints.map((c) => c.id), results, [request.authorId]);
+                lines.push(`Results of the tester: ${summary.ok} ok, ${summary.ko} ko, ${summary.blocked} blocked, ${summary.untested} untested out of ${summary.total}.`);
+                for (const checkpoint of checkpoints) {
+                    const result = results.find((r) => r.checkpointId === checkpoint.id);
+                    lines.push(`  - [${result?.result ?? "untested"}] ${checkpoint.text}${result?.comment ? ` — ${result.comment}` : ""}`);
+                }
+            }
+        }
+    }
+    if (request.contextIdeaId !== null) {
+        const idea = store.findIdea(request.contextIdeaId);
+        if (idea)
+            lines.push(`Context idea: ${idea.id} "${idea.text}".`);
+    }
+    lines.push("", "Text:", request.text, "");
+    lines.push(...spaceContextLines(store, target));
+    lines.push("", "Next: read with get_task / search_tasks, act with the write tools (pass this request_id), then call complete_request with a short reply in the author's language.");
+    return lines.join("\n");
+}
+/** Idées actives récentes de la boîte à idées d'un espace. */
+export function recentIdeas(store, space) {
+    return store
+        .listIdeas(space.id)
+        .filter((idea) => idea.archivedAt === null && idea.promotedTaskId === null)
+        .slice(0, CONTEXT_IDEAS);
+}
+/** Arbre des tâches, membres et idées récentes d'un espace, pour claim_request et get_context. */
+export function spaceContextLines(store, space) {
+    const lines = [];
+    const tree = spaceTree(store, space);
+    lines.push(`Tasks of "${space.name}" (key [status, priority] title — assignees):`);
+    lines.push(...(tree.length > 0 ? tree : ["(no task yet)"]));
+    lines.push("", "Members:", ...memberLines(store, space));
+    const ideas = recentIdeas(store, space);
+    lines.push("", "Recent ideas in the idea box:");
+    lines.push(...(ideas.length > 0 ? ideas.map((idea) => `- ${idea.id}: "${idea.text.trim().replace(/\s+/g, " ")}" (${ago(idea.createdAt)})`) : ["(none)"]));
+    return lines;
+}
+// --- Données structurées des réponses -----------------------------------------------
+export function spaceData(space) {
+    return { id: space.id, name: space.name, kind: space.kind, keyPrefix: space.keyPrefix };
+}
+export function memberData(store, space) {
+    return store.listMemberships(space.id).map((m) => {
+        const user = store.getUser(m.userId);
+        return { id: user.id, name: userLabel(user), email: user.email, role: m.role };
+    });
+}
+export function taskData(store, task) {
+    const parent = task.parentId === null ? null : store.findTask(task.parentId);
+    return {
+        id: task.id,
+        key: taskKey(store, task),
+        title: task.title,
+        type: task.type,
+        status: task.status,
+        priority: task.priority,
+        depth: task.depth,
+        parentKey: parent ? taskKey(store, parent) : null,
+        assigneeIds: store.listAssigneeIds(task.id),
+        tags: store
+            .listTagIds(task.id)
+            .map((id) => store.findTag(id)?.name ?? id)
+            .sort((a, b) => a.localeCompare(b)),
+    };
+}
+/** Tâches d'un espace dans l'ordre de l'arbre : chaque tâche puis ses sous-tâches, par colonne et rang. */
+export function treeData(store, space) {
+    const tasks = store.listTasks(space.id);
+    const children = new Map();
+    for (const task of tasks)
+        children.set(task.parentId, [...(children.get(task.parentId) ?? []), task]);
+    for (const list of children.values())
+        list.sort((a, b) => STATUS_RANK[a.status] - STATUS_RANK[b.status] || a.position - b.position);
+    const ordered = [];
+    const walk = (parentId) => {
+        for (const task of children.get(parentId) ?? []) {
+            ordered.push(taskData(store, task));
+            walk(task.id);
+        }
+    };
+    walk(null);
+    return ordered;
+}
+export function ideaData(store, idea) {
+    const promoted = idea.promotedTaskId === null ? null : store.findTask(idea.promotedTaskId);
+    return { id: idea.id, text: idea.text, archived: idea.archivedAt !== null, promotedTaskKey: promoted ? taskKey(store, promoted) : null, createdAt: idea.createdAt };
+}
+export function requestData(store, agent, request) {
+    const author = store.getUser(request.authorId);
+    const task = request.contextTaskId === null ? null : store.findTask(request.contextTaskId);
+    return {
+        id: request.id,
+        kind: request.kind,
+        status: request.status,
+        text: request.text,
+        author: { id: author.id, name: userLabel(author), email: author.email },
+        contextTask: task ? { id: task.id, key: taskKey(store, task), title: task.title } : null,
+        contextIdeaId: request.contextIdeaId,
+        createdAt: request.createdAt,
+        claimedAt: request.claimedAt,
+        claimedByThisToken: request.claimedByTokenId === agent.token.id,
+        reply: request.reply,
+        failureReason: request.failureReason,
+    };
+}
+// --- Résumés des actions (affichés dans la GUI, en français) ----------------------
+export function quote(text, max = 60) {
+    const line = text.trim().split(/\r?\n/)[0];
+    return `« ${line.length > max ? `${line.slice(0, max - 1)}…` : line} »`;
+}
+/** Résumé d'une création de tâche. */
+export function createdTaskSummary(store, task) {
+    const what = task.type === "test" ? "Test créé" : task.depth === 0 ? "Tâche créée" : task.depth === 1 ? "Sous-tâche créée" : "Sous-sous-tâche créée";
+    const parent = task.parentId === null ? null : store.findTask(task.parentId);
+    return `${what} : ${quote(task.title)}${parent ? ` sous ${taskKey(store, parent)}` : ""}`;
+}
+/** Résumé des champs changés d'une tâche, et nature de l'opération. */
+export function taskUpdateSummary(store, before, after) {
+    const parts = [];
+    if (before.title !== after.title)
+        parts.push(`Titre ${quote(after.title)}`);
+    if (before.description !== after.description)
+        parts.push("Description modifiée");
+    if (before.status !== after.status)
+        parts.push(`Statut ${STATUS_LABELS[before.status]} → ${STATUS_LABELS[after.status]}`);
+    if (before.priority !== after.priority)
+        parts.push(`Priorité ${PRIORITY_LABELS[before.priority]} → ${PRIORITY_LABELS[after.priority]}`);
+    if (before.type !== after.type)
+        parts.push(`Type ${TYPE_LABELS[before.type]} → ${TYPE_LABELS[after.type]}`);
+    if (before.parentId !== after.parentId) {
+        const parent = after.parentId === null ? null : store.findTask(after.parentId);
+        parts.push(parent ? `Déplacée sous ${taskKey(store, parent)}` : "Remontée au premier niveau");
+    }
+    if (before.testedTaskId !== after.testedTaskId) {
+        const tested = after.testedTaskId === null ? null : store.findTask(after.testedTaskId);
+        parts.push(tested ? `Teste ${taskKey(store, tested)}` : "Tâche testée retirée");
+    }
+    const onlyPlacement = before.title === after.title &&
+        before.description === after.description &&
+        before.priority === after.priority &&
+        before.type === after.type &&
+        before.testedTaskId === after.testedTaskId;
+    if (parts.length === 0 && before.position !== after.position)
+        parts.push("Position changée");
+    return { summary: parts.join(" · ") || "Aucun changement", operation: onlyPlacement ? "move" : "update" };
+}
+/** Résumé d'un changement d'assignés. */
+export function assigneesSummary(store, before, after, test) {
+    const name = (id) => {
+        const user = store.findUser(id);
+        return user ? userLabel(user) : id;
+    };
+    const added = after.filter((id) => !before.includes(id)).map(name);
+    const removed = before.filter((id) => !after.includes(id)).map(name);
+    const parts = [];
+    if (added.length > 0)
+        parts.push(`${test ? "Testeur ajouté" : "Assigné à"} ${added.join(", ")}`);
+    if (removed.length > 0)
+        parts.push(`${test ? "Testeur retiré" : "Désassigné"} : ${removed.join(", ")}`);
+    return parts.join(" · ") || "Assignés inchangés";
+}
+/** Vérifie qu'un texte libre n'est pas vide ; le message dit quoi fournir. */
+export function requireText(value, what) {
+    const text = value.trim();
+    if (text === "")
+        throw new OrganizerError(`The ${what} is empty: provide a non-empty ${what}.`);
+    return text;
+}

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

@@ -0,0 +1,21 @@
+import type { Attachment } from "../../shared/schemas/entities.schema.js";
+/** Sous-répertoire des pièces jointes dans le répertoire de données. */
+export declare const ATTACHMENTS_DIRNAME = "attachments";
+/**
+ * Fichiers des pièces jointes, rangés sous `<dataDir>/attachments/<id>`. La
+ * base enregistre le chemin relatif au répertoire de données.
+ */
+export declare class AttachmentStorage {
+    readonly dataDir: string;
+    constructor(dataDir: string);
+    /** Chemin relatif, enregistré en base, du fichier d'une pièce jointe. */
+    storagePathOf(id: string): string;
+    private absolute;
+    /** Écrit le contenu d'une pièce jointe et renvoie son chemin relatif. */
+    write(id: string, content: Buffer): string;
+    read(attachment: Attachment): Buffer;
+    /** Vrai si le fichier d'une pièce jointe existe. */
+    exists(storagePath: string): boolean;
+    /** Efface les fichiers de pièces jointes supprimées de la base ; un fichier déjà absent est ignoré. */
+    remove(storagePaths: readonly string[]): void;
+}

package/dist/src/core/attachments.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Sous-répertoire des pièces jointes dans le répertoire de données. */
+export const ATTACHMENTS_DIRNAME = "attachments";
+/**
+ * Fichiers des pièces jointes, rangés sous `<dataDir>/attachments/<id>`. La
+ * base enregistre le chemin relatif au répertoire de données.
+ */
+export class AttachmentStorage {
+    dataDir;
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+    }
+    /** Chemin relatif, enregistré en base, du fichier d'une pièce jointe. */
+    storagePathOf(id) {
+        return `${ATTACHMENTS_DIRNAME}/${id}`;
+    }
+    absolute(storagePath) {
+        const resolved = path.resolve(this.dataDir, storagePath);
+        const root = path.resolve(this.dataDir, ATTACHMENTS_DIRNAME) + path.sep;
+        if (!resolved.startsWith(root))
+            throw new Error(`Attachment path ${storagePath} is outside of ${root}.`);
+        return resolved;
+    }
+    /** Écrit le contenu d'une pièce jointe et renvoie son chemin relatif. */
+    write(id, content) {
+        const storagePath = this.storagePathOf(id);
+        fs.mkdirSync(path.join(this.dataDir, ATTACHMENTS_DIRNAME), { recursive: true });
+        fs.writeFileSync(this.absolute(storagePath), content, { flag: "wx" });
+        return storagePath;
+    }
+    read(attachment) {
+        return fs.readFileSync(this.absolute(attachment.storagePath));
+    }
+    /** Vrai si le fichier d'une pièce jointe existe. */
+    exists(storagePath) {
+        return fs.existsSync(this.absolute(storagePath));
+    }
+    /** Efface les fichiers de pièces jointes supprimées de la base ; un fichier déjà absent est ignoré. */
+    remove(storagePaths) {
+        for (const storagePath of storagePaths)
+            fs.rmSync(this.absolute(storagePath), { force: true });
+    }
+}

package/dist/src/core/data-dir.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Répertoire des données : MCP_ORGANIZER_DATA_DIR, puis MCP_DATA_DIR,
+ * puis <racine du package>/.organizer-data.
+ */
+export declare function resolveDataDir(rootDir: string): string;

package/dist/src/core/data-dir.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+/**
+ * Répertoire des données : MCP_ORGANIZER_DATA_DIR, puis MCP_DATA_DIR,
+ * puis <racine du package>/.organizer-data.
+ */
+export function resolveDataDir(rootDir) {
+    const configured = process.env.MCP_ORGANIZER_DATA_DIR?.trim() || process.env.MCP_DATA_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.join(rootDir, ".organizer-data");
+}

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

@@ -0,0 +1,13 @@
+import Database from "better-sqlite3";
+/** Nom du fichier de la base dans le répertoire de données. */
+export declare const DATABASE_FILENAME = "organizer.db";
+/** Attente maximale d'un verrou tenu par un autre processus, en millisecondes. */
+export declare const BUSY_TIMEOUT_MS = 5000;
+/** Chemin de la base dans le répertoire de données. */
+export declare function databasePath(dataDir: string): string;
+/**
+ * Ouvre la base `<dataDir>/organizer.db` : mode WAL (plusieurs processus
+ * lisent et écrivent la même base), clés étrangères actives, attente des
+ * verrous, puis migrations.
+ */
+export declare function openDatabase(dataDir: string): Database.Database;

package/dist/src/core/db.js

@@ -0,0 +1,38 @@
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import path from "node:path";
+import { migrate } from "./migrations.js";
+/** Nom du fichier de la base dans le répertoire de données. */
+export const DATABASE_FILENAME = "organizer.db";
+/** Attente maximale d'un verrou tenu par un autre processus, en millisecondes. */
+export const BUSY_TIMEOUT_MS = 5000;
+/** Chemin de la base dans le répertoire de données. */
+export function databasePath(dataDir) {
+    return path.join(dataDir, DATABASE_FILENAME);
+}
+/**
+ * Ouvre la base `<dataDir>/organizer.db` : mode WAL (plusieurs processus
+ * lisent et écrivent la même base), clés étrangères actives, attente des
+ * verrous, puis migrations.
+ */
+export function openDatabase(dataDir) {
+    fs.mkdirSync(dataDir, { recursive: true });
+    const db = new Database(databasePath(dataDir));
+    try {
+        db.pragma(`busy_timeout = ${BUSY_TIMEOUT_MS}`);
+        const mode = db.pragma("journal_mode = WAL", { simple: true });
+        if (mode !== "wal") {
+            throw new Error(`SQLite refused WAL mode for ${databasePath(dataDir)} (mode: ${String(mode)}). Put the data directory on a local disk.`);
+        }
+        db.pragma("foreign_keys = ON");
+        if (db.pragma("foreign_keys", { simple: true }) !== 1) {
+            throw new Error("SQLite refused to enable foreign keys.");
+        }
+        migrate(db);
+        return db;
+    }
+    catch (err) {
+        db.close();
+        throw err;
+    }
+}

package/dist/src/core/env-file.d.ts

@@ -0,0 +1,11 @@
+export interface EnvFile {
+    path: string;
+    /** Fichier imposé par `--dotenv` : son absence est une erreur. */
+    required: boolean;
+}
+/** Fichier `.env` à relire, d'après la ligne de commande. */
+export declare function resolveEnvFile(argv: readonly string[], rootDir: string): EnvFile;
+/** Arguments de la ligne de commande sans l'option `--dotenv`. */
+export declare function withoutEnvFileFlag(argv: readonly string[]): string[];
+/** Relit le fichier dans `process.env`, en écrasant les valeurs héritées. */
+export declare function loadEnvFile(file: EnvFile): void;

package/dist/src/core/env-file.js

@@ -0,0 +1,36 @@
+import dotenv from "dotenv";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Fichier `.env` relu par le serveur. Ses valeurs priment sur les variables
+ * héritées de la déclaration du MCP.
+ *
+ * `--dotenv=<chemin>` fixe le fichier ; il doit alors exister. Sans cette
+ * option, le serveur lit `<racine du package>/.env` s'il existe.
+ */
+const ENV_FILE_FLAG = "--dotenv=";
+/** Fichier `.env` à relire, d'après la ligne de commande. */
+export function resolveEnvFile(argv, rootDir) {
+    const flags = argv.filter((arg) => arg.startsWith(ENV_FILE_FLAG));
+    if (flags.length > 1)
+        throw new Error("--dotenv is given more than once: pass a single file.");
+    if (flags.length === 0)
+        return { path: path.join(rootDir, ".env"), required: false };
+    const value = flags[0].slice(ENV_FILE_FLAG.length).trim();
+    if (value === "")
+        throw new Error("--dotenv expects a path: --dotenv=<path to a .env file>.");
+    return { path: path.resolve(value), required: true };
+}
+/** Arguments de la ligne de commande sans l'option `--dotenv`. */
+export function withoutEnvFileFlag(argv) {
+    return argv.filter((arg) => !arg.startsWith(ENV_FILE_FLAG));
+}
+/** Relit le fichier dans `process.env`, en écrasant les valeurs héritées. */
+export function loadEnvFile(file) {
+    if (!fs.existsSync(file.path)) {
+        if (file.required)
+            throw new Error(`The file given by --dotenv does not exist: ${file.path}. Create it or fix the path.`);
+        return;
+    }
+    dotenv.config({ path: file.path, override: true, quiet: true });
+}

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

@@ -0,0 +1,24 @@
+/** Erreur métier : son message dit à l'appelant ce qui ne va pas et quoi faire. */
+export declare class OrganizerError extends Error {
+    constructor(message: string);
+}
+/** Entité introuvable. */
+export declare class NotFoundError extends OrganizerError {
+    constructor(message: string);
+}
+/** Mutation refusée parce qu'elle violerait un invariant du modèle. */
+export declare class InvariantError extends OrganizerError {
+    constructor(message: string);
+}
+/** Requête sans session valide, ou identifiants refusés. */
+export declare class UnauthorizedError extends OrganizerError {
+    constructor(message: string);
+}
+/** Action refusée à l'utilisateur connecté par les règles de droits. */
+export declare class ForbiddenError extends OrganizerError {
+    constructor(message: string);
+}
+/** Erreur de configuration : le message suffit, sans pile d'appels. */
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}

package/dist/src/core/errors.js

@@ -0,0 +1,42 @@
+/** Erreur métier : son message dit à l'appelant ce qui ne va pas et quoi faire. */
+export class OrganizerError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "OrganizerError";
+    }
+}
+/** Entité introuvable. */
+export class NotFoundError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "NotFoundError";
+    }
+}
+/** Mutation refusée parce qu'elle violerait un invariant du modèle. */
+export class InvariantError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "InvariantError";
+    }
+}
+/** Requête sans session valide, ou identifiants refusés. */
+export class UnauthorizedError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "UnauthorizedError";
+    }
+}
+/** Action refusée à l'utilisateur connecté par les règles de droits. */
+export class ForbiddenError extends OrganizerError {
+    constructor(message) {
+        super(message);
+        this.name = "ForbiddenError";
+    }
+}
+/** Erreur de configuration : le message suffit, sans pile d'appels. */
+export class ConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ConfigError";
+    }
+}

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

@@ -0,0 +1,34 @@
+import type { Mutation } from "./store.js";
+import { type AgentAction, type TaskSnapshot } from "../../shared/schemas/entities.schema.js";
+/**
+ * Retour à un état antérieur : annulation d'une action de l'agent, après
+ * comparaison de l'état courant de l'entité avec celui que l'action a
+ * laissé, et restauration des champs d'une version de tâche.
+ */
+/** Champs d'une tâche comparés et restaurés par l'historique. */
+declare const TASK_FIELDS: readonly ["title", "description", "status", "priority", "type", "parentId", "testedTaskId"];
+/**
+ * Annule une action de l'agent dans la mutation `tx` (acteur utilisateur).
+ * L'état courant de l'entité doit être celui que l'action a laissé ; sinon le
+ * refus nomme l'auteur de la modification. Une création est supprimée, une
+ * suppression recréée, une modification ramenée à l'état d'avant.
+ */
+export declare function undoAgentAction(tx: Mutation, action: AgentAction): void;
+/** Libellés français des champs restaurables d'une tâche ; « position » est le rang dans une même colonne. */
+export declare const TASK_FIELD_LABELS: Record<(typeof TASK_FIELDS)[number] | "position" | "assigneeIds" | "tagIds", string>;
+/**
+ * Champs qui diffèrent entre deux instantanés de tâche, dans l'ordre des
+ * libellés. La position ne compte que dans une même colonne : un changement
+ * de colonne la change toujours.
+ */
+export declare function changedTaskFields(from: TaskSnapshot, to: TaskSnapshot): (keyof typeof TASK_FIELD_LABELS)[];
+/**
+ * Ramène une tâche aux champs de `target` (titre, description, statut,
+ * priorité, type, parent, tâche testée, position, assignés, tags) et renvoie
+ * les champs changés. La tâche reprend sa position d'alors si elle est
+ * libre ; revenue dans une autre colonne où cette position est prise, elle va
+ * en fin de colonne ; dans sa colonne, une position prise rend la
+ * restauration impossible.
+ */
+export declare function restoreTaskFields(tx: Mutation, taskId: string, target: TaskSnapshot): (keyof typeof TASK_FIELD_LABELS)[];
+export {};