@imenam/mcp-feature-analyzer 1.0.0

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

@@ -0,0 +1,372 @@
+import { z } from "zod";
+export declare const ANALYSIS_MODES: readonly ["branch", "working_tree"];
+export declare const FILE_STATUSES: readonly ["added", "modified", "deleted", "renamed"];
+export declare const SEVERITIES: readonly ["critical", "major", "minor", "trivial"];
+export declare const FINDING_KINDS: readonly ["issue", "requirement_gap"];
+export declare const FINDING_STATUSES: readonly ["open", "ignored", "outdated"];
+export declare const DIAGRAM_KINDS: readonly ["flow", "layers", "mindmap"];
+export declare const NODE_SHAPES: readonly ["box", "pill", "decision"];
+export declare const NODE_STATUSES: readonly ["new", "modified", "impacted", "existing", "finding", "missing"];
+export declare const REVIEW_STATES: readonly ["pending", "submitted"];
+export declare const REVIEW_DECISIONS: readonly ["approve", "request_changes", "reject"];
+export declare const EDITORS: readonly ["agent", "user"];
+/** Identifiant d'analyse : slug en minuscules, sert aussi de nom de fichier. */
+export declare const ANALYSIS_ID_PATTERN: RegExp;
+/** Identifiant d'un constat, d'une remarque, d'un schéma ou d'un nœud. */
+export declare const ITEM_ID_PATTERN: RegExp;
+/** Fichier modifié par la feature, tel que figé au dernier snapshot. */
+export declare const FileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    oldPath: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        added: "added";
+        deleted: "deleted";
+        modified: "modified";
+        renamed: "renamed";
+    }>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    binary: z.ZodBoolean;
+    contentAvailable: z.ZodBoolean;
+    lineCount: z.ZodNumber;
+    reviewed: z.ZodBoolean;
+}, z.core.$strip>;
+/** Plage de lignes du côté « nouveau » du diff, bornes incluses. */
+export declare const FindingLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    startLine: z.ZodNumber;
+    endLine: z.ZodNumber;
+}, z.core.$strip>;
+export declare const FindingSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        major: "major";
+        minor: "minor";
+        trivial: "trivial";
+    }>;
+    kind: z.ZodEnum<{
+        issue: "issue";
+        requirement_gap: "requirement_gap";
+    }>;
+    title: z.ZodString;
+    body: z.ZodString;
+    location: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        startLine: z.ZodNumber;
+        endLine: z.ZodNumber;
+    }, z.core.$strip>>;
+    anchorText: z.ZodNullable<z.ZodString>;
+    suggestion: z.ZodNullable<z.ZodString>;
+    prompt: z.ZodNullable<z.ZodString>;
+    status: z.ZodEnum<{
+        ignored: "ignored";
+        open: "open";
+        outdated: "outdated";
+    }>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+/** Emplacement d'une remarque : une ligne du côté « nouveau », ou le fichier entier (`line` null). */
+export declare const NoteLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const NoteSchema: z.ZodObject<{
+    id: z.ZodString;
+    location: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    text: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare const DiagramNodeLocationSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const DiagramNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    shape: z.ZodEnum<{
+        box: "box";
+        decision: "decision";
+        pill: "pill";
+    }>;
+    status: z.ZodEnum<{
+        existing: "existing";
+        finding: "finding";
+        impacted: "impacted";
+        missing: "missing";
+        modified: "modified";
+        new: "new";
+    }>;
+    layer: z.ZodNullable<z.ZodString>;
+    detail: z.ZodNullable<z.ZodString>;
+    location: z.ZodNullable<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const DiagramLinkSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const DiagramSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    kind: z.ZodEnum<{
+        flow: "flow";
+        layers: "layers";
+        mindmap: "mindmap";
+    }>;
+    layers: z.ZodArray<z.ZodString>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        shape: z.ZodEnum<{
+            box: "box";
+            decision: "decision";
+            pill: "pill";
+        }>;
+        status: z.ZodEnum<{
+            existing: "existing";
+            finding: "finding";
+            impacted: "impacted";
+            missing: "missing";
+            modified: "modified";
+            new: "new";
+        }>;
+        layer: z.ZodNullable<z.ZodString>;
+        detail: z.ZodNullable<z.ZodString>;
+        location: z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    links: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    updatedAt: z.ZodString;
+}, z.core.$strip>;
+export declare const ReviewSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        pending: "pending";
+        submitted: "submitted";
+    }>;
+    decision: z.ZodNullable<z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+        request_changes: "request_changes";
+    }>>;
+    selectedFindingIds: z.ZodArray<z.ZodString>;
+    selectedNoteIds: z.ZodArray<z.ZodString>;
+    prompt: z.ZodNullable<z.ZodString>;
+    submittedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const RequestSchema: z.ZodObject<{
+    text: z.ZodString;
+    source: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** Vue d'ensemble de la feature : objectif, approche et points d'attention pour le relecteur. */
+export declare const OverviewSchema: z.ZodObject<{
+    objective: z.ZodString;
+    approach: z.ZodString;
+    attentionPoints: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+/** Nom de projet : non vide, sans espace en tête ni en fin. */
+export declare const ProjectNameSchema: z.ZodString;
+export declare const AnalysisSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    project: z.ZodString;
+    repoPath: z.ZodString;
+    mode: z.ZodEnum<{
+        branch: "branch";
+        working_tree: "working_tree";
+    }>;
+    base: z.ZodString;
+    head: z.ZodNullable<z.ZodString>;
+    baseCommit: z.ZodString;
+    headCommit: z.ZodNullable<z.ZodString>;
+    snapshotAt: z.ZodString;
+    request: z.ZodNullable<z.ZodObject<{
+        text: z.ZodString;
+        source: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    overview: z.ZodNullable<z.ZodObject<{
+        objective: z.ZodString;
+        approach: z.ZodString;
+        attentionPoints: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    summary: z.ZodArray<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        oldPath: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            added: "added";
+            deleted: "deleted";
+            modified: "modified";
+            renamed: "renamed";
+        }>;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+        binary: z.ZodBoolean;
+        contentAvailable: z.ZodBoolean;
+        lineCount: z.ZodNumber;
+        reviewed: z.ZodBoolean;
+    }, z.core.$strip>>;
+    findings: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            major: "major";
+            minor: "minor";
+            trivial: "trivial";
+        }>;
+        kind: z.ZodEnum<{
+            issue: "issue";
+            requirement_gap: "requirement_gap";
+        }>;
+        title: z.ZodString;
+        body: z.ZodString;
+        location: z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            startLine: z.ZodNumber;
+            endLine: z.ZodNumber;
+        }, z.core.$strip>>;
+        anchorText: z.ZodNullable<z.ZodString>;
+        suggestion: z.ZodNullable<z.ZodString>;
+        prompt: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            ignored: "ignored";
+            open: "open";
+            outdated: "outdated";
+        }>;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    notes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        location: z.ZodNullable<z.ZodObject<{
+            path: z.ZodString;
+            line: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+        text: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>;
+    diagrams: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        kind: z.ZodEnum<{
+            flow: "flow";
+            layers: "layers";
+            mindmap: "mindmap";
+        }>;
+        layers: z.ZodArray<z.ZodString>;
+        nodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            shape: z.ZodEnum<{
+                box: "box";
+                decision: "decision";
+                pill: "pill";
+            }>;
+            status: z.ZodEnum<{
+                existing: "existing";
+                finding: "finding";
+                impacted: "impacted";
+                missing: "missing";
+                modified: "modified";
+                new: "new";
+            }>;
+            layer: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+            location: z.ZodNullable<z.ZodObject<{
+                path: z.ZodString;
+                line: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        links: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            label: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>>;
+    review: z.ZodObject<{
+        state: z.ZodEnum<{
+            pending: "pending";
+            submitted: "submitted";
+        }>;
+        decision: z.ZodNullable<z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            request_changes: "request_changes";
+        }>>;
+        selectedFindingIds: z.ZodArray<z.ZodString>;
+        selectedNoteIds: z.ZodArray<z.ZodString>;
+        prompt: z.ZodNullable<z.ZodString>;
+        submittedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    revision: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastEditor: z.ZodEnum<{
+        agent: "agent";
+        user: "user";
+    }>;
+}, z.core.$strip>;
+export type AnalysisMode = (typeof ANALYSIS_MODES)[number];
+export type FileStatus = (typeof FILE_STATUSES)[number];
+export type Severity = (typeof SEVERITIES)[number];
+export type FindingKind = (typeof FINDING_KINDS)[number];
+export type FindingStatus = (typeof FINDING_STATUSES)[number];
+export type DiagramKind = (typeof DIAGRAM_KINDS)[number];
+export type NodeShape = (typeof NODE_SHAPES)[number];
+export type NodeStatus = (typeof NODE_STATUSES)[number];
+export type ReviewState = (typeof REVIEW_STATES)[number];
+export type ReviewDecision = (typeof REVIEW_DECISIONS)[number];
+export type Editor = (typeof EDITORS)[number];
+export type FileEntry = z.infer<typeof FileEntrySchema>;
+export type FindingLocation = z.infer<typeof FindingLocationSchema>;
+export type Finding = z.infer<typeof FindingSchema>;
+export type NoteLocation = z.infer<typeof NoteLocationSchema>;
+export type Note = z.infer<typeof NoteSchema>;
+export type DiagramNodeLocation = z.infer<typeof DiagramNodeLocationSchema>;
+export type DiagramNode = z.infer<typeof DiagramNodeSchema>;
+export type DiagramLink = z.infer<typeof DiagramLinkSchema>;
+export type Diagram = z.infer<typeof DiagramSchema>;
+export type Review = z.infer<typeof ReviewSchema>;
+export type AnalysisRequest = z.infer<typeof RequestSchema>;
+export type Overview = z.infer<typeof OverviewSchema>;
+export type Analysis = z.infer<typeof AnalysisSchema>;
+/** État d'avancement d'une revue, dérivé des fichiers revus et de la soumission. */
+export declare const REVIEW_PROGRESS_STATES: readonly ["not_started", "in_progress", "files_reviewed", "submitted"];
+export type ReviewProgressState = (typeof REVIEW_PROGRESS_STATES)[number];
+/** Avancement d'une revue (voir `reviewProgress` dans `shared/review-state.ts`). */
+export interface ReviewProgress {
+    state: ReviewProgressState;
+    reviewedFiles: number;
+    totalFiles: number;
+    /** Décision de la revue soumise ; null tant qu'elle ne l'est pas. */
+    decision: ReviewDecision | null;
+}
+/** Vue légère d'une analyse, pour les listes. */
+export interface AnalysisSummary {
+    id: string;
+    title: string;
+    project: string;
+    mode: AnalysisMode;
+    base: string;
+    head: string | null;
+    fileCount: number;
+    reviewedCount: number;
+    /** Constats au statut `open`, par gravité. */
+    openFindings: Record<Severity, number>;
+    diagramCount: number;
+    progress: ReviewProgress;
+    updatedAt: string;
+    revision: number;
+}

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

@@ -0,0 +1,152 @@
+import { z } from "zod";
+export const ANALYSIS_MODES = ["branch", "working_tree"];
+export const FILE_STATUSES = ["added", "modified", "deleted", "renamed"];
+export const SEVERITIES = ["critical", "major", "minor", "trivial"];
+export const FINDING_KINDS = ["issue", "requirement_gap"];
+export const FINDING_STATUSES = ["open", "ignored", "outdated"];
+export const DIAGRAM_KINDS = ["flow", "layers", "mindmap"];
+export const NODE_SHAPES = ["box", "pill", "decision"];
+export const NODE_STATUSES = ["new", "modified", "impacted", "existing", "finding", "missing"];
+export const REVIEW_STATES = ["pending", "submitted"];
+export const REVIEW_DECISIONS = ["approve", "request_changes", "reject"];
+export const EDITORS = ["agent", "user"];
+/** Identifiant d'analyse : slug en minuscules, sert aussi de nom de fichier. */
+export const ANALYSIS_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** Identifiant d'un constat, d'une remarque, d'un schéma ou d'un nœud. */
+export const ITEM_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+const ItemIdSchema = z
+    .string()
+    .regex(ITEM_ID_PATTERN, "must contain only letters, digits, '_' or '-' (1 to 64 characters)");
+const LineSchema = z.number().int().positive();
+const IsoDateSchema = z.string().min(1);
+/** Fichier modifié par la feature, tel que figé au dernier snapshot. */
+export const FileEntrySchema = z.object({
+    path: z.string().min(1),
+    oldPath: z.string().min(1).nullable(),
+    status: z.enum(FILE_STATUSES),
+    additions: z.number().int().nonnegative(),
+    deletions: z.number().int().nonnegative(),
+    binary: z.boolean(),
+    /** Vrai quand le texte du côté « nouveau » est conservé dans le snapshot. */
+    contentAvailable: z.boolean(),
+    /** Nombre de lignes du côté « nouveau » ; 0 quand le contenu n'est pas disponible. */
+    lineCount: z.number().int().nonnegative(),
+    reviewed: z.boolean(),
+});
+/** Plage de lignes du côté « nouveau » du diff, bornes incluses. */
+export const FindingLocationSchema = z.object({
+    path: z.string().min(1),
+    startLine: LineSchema,
+    endLine: LineSchema,
+});
+export const FindingSchema = z.object({
+    id: ItemIdSchema,
+    severity: z.enum(SEVERITIES),
+    kind: z.enum(FINDING_KINDS),
+    title: z.string().min(1),
+    body: z.string(),
+    location: FindingLocationSchema.nullable(),
+    /** Texte exact des lignes visées au moment où le constat a été ancré. */
+    anchorText: z.string().nullable(),
+    /** Texte de remplacement proposé pour les lignes visées. */
+    suggestion: z.string().nullable(),
+    /** Prompt fourni par l'agent ; remplace le corps généré dans le retour. */
+    prompt: z.string().nullable(),
+    status: z.enum(FINDING_STATUSES),
+    createdAt: IsoDateSchema,
+});
+/** Emplacement d'une remarque : une ligne du côté « nouveau », ou le fichier entier (`line` null). */
+export const NoteLocationSchema = z.object({
+    path: z.string().min(1),
+    line: LineSchema.nullable(),
+});
+export const NoteSchema = z.object({
+    id: ItemIdSchema,
+    location: NoteLocationSchema.nullable(),
+    text: z.string().min(1),
+    createdAt: IsoDateSchema,
+});
+export const DiagramNodeLocationSchema = z.object({
+    path: z.string().min(1),
+    line: LineSchema.nullable(),
+});
+export const DiagramNodeSchema = z.object({
+    id: ItemIdSchema,
+    label: z.string().min(1),
+    shape: z.enum(NODE_SHAPES),
+    status: z.enum(NODE_STATUSES),
+    layer: z.string().min(1).nullable(),
+    detail: z.string().nullable(),
+    location: DiagramNodeLocationSchema.nullable(),
+});
+export const DiagramLinkSchema = z.object({
+    from: ItemIdSchema,
+    to: ItemIdSchema,
+    label: z.string().nullable(),
+});
+export const DiagramSchema = z.object({
+    id: ItemIdSchema,
+    title: z.string().min(1),
+    kind: z.enum(DIAGRAM_KINDS),
+    /** Ordre des colonnes quand `kind` vaut `layers`. */
+    layers: z.array(z.string().min(1)),
+    nodes: z.array(DiagramNodeSchema),
+    links: z.array(DiagramLinkSchema),
+    updatedAt: IsoDateSchema,
+});
+export const ReviewSchema = z.object({
+    state: z.enum(REVIEW_STATES),
+    decision: z.enum(REVIEW_DECISIONS).nullable(),
+    selectedFindingIds: z.array(ItemIdSchema),
+    selectedNoteIds: z.array(ItemIdSchema),
+    prompt: z.string().nullable(),
+    submittedAt: IsoDateSchema.nullable(),
+});
+export const RequestSchema = z.object({
+    text: z.string().min(1),
+    source: z.string().min(1).nullable(),
+});
+/** Vue d'ensemble de la feature : objectif, approche et points d'attention pour le relecteur. */
+export const OverviewSchema = z.object({
+    /** Ce que la feature doit permettre, du point de vue fonctionnel. */
+    objective: z.string().min(1),
+    /** Comment elle y parvient : choix d'architecture, flux principal. */
+    approach: z.string().min(1),
+    /** Risques et points à vérifier en priorité. */
+    attentionPoints: z.array(z.string().min(1)),
+});
+/** Nom de projet : non vide, sans espace en tête ni en fin. */
+export const ProjectNameSchema = z
+    .string()
+    .min(1)
+    .refine((value) => value === value.trim(), "must not start or end with whitespace");
+export const AnalysisSchema = z.object({
+    id: z.string().regex(ANALYSIS_ID_PATTERN),
+    title: z.string().min(1),
+    /** Projet ou feature auquel l'analyse appartient ; sert de dossier de rangement. */
+    project: ProjectNameSchema,
+    repoPath: z.string().min(1),
+    mode: z.enum(ANALYSIS_MODES),
+    /** Ref de base en mode `branch` ; "HEAD" en mode `working_tree`. */
+    base: z.string().min(1),
+    /** Ref de tête en mode `branch` ; null en mode `working_tree`. */
+    head: z.string().min(1).nullable(),
+    baseCommit: z.string().min(1),
+    headCommit: z.string().min(1).nullable(),
+    snapshotAt: IsoDateSchema,
+    request: RequestSchema.nullable(),
+    overview: OverviewSchema.nullable(),
+    /** Changements fonctionnels de la feature, une puce par changement. */
+    summary: z.array(z.string().min(1)),
+    files: z.array(FileEntrySchema),
+    findings: z.array(FindingSchema),
+    notes: z.array(NoteSchema),
+    diagrams: z.array(DiagramSchema),
+    review: ReviewSchema,
+    revision: z.number().int().nonnegative(),
+    createdAt: IsoDateSchema,
+    updatedAt: IsoDateSchema,
+    lastEditor: z.enum(EDITORS),
+});
+/** État d'avancement d'une revue, dérivé des fichiers revus et de la soumission. */
+export const REVIEW_PROGRESS_STATES = ["not_started", "in_progress", "files_reviewed", "submitted"];

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

@@ -0,0 +1,92 @@
+import { z } from "zod";
+export declare const SetFileReviewedBodySchema: z.ZodObject<{
+    path: z.ZodString;
+    reviewed: z.ZodBoolean;
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const SetFindingStatusBodySchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ignored: "ignored";
+        open: "open";
+        outdated: "outdated";
+    }>;
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
+/** Remarque sur une ligne du côté « nouveau » (`line`), ou sur le fichier entier (`line` absent ou null). */
+export declare const AddNoteBodySchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    text: z.ZodString;
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const DeleteNoteBodySchema: z.ZodObject<{
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
+export declare const SubmitReviewBodySchema: z.ZodObject<{
+    decision: z.ZodEnum<{
+        approve: "approve";
+        reject: "reject";
+        request_changes: "request_changes";
+    }>;
+    findingIds: z.ZodArray<z.ZodString>;
+    noteIds: z.ZodArray<z.ZodString>;
+    baseRevision: z.ZodNumber;
+}, z.core.$strict>;
+export type SetFileReviewedBody = z.infer<typeof SetFileReviewedBodySchema>;
+export type SetFindingStatusBody = z.infer<typeof SetFindingStatusBodySchema>;
+export type AddNoteBody = z.infer<typeof AddNoteBodySchema>;
+export type DeleteNoteBody = z.infer<typeof DeleteNoteBodySchema>;
+export type SubmitReviewBody = z.infer<typeof SubmitReviewBodySchema>;
+/** Données IPC des requêtes de la GUI qui visent une analyse. */
+export declare const AnalysisRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+}, z.core.$strict>;
+export declare const SetFileReviewedRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    body: z.ZodObject<{
+        path: z.ZodString;
+        reviewed: z.ZodBoolean;
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const SetFindingStatusRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    findingId: z.ZodString;
+    body: z.ZodObject<{
+        status: z.ZodEnum<{
+            ignored: "ignored";
+            open: "open";
+            outdated: "outdated";
+        }>;
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const AddNoteRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    body: z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        text: z.ZodString;
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const DeleteNoteRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    noteId: z.ZodString;
+    body: z.ZodObject<{
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const SubmitReviewRequestSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    body: z.ZodObject<{
+        decision: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            request_changes: "request_changes";
+        }>;
+        findingIds: z.ZodArray<z.ZodString>;
+        noteIds: z.ZodArray<z.ZodString>;
+        baseRevision: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;

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

@@ -0,0 +1,46 @@
+import { z } from "zod";
+import { FINDING_STATUSES, REVIEW_DECISIONS } from "./analysis.schema.js";
+/**
+ * Corps des requêtes de modification envoyées par la GUI. Chaque corps porte
+ * `baseRevision`, la révision de l'analyse affichée : le serveur refuse la
+ * modification si l'analyse a avancé depuis.
+ */
+const BaseRevisionSchema = z.number().int().nonnegative();
+export const SetFileReviewedBodySchema = z.strictObject({
+    path: z.string().min(1),
+    reviewed: z.boolean(),
+    baseRevision: BaseRevisionSchema,
+});
+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). */
+export const AddNoteBodySchema = z.strictObject({
+    path: z.string().min(1),
+    line: z.number().int().nullable().optional(),
+    text: z.string().trim().min(1, "the note text is empty"),
+    baseRevision: BaseRevisionSchema,
+});
+export const DeleteNoteBodySchema = z.strictObject({
+    baseRevision: BaseRevisionSchema,
+});
+export const SubmitReviewBodySchema = z.strictObject({
+    decision: z.enum(REVIEW_DECISIONS),
+    findingIds: z.array(z.string().min(1)),
+    noteIds: z.array(z.string().min(1)),
+    baseRevision: BaseRevisionSchema,
+});
+/** Données IPC des requêtes de la GUI qui visent une analyse. */
+export const AnalysisRequestSchema = z.strictObject({ analysisId: z.string().min(1) });
+export const SetFileReviewedRequestSchema = AnalysisRequestSchema.extend({ body: SetFileReviewedBodySchema });
+export const SetFindingStatusRequestSchema = AnalysisRequestSchema.extend({
+    findingId: z.string().min(1),
+    body: SetFindingStatusBodySchema,
+});
+export const AddNoteRequestSchema = AnalysisRequestSchema.extend({ body: AddNoteBodySchema });
+export const DeleteNoteRequestSchema = AnalysisRequestSchema.extend({
+    noteId: z.string().min(1),
+    body: DeleteNoteBodySchema,
+});
+export const SubmitReviewRequestSchema = AnalysisRequestSchema.extend({ body: SubmitReviewBodySchema });