@imenam/mcp-feature-analyzer 1.0.0

package/dist/src/tools/add-findings.js

@@ -0,0 +1,106 @@
+import { summarize } from "../core/analysis-store.js";
+import { AnalysisError } from "../core/errors.js";
+import { itemId } from "../core/ids.js";
+import { resolveLocation } from "../core/locations.js";
+import { FINDING_KINDS, SEVERITIES } from "../../shared/schemas/analysis.schema.js";
+import { findingLine, severityCountsLabel } from "./format.js";
+import { readItemId, readLocation } from "./inputs.js";
+import { nullableText, optionalEnum, rejectUnknownFields, requireArray, requireEnum, requireObject, requireString, requireText, textResult, } from "./types.js";
+export const FINDING_INPUT_FIELDS = [
+    "id",
+    "severity",
+    "kind",
+    "title",
+    "body",
+    "path",
+    "start_line",
+    "end_line",
+    "suggestion",
+    "prompt",
+];
+/**
+ * Ajoute un lot de constats. Tout le lot est validé (champs, identifiants,
+ * emplacements résolus sur le snapshot) avant l'écriture : un seul constat
+ * invalide et rien n'est ajouté.
+ */
+export function addFindings(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "findings"]);
+    const id = requireString(args, "analysis_id");
+    const items = requireArray(args, "findings", 1);
+    const analysis = store.get(id);
+    const snapshot = store.getSnapshot(id);
+    const taken = new Set(analysis.findings.map((finding) => finding.id));
+    const batchIds = new Set();
+    const prepared = [];
+    const errors = [];
+    items.forEach((raw, index) => {
+        try {
+            const item = requireObject(raw, `findings[${index}]`);
+            rejectUnknownFields(item, FINDING_INPUT_FIELDS);
+            const findingId = readItemId(item, "id");
+            if (findingId !== undefined) {
+                if (taken.has(findingId))
+                    throw new Error(`id "${findingId}" is already used by another finding of this analysis.`);
+                if (batchIds.has(findingId))
+                    throw new Error(`id "${findingId}" appears twice in this batch.`);
+                batchIds.add(findingId);
+            }
+            const severity = requireEnum(item, "severity", SEVERITIES);
+            const kind = optionalEnum(item, "kind", FINDING_KINDS) ?? "issue";
+            const title = requireString(item, "title");
+            const body = requireText(item, "body");
+            const suggestion = nullableText(item, "suggestion", "", true) ?? null;
+            const prompt = nullableText(item, "prompt") ?? null;
+            const location = readLocation(item);
+            if (location === null)
+                throw new Error(`"path" cannot be null here: omit it for a finding without location.`);
+            if (location === undefined && kind === "issue") {
+                throw new Error(`an issue needs a location ("path" and "start_line"); only requirement_gap findings may omit it.`);
+            }
+            if (location === undefined && suggestion !== null) {
+                throw new Error(`"suggestion" replaces the targeted lines, so it needs a location ("path" and "start_line").`);
+            }
+            const resolved = location === undefined ? null : resolveLocation(snapshot, analysis.files, location);
+            prepared.push({
+                id: findingId,
+                severity,
+                kind,
+                title,
+                body,
+                location: resolved && { path: resolved.path, startLine: resolved.startLine, endLine: resolved.endLine },
+                anchorText: resolved?.anchorText ?? null,
+                suggestion,
+                prompt,
+            });
+        }
+        catch (err) {
+            errors.push(`- findings[${index}]: ${err.message}`);
+        }
+    });
+    if (errors.length > 0) {
+        throw new AnalysisError(`No finding was added: ${errors.length} of ${items.length} finding(s) are invalid. Fix them and send the whole batch again.\n` +
+            errors.join("\n"));
+    }
+    const added = [];
+    const updated = store.mutate(id, "agent", (draft) => {
+        if (draft.snapshotAt !== analysis.snapshotAt) {
+            throw new AnalysisError(`The diff of analysis "${id}" was recomputed while the findings were validated. Send the batch again.`);
+        }
+        const ids = new Set([...draft.findings.map((finding) => finding.id), ...batchIds]);
+        const now = new Date().toISOString();
+        for (const finding of prepared) {
+            const newId = finding.id ?? itemId("finding", ids);
+            ids.add(newId);
+            const created = { ...finding, id: newId, status: "open", createdAt: now };
+            added.push(created);
+            draft.findings.push(created);
+        }
+    });
+    const lines = [
+        `Added ${added.length} finding(s) to "${updated.title}" (${updated.id}):`,
+        ...added.map((finding) => `  ${findingLine(finding)}`),
+        `Open findings: ${severityCountsLabel(summarize(updated).openFindings)}.`,
+        "Next: draw a diagram with set_diagram if a picture helps, then ask the user to review the analysis in the GUI.",
+    ];
+    return { result: textResult(lines.join("\n")), analysisId: updated.id };
+}

package/dist/src/tools/create-analysis.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/** Calcule et fige le diff du dépôt, puis crée l'analyse. */
+export declare function createAnalysis(store: AnalysisStore, args: Args): Promise<MutationResult>;

package/dist/src/tools/create-analysis.js

@@ -0,0 +1,36 @@
+import { computeSnapshot } from "../core/git.js";
+import { ANALYSIS_MODES } from "../../shared/schemas/analysis.schema.js";
+import { fileLine, fileTotals, snapshotLabel } from "./format.js";
+import { optionalString, rejectUnknownFields, requireEnum, requireString, textResult, } from "./types.js";
+const FIELDS = ["repo_path", "project", "title", "mode", "base", "head", "request_text", "request_source"];
+/** Calcule et fige le diff du dépôt, puis crée l'analyse. */
+export async function createAnalysis(store, args) {
+    rejectUnknownFields(args, FIELDS);
+    const repoPath = requireString(args, "repo_path");
+    const project = requireString(args, "project");
+    const title = requireString(args, "title");
+    const mode = requireEnum(args, "mode", ANALYSIS_MODES);
+    const base = optionalString(args, "base");
+    const head = optionalString(args, "head");
+    const requestText = optionalString(args, "request_text");
+    const requestSource = optionalString(args, "request_source");
+    if (requestSource !== undefined && requestText === undefined) {
+        throw new Error(`"request_source" describes the initial request: give "request_text" too.`);
+    }
+    const computed = await computeSnapshot({ repoPath, mode, base, head });
+    const analysis = store.create({ project, title, request: requestText === undefined ? null : { text: requestText, source: requestSource ?? null } }, computed);
+    const lines = [
+        `Created analysis "${analysis.title}" (id: ${analysis.id}) in project "${analysis.project}".`,
+        `Repository: ${analysis.repoPath}`,
+        `Diff: ${snapshotLabel(analysis)}`,
+        "",
+    ];
+    if (analysis.files.length === 0) {
+        lines.push("Changed files: none — the diff is empty. Check the mode and refs; delete this analysis with delete_analysis and create it again with the right ones.");
+    }
+    else {
+        lines.push(`Changed files (${fileTotals(analysis.files)}):`, ...analysis.files.map((file) => `  ${fileLine(file)}`));
+    }
+    lines.push("", "Next steps:", `1. Read the frozen diff with get_diff (analysis_id "${analysis.id}"); anchor findings on its new-side line numbers.`, "2. Write the overview (objective, approach, attention_points) and the summary (the functional changes of the feature) with update_analysis.", "3. Record problems with add_findings, including requirement_gap findings for requested behaviour that is missing.", "4. Add diagrams with set_diagram when a picture helps the reviewer: one subject each, 5 to 12 nodes, no crossing.", "5. Ask the user to review the analysis in the GUI, then read the outcome with get_review_feedback.");
+    return { result: textResult(lines.join("\n")), analysisId: analysis.id };
+}

package/dist/src/tools/delete-analysis.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/** Supprime une analyse et son snapshot de diff. */
+export declare function deleteAnalysis(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/delete-analysis.js

@@ -0,0 +1,11 @@
+import { rejectUnknownFields, requireString, textResult } from "./types.js";
+/** Supprime une analyse et son snapshot de diff. */
+export function deleteAnalysis(store, args) {
+    rejectUnknownFields(args, ["analysis_id"]);
+    const id = requireString(args, "analysis_id");
+    store.delete(id);
+    return {
+        result: textResult(`Deleted analysis ${id} and its diff snapshot. The repository is untouched.`),
+        analysisId: id,
+    };
+}

package/dist/src/tools/delete-diagram.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/** Supprime un schéma d'une analyse. */
+export declare function deleteDiagram(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/delete-diagram.js

@@ -0,0 +1,22 @@
+import { AnalysisError } from "../core/errors.js";
+import { rejectUnknownFields, requireString, textResult } from "./types.js";
+/** Supprime un schéma d'une analyse. */
+export function deleteDiagram(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "diagram_id"]);
+    const id = requireString(args, "analysis_id");
+    const diagramId = requireString(args, "diagram_id");
+    let title = "";
+    const updated = store.mutate(id, "agent", (draft) => {
+        const diagram = draft.diagrams.find((entry) => entry.id === diagramId);
+        if (!diagram) {
+            const existing = draft.diagrams.map((entry) => entry.id).join(", ") || "none";
+            throw new AnalysisError(`Diagram "${diagramId}" not found in analysis "${id}". Existing diagrams: ${existing}.`);
+        }
+        title = diagram.title;
+        draft.diagrams = draft.diagrams.filter((entry) => entry.id !== diagramId);
+    });
+    return {
+        result: textResult(`Deleted diagram ${diagramId} ("${title}") from "${updated.title}" (${updated.id}). ${updated.diagrams.length} diagram(s) remain.`),
+        analysisId: updated.id,
+    };
+}

package/dist/src/tools/delete-findings.d.ts

@@ -0,0 +1,7 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/**
+ * Supprime des constats par identifiant et les retire de la sélection de la
+ * revue. Un identifiant inconnu fait échouer l'appel sans rien supprimer.
+ */
+export declare function deleteFindings(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/delete-findings.js

@@ -0,0 +1,27 @@
+import { AnalysisError } from "../core/errors.js";
+import { rejectUnknownFields, requireString, requireStringArray, textResult } from "./types.js";
+/**
+ * Supprime des constats par identifiant et les retire de la sélection de la
+ * revue. Un identifiant inconnu fait échouer l'appel sans rien supprimer.
+ */
+export function deleteFindings(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "finding_ids"]);
+    const id = requireString(args, "analysis_id");
+    const ids = [...new Set(requireStringArray(args, "finding_ids", 1))];
+    const updated = store.mutate(id, "agent", (draft) => {
+        const known = new Set(draft.findings.map((finding) => finding.id));
+        const unknown = ids.filter((findingId) => !known.has(findingId));
+        if (unknown.length > 0) {
+            const existing = draft.findings.map((finding) => finding.id).join(", ") || "none";
+            throw new AnalysisError(`No finding was deleted: unknown finding id(s) ${unknown.join(", ")} in analysis "${id}". Existing findings: ${existing}.`);
+        }
+        const removed = new Set(ids);
+        draft.findings = draft.findings.filter((finding) => !removed.has(finding.id));
+        draft.review.selectedFindingIds = draft.review.selectedFindingIds.filter((findingId) => !removed.has(findingId));
+    });
+    return {
+        result: textResult(`Deleted ${ids.length} finding(s) from "${updated.title}" (${updated.id}): ${ids.join(", ")}. ` +
+            `${updated.findings.length} finding(s) remain.`),
+        analysisId: updated.id,
+    };
+}

package/dist/src/tools/format.d.ts

@@ -0,0 +1,27 @@
+import { type Analysis, type FileEntry, type Finding, type Note, type Overview, type ReviewProgress, type ReviewProgressState, type Severity } from "../../shared/schemas/analysis.schema.js";
+/** Sha abrégé à 7 caractères. */
+export declare function shortSha(sha: string | null): string;
+/** Refs d'une analyse : `branch master...HEAD` ou `working_tree (changes against HEAD)`. */
+export declare function refsLabel(analysis: Pick<Analysis, "mode" | "base" | "head">): string;
+/** Refs et commits figés d'une analyse. */
+export declare function snapshotLabel(analysis: Analysis): string;
+/** Ligne d'un fichier modifié : statut, chemin (ancien chemin si renommé), +/-. */
+export declare function fileLine(file: FileEntry): string;
+/** Totaux +/- des fichiers. */
+export declare function fileTotals(files: FileEntry[]): string;
+/** `path:12` ou `path:12-14`, ou `no location`. */
+export declare function locationLabel(finding: Pick<Finding, "location">): string;
+/** `path`, `path:12`, ou `whole analysis` pour une remarque sans emplacement. */
+export declare function noteLocationLabel(note: Pick<Note, "location">): string;
+/** Ligne d'un constat : id, gravité, nature, statut, emplacement, titre. */
+export declare function findingLine(finding: Finding): string;
+/** `1 critical, 2 major` ; `none` quand tous les compteurs sont à zéro. */
+export declare function severityCountsLabel(counts: Record<Severity, number>): string;
+/** Préfixe chaque ligne non vide de `indent`. */
+export declare function indentBlock(text: string, indent: string): string;
+/** Nom anglais d'un état de revue : `not started`, `in progress`… */
+export declare function progressStateLabel(state: ReviewProgressState): string;
+/** `in progress (2/7 files reviewed)` ou `submitted, decision approve (7/7 files reviewed)`. */
+export declare function progressLabel(progress: ReviewProgress): string;
+/** Bloc « Overview » : objectif, approche et points d'attention ; une ligne d'invitation quand il n'y en a pas. */
+export declare function overviewLines(overview: Overview | null): string[];

package/dist/src/tools/format.js

@@ -0,0 +1,92 @@
+import { SEVERITIES, } from "../../shared/schemas/analysis.schema.js";
+import { lineRange, noteLocationText } from "../../shared/text.js";
+/** Lettre de statut d'un fichier, à la manière de `git status --short`. */
+const FILE_STATUS_LETTERS = {
+    added: "A",
+    modified: "M",
+    deleted: "D",
+    renamed: "R",
+};
+/** Sha abrégé à 7 caractères. */
+export function shortSha(sha) {
+    return sha === null ? "-" : sha.slice(0, 7);
+}
+/** Refs d'une analyse : `branch master...HEAD` ou `working_tree (changes against HEAD)`. */
+export function refsLabel(analysis) {
+    if (analysis.mode === "branch")
+        return `branch ${analysis.base}...${analysis.head}`;
+    return "working_tree (uncommitted changes against HEAD)";
+}
+/** Refs et commits figés d'une analyse. */
+export function snapshotLabel(analysis) {
+    const commits = analysis.mode === "branch"
+        ? `base ${shortSha(analysis.baseCommit)}, head ${shortSha(analysis.headCommit)}`
+        : `HEAD ${shortSha(analysis.baseCommit)}`;
+    return `${refsLabel(analysis)} (${commits}, snapshot at ${analysis.snapshotAt})`;
+}
+/** Ligne d'un fichier modifié : statut, chemin (ancien chemin si renommé), +/-. */
+export function fileLine(file) {
+    const name = file.oldPath === null ? file.path : `${file.oldPath} -> ${file.path}`;
+    const counts = file.binary ? "binary" : `+${file.additions} -${file.deletions}`;
+    const extra = !file.binary && !file.contentAvailable && file.status !== "deleted" ? ", content too large to anchor findings" : "";
+    return `${FILE_STATUS_LETTERS[file.status]} ${name}  ${counts}${extra}`;
+}
+/** Totaux +/- des fichiers. */
+export function fileTotals(files) {
+    const additions = files.reduce((sum, file) => sum + file.additions, 0);
+    const deletions = files.reduce((sum, file) => sum + file.deletions, 0);
+    return `${files.length} file(s), +${additions} -${deletions}`;
+}
+/** `path:12` ou `path:12-14`, ou `no location`. */
+export function locationLabel(finding) {
+    const location = finding.location;
+    if (location === null)
+        return "no location";
+    return `${location.path}:${lineRange(location.startLine, location.endLine)}`;
+}
+/** `path`, `path:12`, ou `whole analysis` pour une remarque sans emplacement. */
+export function noteLocationLabel(note) {
+    return note.location ? noteLocationText(note.location) : "whole analysis";
+}
+/** Ligne d'un constat : id, gravité, nature, statut, emplacement, titre. */
+export function findingLine(finding) {
+    return `${finding.id} [${finding.severity}] ${finding.kind}, ${finding.status} — ${locationLabel(finding)} — ${finding.title}`;
+}
+/** `1 critical, 2 major` ; `none` quand tous les compteurs sont à zéro. */
+export function severityCountsLabel(counts) {
+    const parts = SEVERITIES.filter((severity) => counts[severity] > 0).map((severity) => `${counts[severity]} ${severity}`);
+    return parts.length === 0 ? "none" : parts.join(", ");
+}
+/** Préfixe chaque ligne non vide de `indent`. */
+export function indentBlock(text, indent) {
+    return text
+        .split("\n")
+        .map((line) => (line === "" ? "" : `${indent}${line}`))
+        .join("\n");
+}
+const REVIEW_PROGRESS_TEXT = {
+    not_started: "not started",
+    in_progress: "in progress",
+    files_reviewed: "all files reviewed, not submitted",
+    submitted: "submitted",
+};
+/** Nom anglais d'un état de revue : `not started`, `in progress`… */
+export function progressStateLabel(state) {
+    return REVIEW_PROGRESS_TEXT[state];
+}
+/** `in progress (2/7 files reviewed)` ou `submitted, decision approve (7/7 files reviewed)`. */
+export function progressLabel(progress) {
+    const decision = progress.state === "submitted" ? `, decision ${progress.decision}` : "";
+    return `${REVIEW_PROGRESS_TEXT[progress.state]}${decision} (${progress.reviewedFiles}/${progress.totalFiles} files reviewed)`;
+}
+/** Bloc « Overview » : objectif, approche et points d'attention ; une ligne d'invitation quand il n'y en a pas. */
+export function overviewLines(overview) {
+    if (overview === null)
+        return ["Overview: none yet (write objective and approach with update_analysis)."];
+    const lines = ["Overview:", `  Objective: ${indentBlock(overview.objective, "    ").trimStart()}`, `  Approach: ${indentBlock(overview.approach, "    ").trimStart()}`];
+    if (overview.attentionPoints.length === 0)
+        lines.push("  Attention points: none");
+    else
+        lines.push("  Attention points:", ...overview.attentionPoints.map((point) => `  - ${point}`));
+    return lines;
+}

package/dist/src/tools/get-analysis.d.ts

@@ -0,0 +1,4 @@
+import { type AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type ToolResult } from "./types.js";
+/** Vue complète et lisible d'une analyse. */
+export declare function getAnalysis(store: AnalysisStore, args: Args): ToolResult;

package/dist/src/tools/get-analysis.js

@@ -0,0 +1,87 @@
+import { summarize } from "../core/analysis-store.js";
+import { diagramQuality } from "../../shared/diagram-quality.js";
+import { reviewProgress } from "../../shared/review-state.js";
+import { sortBySeverity } from "../../shared/severity.js";
+import { fileLine, fileTotals, findingLine, noteLocationLabel, overviewLines, progressLabel, severityCountsLabel, snapshotLabel, } from "./format.js";
+import { rejectUnknownFields, requireString, textResult } from "./types.js";
+function noteLine(note) {
+    return `${note.id} — ${noteLocationLabel(note)} — ${note.text.replace(/\n/g, " / ")}`;
+}
+function reviewLines(analysis) {
+    const review = analysis.review;
+    const progress = progressLabel(reviewProgress(analysis));
+    if (review.state === "submitted") {
+        return [
+            `Review: ${progress}, submitted at ${review.submittedAt}, ` +
+                `${review.selectedFindingIds.length} finding(s) and ${review.selectedNoteIds.length} note(s) selected. ` +
+                `Read it with get_review_feedback.`,
+        ];
+    }
+    return [`Review: ${progress} — the reviewer has not submitted feedback yet.`];
+}
+/** Ligne d'un schéma, avec un avertissement quand son tracé a des croisements ou ne peut pas être calculé. */
+function diagramLine(diagram) {
+    const head = `  ${diagram.id} — "${diagram.title}" (${diagram.kind}, ${diagram.nodes.length} node(s), ${diagram.links.length} link(s))`;
+    let quality;
+    try {
+        quality = diagramQuality(diagram);
+    }
+    catch (err) {
+        return `${head} — WARNING: cannot be laid out (${err.message}). Fix it with set_diagram.`;
+    }
+    const problems = [];
+    if (quality.crossings.length > 0)
+        problems.push(`${quality.crossings.length} link crossing(s)`);
+    if (quality.nodeOverlaps.length > 0)
+        problems.push(`${quality.nodeOverlaps.length} link(s) through a node`);
+    if (problems.length === 0)
+        return head;
+    return `${head} — WARNING: ${problems.join(", ")}. Send it again with set_diagram to see the details and fix it.`;
+}
+/** Vue complète et lisible d'une analyse. */
+export function getAnalysis(store, args) {
+    rejectUnknownFields(args, ["analysis_id"]);
+    const analysis = store.get(requireString(args, "analysis_id"));
+    const lines = [
+        `# ${analysis.title} (id: ${analysis.id})`,
+        `Project: ${analysis.project}`,
+        `Repository: ${analysis.repoPath}`,
+        `Diff: ${snapshotLabel(analysis)}`,
+        `Revision ${analysis.revision}, last edited by ${analysis.lastEditor} at ${analysis.updatedAt}`,
+        "",
+    ];
+    if (analysis.request) {
+        lines.push(`Initial request${analysis.request.source ? ` (${analysis.request.source})` : ""}:`, analysis.request.text, "");
+    }
+    else {
+        lines.push("Initial request: none recorded (set it with update_analysis).", "");
+    }
+    lines.push(...overviewLines(analysis.overview), "");
+    if (analysis.summary.length > 0) {
+        lines.push("Summary:", ...analysis.summary.map((bullet) => `- ${bullet}`), "");
+    }
+    else {
+        lines.push("Summary: none yet (write it with update_analysis).", "");
+    }
+    const reviewed = analysis.files.filter((file) => file.reviewed).length;
+    lines.push(`Files (${fileTotals(analysis.files)}; reviewed ${reviewed}/${analysis.files.length}):`);
+    lines.push(...analysis.files.map((file) => `  [${file.reviewed ? "x" : " "}] ${fileLine(file)}`), "");
+    const counts = { open: 0, ignored: 0, outdated: 0 };
+    for (const finding of analysis.findings)
+        counts[finding.status]++;
+    lines.push(`Findings (${analysis.findings.length}: ${counts.open} open, ${counts.ignored} ignored, ${counts.outdated} outdated; ` +
+        `open by severity: ${severityCountsLabel(summarize(analysis).openFindings)}):`);
+    if (analysis.findings.length === 0)
+        lines.push("  none (record them with add_findings)");
+    lines.push(...sortBySeverity(analysis.findings).map((finding) => `  ${findingLine(finding)}`), "");
+    lines.push(`Reviewer notes (${analysis.notes.length}):`);
+    if (analysis.notes.length === 0)
+        lines.push("  none");
+    lines.push(...analysis.notes.map((note) => `  ${noteLine(note)}`), "");
+    lines.push(`Diagrams (${analysis.diagrams.length}):`);
+    if (analysis.diagrams.length === 0)
+        lines.push("  none (draw one with set_diagram when a picture helps)");
+    lines.push(...analysis.diagrams.map(diagramLine), "");
+    lines.push(...reviewLines(analysis));
+    return textResult(lines.join("\n"));
+}

package/dist/src/tools/get-diff.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type ToolResult } from "./types.js";
+/** Diff figé d'un fichier ou de tous les fichiers de l'analyse, avec numéros de ligne ancien et nouveau. */
+export declare function getDiff(store: AnalysisStore, args: Args): ToolResult;

package/dist/src/tools/get-diff.js

@@ -0,0 +1,67 @@
+import { AnalysisError } from "../core/errors.js";
+import { fileLine, snapshotLabel } from "./format.js";
+import { optionalString, rejectUnknownFields, requireString, textResult } from "./types.js";
+const MARKERS = { context: " ", add: "+", del: "-" };
+/** Lignes d'un fichier : en-tête, marqueurs binaire / contenu indisponible, puis hunks numérotés `ancien | nouveau`. */
+function renderFile(entry, diff) {
+    const out = [`=== ${fileLine(entry)}${entry.reviewed ? "  (reviewed)" : ""}`];
+    if (entry.binary) {
+        out.push("[binary file: no line-level diff, findings cannot be anchored on its lines]");
+        return out;
+    }
+    if (entry.status === "deleted") {
+        out.push("[deleted file: no new side, findings cannot be anchored on its lines]");
+    }
+    else if (!entry.contentAvailable) {
+        out.push("[new-side content not kept (file too large): findings cannot be anchored on its lines]");
+    }
+    if (diff.hunks.length === 0) {
+        out.push(entry.status === "renamed" ? "[renamed without content changes]" : "[no textual changes]");
+        return out;
+    }
+    let width = 1;
+    for (const hunk of diff.hunks) {
+        for (const line of hunk.lines) {
+            width = Math.max(width, String(line.oldNo ?? "").length, String(line.newNo ?? "").length);
+        }
+    }
+    const column = (value) => String(value ?? "").padStart(width);
+    for (const hunk of diff.hunks) {
+        out.push(hunk.header);
+        for (const line of hunk.lines) {
+            out.push(`${column(line.oldNo)} | ${column(line.newNo)} ${MARKERS[line.type]} ${line.text}`);
+        }
+    }
+    return out;
+}
+/** Diff figé d'un fichier ou de tous les fichiers de l'analyse, avec numéros de ligne ancien et nouveau. */
+export function getDiff(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "path"]);
+    const analysis = store.get(requireString(args, "analysis_id"));
+    const path = optionalString(args, "path");
+    const snapshot = store.getSnapshot(analysis.id);
+    let entries = analysis.files;
+    if (path !== undefined) {
+        const entry = analysis.files.find((file) => file.path === path);
+        if (!entry) {
+            const known = analysis.files.map((file) => file.path).join(", ") || "none";
+            throw new AnalysisError(`File "${path}" is not part of analysis "${analysis.id}". Changed files: ${known}.`);
+        }
+        entries = [entry];
+    }
+    const lines = [
+        `Frozen diff of "${analysis.title}" (${analysis.id}): ${snapshotLabel(analysis)}.`,
+        "Columns: old line | new line, then + (added), - (removed) or a space (context). " +
+            "Anchor findings on the NEW-side numbers (second column).",
+    ];
+    if (entries.length === 0)
+        lines.push("", "The analysis has no changed files.");
+    for (const entry of entries) {
+        const diff = snapshot.files.find((file) => file.path === entry.path);
+        if (!diff) {
+            throw new AnalysisError(`The diff snapshot of analysis "${analysis.id}" has no entry for "${entry.path}". Recompute it with refresh_analysis.`);
+        }
+        lines.push("", ...renderFile(entry, diff));
+    }
+    return textResult(lines.join("\n"));
+}

package/dist/src/tools/get-review-feedback.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type ToolResult } from "./types.js";
+/** Retour du relecteur : décision, points retenus et prompt ; sinon l'avancement de la revue. Lecture seule. */
+export declare function getReviewFeedback(store: AnalysisStore, args: Args): ToolResult;

package/dist/src/tools/get-review-feedback.js

@@ -0,0 +1,71 @@
+import { reviewProgress } from "../../shared/review-state.js";
+import { sortBySeverity } from "../../shared/severity.js";
+import { findingLine, indentBlock, noteLocationLabel, overviewLines, progressLabel } from "./format.js";
+import { rejectUnknownFields, requireString, textResult } from "./types.js";
+function findingDetails(finding) {
+    const lines = [`- ${findingLine(finding)}`];
+    if (finding.body.trim() !== "")
+        lines.push(indentBlock(finding.body, "    "));
+    if (finding.suggestion !== null)
+        lines.push("    Proposed replacement:", indentBlock(finding.suggestion, "      "));
+    return lines;
+}
+function noteDetails(note) {
+    return `- ${note.id} — ${noteLocationLabel(note)}\n${indentBlock(note.text, "    ")}`;
+}
+/** Avancement d'une revue non soumise. */
+function progressLines(analysis) {
+    const progress = reviewProgress(analysis);
+    const ignored = analysis.findings.filter((finding) => finding.status === "ignored").length;
+    return [
+        `The review of "${analysis.title}" (${analysis.id}, project "${analysis.project}") is not submitted yet.`,
+        `Review state: ${progressLabel(progress)}.`,
+        `Progress: ${progress.reviewedFiles}/${progress.totalFiles} file(s) reviewed, ${ignored}/${analysis.findings.length} finding(s) ignored, ` +
+            `${analysis.notes.length} reviewer note(s).`,
+        "",
+        ...overviewLines(analysis.overview),
+        "",
+        "Ask the user to finish the review in the GUI and save the feedback, then call get_review_feedback again.",
+    ];
+}
+/** Retour du relecteur : décision, points retenus et prompt ; sinon l'avancement de la revue. Lecture seule. */
+export function getReviewFeedback(store, args) {
+    rejectUnknownFields(args, ["analysis_id"]);
+    const analysis = store.get(requireString(args, "analysis_id"));
+    const review = analysis.review;
+    if (review.state !== "submitted")
+        return textResult(progressLines(analysis).join("\n"));
+    const selectedFindings = new Set(review.selectedFindingIds);
+    const selectedNotes = new Set(review.selectedNoteIds);
+    const findings = sortBySeverity(analysis.findings.filter((finding) => selectedFindings.has(finding.id)));
+    const notes = analysis.notes.filter((note) => selectedNotes.has(note.id));
+    const lines = [
+        `Review of "${analysis.title}" (${analysis.id}, project "${analysis.project}") submitted at ${review.submittedAt}.`,
+        `Decision: ${review.decision}`,
+        "",
+        ...overviewLines(analysis.overview),
+        "",
+        `Selected findings (${findings.length}):`,
+    ];
+    lines.push(...(findings.length === 0 ? ["  none"] : findings.flatMap(findingDetails)), "");
+    lines.push(`Selected reviewer notes (${notes.length}):`);
+    lines.push(...(notes.length === 0 ? ["  none"] : notes.map(noteDetails)), "");
+    if (review.prompt === null) {
+        lines.push("Prompt: none was recorded with this submission.");
+    }
+    else {
+        lines.push("Prompt from the reviewer (verbatim):", "-----", review.prompt, "-----");
+    }
+    lines.push("");
+    if (review.decision === "reject") {
+        lines.push("Next steps: the reviewer rejected the feature. Ask the user how to proceed before changing the code.");
+    }
+    else if (review.decision === "approve" && findings.length === 0 && notes.length === 0) {
+        lines.push("Next steps: the reviewer approved the feature with no points to address.");
+    }
+    else {
+        lines.push("Next steps: address the points above in the repository, then call refresh_analysis to recompute the diff " +
+            "(it discards this feedback and starts a new review round).");
+    }
+    return textResult(lines.join("\n"));
+}

package/dist/src/tools/inputs.d.ts

@@ -0,0 +1,14 @@
+import { type Args } from "./types.js";
+/** Emplacement demandé par l'agent : `null` pour retirer l'emplacement, `undefined` s'il n'en donne pas. */
+export type LocationInput = {
+    path: string;
+    startLine: number;
+    endLine: number | undefined;
+} | null | undefined;
+/**
+ * Lit `path`, `start_line` et `end_line`. `path` et `start_line` vont ensemble ;
+ * `end_line` vaut `start_line` quand il est omis. `path: null` retire l'emplacement.
+ */
+export declare function readLocation(args: Args, prefix?: string): LocationInput;
+/** Lit un identifiant d'élément facultatif fourni par l'agent. */
+export declare function readItemId(args: Args, field: string, prefix?: string): string | undefined;