@ogygie/core 0.11.2 → 0.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.11.2",
+  "version": "0.12.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",

package/src/vocabulary-audit.test.ts

@@ -9,6 +9,7 @@ import { describe, expect, it } from "vitest";
 import {
   auditProductVocabulary,
   canonicalByAlias,
+  derogatedFeatureIdsOf,
   vocabularyRootsOf,
 } from "./vocabulary-audit.js";
 
@@ -198,3 +199,101 @@ describe("dérivations du bloc vocabulary", () => {
     ]);
   });
 });
+
+describe("auditProductVocabulary — B3 : la dérogation des ids de features (D16)", () => {
+  /** The product's features are named `widgets` — the very forbidden alias. */
+  const FEATURE_IDS = ["widgets", "gadget-catalog"];
+
+  it("ÉTANT DONNÉ un id de feature qui EST un alias interdit QUAND le code en dérive ses identifiants ALORS rien n'est signalé", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [
+        {
+          path: "apps/api/src/features/widgets/routes.ts",
+          content: [
+            'import { listWidgets } from "../features/widgets/service.js";',
+            "export function registerWidgetsRoutes() {}",
+          ].join("\n"),
+        },
+      ],
+      governedFiles: [],
+      featureIds: FEATURE_IDS,
+    });
+    expect(violations).toEqual([]);
+  });
+
+  it("MUTATION — sans la dérogation, ces mêmes identifiants dérivés sont TOUS signalés", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [
+        {
+          path: "apps/api/src/features/widgets/routes.ts",
+          content: [
+            'import { listWidgets } from "../features/widgets/service.js";',
+            "export function registerWidgetsRoutes() {}",
+          ].join("\n"),
+        },
+      ],
+      governedFiles: [],
+    });
+    expect(violations.map((violation) => violation.match.identifier).sort()).toEqual([
+      "listWidgets",
+      "registerWidgetsRoutes",
+      "widgets",
+    ]);
+  });
+
+  it("la dérogation couvre la DÉRIVATION, jamais un nom seulement préfixé par la racine", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [
+        { path: "apps/api/src/features/widgets/service.ts", content: "const widgetCode = 1;" },
+      ],
+      governedFiles: [],
+      featureIds: FEATURE_IDS,
+    });
+    // `widgetCode` carries the root but NOT the whole feature id `widgets`.
+    expect(violations).toHaveLength(1);
+    expect(violations[0]?.match.identifier).toBe("widgetCode");
+  });
+
+  it("un id de feature multi-segments couvre ses dérivés, et lui seul", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [
+        {
+          path: "apps/api/src/features/gadget-catalog/service.ts",
+          content: ["const gadgetCatalogRows = [];", "const gadgetCatalogue = [];"].join("\n"),
+        },
+      ],
+      governedFiles: [],
+      featureIds: FEATURE_IDS,
+    });
+    expect(violations.map((violation) => violation.match.identifier)).toEqual([
+      "gadgetCatalogue",
+    ]);
+  });
+
+  it("la dérogation ne touche PAS la règle des fichiers gouvernés (B4)", () => {
+    const violations = auditProductVocabulary({
+      vocabulary: VOCABULARY,
+      sourceFiles: [],
+      governedFiles: [{ path: "AGENTS.md", content: "le gadget du produit" }],
+      featureIds: ["gadget"],
+    });
+    expect(violations).toHaveLength(1);
+    expect(violations[0]?.kind).toBe("GOVERNED_FILE");
+  });
+});
+
+describe("derogatedFeatureIdsOf — ce que la dérogation excuse VRAIMENT", () => {
+  it("ne retient que les ids de features qui portent un alias interdit", () => {
+    expect(
+      derogatedFeatureIdsOf(VOCABULARY, ["widgets", "invoices", "gadget-catalog"]),
+    ).toEqual(["widgets", "gadget-catalog"]);
+  });
+
+  it("sans vocabulaire déclaré, aucune dérogation à annoncer", () => {
+    expect(derogatedFeatureIdsOf(undefined, ["widgets"])).toEqual([]);
+  });
+});

package/src/vocabulary-audit.ts

@@ -30,6 +30,7 @@ import {
   findProductVocabulary,
   stripComments,
   stripProseStrings,
+  tokenCarriesExactName,
   type VocabularyMatch,
 } from "./vocabulary.js";
 
@@ -61,6 +62,14 @@ export interface VocabularyAuditInput {
   readonly sourceFiles: readonly ScannedFile[];
   /** Framework-governed files as they exist in the project (B4). */
   readonly governedFiles: readonly ScannedFile[];
+  /**
+   * The manifest's feature ids. Identifiers DERIVED from one of them are not
+   * judged against the forbidden aliases (B3 derogation, D16): a feature id
+   * names a document and follows the project's language, while the code
+   * derives its folders, import paths and function names from it. Absent or
+   * empty, nothing is excused.
+   */
+  readonly featureIds?: readonly string[];
 }
 
 /**
@@ -81,6 +90,23 @@ export function canonicalByAlias(vocabulary: ProductVocabulary): ReadonlyMap<str
   return byAlias;
 }
 
+/**
+ * The feature ids the derogation actually covers (D16): those whose own name
+ * carries a forbidden root. A feature id that collides with nothing excuses
+ * nothing, and must NOT be announced — a derogation list padded with harmless
+ * entries is a list nobody reads, which is how a derogation gets forgotten.
+ */
+export function derogatedFeatureIdsOf(
+  vocabulary: ProductVocabulary | undefined,
+  featureIds: readonly string[],
+): readonly string[] {
+  if (vocabulary === undefined || vocabulary.entries.length === 0) return [];
+  const forbiddenAliases = [...canonicalByAlias(vocabulary).keys()];
+  return featureIds.filter(
+    (featureId) => findProductVocabulary(featureId, forbiddenAliases).length > 0,
+  );
+}
+
 export function auditProductVocabulary(
   input: VocabularyAuditInput,
 ): readonly VocabularyViolation[] {
@@ -92,9 +118,14 @@ export function auditProductVocabulary(
   const canonicalTerms = vocabulary.entries.map((entry) => entry.canonical);
   const violations: VocabularyViolation[] = [];
 
+  const featureIds = input.featureIds ?? [];
+  const derivesFromAFeatureId = (identifier: string): boolean =>
+    featureIds.some((featureId) => tokenCarriesExactName(identifier, featureId));
+
   for (const file of input.sourceFiles) {
     const judged = stripProseStrings(stripComments(file.content));
     for (const match of findProductVocabulary(judged, forbiddenAliases)) {
+      if (derivesFromAFeatureId(match.identifier)) continue;
       violations.push({
         kind: "FORBIDDEN_ALIAS",
         filePath: file.path,

package/src/vocabulary.ts

@@ -75,6 +75,30 @@ function tokenCarriesRoot(
   return false;
 }
 
+/**
+ * Does this token carry that whole name as an EXACT run of segments? Unlike
+ * `tokenCarriesRoot`, the last segment must match in full: this serves the
+ * feature-id derogation (D16), where the point is to excuse what DERIVES from
+ * a declared name — `registerOrdersRoutes` for the feature `orders` — and
+ * never a name that merely starts the same way (`orderCode` stays judged).
+ */
+export function tokenCarriesExactName(token: string, name: string): boolean {
+  const tokenSegments = segmentsOfIdentifier(token);
+  const nameSegments = segmentsOfIdentifier(name);
+  if (nameSegments.length === 0) return false;
+  for (let start = 0; start + nameSegments.length <= tokenSegments.length; start += 1) {
+    let allMatch = true;
+    for (let offset = 0; offset < nameSegments.length; offset += 1) {
+      if (tokenSegments[start + offset] !== nameSegments[offset]) {
+        allMatch = false;
+        break;
+      }
+    }
+    if (allMatch) return true;
+  }
+  return false;
+}
+
 /**
  * Every forbidden root the text names, in order of appearance, deduplicated by
  * (root, identifier): one finding per distinct faulty identifier, however many