@imenam/mcp-feature-analyzer 1.0.0

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

@@ -0,0 +1,91 @@
+import { z } from "zod";
+/**
+ * Taille maximale, en octets, du contenu « nouveau côté » conservé dans le
+ * snapshot pour un fichier. Au-delà, `newContent` vaut null et le fichier
+ * n'accepte pas de constat ancré sur ses lignes.
+ */
+export declare const MAX_SNAPSHOT_FILE_BYTES: number;
+export declare const DIFF_LINE_TYPES: readonly ["context", "add", "del"];
+/** Ligne d'un hunk ; le texte ne contient ni préfixe de diff ni fin de ligne (`\n` ou `\r\n`). */
+export declare const DiffLineSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        add: "add";
+        context: "context";
+        del: "del";
+    }>;
+    oldNo: z.ZodNullable<z.ZodNumber>;
+    newNo: z.ZodNullable<z.ZodNumber>;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const HunkSchema: z.ZodObject<{
+    header: z.ZodString;
+    oldStart: z.ZodNumber;
+    oldLines: z.ZodNumber;
+    newStart: z.ZodNumber;
+    newLines: z.ZodNumber;
+    lines: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            add: "add";
+            context: "context";
+            del: "del";
+        }>;
+        oldNo: z.ZodNullable<z.ZodNumber>;
+        newNo: z.ZodNullable<z.ZodNumber>;
+        text: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Diff figé d'un fichier. `newContent` est le texte du côté « nouveau » au
+ * moment du snapshot ; il vaut null pour un fichier supprimé, binaire ou plus
+ * gros que MAX_SNAPSHOT_FILE_BYTES.
+ */
+export declare const FileDiffSchema: z.ZodObject<{
+    path: z.ZodString;
+    hunks: z.ZodArray<z.ZodObject<{
+        header: z.ZodString;
+        oldStart: z.ZodNumber;
+        oldLines: z.ZodNumber;
+        newStart: z.ZodNumber;
+        newLines: z.ZodNumber;
+        lines: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                add: "add";
+                context: "context";
+                del: "del";
+            }>;
+            oldNo: z.ZodNullable<z.ZodNumber>;
+            newNo: z.ZodNullable<z.ZodNumber>;
+            text: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    newContent: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const DiffSnapshotSchema: z.ZodObject<{
+    analysisId: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        hunks: z.ZodArray<z.ZodObject<{
+            header: z.ZodString;
+            oldStart: z.ZodNumber;
+            oldLines: z.ZodNumber;
+            newStart: z.ZodNumber;
+            newLines: z.ZodNumber;
+            lines: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    add: "add";
+                    context: "context";
+                    del: "del";
+                }>;
+                oldNo: z.ZodNullable<z.ZodNumber>;
+                newNo: z.ZodNullable<z.ZodNumber>;
+                text: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        newContent: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DiffLineType = (typeof DIFF_LINE_TYPES)[number];
+export type DiffLine = z.infer<typeof DiffLineSchema>;
+export type Hunk = z.infer<typeof HunkSchema>;
+export type FileDiff = z.infer<typeof FileDiffSchema>;
+export type DiffSnapshot = z.infer<typeof DiffSnapshotSchema>;

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

@@ -0,0 +1,37 @@
+import { z } from "zod";
+/**
+ * Taille maximale, en octets, du contenu « nouveau côté » conservé dans le
+ * snapshot pour un fichier. Au-delà, `newContent` vaut null et le fichier
+ * n'accepte pas de constat ancré sur ses lignes.
+ */
+export const MAX_SNAPSHOT_FILE_BYTES = 1024 * 1024;
+export const DIFF_LINE_TYPES = ["context", "add", "del"];
+/** Ligne d'un hunk ; le texte ne contient ni préfixe de diff ni fin de ligne (`\n` ou `\r\n`). */
+export const DiffLineSchema = z.object({
+    type: z.enum(DIFF_LINE_TYPES),
+    oldNo: z.number().int().positive().nullable(),
+    newNo: z.number().int().positive().nullable(),
+    text: z.string(),
+});
+export const HunkSchema = z.object({
+    header: z.string(),
+    oldStart: z.number().int().nonnegative(),
+    oldLines: z.number().int().nonnegative(),
+    newStart: z.number().int().nonnegative(),
+    newLines: z.number().int().nonnegative(),
+    lines: z.array(DiffLineSchema),
+});
+/**
+ * Diff figé d'un fichier. `newContent` est le texte du côté « nouveau » au
+ * moment du snapshot ; il vaut null pour un fichier supprimé, binaire ou plus
+ * gros que MAX_SNAPSHOT_FILE_BYTES.
+ */
+export const FileDiffSchema = z.object({
+    path: z.string().min(1),
+    hunks: z.array(HunkSchema),
+    newContent: z.string().nullable(),
+});
+export const DiffSnapshotSchema = z.object({
+    analysisId: z.string().min(1),
+    files: z.array(FileDiffSchema),
+});

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

@@ -0,0 +1,29 @@
+import { z } from "zod";
+/**
+ * Nature d'une erreur renvoyée par le maître à une requête du GUI worker, qui
+ * la traduit en code HTTP : invalid → 400, not_found → 404, conflict → 409,
+ * internal → 500.
+ */
+export declare const IPC_ERROR_KINDS: readonly ["invalid", "not_found", "conflict", "internal"];
+export type IpcErrorKind = (typeof IPC_ERROR_KINDS)[number];
+/** Message échangé entre le processus maître MCP et le GUI worker. */
+export declare const IPCMessageSchema: z.ZodObject<{
+    type: z.ZodString;
+    correlationId: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodAny>;
+    error: z.ZodOptional<z.ZodString>;
+    errorKind: z.ZodOptional<z.ZodEnum<{
+        conflict: "conflict";
+        internal: "internal";
+        invalid: "invalid";
+        not_found: "not_found";
+    }>>;
+    timestamp: z.ZodString;
+}, z.core.$strip>;
+export type IPCMessage = z.infer<typeof IPCMessageSchema>;
+/** Types d'IPC envoyés par le maître et relayés tels quels aux clients SSE de la GUI. */
+export declare const PUSHED_EVENT_TYPES: readonly ["INITIAL_STATE", "ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
+export type PushedEventType = (typeof PUSHED_EVENT_TYPES)[number];
+/** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
+export declare const GUI_REQUEST_TYPES: readonly ["GET_CONFIG", "LIST_ANALYSES", "GET_ANALYSIS", "GET_DIFF", "SET_FILE_REVIEWED", "SET_FINDING_STATUS", "ADD_NOTE", "DELETE_NOTE", "SUBMIT_REVIEW"];
+export type GuiRequestType = (typeof GUI_REQUEST_TYPES)[number];

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+/**
+ * Nature d'une erreur renvoyée par le maître à une requête du GUI worker, qui
+ * la traduit en code HTTP : invalid → 400, not_found → 404, conflict → 409,
+ * internal → 500.
+ */
+export const IPC_ERROR_KINDS = ["invalid", "not_found", "conflict", "internal"];
+/** Message échangé entre le processus maître MCP et le GUI worker. */
+export const IPCMessageSchema = z.object({
+    type: z.string(),
+    correlationId: z.string().optional(),
+    data: z.any().optional(),
+    error: z.string().optional(),
+    errorKind: z.enum(IPC_ERROR_KINDS).optional(),
+    timestamp: z.string(),
+});
+/** Types d'IPC envoyés par le maître et relayés tels quels aux clients SSE de la GUI. */
+export const PUSHED_EVENT_TYPES = ["INITIAL_STATE", "ANALYSES_UPDATED", "ANALYSIS_UPDATED"];
+/** Requêtes du GUI worker au maître ; chacune reçoit une réponse de même `correlationId`. */
+export const GUI_REQUEST_TYPES = [
+    "GET_CONFIG",
+    "LIST_ANALYSES",
+    "GET_ANALYSIS",
+    "GET_DIFF",
+    "SET_FILE_REVIEWED",
+    "SET_FINDING_STATUS",
+    "ADD_NOTE",
+    "DELETE_NOTE",
+    "SUBMIT_REVIEW",
+];

package/dist/shared/severity.d.ts

@@ -0,0 +1,11 @@
+import { type Severity } from "./schemas/analysis.schema.js";
+/** Rang d'une gravité : 0 pour la plus grave. */
+export declare function severityRank(severity: Severity): number;
+/** Comparateur qui trie de la plus grave à la moins grave. */
+export declare function compareSeverity(a: Severity, b: Severity): number;
+/** Copie triée de la plus grave à la moins grave ; à gravité égale, l'ordre d'origine est conservé. */
+export declare function sortBySeverity<T extends {
+    severity: Severity;
+}>(items: readonly T[]): T[];
+/** Compteur à zéro pour chaque gravité. */
+export declare function emptySeverityCounts(): Record<Severity, number>;

package/dist/shared/severity.js

@@ -0,0 +1,17 @@
+import { SEVERITIES } from "./schemas/analysis.schema.js";
+/** Rang d'une gravité : 0 pour la plus grave. */
+export function severityRank(severity) {
+    return SEVERITIES.indexOf(severity);
+}
+/** Comparateur qui trie de la plus grave à la moins grave. */
+export function compareSeverity(a, b) {
+    return severityRank(a) - severityRank(b);
+}
+/** Copie triée de la plus grave à la moins grave ; à gravité égale, l'ordre d'origine est conservé. */
+export function sortBySeverity(items) {
+    return [...items].sort((a, b) => compareSeverity(a.severity, b.severity));
+}
+/** Compteur à zéro pour chaque gravité. */
+export function emptySeverityCounts() {
+    return { critical: 0, major: 0, minor: 0, trivial: 0 };
+}

package/dist/shared/text.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Découpe un texte en lignes. Les fins de ligne `\n` et `\r\n` sont retirées ;
+ * une fin de ligne finale ne crée pas de ligne vide supplémentaire.
+ */
+export declare function splitLines(content: string): string[];
+/** Plage de lignes : « 12 », ou « 12-14 » avec `separator` entre les bornes. */
+export declare function lineRange(startLine: number, endLine: number, separator?: string): string;
+/** Emplacement d'une remarque : « chemin » pour un fichier entier, « chemin:ligne » sinon. */
+export declare function noteLocationText(location: {
+    path: string;
+    line: number | null;
+}): string;

package/dist/shared/text.js

@@ -0,0 +1,20 @@
+/**
+ * Découpe un texte en lignes. Les fins de ligne `\n` et `\r\n` sont retirées ;
+ * une fin de ligne finale ne crée pas de ligne vide supplémentaire.
+ */
+export function splitLines(content) {
+    if (content === "")
+        return [];
+    const lines = content.split("\n").map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+    if (lines[lines.length - 1] === "" && content.endsWith("\n"))
+        lines.pop();
+    return lines;
+}
+/** Plage de lignes : « 12 », ou « 12-14 » avec `separator` entre les bornes. */
+export function lineRange(startLine, endLine, separator = "-") {
+    return startLine === endLine ? `${startLine}` : `${startLine}${separator}${endLine}`;
+}
+/** Emplacement d'une remarque : « chemin » pour un fichier entier, « chemin:ligne » sinon. */
+export function noteLocationText(location) {
+    return location.line === null ? location.path : `${location.path}:${location.line}`;
+}

package/dist/src/cli/setup-mcp.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Comment la GUI sera exposée. `undefined` des deux côtés = rien n'a été passé
+ * en ligne de commande : on retombe sur le placeholder PROXY_URL à compléter.
+ */
+export interface GuiExposure {
+    proxyUrl?: string;
+    appPort?: number;
+}
+/**
+ * Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de la GUI.
+ * Les deux ensemble sont refusés : au runtime PROXY_URL primerait toujours,
+ * donc un fichier portant les deux serait silencieusement trompeur.
+ */
+export declare function parseGuiExposure(argv: string[]): {
+    exposure: GuiExposure;
+} | {
+    error: string;
+};
+export interface SetupMcpOptions {
+    cwd: string;
+    force: boolean;
+    exposure?: GuiExposure;
+}
+export declare function runSetupMcp({ cwd, force, exposure }: SetupMcpOptions): number;

package/dist/src/cli/setup-mcp.js

@@ -0,0 +1,145 @@
+import fs from "fs";
+import path from "path";
+const SERVER_NAME = "mcp-feature-analyzer";
+const PACKAGE_NAME = "@imenam/mcp-feature-analyzer";
+/** Slashes POSIX : évite les backslashes échappés dans le JSON, et Node les accepte sous Windows. */
+function toPosixPath(dir) {
+    return dir.replace(/\\/g, "/");
+}
+/** "mon-projet" -> "Mon-projet" */
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/** "mon_projet-web" -> "Mon Projet Web" */
+function toDisplayName(folder) {
+    return folder.split(/[-_]+/).filter(Boolean).map(capitalize).join(" ");
+}
+/**
+ * Valeurs volontairement vides : chaque variable est inactive tant qu'elle n'est
+ * pas remplie (PROXY_URL et APP_PORT vides = GUI désactivée), donc le fichier
+ * généré est utilisable tel quel, jamais à moitié cassé.
+ */
+function buildServerEntry(codeRoot, exposure) {
+    const folder = path.basename(codeRoot) || "feature-analyzer";
+    // Un port explicite désactive le placeholder proxy : les deux variables ne
+    // doivent jamais être renseignées ensemble, PROXY_URL primant au runtime.
+    const proxyUrl = exposure.appPort !== undefined ? "" : exposure.proxyUrl ?? "http://localhost:";
+    return {
+        command: "npx",
+        args: ["-y", PACKAGE_NAME],
+        env: {
+            PROXY_URL: proxyUrl,
+            APP_PORT: exposure.appPort !== undefined ? String(exposure.appPort) : "",
+            APP_GROUP: capitalize(folder),
+            APP_NAME: `Feature Analyzer ${toDisplayName(folder)}`,
+            APP_PATH: `/feature-analyzer-${folder}`,
+            MCP_FEATURE_ANALYZER_DATA_DIR: toPosixPath(path.join(codeRoot, ".feature-analyzer-data")),
+            MCP_LOG_DIR: "",
+        },
+    };
+}
+const GENERATED_VARS = [
+    ["PROXY_URL", "URL du proxy pour exposer la GUI (compléter le port)"],
+    ["APP_PORT", "port local si aucun proxy — la GUI est servie sur http://localhost:<port>"],
+    ["APP_GROUP", "groupe d'affichage dans le dashboard du proxy"],
+    ["APP_NAME", "nom affiché de la GUI dans le dashboard du proxy"],
+    ["APP_PATH", "chemin de montage de la GUI derrière le proxy"],
+    ["MCP_FEATURE_ANALYZER_DATA_DIR", "répertoire de stockage des analyses (pré-rempli)"],
+    ["MCP_LOG_DIR", "répertoire des logs (défaut : <data>/logs)"],
+];
+/** Lit `--flag=valeur` (tirets ou underscores acceptés). */
+function readFlag(argv, name) {
+    const prefixes = [`--${name}=`, `--${name.replace(/_/g, "-")}=`];
+    for (const arg of argv) {
+        const prefix = prefixes.find((p) => arg.startsWith(p));
+        if (prefix)
+            return arg.slice(prefix.length).trim();
+    }
+    return undefined;
+}
+/**
+ * Traduit `--proxy_url=` / `--app_port=` en mode d'exposition de la GUI.
+ * Les deux ensemble sont refusés : au runtime PROXY_URL primerait toujours,
+ * donc un fichier portant les deux serait silencieusement trompeur.
+ */
+export function parseGuiExposure(argv) {
+    const rawProxyUrl = readFlag(argv, "proxy_url");
+    const rawAppPort = readFlag(argv, "app_port");
+    if (rawProxyUrl !== undefined && rawAppPort !== undefined) {
+        return { error: "--proxy_url et --app_port sont exclusifs : la GUI passe par le proxy, ou écoute sur un port local." };
+    }
+    if (rawProxyUrl !== undefined) {
+        if (rawProxyUrl === "")
+            return { error: "--proxy_url attend une URL, ex : --proxy_url=http://localhost:3000" };
+        let parsed;
+        try {
+            parsed = new URL(rawProxyUrl);
+        }
+        catch {
+            return { error: `--proxy_url invalide : "${rawProxyUrl}" n'est pas une URL absolue (ex : http://localhost:3000).` };
+        }
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+            return { error: `--proxy_url invalide : protocole "${parsed.protocol}" non supporté (http ou https attendu).` };
+        }
+        // Une barre finale casserait la concaténation PROXY_URL + APP_PATH.
+        return { exposure: { proxyUrl: rawProxyUrl.replace(/\/+$/, "") } };
+    }
+    if (rawAppPort !== undefined) {
+        const port = Number(rawAppPort);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            return { error: `--app_port invalide : "${rawAppPort}" n'est pas un entier entre 1 et 65535.` };
+        }
+        return { exposure: { appPort: port } };
+    }
+    return { exposure: {} };
+}
+export function runSetupMcp({ cwd, force, exposure = {} }) {
+    const target = path.join(cwd, ".mcp.json");
+    let config = {};
+    const exists = fs.existsSync(target);
+    if (exists) {
+        const raw = fs.readFileSync(target, "utf-8").trim();
+        if (raw !== "") {
+            try {
+                config = JSON.parse(raw);
+            }
+            catch (err) {
+                console.error(`Erreur : ${target} contient du JSON invalide (${err.message}).`);
+                console.error("Corrigez le fichier ou supprimez-le, puis relancez la commande.");
+                return 1;
+            }
+        }
+        if (typeof config !== "object" || config === null || Array.isArray(config)) {
+            console.error(`Erreur : ${target} ne contient pas un objet JSON.`);
+            return 1;
+        }
+    }
+    if (typeof config.mcpServers !== "object" || config.mcpServers === null || Array.isArray(config.mcpServers)) {
+        config.mcpServers = {};
+    }
+    const alreadyPresent = Object.prototype.hasOwnProperty.call(config.mcpServers, SERVER_NAME);
+    if (alreadyPresent && !force) {
+        console.error(`Le serveur "${SERVER_NAME}" est déjà configuré dans ${target}.`);
+        console.error("Relancez avec --force pour écraser cette entrée (les autres serveurs sont préservés).");
+        return 1;
+    }
+    config.mcpServers[SERVER_NAME] = buildServerEntry(cwd, exposure);
+    fs.writeFileSync(target, JSON.stringify(config, null, 2) + "\n", "utf-8");
+    const action = alreadyPresent ? "remplacée" : exists ? "ajoutée" : "créée";
+    console.log(`Configuration ${SERVER_NAME} ${action} dans ${target}`);
+    console.log("");
+    if (exposure.appPort !== undefined) {
+        console.log(`GUI en accès direct : http://localhost:${exposure.appPort} (sans proxy).`);
+    }
+    else if (exposure.proxyUrl !== undefined) {
+        console.log(`GUI exposée via le proxy ${exposure.proxyUrl}.`);
+    }
+    console.log('À compléter dans le champ "env" :');
+    for (const [name, description] of GENERATED_VARS) {
+        console.log(`  ${name.padEnd(30)} ${description}`);
+    }
+    console.log("");
+    console.log("Une variable laissée vide est simplement inactive.");
+    console.log("PROXY_URL et APP_PORT s'excluent : PROXY_URL prime si les deux sont renseignés.");
+    return 0;
+}

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

@@ -0,0 +1,95 @@
+import { type Analysis, type AnalysisRequest, type AnalysisSummary, type Editor, type Review } from "../../shared/schemas/analysis.schema.js";
+import { type DiffSnapshot } from "../../shared/schemas/diff.schema.js";
+import type { ComputedSnapshot } from "./git.js";
+import { type RefreshStats } from "./refresh.js";
+export interface CreateAnalysisInput {
+    project: string;
+    title: string;
+    request?: AnalysisRequest | null;
+    summary?: string[];
+}
+export interface MutateOptions {
+    /**
+     * Révision sur laquelle la modification est basée. Quand elle est fournie et
+     * que l'analyse a avancé depuis, l'écriture est refusée.
+     */
+    baseRevision?: number;
+}
+/** Résultat de `list` : les analyses lisibles et les fichiers qui ne le sont pas. */
+export interface AnalysisListing {
+    analyses: AnalysisSummary[];
+    unreadable: Array<{
+        id: string;
+        error: string;
+    }>;
+}
+export interface ReplaceSnapshotResult {
+    analysis: Analysis;
+    stats: RefreshStats;
+    /** Revue en place avant le recalcul, remplacée par une revue vierge. */
+    previousReview: Review;
+}
+/** Revue vierge : en attente, sans décision, sélection ni prompt. */
+export declare function pendingReview(): Review;
+/**
+ * Persistance des analyses : `<dataDir>/analyses/<id>.json` pour l'analyse et
+ * `<dataDir>/diffs/<id>.json` pour son snapshot de diff. Plusieurs processus
+ * peuvent partager le même répertoire : chaque cycle lire-modifier-écrire est
+ * sérialisé par un verrou fichier, et le cache mémoire est invalidé dès que la
+ * signature (mtime, taille) du fichier change.
+ */
+export declare class AnalysisStore {
+    readonly dataDir: string;
+    private readonly analysesDir;
+    private readonly diffsDir;
+    private readonly analysisCache;
+    private readonly snapshotCache;
+    constructor(dataDir: string);
+    analysisPath(id: string): string;
+    snapshotPath(id: string): string;
+    /** Refuse un identifiant qui ne peut pas désigner une analyse (et donc un nom de fichier). */
+    private assertId;
+    private notFound;
+    /**
+     * Sérialise l'accès en écriture à une analyse entre processus : `wx` échoue si
+     * le verrou existe déjà. Non réentrant.
+     */
+    private withLock;
+    /**
+     * Lit, migre et valide un document JSON. Un document migré est réécrit sur
+     * disque. `parse` renvoie le document typé ou lève une erreur. Renvoie null
+     * si le fichier n'existe pas.
+     */
+    private readDocument;
+    private parseAnalysis;
+    private parseSnapshot;
+    private writeAnalysis;
+    private writeSnapshot;
+    /** Valide une analyse complète (schéma puis invariants) avant écriture. */
+    private validate;
+    has(id: string): boolean;
+    /** Résumés des analyses, de la plus récemment modifiée à la plus ancienne. */
+    list(): AnalysisListing;
+    get(id: string): Analysis;
+    getSnapshot(id: string): DiffSnapshot;
+    /** Crée une analyse à partir d'un snapshot calculé ; le snapshot est écrit avant l'analyse. */
+    create(input: CreateAnalysisInput, snapshot: ComputedSnapshot): Analysis;
+    private buildSnapshot;
+    /**
+     * Point unique de modification : applique `fn` à une copie de l'analyse,
+     * vérifie schéma et invariants, incrémente la révision puis écrit. Les champs
+     * issus du snapshot ne peuvent pas changer ici (voir `replaceSnapshot`).
+     */
+    mutate(id: string, editor: Editor, fn: (draft: Analysis) => void, options?: MutateOptions): Analysis;
+    private assertBaseRevision;
+    /**
+     * Remplace le snapshot de diff d'une analyse par `snapshot`, recalculé avec
+     * les mêmes dépôt, mode et refs, met à jour fichiers et constats selon
+     * `applyRefresh` et remet la revue à l'état vierge, dans la même écriture.
+     */
+    replaceSnapshot(id: string, editor: Editor, snapshot: ComputedSnapshot, options?: MutateOptions): ReplaceSnapshotResult;
+    /** Supprime l'analyse et son snapshot de diff. */
+    delete(id: string): void;
+}
+/** Vue légère d'une analyse. */
+export declare function summarize(analysis: Analysis): AnalysisSummary;