@imenam/mcp-design 1.0.10 → 1.0.11

package/dist/shared/schemas/feedback.schema.d.ts

@@ -0,0 +1,185 @@
+import { z } from "zod";
+export declare const RemarkTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"page">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"node">;
+    element: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            ellipse: "ellipse";
+            group: "group";
+            icon: "icon";
+            instance: "instance";
+            line: "line";
+            rect: "rect";
+            text: "text";
+        }>;
+    }, z.core.$strip>;
+    path: z.ZodArray<z.ZodString>;
+    box: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"area">;
+    box: z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+    }, z.core.$strip>;
+    elements: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            ellipse: "ellipse";
+            group: "group";
+            icon: "icon";
+            instance: "instance";
+            line: "line";
+            rect: "rect";
+            text: "text";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "kind">;
+export declare const FeedbackFileSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    remarks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        designId: z.ZodString;
+        number: z.ZodNullable<z.ZodNumber>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"page">;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"node">;
+            element: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    ellipse: "ellipse";
+                    group: "group";
+                    icon: "icon";
+                    instance: "instance";
+                    line: "line";
+                    rect: "rect";
+                    text: "text";
+                }>;
+            }, z.core.$strip>;
+            path: z.ZodArray<z.ZodString>;
+            box: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"area">;
+            box: z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>;
+            elements: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                type: z.ZodEnum<{
+                    ellipse: "ellipse";
+                    group: "group";
+                    icon: "icon";
+                    instance: "instance";
+                    line: "line";
+                    rect: "rect";
+                    text: "text";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+        text: z.ZodString;
+        capture: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            draft: "draft";
+            sent: "sent";
+        }>;
+        round: z.ZodNullable<z.ZodNumber>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    rounds: z.ZodArray<z.ZodObject<{
+        number: z.ZodNumber;
+        title: z.ZodString;
+        submittedAt: z.ZodString;
+        remarks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            designId: z.ZodString;
+            designName: z.ZodString;
+            number: z.ZodNullable<z.ZodNumber>;
+            target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"page">;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"node">;
+                element: z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    type: z.ZodEnum<{
+                        ellipse: "ellipse";
+                        group: "group";
+                        icon: "icon";
+                        instance: "instance";
+                        line: "line";
+                        rect: "rect";
+                        text: "text";
+                    }>;
+                }, z.core.$strip>;
+                path: z.ZodArray<z.ZodString>;
+                box: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"area">;
+                box: z.ZodObject<{
+                    x: z.ZodNumber;
+                    y: z.ZodNumber;
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strip>;
+                elements: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    name: z.ZodString;
+                    type: z.ZodEnum<{
+                        ellipse: "ellipse";
+                        group: "group";
+                        icon: "icon";
+                        instance: "instance";
+                        line: "line";
+                        rect: "rect";
+                        text: "text";
+                    }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>], "kind">;
+            text: z.ZodString;
+            capture: z.ZodNullable<z.ZodString>;
+            processed: z.ZodNullable<z.ZodObject<{
+                at: z.ZodString;
+                by: z.ZodEnum<{
+                    agent: "agent";
+                    user: "user";
+                }>;
+                note: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    lastNumbers: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type FeedbackFile = z.infer<typeof FeedbackFileSchema>;
+/**
+ * Met un fichier de version 1 au format courant : chaque retour reçoit le nom
+ * proposé par défaut, et aucune remarque n'est encore traitée. Renvoie null
+ * pour un fichier qui n'est pas en version 1.
+ */
+export declare function migrateFeedbackFile(raw: unknown, defaultTitle: (number: number) => string): unknown | null;

package/dist/shared/schemas/feedback.schema.js

@@ -0,0 +1,87 @@
+import { z } from "zod";
+import { NODE_TYPES } from "./design.schema.js";
+/**
+ * Fichier des remarques : `<dataDir>/feedback/remarks.json`.
+ *
+ * Il tient les remarques en cours (brouillons et transmises) et la liste des
+ * retours transmis, chacun figé au moment de l'envoi, hormis le suivi de son
+ * traitement. Les types TypeScript vivent dans `shared/feedback.ts`,
+ * importable par la GUI sans zod.
+ */
+const BoxSchema = z.object({ x: z.number(), y: z.number(), width: z.number(), height: z.number() });
+const RemarkElementSchema = z.object({ id: z.string(), name: z.string(), type: z.enum(NODE_TYPES) });
+export const RemarkTargetSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("page") }),
+    z.object({ kind: z.literal("node"), element: RemarkElementSchema, path: z.array(z.string()), box: BoxSchema }),
+    z.object({ kind: z.literal("area"), box: BoxSchema, elements: z.array(RemarkElementSchema) }),
+]);
+const RemarkSchema = z.object({
+    id: z.string(),
+    designId: z.string(),
+    number: z.number().int().positive().nullable(),
+    target: RemarkTargetSchema,
+    text: z.string().min(1),
+    capture: z.string().nullable(),
+    status: z.enum(["draft", "sent"]),
+    round: z.number().int().positive().nullable(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+});
+const RemarkProcessingSchema = z.object({
+    at: z.string(),
+    by: z.enum(["agent", "user"]),
+    note: z.string().nullable(),
+});
+const RoundRemarkSchema = z.object({
+    id: z.string(),
+    designId: z.string(),
+    designName: z.string(),
+    number: z.number().int().positive().nullable(),
+    target: RemarkTargetSchema,
+    text: z.string().min(1),
+    capture: z.string().nullable(),
+    processed: RemarkProcessingSchema.nullable(),
+});
+const FeedbackRoundSchema = z.object({
+    number: z.number().int().positive(),
+    title: z.string().min(1),
+    submittedAt: z.string(),
+    remarks: z.array(RoundRemarkSchema),
+});
+export const FeedbackFileSchema = z.object({
+    version: z.literal(2),
+    remarks: z.array(RemarkSchema),
+    rounds: z.array(FeedbackRoundSchema),
+    /** Dernier numéro de pastille attribué par design : un numéro supprimé n'est jamais réutilisé. */
+    lastNumbers: z.record(z.string(), z.number().int().nonnegative()),
+});
+/** Version 1 : des retours sans nom, et des remarques sans suivi de traitement. */
+const FeedbackFileV1Schema = z.object({
+    version: z.literal(1),
+    remarks: z.array(RemarkSchema),
+    rounds: z.array(z.object({
+        number: z.number().int().positive(),
+        submittedAt: z.string(),
+        remarks: z.array(RoundRemarkSchema.omit({ processed: true })),
+    })),
+    lastNumbers: z.record(z.string(), z.number().int().nonnegative()),
+});
+/**
+ * Met un fichier de version 1 au format courant : chaque retour reçoit le nom
+ * proposé par défaut, et aucune remarque n'est encore traitée. Renvoie null
+ * pour un fichier qui n'est pas en version 1.
+ */
+export function migrateFeedbackFile(raw, defaultTitle) {
+    const v1 = FeedbackFileV1Schema.safeParse(raw);
+    if (!v1.success)
+        return null;
+    return {
+        ...v1.data,
+        version: 2,
+        rounds: v1.data.rounds.map((round) => ({
+            ...round,
+            title: defaultTitle(round.number),
+            remarks: round.remarks.map((remark) => ({ ...remark, processed: null })),
+        })),
+    };
+}

package/dist/shared/tree.d.ts

@@ -66,6 +66,8 @@ export declare function computeLayout(nodes: RenderNode[]): Layout;
 /** Origine de l'espace de coordonnées dans lequel vit un élément. */
 export declare function spaceOriginOf(layout: Layout, parentId: string | null): Point;
 export declare function boundsOf(layout: Layout, id: string): Box;
+/** Vrai si les deux boîtes ont une surface commune ; un simple contact ne compte pas. */
+export declare function boxesIntersect(a: Box, b: Box): boolean;
 /** Boîte englobante commune à plusieurs éléments, en coordonnées document. */
 export declare function unionBoundsOf(layout: Layout, ids: string[]): Box | null;
 export declare const REORDER_DIRECTIONS: readonly ["front", "back", "forward", "backward"];

package/dist/shared/tree.js

@@ -140,6 +140,10 @@ export function spaceOriginOf(layout, parentId) {
 export function boundsOf(layout, id) {
     return layout.bounds.get(id) ?? { x: 0, y: 0, width: 0, height: 0 };
 }
+/** Vrai si les deux boîtes ont une surface commune ; un simple contact ne compte pas. */
+export function boxesIntersect(a, b) {
+    return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
 /** Boîte englobante commune à plusieurs éléments, en coordonnées document. */
 export function unionBoundsOf(layout, ids) {
     return unionBox(ids.map((id) => layout.bounds.get(id)).filter((box) => box !== undefined));

package/dist/src/core/design-store.d.ts

@@ -38,11 +38,7 @@ export declare class DesignStore {
     private stampOf;
     private remember;
     private write;
-    /**
-     * Sérialise le cycle lire-modifier-écrire entre processus. `wx` échoue si le
-     * fichier existe déjà : c'est l'opération atomique qui départage deux
-     * écrivains concurrents. Non réentrant — ne jamais appeler depuis `fn`.
-     */
+    /** Verrou inter-processus du fichier d'un design. Non réentrant — ne jamais appeler depuis `fn`. */
     private withLock;
     /** Identifiant lisible dérivé du nom, suffixé seulement en cas de collision. */
     private allocateId;

package/dist/src/core/design-store.js

@@ -2,21 +2,11 @@ import fs from "fs";
 import path from "path";
 import { DesignSchema, normalizeDesignGroup, } from "../../shared/schemas/design.schema.js";
 import { DesignError } from "./node-factory.js";
+import { withFileLock } from "./file-lock.js";
 import { normalizeHierarchy } from "./hierarchy.js";
 import { migrateDesign } from "./migrate.js";
 import { shortId, slugify } from "./ids.js";
 import { countChanges } from "./diff.js";
-/** Au-delà de ce délai, un verrou est réputé abandonné (processus tué en cours d'écriture). */
-const LOCK_STALE_MS = 10_000;
-const LOCK_RETRY_MS = 25;
-const LOCK_TIMEOUT_MS = 5_000;
-/**
- * Pause bloquante. Le store est entièrement synchrone — le rendre asynchrone
- * pour l'attente d'un verrou contaminerait tous les appelants.
- */
-function sleepSync(ms) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
 /**
  * Persistance des designs : un fichier JSON par design dans <dataDir>/designs.
  * Pas de base de données — un design tient dans quelques dizaines de Ko et le
@@ -75,52 +65,9 @@ export class DesignStore {
         // prendrait notre propre écriture pour une modification externe.
         this.remember(design);
     }
-    /**
-     * Sérialise le cycle lire-modifier-écrire entre processus. `wx` échoue si le
-     * fichier existe déjà : c'est l'opération atomique qui départage deux
-     * écrivains concurrents. Non réentrant — ne jamais appeler depuis `fn`.
-     */
+    /** Verrou inter-processus du fichier d'un design. Non réentrant — ne jamais appeler depuis `fn`. */
     withLock(id, fn) {
-        const lockPath = `${this.filePath(id)}.lock`;
-        const deadline = Date.now() + LOCK_TIMEOUT_MS;
-        let fd;
-        for (;;) {
-            try {
-                fd = fs.openSync(lockPath, "wx");
-                break;
-            }
-            catch (err) {
-                if (err.code !== "EEXIST")
-                    throw err;
-                try {
-                    // Un processus tué laisse son verrou derrière lui : passé le délai
-                    // d'obsolescence on le casse, sinon le design serait bloqué à vie.
-                    if (Date.now() - fs.statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
-                        fs.unlinkSync(lockPath);
-                        continue;
-                    }
-                }
-                catch {
-                    continue; // Verrou disparu entre le open et le stat : on retente aussitôt.
-                }
-                if (Date.now() > deadline) {
-                    throw new DesignError(`Design "${id}" is being written by another editor and did not free up in ${LOCK_TIMEOUT_MS} ms. Try again in a moment.`);
-                }
-                sleepSync(LOCK_RETRY_MS);
-            }
-        }
-        try {
-            return fn();
-        }
-        finally {
-            fs.closeSync(fd);
-            try {
-                fs.unlinkSync(lockPath);
-            }
-            catch {
-                // Verrou déjà cassé pour obsolescence par un autre processus.
-            }
-        }
+        return withFileLock(`${this.filePath(id)}.lock`, `Design "${id}"`, fn);
     }
     /** Identifiant lisible dérivé du nom, suffixé seulement en cas de collision. */
     allocateId(name) {

package/dist/src/core/feedback-store.d.ts

@@ -0,0 +1,73 @@
+import { type FeedbackRound, type Remark } from "../../shared/feedback.js";
+import { type FeedbackFile } from "../../shared/schemas/feedback.schema.js";
+import type { Box } from "../../shared/tree.js";
+import type { DesignStore } from "./design-store.js";
+/** Cible demandée par la GUI ; le serveur la complète d'après le design. */
+export type RemarkTargetInput = {
+    kind: "page";
+} | {
+    kind: "node";
+    nodeId: string;
+} | {
+    kind: "area";
+    box: Box;
+    elementIds: string[];
+};
+export interface AddRemarkInput {
+    designId: string;
+    target: RemarkTargetInput;
+    text: string;
+    /** Joindre une capture de l'élément ou de la zone. Sans effet sur une remarque de page. */
+    capture: boolean;
+}
+export interface SetProcessedInput {
+    round: number;
+    /** Remarques visées ; toutes celles du retour quand omis. */
+    remarkIds?: string[];
+    processed: boolean;
+    by: "agent" | "user";
+    note?: string | null;
+}
+/**
+ * Remarques de l'utilisateur et retours transmis à l'agent, dans
+ * `<dataDir>/feedback/remarks.json`, captures dans `<dataDir>/feedback/captures`.
+ *
+ * Un seul fichier pour tout le projet : un retour peut couvrir plusieurs pages.
+ */
+export declare class FeedbackStore {
+    private readonly designs;
+    private readonly dir;
+    private readonly capturesDir;
+    private readonly file;
+    constructor(designs: DesignStore);
+    getFilePath(): string;
+    read(): FeedbackFile;
+    private mutate;
+    remarks(designId?: string): Remark[];
+    rounds(): FeedbackRound[];
+    capturePath(name: string): string;
+    readCapture(name: string): Buffer;
+    /** Complète la cible d'après l'état courant du design. */
+    private resolveTarget;
+    private renderCapture;
+    add(input: AddRemarkInput): Remark;
+    private draftOf;
+    updateText(id: string, text: string): Remark;
+    /**
+     * Retire une remarque de la liste. La capture d'un brouillon part avec lui ;
+     * celle d'une remarque transmise reste, le retour qui la contient la cite.
+     */
+    delete(id: string): void;
+    /** Retire les remarques d'un design supprimé, selon la même règle que `delete`. */
+    deleteDesign(designId: string): void;
+    /** Fige les brouillons choisis dans un nouveau retour nommé, et les marque transmis. */
+    submit(remarkIds: string[], title: string): FeedbackRound;
+    private roundOf;
+    rename(number: number, title: string): FeedbackRound;
+    /**
+     * Déclare des remarques d'un retour traitées, ou les rouvre. Une remarque
+     * déjà traitée reste inchangée ; une nouvelle note remplace l'ancienne et
+     * son auteur, en gardant la date d'origine.
+     */
+    setProcessed(input: SetProcessedInput): FeedbackRound;
+}