@imenam/mcp-feature-analyzer 1.0.0

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

@@ -0,0 +1,121 @@
+import { has, nullableString, optionalString, rejectUnknownFields, requireString, requireStringArray, textResult, } from "./types.js";
+const EDITABLE = [
+    "title",
+    "project",
+    "summary",
+    "objective",
+    "approach",
+    "attention_points",
+    "request_text",
+    "request_source",
+];
+/**
+ * Lit `objective`, `approach` et `attention_points`. `objective: null` retire
+ * toute la vue d'ensemble et exclut les deux autres champs.
+ */
+function readOverview(args) {
+    const objective = nullableString(args, "objective");
+    const approach = optionalString(args, "approach");
+    const attentionPoints = has(args, "attention_points") ? requireStringArray(args, "attention_points") : undefined;
+    if (objective === null) {
+        if (approach !== undefined || attentionPoints !== undefined) {
+            throw new Error(`"objective" is null (overview removed), so "approach" and "attention_points" cannot be set.`);
+        }
+        return { remove: true };
+    }
+    if (objective === undefined && approach === undefined && attentionPoints === undefined)
+        return undefined;
+    return { remove: false, objective, approach, attentionPoints };
+}
+/**
+ * Applique la modification de la vue d'ensemble : sans vue d'ensemble existante,
+ * `objective` et `approach` sont requis pour la créer ; sinon chaque champ donné
+ * remplace le précédent et les autres sont conservés.
+ */
+function nextOverview(id, current, input) {
+    if (input.remove)
+        return null;
+    if (current === null) {
+        const missing = ["objective", "approach"].filter((field) => input[field] === undefined);
+        if (missing.length > 0) {
+            throw new Error(`Analysis "${id}" has no overview yet: give ${missing.map((field) => `"${field}"`).join(" and ")} too ` +
+                `to create it ("attention_points" is optional and defaults to an empty list).`);
+        }
+        return { objective: input.objective, approach: input.approach, attentionPoints: input.attentionPoints ?? [] };
+    }
+    return {
+        objective: input.objective ?? current.objective,
+        approach: input.approach ?? current.approach,
+        attentionPoints: input.attentionPoints ?? current.attentionPoints,
+    };
+}
+/** Met à jour le titre, le projet, la vue d'ensemble, le résumé et la demande initiale d'une analyse. */
+export function updateAnalysis(store, args) {
+    rejectUnknownFields(args, ["analysis_id", ...EDITABLE]);
+    const id = requireString(args, "analysis_id");
+    const given = EDITABLE.filter((field) => has(args, field));
+    if (given.length === 0) {
+        throw new Error(`Give at least one field to change: ${EDITABLE.join(", ")}.`);
+    }
+    const title = optionalString(args, "title");
+    const project = optionalString(args, "project");
+    const summary = has(args, "summary") ? requireStringArray(args, "summary") : undefined;
+    const overview = readOverview(args);
+    const requestText = nullableString(args, "request_text");
+    const requestSource = nullableString(args, "request_source");
+    if (requestText === null && typeof requestSource === "string") {
+        throw new Error(`"request_text" is null (request removed), so "request_source" cannot be set.`);
+    }
+    let previousProject = "";
+    const analysis = store.mutate(id, "agent", (draft) => {
+        previousProject = draft.project;
+        if (title !== undefined)
+            draft.title = title;
+        if (project !== undefined)
+            draft.project = project;
+        if (summary !== undefined)
+            draft.summary = summary;
+        if (overview !== undefined)
+            draft.overview = nextOverview(id, draft.overview, overview);
+        if (requestText === null) {
+            draft.request = null;
+        }
+        else if (requestText !== undefined) {
+            draft.request = { text: requestText, source: requestSource !== undefined ? requestSource : (draft.request?.source ?? null) };
+        }
+        else if (requestSource !== undefined) {
+            if (draft.request === null) {
+                throw new Error(`Analysis "${id}" has no initial request to attach a source to: give "request_text" too.`);
+            }
+            draft.request = { ...draft.request, source: requestSource };
+        }
+    });
+    const changes = [];
+    if (title !== undefined)
+        changes.push(`title "${analysis.title}"`);
+    if (project !== undefined) {
+        changes.push(project === previousProject ? `project "${project}" (unchanged)` : `project "${previousProject}" -> "${project}"`);
+    }
+    if (summary !== undefined)
+        changes.push(`summary (${analysis.summary.length} bullet(s))`);
+    if (overview !== undefined) {
+        changes.push(analysis.overview === null
+            ? "overview removed"
+            : `overview (${analysis.overview.attentionPoints.length} attention point(s))`);
+    }
+    if (requestText !== undefined || requestSource !== undefined) {
+        changes.push(analysis.request === null ? "initial request removed" : "initial request");
+    }
+    const missing = [];
+    if (analysis.overview === null)
+        missing.push("the overview (objective, approach, attention_points)");
+    if (analysis.summary.length === 0)
+        missing.push("the summary");
+    const next = missing.length > 0
+        ? `Next: write ${missing.join(" and ")} with update_analysis, then record problems and missing requirements with add_findings.`
+        : `Next: record problems and missing requirements with add_findings.`;
+    return {
+        result: textResult(`Updated analysis ${analysis.id}: ${changes.join(", ")}. Revision ${analysis.revision}.\n${next}`),
+        analysisId: analysis.id,
+    };
+}

package/dist/src/tools/update-finding.d.ts

@@ -0,0 +1,8 @@
+import type { AnalysisStore } from "../core/analysis-store.js";
+import { type Args, type MutationResult } from "./types.js";
+/**
+ * Modifie les champs de l'agent d'un constat. Un nouvel emplacement est résolu
+ * sur le snapshot ; un nouvel emplacement ou son retrait rouvre un constat
+ * `outdated`. Le statut `ignored` relève du relecteur et n'est pas modifié.
+ */
+export declare function updateFinding(store: AnalysisStore, args: Args): MutationResult;

package/dist/src/tools/update-finding.js

@@ -0,0 +1,91 @@
+import { AnalysisError } from "../core/errors.js";
+import { resolveLocation } from "../core/locations.js";
+import { FINDING_KINDS, SEVERITIES } from "../../shared/schemas/analysis.schema.js";
+import { findingLine } from "./format.js";
+import { readLocation } from "./inputs.js";
+import { has, nullableText, optionalEnum, optionalString, rejectUnknownFields, requireString, requireText, textResult, } from "./types.js";
+const EDITABLE = ["severity", "kind", "title", "body", "path", "start_line", "end_line", "suggestion", "prompt"];
+/**
+ * Modifie les champs de l'agent d'un constat. Un nouvel emplacement est résolu
+ * sur le snapshot ; un nouvel emplacement ou son retrait rouvre un constat
+ * `outdated`. Le statut `ignored` relève du relecteur et n'est pas modifié.
+ */
+export function updateFinding(store, args) {
+    rejectUnknownFields(args, ["analysis_id", "finding_id", ...EDITABLE]);
+    const id = requireString(args, "analysis_id");
+    const findingId = requireString(args, "finding_id");
+    const given = EDITABLE.filter((field) => has(args, field));
+    if (given.length === 0) {
+        throw new Error(`Give at least one field to change: ${EDITABLE.join(", ")}.`);
+    }
+    const severity = optionalEnum(args, "severity", SEVERITIES);
+    const kind = optionalEnum(args, "kind", FINDING_KINDS);
+    const title = optionalString(args, "title");
+    const body = has(args, "body") ? requireText(args, "body") : undefined;
+    const suggestion = nullableText(args, "suggestion", "", true);
+    const prompt = nullableText(args, "prompt");
+    const location = readLocation(args);
+    const analysis = store.get(id);
+    const current = analysis.findings.find((finding) => finding.id === findingId);
+    if (!current) {
+        const known = analysis.findings.map((finding) => finding.id).join(", ") || "none";
+        throw new AnalysisError(`Finding "${findingId}" not found in analysis "${id}". Existing findings: ${known}.`);
+    }
+    const nextKind = kind ?? current.kind;
+    const nextHasLocation = location === undefined ? current.location !== null : location !== null;
+    const nextSuggestion = suggestion === undefined ? current.suggestion : suggestion;
+    if (!nextHasLocation && nextKind === "issue") {
+        throw new AnalysisError(`Finding "${findingId}" would be an issue without location; only requirement_gap findings may have none. Give "path" and "start_line", or set kind to requirement_gap.`);
+    }
+    if (!nextHasLocation && nextSuggestion !== null) {
+        throw new AnalysisError(`Finding "${findingId}" would have a suggestion but no location to replace. Clear it with "suggestion": null, or keep a location.`);
+    }
+    let resolved = null;
+    if (location)
+        resolved = resolveLocation(store.getSnapshot(id), analysis.files, location);
+    const previousStatus = current.status;
+    const updated = store.mutate(id, "agent", (draft) => {
+        if (draft.snapshotAt !== analysis.snapshotAt) {
+            throw new AnalysisError(`The diff of analysis "${id}" was recomputed while the finding was validated. Send the update again.`);
+        }
+        const finding = draft.findings.find((entry) => entry.id === findingId);
+        if (!finding)
+            throw new AnalysisError(`Finding "${findingId}" was deleted in the meantime from analysis "${id}".`);
+        if (severity !== undefined)
+            finding.severity = severity;
+        if (kind !== undefined)
+            finding.kind = kind;
+        if (title !== undefined)
+            finding.title = title;
+        if (body !== undefined)
+            finding.body = body;
+        if (suggestion !== undefined)
+            finding.suggestion = suggestion;
+        if (prompt !== undefined)
+            finding.prompt = prompt;
+        if (location === null) {
+            finding.location = null;
+            finding.anchorText = null;
+        }
+        else if (resolved) {
+            finding.location = { path: resolved.path, startLine: resolved.startLine, endLine: resolved.endLine };
+            finding.anchorText = resolved.anchorText;
+        }
+        if (location !== undefined && finding.status === "outdated")
+            finding.status = "open";
+    });
+    const finding = updated.findings.find((entry) => entry.id === findingId);
+    const lines = [`Updated finding ${findingId} (${given.join(", ")}):`, `  ${findingLine(finding)}`];
+    if (previousStatus === "outdated" && finding.status === "open") {
+        lines.push(location === null
+            ? "It was outdated; removing its location reopened it."
+            : "It was outdated; the new location reopened it.");
+    }
+    else if (finding.status === "outdated") {
+        lines.push("It is still outdated: give a new location (path and start_line, from get_diff) to reopen it, or delete it with delete_findings if it is solved.");
+    }
+    else if (finding.status === "ignored") {
+        lines.push("It stays ignored: only the reviewer can reopen it in the GUI.");
+    }
+    return { result: textResult(lines.join("\n")), analysisId: updated.id };
+}

package/dist/src/version.d.ts

@@ -0,0 +1 @@
+export declare const APP_VERSION = "1.0.0";

package/dist/src/version.js

@@ -0,0 +1,2 @@
+// Auto-generated version file - do not edit manually
+export const APP_VERSION = '1.0.0';