@imenam/mcp-feature-analyzer 1.0.0

package/dist/shared/diagram-quality.d.ts

@@ -0,0 +1,30 @@
+import { type DiagramLayout } from "./diagram-layout.js";
+import type { Diagram } from "./schemas/analysis.schema.js";
+/** Lien désigné par ses extrémités et sa position dans `diagram.links`. */
+export interface LinkRef {
+    index: number;
+    from: string;
+    to: string;
+}
+export interface LinkCrossing {
+    a: LinkRef;
+    b: LinkRef;
+}
+export interface NodeOverlap {
+    link: LinkRef;
+    /** Identifiant du nœud traversé. */
+    node: string;
+}
+export interface DiagramQuality {
+    crossings: LinkCrossing[];
+    nodeOverlaps: NodeOverlap[];
+}
+/**
+ * Croisements et traversées de nœuds du tracé de `diagram`. Deux liens qui
+ * partent du même nœud ou y arrivent ne se croisent pas en s'y rejoignant ;
+ * seul un croisement franc entre eux compte. `layout` évite de recalculer un
+ * placement déjà connu ; il doit provenir de `layoutDiagram(diagram)`.
+ */
+export declare function diagramQuality(diagram: Diagram, layout?: DiagramLayout): DiagramQuality;
+/** Vrai quand le schéma ne présente ni croisement ni traversée de nœud. */
+export declare function isClean(quality: DiagramQuality): boolean;

package/dist/shared/diagram-quality.js

@@ -0,0 +1,26 @@
+/**
+ * Lisibilité d'un schéma placé : paires de liens qui se croisent et liens qui
+ * traversent un nœud qu'ils ne relient pas, mesurées sur le tracé de
+ * `layoutDiagram`. Partagé par les outils (`set_diagram`, `get_analysis`) et la GUI.
+ */
+import { routeIssues } from "./diagram-geometry.js";
+import { layoutDiagram } from "./diagram-layout.js";
+/**
+ * Croisements et traversées de nœuds du tracé de `diagram`. Deux liens qui
+ * partent du même nœud ou y arrivent ne se croisent pas en s'y rejoignant ;
+ * seul un croisement franc entre eux compte. `layout` évite de recalculer un
+ * placement déjà connu ; il doit provenir de `layoutDiagram(diagram)`.
+ */
+export function diagramQuality(diagram, layout = layoutDiagram(diagram)) {
+    const index = new Map(diagram.nodes.map((node, position) => [node.id, position]));
+    const refs = diagram.links.map((link, position) => ({ index: position, from: link.from, to: link.to }));
+    const issues = routeIssues(layout.nodes, layout.links.map((link) => ({ u: index.get(link.from), v: index.get(link.to), points: link.points })));
+    return {
+        crossings: issues.crossings.map(([a, b]) => ({ a: refs[a], b: refs[b] })),
+        nodeOverlaps: issues.overlaps.map(({ link, node }) => ({ link: refs[link], node: diagram.nodes[node].id })),
+    };
+}
+/** Vrai quand le schéma ne présente ni croisement ni traversée de nœud. */
+export function isClean(quality) {
+    return quality.crossings.length === 0 && quality.nodeOverlaps.length === 0;
+}

package/dist/shared/labels.d.ts

@@ -0,0 +1,31 @@
+import type { AnalysisMode, FileStatus, FindingKind, FindingStatus, NodeStatus, ReviewDecision, ReviewProgressState, Severity } from "./schemas/analysis.schema.js";
+/** Libellé et couleurs d'une pastille : texte `color` sur fond `background`. */
+export interface BadgeStyle {
+    label: string;
+    color: string;
+    background: string;
+}
+export declare const SEVERITY_STYLES: Record<Severity, BadgeStyle>;
+/** Pastille des remarques du relecteur. */
+export declare const NOTE_STYLE: BadgeStyle;
+export declare const FINDING_STATUS_LABELS: Record<FindingStatus, string>;
+export declare const FINDING_KIND_LABELS: Record<FindingKind, string>;
+export declare const FILE_STATUS_LABELS: Record<FileStatus, string>;
+export declare const MODE_LABELS: Record<AnalysisMode, string>;
+export declare const DECISION_LABELS: Record<ReviewDecision, string>;
+/** Pastille de l'état d'avancement d'une revue. */
+export declare const REVIEW_PROGRESS_STYLES: Record<ReviewProgressState, BadgeStyle>;
+/** Pastille de la décision d'une revue soumise, affichée à côté de « Soumise ». */
+export declare const DECISION_STYLES: Record<ReviewDecision, BadgeStyle>;
+/**
+ * Apparence d'un nœud de schéma : fond (`fill` null : contour seul), contour,
+ * couleur du libellé et couleur de l'icône.
+ */
+export interface NodeStyle {
+    label: string;
+    fill: string | null;
+    stroke: string;
+    text: string;
+    accent: string;
+}
+export declare const NODE_STATUS_STYLES: Record<NodeStatus, NodeStyle>;

package/dist/shared/labels.js

@@ -0,0 +1,53 @@
+export const SEVERITY_STYLES = {
+    critical: { label: "Critique", color: "#f0625a", background: "#34191c" },
+    major: { label: "Majeur", color: "#e3a33b", background: "#33270f" },
+    minor: { label: "Mineur", color: "#6fb3ff", background: "#13243a" },
+    trivial: { label: "Détail", color: "#9aa1b1", background: "#1c2029" },
+};
+/** Pastille des remarques du relecteur. */
+export const NOTE_STYLE = { label: "Remarque", color: "#c4a8ff", background: "#241d3a" };
+export const FINDING_STATUS_LABELS = {
+    open: "Ouvert",
+    ignored: "Ignoré",
+    outdated: "Obsolète",
+};
+export const FINDING_KIND_LABELS = {
+    issue: "Problème",
+    requirement_gap: "Exigence manquante",
+};
+export const FILE_STATUS_LABELS = {
+    added: "Ajouté",
+    modified: "Modifié",
+    deleted: "Supprimé",
+    renamed: "Renommé",
+};
+export const MODE_LABELS = {
+    branch: "Branche",
+    working_tree: "Copie de travail",
+};
+export const DECISION_LABELS = {
+    approve: "Approuver",
+    request_changes: "Demander des corrections",
+    reject: "Rejeter",
+};
+/** Pastille de l'état d'avancement d'une revue. */
+export const REVIEW_PROGRESS_STYLES = {
+    not_started: { label: "Non commencée", color: "#9aa1b1", background: "#1c2029" },
+    in_progress: { label: "En cours", color: "#6fb3ff", background: "#13243a" },
+    files_reviewed: { label: "Fichiers revus", color: "#8b97ff", background: "#1b1f3d" },
+    submitted: { label: "Soumise", color: "#3fb950", background: "#11201a" },
+};
+/** Pastille de la décision d'une revue soumise, affichée à côté de « Soumise ». */
+export const DECISION_STYLES = {
+    approve: { label: "Approuvée", color: "#3fb950", background: "#11201a" },
+    request_changes: { label: "Corrections demandées", color: "#e3a33b", background: "#33270f" },
+    reject: { label: "Rejetée", color: "#f0625a", background: "#34191c" },
+};
+export const NODE_STATUS_STYLES = {
+    new: { label: "Nouveau", fill: "#11201a", stroke: "#2c6b3a", text: "#bfeccd", accent: "#3fb950" },
+    modified: { label: "Modifié", fill: "#151a2b", stroke: "#36407a", text: "#d5daff", accent: "#8b97ff" },
+    impacted: { label: "Impacté, non modifié", fill: "#13161f", stroke: "#2a2f3d", text: "#7b8396", accent: "#646b7b" },
+    existing: { label: "Existant", fill: "#13161f", stroke: "#2a2f3d", text: "#9aa1b1", accent: "#646b7b" },
+    finding: { label: "Constat", fill: "#221416", stroke: "#6b2a2d", text: "#f0a09a", accent: "#f0625a" },
+    missing: { label: "Attendu, absent", fill: null, stroke: "#6b2a2d", text: "#f0776f", accent: "#b0605b" },
+};

package/dist/shared/mindmap-tree.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Règle des cartes mentales : les liens forment un arbre. Une seule racine
+ * (nœud sans lien entrant), un seul parent pour chaque autre nœud, aucun
+ * cycle, tous les nœuds atteignables depuis la racine.
+ */
+import type { Diagram } from "./schemas/analysis.schema.js";
+export type MindmapProblem = {
+    kind: "self_loop";
+    node: string;
+} | {
+    kind: "no_root";
+} | {
+    kind: "several_roots";
+    roots: string[];
+} | {
+    kind: "several_parents";
+    node: string;
+    parents: string[];
+} | {
+    kind: "cycle";
+    nodes: string[];
+} | {
+    kind: "unreachable";
+    root: string;
+    nodes: string[];
+};
+/** Problèmes qui empêchent `diagram` d'être une carte mentale ; liste vide pour un arbre. */
+export declare function mindmapProblems(diagram: Pick<Diagram, "nodes" | "links">): MindmapProblem[];

package/dist/shared/mindmap-tree.js

@@ -0,0 +1,62 @@
+/** Problèmes qui empêchent `diagram` d'être une carte mentale ; liste vide pour un arbre. */
+export function mindmapProblems(diagram) {
+    const ids = diagram.nodes.map((node) => node.id);
+    const known = new Set(ids);
+    const parents = new Map(ids.map((id) => [id, []]));
+    const children = new Map(ids.map((id) => [id, []]));
+    const problems = [];
+    for (const link of diagram.links) {
+        if (!known.has(link.from) || !known.has(link.to))
+            continue;
+        if (link.from === link.to) {
+            problems.push({ kind: "self_loop", node: link.from });
+            continue;
+        }
+        parents.get(link.to).push(link.from);
+        children.get(link.from).push(link.to);
+    }
+    const roots = ids.filter((id) => parents.get(id).length === 0);
+    if (roots.length === 0 && ids.length > 0)
+        problems.push({ kind: "no_root" });
+    if (roots.length > 1)
+        problems.push({ kind: "several_roots", roots });
+    for (const id of ids) {
+        const list = parents.get(id);
+        if (list.length > 1)
+            problems.push({ kind: "several_parents", node: id, parents: list });
+    }
+    // Cycles : parcours en profondeur, un cycle relevé par lien de retour.
+    const state = new Map(ids.map((id) => [id, 0]));
+    const path = [];
+    const visit = (id) => {
+        state.set(id, 1);
+        path.push(id);
+        for (const next of children.get(id)) {
+            if (state.get(next) === 1)
+                problems.push({ kind: "cycle", nodes: [...path.slice(path.indexOf(next)), next] });
+            else if (state.get(next) === 0)
+                visit(next);
+        }
+        path.pop();
+        state.set(id, 2);
+    };
+    for (const id of [...roots, ...ids])
+        if (state.get(id) === 0)
+            visit(id);
+    if (roots.length === 1) {
+        const reached = new Set([roots[0]]);
+        const queue = [roots[0]];
+        while (queue.length > 0) {
+            for (const next of children.get(queue.shift())) {
+                if (!reached.has(next)) {
+                    reached.add(next);
+                    queue.push(next);
+                }
+            }
+        }
+        const unreachable = ids.filter((id) => !reached.has(id));
+        if (unreachable.length > 0)
+            problems.push({ kind: "unreachable", root: roots[0], nodes: unreachable });
+    }
+    return problems;
+}

package/dist/shared/prompt.d.ts

@@ -0,0 +1,17 @@
+import type { Analysis, ReviewDecision } from "./schemas/analysis.schema.js";
+/** Points retenus pour le prompt et décision du relecteur. */
+export interface PromptSelection {
+    findingIds: string[];
+    noteIds: string[];
+    decision: ReviewDecision | null;
+}
+/**
+ * Prompt de correction destiné à l'agent : en-tête (titre, refs, objectif de la
+ * feature quand la vue d'ensemble existe), décision,
+ * liste numérotée des constats retenus (du plus grave au moins grave, puis dans
+ * l'ordre de l'analyse) suivie des remarques du relecteur. Le `prompt` propre
+ * à un constat remplace son corps, ses lignes actuelles et son correctif.
+ */
+export declare function buildAgentPrompt(analysis: Analysis, selection: PromptSelection): string;
+/** Prompt de tous les constats ouverts, sans décision ni remarque. */
+export declare function buildAllOpenFindingsPrompt(analysis: Analysis): string;

package/dist/shared/prompt.js

@@ -0,0 +1,97 @@
+import { sortBySeverity } from "./severity.js";
+import { lineRange, noteLocationText } from "./text.js";
+const SEVERITY_NAMES = {
+    critical: "Critical",
+    major: "Major",
+    minor: "Minor",
+    trivial: "Trivial",
+};
+const DECISION_LINES = {
+    approve: "Decision: Approve. The feature can be merged.",
+    request_changes: "Decision: Request changes. Rework the feature and address the points below.",
+    reject: "Decision: Reject. The feature is abandoned.",
+};
+const INDENT = "   ";
+function indent(text) {
+    return text.split("\n").map((line) => (line === "" ? "" : `${INDENT}${line}`));
+}
+function fenced(label, text) {
+    return [`${INDENT}${label}`, `${INDENT}\`\`\``, ...indent(text), `${INDENT}\`\`\``];
+}
+function refsLabel(analysis) {
+    if (analysis.mode === "branch")
+        return `branch ${analysis.base}...${analysis.head}`;
+    return "working tree changes against HEAD";
+}
+function findingLocation(finding) {
+    const location = finding.location;
+    if (!location)
+        return null;
+    return `${location.path}:${lineRange(location.startLine, location.endLine)}`;
+}
+function findingBlock(number, finding) {
+    const location = findingLocation(finding);
+    const title = finding.kind === "requirement_gap" ? `Missing requirement: ${finding.title}` : finding.title;
+    const head = `${number}. [${SEVERITY_NAMES[finding.severity]}] ${location ? `${location} — ` : ""}${title}`;
+    if (finding.prompt !== null)
+        return [head, ...indent(finding.prompt)];
+    const lines = [head];
+    if (finding.body.trim() !== "")
+        lines.push(...indent(finding.body));
+    if (finding.anchorText !== null)
+        lines.push(...fenced("Current lines:", finding.anchorText));
+    if (finding.suggestion !== null)
+        lines.push(...fenced("Proposed replacement:", finding.suggestion));
+    return lines;
+}
+function noteBlock(number, note) {
+    const where = note.location ? `${noteLocationText(note.location)} — ` : "";
+    const [first, ...rest] = note.text.split("\n");
+    return [`${number}. [Reviewer note] ${where}${first}`, ...rest.map((line) => (line === "" ? "" : `${INDENT}${line}`))];
+}
+function pick(items, ids, label) {
+    const known = new Set(items.map((item) => item.id));
+    const unknown = ids.filter((id) => !known.has(id));
+    if (unknown.length > 0)
+        throw new Error(`Unknown ${label} id(s): ${unknown.join(", ")}.`);
+    const wanted = new Set(ids);
+    return items.filter((item) => wanted.has(item.id));
+}
+/**
+ * Prompt de correction destiné à l'agent : en-tête (titre, refs, objectif de la
+ * feature quand la vue d'ensemble existe), décision,
+ * liste numérotée des constats retenus (du plus grave au moins grave, puis dans
+ * l'ordre de l'analyse) suivie des remarques du relecteur. Le `prompt` propre
+ * à un constat remplace son corps, ses lignes actuelles et son correctif.
+ */
+export function buildAgentPrompt(analysis, selection) {
+    const findings = sortBySeverity(pick(analysis.findings, selection.findingIds, "finding"));
+    const notes = pick(analysis.notes, selection.noteIds, "note");
+    const out = [`Review feedback on "${analysis.title}" (${refsLabel(analysis)}).`];
+    if (analysis.overview !== null)
+        out.push(`Feature objective: ${analysis.overview.objective}`);
+    if (selection.decision !== null)
+        out.push(DECISION_LINES[selection.decision]);
+    out.push("");
+    if (findings.length === 0 && notes.length === 0) {
+        out.push("No points to address.");
+        return out.join("\n");
+    }
+    out.push("Address the following points:");
+    let number = 1;
+    for (const finding of findings) {
+        out.push("", ...findingBlock(number++, finding));
+    }
+    for (const note of notes) {
+        out.push("", ...noteBlock(number++, note));
+    }
+    return out.join("\n");
+}
+/** Prompt de tous les constats ouverts, sans décision ni remarque. */
+export function buildAllOpenFindingsPrompt(analysis) {
+    return buildAgentPrompt(analysis, {
+        findingIds: analysis.findings.filter((finding) => finding.status === "open").map((finding) => finding.id),
+        noteIds: [],
+        decision: null,
+    });
+}

package/dist/shared/review-state.d.ts

@@ -0,0 +1,10 @@
+import type { Analysis, ReviewProgress } from "./schemas/analysis.schema.js";
+/**
+ * Avancement de la revue d'une analyse :
+ * - `submitted` : revue soumise, avec sa décision ;
+ * - `files_reviewed` : tous les fichiers revus, revue non soumise ;
+ * - `in_progress` : au moins un fichier revu, revue non soumise ;
+ * - `not_started` : aucun fichier revu, revue non soumise. Une analyse sans
+ *   fichier reste `not_started` jusqu'à la soumission.
+ */
+export declare function reviewProgress(analysis: Pick<Analysis, "files" | "review">): ReviewProgress;

package/dist/shared/review-state.js

@@ -0,0 +1,17 @@
+/**
+ * Avancement de la revue d'une analyse :
+ * - `submitted` : revue soumise, avec sa décision ;
+ * - `files_reviewed` : tous les fichiers revus, revue non soumise ;
+ * - `in_progress` : au moins un fichier revu, revue non soumise ;
+ * - `not_started` : aucun fichier revu, revue non soumise. Une analyse sans
+ *   fichier reste `not_started` jusqu'à la soumission.
+ */
+export function reviewProgress(analysis) {
+    const totalFiles = analysis.files.length;
+    const reviewedFiles = analysis.files.filter((file) => file.reviewed).length;
+    if (analysis.review.state === "submitted") {
+        return { state: "submitted", reviewedFiles, totalFiles, decision: analysis.review.decision };
+    }
+    const state = reviewedFiles === 0 ? "not_started" : reviewedFiles === totalFiles ? "files_reviewed" : "in_progress";
+    return { state, reviewedFiles, totalFiles, decision: null };
+}