@ogygie/studio 0.5.0 → 0.5.1

package/src/server/service.ts

@@ -1,426 +0,0 @@
-/**
- * @intent Business logic of the ogygie-studio feature. Pure functions over the
- * injected SpecStorage (declared-effects principle): list/read/write specs,
- * serialize a conformant frontmatter, enforce the studio transition rules.
- * The studio is a VIEW over the repo: it never repairs a broken spec, never
- * writes `implemented` (that status belongs to the implementation flow —
- * manifest + CI), and preserves the markdown body byte-exact.
- */
-import {
-  SECTIONS_SPEC_OBLIGATOIRES,
-  SpecFrontmatterSchema,
-  parseSpecFrontmatter,
-  type SpecFrontmatter,
-} from "@ogygie/core/spec";
-import { OgygieManifestSchema, type OgygieManifest } from "@ogygie/core/manifest";
-import {
-  OgygieFailure,
-  ogygieError,
-  throwOgygieError,
-  type OgygieError,
-} from "@ogygie/core/errors";
-import type { SpecStorage } from "./storage/spec-storage.js";
-import type {
-  GetSpecOutput,
-  ReadableSpecSummary,
-  SpecSummary,
-} from "./schemas.js";
-
-export interface StudioDeps {
-  storage: SpecStorage;
-}
-
-const SPECS_DIR = "specs";
-const TEMPLATE_PATH = "specs/_TEMPLATE.spec.md";
-const MANIFEST_PATH = "ogygie.manifest.json";
-
-/** Same block shape as scripts/verify-specs.ts — the studio reads specs the
- * way the gate does, or the two would disagree on what a spec is. */
-const FRONTMATTER_BLOCK = /^---\n([\s\S]*?)\n---/;
-
-export interface SplitSpecFile {
-  frontmatterText: string;
-  /** Everything after the closing `---`, byte-exact (leading newline included). */
-  body: string;
-}
-
-export function splitSpecFile(content: string): SplitSpecFile | null {
-  const match = FRONTMATTER_BLOCK.exec(content);
-  if (match === null || match[1] === undefined) return null;
-  return { frontmatterText: match[1], body: content.slice(match[0].length) };
-}
-
-/** In-order scan, identical to the gate: a section out of order counts as
- * absent — the studio must refuse exactly what the CI would refuse. */
-export function presentSectionsOf(body: string): string[] {
-  const searchable = `\n${body}`;
-  const present: string[] = [];
-  let cursor = 0;
-  for (const section of SECTIONS_SPEC_OBLIGATOIRES) {
-    const position = searchable.indexOf(`\n${section}`, cursor);
-    if (position === -1) continue;
-    present.push(section);
-    cursor = position + section.length;
-  }
-  return present;
-}
-
-function missingSectionsOf(body: string): string[] {
-  const present = new Set(presentSectionsOf(body));
-  return SECTIONS_SPEC_OBLIGATOIRES.filter((section) => !present.has(section));
-}
-
-/** Quotes one frontmatter array element so parseSpecFrontmatter reads it back
- * verbatim. Refuses what the restricted format cannot carry (both quote kinds,
- * newlines) instead of writing a file the gate would then refuse. */
-function quoteFrontmatterElement(value: string, specPath: string): string {
-  if (value.includes("\n") || (value.includes('"') && value.includes("'"))) {
-    throwOgygieError(
-      {
-        code: "SPEC_FRONTMATTER_UNSERIALIZABLE",
-        message:
-          "A frontmatter array element cannot be written in the restricted spec format.",
-        file: specPath,
-        cause: `element ${JSON.stringify(value)} contains a newline or both quote kinds`,
-        suggestedFix:
-          "Rewrite the element without newlines and with at most one kind of quote character.",
-      },
-      422,
-    );
-  }
-  return value.includes('"') ? `'${value}'` : `"${value}"`;
-}
-
-/** Serializes a VALID frontmatter into the restricted `key: value` format the
- * parser owns (scalars + inline arrays). Deterministic template order; the
- * `deferred` line is only written when non-empty, like the template. */
-export function serializeSpecFrontmatter(
-  frontmatter: SpecFrontmatter,
-  specPath: string,
-): string {
-  const quote = (value: string): string => quoteFrontmatterElement(value, specPath);
-  const lines = [
-    `id: ${frontmatter.id}`,
-    `status: ${frontmatter.status}`,
-    `depends_on: [${frontmatter.depends_on.join(", ")}]`,
-    `priority: ${frontmatter.priority}`,
-    `refs: [${frontmatter.refs.map(quote).join(", ")}]`,
-  ];
-  if (frontmatter.deferred.length > 0) {
-    lines.push(`deferred: [${frontmatter.deferred.map(quote).join(", ")}]`);
-  }
-  return lines.join("\n");
-}
-
-function specPathOf(specId: string): string {
-  return `${SPECS_DIR}/${specId}.spec.md`;
-}
-
-function frontmatterInvalidError(filePath: string, cause: string): OgygieError {
-  return ogygieError({
-    code: "SPEC_FRONTMATTER_INVALID",
-    message: `Spec ${filePath} has an invalid frontmatter.`,
-    file: filePath,
-    cause,
-    suggestedFix:
-      "Fix the frontmatter in your editor to match packages/ogygie-core/src/spec.schema.ts — the studio never repairs a spec silently.",
-  });
-}
-
-interface ParsedSpec {
-  frontmatter: SpecFrontmatter;
-  body: string;
-}
-
-/** Parses a spec file or explains why it cannot be trusted. */
-function parseSpec(filePath: string, fileName: string, content: string):
-  | { ok: true; spec: ParsedSpec }
-  | { ok: false; error: OgygieError } {
-  const split = splitSpecFile(content);
-  if (split === null) {
-    return {
-      ok: false,
-      error: frontmatterInvalidError(
-        filePath,
-        "file does not start with a --- ... --- frontmatter block",
-      ),
-    };
-  }
-  const parsed = parseSpecFrontmatter(split.frontmatterText);
-  if (parsed.problems.length > 0) {
-    return { ok: false, error: frontmatterInvalidError(filePath, parsed.problems.join(" ; ")) };
-  }
-  const checked = SpecFrontmatterSchema.safeParse(parsed.value);
-  if (!checked.success) {
-    return {
-      ok: false,
-      error: frontmatterInvalidError(
-        filePath,
-        checked.error.issues
-          .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
-          .join(" ; "),
-      ),
-    };
-  }
-  const expectedId = fileName.replace(/\.spec\.md$/, "");
-  if (checked.data.id !== expectedId) {
-    return {
-      ok: false,
-      error: ogygieError({
-        code: "SPEC_ID_MISMATCH",
-        message: `Spec ${fileName} declares id "${checked.data.id}" — expected "${expectedId}".`,
-        file: filePath,
-        cause: `id=${checked.data.id} ≠ filename ${expectedId}`,
-        suggestedFix: "Make the frontmatter id identical to the file name.",
-      }),
-    };
-  }
-  return { ok: true, spec: { frontmatter: checked.data, body: split.body } };
-}
-
-function toReadableSummary(filePath: string, spec: ParsedSpec): ReadableSpecSummary {
-  return {
-    id: spec.frontmatter.id,
-    status: spec.frontmatter.status,
-    priority: spec.frontmatter.priority,
-    depends_on: spec.frontmatter.depends_on,
-    filePath,
-    presentSections: presentSectionsOf(spec.body),
-  };
-}
-
-async function listSpecFileNames(deps: StudioDeps): Promise<string[]> {
-  const entries = await deps.storage.list(SPECS_DIR);
-  return entries
-    .map((entry) => entry.name)
-    .filter((name) => name.endsWith(".spec.md") && !name.startsWith("_"))
-    .sort();
-}
-
-// ------------------------------------------------------------------ use cases
-
-export async function listSpecSummaries(deps: StudioDeps): Promise<SpecSummary[]> {
-  const fileNames = await listSpecFileNames(deps);
-  const summaries: SpecSummary[] = [];
-  for (const fileName of fileNames) {
-    const filePath = `${SPECS_DIR}/${fileName}`;
-    const content = await deps.storage.read(filePath);
-    const parsed = parseSpec(filePath, fileName, content);
-    const id = fileName.replace(/\.spec\.md$/, "");
-    summaries.push(
-      parsed.ok
-        ? toReadableSummary(filePath, parsed.spec)
-        : { id, filePath, error: parsed.error },
-    );
-  }
-  return summaries;
-}
-
-async function readParsedSpec(deps: StudioDeps, specId: string): Promise<ParsedSpec> {
-  const fileName = `${specId}.spec.md`;
-  const fileNames = await listSpecFileNames(deps);
-  if (!fileNames.includes(fileName)) {
-    throwOgygieError(
-      {
-        code: "SPEC_NOT_FOUND",
-        message: `No spec file exists for id "${specId}".`,
-        file: specPathOf(specId),
-        cause: `${fileName} absent from ${SPECS_DIR}/`,
-        suggestedFix: "Pick an id from GET /api/specs, or create the spec first.",
-      },
-      404,
-    );
-  }
-  const filePath = specPathOf(specId);
-  const content = await deps.storage.read(filePath);
-  const parsed = parseSpec(filePath, fileName, content);
-  if (!parsed.ok) {
-    // An unreadable spec cannot be edited from the studio: fixing it in a code
-    // editor keeps the "never silently repaired" promise intact.
-    throw new OgygieFailure(parsed.error, 422);
-  }
-  return parsed.spec;
-}
-
-export async function getSpec(deps: StudioDeps, specId: string): Promise<GetSpecOutput> {
-  const spec = await readParsedSpec(deps, specId);
-  return {
-    frontmatter: spec.frontmatter,
-    body: spec.body,
-    presentSections: presentSectionsOf(spec.body),
-  };
-}
-
-export interface SaveSpecInput {
-  frontmatter: SpecFrontmatter;
-  body?: string | undefined;
-}
-
-export async function saveSpec(
-  deps: StudioDeps,
-  specId: string,
-  input: SaveSpecInput,
-): Promise<ReadableSpecSummary> {
-  const current = await readParsedSpec(deps, specId);
-  const filePath = specPathOf(specId);
-
-  if (input.frontmatter.id !== specId) {
-    throwOgygieError(
-      {
-        code: "SPEC_ID_MISMATCH",
-        message: `The submitted frontmatter declares id "${input.frontmatter.id}" — expected "${specId}".`,
-        file: filePath,
-        cause: `frontmatter.id=${input.frontmatter.id} ≠ route param ${specId}`,
-        suggestedFix: "Keep the id identical to the file name — it is not editable.",
-      },
-      422,
-    );
-  }
-
-  const from = current.frontmatter.status;
-  const target = input.frontmatter.status;
-  if (target === "implemented" && from !== "implemented") {
-    throwOgygieError(
-      {
-        code: "STUDIO_TRANSITION_FORBIDDEN",
-        message:
-          "Status `implemented` belongs to the implementation flow (manifest + CI), never to the studio UI.",
-        file: filePath,
-        cause: `attempted transition ${from} → implemented from the studio`,
-        suggestedFix:
-          "Implement the feature, update the manifest to delivered, then flip the spec in the implementation commit.",
-      },
-      409,
-    );
-  }
-  const isValidation = from === "draft" && target === "validated";
-  if (from !== target && !isValidation) {
-    throwOgygieError(
-      {
-        code: "STUDIO_TRANSITION_FORBIDDEN",
-        message: "The studio only performs the draft → validated transition.",
-        file: filePath,
-        cause: `attempted transition ${from} → ${target} from the studio`,
-        suggestedFix:
-          "Reopening or downgrading a spec happens in the implementation flow (spec amendment commit), not in the studio.",
-      },
-      409,
-    );
-  }
-
-  // A provided body replaces the markdown; an omitted one is preserved
-  // byte-exact. The leading newline keeps `\n# @intent` matchable.
-  let body = input.body ?? current.body;
-  if (input.body !== undefined && !body.startsWith("\n")) {
-    body = `\n${body}`;
-  }
-
-  if (isValidation) {
-    const missing = missingSectionsOf(body);
-    if (missing.length > 0) {
-      throwOgygieError(
-        {
-          code: "SPEC_SECTION_MISSING",
-          message: `Spec ${specId} cannot be validated: ${missing.length} mandatory section(s) missing.`,
-          file: filePath,
-          cause: `missing or out-of-order: ${missing.join(" ; ")}`,
-          suggestedFix:
-            "Write the missing sections (in canonical order) before validating — a validated spec is an implementation contract.",
-          details: { missingSections: missing },
-        },
-        409,
-      );
-    }
-  }
-
-  const serialized = serializeSpecFrontmatter(input.frontmatter, filePath);
-  const content = `---\n${serialized}\n---${body}`;
-  const message = isValidation ? `spec: validate ${specId}` : `spec: save ${specId}`;
-  await deps.storage.write(filePath, content, message);
-  return toReadableSummary(filePath, { frontmatter: input.frontmatter, body });
-}
-
-export async function createSpec(
-  deps: StudioDeps,
-  specId: string,
-): Promise<ReadableSpecSummary> {
-  const fileName = `${specId}.spec.md`;
-  const fileNames = await listSpecFileNames(deps);
-  if (fileNames.includes(fileName)) {
-    throwOgygieError(
-      {
-        code: "SPEC_ALREADY_EXISTS",
-        message: `A spec already exists for id "${specId}" — nothing was overwritten.`,
-        file: specPathOf(specId),
-        cause: `${fileName} already present in ${SPECS_DIR}/`,
-        suggestedFix: "Open the existing spec from the board, or pick another id.",
-      },
-      409,
-    );
-  }
-  let template: string;
-  try {
-    template = await deps.storage.read(TEMPLATE_PATH);
-  } catch {
-    return throwOgygieError({
-      code: "SPEC_TEMPLATE_NOT_FOUND",
-      message: "specs/_TEMPLATE.spec.md is missing — the studio creates specs from it.",
-      file: TEMPLATE_PATH,
-      cause: "template file unreadable",
-      suggestedFix: "Restore specs/_TEMPLATE.spec.md from the framework skeleton.",
-    });
-  }
-  const content = template.replace(/^id: .*$/m, `id: ${specId}`);
-  const filePath = specPathOf(specId);
-  await deps.storage.write(filePath, content, `spec: create ${specId}`);
-
-  const parsed = parseSpec(filePath, fileName, content);
-  if (!parsed.ok) {
-    // The template itself must produce a readable draft; anything else is a
-    // broken template, not a user mistake.
-    return throwOgygieError({
-      code: "SPEC_TEMPLATE_NOT_FOUND",
-      message: "specs/_TEMPLATE.spec.md does not produce a readable draft spec.",
-      file: TEMPLATE_PATH,
-      cause: parsed.error.cause,
-      suggestedFix: "Fix the template's frontmatter to match SpecFrontmatterSchema.",
-    });
-  }
-  return toReadableSummary(filePath, parsed.spec);
-}
-
-export async function getManifest(deps: StudioDeps): Promise<OgygieManifest> {
-  const content = await deps.storage.read(MANIFEST_PATH);
-  let raw: unknown;
-  try {
-    raw = JSON.parse(content);
-  } catch (parseError) {
-    return throwOgygieError(
-      {
-        code: "MANIFEST_INVALID",
-        message: "ogygie.manifest.json is not valid JSON.",
-        file: MANIFEST_PATH,
-        cause: parseError instanceof Error ? parseError.message : "unparseable JSON",
-        suggestedFix: "Fix the manifest JSON — the studio only ever READS it.",
-      },
-      422,
-    );
-  }
-  const parsed = OgygieManifestSchema.safeParse(raw);
-  if (!parsed.success) {
-    throwOgygieError(
-      {
-        code: "MANIFEST_INVALID",
-        message: "ogygie.manifest.json does not satisfy OgygieManifestSchema.",
-        file: MANIFEST_PATH,
-        cause: parsed.error.issues
-          .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
-          .join(" ; "),
-        suggestedFix:
-          "Fix the listed fields to match packages/ogygie-core/src/manifest.schema.ts.",
-      },
-      422,
-    );
-  }
-  return parsed.data;
-}

package/src/server/start.ts

@@ -1,80 +0,0 @@
-/**
- * @intent Entry point of `ogygie studio`: local SpecStorage rooted at the
- * launched repo, Fastify bound to 127.0.0.1 ONLY (localhost tool — never
- * exposed), then the browser opens on the board. The repo is the state; this
- * process is just a view over it.
- *
- * The UI is SHIPPED already built in `dist-ui/` (spec v2): a consumer installs
- * the package and runs it, with none of the build-time dependencies. Building
- * on the fly only ever happens inside the framework's own workspace, where
- * vite is present — and when it is not, the refusal says so instead of failing
- * on a module resolution error.
- */
-import { existsSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { FastifyInstance } from "fastify";
-import { throwOgygieError } from "@ogygie/core/errors";
-import { createLocalSpecStorage } from "./storage/local-adapter.js";
-import { createStudioApp } from "./app.js";
-
-const PACKAGE_DIR = fileURLToPath(new URL("../..", import.meta.url));
-
-export interface StartStudioOptions {
-  /** Root of the Ogygie repo to project (specs/ + ogygie.manifest.json). */
-  repoRoot: string;
-  port?: number | undefined;
-  /** Set false in scripts/tests; defaults to opening the board in a browser. */
-  openBrowser?: boolean | undefined;
-}
-
-async function buildUiIfMissing(uiDistDir: string): Promise<void> {
-  if (existsSync(join(uiDistDir, "index.html"))) return;
-  console.log("ogygie studio — UI absente, construction unique…");
-  try {
-    const { build } = await import("vite");
-    await build({
-      configFile: join(PACKAGE_DIR, "vite.config.ts"),
-      logLevel: "warn",
-    });
-  } catch (thrown) {
-    throwOgygieError({
-      code: "OGYGIE_STUDIO_UI_MISSING",
-      message: "The studio UI is missing and cannot be built here.",
-      file: "packages/ogygie-studio/dist-ui/index.html",
-      cause:
-        thrown instanceof Error
-          ? `dist-ui absent and vite unavailable: ${thrown.message}`
-          : "dist-ui absent and vite unavailable",
-      suggestedFix:
-        "A published @ogygie/studio ships its UI already built — reinstall the package. Inside the framework workspace, run `pnpm --filter @ogygie/studio build`.",
-    });
-  }
-}
-
-function openInBrowser(url: string): void {
-  const opener = process.platform === "darwin" ? "open" : "xdg-open";
-  try {
-    spawn(opener, [url], { detached: true, stdio: "ignore" }).unref();
-  } catch {
-    // Opening the browser is a convenience, never a failure: the URL is logged.
-  }
-}
-
-export async function startStudio(options: StartStudioOptions): Promise<FastifyInstance> {
-  const port = options.port ?? 4001;
-  const uiDistDir = join(PACKAGE_DIR, "dist-ui");
-  await buildUiIfMissing(uiDistDir);
-
-  const app = await createStudioApp({
-    storage: createLocalSpecStorage(options.repoRoot),
-    uiDistDir,
-  });
-  await app.listen({ port, host: "127.0.0.1" });
-
-  const url = `http://127.0.0.1:${port}`;
-  console.log(`ogygie studio — ${url} (repo: ${options.repoRoot})`);
-  if (options.openBrowser !== false) openInBrowser(url);
-  return app;
-}

package/src/server/storage/local-adapter.test.ts

@@ -1,52 +0,0 @@
-/**
- * @intent Proves the v1 local-adapter contract on a scratch directory: list
- * only files, read/write UTF-8 round-trip, STORAGE_FILE_NOT_FOUND on a missing
- * file, and the traversal guard (a path escaping the root is refused).
- */
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createLocalSpecStorage } from "./local-adapter.js";
-
-describe("ogygie-studio — local-adapter", () => {
-  let rootDir: string;
-
-  beforeAll(async () => {
-    rootDir = await mkdtemp(join(tmpdir(), "ogygie-studio-"));
-    await mkdir(join(rootDir, "specs"));
-    await writeFile(join(rootDir, "specs", "alpha.spec.md"), "contenu", "utf8");
-    await mkdir(join(rootDir, "specs", "sous-dossier"));
-  });
-
-  afterAll(async () => {
-    await rm(rootDir, { recursive: true, force: true });
-  });
-
-  it("ÉTANT DONNÉ un dossier specs QUAND on liste ALORS seuls les FICHIERS remontent", async () => {
-    const storage = createLocalSpecStorage(rootDir);
-    const entries = await storage.list("specs");
-    expect(entries).toEqual([{ name: "alpha.spec.md" }]);
-  });
-
-  it("ÉTANT DONNÉ un fichier écrit QUAND on le relit ALORS le contenu revient octet pour octet", async () => {
-    const storage = createLocalSpecStorage(rootDir);
-    const content = "---\nid: beta\n---\n\n# @intent\naccentué, émoji ✅\n";
-    await storage.write("specs/beta.spec.md", content, "spec: save beta");
-    expect(await storage.read("specs/beta.spec.md")).toBe(content);
-  });
-
-  it("ÉTANT DONNÉ un fichier absent QUAND on le lit ALORS STORAGE_FILE_NOT_FOUND", async () => {
-    const storage = createLocalSpecStorage(rootDir);
-    await expect(storage.read("specs/fantome.spec.md")).rejects.toMatchObject({
-      error: expect.objectContaining({ code: "STORAGE_FILE_NOT_FOUND" }),
-    });
-  });
-
-  it("ÉTANT DONNÉ un chemin qui s'échappe de la racine QUAND on le lit ALORS STORAGE_PATH_OUTSIDE_ROOT", async () => {
-    const storage = createLocalSpecStorage(rootDir);
-    await expect(storage.read("../hors-racine")).rejects.toMatchObject({
-      error: expect.objectContaining({ code: "STORAGE_PATH_OUTSIDE_ROOT" }),
-    });
-  });
-});

package/src/server/storage/local-adapter.ts

@@ -1,67 +0,0 @@
-/**
- * @intent v1 SpecStorage implementation: the local filesystem, rooted at the
- * repo the studio was launched in. Deliberately dumb — existence policy,
- * parsing and transition rules all live in the service; this adapter only
- * touches the disk. `message` is ignored: in v1 the dev commits by hand.
- */
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, join, normalize } from "node:path";
-import { throwOgygieError } from "@ogygie/core/errors";
-import type { FileEntry, SpecStorage } from "./spec-storage.js";
-
-/** Refuses any path escaping the repo root — the studio serves localhost, but
- * a traversal bug must still be structurally impossible. */
-function resolveInsideRoot(rootDir: string, relativePath: string): string {
-  const absolute = normalize(join(rootDir, relativePath));
-  if (!absolute.startsWith(normalize(rootDir))) {
-    throwOgygieError(
-      {
-        code: "STORAGE_PATH_OUTSIDE_ROOT",
-        message: "The requested path escapes the repo root.",
-        file: null,
-        cause: `relative path "${relativePath}" resolves outside "${rootDir}"`,
-        suggestedFix: "Only address files inside the repo (specs/, ogygie.manifest.json).",
-      },
-      400,
-    );
-  }
-  return absolute;
-}
-
-export function createLocalSpecStorage(rootDir: string): SpecStorage {
-  return {
-    async list(dir: string): Promise<FileEntry[]> {
-      const absolute = resolveInsideRoot(rootDir, dir);
-      try {
-        const entries = await readdir(absolute, { withFileTypes: true });
-        return entries
-          .filter((entry) => entry.isFile())
-          .map((entry) => ({ name: entry.name }));
-      } catch {
-        return [];
-      }
-    },
-
-    async read(path: string): Promise<string> {
-      const absolute = resolveInsideRoot(rootDir, path);
-      try {
-        return await readFile(absolute, "utf8");
-      } catch {
-        return throwOgygieError({
-          code: "STORAGE_FILE_NOT_FOUND",
-          message: "The requested file cannot be read from the repo.",
-          file: path,
-          cause: `readFile failed for "${absolute}"`,
-          suggestedFix:
-            "Check that the studio was launched from an Ogygie repo root (specs/ + ogygie.manifest.json).",
-        });
-      }
-    },
-
-    async write(path: string, content: string, _message: string): Promise<void> {
-      const absolute = resolveInsideRoot(rootDir, path);
-      await mkdir(dirname(absolute), { recursive: true });
-      await writeFile(absolute, content, "utf8");
-    },
-  };
-}

package/src/server/storage/memory-adapter.ts

@@ -1,49 +0,0 @@
-/**
- * @intent In-memory SpecStorage for the tests (no real fs, principle 7) and
- * for any future embedded use. Exposes the underlying file map and the write
- * messages so a test can assert BOTH the produced content and the declared
- * intent ("spec: validate <id>") without touching a disk.
- */
-import { throwOgygieError } from "@ogygie/core/errors";
-import type { FileEntry, SpecStorage } from "./spec-storage.js";
-
-export interface MemorySpecStorage extends SpecStorage {
-  /** Relative path → content. Mutable on purpose: tests arrange states here. */
-  files: Map<string, string>;
-  /** Every message passed to write(), in order. */
-  messages: string[];
-}
-
-export function createMemorySpecStorage(
-  initialFiles: Record<string, string>,
-): MemorySpecStorage {
-  const files = new Map(Object.entries(initialFiles));
-  const messages: string[] = [];
-  return {
-    files,
-    messages,
-    async list(dir: string): Promise<FileEntry[]> {
-      const prefix = dir.endsWith("/") ? dir : `${dir}/`;
-      return [...files.keys()]
-        .filter((path) => path.startsWith(prefix) && !path.slice(prefix.length).includes("/"))
-        .map((path) => ({ name: path.slice(prefix.length) }));
-    },
-    async read(path: string): Promise<string> {
-      const content = files.get(path);
-      if (content === undefined) {
-        return throwOgygieError({
-          code: "STORAGE_FILE_NOT_FOUND",
-          message: "The requested file does not exist in the memory storage.",
-          file: path,
-          cause: `no entry for "${path}"`,
-          suggestedFix: "Arrange the file in the test's initialFiles first.",
-        });
-      }
-      return content;
-    },
-    async write(path: string, content: string, message: string): Promise<void> {
-      files.set(path, content);
-      messages.push(message);
-    },
-  };
-}