@fougere/cli 0.12.5-alpha.0 → 0.13.0-alpha.0

package/src/loader.ts

@@ -1,28 +0,0 @@
-import { resolve, sep } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { frondAliases } from '@fougere/compiler';
-import { resolveConventions } from '@fougere/core';
-import { setModuleLoader, loadConfig } from '@fougere/core/node';
-import type { Conventions } from '@fougere/core';
-
-/**
- * The loader every command needs — made FROM the project, since a module key (`'@fougere/log'`)
- * is resolved against whoever made the loader: made here, it looked in the CLI's own
- * dependencies and never in the project's.
- */
-export async function installLoader(root: string, reread = false): Promise<Conventions> {
-  const { createJiti } = await import('jiti');
-  const project = pathToFileURL(resolve(root) + sep).href;
-  const bare = createJiti(project, { interopDefault: true });
-  setModuleLoader((filePath) => bare.import(filePath) as Promise<Record<string, unknown>>);
-
-  const conventions = resolveConventions((await loadConfig(root)).conventions);
-  const jiti = createJiti(project, {
-    interopDefault: true,
-    alias: await frondAliases(root, conventions),
-    ...(reread ? { moduleCache: false } : {}),
-  });
-  setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
-
-  return conventions;
-}

package/src/machine.ts

@@ -1,17 +0,0 @@
-/** A command's machine output — the one shape a pipe reads. */
-export function machineWanted(raw: Record<string, unknown>): boolean {
-  return raw.json === true || typeof raw.names === 'string';
-}
-
-/**
- * A `Map` serializes to `{}`, so the facade converts it rather than each command flattening its own
- * result: `GraphResult.nodes` is a Map, and `graph --json` would have printed a report with an
- * empty graph in it.
- */
-export function machineText(value: unknown): string {
-  return JSON.stringify(value, (_key, held) => (held instanceof Map ? Object.fromEntries(held) : held), 2);
-}
-
-export function printMachine(value: unknown): void {
-  process.stdout.write(machineText(value) + '\n');
-}

package/src/runner.ts

@@ -1,152 +0,0 @@
-/**
- * CLI runner — scans frond entities for flags, looks for app commands for presentation, dispatches
- * via citty.
- */
-import type { App } from '@fougere/core';
-import { createAppRunner } from '@fougere/core';
-import { lowerFirst } from '@fougere/core/contract';
-import { defineCommand, runMain } from 'citty';
-import { ui } from './ui.js';
-import { machineWanted } from './machine.js';
-import { Shapes } from '@fougere/schema';
-import { entityToArgs } from './bridge.js';
-import { readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-
-function toKebab(name: string): string {
-  return name.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase()).replace(/^-/, '');
-}
-
-function toCamel(kebab: string): string {
-  return kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-}
-
-/** Scan app/commands/ for command classes. */
-async function loadAppCommands(
-  root: string,
-  loader: (path: string) => Promise<Record<string, unknown>>,
-): Promise<Map<string, new (...args: unknown[]) => { run: (raw: Record<string, unknown>) => Promise<void> }>> {
-  const map = new Map();
-  const dir = join(root, 'app', 'commands');
-  const files = await readdir(dir, { withFileTypes: true }).catch(() => []);
-
-  for (const f of files) {
-    if (!f.isFile() || !(f.name.endsWith('.ts') || f.name.endsWith('.js'))) continue;
-    const name = f.name.replace(/Command\.(ts|js)$/, '').replace(/\.(ts|js)$/, '');
-    const kebab = toKebab(name);
-    const mod = await loader(join(dir, f.name));
-    if (mod.default && typeof mod.default === 'function') {
-      map.set(kebab, mod.default);
-    }
-  }
-
-  return map;
-}
-
-/**
- * Every operation of an app, as a terminal command.
- *
- * `root` is where the PRESENTATION classes are looked for — `app/commands/`, one per command
- * that wants to print something of its own. It defaults to this package, which is how
- * `npx fougere` finds its fifteen; a project passes its own and gets the same treatment for
- * the operations it declares, with no class at all where a default rendering will do.
- */
-export async function run(app: App, root = new URL('..', import.meta.url).pathname): Promise<void> {
-  const terminal = ui();
-
-  const { createJiti } = await import('jiti');
-  const jiti = createJiti(import.meta.url, { interopDefault: true });
-  const loader = (path: string) => jiti.import(path) as Promise<Record<string, unknown>>;
-  const appCommands = await loadAppCommands(root, loader);
-
-  const subCommands: Record<string, ReturnType<typeof defineCommand>> = {};
-
-  for (const frond of app.fronds) {
-    const handlerMap = new Map(frond.handlers.map((h) => [h.address, h]));
-
-    for (const entity of frond.entities) {
-      const handlerEntry = handlerMap.get(entity.name);
-      if (!handlerEntry) continue;
-
-      const handlerName = `${entity.name}Handler`;
-      let handler: Record<string, Function>;
-      try {
-        handler = app.resolve<Record<string, Function>>(handlerName);
-      } catch { continue; }
-
-      if (typeof handler.execute !== 'function') continue;
-
-      const cmdName = toKebab(entity.name);
-      const fields = entity.entityClass.getFields();
-      const args = entityToArgs(fields);
-
-      // Check for an app command (presentation layer)
-      const AppCommand = appCommands.get(cmdName);
-
-      // App commands handle their own prompting — don't let citty reject missing args
-      if (AppCommand) {
-        for (const def of Object.values(args)) {
-          if (typeof def === 'object' && def) def.required = false;
-        }
-      }
-
-      subCommands[cmdName] = defineCommand({
-        meta: {
-          name: cmdName,
-          // `--help` reads the operation's own doc sentence, which the scan already
-          // carries for every facade (`OperationContract.description`). A table here
-          // would be the same fact written twice, and it drifted: it described `add`
-          // and `doctor`, which do not exist, and had nothing for `call` or `serve`.
-          description: handlerEntry.operations.get('execute')?.description,
-        },
-        args,
-        run: async ({ args: parsed }) => {
-          // JSON is a protocol: a branded intro before `{` makes it unparsable. Read from
-          // the invocation's own args, so any command declaring `json` gets a clean stdout
-          // — naming `explain` here is what let `graph --json` print its decorated box.
-          const machineOutput = machineWanted(parsed as Record<string, unknown>);
-
-          // `completion` is exempt by nature, not by flag: its output IS a shell script,
-          // there is no invocation of it that wants decoration.
-          if (cmdName !== 'completion' && !machineOutput) terminal.intro();
-
-          // citty adds `_` (raw positionals) and `--` (passthrough); strip them
-          // so only the entity's own fields reach the handler — read as their shape says,
-          // since a flag is text.
-          const input = Object.fromEntries(
-            Object.entries(parsed as Record<string, unknown>)
-              .filter(([key]) => key !== '_' && key !== '--')
-              .map(([key, value]) => [key, Shapes.fromText(fields[key]?.shape, value)]),
-          );
-
-          try {
-            if (AppCommand) {
-              const cmd = new (AppCommand as new (...a: unknown[]) => { run: (raw: Record<string, unknown>) => Promise<void> })(app, terminal);
-              await cmd.run(input);
-            } else {
-              // Ride the call contract — the same envelope every consumer uses.
-              await createAppRunner(app)(
-                { entity: lowerFirst(entity.name), op: 'execute' },
-                { params: {}, query: {}, input: input, state: {} },
-              );
-            }
-          } catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            // A machine reader parses stdout: a refusal printed there is a refusal that
-            // breaks the parse instead of being read. stderr is where it belongs.
-            if (machineOutput) process.stderr.write(message + '\n');
-            else terminal.error(message);
-            process.exit(1);
-          }
-        },
-      });
-    }
-  }
-
-  const main = defineCommand({
-    meta: { name: 'fougere', description: 'Fougere CLI' },
-    subCommands,
-  });
-
-  await runMain(main);
-}

package/src/theme.ts

@@ -1,19 +0,0 @@
-import pc from 'picocolors';
-
-export interface ThemeColors {
-  brand: (text: string) => string;
-  success: (text: string) => string;
-  error: (text: string) => string;
-  warn: (text: string) => string;
-  muted: (text: string) => string;
-  bold: (text: string) => string;
-}
-
-export const defaultTheme: ThemeColors = {
-  brand: pc.green,
-  success: pc.green,
-  error: pc.red,
-  warn: pc.yellow,
-  muted: pc.dim,
-  bold: pc.bold,
-};

package/src/typescript/EntityTypes.ts

@@ -1,92 +0,0 @@
-import { Shapes, upperFirst, type FieldDescriptor, type SchemaDescriptor } from '@fougere/schema';
-import { docCommentOf, propertyKey } from './syntax.js';
-
-export interface EntityTypesOptions {
-  name?: string;
-  exported?: boolean;
-}
-
-/** So a nullable field lands as a union. */
-function typeOf(field: FieldDescriptor): string {
-  const types = Shapes.typesOf(field);
-  const nullable = types.includes('null');
-  const base = types.find((t) => t !== 'null');
-  const inner = baseTypeOf(base, field);
-
-  return nullable ? `${inner} | null` : inner;
-}
-
-/** So `date-time` becomes a `Date`, the same thing the boundary decodes to. */
-function baseTypeOf(base: string | undefined, field: FieldDescriptor): string {
-  if (field.enum?.length) {
-    return field.enum.map((v) => (v === null ? 'null' : JSON.stringify(v))).join(' | ');
-  }
-  switch (base) {
-    case 'string':
-      return field.format === 'date-time' ? 'Date' : 'string';
-    case 'number':
-    case 'integer':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'array':
-      return field.items ? `${typeOf(field.items)}[]` : 'string[]';
-    case 'object':
-      return field.properties ? objectTypeOf(field.properties, field.required ?? []) : 'Record<string, unknown>';
-    default:
-      return 'unknown';
-  }
-}
-
-/** So a nested object keeps its optionality. */
-function objectTypeOf(properties: Record<string, FieldDescriptor>, required: readonly string[]): string {
-  const members = Object.entries(properties).map(([name, field]) => {
-    const optional = required.includes(name) ? '' : '?';
-
-    return `${propertyKey(name)}${optional}: ${typeOf(field)}`;
-  });
-
-  return `{ ${members.join('; ')} }`;
-}
-
-/** So the generated class carries its row type. */
-function shapeTypeOf(descriptor: SchemaDescriptor, indent = ''): string {
-  const entries = Object.entries(descriptor.properties ?? {});
-  if (entries.length === 0) return '{}';
-
-  const lines = entries.map(([key, field]) => {
-    const doc = docCommentOf(field.description, `${indent}  `);
-
-    return `${doc}${indent}  ${propertyKey(key)}: ${typeOf(field)};`;
-  });
-
-  return `{\n${lines.join('\n')}\n${indent}}`;
-}
-
-export class EntityTypes {
-  private constructor(private readonly descriptor: SchemaDescriptor) {}
-
-  static of(descriptor: SchemaDescriptor): EntityTypes {
-    return new EntityTypes(descriptor);
-  }
-
-  render(options: EntityTypesOptions = {}): string {
-    const name = identifierOf(options.name ?? upperFirst(this.descriptor.title ?? 'Schema'));
-    const exported = options.exported === false ? '' : 'export ';
-    const card = JSON.stringify(this.descriptor, null, 2)
-      .split('\n')
-      .map((line, i) => (i === 0 ? line : `  ${line}`))
-      .join('\n');
-
-    return `${exported}class ${name} extends Card.fromDescriptor<${shapeTypeOf(this.descriptor)}>(${card}).toSchema() {}`;
-  }
-}
-
-/** So a name that cannot declare a class is refused before it reaches a file. */
-function identifierOf(name: string): string {
-  if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name)) {
-    throw new Error(`'${name}' is not a TypeScript identifier — it cannot name a generated declaration`);
-  }
-
-  return name;
-}

package/src/typescript/FacadeTypes.ts

@@ -1,50 +0,0 @@
-import type { SchemaDescriptor } from '@fougere/schema';
-import { docCommentOf, propertyKey } from './syntax.js';
-
-export interface OpDescriptor {
-  name: string;
-  description?: string;
-  output?: SchemaDescriptor;
-  cardinality?: 'one' | 'maybe' | 'many' | 'page' | 'none';
-}
-
-export interface FacadeTypesOptions {
-  name?: string;
-  exported?: boolean;
-  rowType?: string;
-}
-
-/** So a consumer sees the cardinality in the type, not in a doc line. */
-function returnTypeOf(op: OpDescriptor, rowType: string): string {
-  switch (op.cardinality) {
-    case 'many': return `${rowType}[]`;
-    case 'page': return `${rowType}[] & { total?: number; endCursor?: string; hasMore?: boolean }`;
-    case 'maybe': return `${rowType} | undefined`;
-    case 'one': return rowType;
-    case 'none': return 'unknown';
-    default: return 'unknown';
-  }
-}
-
-export class FacadeTypes {
-  private constructor(private readonly operations: readonly OpDescriptor[]) {}
-
-  static of(operations: readonly OpDescriptor[]): FacadeTypes {
-    return new FacadeTypes(operations);
-  }
-
-  render(options: FacadeTypesOptions = {}): string {
-    const name = options.name ?? 'Facade';
-    const exported = options.exported === false ? '' : 'export ';
-    const rowType = options.rowType ?? 'unknown';
-    const members = this.operations.map((operation) => {
-      const doc = docCommentOf(operation.description, '  ');
-
-      return `${doc}  ${propertyKey(operation.name)}(invocation?: Invocation): Promise<${returnTypeOf(operation, rowType)}>;`;
-    });
-
-    if (members.length === 0) return `${exported}interface ${name} {}`;
-
-    return `${exported}interface ${name} {\n${members.join('\n')}\n}`;
-  }
-}

package/src/typescript/syntax.ts

@@ -1,11 +0,0 @@
-/** So a name that is not an identifier is still written as a key. */
-export function propertyKey(name: string): string {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
-}
-
-/** So a sentence shows on hover — and cannot close the comment it sits in. */
-export function docCommentOf(text: string | undefined, indent: string): string {
-  if (!text) return '';
-
-  return `${indent}/** ${text.replace(/\*\//g, '*\\/')} */\n`;
-}

package/src/ui.ts

@@ -1,142 +0,0 @@
-/** Fougere CLI UI — beautiful terminal interface. */
-import * as clack from '@clack/prompts';
-import pc from 'picocolors';
-import { consola } from 'consola';
-import { defaultTheme, type ThemeColors } from './theme.js';
-
-export interface UiTheme {
-  colors?: Partial<ThemeColors>;
-}
-
-export function ui(options?: UiTheme) {
-  const c = { ...defaultTheme, ...options?.colors };
-
-  return {
-    // ── Lifecycle ─────────────────────────────────
-
-    /** Start a new CLI session with a branded header. */
-    intro(title = 'Fougere') {
-      clack.intro(c.brand(title));
-    },
-
-    /** End the session with a message. */
-    outro(message: string) {
-      clack.outro(c.success(message));
-    },
-
-    /** Cancel and exit. */
-    cancel(message = 'Cancelled.') {
-      clack.cancel(c.muted(message));
-      process.exit(0);
-    },
-
-    // ── Prompts ───────────────────────────────────
-
-    /** Text input. */
-    async text(opts: { message: string; placeholder?: string; defaultValue?: string; validate?: (value: string) => string | undefined }) {
-      const result = await clack.text(opts);
-
-
-
-
-      if (clack.isCancel(result)) { this.cancel(); return ''; }
-
-      return result as string;
-    },
-
-    /** Yes/no confirmation. */
-    async confirm(opts: { message: string; initialValue?: boolean }) {
-      const result = await clack.confirm(opts);
-
-
-
-
-      if (clack.isCancel(result)) { this.cancel(); return false; }
-
-      return result as boolean;
-    },
-
-    /** Select one from a list. */
-    async select(opts: {
-      message: string;
-      options: { value: string; label?: string; hint?: string }[];
-      initialValue?: string;
-    }) {
-      const result = await clack.select(opts as Parameters<typeof clack.select>[0]);
-
-
-
-
-      if (clack.isCancel(result)) { this.cancel(); return ''; }
-
-      return result as string;
-    },
-
-    /** Multi-select from a list. */
-    async multiselect(opts: {
-      message: string;
-      options: { value: string; label?: string; hint?: string }[];
-      required?: boolean;
-    }) {
-      const result = await clack.multiselect(opts as Parameters<typeof clack.multiselect>[0]);
-
-
-
-
-      if (clack.isCancel(result)) { this.cancel(); return [] as string[]; }
-
-      return result as string[];
-    },
-
-    // ── Spinner ───────────────────────────────────
-
-    /** Start a spinner. Returns stop/update functions. */
-    spinner(message?: string) {
-      const s = clack.spinner();
-      s.start(message);
-
-      return {
-        update: (msg: string) => s.message(msg),
-        stop: (msg?: string) => s.stop(msg),
-      };
-    },
-
-    // ── Output ────────────────────────────────────
-
-    /** Informational message. */
-    info(message: string) {
-      clack.log.info(message);
-    },
-
-    /** Success message. */
-    success(message: string) {
-      clack.log.success(c.success(message));
-    },
-
-    /** Warning message. */
-    warn(message: string) {
-      clack.log.warn(c.warn(message));
-    },
-
-    /** Error message. */
-    error(message: string) {
-      clack.log.error(c.error(message));
-    },
-
-    /** Step indicator. */
-    step(message: string) {
-      clack.log.step(message);
-    },
-
-    /** Note box — multiline content in a box. */
-    note(message: string, title?: string) {
-      clack.note(message, title);
-    },
-
-    // ── Raw colors/consola ────────────────────────
-
-    colors: c,
-    pc,
-    consola,
-  };
-}

package/templates/flat/AGENTS.md

@@ -1,14 +0,0 @@
-# Working in this application
-
-This project is built with **Fougere**. Read `CLAUDE.md` for the model and architecture guidance
-that applies to every coding agent.
-
-## Required verification workflow
-
-After every change to handlers, entities, Fronds, configuration, or topology:
-
-1. Run `fougere check`.
-2. Fix every deterministic error it reports before continuing.
-3. Run the relevant tests, then run `pnpm typecheck`.
-
-`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/flat/CLAUDE.md

@@ -1,87 +0,0 @@
-# Working in this application
-
-Built with **Fougere**. This file is read by coding agents before they touch anything — it states
-the few facts that change what they should write.
-
-## One declaration, everything derives
-
-A field belongs to its entity and to nowhere else. Adding it there alone produces the SQL column,
-the validation, the input contract, the write and the output shape. Additive storage changes need no
-hand-written migration; renames, removals and type changes still do. No DTO or permitted-params list
-needs to stay in step.
-
-```ts
-// entities/Product.ts — and nothing else
-sku: text({ min: 3, max: 32 }),
-```
-
-Two consequences worth stating, because they are what makes it hold:
-
-- **An input view derives from the entity** — `Order.omit('id', 'status').extend({ items })`, never
-  a parallel entity that repeats the same fields. A field added to the entity is then accepted
-  without touching the view.
-- **A handler writes what the input carries** (`{ ...attributes }`), it does not enumerate its
-  fields — otherwise a new field is validated, then silently not written.
-
-If you are about to write the same constraint in two places, you have missed the derivation.
-
-## A surface is a facade, never a logic
-
-Every facade goes through the handler **façade**, which is where validation sits: unknown-key refusal,
-collectors. A resolver or route you wire yourself against the storage — or worse, against the database —
-is a second facade with no validator behind it, and the rules declared in the entities stop applying there.
-
-Before adding a surface, reach for its **projection**:
-
-| surface | the call |
-|---|---|
-| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/adapter-rest` |
-| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/adapter-graphql` |
-
-Hand-writing the types (`buildSchema`, raw SDL, one Pothos resolver per field) rebuilds what the
-projection already derives, and drops the validator on the way. `registerType` / `registerOperations`
-exist to add what a projection cannot derive — never to replace it.
-
-## Reading data
-
-Storage is reached through a repository. Never inject `Storage` directly into a handler,
-presenter or collector — the boot refuses it. With no repository file, ask for the default shape:
-
-```ts
-import type { RepositoryOf } from '@fougere/core';
-import Product from '../entities/Product.js';
-
-constructor(private products: RepositoryOf<Product>) {}
-```
-
-If the handler extends `Crud(Product)`, its inherited `this.storage` is already backed by that
-repository; do not add a constructor. The repository forwards the guarded storage gestures:
-
-```
-list(options?)        every row — `options.where` filters, plus paging and sorting
-findById(id)          one row by id
-findBy(criteria)      one row by criteria      — findBy({ email })
-findAllBy(criteria)   every row of a criteria  — findAllBy({ order_id }) IS a one-to-many relation
-create / update / delete
-```
-
-Read a relation with `findAllBy`. Never read a whole table to filter it in memory.
-
-When a query deserves a domain name, add `repositories/ProductRepository.ts` with
-`class ProductRepository extends Repository(Product)`, put the query there, and inject
-`ProductRepository`. A repository is registered as a provider and remains the only route to storage.
-
-## Checking your work
-
-After every change to handlers, entities, Fronds, configuration, or topology:
-
-1. Run `fougere check`.
-2. Fix every deterministic error it reports before continuing.
-3. Run the relevant tests, then run the project typecheck.
-
-```bash
-fougere check
-pnpm typecheck
-```
-
-`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/flat/_gitignore

@@ -1,6 +0,0 @@
-node_modules
-.nuxt
-.output
-.data
-dist
-*.log

package/templates/flat/app/app.vue

@@ -1,25 +0,0 @@
-<template>
-  <NuxtPage />
-</template>
-
-<style>
-:root { --fg: #1a1a1a; --muted: #6b7280; --border: #e5e7eb; --accent: #2563eb; }
-* { box-sizing: border-box; }
-body { margin: 0; font-family: system-ui, -apple-system, sans-serif; color: var(--fg); line-height: 1.6; }
-.wrap { max-width: 720px; margin: 3rem auto; padding: 0 1.5rem; }
-a { color: var(--accent); text-decoration: none; }
-a:hover { text-decoration: underline; }
-h1 { font-size: 1.6rem; margin-bottom: 0.25rem; }
-code { background: #f3f4f6; padding: 0.1rem 0.35rem; border-radius: 4px; font-size: 0.9em; }
-table { width: 100%; border-collapse: collapse; margin-top: 1rem; }
-th, td { text-align: left; padding: 0.6rem 0.5rem; border-bottom: 1px solid var(--border); }
-th { font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.03em; color: var(--muted); }
-label { display: block; font-size: 0.85rem; margin: 0.9rem 0 0.3rem; color: var(--muted); }
-input, textarea { width: 100%; padding: 0.5rem 0.6rem; border: 1px solid var(--border); border-radius: 6px; font: inherit; }
-button { padding: 0.5rem 0.9rem; border: 0; border-radius: 6px; background: var(--accent); color: #fff; font: inherit; cursor: pointer; }
-button:disabled { opacity: 0.5; cursor: default; }
-.badge { font-size: 0.72rem; padding: 0.15rem 0.55rem; border-radius: 999px; background: #f3f4f6; color: var(--muted); }
-.badge.published { background: #dcfce7; color: #166534; }
-.muted { color: var(--muted); }
-.err { color: #b91c1c; font-size: 0.9rem; }
-</style>

package/templates/flat/app/pages/index.vue

@@ -1,7 +0,0 @@
-<template>
-  <main class="wrap">
-    <h1>🌿 Fougère</h1>
-    <p>Your project is running.</p>
-    <p class="muted">Edit <code>entities/</code> and <code>handlers/</code> — they are scanned and projected automatically.</p>
-  </main>
-</template>

package/templates/flat/fougere.config.ts

@@ -1,7 +0,0 @@
-import type { FougereConfig } from '@fougere/core';
-
-export default {
-  // File-backed on purpose: your data must survive dev reloads and deploys.
-  // Lives under .data/ (gitignored) — the single writable-state dir.
-  db: { dialect: 'sqlite', path: '.data/app.db' },
-} satisfies FougereConfig;

package/templates/flat/nuxt.config.ts

@@ -1,4 +0,0 @@
-export default defineNuxtConfig({
-  modules: ['@fougere/nuxt'],
-  compatibilityDate: '2026-07-20',
-});