@ogygie/core 0.13.0 → 0.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/core",
-  "version": "0.13.0",
+  "version": "0.14.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",
@@ -13,28 +13,29 @@
     "access": "public"
   },
   "exports": {
-    "./manifest": "./src/manifest.schema.ts",
-    "./manifest-owners": "./src/manifest-owners.ts",
-    "./vocabulary": "./src/vocabulary.ts",
-    "./vocabulary-audit": "./src/vocabulary-audit.ts",
-    "./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",
+    "./client": "./src/manifest-client.ts",
+    "./client-react": "./src/manifest-client-react.ts",
+    "./clock": "./src/clock.ts",
+    "./contract-purity": "./src/contract-purity.ts",
+    "./db": "./src/db.ts",
     "./decision-refs": "./src/decision-refs.ts",
     "./design-brief": "./src/design-brief.ts",
-    "./module-purity": "./src/module-purity.ts",
-    "./contract-purity": "./src/contract-purity.ts",
     "./errors": "./src/error.schema.ts",
-    "./db": "./src/db.ts",
-    "./clock": "./src/clock.ts",
-    "./tenant": "./src/tenant.ts",
+    "./gateway": "./src/manifest-gateway.ts",
+    "./impact": "./src/impact.ts",
+    "./manifest": "./src/manifest.schema.ts",
+    "./manifest-owners": "./src/manifest-owners.ts",
+    "./module-purity": "./src/module-purity.ts",
+    "./repo-adapter": "./src/repo-adapter.ts",
+    "./scan": "./src/scan.ts",
     "./shared-tables": "./src/shared-tables.ts",
+    "./spec": "./src/spec.schema.ts",
+    "./tenant": "./src/tenant.ts",
     "./test-kit": "./src/test-kit.ts",
-    "./gateway": "./src/manifest-gateway.ts",
-    "./client": "./src/manifest-client.ts",
-    "./client-react": "./src/manifest-client-react.ts"
+    "./vocabulary": "./src/vocabulary.ts",
+    "./vocabulary-audit": "./src/vocabulary-audit.ts",
+    "./web-lint": "./src/web-lint.ts"
   },
   "peerDependencies": {
     "@electric-sql/pglite": "^0.3.0",

package/src/manifest-owners.test.ts

@@ -5,7 +5,8 @@
  * confirm, and that neither shadows the other.
  */
 import { describe, expect, it } from "vitest";
-import { declaredEntries, findSpecOwner } from "./manifest-owners.js";
+import { declaredEntries, findSpecOwner, hasImplementation } from "./manifest-owners.js";
+import type { SpecOwner, SpecOwnerKind } from "./manifest-owners.js";
 import { OgygieManifestSchema } from "./manifest.schema.js";
 
 function manifestWith(extra: Record<string, unknown>) {
@@ -250,3 +251,30 @@ describe("declaredEntries — tout ce que la carte déclare, à un seul endroit"
     expect(declaredEntries(withApps({}))).toEqual([]);
   });
 });
+
+describe("hasImplementation — ce qui prouve qu'une spec draft a déjà du code", () => {
+  const owner = (
+    kind: SpecOwnerKind,
+    status: "skeleton" | "in-progress" | "delivered",
+  ): SpecOwner => ({ kind, name: "peu-importe", status, folder: "un/chemin" });
+
+  it("ÉTANT DONNÉ un statut au-delà de skeleton ALORS l'implémentation existe, dossier ou pas", () => {
+    for (const kind of ["feature", "package", "framework-package"] as SpecOwnerKind[]) {
+      expect(hasImplementation(owner(kind, "in-progress"), false)).toBe(true);
+      expect(hasImplementation(owner(kind, "delivered"), false)).toBe(true);
+    }
+  });
+
+  it("une FEATURE skeleton dont le dossier existe a bien du code — c'est la preuve historique", () => {
+    expect(hasImplementation(owner("feature", "skeleton"), true)).toBe(true);
+    expect(hasImplementation(owner("feature", "skeleton"), false)).toBe(false);
+  });
+
+  it("MUTATION : un PACKAGE skeleton dont le dossier existe n'a PAS de code — le manifeste EXIGE ce dossier", () => {
+    // Sans cette règle, une spec draft et un package skeleton ne peuvent pas
+    // coexister : verify-manifest réclame le dossier, verify-specs y lit du
+    // code, et le projet est coincé entre deux fichiers gouvernés.
+    expect(hasImplementation(owner("package", "skeleton"), true)).toBe(false);
+    expect(hasImplementation(owner("framework-package", "skeleton"), true)).toBe(false);
+  });
+});

package/src/manifest-owners.ts

@@ -158,6 +158,28 @@ export function findSpecOwner(
   return { kind: owner.kind, name: owner.name, status: owner.status, folder: owner.folder };
 }
 
+/**
+ * Does an implementation of this spec exist? The question the `draft` rule of
+ * the spec lifecycle rests on ("draft = no code yet").
+ *
+ * A declared status above `skeleton` always answers yes. A FOLDER on disk only
+ * answers yes for a FEATURE, whose folder is born with its code and is
+ * therefore evidence of it. A package's folder is NOT evidence: the manifest
+ * gate REQUIRES it to exist (MANIFEST_PACKAGE_NOT_FOUND), so a package
+ * declared `skeleton` whose spec is still `draft` could satisfy neither gate —
+ * one demands the folder, the other reads it as code, and the project is stuck
+ * between two governed files it may not edit. Observed on a consumer project
+ * the day it declared its first package before writing it.
+ *
+ * Lives here rather than in the gate script for the reason the whole module
+ * exists: the rule travels with the versioned package, not with a copy each
+ * project keeps.
+ */
+export function hasImplementation(owner: SpecOwner, folderExists: boolean): boolean {
+  if (owner.status !== "skeleton") return true;
+  return owner.kind === "feature" && folderExists;
+}
+
 /** What a refusal should suggest — both natures, never one that cannot exist. */
 export const SPEC_OWNER_FIX =
   "Set the owning entry to delivered in the manifest — a feature under `features`, a library under `packages`, or a published package under `framework.packages` (which names its spec explicitly) — or keep the spec in validated.";

package/src/scan.test.ts

@@ -0,0 +1,31 @@
+/**
+ * @intent Prouve la règle de parcours des gates, avec le cas qui l'a imposée :
+ * un projet Nuxt dont `typecheck` génère `.nuxt/` que `lint` refusait ensuite.
+ */
+import { describe, expect, it } from "vitest";
+import { isScannableDirectory, NEVER_SCANNED_DIRECTORIES } from "./scan.js";
+
+describe("isScannableDirectory", () => {
+  it("parcourt le code du projet", () => {
+    for (const name of ["apps", "packages", "src", "scripts", "features", "specs"]) {
+      expect(isScannableDirectory(name)).toBe(true);
+    }
+  });
+
+  it("ne parcourt AUCUN dossier en point — c'est la règle qui ne vieillit pas", () => {
+    for (const name of [".git", ".nuxt", ".output", ".next", ".svelte-kit", ".turbo", ".venv"]) {
+      expect(isScannableDirectory(name)).toBe(false);
+    }
+  });
+
+  it("ne parcourt pas les artefacts au nom ordinaire", () => {
+    for (const name of NEVER_SCANNED_DIRECTORIES) expect(isScannableDirectory(name)).toBe(false);
+  });
+
+  it("MUTATION : un dossier dont le nom COMMENCE par celui d'un artefact reste parcouru", () => {
+    // `distribution/` n'est pas `dist/`, et `buildings/` n'est pas `build/`.
+    expect(isScannableDirectory("distribution")).toBe(true);
+    expect(isScannableDirectory("buildings")).toBe(true);
+    expect(isScannableDirectory("node_modules_backup")).toBe(true);
+  });
+});

package/src/scan.ts

@@ -0,0 +1,35 @@
+/**
+ * @intent Which directories a gate WALKS — the one rule, for every gate.
+ *
+ * It existed five times, slightly differently, in as many scripts. That is how
+ * it fell behind: the lists were written when a build produced `dist/`, and a
+ * modern framework generates `.nuxt/`, `.output/`, `.next/`, `.svelte-kit/`,
+ * while a Python package carries `.venv/`. A gate that walks into them reports
+ * bans and forbidden words found in code NOBODY WROTE — and worse, it does so
+ * only after a build, so the loop passes in CI and fails on the machine of
+ * whoever just ran it. A consumer project hit exactly that: `typecheck`
+ * generated `.nuxt/`, and `lint` then refused a type-suppression directive the
+ * framework had written into its own generated types.
+ *
+ * The rule is deliberately blunt, because a subtle one would fall behind again:
+ * a DOT-directory is never source. Everything a project actually writes lives
+ * in a plainly-named folder; tooling, caches, virtual environments and build
+ * output all hide behind a dot, by a convention older than any of these tools.
+ */
+
+/** Plainly-named directories that are still artefacts, not source. */
+export const NEVER_SCANNED_DIRECTORIES = [
+  "node_modules",
+  "dist",
+  "dist-ui",
+  "build",
+  "coverage",
+] as const;
+
+/** Does a gate walk into this directory? Its NAME is the whole question. */
+export function isScannableDirectory(name: string): boolean {
+  // `.git`, `.nuxt`, `.output`, `.next`, `.svelte-kit`, `.turbo`, `.venv`,
+  // `.pytest_cache`… — one rule instead of a list that ages.
+  if (name.startsWith(".")) return false;
+  return !(NEVER_SCANNED_DIRECTORIES as readonly string[]).includes(name);
+}