@imenam/mcp-design 1.0.10 → 1.0.12

package/dist/src/index.js

@@ -10,13 +10,14 @@ import { GuiLauncher, createLogger, setupLogging } from "@imenam/mcp-gui-interfa
 import { APP_VERSION } from "./version.js";
 import { resolveLogDir } from "./core/log-dir.js";
 import { DesignStore } from "./core/design-store.js";
+import { FeedbackStore } from "./core/feedback-store.js";
 import { NODE_DEFAULTS } from "./core/node-factory.js";
 import { EXPORT_FORMATS } from "./core/export.js";
 import { MIN_LINE_HEIGHT_PX } from "../shared/render.js";
 import { CORE_ICONS, iconCount } from "../shared/icons/index.js";
 import { NODE_FIELD_DOCS } from "../shared/node-fields.js";
 import { REORDER_DIRECTIONS } from "../shared/tree.js";
-import { normalizeDesignGroup } from "../shared/schemas/design.schema.js";
+import { IMAGE_FITS, NODE_TYPES, normalizeDesignGroup } from "../shared/schemas/design.schema.js";
 import { listDesigns } from "./tools/list-designs.js";
 import { createDesign } from "./tools/create-design.js";
 import { duplicateDesign } from "./tools/duplicate-design.js";
@@ -24,6 +25,8 @@ import { getDesign } from "./tools/get-design.js";
 import { updateDesign } from "./tools/update-design.js";
 import { deleteDesign } from "./tools/delete-design.js";
 import { addNodes } from "./tools/add-nodes.js";
+import { addImage } from "./tools/add-image.js";
+import { IMAGE_FORMATS } from "./core/image-store.js";
 import { updateNodes } from "./tools/update-nodes.js";
 import { deleteNodes } from "./tools/delete-nodes.js";
 import { duplicateNodes, MAX_DUPLICATE_COPIES } from "./tools/duplicate-nodes.js";
@@ -32,6 +35,8 @@ import { groupDesigns } from "./tools/group-designs.js";
 import { ungroupNodes } from "./tools/ungroup-nodes.js";
 import { detachInstances } from "./tools/detach-instances.js";
 import { getChanges } from "./tools/get-changes.js";
+import { getFeedback } from "./tools/get-feedback.js";
+import { markFeedbackProcessed } from "./tools/mark-feedback-processed.js";
 import { markSynced } from "./tools/mark-synced.js";
 import { exportDesignTool } from "./tools/export-design.js";
 import { screenshotDesignTool } from "./tools/screenshot-design.js";
@@ -74,6 +79,7 @@ function getConfig() {
 }
 getConfig();
 const store = new DesignStore(rootDir);
+const feedback = new FeedbackStore(store);
 const server = new Server({ name: "mcp-design", version: APP_VERSION }, { capabilities: { tools: {} } });
 // --- Cycle de vie de la GUI -------------------------------------------------
 let guiLauncher;
@@ -97,6 +103,20 @@ function reply(msg, type, data) {
 function replyError(msg, type, error) {
     broadcastToGUI({ type, correlationId: msg.correlationId, error, timestamp: new Date().toISOString() });
 }
+/** État des remarques renvoyé à la GUI après chaque lecture ou modification. */
+function remarksState() {
+    return { remarks: feedback.remarks(), rounds: feedback.rounds(), file: feedback.getFilePath() };
+}
+/** Prévient les autres onglets de la GUI que les remarques ont changé. */
+function notifyRemarksChanged() {
+    broadcastToGUI({ type: "REMARKS_UPDATED", data: {}, timestamp: new Date().toISOString() });
+}
+/** Supprime un design et ses remarques. */
+function deleteDesignAndRemarks(id) {
+    store.delete(id);
+    feedback.deleteDesign(id);
+    notifyRemarksChanged();
+}
 /** Notifie la GUI qu'un design a changé côté agent, pour qu'elle se rafraîchisse. */
 function notifyDesignChanged(designId) {
     broadcastToGUI({
@@ -163,7 +183,7 @@ function handleIPCMessage(msg) {
             return;
         case "DELETE_DESIGN":
             try {
-                store.delete(String(msg.data?.id));
+                deleteDesignAndRemarks(String(msg.data?.id));
                 reply(msg, "DELETE_DESIGN_RESPONSE", { designs: store.list() });
             }
             catch (err) {
@@ -181,6 +201,117 @@ function handleIPCMessage(msg) {
                 replyError(msg, "SET_DESIGN_GROUP_RESPONSE", err.message);
             }
             return;
+        case "LIST_REMARKS":
+            try {
+                reply(msg, "LIST_REMARKS_RESPONSE", remarksState());
+            }
+            catch (err) {
+                replyError(msg, "LIST_REMARKS_RESPONSE", err.message);
+            }
+            return;
+        case "ADD_REMARK":
+            try {
+                const remark = feedback.add({
+                    designId: String(msg.data?.designId ?? ""),
+                    target: msg.data?.target,
+                    text: String(msg.data?.text ?? ""),
+                    capture: msg.data?.capture === true,
+                });
+                notifyRemarksChanged();
+                reply(msg, "ADD_REMARK_RESPONSE", { remark, ...remarksState() });
+            }
+            catch (err) {
+                replyError(msg, "ADD_REMARK_RESPONSE", err.message);
+            }
+            return;
+        case "UPDATE_REMARK":
+            try {
+                const remark = feedback.updateText(String(msg.data?.id ?? ""), String(msg.data?.text ?? ""));
+                notifyRemarksChanged();
+                reply(msg, "UPDATE_REMARK_RESPONSE", { remark, ...remarksState() });
+            }
+            catch (err) {
+                replyError(msg, "UPDATE_REMARK_RESPONSE", err.message);
+            }
+            return;
+        case "DELETE_REMARK":
+            try {
+                feedback.delete(String(msg.data?.id ?? ""));
+                notifyRemarksChanged();
+                reply(msg, "DELETE_REMARK_RESPONSE", remarksState());
+            }
+            catch (err) {
+                replyError(msg, "DELETE_REMARK_RESPONSE", err.message);
+            }
+            return;
+        case "SUBMIT_FEEDBACK":
+            try {
+                const ids = Array.isArray(msg.data?.remarkIds) ? msg.data.remarkIds.map(String) : [];
+                const round = feedback.submit(ids, String(msg.data?.title ?? ""));
+                notifyRemarksChanged();
+                reply(msg, "SUBMIT_FEEDBACK_RESPONSE", { round, ...remarksState() });
+            }
+            catch (err) {
+                replyError(msg, "SUBMIT_FEEDBACK_RESPONSE", err.message);
+            }
+            return;
+        case "RENAME_ROUND":
+            try {
+                feedback.rename(Number(msg.data?.round), String(msg.data?.title ?? ""));
+                notifyRemarksChanged();
+                reply(msg, "RENAME_ROUND_RESPONSE", remarksState());
+            }
+            catch (err) {
+                replyError(msg, "RENAME_ROUND_RESPONSE", err.message);
+            }
+            return;
+        case "SET_REMARK_PROCESSED":
+            try {
+                feedback.setProcessed({
+                    round: Number(msg.data?.round),
+                    remarkIds: [String(msg.data?.remarkId ?? "")],
+                    processed: msg.data?.processed === true,
+                    by: "user",
+                });
+                notifyRemarksChanged();
+                reply(msg, "SET_REMARK_PROCESSED_RESPONSE", remarksState());
+            }
+            catch (err) {
+                replyError(msg, "SET_REMARK_PROCESSED_RESPONSE", err.message);
+            }
+            return;
+        case "SET_ROUNDS_PROCESSED":
+            try {
+                const numbers = msg.data?.round === undefined || msg.data?.round === null
+                    ? feedback.rounds().map((round) => round.number)
+                    : [Number(msg.data.round)];
+                for (const round of numbers) {
+                    feedback.setProcessed({ round, processed: msg.data?.processed === true, by: "user" });
+                }
+                notifyRemarksChanged();
+                reply(msg, "SET_ROUNDS_PROCESSED_RESPONSE", remarksState());
+            }
+            catch (err) {
+                replyError(msg, "SET_ROUNDS_PROCESSED_RESPONSE", err.message);
+            }
+            return;
+        case "GET_CAPTURE":
+            try {
+                reply(msg, "GET_CAPTURE_RESPONSE", { png: feedback.readCapture(String(msg.data?.name ?? "")).toString("base64") });
+            }
+            catch (err) {
+                replyError(msg, "GET_CAPTURE_RESPONSE", err.message);
+            }
+            return;
+        case "GET_IMAGE":
+            try {
+                const image = store.images.read(String(msg.data?.name ?? ""));
+                reply(msg, "GET_IMAGE_RESPONSE", { data: image.data.toString("base64"), mimeType: image.mimeType });
+            }
+            catch (err) {
+                replyError(msg, "GET_IMAGE_RESPONSE", err.message);
+            }
+            return;
         case "GET_CONFIG":
             reply(msg, "GET_CONFIG_RESPONSE", { dataDir: store.getDataDir(), version: APP_VERSION });
             return;
@@ -340,6 +471,7 @@ const NODE_FIELDS_DOC = "Every length is in PIXELS (x, y, width, height, strokeW
     "a text node given no height takes the exact height of its text, so its first line starts at y — " +
     "pass a height only to centre a label inside a container (same y and height as the container); " +
     "icon: icon (required — the name of the drawing), fill, stroke, strokeWidth; " +
+    "image: image (required — the stored name returned by add_image), fit; " +
     "instance: componentId (required — the id of the group it mirrors); nothing else, its look comes from that group. " +
     "Any field left out falls back to a sensible default, so a node can be created from its type alone.";
 /**
@@ -374,6 +506,8 @@ const NODE_PROPERTIES = {
     strokeWidth: { type: "number", minimum: 0, description: NODE_FIELD_DOCS.strokeWidth },
     radius: { type: "number", minimum: 0, description: NODE_FIELD_DOCS.radius },
     icon: { type: "string", description: NODE_FIELD_DOCS.icon },
+    image: { type: "string", description: NODE_FIELD_DOCS.image },
+    fit: { type: "string", enum: [...IMAGE_FITS], description: NODE_FIELD_DOCS.fit },
     componentId: { type: "string", description: NODE_FIELD_DOCS.componentId },
     text: { type: "string", description: NODE_FIELD_DOCS.text },
     color: { type: "string", description: NODE_FIELD_DOCS.color },
@@ -508,7 +642,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                             properties: {
                                 type: {
                                     type: "string",
-                                    enum: ["rect", "ellipse", "line", "text", "icon", "group", "instance"],
+                                    enum: [...NODE_TYPES],
                                     description: NODE_FIELD_DOCS.type,
                                 },
                                 ...NODE_PROPERTIES,
@@ -521,6 +655,41 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["design_id", "nodes"],
             },
         },
+        {
+            name: "add_image",
+            description: "Place a picture (photo, logo, illustration, screenshot) on a design, on top of the other nodes. " +
+                `Give the ABSOLUTE path of the image file on the agent machine; accepted formats: ${Object.keys(IMAGE_FORMATS).join(", ")}. ` +
+                "The file is copied into the media library of the designs, so the design keeps working if the original moves. " +
+                "Without width and height the node takes the picture's natural size; with only one of them, the other follows the picture's proportions. " +
+                "Use it for real pictures only — icons come from the \"icon\" node, shapes from add_nodes. " +
+                "The answer gives the stored name of the picture: an image node in add_nodes with that name places it again without a second import.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    design_id: { type: "string", description: DESIGN_ID_DOC },
+                    file_path: { type: "string", description: "Absolute path to the image file on the agent machine." },
+                    file_content: {
+                        type: "string",
+                        description: "Filled in by the mcp-http-gateway relay, never by the agent: the base64 content of the file read on the agent machine.",
+                    },
+                    file_name: {
+                        type: "string",
+                        description: "Filled in by the mcp-http-gateway relay, never by the agent: the original name of the file read on the agent machine.",
+                    },
+                    id: NODE_PROPERTIES.id,
+                    name: { type: "string", description: `${NODE_FIELD_DOCS.name} Defaults to the file name without its extension.` },
+                    parentId: NODE_PROPERTIES.parentId,
+                    x: NODE_PROPERTIES.x,
+                    y: NODE_PROPERTIES.y,
+                    width: { type: "number", description: "Width of the box, in pixels. Defaults to the picture's natural width, or follows its proportions when only height is given." },
+                    height: { type: "number", description: "Height of the box, in pixels. Defaults to the picture's natural height, or follows its proportions when only width is given." },
+                    rotation: NODE_PROPERTIES.rotation,
+                    opacity: NODE_PROPERTIES.opacity,
+                    fit: NODE_PROPERTIES.fit,
+                },
+                required: ["design_id", "file_path"],
+            },
+        },
         {
             name: "update_nodes",
             description: "Patch existing nodes. Each entry needs an id plus only the fields to change; everything else is preserved. " +
@@ -694,6 +863,51 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["design_ids", "group"],
             },
         },
+        {
+            name: "get_feedback",
+            description: "Read the feedback the user wrote on the designs in the GUI. In \"Remarques\" mode the user pins remarks on a whole page, " +
+                "on an element or on a rectangular area, then clicks \"Terminer les retours\": the selected remarks are frozen into a numbered, " +
+                "named feedback round. Call this tool when the user says their feedback is done. By default it returns the oldest round that still " +
+                "has unprocessed remarks (the latest one once everything is processed): every remark with its id, its page, the element it targets " +
+                "(id, name, path, box) or the area and the elements inside it, its processing state, and the captures of elements and areas as " +
+                "images. It also lists every round with its progress. Reading never changes anything: once you have applied remarks, report it " +
+                "with mark_feedback_processed.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    round: {
+                        type: "number",
+                        description: "Number of the feedback round to read (default: the oldest round still to process, else the latest one).",
+                    },
+                    captures: {
+                        type: "boolean",
+                        description: "Include the captures of elements and areas as images (default true). Set false to save context.",
+                    },
+                },
+            },
+        },
+        {
+            name: "mark_feedback_processed",
+            description: "Report that you have handled remarks of a feedback round read with get_feedback. The user follows this progress in the GUI's " +
+                "feedback page, round by round: call it once the changes are actually made, with the ids of the remarks you handled and a short " +
+                "note of what you changed. Leave remark_ids out to mark every remark of the round.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    round: { type: "number", description: "Number of the feedback round, as shown by get_feedback." },
+                    remark_ids: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Ids of the handled remarks (rm_...), as listed by get_feedback. Omit to mark the whole round.",
+                    },
+                    note: {
+                        type: "string",
+                        description: "What you changed, in one or two sentences. Shown to the user next to each marked remark.",
+                    },
+                },
+                required: ["round"],
+            },
+        },
         {
             name: "get_changes",
             description: "Show every node added, modified, removed or reordered since the last mark_synced — this is how you pick up what the user changed by hand in the GUI. Reading changes never acknowledges them; call mark_synced once the changes are integrated into the code.",
@@ -820,6 +1034,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "delete_design": {
                 const result = deleteDesign(store, params);
+                feedback.deleteDesign(result.designId);
+                notifyRemarksChanged();
                 broadcastToGUI({ type: "DESIGNS_UPDATED", data: { designs: store.list() }, timestamp: new Date().toISOString() });
                 return result;
             }
@@ -828,6 +1044,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 notifyDesignChanged(result.design.id);
                 return { ...result, content: [{ type: "text", text: result.content[0].text + guiHint(result.design.id) }] };
             }
+            case "add_image": {
+                const result = addImage(store, params);
+                notifyDesignChanged(result.design.id);
+                return { ...result, content: [{ type: "text", text: result.content[0].text + guiHint(result.design.id) }] };
+            }
             case "update_nodes": {
                 const result = updateNodes(store, params);
                 notifyDesignChanged(result.design.id);
@@ -870,6 +1091,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "get_changes":
                 return getChanges(store, params);
+            case "get_feedback":
+                return getFeedback(feedback, params);
+            case "mark_feedback_processed": {
+                const result = markFeedbackProcessed(feedback, params);
+                notifyRemarksChanged();
+                return result;
+            }
             case "mark_synced": {
                 const result = markSynced(store, params);
                 notifyDesignChanged(result.design.id);

package/dist/src/tools/add-image.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+export declare function addImage(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/add-image.js

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import { buildNode, DesignError } from "../core/node-factory.js";
+import { requireString, textResult } from "./types.js";
+/** Champs du noeud que l'appel peut fixer, en plus de l'image elle-même. */
+const NODE_FIELDS = ["id", "name", "parentId", "x", "y", "width", "height", "rotation", "opacity", "fit"];
+/**
+ * Octets de l'image : le contenu transmis par le relais du gateway quand il est
+ * présent, sinon le fichier désigné par `file_path`, lu sur cette machine.
+ */
+function readImageBytes(args) {
+    if (typeof args.file_content === "string" && args.file_content !== "") {
+        return Buffer.from(args.file_content, "base64");
+    }
+    const filePath = requireString(args, "file_path");
+    if (!path.isAbsolute(filePath))
+        throw new DesignError(`file_path must be an absolute path: ${filePath}`);
+    if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile())
+        throw new DesignError(`File not found: ${filePath}`);
+    return fs.readFileSync(filePath);
+}
+/**
+ * Taille de la boîte : celle demandée, sinon les dimensions naturelles de
+ * l'image. Une seule dimension donnée, l'autre suit les proportions de l'image.
+ */
+function boxSize(image, width, height) {
+    const w = width === undefined ? undefined : Number(width);
+    const h = height === undefined ? undefined : Number(height);
+    if (w !== undefined && h !== undefined)
+        return { width: w, height: h };
+    if (w !== undefined)
+        return { width: w, height: Math.round(((w * image.height) / image.width) * 100) / 100 };
+    if (h !== undefined)
+        return { width: Math.round(((h * image.width) / image.height) * 100) / 100, height: h };
+    return { width: image.width, height: image.height };
+}
+export function addImage(store, args) {
+    const params = args ?? {};
+    const id = requireString(params, "design_id");
+    const current = store.get(id);
+    const image = store.images.save(readImageBytes(params));
+    const input = { type: "image", image: image.name };
+    for (const field of NODE_FIELDS) {
+        if (params[field] !== undefined)
+            input[field] = params[field];
+    }
+    if (input.name === undefined) {
+        const original = typeof params.file_name === "string" ? params.file_name : String(params.file_path ?? "");
+        const base = path.basename(original.replace(/\\/g, "/")).replace(/\.[^.]+$/, "");
+        if (base !== "")
+            input.name = base;
+    }
+    Object.assign(input, boxSize(image, params.width, params.height));
+    const node = buildNode(input, new Set(current.nodes.map((n) => n.id)), current.nodes.length + 1);
+    const design = store.mutate(id, "agent", (draft) => {
+        draft.nodes.push(node);
+    });
+    return {
+        ...textResult(`Added image ${node.id} — "${node.name}" to "${design.name}" at ${Math.round(node.x)},${Math.round(node.y)} ` +
+            `size ${Math.round(node.width)}x${Math.round(node.height)}, fit ${node.fit}.\n` +
+            `Stored as "${image.name}" (${image.format}, ${image.width}x${image.height} px, ${image.bytes} bytes). ` +
+            `Use that name as the "image" field of an image node in add_nodes to place the same picture again.`),
+        design,
+    };
+}

package/dist/src/tools/add-nodes.js

@@ -12,6 +12,8 @@ export function addNodes(store, args) {
     // Tout est construit avant d'écrire : une entrée invalide n'ajoute rien du tout.
     input.forEach((raw, index) => {
         const node = buildNode(raw, existingIds, current.nodes.length + index + 1);
+        if (node.type === "image")
+            store.images.requireStored(node.image ?? "");
         existingIds.add(node.id);
         created.push(node);
     });

package/dist/src/tools/delete-design.d.ts

@@ -1,3 +1,5 @@
 import type { DesignStore } from "../core/design-store.js";
 import { type ToolResult } from "./types.js";
-export declare function deleteDesign(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult;
+export declare function deleteDesign(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult & {
+    designId: string;
+};

package/dist/src/tools/delete-design.js

@@ -3,5 +3,8 @@ export function deleteDesign(store, args) {
     const id = requireString(args, "design_id");
     const design = store.get(id);
     store.delete(id);
-    return textResult(`Design "${design.name}" (${id}) deleted, along with its ${design.nodes.length} node(s).`);
+    return {
+        ...textResult(`Design "${design.name}" (${id}) deleted, along with its ${design.nodes.length} node(s) and its remarks.`),
+        designId: id,
+    };
 }

package/dist/src/tools/export-design.js

@@ -15,7 +15,7 @@ export function exportDesignTool(store, args) {
         throw new Error(`Unknown format "${String(format)}". Expected one of: ${EXPORT_FORMATS.join(", ")}.`);
     }
     const design = store.get(id);
-    const content = render(design, format);
+    const content = render(design, format, store.images);
     const destination = typeof args?.destination_path === "string" ? args.destination_path.trim() : "";
     if (!destination) {
         return textResult(content);

package/dist/src/tools/get-feedback.d.ts

@@ -0,0 +1,3 @@
+import type { FeedbackStore } from "../core/feedback-store.js";
+import type { ImageToolResult } from "./types.js";
+export declare function getFeedback(feedback: FeedbackStore, args: Record<string, unknown> | undefined): ImageToolResult;

package/dist/src/tools/get-feedback.js

@@ -0,0 +1,62 @@
+import { formatFeedbackRound, roundProgress } from "../../shared/feedback.js";
+/**
+ * Retour de l'utilisateur : les remarques qu'il a transmises depuis la GUI avec
+ * « Terminer les retours », figées dans un retour numéroté et nommé.
+ *
+ * Sans numéro demandé, c'est le plus ancien retour encore à traiter, ou le
+ * dernier quand tout est traité. Lire un retour ne change rien : seul
+ * `mark_feedback_processed` déclare des remarques traitées.
+ */
+const STATUS_LABELS = { pending: "to process", in_progress: "in progress", done: "processed" };
+function roundLine(round) {
+    const progress = roundProgress(round);
+    return `  - round ${round.number} "${round.title}" (${round.submittedAt}): ${progress.done}/${progress.total} processed — ${STATUS_LABELS[progress.status]}`;
+}
+export function getFeedback(feedback, args) {
+    const rounds = feedback.rounds();
+    const drafts = feedback.remarks().filter((remark) => remark.status === "draft").length;
+    const draftNote = drafts > 0
+        ? `${drafts} remark(s) are still drafts in the GUI and are not part of any round yet.`
+        : "No draft remark is waiting in the GUI.";
+    if (rounds.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No feedback round has been submitted yet. ${draftNote} ` +
+                        `Ask the user to switch the GUI to "Remarques" mode and click "Terminer les retours" once their remarks are written.`,
+                },
+            ],
+        };
+    }
+    const firstOpen = rounds.find((candidate) => roundProgress(candidate).status !== "done");
+    const requested = args?.round === undefined ? (firstOpen ?? rounds[rounds.length - 1]).number : Number(args.round);
+    const round = rounds.find((candidate) => candidate.number === requested);
+    if (!round) {
+        throw new Error(`Feedback round ${args?.round} not found. Rounds 1 to ${rounds.length} exist.`);
+    }
+    const withCaptures = args?.captures !== false;
+    const footer = [
+        `Feedback rounds (${rounds.length}):`,
+        ...rounds.map(roundLine),
+        draftNote,
+        withCaptures ? "" : "Captures were left out (captures=false).",
+        "Apply the remarks, then call mark_feedback_processed with the round and the ids of the remarks you handled, " +
+            "with a short note of what you changed: the user follows that progress in the GUI.",
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
+    const content = [{ type: "text", text: `${formatFeedbackRound(round)}\n\n${footer}` }];
+    if (withCaptures) {
+        let image = 0;
+        for (const remark of round.remarks) {
+            if (!remark.capture)
+                continue;
+            image += 1;
+            const label = remark.number === null ? "whole page" : `#${remark.number}`;
+            content.push({ type: "text", text: `Image ${image} — remark ${label} on "${remark.designName}" (${remark.designId}).` });
+            content.push({ type: "image", data: feedback.readCapture(remark.capture).toString("base64"), mimeType: "image/png" });
+        }
+    }
+    return { content };
+}

package/dist/src/tools/mark-feedback-processed.d.ts

@@ -0,0 +1,8 @@
+import type { FeedbackStore } from "../core/feedback-store.js";
+import { type ToolResult } from "./types.js";
+/**
+ * L'agent déclare traitées des remarques d'un retour. C'est ce que l'utilisateur
+ * suit dans la page des retours : lire un retour avec `get_feedback` ne marque
+ * rien, seul cet outil le fait.
+ */
+export declare function markFeedbackProcessed(feedback: FeedbackStore, args: Record<string, unknown> | undefined): ToolResult;

package/dist/src/tools/mark-feedback-processed.js

@@ -0,0 +1,29 @@
+import { roundProgress } from "../../shared/feedback.js";
+import { textResult } from "./types.js";
+/**
+ * L'agent déclare traitées des remarques d'un retour. C'est ce que l'utilisateur
+ * suit dans la page des retours : lire un retour avec `get_feedback` ne marque
+ * rien, seul cet outil le fait.
+ */
+export function markFeedbackProcessed(feedback, args) {
+    const number = Number(args?.round);
+    if (!Number.isInteger(number) || number < 1)
+        throw new Error(`"round" is required and must be a feedback round number.`);
+    const rawIds = args?.remark_ids;
+    if (rawIds !== undefined && (!Array.isArray(rawIds) || rawIds.some((id) => typeof id !== "string"))) {
+        throw new Error(`"remark_ids" must be an array of remark ids, as listed by get_feedback.`);
+    }
+    const note = typeof args?.note === "string" ? args.note : null;
+    const round = feedback.setProcessed({
+        round: number,
+        remarkIds: rawIds,
+        processed: true,
+        by: "agent",
+        note,
+    });
+    const progress = roundProgress(round);
+    const marked = rawIds === undefined ? "Every remark" : `${rawIds.length} remark(s)`;
+    return textResult(`${marked} of feedback round ${round.number} "${round.title}" marked as processed. ` +
+        `${progress.done} of ${progress.total} remark(s) of this round are now processed` +
+        (progress.status === "done" ? " — the round is complete." : "."));
+}

package/dist/src/tools/screenshot-design.js

@@ -13,6 +13,7 @@ export function screenshotDesignTool(store, args) {
     }
     const shot = screenshotDesign(design, {
         nodeId,
+        images: store.images,
         scale: args?.scale === undefined ? undefined : Number(args.scale),
         padding: args?.padding === undefined ? (nodeId ? NODE_PADDING : 0) : Number(args.padding),
     });

package/dist/src/tools/update-nodes.js

@@ -21,7 +21,10 @@ export function updateNodes(store, args) {
         if (Object.keys(fields).length === 0) {
             throw new DesignError(`Update for node "${nodeId}" contains no field to change.`);
         }
-        return applyPatch(node, fields);
+        const next = applyPatch(node, fields);
+        if (next.type === "image" && fields.image !== undefined)
+            store.images.requireStored(next.image ?? "");
+        return next;
     });
     const patchedById = new Map(patched.map((n) => [n.id, n]));
     const design = store.mutate(id, "agent", (draft) => {

package/dist/src/version.d.ts

@@ -1 +1 @@
-export declare const APP_VERSION = "1.0.10";
+export declare const APP_VERSION: string;

package/dist/src/version.js

@@ -1,2 +1,16 @@
-// Auto-generated version file - do not edit manually
-export const APP_VERSION = '1.0.10';
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+// Lit la version dans le premier package.json trouvé en remontant depuis ce module.
+function readPackageVersion() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    while (!existsSync(path.join(dir, "package.json"))) {
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            throw new Error("package.json introuvable");
+        dir = parent;
+    }
+    const pkg = JSON.parse(readFileSync(path.join(dir, "package.json"), "utf8"));
+    return pkg.version;
+}
+export const APP_VERSION = readPackageVersion();