@imenam/mcp-feature-analyzer 1.0.13 → 1.0.14

package/dist/shared/context-expansion.d.ts

@@ -1,29 +1,39 @@
 import type { FileDiff } from "./schemas/diff.schema.js";
 /** Nombre de lignes de contexte ajoutées, ou retirées, au-dessus et en dessous d'un bloc par clic. */
 export declare const CONTEXT_STEP = 5;
-/** État du contexte d'un bloc élargi. */
+/** État du contexte d'un bloc affiché. */
 export interface HunkContext {
     /** Lignes de contexte affichées au-dessus de la première ligne modifiée du bloc. */
     context: number;
-    /** Lignes de contexte ajoutées au-dessus et en dessous du bloc. */
-    above: number;
-    below: number;
+    /** Indices des blocs du diff d'origine réunis dans ce bloc. */
+    members: number[];
+    /** Le bloc porte des lignes de contexte ajoutées. */
+    canShrink: boolean;
     /** Le fichier a encore des lignes à ajouter au-dessus ou en dessous du bloc. */
     canGrow: boolean;
 }
 export interface ExpandedDiff {
     fileDiff: FileDiff;
-    /** Contexte de chaque bloc, dans l'ordre des blocs. */
+    /** Contexte de chaque bloc affiché, dans l'ordre des blocs. */
     hunks: HunkContext[];
+    /** Lignes ajoutées autour de chaque bloc du diff d'origine, du côté qui en compte le plus. */
+    extras: number[];
     /** Numéros, côté « nouveau », des lignes de contexte ajoutées. */
     added: Set<number>;
 }
 /**
  * Diff de `fileDiff` dont chaque bloc `i` gagne jusqu'à `extras[i]` lignes de
- * contexte au-dessus et autant en dessous, tirées de `newContent`. Les blocs
- * ne fusionnent pas : les lignes entre deux blocs vont d'abord au bloc du
- * dessus, puis au bloc du dessous, sans jamais se recouvrir ; le début et la
- * fin du fichier bornent aussi l'élargissement. Un bloc sans ligne ajoutée
- * reste inchangé. Null quand le snapshot ne conserve pas le contenu du fichier.
+ * contexte au-dessus et autant en dessous, tirées de `newContent`. Les lignes
+ * entre deux blocs vont d'abord au bloc du dessus, puis au bloc du dessous,
+ * sans jamais se recouvrir ; le début et la fin du fichier bornent aussi
+ * l'élargissement. Deux blocs que plus aucune ligne masquée ne sépare n'en
+ * forment plus qu'un. Un bloc sans ligne ajoutée ni voisin réuni reste
+ * inchangé. Null quand le snapshot ne conserve pas le contenu du fichier.
  */
 export declare function expandContext(fileDiff: FileDiff, extras: readonly number[]): ExpandedDiff | null;
+/**
+ * Élargissement de chaque bloc d'origine après un clic sur « +5 » (`delta`
+ * `1`) ou « −5 » (`-1`) dans l'en-tête du bloc affiché `hunkIndex` : chacun
+ * des blocs qu'il réunit gagne ou perd une tranche de lignes.
+ */
+export declare function stepContext(expanded: ExpandedDiff, hunkIndex: number, delta: 1 | -1): number[];

package/dist/shared/context-expansion.js

@@ -5,6 +5,20 @@ export const CONTEXT_STEP = 5;
 function headerRange(start, count) {
     return count === 1 ? `${start}` : `${start},${count}`;
 }
+/** Bloc couvrant les plages données, en-tête recalculé à partir de celui de `source`. */
+function rangedHunk(source, oldStart, newStart, lines) {
+    const oldLines = lines.filter((line) => line.type !== "add").length;
+    const newLines = lines.filter((line) => line.type !== "del").length;
+    const rest = source.header.replace(/^@@[^@]*@@/, "");
+    return {
+        header: `@@ -${headerRange(oldStart, oldLines)} +${headerRange(newStart, newLines)} @@${rest}`,
+        oldStart,
+        oldLines,
+        newStart,
+        newLines,
+        lines,
+    };
+}
 /** Nombre de lignes de contexte en tête du bloc, avant sa première ligne modifiée. */
 function leadingContext(hunk) {
     const index = hunk.lines.findIndex((line) => line.type !== "context");
@@ -12,19 +26,19 @@ function leadingContext(hunk) {
 }
 /**
  * Diff de `fileDiff` dont chaque bloc `i` gagne jusqu'à `extras[i]` lignes de
- * contexte au-dessus et autant en dessous, tirées de `newContent`. Les blocs
- * ne fusionnent pas : les lignes entre deux blocs vont d'abord au bloc du
- * dessus, puis au bloc du dessous, sans jamais se recouvrir ; le début et la
- * fin du fichier bornent aussi l'élargissement. Un bloc sans ligne ajoutée
- * reste inchangé. Null quand le snapshot ne conserve pas le contenu du fichier.
+ * contexte au-dessus et autant en dessous, tirées de `newContent`. Les lignes
+ * entre deux blocs vont d'abord au bloc du dessus, puis au bloc du dessous,
+ * sans jamais se recouvrir ; le début et la fin du fichier bornent aussi
+ * l'élargissement. Deux blocs que plus aucune ligne masquée ne sépare n'en
+ * forment plus qu'un. Un bloc sans ligne ajoutée ni voisin réuni reste
+ * inchangé. Null quand le snapshot ne conserve pas le contenu du fichier.
  */
 export function expandContext(fileDiff, extras) {
     if (fileDiff.newContent === null)
         return null;
     const content = splitLines(fileDiff.newContent);
     const added = new Set();
-    const contexts = [];
-    const hunks = [];
+    const parts = [];
     // Écart entre les numéros des deux côtés avant le bloc courant, et dernière ligne déjà affichée.
     let offset = 0;
     let shownUntil = 0;
@@ -44,32 +58,58 @@ export function expandContext(fileDiff, extras) {
             added.add(newNo);
             return { type: "context", oldNo: newNo + shift, newNo, text: content[newNo - 1] };
         };
-        if (above === 0 && below === 0) {
-            hunks.push(hunk);
-        }
-        else {
-            const lines = [
+        const expanded = above === 0 && below === 0
+            ? hunk
+            : rangedHunk(hunk, (hunk.oldLines === 0 ? hunk.oldStart + 1 : hunk.oldStart) - above, first - above, [
                 ...Array.from({ length: above }, (_, k) => contextLine(first - above + k, offset)),
                 ...hunk.lines,
                 ...Array.from({ length: below }, (_, k) => contextLine(last + 1 + k, after)),
-            ];
-            const oldStart = (hunk.oldLines === 0 ? hunk.oldStart + 1 : hunk.oldStart) - above;
-            const newStart = first - above;
-            const oldLines = hunk.oldLines + above + below;
-            const newLines = hunk.newLines + above + below;
-            const rest = hunk.header.replace(/^@@[^@]*@@/, "");
-            hunks.push({
-                header: `@@ -${headerRange(oldStart, oldLines)} +${headerRange(newStart, newLines)} @@${rest}`,
-                oldStart,
-                oldLines,
-                newStart,
-                newLines,
-                lines,
-            });
-        }
-        contexts.push({ context: leadingContext(hunk) + above, above, below, canGrow: above < aboveRoom || below < belowRoom });
+            ]);
+        parts.push({
+            hunk: expanded,
+            above,
+            below,
+            canGrow: above < aboveRoom || below < belowRoom,
+            joinsPrevious: index > 0 && above === aboveRoom,
+        });
         offset = after;
         shownUntil = last + below;
     });
-    return { fileDiff: { ...fileDiff, hunks }, hunks: contexts, added };
+    const groups = [];
+    parts.forEach((part, index) => {
+        if (part.joinsPrevious)
+            groups[groups.length - 1].push(index);
+        else
+            groups.push([index]);
+    });
+    const hunks = groups.map((members) => {
+        if (members.length === 1)
+            return parts[members[0]].hunk;
+        const head = parts[members[0]].hunk;
+        return rangedHunk(head, head.oldLines === 0 ? head.oldStart + 1 : head.oldStart, head.newLines === 0 ? head.newStart + 1 : head.newStart, members.flatMap((member) => parts[member].hunk.lines));
+    });
+    const contexts = groups.map((members) => ({
+        context: leadingContext(fileDiff.hunks[members[0]]) + parts[members[0]].above,
+        members,
+        canShrink: members.some((member) => parts[member].above > 0 || parts[member].below > 0),
+        canGrow: members.some((member) => parts[member].canGrow),
+    }));
+    return {
+        fileDiff: { ...fileDiff, hunks },
+        hunks: contexts,
+        extras: parts.map((part) => Math.max(part.above, part.below)),
+        added,
+    };
+}
+/**
+ * Élargissement de chaque bloc d'origine après un clic sur « +5 » (`delta`
+ * `1`) ou « −5 » (`-1`) dans l'en-tête du bloc affiché `hunkIndex` : chacun
+ * des blocs qu'il réunit gagne ou perd une tranche de lignes.
+ */
+export function stepContext(expanded, hunkIndex, delta) {
+    const next = [...expanded.extras];
+    for (const member of expanded.hunks[hunkIndex].members) {
+        next[member] = Math.max(0, next[member] + delta * CONTEXT_STEP);
+    }
+    return next;
 }

package/dist/shared/inline-diff.d.ts

@@ -0,0 +1,26 @@
+import type { DiffLine } from "./schemas/diff.schema.js";
+import type { MergedLine } from "./reindent.js";
+/** Plage de caractères d'une ligne, `start` inclus, `end` exclu. */
+export interface CharRange {
+    start: number;
+    end: number;
+}
+/** Parties d'une ligne supprimée et de la ligne ajoutée qui la remplace qui diffèrent de l'autre. */
+export interface InlineChanges {
+    removed: CharRange[];
+    added: CharRange[];
+}
+/**
+ * Parties qui diffèrent entre une ligne supprimée et la ligne ajoutée qui la
+ * remplace, comparées mot à mot. Null quand les lignes sont identiques, trop
+ * longues, ou trop différentes pour qu'un surlignage partiel ait un sens :
+ * moins de la moitié de leurs mots, hors espaces, en commun.
+ */
+export declare function inlineChanges(oldText: string, newText: string): InlineChanges | null;
+/**
+ * Parties modifiées des lignes d'un bloc. Dans chaque suite de lignes supprimées
+ * suivie de lignes ajoutées, hors lignes dont seule l'indentation change, la
+ * i-ème ligne supprimée est comparée à la i-ème ligne ajoutée. Seules les lignes
+ * dont la comparaison aboutit figurent dans le résultat.
+ */
+export declare function inlineChangesOfLines(lines: MergedLine[]): Map<DiffLine, CharRange[]>;

package/dist/shared/inline-diff.js

@@ -0,0 +1,116 @@
+/** Nombre maximal de mots d'une ligne au-delà duquel la comparaison n'est pas faite. */
+const MAX_TOKENS = 400;
+/** Part minimale des mots, hors espaces, communs aux deux lignes pour les comparer mot à mot. */
+const MIN_SIMILARITY = 0.5;
+/** Mots d'une ligne : identifiants et nombres, suites d'espaces, et chaque autre caractère seul. */
+function tokenize(text) {
+    const tokens = [];
+    for (const match of text.matchAll(/[\p{L}\p{N}_$]+|\s+|[^\p{L}\p{N}_$\s]/gu)) {
+        tokens.push({ text: match[0], start: match.index });
+    }
+    return tokens;
+}
+function isBlank(token) {
+    return token.text.trim() === "";
+}
+/** Indices des mots de `a` et de `b` qui appartiennent à leur plus longue suite commune. */
+function commonTokens(a, b) {
+    const width = b.length + 1;
+    // lengths[i * width + j] : longueur de la plus longue suite commune de a[i..] et b[j..].
+    const lengths = new Uint32Array((a.length + 1) * width);
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lengths[i * width + j] =
+                a[i].text === b[j].text ? lengths[(i + 1) * width + j + 1] + 1 : Math.max(lengths[(i + 1) * width + j], lengths[i * width + j + 1]);
+        }
+    }
+    const inA = new Set();
+    const inB = new Set();
+    let i = 0;
+    let j = 0;
+    while (i < a.length && j < b.length) {
+        if (a[i].text === b[j].text) {
+            inA.add(i++);
+            inB.add(j++);
+        }
+        else if (lengths[(i + 1) * width + j] >= lengths[i * width + j + 1])
+            i++;
+        else
+            j++;
+    }
+    return { inA, inB };
+}
+/**
+ * Plages couvertes par les mots absents de `common`, les mots voisins réunis en
+ * une plage ; les espaces en bord de plage n'en font pas partie.
+ */
+function changedRanges(tokens, common) {
+    const runs = [];
+    tokens.forEach((token, index) => {
+        if (common.has(index))
+            return;
+        const last = runs[runs.length - 1];
+        if (last && last[last.length - 1] === tokens[index - 1])
+            last.push(token);
+        else
+            runs.push([token]);
+    });
+    return runs.flatMap((run) => {
+        const first = run.findIndex((token) => !isBlank(token));
+        if (first === -1)
+            return [];
+        const last = run.length - 1 - [...run].reverse().findIndex((token) => !isBlank(token));
+        return [{ start: run[first].start, end: run[last].start + run[last].text.length }];
+    });
+}
+/**
+ * Parties qui diffèrent entre une ligne supprimée et la ligne ajoutée qui la
+ * remplace, comparées mot à mot. Null quand les lignes sont identiques, trop
+ * longues, ou trop différentes pour qu'un surlignage partiel ait un sens :
+ * moins de la moitié de leurs mots, hors espaces, en commun.
+ */
+export function inlineChanges(oldText, newText) {
+    if (oldText === newText)
+        return null;
+    const oldTokens = tokenize(oldText);
+    const newTokens = tokenize(newText);
+    if (oldTokens.length > MAX_TOKENS || newTokens.length > MAX_TOKENS)
+        return null;
+    const { inA, inB } = commonTokens(oldTokens, newTokens);
+    const shared = [...inA].filter((index) => !isBlank(oldTokens[index])).length;
+    const longest = Math.max(oldTokens.filter((token) => !isBlank(token)).length, newTokens.filter((token) => !isBlank(token)).length);
+    if (longest === 0 || shared / longest < MIN_SIMILARITY)
+        return null;
+    return { removed: changedRanges(oldTokens, inA), added: changedRanges(newTokens, inB) };
+}
+/**
+ * Parties modifiées des lignes d'un bloc. Dans chaque suite de lignes supprimées
+ * suivie de lignes ajoutées, hors lignes dont seule l'indentation change, la
+ * i-ème ligne supprimée est comparée à la i-ème ligne ajoutée. Seules les lignes
+ * dont la comparaison aboutit figurent dans le résultat.
+ */
+export function inlineChangesOfLines(lines) {
+    const result = new Map();
+    const single = (index, type) => lines[index]?.oldLine === null && lines[index].line.type === type;
+    let index = 0;
+    while (index < lines.length) {
+        if (!single(index, "del")) {
+            index++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        while (single(index, "del"))
+            removed.push(lines[index++].line);
+        while (single(index, "add"))
+            added.push(lines[index++].line);
+        for (let pair = 0; pair < Math.min(removed.length, added.length); pair++) {
+            const changes = inlineChanges(removed[pair].text, added[pair].text);
+            if (!changes)
+                continue;
+            result.set(removed[pair], changes.removed);
+            result.set(added[pair], changes.added);
+        }
+    }
+    return result;
+}

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

@@ -114,6 +114,7 @@ export declare const NoteSchema: z.ZodObject<{
         path: z.ZodString;
         line: z.ZodNullable<z.ZodNumber>;
     }, z.core.$strip>>;
+    findingId: z.ZodNullable<z.ZodString>;
     text: z.ZodString;
     createdAt: z.ZodString;
 }, z.core.$strip>;
@@ -310,6 +311,7 @@ export declare const AnalysisSchema: z.ZodObject<{
             path: z.ZodString;
             line: z.ZodNullable<z.ZodNumber>;
         }, z.core.$strip>>;
+        findingId: z.ZodNullable<z.ZodString>;
         text: z.ZodString;
         createdAt: z.ZodString;
     }, z.core.$strip>>;

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

@@ -88,6 +88,8 @@ export const NoteLocationSchema = z.object({
 export const NoteSchema = z.object({
     id: ItemIdSchema,
     location: NoteLocationSchema.nullable(),
+    /** Constat auquel la remarque répond ; null pour une remarque libre. Supprimer le constat supprime la remarque. */
+    findingId: ItemIdSchema.nullable(),
     text: z.string().min(1),
     createdAt: IsoDateSchema,
 });

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

@@ -12,10 +12,14 @@ export declare const SetFindingStatusBodySchema: z.ZodObject<{
     }>;
     baseRevision: z.ZodNumber;
 }, z.core.$strict>;
-/** Remarque sur une ligne du côté « nouveau » (`line`), ou sur le fichier entier (`line` absent ou null). */
+/**
+ * Remarque sur une ligne du côté « nouveau » (`line`), ou sur le fichier entier (`line` absent ou null).
+ * `findingId` lie la remarque au constat auquel elle répond.
+ */
 export declare const AddNoteBodySchema: z.ZodObject<{
     path: z.ZodString;
     line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    findingId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     text: z.ZodString;
     baseRevision: z.ZodNumber;
 }, z.core.$strict>;
@@ -71,6 +75,7 @@ export declare const AddNoteRequestSchema: z.ZodObject<{
     body: z.ZodObject<{
         path: z.ZodString;
         line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        findingId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         text: z.ZodString;
         baseRevision: z.ZodNumber;
     }, z.core.$strict>;

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

@@ -15,10 +15,14 @@ export const SetFindingStatusBodySchema = z.strictObject({
     status: z.enum(FINDING_STATUSES),
     baseRevision: BaseRevisionSchema,
 });
-/** Remarque sur une ligne du côté « nouveau » (`line`), ou sur le fichier entier (`line` absent ou null). */
+/**
+ * Remarque sur une ligne du côté « nouveau » (`line`), ou sur le fichier entier (`line` absent ou null).
+ * `findingId` lie la remarque au constat auquel elle répond.
+ */
 export const AddNoteBodySchema = z.strictObject({
     path: z.string().min(1),
     line: z.number().int().nullable().optional(),
+    findingId: z.string().min(1).nullable().optional(),
     text: z.string().trim().min(1, "the note text is empty"),
     baseRevision: BaseRevisionSchema,
 });

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

@@ -13,6 +13,7 @@ import type { Analysis } from "../../shared/schemas/analysis.schema.js";
  *   disponible et endLine ≤ nombre de lignes ;
  * - les liens d'un schéma relient des nœuds existants ; en `layers`, chaque nœud a une couche
  *   déclarée dans `layers`, sans doublon ;
+ * - une remarque liée à un constat vise un constat existant ;
  * - la revue ne sélectionne que des constats et remarques existants, et son état est cohérent.
  */
 export declare function findInvariantViolations(analysis: Analysis): string[];

package/dist/src/core/invariants.js

@@ -24,6 +24,7 @@ function duplicates(ids) {
  *   disponible et endLine ≤ nombre de lignes ;
  * - les liens d'un schéma relient des nœuds existants ; en `layers`, chaque nœud a une couche
  *   déclarée dans `layers`, sans doublon ;
+ * - une remarque liée à un constat vise un constat existant ;
  * - la revue ne sélectionne que des constats et remarques existants, et son état est cohérent.
  */
 export function findInvariantViolations(analysis) {
@@ -136,6 +137,11 @@ export function findInvariantViolations(analysis) {
         if (!noteIds.has(id))
             problems.push(`review selects unknown note "${id}"`);
     }
+    for (const note of analysis.notes) {
+        if (note.findingId !== null && !findingIds.has(note.findingId)) {
+            problems.push(`note "${note.id}" answers unknown finding "${note.findingId}"`);
+        }
+    }
     if (review.state === "submitted" && (review.decision === null || review.submittedAt === null)) {
         problems.push("a submitted review needs a decision and a submittedAt date");
     }

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

@@ -14,6 +14,8 @@ export declare const addProject: MigrationStep;
 export declare const addOverview: MigrationStep;
 /** Ajoute `explanations` vide : l'analyse n'a pas encore d'explication. */
 export declare const addExplanations: MigrationStep;
+/** Ajoute `findingId` à null sur les remarques qui n'en ont pas : elles restent des remarques libres. */
+export declare const addNoteFindingIds: MigrationStep;
 /** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
 export declare const ANALYSIS_MIGRATIONS: readonly MigrationStep[];
 /** Étapes appliquées aux snapshots de diff (`diffs/<id>.json`), dans l'ordre. */

package/dist/src/core/migrate.js

@@ -26,8 +26,18 @@ export const addProject = (doc) => {
 export const addOverview = (doc) => (doc.overview !== undefined ? null : { ...doc, overview: null });
 /** Ajoute `explanations` vide : l'analyse n'a pas encore d'explication. */
 export const addExplanations = (doc) => (doc.explanations !== undefined ? null : { ...doc, explanations: [] });
+/** Ajoute `findingId` à null sur les remarques qui n'en ont pas : elles restent des remarques libres. */
+export const addNoteFindingIds = (doc) => {
+    if (!Array.isArray(doc.notes))
+        return null;
+    const notes = doc.notes;
+    const missing = (note) => !!note && typeof note === "object" && note.findingId === undefined;
+    if (!notes.some(missing))
+        return null;
+    return { ...doc, notes: notes.map((note) => (missing(note) ? { ...note, findingId: null } : note)) };
+};
 /** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
-export const ANALYSIS_MIGRATIONS = [addProject, addOverview, addExplanations];
+export const ANALYSIS_MIGRATIONS = [addProject, addOverview, addExplanations, addNoteFindingIds];
 /** Étapes appliquées aux snapshots de diff (`diffs/<id>.json`), dans l'ordre. */
 export const SNAPSHOT_MIGRATIONS = [];
 /** Applique `steps` à la suite. Renvoie null si aucune étape n'a modifié le document. */

package/dist/src/core/review-actions.d.ts

@@ -13,7 +13,10 @@ export declare function setFileReviewed(store: AnalysisStore, analysisId: string
  * le réancre.
  */
 export declare function setFindingStatus(store: AnalysisStore, analysisId: string, findingId: string, body: SetFindingStatusBody): Analysis;
-/** Ajoute une remarque du relecteur sur une ligne du côté « nouveau » ou sur un fichier entier. */
+/**
+ * Ajoute une remarque du relecteur sur une ligne du côté « nouveau » ou sur un fichier entier,
+ * liée au constat `findingId` quand elle y répond.
+ */
 export declare function addNote(store: AnalysisStore, analysisId: string, body: AddNoteBody): Analysis;
 /**
  * Remplace le texte d'une remarque. Quand elle fait partie d'une revue soumise,

package/dist/src/core/review-actions.js

@@ -34,14 +34,22 @@ export function setFindingStatus(store, analysisId, findingId, body) {
         finding.status = body.status;
     }, { baseRevision: body.baseRevision });
 }
-/** Ajoute une remarque du relecteur sur une ligne du côté « nouveau » ou sur un fichier entier. */
+/**
+ * Ajoute une remarque du relecteur sur une ligne du côté « nouveau » ou sur un fichier entier,
+ * liée au constat `findingId` quand elle y répond.
+ */
 export function addNote(store, analysisId, body) {
     return store.mutate(analysisId, "user", (draft) => {
         const location = { path: body.path, line: body.line ?? null };
         assertNoteLocation(draft.files, location);
+        const findingId = body.findingId ?? null;
+        if (findingId !== null && !draft.findings.some((finding) => finding.id === findingId)) {
+            throw new NotFoundError(`Finding "${findingId}" not found in analysis "${analysisId}".`);
+        }
         draft.notes.push({
             id: itemId("note", new Set(draft.notes.map((note) => note.id))),
             location,
+            findingId,
             text: body.text,
             createdAt: new Date().toISOString(),
         });

package/dist/src/index.js

@@ -523,7 +523,8 @@ const TOOLS = [
     },
     {
         name: "delete_findings",
-        description: "Delete findings by id, typically once refresh_analysis shows them solved. If any id is unknown, nothing is deleted.",
+        description: "Delete findings by id, typically once refresh_analysis shows them solved. The reviewer notes written on these findings are deleted with them. " +
+            "If any id is unknown, nothing is deleted.",
         inputSchema: {
             type: "object",
             properties: {

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

@@ -1,7 +1,8 @@
 import type { AnalysisStore } from "../core/analysis-store.js";
 import { type Args, type MutationResult } from "./types.js";
 /**
- * Supprime des constats par identifiant et les retire de la sélection de la
- * revue. Un identifiant inconnu fait échouer l'appel sans rien supprimer.
+ * Supprime des constats par identifiant, avec les remarques du relecteur qui
+ * leur répondent, et les retire de la sélection de la revue. Un identifiant
+ * inconnu fait échouer l'appel sans rien supprimer.
  */
 export declare function deleteFindings(store: AnalysisStore, args: Args): MutationResult;

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

@@ -1,13 +1,15 @@
 import { AnalysisError } from "../core/errors.js";
 import { rejectUnknownFields, requireString, requireStringArray, textResult } from "./types.js";
 /**
- * Supprime des constats par identifiant et les retire de la sélection de la
- * revue. Un identifiant inconnu fait échouer l'appel sans rien supprimer.
+ * Supprime des constats par identifiant, avec les remarques du relecteur qui
+ * leur répondent, et les retire de la sélection de la revue. Un identifiant
+ * inconnu fait échouer l'appel sans rien supprimer.
  */
 export function deleteFindings(store, args) {
     rejectUnknownFields(args, ["analysis_id", "finding_ids"]);
     const id = requireString(args, "analysis_id");
     const ids = [...new Set(requireStringArray(args, "finding_ids", 1))];
+    let removedNoteCount = 0;
     const updated = store.mutate(id, "agent", (draft) => {
         const known = new Set(draft.findings.map((finding) => finding.id));
         const unknown = ids.filter((findingId) => !known.has(findingId));
@@ -18,10 +20,15 @@ export function deleteFindings(store, args) {
         const removed = new Set(ids);
         draft.findings = draft.findings.filter((finding) => !removed.has(finding.id));
         draft.review.selectedFindingIds = draft.review.selectedFindingIds.filter((findingId) => !removed.has(findingId));
+        const removedNotes = new Set(draft.notes.filter((note) => note.findingId !== null && removed.has(note.findingId)).map((note) => note.id));
+        removedNoteCount = removedNotes.size;
+        draft.notes = draft.notes.filter((note) => !removedNotes.has(note.id));
+        draft.review.selectedNoteIds = draft.review.selectedNoteIds.filter((noteId) => !removedNotes.has(noteId));
     });
+    const notes = removedNoteCount > 0 ? ` ${removedNoteCount} reviewer note(s) answering them were deleted too.` : "";
     return {
         result: textResult(`Deleted ${ids.length} finding(s) from "${updated.title}" (${updated.id}): ${ids.join(", ")}. ` +
-            `${updated.findings.length} finding(s) remain.`),
+            `${updated.findings.length} finding(s) remain.${notes}`),
         analysisId: updated.id,
     };
 }