@imenam/mcp-feature-analyzer 1.0.0

package/dist/src/core/log-dir.js

@@ -0,0 +1,13 @@
+import path from "path";
+import { resolveDataDir } from "./data-dir.js";
+/**
+ * Répertoire des logs : MCP_LOG_DIR s'il est renseigné, sinon <dataDir>/logs.
+ * Lu depuis process.env au démarrage, avant le chargement du .env du package :
+ * la variable vient donc de la déclaration du serveur dans le client MCP.
+ */
+export function resolveLogDir(rootDir) {
+    const configured = process.env.MCP_LOG_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.join(resolveDataDir(rootDir), "logs");
+}

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

@@ -0,0 +1,24 @@
+/**
+ * Mises à niveau des fichiers de données, appliquées à la lecture avant la
+ * validation de schéma. Chaque étape est idempotente : elle renvoie null quand
+ * le document est déjà dans le format qu'elle produit.
+ */
+export type RawDocument = Record<string, unknown>;
+/** Étape de migration : document mis à niveau, ou null si elle n'a rien à changer. */
+export type MigrationStep = (raw: RawDocument) => RawDocument | null;
+/** Dernier segment d'un chemin POSIX ou Windows, séparateurs finaux ignorés ; chaîne vide pour une racine. */
+export declare function repoFolderName(repoPath: string): string;
+/** Ajoute `project` : le nom du dossier du dépôt (`basename(repoPath)`). */
+export declare const addProject: MigrationStep;
+/** Ajoute `overview` à null : l'analyse n'a pas encore de vue d'ensemble. */
+export declare const addOverview: 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. */
+export declare const SNAPSHOT_MIGRATIONS: readonly MigrationStep[];
+/** Applique `steps` à la suite. Renvoie null si aucune étape n'a modifié le document. */
+export declare function applyMigrations(raw: unknown, steps: readonly MigrationStep[]): RawDocument | null;
+/** Met à niveau une analyse brute ; null si elle est déjà à jour. */
+export declare function migrateAnalysis(raw: unknown): RawDocument | null;
+/** Met à niveau un snapshot de diff brut ; null s'il est déjà à jour. */
+export declare function migrateSnapshot(raw: unknown): RawDocument | null;

package/dist/src/core/migrate.js

@@ -0,0 +1,53 @@
+/**
+ * Mises à niveau des fichiers de données, appliquées à la lecture avant la
+ * validation de schéma. Chaque étape est idempotente : elle renvoie null quand
+ * le document est déjà dans le format qu'elle produit.
+ */
+import { AnalysisError } from "./errors.js";
+/** Dernier segment d'un chemin POSIX ou Windows, séparateurs finaux ignorés ; chaîne vide pour une racine. */
+export function repoFolderName(repoPath) {
+    const parts = repoPath.split(/[\\/]+/).filter((part) => part !== "");
+    const last = parts[parts.length - 1] ?? "";
+    return /^[A-Za-z]:$/.test(last) ? "" : last.trim();
+}
+/** Ajoute `project` : le nom du dossier du dépôt (`basename(repoPath)`). */
+export const addProject = (doc) => {
+    if (doc.project !== undefined)
+        return null;
+    const repoPath = doc.repoPath;
+    const project = typeof repoPath === "string" ? repoFolderName(repoPath) : "";
+    if (project === "") {
+        throw new AnalysisError(`Cannot derive the project of analysis "${String(doc.id)}" from its repoPath ${JSON.stringify(repoPath)}: ` +
+            `set "project" in the analysis file, or delete the analysis with delete_analysis and create it again.`);
+    }
+    return { ...doc, project };
+};
+/** Ajoute `overview` à null : l'analyse n'a pas encore de vue d'ensemble. */
+export const addOverview = (doc) => (doc.overview !== undefined ? null : { ...doc, overview: null });
+/** Étapes appliquées aux analyses (`analyses/<id>.json`), dans l'ordre. */
+export const ANALYSIS_MIGRATIONS = [addProject, addOverview];
+/** É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. */
+export function applyMigrations(raw, steps) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    let current = raw;
+    let changed = false;
+    for (const step of steps) {
+        const next = step(current);
+        if (next !== null) {
+            current = next;
+            changed = true;
+        }
+    }
+    return changed ? current : null;
+}
+/** Met à niveau une analyse brute ; null si elle est déjà à jour. */
+export function migrateAnalysis(raw) {
+    return applyMigrations(raw, ANALYSIS_MIGRATIONS);
+}
+/** Met à niveau un snapshot de diff brut ; null s'il est déjà à jour. */
+export function migrateSnapshot(raw) {
+    return applyMigrations(raw, SNAPSHOT_MIGRATIONS);
+}

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

@@ -0,0 +1,30 @@
+import type { Analysis } from "../../shared/schemas/analysis.schema.js";
+import type { DiffSnapshot } from "../../shared/schemas/diff.schema.js";
+import type { ComputedSnapshot } from "./git.js";
+/** Bilan d'un recalcul, pour le message renvoyé à l'agent. */
+export interface RefreshStats {
+    fileCount: number;
+    filesAdded: number;
+    filesRemoved: number;
+    /** Fichiers revus dont le diff est inchangé : ils restent revus. */
+    reviewedKept: number;
+    /** Fichiers revus toujours présents dont le diff a changé : ils repassent à « non revu ». */
+    reviewedReset: number;
+    /** Constats ouverts passés à `outdated`. */
+    findingsOutdated: number;
+    /** Constats `outdated` revenus à `open`. */
+    findingsRestored: number;
+}
+export interface RefreshResult {
+    fields: Pick<Analysis, "baseCommit" | "headCommit" | "snapshotAt" | "files" | "findings">;
+    stats: RefreshStats;
+}
+/**
+ * Calcule les champs d'une analyse après recalcul de son snapshot :
+ * - `reviewed` n'est conservé que pour les fichiers dont le diff est inchangé ;
+ * - un constat `open` dont les lignes ne correspondent plus à `anchorText`, ou dont le
+ *   fichier a quitté le diff, passe à `outdated` ;
+ * - un constat `outdated` dont les lignes correspondent de nouveau revient à `open` ;
+ * - un constat `ignored` reste `ignored`, un constat sans emplacement ne change pas.
+ */
+export declare function applyRefresh(analysis: Analysis, oldSnapshot: DiffSnapshot, next: ComputedSnapshot): RefreshResult;

package/dist/src/core/refresh.js

@@ -0,0 +1,113 @@
+import { splitLines } from "../../shared/text.js";
+import { AnalysisError } from "./errors.js";
+function hunksEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((hunk, index) => {
+        const other = b[index];
+        if (hunk.header !== other.header ||
+            hunk.oldStart !== other.oldStart ||
+            hunk.oldLines !== other.oldLines ||
+            hunk.newStart !== other.newStart ||
+            hunk.newLines !== other.newLines ||
+            hunk.lines.length !== other.lines.length) {
+            return false;
+        }
+        return hunk.lines.every((line, i) => {
+            const o = other.lines[i];
+            return line.type === o.type && line.oldNo === o.oldNo && line.newNo === o.newNo && line.text === o.text;
+        });
+    });
+}
+/**
+ * Vrai quand le diff d'un fichier est identique d'un snapshot à l'autre. Un
+ * fichier binaire n'a pas de hunks comparables : son diff est toujours tenu
+ * pour changé.
+ */
+function sameFileDiff(oldEntry, oldDiff, newEntry, newDiff) {
+    if (!oldDiff || oldEntry.binary || newEntry.binary)
+        return false;
+    return oldEntry.status === newEntry.status && oldEntry.oldPath === newEntry.oldPath && hunksEqual(oldDiff.hunks, newDiff.hunks);
+}
+/** Texte actuel des lignes visées par un constat, ou null si elles ne sont plus lisibles. */
+function currentText(finding, diffs) {
+    const location = finding.location;
+    if (!location)
+        return null;
+    const content = diffs.get(location.path)?.newContent;
+    if (content === null || content === undefined)
+        return null;
+    const lines = splitLines(content);
+    if (location.startLine < 1 || location.endLine > lines.length || location.startLine > location.endLine)
+        return null;
+    return lines.slice(location.startLine - 1, location.endLine).join("\n");
+}
+/**
+ * Calcule les champs d'une analyse après recalcul de son snapshot :
+ * - `reviewed` n'est conservé que pour les fichiers dont le diff est inchangé ;
+ * - un constat `open` dont les lignes ne correspondent plus à `anchorText`, ou dont le
+ *   fichier a quitté le diff, passe à `outdated` ;
+ * - un constat `outdated` dont les lignes correspondent de nouveau revient à `open` ;
+ * - un constat `ignored` reste `ignored`, un constat sans emplacement ne change pas.
+ */
+export function applyRefresh(analysis, oldSnapshot, next) {
+    if (next.repoPath !== analysis.repoPath || next.mode !== analysis.mode || next.base !== analysis.base || next.head !== analysis.head) {
+        throw new AnalysisError(`The new snapshot does not match analysis "${analysis.id}": compute it with the repository, mode and refs of the analysis.`);
+    }
+    const oldEntries = new Map(analysis.files.map((file) => [file.path, file]));
+    const oldDiffs = new Map(oldSnapshot.files.map((file) => [file.path, file]));
+    const newDiffs = new Map(next.diff.map((file) => [file.path, file]));
+    const stats = {
+        fileCount: next.files.length,
+        filesAdded: 0,
+        filesRemoved: 0,
+        reviewedKept: 0,
+        reviewedReset: 0,
+        findingsOutdated: 0,
+        findingsRestored: 0,
+    };
+    const files = next.files.map((entry) => {
+        const previous = oldEntries.get(entry.path);
+        if (!previous) {
+            stats.filesAdded++;
+            return { ...entry, reviewed: false };
+        }
+        if (!previous.reviewed)
+            return { ...entry, reviewed: false };
+        const newDiff = newDiffs.get(entry.path);
+        if (!newDiff)
+            throw new AnalysisError(`The new snapshot has no diff for "${entry.path}".`);
+        if (sameFileDiff(previous, oldDiffs.get(entry.path), entry, newDiff)) {
+            stats.reviewedKept++;
+            return { ...entry, reviewed: true };
+        }
+        stats.reviewedReset++;
+        return { ...entry, reviewed: false };
+    });
+    const newPaths = new Set(next.files.map((file) => file.path));
+    stats.filesRemoved = analysis.files.filter((file) => !newPaths.has(file.path)).length;
+    const findings = analysis.findings.map((finding) => {
+        if (finding.location === null || finding.status === "ignored")
+            return finding;
+        const matches = currentText(finding, newDiffs) === finding.anchorText;
+        if (finding.status === "open" && !matches) {
+            stats.findingsOutdated++;
+            return { ...finding, status: "outdated" };
+        }
+        if (finding.status === "outdated" && matches) {
+            stats.findingsRestored++;
+            return { ...finding, status: "open" };
+        }
+        return finding;
+    });
+    return {
+        fields: {
+            baseCommit: next.baseCommit,
+            headCommit: next.headCommit,
+            snapshotAt: next.snapshotAt,
+            files,
+            findings,
+        },
+        stats,
+    };
+}

package/dist/src/core/request-guard.d.ts

@@ -0,0 +1,32 @@
+/** Interface d'écoute du GUI worker : la boucle locale uniquement. */
+export declare const LISTEN_HOST = "127.0.0.1";
+/** Refus d'une requête : code HTTP et message renvoyé au client. */
+export interface GuardRejection {
+    status: 403 | 415;
+    error: string;
+}
+/**
+ * Nom d'hôte d'un en-tête `Host` ou d'une URL d'origine, sans port ni crochets,
+ * en minuscules. Renvoie null quand la valeur n'est pas exploitable.
+ */
+export declare function hostnameOf(hostHeader: string): string | null;
+/**
+ * Noms d'hôte sous lesquels la GUI est légitimement appelée : boucle locale,
+ * nom et adresses de la machine (accès par le proxy depuis le réseau, qui
+ * transmet l'en-tête `Host` d'origine) et hôte du proxy.
+ */
+export declare function allowedHostnames(proxyUrl: string | undefined): Set<string>;
+/**
+ * Contrôle d'une requête entrante.
+ * - L'en-tête `Host` doit désigner un hôte autorisé : une page tierce qui fait
+ *   pointer son domaine vers 127.0.0.1 (DNS rebinding) est refusée.
+ * - Une requête de modification exige `Content-Type: application/json`, qu'un
+ *   navigateur ne peut envoyer vers une autre origine sans requête préalable
+ *   CORS, refusée ici ; une origine différente de l'hôte appelé est refusée.
+ */
+export declare function checkRequest(request: {
+    method: string;
+    host: string | undefined;
+    origin: string | undefined;
+    contentType: string | undefined;
+}, allowed: Set<string>): GuardRejection | null;

package/dist/src/core/request-guard.js

@@ -0,0 +1,72 @@
+import os from "os";
+/** Interface d'écoute du GUI worker : la boucle locale uniquement. */
+export const LISTEN_HOST = "127.0.0.1";
+/** Méthodes HTTP sans effet de bord, exemptées du contrôle des modifications. */
+const SAFE_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+/**
+ * Nom d'hôte d'un en-tête `Host` ou d'une URL d'origine, sans port ni crochets,
+ * en minuscules. Renvoie null quand la valeur n'est pas exploitable.
+ */
+export function hostnameOf(hostHeader) {
+    const value = hostHeader.trim().toLowerCase();
+    if (value === "")
+        return null;
+    try {
+        return new URL(`http://${value}`).hostname.replace(/^\[(.*)\]$/, "$1");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Noms d'hôte sous lesquels la GUI est légitimement appelée : boucle locale,
+ * nom et adresses de la machine (accès par le proxy depuis le réseau, qui
+ * transmet l'en-tête `Host` d'origine) et hôte du proxy.
+ */
+export function allowedHostnames(proxyUrl) {
+    const names = new Set(["localhost", "127.0.0.1", "::1"]);
+    names.add(os.hostname().toLowerCase());
+    for (const addresses of Object.values(os.networkInterfaces())) {
+        for (const address of addresses ?? [])
+            names.add(address.address.toLowerCase());
+    }
+    if (proxyUrl) {
+        const proxyHost = hostnameOf(new URL(proxyUrl).host);
+        if (proxyHost !== null)
+            names.add(proxyHost);
+    }
+    return names;
+}
+/**
+ * Contrôle d'une requête entrante.
+ * - L'en-tête `Host` doit désigner un hôte autorisé : une page tierce qui fait
+ *   pointer son domaine vers 127.0.0.1 (DNS rebinding) est refusée.
+ * - Une requête de modification exige `Content-Type: application/json`, qu'un
+ *   navigateur ne peut envoyer vers une autre origine sans requête préalable
+ *   CORS, refusée ici ; une origine différente de l'hôte appelé est refusée.
+ */
+export function checkRequest(request, allowed) {
+    const hostname = request.host === undefined ? null : hostnameOf(request.host);
+    if (hostname === null || !allowed.has(hostname)) {
+        return { status: 403, error: `Host "${request.host ?? ""}" is not allowed: open the GUI through the proxy or http://localhost.` };
+    }
+    if (SAFE_METHODS.has(request.method.toUpperCase()))
+        return null;
+    const mediaType = request.contentType?.split(";")[0].trim().toLowerCase();
+    if (mediaType !== "application/json") {
+        return { status: 415, error: `Content-Type must be application/json, got "${request.contentType ?? ""}".` };
+    }
+    if (request.origin === undefined)
+        return null;
+    let originHost;
+    try {
+        originHost = new URL(request.origin).host.toLowerCase();
+    }
+    catch {
+        return { status: 403, error: `Cross-origin request refused: origin "${request.origin}" is not a valid URL.` };
+    }
+    if (originHost !== request.host.trim().toLowerCase()) {
+        return { status: 403, error: `Cross-origin request refused: origin "${request.origin}" does not match host "${request.host}".` };
+    }
+    return null;
+}

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

@@ -0,0 +1,27 @@
+import type { Analysis } from "../../shared/schemas/analysis.schema.js";
+import type { AddNoteBody, DeleteNoteBody, SetFileReviewedBody, SetFindingStatusBody, SubmitReviewBody } from "../../shared/schemas/api.schema.js";
+import type { AnalysisStore } from "./analysis-store.js";
+/**
+ * Modifications faites par le relecteur depuis la GUI. Chacune passe par
+ * `store.mutate(id, "user", …, { baseRevision })` et renvoie l'analyse écrite.
+ */
+/** Marque un fichier de l'analyse comme revu, ou le repasse à revoir. */
+export declare function setFileReviewed(store: AnalysisStore, analysisId: string, body: SetFileReviewedBody): Analysis;
+/**
+ * Ignore ou rouvre un constat. `outdated` est posé uniquement par le recalcul
+ * du snapshot, et un constat obsolète ne change de statut que lorsque l'agent
+ * 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. */
+export declare function addNote(store: AnalysisStore, analysisId: string, body: AddNoteBody): Analysis;
+/**
+ * Supprime une remarque. Quand elle fait partie d'une revue soumise, elle est
+ * retirée de la sélection et le prompt enregistré est recalculé sans elle.
+ */
+export declare function deleteNote(store: AnalysisStore, analysisId: string, noteId: string, body: DeleteNoteBody): Analysis;
+/**
+ * Soumet la revue : décision, points retenus et prompt calculé ici. Une
+ * nouvelle soumission remplace la précédente.
+ */
+export declare function submitReview(store: AnalysisStore, analysisId: string, body: SubmitReviewBody): Analysis;

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

@@ -0,0 +1,99 @@
+import { buildAgentPrompt } from "../../shared/prompt.js";
+import { AnalysisError, NotFoundError } from "./errors.js";
+import { itemId } from "./ids.js";
+import { assertNoteLocation } from "./locations.js";
+/**
+ * Modifications faites par le relecteur depuis la GUI. Chacune passe par
+ * `store.mutate(id, "user", …, { baseRevision })` et renvoie l'analyse écrite.
+ */
+/** Marque un fichier de l'analyse comme revu, ou le repasse à revoir. */
+export function setFileReviewed(store, analysisId, body) {
+    return store.mutate(analysisId, "user", (draft) => {
+        const file = draft.files.find((entry) => entry.path === body.path);
+        if (!file)
+            throw new NotFoundError(`File "${body.path}" is not part of analysis "${analysisId}".`);
+        file.reviewed = body.reviewed;
+    }, { baseRevision: body.baseRevision });
+}
+/**
+ * Ignore ou rouvre un constat. `outdated` est posé uniquement par le recalcul
+ * du snapshot, et un constat obsolète ne change de statut que lorsque l'agent
+ * le réancre.
+ */
+export function setFindingStatus(store, analysisId, findingId, body) {
+    if (body.status === "outdated") {
+        throw new AnalysisError(`A finding cannot be marked outdated from the review: only refresh_analysis does it, when the targeted lines change. Choose "ignored" or "open".`);
+    }
+    return store.mutate(analysisId, "user", (draft) => {
+        const finding = draft.findings.find((entry) => entry.id === findingId);
+        if (!finding)
+            throw new NotFoundError(`Finding "${findingId}" not found in analysis "${analysisId}".`);
+        if (finding.status === "outdated") {
+            throw new AnalysisError(`Finding "${findingId}" is outdated: its lines changed since it was written. The agent must anchor it again with update_finding before it can be ignored or reopened.`);
+        }
+        finding.status = body.status;
+    }, { baseRevision: body.baseRevision });
+}
+/** Ajoute une remarque du relecteur sur une ligne du côté « nouveau » ou sur un fichier entier. */
+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);
+        draft.notes.push({
+            id: itemId("note", new Set(draft.notes.map((note) => note.id))),
+            location,
+            text: body.text,
+            createdAt: new Date().toISOString(),
+        });
+    }, { baseRevision: body.baseRevision });
+}
+/**
+ * Supprime une remarque. Quand elle fait partie d'une revue soumise, elle est
+ * retirée de la sélection et le prompt enregistré est recalculé sans elle.
+ */
+export function deleteNote(store, analysisId, noteId, body) {
+    return store.mutate(analysisId, "user", (draft) => {
+        const index = draft.notes.findIndex((note) => note.id === noteId);
+        if (index === -1)
+            throw new NotFoundError(`Note "${noteId}" not found in analysis "${analysisId}".`);
+        draft.notes.splice(index, 1);
+        const review = draft.review;
+        if (!review.selectedNoteIds.includes(noteId))
+            return;
+        review.selectedNoteIds = review.selectedNoteIds.filter((id) => id !== noteId);
+        if (review.state === "submitted") {
+            review.prompt = buildAgentPrompt(draft, {
+                findingIds: review.selectedFindingIds,
+                noteIds: review.selectedNoteIds,
+                decision: review.decision,
+            });
+        }
+    }, { baseRevision: body.baseRevision });
+}
+function assertKnownIds(label, ids, known) {
+    const knownSet = new Set(known);
+    const unknown = ids.filter((id) => !knownSet.has(id));
+    if (unknown.length > 0)
+        throw new AnalysisError(`Unknown ${label} id(s) in the selection: ${unknown.join(", ")}.`);
+    const duplicated = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (duplicated.length > 0)
+        throw new AnalysisError(`The selection lists ${label} id(s) twice: ${[...new Set(duplicated)].join(", ")}.`);
+}
+/**
+ * Soumet la revue : décision, points retenus et prompt calculé ici. Une
+ * nouvelle soumission remplace la précédente.
+ */
+export function submitReview(store, analysisId, body) {
+    return store.mutate(analysisId, "user", (draft) => {
+        assertKnownIds("finding", body.findingIds, draft.findings.map((finding) => finding.id));
+        assertKnownIds("note", body.noteIds, draft.notes.map((note) => note.id));
+        draft.review = {
+            state: "submitted",
+            decision: body.decision,
+            selectedFindingIds: [...body.findingIds],
+            selectedNoteIds: [...body.noteIds],
+            prompt: buildAgentPrompt(draft, { findingIds: body.findingIds, noteIds: body.noteIds, decision: body.decision }),
+            submittedAt: new Date().toISOString(),
+        };
+    }, { baseRevision: body.baseRevision });
+}

package/dist/src/gui-worker.d.ts

@@ -0,0 +1 @@
+export {};