@ogygie/generate 0.24.0 → 0.25.1

package/dist/cli/map-entry.d.ts

@@ -0,0 +1,32 @@
+import { type OgygieError } from "@ogygie/core/errors";
+import { type GenerateProject } from "./project.js";
+export interface ScreenMapEntry {
+    name: string;
+    intent: string;
+    app: string;
+    folder: string;
+    spec: string;
+    routes: never[];
+    dbTables: never[];
+    dependsOn: string[];
+    status: "skeleton" | "in-progress";
+}
+/** The features folder of an app, as its sibling features are laid out (`src/features` when none says otherwise). */
+export declare function featureFolderOfApp(project: GenerateProject, appName: string, featureId: string): string;
+export type ScreenEntryOutcome = {
+    ok: true;
+    entry: ScreenMapEntry;
+} | {
+    ok: false;
+    problem: OgygieError;
+} | {
+    ok: false;
+    problem: null;
+};
+/**
+ * The entry a screen spec off the map would get — or `{ ok: false, problem: null }` when the spec is not a screen's
+ * (nothing to add: the feature pipeline says what is missing), or a refusal when the front app cannot be told.
+ */
+export declare function screenMapEntryOf(project: GenerateProject, featureId: string, markdown: string, specPath: string): ScreenEntryOutcome;
+/** Adds the entry to the map on disk when the spec is a screen off the map; says what it did. Null entry: nothing to add. */
+export declare function ensureScreenOnMap(project: GenerateProject, featureId: string, log: (line: string) => void): ScreenEntryOutcome | null;

package/dist/cli/run.js

@@ -71,7 +71,10 @@ function printReport(specPath, report, out) {
 }
 async function runCheckCommand(project, featureId, out) {
   const specPaths = [];
-  if (featureId !== void 0) {
+  const offMapSpec = featureId === void 0 ? void 0 : `${project.specsFolder.replace(/\/+$/u, "")}/${featureId}.spec.md`;
+  if (featureId !== void 0 && offMapSpec !== void 0 && !project.manifest.features.some((feature) => feature.name === featureId) && existsSync(join(project.root, offMapSpec))) {
+    specPaths.push(offMapSpec);
+  } else if (featureId !== void 0) {
     const target = targetKindOf(project, featureId) === "screen" ? screenTargetOf(project, featureId) : featureTargetOf(project, featureId);
     if (!target.ok) {
       out.error(formatProblem(target.problem));
@@ -101,8 +104,8 @@ async function runCheckCommand(project, featureId, out) {
 }
 
 // src/cli/generate-command.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync as readdirSync2, writeFileSync } from "node:fs";
-import { dirname, join as join2 } from "node:path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, readdirSync as readdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join3 } from "node:path";
 import { performance } from "node:perf_hooks";
 
 // ../ogygie-core/src/spec.schema.ts
@@ -240,6 +243,69 @@ function compositionOfSpec(content) {
   return COMPOSITION_LINE.exec(section)?.[1] ?? null;
 }
 
+// src/cli/map-entry.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+function featureFolderOfApp(project, appName, featureId) {
+  const parents = project.manifest.features.filter((feature) => feature.app === appName).map((feature) => feature.folder.split("/").slice(0, -1).join("/")).filter((parent) => parent !== "");
+  const counts = /* @__PURE__ */ new Map();
+  for (const parent of parents) counts.set(parent, (counts.get(parent) ?? 0) + 1);
+  const common = [...counts.entries()].sort((left, right) => right[1] - left[1])[0]?.[0] ?? "src/features";
+  return `${common}/${featureId}`;
+}
+function screenMapEntryOf(project, featureId, markdown, specPath) {
+  const first = checkSpec({ markdown, specPath, generation: project.generation });
+  if (first.kind !== "screen" || first.screen === null) return { ok: false, problem: null };
+  const frontApps = project.manifest.apps.filter((app) => app.type === "front");
+  const point = first.screen.mounts === void 0 ? void 0 : (project.generation?.front?.extensionPoints ?? []).find((candidate) => candidate.id === first.screen?.mounts?.point);
+  const appName = point?.app ?? (frontApps.length === 1 ? frontApps[0]?.name : void 0);
+  if (appName === void 0) {
+    return {
+      ok: false,
+      problem: ogygieError({
+        code: "OGYGIE_GENERATE_PROJECT_INVALID",
+        message: `The screen "${featureId}" is not on the map and the map has ${frontApps.length} front apps: nothing says which one carries it.`,
+        file: MANIFEST_FILE,
+        cause: `no features[] entry is named "${featureId}" and the front app cannot be told (${frontApps.map((app) => app.name).join(", ") || "none"})`,
+        suggestedFix: "Declare the entry on the map with its `app`, or mount the screen on an extension point that names its app.",
+        details: { featureId, frontApps: frontApps.map((app) => app.name) }
+      })
+    };
+  }
+  const frontmatter = parseSpecDocument(markdown).frontmatter;
+  const known = new Set(project.manifest.features.map((feature) => feature.name));
+  const dependsOn = (frontmatter?.depends_on ?? []).filter((dependency) => known.has(dependency));
+  return {
+    ok: true,
+    entry: {
+      name: featureId,
+      intent: intentForManifest(intentOfSpec(markdown), specPath),
+      app: appName,
+      folder: featureFolderOfApp(project, appName, featureId),
+      spec: specPath,
+      routes: [],
+      dbTables: [],
+      dependsOn,
+      status: entryStatusForSpec(frontmatter?.status)
+    }
+  };
+}
+function ensureScreenOnMap(project, featureId, log) {
+  if (project.manifest.features.some((feature) => feature.name === featureId)) return null;
+  const specPath = `${project.specsFolder.replace(/\/+$/u, "")}/${featureId}.spec.md`;
+  const absolute = join2(project.root, specPath);
+  if (!existsSync2(absolute)) return null;
+  const outcome = screenMapEntryOf(project, featureId, readFileSync2(absolute, "utf8"), specPath);
+  if (!outcome.ok) return outcome;
+  const raw = project.rawManifest;
+  const features = Array.isArray(raw["features"]) ? raw["features"] : [];
+  raw["features"] = features;
+  features.push(outcome.entry);
+  writeFileSync(join2(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
+  log(`  ajout\xE9e  ${MANIFEST_FILE} \u203A features[${featureId}] (\xE9cran hors carte : app ${outcome.entry.app}, dossier ${outcome.entry.folder}, status ${outcome.entry.status}${outcome.entry.status === "skeleton" ? " tant que la spec est draft" : ""})`);
+  return outcome;
+}
+
 // src/cli/generate-command.ts
 function generatedFeatureIdsOf(project) {
   const kinds = [];
@@ -247,9 +313,9 @@ function generatedFeatureIdsOf(project) {
     if (feature.spec === null) continue;
     const kind = targetKindOf(project, feature.name);
     if (kind === null) continue;
-    const specPath = join2(project.root, feature.spec);
-    if (!existsSync2(specPath)) continue;
-    const first = checkSpec({ markdown: readFileSync2(specPath, "utf8"), specPath: feature.spec, generation: project.generation });
+    const specPath = join3(project.root, feature.spec);
+    if (!existsSync3(specPath)) continue;
+    const first = checkSpec({ markdown: readFileSync3(specPath, "utf8"), specPath: feature.spec, generation: project.generation });
     if (kind === "feature" ? first.block !== null : first.screen !== null) kinds.push({ id: feature.name, kind });
   }
   return [...kinds.filter((entry) => entry.kind === "feature"), ...kinds.filter((entry) => entry.kind === "screen")].map((entry) => entry.id);
@@ -286,6 +352,21 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     out.error("usage: ogygie generate generate <feature-id> | --all");
     return 1;
   }
+  const joined = ensureScreenOnMap(project, featureId, (line) => out.log(line));
+  if (joined !== null) {
+    if (!joined.ok && joined.problem !== null) {
+      out.error(formatProblem(joined.problem));
+      return 1;
+    }
+    if (joined.ok) {
+      const reloaded = loadGenerateProject(project.root);
+      if (!reloaded.ok) {
+        for (const problem of reloaded.problems) out.error(formatProblem(problem));
+        return 1;
+      }
+      return runGenerateScreenCommand(reloaded.project, featureId, out);
+    }
+  }
   if (targetKindOf(project, featureId) === "screen") return runGenerateScreenCommand(project, featureId, out);
   const lookup = featureTargetOf(project, featureId);
   if (!lookup.ok) {
@@ -293,7 +374,7 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     return 1;
   }
   const { target } = lookup;
-  const markdown = readFileSync2(join2(project.root, target.specPath), "utf8");
+  const markdown = readFileSync3(join3(project.root, target.specPath), "utf8");
   const firstPass = checkSpec({ markdown, specPath: target.specPath, generation: target.generation });
   if (firstPass.block === null) {
     for (const problem of firstPass.problems) out.error(formatProblem(problem));
@@ -313,8 +394,8 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     return 1;
   }
   const started = performance.now();
-  const migrationsDir = join2(project.root, target.appPath, target.generation.target.migrations);
-  const existingMigrations = existsSync2(migrationsDir) ? readdirSync2(migrationsDir) : [];
+  const migrationsDir = join3(project.root, target.appPath, target.generation.target.migrations);
+  const existingMigrations = existsSync3(migrationsDir) ? readdirSync2(migrationsDir) : [];
   const plan = buildFeaturePlan({
     featureId,
     folder: target.folder,
@@ -328,10 +409,10 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     generatorVersion: GENERATOR_VERSION,
     behaviors: boundBehaviorsOf(report.behaviors)
   });
-  const logicPath = join2(project.root, target.folder, "logic.ts");
-  const existingLogic = existsSync2(logicPath) ? readFileSync2(logicPath, "utf8") : null;
-  const migrationPath = join2(project.root, plan.migrationPath);
-  const existingMigration = existsSync2(migrationPath) ? readFileSync2(migrationPath, "utf8") : null;
+  const logicPath = join3(project.root, target.folder, "logic.ts");
+  const existingLogic = existsSync3(logicPath) ? readFileSync3(logicPath, "utf8") : null;
+  const migrationPath = join3(project.root, plan.migrationPath);
+  const existingMigration = existsSync3(migrationPath) ? readFileSync3(migrationPath, "utf8") : null;
   const files = generateFeature(plan, { existingLogic, existingMigration, library: loadHolesLibrary() });
   const manifestEntry = applyManifestEntry(project.rawManifest, plan, intentOfSpec(markdown), entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status));
   const specContracts = applySpecContracts(markdown, plan);
@@ -339,22 +420,22 @@ async function runGenerateFeatureCommand(project, featureId, out) {
   let written = 0;
   let emitted = 0;
   for (const file of files) {
-    const absolute = join2(project.root, file.path);
-    const exists = existsSync2(absolute);
+    const absolute = join3(project.root, file.path);
+    const exists = existsSync3(absolute);
     emitted += file.content.split("\n").length - 1;
-    if (exists && readFileSync2(absolute, "utf8") === file.content) {
+    if (exists && readFileSync3(absolute, "utf8") === file.content) {
       out.log(`  identique ${file.path}`);
       continue;
     }
     mkdirSync(dirname(absolute), { recursive: true });
-    writeFileSync(absolute, file.content, "utf8");
+    writeFileSync2(absolute, file.content, "utf8");
     written += 1;
     out.log(`  ${exists ? "r\xE9\xE9crit  " : "\xE9crit    "} ${file.path}`);
   }
   if (manifestEntry.outcome === "unchanged") {
     out.log(`  identique ${MANIFEST_FILE} \u203A features[${featureId}].routes, dbTables`);
   } else {
-    writeFileSync(join2(project.root, MANIFEST_FILE), serializeManifest(manifestEntry.manifest), "utf8");
+    writeFileSync2(join3(project.root, MANIFEST_FILE), serializeManifest(manifestEntry.manifest), "utf8");
     out.log(
       `  ${manifestEntry.outcome === "created" ? "ajout\xE9e  " : "r\xE9\xE9crite "} ${MANIFEST_FILE} \u203A features[${featureId}] (${plan.operations.length} route(s), ${1 + plan.slots.length + plan.references.filter((reference) => reference.table !== null).length} table(s)${manifestEntry.outcome === "created" ? `, status ${entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status)} : \xE0 vous de dire delivered` : ""})`
     );
@@ -367,7 +448,7 @@ async function runGenerateFeatureCommand(project, featureId, out) {
     out.log(`  identique ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es`);
   } else {
     const addedLines = specContracts.markdown.split("\n").length - markdown.split("\n").length;
-    writeFileSync(join2(project.root, target.specPath), specContracts.markdown, "utf8");
+    writeFileSync2(join3(project.root, target.specPath), specContracts.markdown, "utf8");
     out.log(
       `  ${specContracts.outcome === "inserted" ? "ins\xE9r\xE9   " : "r\xE9\xE9crit  "} ${target.specPath} \u203A bloc @generated de # Contrats de donn\xE9es${specContracts.outcome === "inserted" ? ` (+${addedLines} lignes)` : ""}`
     );
@@ -380,8 +461,8 @@ async function runGenerateFeatureCommand(project, featureId, out) {
 
 // src/cli/preview-command.ts
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync3 } from "node:fs";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync3 } from "node:fs";
+import { join as join4 } from "node:path";
 var PREVIEWS_ROOT = "previews";
 function previewsDirOf(featureId, composition) {
   return composition === null ? `${PREVIEWS_ROOT}/${featureId}` : `${PREVIEWS_ROOT}/${featureId}/${composition}`;
@@ -412,29 +493,29 @@ async function runPreviewCommand(project, featureId, out, runner = vitestPreview
     return 0;
   }
   const testPath = `${target.folder}/${pascalCaseOf(featureId)}Screen${PREVIEWS_FILE_SUFFIX}`;
-  if (!existsSync3(join3(project.root, testPath))) {
+  if (!existsSync4(join4(project.root, testPath))) {
     out.error(`ogygie generate preview \u2014 ${testPath} n'existe pas : lancez \`ogygie generate generate ${featureId}\` d'abord, le test des aper\xE7us est \xE9mis avec l'\xE9cran.`);
     return 1;
   }
-  const specAbsolute = join3(project.root, target.specPath);
-  const composition = existsSync3(specAbsolute) ? compositionOfSpec(readFileSync3(specAbsolute, "utf8")) : null;
+  const specAbsolute = join4(project.root, target.specPath);
+  const composition = existsSync4(specAbsolute) ? compositionOfSpec(readFileSync4(specAbsolute, "utf8")) : null;
   const relativeDir = previewsDirOf(featureId, composition);
-  const outDir = join3(project.root, relativeDir);
+  const outDir = join4(project.root, relativeDir);
   const run = runner({ projectRoot: project.root, testPath, outDir });
   for (const line of run.lines) out.log(`  ${line}`);
   if (run.code !== 0) {
     out.error(`ogygie generate preview \u2014 le rendu des aper\xE7us de ${featureId} a \xE9chou\xE9 (code ${run.code}) : rien n'est publi\xE9 tant qu'un \xE9tat ne rend pas.`);
     return run.code;
   }
-  const pages = existsSync3(outDir) ? readdirSync3(outDir).filter((name) => name.endsWith(".html")).sort() : [];
+  const pages = existsSync4(outDir) ? readdirSync3(outDir).filter((name) => name.endsWith(".html")).sort() : [];
   out.log(`ogygie generate preview \u2014 ${featureId} : ${pages.length} page(s) dans ${relativeDir}/ (${pages.map((name) => name.replace(/\.html$/u, "")).join(", ")})${composition === null ? "" : ` \u2014 composition ${composition}`}.`);
   return pages.length === 0 ? 1 : 0;
 }
 
 // src/cli/schemas-command.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { appendFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { appendFileSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/schemas/draft.ts
@@ -653,9 +734,9 @@ function featureFolderFor(project, featureId) {
   return `${common}/${featureId}`;
 }
 function availableGateScripts(projectRoot) {
-  const path = join4(projectRoot, "package.json");
-  if (!existsSync4(path)) return [];
-  const scripts = JSON.parse(readFileSync4(path, "utf8")).scripts ?? {};
+  const path = join5(projectRoot, "package.json");
+  if (!existsSync5(path)) return [];
+  const scripts = JSON.parse(readFileSync5(path, "utf8")).scripts ?? {};
   return SCHEMAS_GATE_SCRIPTS.filter((script) => script in scripts);
 }
 async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
@@ -665,8 +746,8 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
   }
   const onMap = project.manifest.features.find((feature) => feature.name === featureId);
   const specPath = onMap?.spec ?? `${project.specsFolder.replace(/\/+$/u, "")}/${featureId}.spec.md`;
-  const specAbsolute = join4(project.root, specPath);
-  if (!existsSync4(specAbsolute)) {
+  const specAbsolute = join5(project.root, specPath);
+  if (!existsSync5(specAbsolute)) {
     out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `No spec carries the feature "${featureId}".`, file: specPath, cause: `${specPath} does not exist`, suggestedFix: "Write the spec first: a schemas module derives from a spec, never the reverse." })));
     return 1;
   }
@@ -674,7 +755,7 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
     out.error(formatProblem(ogygieError({ code: "OGYGIE_GENERATE_PROJECT_INVALID", message: `The feature "${featureId}" cannot be generated from this map.`, file: MANIFEST_FILE, cause: project.apiApp === void 0 ? "apps[] has no entry with type=api" : "the manifest declares no generation block", suggestedFix: "Declare the api app and the `generation` block in the manifest." })));
     return 1;
   }
-  const markdown = readFileSync4(specAbsolute, "utf8");
+  const markdown = readFileSync5(specAbsolute, "utf8");
   const first = checkSpec({ markdown, specPath, generation: project.generation });
   if (first.kind !== "feature" || first.block === null) {
     out.log(`ogygie generate schemas \u2014 ${specPath} ${first.kind === "screen" ? "est un \xE9cran : ses contrats sont ceux des features qu'il consomme" : "n'a pas de bloc # G\xE9n\xE9ration de feature"}, rien \xE0 \xE9crire.`);
@@ -683,8 +764,8 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
   const block = first.block;
   const folder = onMap === void 0 ? `${project.apiApp.path}/${featureFolderFor(project, featureId)}` : `${project.apiApp.path}/${onMap.folder}`;
   const modulePath = `${folder}/${block.contracts.module.replace(/^\.\//u, "")}`;
-  const moduleAbsolute = join4(project.root, modulePath);
-  if (existsSync4(moduleAbsolute)) {
+  const moduleAbsolute = join5(project.root, modulePath);
+  if (existsSync5(moduleAbsolute)) {
     out.log(`ogygie generate schemas \u2014 ${modulePath} existe : il appartient au repo, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
     return 0;
   }
@@ -711,7 +792,7 @@ async function runSchemasCommand(project, featureId, argv, out, deps = {}) {
     },
     async judge(source, attempt) {
       mkdirSync2(dirname2(moduleAbsolute), { recursive: true });
-      writeFileSync2(moduleAbsolute, source, "utf8");
+      writeFileSync3(moduleAbsolute, source, "utf8");
       let moduleExports;
       try {
         moduleExports = await importProductModule(`${pathToFileURL(moduleAbsolute).href}?attempt=${attempt}`);
@@ -772,7 +853,7 @@ ${rows.join("\n")}
     raw["features"] = features;
     const status = entryStatusForSpec(parseSpecDocument(markdown).frontmatter?.status);
     features.push({ name: featureId, intent: intentForManifest(intentOfSpec(markdown), specPath), folder: featureFolderFor(project, featureId), spec: specPath, routes: [], dbTables: [], dependsOn: [], status });
-    writeFileSync2(join4(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
+    writeFileSync3(join5(project.root, MANIFEST_FILE), serializeManifest(raw), "utf8");
     out.log(`  ajout\xE9e  ${MANIFEST_FILE} \u203A features[${featureId}] (routes et tables viendront de \`generate\`, status ${status}${status === "skeleton" ? " tant que la spec est draft" : ""})`);
   }
   out.log(`ogygie generate schemas \u2014 ${featureId} : module \xE9crit en ${result.attempts} tentative(s) par ${result.model ?? "?"}, ${result.usage.length} appel(s) de mod\xE8le (${totalInput} jetons d'entr\xE9e, ${totalOutput} de sortie) ; commit\xE9 une fois, jamais r\xE9g\xE9n\xE9r\xE9 (D52).`);
@@ -784,7 +865,7 @@ import { performance as performance2 } from "node:perf_hooks";
 
 // ../ogygie-core/src/repo-adapter.ts
 import { readFile as readFileFromDisk, readdir, realpath, stat } from "node:fs/promises";
-import { isAbsolute, join as join5, resolve, sep } from "node:path";
+import { isAbsolute, join as join6, resolve, sep } from "node:path";
 import { z as z2 } from "zod";
 var RepoFileEntrySchema = z2.object({
   /** Path relative to the LISTED directory, "/" separated, never absolute. */
@@ -846,16 +927,16 @@ async function listFilesRecursively(absoluteDir, prefix) {
     const relativePath = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
       if (isSkippedDirectory(entry.name)) continue;
-      files.push(...await listFilesRecursively(join5(absoluteDir, entry.name), relativePath));
+      files.push(...await listFilesRecursively(join6(absoluteDir, entry.name), relativePath));
     } else if (entry.isFile()) {
-      const stats = await stat(join5(absoluteDir, entry.name));
+      const stats = await stat(join6(absoluteDir, entry.name));
       files.push({ path: relativePath, sizeBytes: stats.size });
     }
   }
   return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
 }
 async function resolveGitDirs(rootDir) {
-  const dotGit = join5(rootDir, ".git");
+  const dotGit = join6(rootDir, ".git");
   let gitDir;
   try {
     const stats = await stat(dotGit);
@@ -871,7 +952,7 @@ async function resolveGitDirs(rootDir) {
     return null;
   }
   try {
-    const commonPointer = (await readFileFromDisk(join5(gitDir, "commondir"), "utf8")).trim();
+    const commonPointer = (await readFileFromDisk(join6(gitDir, "commondir"), "utf8")).trim();
     return { gitDir, commonDir: isAbsolute(commonPointer) ? commonPointer : resolve(gitDir, commonPointer) };
   } catch {
     return { gitDir, commonDir: gitDir };
@@ -880,13 +961,13 @@ async function resolveGitDirs(rootDir) {
 async function readRefSha(dirs, refName) {
   for (const base of [dirs.gitDir, dirs.commonDir]) {
     try {
-      const sha = (await readFileFromDisk(join5(base, refName), "utf8")).trim();
+      const sha = (await readFileFromDisk(join6(base, refName), "utf8")).trim();
       if (sha !== "") return sha;
     } catch {
     }
   }
   try {
-    const packed = await readFileFromDisk(join5(dirs.commonDir, "packed-refs"), "utf8");
+    const packed = await readFileFromDisk(join6(dirs.commonDir, "packed-refs"), "utf8");
     for (const line of packed.split("\n")) {
       if (line.startsWith("#") || line.startsWith("^")) continue;
       const [sha, name] = line.trim().split(" ");
@@ -934,7 +1015,7 @@ function createFilesystemRepoAdapter(rootDir) {
       if (dirs === null) return null;
       let head;
       try {
-        head = (await readFileFromDisk(join5(dirs.gitDir, "HEAD"), "utf8")).trim();
+        head = (await readFileFromDisk(join6(dirs.gitDir, "HEAD"), "utf8")).trim();
       } catch {
         return null;
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ogygie/generate",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "description": "Ogygie generator: reads the `# Génération` block of a spec and its schemas.ts, derives everything deterministic without a model (routes, pipeline, database, factories, tests, screens, previews), fills the typed holes of logic.ts by library, draw and escalation, and draws the first schemas.ts of a new feature — judged by the gates. Sixth package of the lockstep (D55).",
   "license": "MIT",
   "type": "module",
@@ -29,7 +29,7 @@
     }
   },
   "dependencies": {
-    "@ogygie/core": "0.24.0",
+    "@ogygie/core": "0.25.1",
     "tsx": "^4.20.0",
     "yaml": "^2.9.0",
     "zod": "^4.0.0"
@@ -38,7 +38,7 @@
     "@lingui/babel-plugin-lingui-macro": "^5.9.5",
     "@lingui/core": "^5.9.5",
     "@lingui/react": "^5.9.5",
-    "@ogygie/ui": "0.24.0",
+    "@ogygie/ui": "0.25.1",
     "@starter/api": "0.1.0",
     "@tanstack/react-query": "^5.102.2",
     "@tanstack/react-router": "^1.170.32",