@imenam/mcp-organizer 0.0.0-stage → 1.0.1

package/dist/src/core/migrations.js

@@ -0,0 +1,404 @@
+/**
+ * Migrations SQL versionnées. La migration d'indice i amène la base à la
+ * version i + 1 (`PRAGMA user_version`). Une migration publiée ne se modifie
+ * plus : toute évolution du schéma s'ajoute en fin de liste.
+ */
+export const MIGRATIONS = [
+    `
+  CREATE TABLE users (
+    id            TEXT PRIMARY KEY,
+    email         TEXT NOT NULL UNIQUE CHECK (email = lower(email) AND email <> ''),
+    display_name  TEXT,
+    password_hash TEXT,
+    status        TEXT NOT NULL CHECK (status IN ('invited', 'active', 'disabled')),
+    created_at    TEXT NOT NULL,
+    CHECK (status = 'invited' OR display_name IS NOT NULL)
+  );
+
+  CREATE TABLE access_links (
+    id         TEXT PRIMARY KEY,
+    user_id    TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    purpose    TEXT NOT NULL CHECK (purpose IN ('invite', 'reset')),
+    token_hash TEXT NOT NULL UNIQUE,
+    expires_at TEXT NOT NULL,
+    used_at    TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX access_links_user ON access_links(user_id);
+
+  CREATE TABLE sessions (
+    id_hash    TEXT PRIMARY KEY,
+    user_id    TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    created_at TEXT NOT NULL,
+    expires_at TEXT NOT NULL
+  );
+  CREATE INDEX sessions_user ON sessions(user_id);
+  CREATE INDEX sessions_expiry ON sessions(expires_at);
+
+  CREATE TABLE user_settings (
+    user_id              TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
+    agent_scope          TEXT NOT NULL DEFAULT 'personal' CHECK (agent_scope IN ('personal', 'current_space')),
+    notify_assign_app    INTEGER NOT NULL DEFAULT 1 CHECK (notify_assign_app IN (0, 1)),
+    notify_assign_email  INTEGER NOT NULL DEFAULT 1 CHECK (notify_assign_email IN (0, 1)),
+    notify_comment_app   INTEGER NOT NULL DEFAULT 1 CHECK (notify_comment_app IN (0, 1)),
+    notify_comment_email INTEGER NOT NULL DEFAULT 1 CHECK (notify_comment_email IN (0, 1))
+  );
+
+  CREATE TABLE spaces (
+    id               TEXT PRIMARY KEY,
+    name             TEXT NOT NULL CHECK (name <> ''),
+    kind             TEXT NOT NULL CHECK (kind IN ('personal', 'shared')),
+    owner_id         TEXT NOT NULL REFERENCES users(id),
+    key_prefix       TEXT NOT NULL,
+    next_task_number INTEGER NOT NULL DEFAULT 1 CHECK (next_task_number >= 1),
+    created_at       TEXT NOT NULL
+  );
+  CREATE UNIQUE INDEX spaces_one_personal_per_user ON spaces(owner_id) WHERE kind = 'personal';
+
+  CREATE TABLE memberships (
+    space_id  TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    user_id   TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    role      TEXT NOT NULL CHECK (role IN ('owner', 'member')),
+    joined_at TEXT NOT NULL,
+    PRIMARY KEY (space_id, user_id)
+  );
+  CREATE INDEX memberships_user ON memberships(user_id);
+
+  CREATE TABLE invitations (
+    id          TEXT PRIMARY KEY,
+    space_id    TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    email       TEXT NOT NULL CHECK (email = lower(email)),
+    token_hash  TEXT NOT NULL UNIQUE,
+    invited_by  TEXT NOT NULL REFERENCES users(id),
+    created_at  TEXT NOT NULL,
+    expires_at  TEXT NOT NULL,
+    accepted_at TEXT,
+    revoked_at  TEXT
+  );
+  CREATE INDEX invitations_space ON invitations(space_id);
+  CREATE INDEX invitations_email ON invitations(email);
+
+  CREATE TABLE tasks (
+    id          TEXT PRIMARY KEY,
+    space_id    TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    number      INTEGER NOT NULL CHECK (number >= 1),
+    parent_id   TEXT REFERENCES tasks(id) ON DELETE CASCADE,
+    depth       INTEGER NOT NULL CHECK (depth IN (0, 1, 2)),
+    type        TEXT NOT NULL CHECK (type IN ('standard', 'test')),
+    title       TEXT NOT NULL CHECK (title <> ''),
+    description TEXT NOT NULL DEFAULT '',
+    status      TEXT NOT NULL CHECK (status IN ('todo', 'doing', 'review', 'done')),
+    priority    TEXT NOT NULL CHECK (priority IN ('low', 'medium', 'high', 'critical')),
+    position    REAL NOT NULL,
+    created_by  TEXT NOT NULL REFERENCES users(id),
+    created_at  TEXT NOT NULL,
+    updated_at  TEXT NOT NULL,
+    version     INTEGER NOT NULL DEFAULT 1 CHECK (version >= 1),
+    UNIQUE (space_id, number),
+    CHECK ((parent_id IS NULL) = (depth = 0))
+  );
+  CREATE INDEX tasks_column ON tasks(space_id, parent_id, status, position);
+  CREATE INDEX tasks_parent ON tasks(parent_id);
+
+  CREATE TABLE task_assignees (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, user_id)
+  );
+  CREATE INDEX task_assignees_user ON task_assignees(user_id);
+
+  CREATE TABLE tags (
+    id       TEXT PRIMARY KEY,
+    space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    name     TEXT NOT NULL CHECK (name <> ''),
+    UNIQUE (space_id, name)
+  );
+
+  CREATE TABLE task_tags (
+    task_id TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tag_id  TEXT NOT NULL REFERENCES tags(id) ON DELETE CASCADE,
+    PRIMARY KEY (task_id, tag_id)
+  );
+  CREATE INDEX task_tags_tag ON task_tags(tag_id);
+
+  CREATE TABLE checklist_items (
+    id       TEXT PRIMARY KEY,
+    task_id  TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    text     TEXT NOT NULL CHECK (text <> ''),
+    done     INTEGER NOT NULL DEFAULT 0 CHECK (done IN (0, 1)),
+    position REAL NOT NULL
+  );
+  CREATE INDEX checklist_items_task ON checklist_items(task_id, position);
+
+  CREATE TABLE test_checkpoints (
+    id       TEXT PRIMARY KEY,
+    task_id  TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    text     TEXT NOT NULL CHECK (text <> ''),
+    position REAL NOT NULL
+  );
+  CREATE INDEX test_checkpoints_task ON test_checkpoints(task_id, position);
+
+  CREATE TABLE test_results (
+    checkpoint_id TEXT NOT NULL REFERENCES test_checkpoints(id) ON DELETE CASCADE,
+    tester_id     TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    result        TEXT NOT NULL CHECK (result IN ('ok', 'ko', 'blocked', 'untested')),
+    comment       TEXT NOT NULL DEFAULT '',
+    updated_at    TEXT NOT NULL,
+    PRIMARY KEY (checkpoint_id, tester_id)
+  );
+  CREATE INDEX test_results_tester ON test_results(tester_id);
+
+  CREATE TABLE test_reviews (
+    id           TEXT PRIMARY KEY,
+    task_id      TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    tester_id    TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    text         TEXT NOT NULL DEFAULT '',
+    submitted_at TEXT,
+    request_id   TEXT REFERENCES agent_requests(id) ON DELETE SET NULL
+  );
+  CREATE INDEX test_reviews_task ON test_reviews(task_id, tester_id);
+
+  CREATE TABLE comments (
+    id         TEXT PRIMARY KEY,
+    task_id    TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    author_id  TEXT NOT NULL REFERENCES users(id),
+    body       TEXT NOT NULL CHECK (body <> ''),
+    created_at TEXT NOT NULL,
+    edited_at  TEXT
+  );
+  CREATE INDEX comments_task ON comments(task_id, created_at);
+
+  CREATE TABLE attachments (
+    id           TEXT PRIMARY KEY,
+    task_id      TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    uploader_id  TEXT NOT NULL REFERENCES users(id),
+    filename     TEXT NOT NULL,
+    mime         TEXT NOT NULL,
+    size         INTEGER NOT NULL CHECK (size >= 0),
+    storage_path TEXT NOT NULL,
+    created_at   TEXT NOT NULL
+  );
+  CREATE INDEX attachments_task ON attachments(task_id);
+
+  CREATE TABLE ideas (
+    id               TEXT PRIMARY KEY,
+    space_id         TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    author_id        TEXT NOT NULL REFERENCES users(id),
+    text             TEXT NOT NULL CHECK (text <> ''),
+    origin           TEXT NOT NULL CHECK (origin IN ('manual', 'agent')),
+    request_id       TEXT REFERENCES agent_requests(id) ON DELETE SET NULL,
+    promoted_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    archived_at      TEXT,
+    created_at       TEXT NOT NULL
+  );
+  CREATE INDEX ideas_space ON ideas(space_id, created_at);
+
+  CREATE TABLE agent_requests (
+    id              TEXT PRIMARY KEY,
+    author_id       TEXT NOT NULL REFERENCES users(id),
+    source_space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    target_space_id TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    kind            TEXT NOT NULL CHECK (kind IN ('idea', 'remark', 'test_review', 'message', 'idea_promotion')),
+    context_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL,
+    context_idea_id TEXT REFERENCES ideas(id) ON DELETE SET NULL,
+    text            TEXT NOT NULL CHECK (text <> ''),
+    status          TEXT NOT NULL CHECK (status IN ('pending', 'processing', 'done', 'failed', 'cancelled')),
+    reply           TEXT,
+    failure_reason  TEXT,
+    created_at      TEXT NOT NULL,
+    updated_at      TEXT NOT NULL,
+    claimed_at      TEXT,
+    completed_at    TEXT,
+    cancelled_by    TEXT REFERENCES users(id)
+  );
+  CREATE INDEX agent_requests_status ON agent_requests(status, created_at);
+  CREATE INDEX agent_requests_source ON agent_requests(source_space_id, created_at);
+  CREATE INDEX agent_requests_target ON agent_requests(target_space_id);
+
+  CREATE TABLE agent_actions (
+    id          TEXT PRIMARY KEY,
+    request_id  TEXT NOT NULL REFERENCES agent_requests(id) ON DELETE CASCADE,
+    seq         INTEGER NOT NULL CHECK (seq >= 1),
+    entity_type TEXT NOT NULL,
+    entity_id   TEXT NOT NULL,
+    operation   TEXT NOT NULL,
+    before      TEXT,
+    after       TEXT,
+    summary     TEXT NOT NULL,
+    created_at  TEXT NOT NULL,
+    undone_at   TEXT,
+    undone_by   TEXT REFERENCES users(id),
+    UNIQUE (request_id, seq)
+  );
+  CREATE INDEX agent_actions_entity ON agent_actions(entity_type, entity_id);
+
+  CREATE TABLE entity_versions (
+    entity_type TEXT NOT NULL CHECK (entity_type IN ('task', 'idea')),
+    entity_id   TEXT NOT NULL,
+    version     INTEGER NOT NULL CHECK (version >= 1),
+    snapshot    TEXT,
+    actor_type  TEXT NOT NULL CHECK (actor_type IN ('user', 'agent')),
+    actor_id    TEXT NOT NULL,
+    request_id  TEXT,
+    created_at  TEXT NOT NULL,
+    PRIMARY KEY (entity_type, entity_id, version)
+  );
+
+  CREATE TABLE notifications (
+    id          TEXT PRIMARY KEY,
+    user_id     TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    type        TEXT NOT NULL CHECK (type IN ('assigned', 'comment')),
+    task_id     TEXT NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
+    actor_type  TEXT NOT NULL CHECK (actor_type IN ('user', 'agent')),
+    actor_id    TEXT,
+    request_id  TEXT,
+    comment_id  TEXT REFERENCES comments(id) ON DELETE CASCADE,
+    created_at  TEXT NOT NULL,
+    read_at     TEXT,
+    emailed_at  TEXT,
+    email_error TEXT
+  );
+  CREATE INDEX notifications_user ON notifications(user_id, read_at, created_at);
+
+  CREATE TABLE changes (
+    seq         INTEGER PRIMARY KEY AUTOINCREMENT,
+    space_id    TEXT,
+    user_id     TEXT,
+    entity_type TEXT NOT NULL,
+    entity_id   TEXT NOT NULL,
+    at          TEXT NOT NULL
+  );
+  CREATE INDEX changes_space ON changes(space_id, seq);
+  CREATE INDEX changes_user ON changes(user_id, seq);
+  `,
+    // Une invitation n'a pas de jeton propre : le lien envoyé est l'AccessLink du compte invité.
+    `
+  CREATE TABLE invitations_v2 (
+    id          TEXT PRIMARY KEY,
+    space_id    TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    email       TEXT NOT NULL CHECK (email = lower(email)),
+    invited_by  TEXT NOT NULL REFERENCES users(id),
+    created_at  TEXT NOT NULL,
+    expires_at  TEXT NOT NULL,
+    accepted_at TEXT,
+    revoked_at  TEXT
+  );
+  INSERT INTO invitations_v2 (id, space_id, email, invited_by, created_at, expires_at, accepted_at, revoked_at)
+    SELECT id, space_id, email, invited_by, created_at, expires_at, accepted_at, revoked_at FROM invitations;
+  DROP TABLE invitations;
+  ALTER TABLE invitations_v2 RENAME TO invitations;
+  CREATE INDEX invitations_space ON invitations(space_id);
+  CREATE INDEX invitations_email ON invitations(email);
+  CREATE UNIQUE INDEX invitations_one_open_per_email ON invitations(space_id, email) WHERE accepted_at IS NULL AND revoked_at IS NULL;
+  `,
+    // Tâche concernée par un changement : la tâche elle-même, ou celle qui porte l'élément modifié.
+    `
+  ALTER TABLE changes ADD COLUMN task_id TEXT;
+  `,
+    // Un brouillon de review au plus par testeur et par tâche.
+    `
+  CREATE UNIQUE INDEX test_reviews_one_draft ON test_reviews(task_id, tester_id) WHERE submitted_at IS NULL;
+  `,
+    // Une notification absente de l'application (préférence désactivée) ne sert qu'à suivre l'envoi de son e-mail.
+    `
+  ALTER TABLE notifications ADD COLUMN in_app INTEGER NOT NULL DEFAULT 1 CHECK (in_app IN (0, 1));
+  DROP INDEX notifications_user;
+  CREATE INDEX notifications_user ON notifications(user_id, in_app, read_at, created_at);
+  CREATE INDEX notifications_comment ON notifications(comment_id);
+  `,
+    // Auteur de chaque changement, et demande de l'agent à l'origine d'un commentaire.
+    `
+  ALTER TABLE changes ADD COLUMN actor_type TEXT;
+  ALTER TABLE changes ADD COLUMN actor_id TEXT;
+  ALTER TABLE changes ADD COLUMN request_id TEXT;
+  CREATE INDEX changes_entity ON changes(entity_type, entity_id, seq);
+  ALTER TABLE comments ADD COLUMN request_id TEXT REFERENCES agent_requests(id) ON DELETE SET NULL;
+  `,
+    // Tâche vérifiée par une tâche de test ; les instantanés de tâche déjà enregistrés reçoivent le champ, vide.
+    `
+  ALTER TABLE tasks ADD COLUMN tested_task_id TEXT REFERENCES tasks(id) ON DELETE SET NULL;
+  CREATE INDEX tasks_tested ON tasks(tested_task_id);
+  UPDATE entity_versions SET snapshot = json_set(snapshot, '$.testedTaskId', json('null')) WHERE entity_type = 'task' AND snapshot IS NOT NULL;
+  UPDATE agent_actions SET before = json_set(before, '$.testedTaskId', json('null')) WHERE entity_type = 'task' AND before IS NOT NULL;
+  UPDATE agent_actions SET after = json_set(after, '$.testedTaskId', json('null')) WHERE entity_type = 'task' AND after IS NOT NULL;
+  `,
+    // Une demande vise l'espace où elle est écrite : le réglage de portée disparaît et chaque demande appartient à l'espace qu'elle vise.
+    `
+  ALTER TABLE user_settings DROP COLUMN agent_scope;
+  UPDATE agent_requests SET source_space_id = target_space_id WHERE source_space_id <> target_space_id;
+  `,
+    // Un lien d'invitation est rattaché à l'invitation qui l'a émis ; les liens d'invitation non rattachés ne servent plus.
+    // Le destinataire d'une invitation peut la refuser.
+    `
+  ALTER TABLE access_links ADD COLUMN invitation_id TEXT REFERENCES invitations(id) ON DELETE CASCADE;
+  CREATE INDEX access_links_invitation ON access_links(invitation_id);
+  DELETE FROM access_links WHERE purpose = 'invite' AND used_at IS NULL;
+  ALTER TABLE invitations ADD COLUMN declined_at TEXT;
+  DROP INDEX invitations_one_open_per_email;
+  CREATE UNIQUE INDEX invitations_one_open_per_email ON invitations(space_id, email) WHERE accepted_at IS NULL AND revoked_at IS NULL AND declined_at IS NULL;
+  `,
+    // Jetons d'agent : un jeton couvre un espace pour un utilisateur ; seul le hash sha256 du jeton est stocké.
+    `
+  CREATE TABLE agent_tokens (
+    id           TEXT PRIMARY KEY,
+    user_id      TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    space_id     TEXT NOT NULL REFERENCES spaces(id) ON DELETE CASCADE,
+    name         TEXT NOT NULL CHECK (name <> ''),
+    prefix       TEXT NOT NULL,
+    token_hash   TEXT NOT NULL UNIQUE,
+    created_at   TEXT NOT NULL,
+    last_used_at TEXT,
+    expires_at   TEXT,
+    revoked_at   TEXT
+  );
+  CREATE INDEX agent_tokens_user ON agent_tokens(user_id, created_at);
+  CREATE INDEX agent_tokens_space ON agent_tokens(space_id);
+  `,
+    // Jeton qui a pris une demande, et jeton auteur de chaque action de l'agent et de chaque version qu'il crée.
+    `
+  ALTER TABLE agent_requests ADD COLUMN claimed_by_token_id TEXT REFERENCES agent_tokens(id) ON DELETE SET NULL;
+  CREATE INDEX agent_requests_claimed_by ON agent_requests(claimed_by_token_id);
+  ALTER TABLE agent_actions ADD COLUMN token_id TEXT REFERENCES agent_tokens(id) ON DELETE SET NULL;
+  ALTER TABLE entity_versions ADD COLUMN token_id TEXT REFERENCES agent_tokens(id) ON DELETE SET NULL;
+  CREATE INDEX agent_requests_target_status ON agent_requests(target_space_id, status, created_at);
+  `,
+    // Retire l'espace source des demandes, identique à l'espace visé : une demande n'a qu'un espace.
+    // L'index (target_space_id, status, created_at) sert aussi les recherches par espace seul.
+    `
+  DROP INDEX agent_requests_source;
+  DROP INDEX agent_requests_target;
+  ALTER TABLE agent_requests DROP COLUMN source_space_id;
+  `,
+    // Révoque les jetons dont le propriétaire n'est plus membre de l'espace couvert : un départ révoque ses jetons.
+    `
+  UPDATE agent_tokens SET revoked_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
+  WHERE revoked_at IS NULL
+    AND NOT EXISTS (SELECT 1 FROM memberships m WHERE m.space_id = agent_tokens.space_id AND m.user_id = agent_tokens.user_id);
+  `,
+];
+/** Version du schéma attendue par ce code. */
+export const SCHEMA_VERSION = MIGRATIONS.length;
+/** Version courante du schéma de la base. */
+export function schemaVersion(db) {
+    return db.pragma("user_version", { simple: true });
+}
+/**
+ * Applique les migrations manquantes, chacune dans une transaction exclusive
+ * qui relit la version : deux processus qui migrent la même base en même temps
+ * n'appliquent chaque migration qu'une fois. Une base plus récente que le code
+ * est refusée.
+ */
+export function migrate(db) {
+    const current = schemaVersion(db);
+    if (current > SCHEMA_VERSION) {
+        throw new Error(`The database schema is version ${current}, newer than the version ${SCHEMA_VERSION} this mcp-organizer supports. Update the @imenam/mcp-organizer package.`);
+    }
+    for (let index = current; index < SCHEMA_VERSION; index++) {
+        db.transaction(() => {
+            if (schemaVersion(db) !== index)
+                return;
+            db.exec(MIGRATIONS[index]);
+            db.pragma(`user_version = ${index + 1}`);
+        }).immediate();
+    }
+}

package/dist/src/core/native-sqlite.d.ts

@@ -0,0 +1,2 @@
+export declare const MISSING_SQLITE_BINDINGS_MESSAGE = "better-sqlite3 n'a pas de module natif compil\u00E9 (\u00AB Could not locate the bindings file \u00BB) : ses scripts d'installation n'ont pas \u00E9t\u00E9 ex\u00E9cut\u00E9s, ce qui arrive avec npm 12 pour un paquet install\u00E9 par npm install ou npx.\nLe site et ses commandes (--server, --set-user, --setup, --backup) en ont besoin ; le mode MCP, non.\n- Installez le site par clonage du d\u00E9p\u00F4t : git clone <d\u00E9p\u00F4t>, puis npm ci et npm run build (README, \u00AB Installer le site \u00BB) ;\n- ou, dans cette installation, autorisez et construisez le module : npm install-scripts approve better-sqlite3, puis npm rebuild better-sqlite3.";
+export declare function assertSqliteLoadable(): Promise<void>;

package/dist/src/core/native-sqlite.js

@@ -0,0 +1,23 @@
+import { ConfigError } from "./errors.js";
+/**
+ * Vérifie que better-sqlite3 charge son module natif, en ouvrant une base en
+ * mémoire. Sans ce module (scripts d'installation npm non exécutés), la
+ * vérification lève une `ConfigError` qui dit comment installer le site.
+ */
+/** Message de better-sqlite3 (paquet `bindings`) quand le module natif n'a pas été construit. */
+const MISSING_BINDINGS = /Could not locate the bindings file/;
+export const MISSING_SQLITE_BINDINGS_MESSAGE = `better-sqlite3 n'a pas de module natif compilé (« Could not locate the bindings file ») : ses scripts d'installation n'ont pas été exécutés, ce qui arrive avec npm 12 pour un paquet installé par npm install ou npx.
+Le site et ses commandes (--server, --set-user, --setup, --backup) en ont besoin ; le mode MCP, non.
+- Installez le site par clonage du dépôt : git clone <dépôt>, puis npm ci et npm run build (README, « Installer le site ») ;
+- ou, dans cette installation, autorisez et construisez le module : npm install-scripts approve better-sqlite3, puis npm rebuild better-sqlite3.`;
+export async function assertSqliteLoadable() {
+    const { default: Database } = await import("better-sqlite3");
+    try {
+        new Database(":memory:").close();
+    }
+    catch (err) {
+        if (MISSING_BINDINGS.test(String(err?.message ?? err)))
+            throw new ConfigError(MISSING_SQLITE_BINDINGS_MESSAGE);
+        throw err;
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { Mailer } from "./mail.js";
+import type { Transcriber } from "./transcription.js";
+import type { Store } from "./store.js";
+import type { NotificationListQuery, NotificationListResponse, SettingsResponse, UnreadCountResponse, UpdateSettingsRequest } from "../../shared/schemas/notifications-api.schema.js";
+/** Dépendances de l'envoi des e-mails de notification. */
+export interface NotificationMailDeps {
+    mailer: Mailer;
+    /** URL publique de la GUI (`ORGANIZER_PUBLIC_URL`), base du lien vers la tâche. */
+    publicUrl: string | undefined;
+    /** Journal des erreurs inattendues de l'envoi. */
+    logError: (message: string) => void;
+}
+/** Raison pour laquelle les e-mails de notification ne partent pas, ou null s'ils peuvent partir. */
+export declare function notificationEmailBlocker(deps: Pick<NotificationMailDeps, "mailer" | "publicUrl">): string | 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 declare class NotificationMailer {
+    private readonly store;
+    private readonly deps;
+    private readonly inFlight;
+    constructor(store: Store, deps: NotificationMailDeps);
+    /** Abonne l'envoi aux mutations du store. */
+    attach(): this;
+    /** Attend la fin des envois en cours. */
+    flush(): Promise<void>;
+    private enqueue;
+    private deliver;
+    private send;
+    private message;
+}
+/** Notifications de l'utilisateur, non lues d'abord, par page. */
+export declare function listNotifications(store: Store, userId: string, query: NotificationListQuery): NotificationListResponse;
+export declare function unreadCount(store: Store, userId: string): UnreadCountResponse;
+/** Marque lue une notification de l'utilisateur ; celle d'un autre est introuvable. */
+export declare function markNotificationRead(store: Store, userId: string, notificationId: string): UnreadCountResponse;
+export declare function markAllNotificationsRead(store: Store, userId: string): UnreadCountResponse;
+/** Ce que les paramètres affichent du serveur : e-mail et dictée. */
+export type SettingsDeps = Pick<NotificationMailDeps, "mailer" | "publicUrl"> & {
+    transcriber: Pick<Transcriber, "enabled" | "disabledReason">;
+};
+export declare function getSettings(store: Store, deps: SettingsDeps, userId: string): SettingsResponse;
+export declare function updateSettings(store: Store, deps: SettingsDeps, userId: string, patch: UpdateSettingsRequest): SettingsResponse;

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;
+}