@ogygie/core 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Ogygie framework core: manifest/spec/error schemas, generic tenancy and gate tooling. Ships TypeScript sources — Ogygie products run tsx/vitest by construction (D1).",
   "license": "MIT",
   "type": "module",
@@ -20,6 +20,8 @@
     "./web-lint": "./src/web-lint.ts",
     "./bundle-budget": "./src/bundle-budget.ts",
     "./spec": "./src/spec.schema.ts",
+    "./impact": "./src/impact.ts",
+    "./repo-adapter": "./src/repo-adapter.ts",
     "./decision-refs": "./src/decision-refs.ts",
     "./design-brief": "./src/design-brief.ts",
     "./module-purity": "./src/module-purity.ts",

package/src/decision-refs.test.ts

@@ -7,6 +7,7 @@
  */
 import { describe, expect, it } from "vitest";
 import {
+  extractDecisionSection,
   findDecisionReferences,
   findDuplicateDecisionIds,
   findUnknownDecisionReferences,
@@ -112,3 +113,33 @@ describe("gate SPEC_UNKNOWN_DECISION_REFERENCE", () => {
     ]);
   });
 });
+
+describe("extraction d'UNE décision (spec ogygie-mcp)", () => {
+  it("ÉTANT DONNÉ une décision déclarée QUAND on l'extrait ALORS on reçoit sa section, titre compris", () => {
+    expect(extractDecisionSection(DECISIONS, "D11")).toBe(
+      [
+        "## D11 — 2026-07-30 — Anglais maximal dans le code",
+        "- **Décision** : les identifiants sont en anglais (voir aussi D99, jamais prise).",
+      ].join("\n"),
+    );
+  });
+
+  it("la DERNIÈRE décision du fichier va jusqu'à la fin, sans ligne vide traînante", () => {
+    expect(extractDecisionSection(`${DECISIONS}\n\n`, "D26")).toBe(
+      [
+        "## D26 — 2026-08 — Nomenclature partagée : codes normalisés",
+        "- **Décision** : le catalogue global s'appuie sur des codes normalisés.",
+      ].join("\n"),
+    );
+  });
+
+  it("MUTATION : une décision seulement CITÉE dans le corps d'une autre ne s'extrait pas", () => {
+    // D99 is mentioned inside D11. Cutting on a citation instead of a heading
+    // would serve half of D11 as if it were a decision of its own.
+    expect(extractDecisionSection(DECISIONS, "D99")).toBeNull();
+  });
+
+  it("MUTATION : un préfixe ne fait pas une décision — D1 n'est pas D11", () => {
+    expect(extractDecisionSection(DECISIONS, "D1")).toBeNull();
+  });
+});

package/src/decision-refs.ts

@@ -69,6 +69,39 @@ export function findDuplicateDecisionIds(
   return duplicated;
 }
 
+/**
+ * The section of ONE decision — its declaring heading and everything up to the
+ * next one — or null when no decisions file declares it.
+ *
+ * Serving a whole decisions file to answer a question about one decision is
+ * how a reader's context fills with rules nobody asked about (spec ogygie-mcp,
+ * `ogygie_read_decisions`). The cut is made on the DECLARING heading, the very
+ * one `parseKnownDecisionIds` counts, so what can be cited and what can be
+ * served never drift apart.
+ */
+export function extractDecisionSection(
+  decisionsMarkdown: string,
+  decisionId: string,
+): string | null {
+  const lines = decisionsMarkdown.split("\n");
+  const trimTrailingBlanks = (section: string[]): string => {
+    while (section.length > 0 && (section[section.length - 1] ?? "").trim() === "") section.pop();
+    return section.join("\n");
+  };
+  let start = -1;
+  for (let index = 0; index < lines.length; index += 1) {
+    const heading = DECISION_HEADING.exec(lines[index] ?? "");
+    if (heading === null) continue;
+    if (start === -1) {
+      if (`D${heading[1]}` === decisionId) start = index;
+      continue;
+    }
+    // The next declaration ends the one being cut.
+    return trimTrailingBlanks(lines.slice(start, index));
+  }
+  return start === -1 ? null : trimTrailingBlanks(lines.slice(start));
+}
+
 /** Every decision citation found in a text (frontmatter included), in order. */
 export function findDecisionReferences(text: string): DecisionReference[] {
   const references: DecisionReference[] = [];

package/src/impact.test.ts

@@ -0,0 +1,251 @@
+/**
+ * @intent Proves specs/impact-analyzer-core.spec.md on an in-memory repo — the
+ * tests the script NEVER had, though it is the first command of the evolution
+ * protocol.
+ *
+ * Two families here. The four findings it already produced, each with the
+ * mutation that would silence it. And the four blind spots it had, each with
+ * the case that fails against yesterday's version: a dependent under another
+ * app, a dependent that is a package, an import by package specifier, and a
+ * report that does not say what it looked at (D12).
+ */
+import { describe, expect, it } from "vitest";
+import { OgygieFailure } from "./error.schema.js";
+import { analyzeImpact, type ImpactReport } from "./impact.js";
+import { OgygieManifestSchema } from "./manifest.schema.js";
+import { createInMemoryRepoAdapter } from "./repo-adapter.js";
+
+const MANIFEST = {
+  version: 1,
+  product: { name: "acme", description: "SaaS générique servant de fixture aux tests d'impact." },
+  apps: [
+    { name: "api", path: "apps/api", type: "api", entryPoint: "apps/api/src/server.ts" },
+    { name: "web", path: "apps/web", type: "front", entryPoint: "apps/web/src/main.tsx" },
+  ],
+  features: [
+    {
+      name: "orders",
+      intent: "Feature cible : elle possède la table orders et expose une route.",
+      folder: "src/features/orders",
+      spec: "specs/orders.spec.md",
+      routes: [
+        { method: "POST", path: "/api/orders", description: "Crée une commande.", schemaInput: "CreateOrderInputSchema", schemaOutput: "CreateOrderOutputSchema" },
+      ],
+      dbTables: ["orders"],
+      dependsOn: [],
+      status: "delivered",
+    },
+    {
+      name: "invoices",
+      intent: "Feature d'API dépendante : elle importe orders par son index.",
+      folder: "src/features/invoices",
+      spec: "specs/invoices.spec.md",
+      routes: [],
+      dbTables: [],
+      dependsOn: ["orders"],
+      status: "delivered",
+    },
+    {
+      name: "orders-screen",
+      intent: "Feature FRONT : elle importe le contrat d'orders par specifier de package.",
+      app: "web",
+      folder: "src/features/orders-screen",
+      spec: "specs/orders-screen.spec.md",
+      routes: [],
+      dbTables: [],
+      dependsOn: ["orders"],
+      status: "delivered",
+    },
+  ],
+  conventions: { agentsMd: "AGENTS.md", failuresMd: "FAILURES.md", specsFolder: "specs/" },
+};
+
+const FILES: Record<string, string> = {
+  "apps/api/src/features/orders/index.ts": "export { createOrder } from './service.js';\n",
+  "apps/api/src/features/orders/service.ts": "export function createOrder() { return 1; }\n",
+  "apps/api/src/features/invoices/service.ts":
+    'import { createOrder } from "../orders/index.js";\nexport const a = createOrder;\n',
+  "apps/web/src/features/orders-screen/queries.ts":
+    'import { ListOrdersOutputSchema } from "@acme/api/features/orders/schemas";\nexport const s = ListOrdersOutputSchema;\n',
+};
+
+function manifestOf(overrides: Record<string, unknown> = {}) {
+  return OgygieManifestSchema.parse({ ...MANIFEST, ...overrides });
+}
+
+async function analyze(
+  files: Record<string, string> = FILES,
+  target = "orders",
+  manifest = manifestOf(),
+): Promise<ImpactReport> {
+  return analyzeImpact({ manifest, adapter: createInMemoryRepoAdapter(files) }, target);
+}
+
+const codesOf = (report: ImpactReport): string[] =>
+  report.findings.map((finding) => finding.code).sort();
+
+describe("B2/B3 — les angles morts d'hier", () => {
+  it("ÉTANT DONNÉ une feature FRONT qui importe le contrat d'une feature d'API ALORS elle est un dépendant", async () => {
+    // Yesterday's version joined every folder to the api app AND only knew
+    // relative imports: this dependent was invisible twice.
+    const report = await analyze();
+    expect(report.dependents.map((dependent) => dependent.name).sort()).toEqual([
+      "invoices",
+      "orders-screen",
+    ]);
+  });
+
+  it("les symboles importés remontent, quelle que soit la forme de l'import", async () => {
+    const report = await analyze();
+    const front = report.dependents.find((dependent) => dependent.name === "orders-screen");
+    expect(front?.importedSymbols).toEqual(["ListOrdersOutputSchema"]);
+  });
+
+  it("ÉTANT DONNÉ un repo SANS app de type api ALORS l'analyse tourne quand même", async () => {
+    // The version of yesterday threw "no app of type api in the manifest" and
+    // analysed nothing at all.
+    const manifest = manifestOf({
+      apps: [{ name: "web", path: "apps/web", type: "front", entryPoint: "apps/web/src/main.tsx" }],
+      features: [MANIFEST.features[2]],
+    });
+    const report = await analyze(FILES, "orders-screen", manifest);
+    expect(report.target.folder).toBe("apps/web/src/features/orders-screen");
+  });
+
+  it("un PACKAGE est une cible comme une autre, et ses dépendants se voient", async () => {
+    const manifest = manifestOf({
+      packages: [
+        {
+          name: "solver",
+          path: "packages/solver",
+          intent: "Package produit servant de fixture : importé par une feature d'API.",
+          spec: "specs/solver.spec.md",
+          dependsOn: [],
+          status: "delivered",
+        },
+      ],
+    });
+    const files = {
+      ...FILES,
+      "packages/solver/index.ts": "export const solve = () => 1;\n",
+      "apps/api/src/features/orders/service.ts":
+        'import { solve } from "solver";\nexport function createOrder() { return solve(); }\n',
+    };
+    const report = await analyze(files, "solver", manifest);
+    expect(report.dependents.map((dependent) => dependent.name)).toEqual(["orders"]);
+  });
+});
+
+describe("B4 — le rapport dit ce qu'il a regardé (D12)", () => {
+  it("le périmètre nomme les dossiers scannés et les natures couvertes", async () => {
+    const report = await analyze();
+    expect(report.scope.scannedFolders).toContain("apps/web/src/features/orders-screen");
+    expect(report.scope.coveredKinds).toContain("feature");
+  });
+
+  it("MUTATION : un PACKAGE sans dépendant interne dit que ses consommateurs EXTERNES sont hors de portée", async () => {
+    // "Aucun dépendant" tout court est le mensonge que D12 interdit.
+    const manifest = manifestOf({
+      packages: [
+        {
+          name: "solver",
+          path: "packages/solver",
+          intent: "Package produit servant de fixture : personne ne l'importe dans ce dépôt.",
+          spec: "specs/solver.spec.md",
+          dependsOn: [],
+          status: "delivered",
+        },
+      ],
+    });
+    const report = await analyze({ ...FILES, "packages/solver/index.ts": "export const a = 1;\n" }, "solver", manifest);
+    expect(report.dependents).toEqual([]);
+    expect(report.scope.outOfReach.join(" ")).toContain("OUTSIDE this repo");
+  });
+
+  it("une entrée dont la carte ne résout pas le dossier est NOMMÉE, l'analyse continue", async () => {
+    const manifest = manifestOf({
+      apps: [{ name: "web", path: "apps/web", type: "front", entryPoint: "apps/web/src/main.tsx" }],
+    });
+    const report = await analyze(FILES, "orders-screen", manifest);
+    // orders and invoices count on an api app that no longer exists: they are
+    // NAMED, and the analysis still returns a report instead of throwing.
+    expect(report.scope.outOfReach.join(" ")).toContain('"orders"');
+    expect(report.scope.outOfReach.join(" ")).toContain('"invoices"');
+    expect(report.target.folder).toBe("apps/web/src/features/orders-screen");
+  });
+});
+
+describe("B5 — les quatre findings, chacun avec sa mutation", () => {
+  it("aucun finding sur un repo conforme", async () => {
+    expect(await analyze().then(codesOf)).toEqual([]);
+  });
+
+  it("FEATURE_BOUNDARY_VIOLATION : importer un fichier INTERNE au lieu de l'index", async () => {
+    const files = {
+      ...FILES,
+      "apps/api/src/features/invoices/service.ts":
+        'import { createOrder } from "../orders/service.js";\nexport const a = createOrder;\n',
+    };
+    const report = await analyze(files);
+    expect(codesOf(report)).toContain("FEATURE_BOUNDARY_VIOLATION");
+    expect(report.dependents.find((d) => d.name === "invoices")?.viaIndexOnly).toBe(false);
+  });
+
+  it("MANIFEST_DEPENDENCY_STALE : un dependsOn que le code ne justifie plus", async () => {
+    const files = { ...FILES, "apps/api/src/features/invoices/service.ts": "export const a = 1;\n" };
+    expect(codesOf(await analyze(files))).toContain("MANIFEST_DEPENDENCY_STALE");
+  });
+
+  it("MANIFEST_DEPENDENCY_UNDECLARED : un import que le manifeste tait", async () => {
+    const manifest = manifestOf({
+      features: MANIFEST.features.map((feature) =>
+        feature.name === "invoices" ? { ...feature, dependsOn: [] } : feature,
+      ),
+    });
+    expect(codesOf(await analyze(FILES, "orders", manifest))).toContain(
+      "MANIFEST_DEPENDENCY_UNDECLARED",
+    );
+  });
+
+  it("TABLE_REFERENCED_OUTSIDE_OWNER : une table touchée hors de son propriétaire", async () => {
+    const files = {
+      ...FILES,
+      "apps/api/src/features/invoices/repository.ts": 'export const t = "orders";\n',
+    };
+    const report = await analyze(files);
+    expect(codesOf(report)).toContain("TABLE_REFERENCED_OUTSIDE_OWNER");
+    expect(report.tableReadersOutsideOwner[0]?.feature).toBe("invoices");
+  });
+
+  it("MUTATION : la même table dans un TEST ne compte pas — c'est le patron de fixture", async () => {
+    const files = {
+      ...FILES,
+      "apps/api/src/features/invoices/service.test.ts": 'const t = "orders";\nexport default t;\n',
+    };
+    expect(codesOf(await analyze(files))).not.toContain("TABLE_REFERENCED_OUTSIDE_OWNER");
+  });
+});
+
+describe("B5 — la commande de test couvre TOUS les dépendants", () => {
+  it("elle nomme les dossiers réels, de toutes les apps", async () => {
+    const report = await analyze();
+    // Yesterday it prefixed everything with `features/`, so a front dependent
+    // was named by a path that runs nothing.
+    expect(report.testCommand).toContain("apps/api/src/features/orders");
+    expect(report.testCommand).toContain("apps/web/src/features/orders-screen");
+  });
+});
+
+describe("refus", () => {
+  it("MUTATION : une cible inconnue est refusée AVEC la liste de ce que la carte déclare", async () => {
+    try {
+      await analyze(FILES, "jamais-declaree");
+      expect.unreachable("l'analyse aurait dû être refusée");
+    } catch (thrown) {
+      expect(thrown).toBeInstanceOf(OgygieFailure);
+      const failure = thrown as OgygieFailure;
+      expect(failure.error.code).toBe("IMPACT_UNKNOWN_FEATURE");
+      expect(failure.error.suggestedFix).toContain("orders-screen");
+    }
+  });
+});