@imenam/mcp-feature-analyzer 1.0.0

package/dist/src/core/analysis-store.js

@@ -0,0 +1,387 @@
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+import { ANALYSIS_ID_PATTERN, AnalysisSchema, } from "../../shared/schemas/analysis.schema.js";
+import { DiffSnapshotSchema } from "../../shared/schemas/diff.schema.js";
+import { reviewProgress } from "../../shared/review-state.js";
+import { emptySeverityCounts } from "../../shared/severity.js";
+import { AnalysisError, NotFoundError, RevisionConflictError } from "./errors.js";
+import { analysisId } from "./ids.js";
+import { assertInvariants, assertSnapshotFieldsUnchanged } from "./invariants.js";
+import { migrateAnalysis, migrateSnapshot } from "./migrate.js";
+import { applyRefresh } from "./refresh.js";
+/** Revue vierge : en attente, sans décision, sélection ni prompt. */
+export function pendingReview() {
+    return { state: "pending", decision: null, selectedFindingIds: [], selectedNoteIds: [], prompt: null, submittedAt: null };
+}
+/** Au-delà de ce délai, un verrou est réputé abandonné par un processus arrêté en cours d'écriture. */
+const LOCK_STALE_MS = 10_000;
+const LOCK_RETRY_MS = 25;
+const LOCK_TIMEOUT_MS = 5_000;
+/** Pause bloquante : le store est synchrone de bout en bout. */
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function formatIssues(issues) {
+    return issues.map((issue) => `${issue.path.map(String).join(".") || "(root)"} ${issue.message}`).join("; ");
+}
+function stampOf(file) {
+    try {
+        const stat = fs.statSync(file);
+        return { mtimeMs: stat.mtimeMs, size: stat.size };
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/** Écriture atomique : fichier temporaire unique puis `rename`, JSON indenté. */
+function writeJsonAtomic(target, value) {
+    const tmp = `${target}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    try {
+        fs.writeFileSync(tmp, JSON.stringify(value, null, 2), "utf-8");
+        fs.renameSync(tmp, target);
+    }
+    catch (err) {
+        fs.rmSync(tmp, { force: true });
+        throw err;
+    }
+}
+/**
+ * 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 class AnalysisStore {
+    dataDir;
+    analysesDir;
+    diffsDir;
+    analysisCache = new Map();
+    snapshotCache = new Map();
+    constructor(dataDir) {
+        this.dataDir = dataDir;
+        this.analysesDir = path.join(dataDir, "analyses");
+        this.diffsDir = path.join(dataDir, "diffs");
+        fs.mkdirSync(this.analysesDir, { recursive: true });
+        fs.mkdirSync(this.diffsDir, { recursive: true });
+    }
+    analysisPath(id) {
+        return path.join(this.analysesDir, `${id}.json`);
+    }
+    snapshotPath(id) {
+        return path.join(this.diffsDir, `${id}.json`);
+    }
+    /** Refuse un identifiant qui ne peut pas désigner une analyse (et donc un nom de fichier). */
+    assertId(id) {
+        if (typeof id !== "string" || !ANALYSIS_ID_PATTERN.test(id)) {
+            throw new AnalysisError(`"${id}" is not a valid analysis id. Use list_analyses to see the available analyses.`);
+        }
+    }
+    notFound(id) {
+        return new NotFoundError(`Analysis "${id}" not found. Use list_analyses to see the available analyses.`);
+    }
+    /**
+     * Sérialise l'accès en écriture à une analyse entre processus : `wx` échoue si
+     * le verrou existe déjà. Non réentrant.
+     */
+    withLock(id, fn) {
+        const lockPath = `${this.analysisPath(id)}.lock`;
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        let fd;
+        for (;;) {
+            try {
+                fd = fs.openSync(lockPath, "wx");
+                break;
+            }
+            catch (err) {
+                if (err.code !== "EEXIST")
+                    throw err;
+                const lockStamp = stampOf(lockPath);
+                // Verrou disparu entre l'ouverture et la lecture de sa date : nouvel essai immédiat.
+                if (lockStamp === null)
+                    continue;
+                if (Date.now() - lockStamp.mtimeMs > LOCK_STALE_MS) {
+                    fs.rmSync(lockPath, { force: true });
+                    continue;
+                }
+                if (Date.now() > deadline) {
+                    throw new AnalysisError(`Analysis "${id}" is being written by another editor and did not free up in ${LOCK_TIMEOUT_MS} ms. Try again in a moment.`);
+                }
+                sleepSync(LOCK_RETRY_MS);
+            }
+        }
+        try {
+            return fn();
+        }
+        finally {
+            fs.closeSync(fd);
+            // Le verrou a pu être cassé pour obsolescence par un autre processus.
+            fs.rmSync(lockPath, { force: true });
+        }
+    }
+    /**
+     * 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.
+     */
+    readDocument(file, label, cache, id, migrate, parse) {
+        const stamp = stampOf(file);
+        if (stamp === null) {
+            cache.delete(id);
+            return null;
+        }
+        const cached = cache.get(id);
+        if (cached && cached.stamp.mtimeMs === stamp.mtimeMs && cached.stamp.size === stamp.size) {
+            return cached.value;
+        }
+        cache.delete(id);
+        let raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(file, "utf-8"));
+        }
+        catch (err) {
+            throw new AnalysisError(`${label} is not readable (${file}): ${err.message}`);
+        }
+        const migrated = migrate(raw);
+        const value = parse(migrated ?? raw);
+        if (migrated)
+            writeJsonAtomic(file, value);
+        const fresh = stampOf(file);
+        if (fresh)
+            cache.set(id, { value, stamp: fresh });
+        return value;
+    }
+    parseAnalysis(id, raw) {
+        const parsed = AnalysisSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new AnalysisError(`Analysis "${id}" does not match the expected schema (${this.analysisPath(id)}): ${formatIssues(parsed.error.issues)}`);
+        }
+        if (parsed.data.id !== id) {
+            throw new AnalysisError(`Analysis file ${this.analysisPath(id)} contains the id "${parsed.data.id}" instead of "${id}".`);
+        }
+        return parsed.data;
+    }
+    parseSnapshot(id, raw) {
+        const parsed = DiffSnapshotSchema.safeParse(raw);
+        if (!parsed.success) {
+            throw new AnalysisError(`Diff snapshot of analysis "${id}" does not match the expected schema (${this.snapshotPath(id)}): ${formatIssues(parsed.error.issues)}`);
+        }
+        if (parsed.data.analysisId !== id) {
+            throw new AnalysisError(`Diff snapshot ${this.snapshotPath(id)} belongs to analysis "${parsed.data.analysisId}" instead of "${id}".`);
+        }
+        return parsed.data;
+    }
+    writeAnalysis(analysis) {
+        const file = this.analysisPath(analysis.id);
+        writeJsonAtomic(file, analysis);
+        const stamp = stampOf(file);
+        if (stamp)
+            this.analysisCache.set(analysis.id, { value: analysis, stamp });
+    }
+    writeSnapshot(snapshot) {
+        const file = this.snapshotPath(snapshot.analysisId);
+        writeJsonAtomic(file, snapshot);
+        const stamp = stampOf(file);
+        if (stamp)
+            this.snapshotCache.set(snapshot.analysisId, { value: snapshot, stamp });
+    }
+    /** Valide une analyse complète (schéma puis invariants) avant écriture. */
+    validate(analysis) {
+        const parsed = AnalysisSchema.safeParse(analysis);
+        if (!parsed.success) {
+            throw new AnalysisError(`Resulting analysis is invalid: ${formatIssues(parsed.error.issues)}`);
+        }
+        assertInvariants(parsed.data);
+        return parsed.data;
+    }
+    has(id) {
+        return ANALYSIS_ID_PATTERN.test(id) && fs.existsSync(this.analysisPath(id));
+    }
+    /** Résumés des analyses, de la plus récemment modifiée à la plus ancienne. */
+    list() {
+        const analyses = [];
+        const unreadable = [];
+        const ids = fs
+            .readdirSync(this.analysesDir)
+            .filter((file) => file.endsWith(".json"))
+            .map((file) => file.slice(0, -".json".length));
+        for (const id of ids) {
+            let analysis;
+            try {
+                this.assertId(id);
+                analysis = this.get(id);
+            }
+            catch (err) {
+                unreadable.push({ id, error: err.message });
+                continue;
+            }
+            analyses.push(summarize(analysis));
+        }
+        analyses.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return { analyses, unreadable };
+    }
+    get(id) {
+        this.assertId(id);
+        const analysis = this.readDocument(this.analysisPath(id), `Analysis "${id}"`, this.analysisCache, id, migrateAnalysis, (raw) => this.parseAnalysis(id, raw));
+        if (analysis === null)
+            throw this.notFound(id);
+        return analysis;
+    }
+    getSnapshot(id) {
+        this.assertId(id);
+        if (!fs.existsSync(this.analysisPath(id)))
+            throw this.notFound(id);
+        const snapshot = this.readDocument(this.snapshotPath(id), `Diff snapshot of analysis "${id}"`, this.snapshotCache, id, migrateSnapshot, (raw) => this.parseSnapshot(id, raw));
+        if (snapshot === null) {
+            throw new AnalysisError(`Diff snapshot of analysis "${id}" is missing (${this.snapshotPath(id)}). ` +
+                `Delete the analysis with delete_analysis and create it again.`);
+        }
+        return snapshot;
+    }
+    /** Crée une analyse à partir d'un snapshot calculé ; le snapshot est écrit avant l'analyse. */
+    create(input, snapshot) {
+        const title = input.title?.trim();
+        if (!title)
+            throw new AnalysisError(`"title" is required to create an analysis.`);
+        const project = input.project?.trim();
+        if (!project)
+            throw new AnalysisError(`"project" is required to create an analysis.`);
+        let id = analysisId(title);
+        while (fs.existsSync(this.analysisPath(id)))
+            id = analysisId(title);
+        const now = new Date().toISOString();
+        const analysis = this.validate({
+            id,
+            title,
+            project,
+            repoPath: snapshot.repoPath,
+            mode: snapshot.mode,
+            base: snapshot.base,
+            head: snapshot.head,
+            baseCommit: snapshot.baseCommit,
+            headCommit: snapshot.headCommit,
+            snapshotAt: snapshot.snapshotAt,
+            request: input.request ?? null,
+            overview: null,
+            summary: input.summary ?? [],
+            files: snapshot.files.map((file) => ({ ...file, reviewed: false })),
+            findings: [],
+            notes: [],
+            diagrams: [],
+            review: pendingReview(),
+            revision: 0,
+            createdAt: now,
+            updatedAt: now,
+            lastEditor: "agent",
+        });
+        const diff = this.buildSnapshot(id, snapshot);
+        return this.withLock(id, () => {
+            this.writeSnapshot(diff);
+            this.writeAnalysis(analysis);
+            return analysis;
+        });
+    }
+    buildSnapshot(id, snapshot) {
+        const parsed = DiffSnapshotSchema.safeParse({ analysisId: id, files: snapshot.diff });
+        if (!parsed.success) {
+            throw new AnalysisError(`Computed diff snapshot is invalid: ${formatIssues(parsed.error.issues)}`);
+        }
+        const diffPaths = parsed.data.files.map((file) => file.path).join("\n");
+        const entryPaths = snapshot.files.map((file) => file.path).join("\n");
+        if (diffPaths !== entryPaths) {
+            throw new AnalysisError(`Computed snapshot is inconsistent: its file list and its diff list differ.`);
+        }
+        return parsed.data;
+    }
+    /**
+     * 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, editor, fn, options = {}) {
+        this.assertId(id);
+        return this.withLock(id, () => {
+            const current = this.get(id);
+            this.assertBaseRevision(current, options);
+            const draft = structuredClone(current);
+            fn(draft);
+            assertSnapshotFieldsUnchanged(current, draft);
+            draft.revision = current.revision + 1;
+            draft.updatedAt = new Date().toISOString();
+            draft.lastEditor = editor;
+            const next = this.validate(draft);
+            this.writeAnalysis(next);
+            return next;
+        });
+    }
+    assertBaseRevision(current, options) {
+        if (options.baseRevision !== undefined && options.baseRevision !== current.revision) {
+            throw new RevisionConflictError(`Analysis "${current.id}" has changed since it was loaded: the edit is based on revision ${options.baseRevision}, ` +
+                `the stored analysis is at revision ${current.revision}. Reload it and apply the change again.`);
+        }
+    }
+    /**
+     * 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, editor, snapshot, options = {}) {
+        this.assertId(id);
+        return this.withLock(id, () => {
+            const current = this.get(id);
+            this.assertBaseRevision(current, options);
+            const oldSnapshot = this.getSnapshot(id);
+            const { fields, stats } = applyRefresh(current, oldSnapshot, snapshot);
+            const next = this.validate({
+                ...structuredClone(current),
+                ...fields,
+                review: pendingReview(),
+                revision: current.revision + 1,
+                updatedAt: new Date().toISOString(),
+                lastEditor: editor,
+            });
+            const diff = this.buildSnapshot(id, snapshot);
+            this.writeSnapshot(diff);
+            this.writeAnalysis(next);
+            return { analysis: next, stats, previousReview: current.review };
+        });
+    }
+    /** Supprime l'analyse et son snapshot de diff. */
+    delete(id) {
+        this.assertId(id);
+        this.withLock(id, () => {
+            if (!fs.existsSync(this.analysisPath(id)))
+                throw this.notFound(id);
+            fs.rmSync(this.analysisPath(id));
+            fs.rmSync(this.snapshotPath(id), { force: true });
+            this.analysisCache.delete(id);
+            this.snapshotCache.delete(id);
+        });
+    }
+}
+/** Vue légère d'une analyse. */
+export function summarize(analysis) {
+    const openFindings = emptySeverityCounts();
+    for (const finding of analysis.findings) {
+        if (finding.status === "open")
+            openFindings[finding.severity]++;
+    }
+    return {
+        id: analysis.id,
+        title: analysis.title,
+        project: analysis.project,
+        mode: analysis.mode,
+        base: analysis.base,
+        head: analysis.head,
+        fileCount: analysis.files.length,
+        reviewedCount: analysis.files.filter((file) => file.reviewed).length,
+        openFindings,
+        diagramCount: analysis.diagrams.length,
+        progress: reviewProgress(analysis),
+        updatedAt: analysis.updatedAt,
+        revision: analysis.revision,
+    };
+}

package/dist/src/core/data-dir.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Répertoire des données : MCP_FEATURE_ANALYZER_DATA_DIR, puis MCP_DATA_DIR,
+ * puis <racine du package>/.feature-analyzer-data.
+ */
+export declare function resolveDataDir(rootDir: string): string;

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

@@ -0,0 +1,11 @@
+import path from "path";
+/**
+ * Répertoire des données : MCP_FEATURE_ANALYZER_DATA_DIR, puis MCP_DATA_DIR,
+ * puis <racine du package>/.feature-analyzer-data.
+ */
+export function resolveDataDir(rootDir) {
+    const configured = process.env.MCP_FEATURE_ANALYZER_DATA_DIR?.trim() || process.env.MCP_DATA_DIR?.trim();
+    if (configured)
+        return path.resolve(configured);
+    return path.join(rootDir, ".feature-analyzer-data");
+}

package/dist/src/core/diff-parser.d.ts

@@ -0,0 +1,22 @@
+import type { FileStatus } from "../../shared/schemas/analysis.schema.js";
+import type { Hunk } from "../../shared/schemas/diff.schema.js";
+/** Diff d'un fichier tel que lu dans la sortie de `git diff`. */
+export interface ParsedFileDiff {
+    /** Chemin côté « nouveau » ; chemin supprimé pour un fichier supprimé. */
+    path: string;
+    /** Ancien chemin d'un fichier renommé ; null sinon. */
+    oldPath: string | null;
+    status: FileStatus;
+    binary: boolean;
+    hunks: Hunk[];
+    additions: number;
+    deletions: number;
+}
+/** Remplace les antislashs par des slashs. */
+export declare function toPosixPath(value: string): string;
+/**
+ * Lit la sortie de `git diff` (format unifié, préfixes `a/` et `b/`) et renvoie
+ * un diff par fichier. Les lignes `` sont écartées ;
+ * les `\r` de fin de ligne sont retirés du texte des lignes.
+ */
+export declare function parseUnifiedDiff(output: string): ParsedFileDiff[];

package/dist/src/core/diff-parser.js

@@ -0,0 +1,225 @@
+import { GitError } from "./errors.js";
+const HUNK_HEADER = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+/** Retire le `\r` final d'une ligne lue dans une sortie découpée sur `\n`. */
+function stripCr(line) {
+    return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+/** Remplace les antislashs par des slashs. */
+export function toPosixPath(value) {
+    return value.replace(/\\/g, "/");
+}
+const ESCAPES = { a: 7, b: 8, t: 9, n: 10, v: 11, f: 12, r: 13, '"': 34, "\\": 92 };
+/**
+ * Décode un chemin entre guillemets tel que git l'écrit (échappements C et
+ * octets en octal). `quoted` commence par `"` ; renvoie le chemin et la
+ * position qui suit le guillemet fermant.
+ */
+function readQuoted(quoted, start) {
+    const bytes = [];
+    let i = start + 1;
+    while (i < quoted.length) {
+        const char = quoted[i];
+        if (char === '"') {
+            return { value: Buffer.from(bytes).toString("utf-8"), end: i + 1 };
+        }
+        if (char === "\\") {
+            const next = quoted[i + 1];
+            if (next !== undefined && /[0-7]/.test(next)) {
+                bytes.push(parseInt(quoted.slice(i + 1, i + 4), 8));
+                i += 4;
+                continue;
+            }
+            if (next !== undefined && ESCAPES[next] !== undefined) {
+                bytes.push(ESCAPES[next]);
+                i += 2;
+                continue;
+            }
+            throw new GitError(`Unexpected escape sequence in git path: ${quoted}`);
+        }
+        bytes.push(...Buffer.from(char, "utf-8"));
+        i += 1;
+    }
+    throw new GitError(`Unterminated quoted path in git output: ${quoted}`);
+}
+/** Chemin d'une ligne `--- a/x`, `+++ b/x`, `rename from x` : décode les guillemets, retire le préfixe. */
+function readPathField(raw, prefix) {
+    // git ajoute une tabulation après un chemin contenant une espace.
+    const field = raw.endsWith("\t") ? raw.slice(0, -1) : raw;
+    if (field === "/dev/null")
+        return null;
+    const value = field.startsWith('"') ? readQuoted(field, 0).value : field;
+    if (prefix === null)
+        return value;
+    if (!value.startsWith(prefix)) {
+        throw new GitError(`Unexpected path "${value}" in git diff output: expected the "${prefix}" prefix.`);
+    }
+    return value.slice(prefix.length);
+}
+/** Chemins ancien et nouveau de la ligne `diff --git a/x b/y`, quand elle est décodable sans ambiguïté. */
+function readGitHeader(rest) {
+    if (rest.startsWith('"')) {
+        const first = readQuoted(rest, 0);
+        const second = rest.slice(first.end + 1);
+        const newPath = second.startsWith('"') ? readQuoted(second, 0).value : second;
+        return strip(first.value, newPath);
+    }
+    const quotedSecond = rest.indexOf(' "b/');
+    if (quotedSecond !== -1 && rest.endsWith('"')) {
+        return strip(rest.slice(0, quotedSecond), readQuoted(rest, quotedSecond + 1).value);
+    }
+    // Sans guillemets, seul le cas symétrique « a/P b/P » se découpe sans ambiguïté.
+    if ((rest.length - 5) % 2 !== 0)
+        return null;
+    const length = (rest.length - 5) / 2;
+    const candidate = rest.slice(2, 2 + length);
+    if (rest !== `a/${candidate} b/${candidate}`)
+        return null;
+    return { oldPath: candidate, newPath: candidate };
+    function strip(oldValue, newValue) {
+        if (!oldValue.startsWith("a/") || !newValue.startsWith("b/"))
+            return null;
+        return { oldPath: oldValue.slice(2), newPath: newValue.slice(2) };
+    }
+}
+function finish(block) {
+    let oldPath = block.renameFrom ?? (block.minusPath === undefined ? undefined : block.minusPath);
+    let newPath = block.renameTo ?? (block.plusPath === undefined ? undefined : block.plusPath);
+    if (oldPath === undefined)
+        oldPath = block.isNew ? null : block.header?.oldPath;
+    if (newPath === undefined)
+        newPath = block.isDeleted ? null : block.header?.newPath;
+    if (oldPath === undefined || newPath === undefined) {
+        throw new GitError(`Cannot determine the file paths of this git diff entry: ${block.headerLine}`);
+    }
+    let status;
+    if (block.isNew || oldPath === null)
+        status = "added";
+    else if (block.isDeleted || newPath === null)
+        status = "deleted";
+    else if (block.renameFrom !== null || oldPath !== newPath)
+        status = "renamed";
+    else
+        status = "modified";
+    const path = status === "deleted" ? oldPath : newPath;
+    if (path === null) {
+        throw new GitError(`Cannot determine the file path of this git diff entry: ${block.headerLine}`);
+    }
+    let additions = 0;
+    let deletions = 0;
+    for (const hunk of block.hunks) {
+        for (const line of hunk.lines) {
+            if (line.type === "add")
+                additions++;
+            else if (line.type === "del")
+                deletions++;
+        }
+    }
+    return {
+        path: toPosixPath(path),
+        oldPath: status === "renamed" && oldPath !== null ? toPosixPath(oldPath) : null,
+        status,
+        binary: block.binary,
+        hunks: block.hunks,
+        additions,
+        deletions,
+    };
+}
+/**
+ * Lit la sortie de `git diff` (format unifié, préfixes `a/` et `b/`) et renvoie
+ * un diff par fichier. Les lignes `` sont écartées ;
+ * les `\r` de fin de ligne sont retirés du texte des lignes.
+ */
+export function parseUnifiedDiff(output) {
+    const lines = output.split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    const files = [];
+    let block = null;
+    let i = 0;
+    while (i < lines.length) {
+        const line = stripCr(lines[i]);
+        if (line.startsWith("diff --git ")) {
+            if (block)
+                files.push(finish(block));
+            block = {
+                header: readGitHeader(line.slice("diff --git ".length)),
+                headerLine: line,
+                minusPath: undefined,
+                plusPath: undefined,
+                renameFrom: null,
+                renameTo: null,
+                isNew: false,
+                isDeleted: false,
+                binary: false,
+                hunks: [],
+            };
+            i++;
+            continue;
+        }
+        if (!block) {
+            throw new GitError(`Unexpected line before the first "diff --git" header: ${line}`);
+        }
+        const hunkMatch = HUNK_HEADER.exec(line);
+        if (hunkMatch) {
+            const oldStart = Number(hunkMatch[1]);
+            const oldLines = hunkMatch[2] === undefined ? 1 : Number(hunkMatch[2]);
+            const newStart = Number(hunkMatch[3]);
+            const newLines = hunkMatch[4] === undefined ? 1 : Number(hunkMatch[4]);
+            const hunkLines = [];
+            let oldNo = oldStart;
+            let newNo = newStart;
+            let oldLeft = oldLines;
+            let newLeft = newLines;
+            i++;
+            while (i < lines.length && (oldLeft > 0 || newLeft > 0 || lines[i].startsWith("\\"))) {
+                const raw = lines[i];
+                const marker = raw[0];
+                const text = stripCr(raw.slice(1));
+                if (marker === " ") {
+                    hunkLines.push({ type: "context", oldNo, newNo, text });
+                    oldNo++;
+                    newNo++;
+                    oldLeft--;
+                    newLeft--;
+                }
+                else if (marker === "-") {
+                    hunkLines.push({ type: "del", oldNo, newNo: null, text });
+                    oldNo++;
+                    oldLeft--;
+                }
+                else if (marker === "+") {
+                    hunkLines.push({ type: "add", oldNo: null, newNo, text });
+                    newNo++;
+                    newLeft--;
+                }
+                else if (marker !== "\\") {
+                    throw new GitError(`Malformed hunk in the diff of ${block.headerLine}: unexpected line "${raw}".`);
+                }
+                i++;
+            }
+            if (oldLeft !== 0 || newLeft !== 0) {
+                throw new GitError(`Truncated hunk "${line}" in the diff of ${block.headerLine}.`);
+            }
+            block.hunks.push({ header: line, oldStart, oldLines, newStart, newLines, lines: hunkLines });
+            continue;
+        }
+        if (line.startsWith("--- "))
+            block.minusPath = readPathField(line.slice(4), "a/");
+        else if (line.startsWith("+++ "))
+            block.plusPath = readPathField(line.slice(4), "b/");
+        else if (line.startsWith("rename from "))
+            block.renameFrom = readPathField(line.slice(12), null);
+        else if (line.startsWith("rename to "))
+            block.renameTo = readPathField(line.slice(10), null);
+        else if (line.startsWith("new file mode "))
+            block.isNew = true;
+        else if (line.startsWith("deleted file mode "))
+            block.isDeleted = true;
+        else if (line.startsWith("Binary files ") || line === "GIT binary patch")
+            block.binary = true;
+        i++;
+    }
+    if (block)
+        files.push(finish(block));
+    return files;
+}

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

@@ -0,0 +1,16 @@
+/** Erreur métier dont le message s'adresse directement à l'agent ou à la GUI. */
+export declare class AnalysisError extends Error {
+    constructor(message: string);
+}
+/** Analyse, constat ou remarque introuvable. */
+export declare class NotFoundError extends AnalysisError {
+    constructor(message: string);
+}
+/** Modification basée sur une révision qui n'est plus la révision enregistrée. */
+export declare class RevisionConflictError extends AnalysisError {
+    constructor(message: string);
+}
+/** Échec d'accès au dépôt git : chemin invalide, dépôt absent, ref inconnue, commande en erreur. */
+export declare class GitError extends Error {
+    constructor(message: string);
+}