@fougere/cli 0.2.0-alpha.1 → 0.3.0-alpha.0

package/fronds/analysis/versions.ts

@@ -0,0 +1,58 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { SetDiff } from '@fougere/schema';
+
+/**
+ * Where a FROND keeps what its shapes used to be — beside `entities/`, not under a dot.
+ * Written by `fougere freeze`, replayed by `fougere migrate`.
+ */
+export const VERSIONS = 'versions';
+
+/** One cut version: its name, and the step that reached it — absent on the first. */
+export interface Version {
+  name: string;
+  step?: SetDiff & { previous?: string };
+}
+
+/**
+ * The versions a frond has cut, oldest first — read by FOLLOWING each step's `previous`.
+ *
+ * That link is the fact recorded the day the version was cut. Sorting directory names is
+ * a guess about the same fact, and a hotfix cut after a later version orders it wrong.
+ */
+export async function chainOf(frondPath: string): Promise<Version[]> {
+  const directory = join(frondPath, VERSIONS);
+  const found = await readdir(directory, { withFileTypes: true }).catch(() => []);
+  const names = found.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  if (names.length === 0) return [];
+
+  const steps = new Map<string, Version['step']>();
+  for (const name of names) {
+    const raw = await readFile(join(directory, name, 'from.json'), 'utf8').catch(() => undefined);
+    steps.set(name, raw ? (JSON.parse(raw) as Version['step']) : undefined);
+  }
+
+  const roots = names.filter((name) => steps.get(name)?.previous === undefined);
+  if (roots.length !== 1) {
+    const said = roots.length === 0 ? 'none starts it' : `${roots.join(', ')} each start one`;
+    throw new Error(`${directory}: a frond's versions are ONE line and ${said}.`);
+  }
+
+  const next = new Map<string, string>();
+  for (const [name, step] of steps) if (step?.previous !== undefined) next.set(step.previous, name);
+
+  const chain: Version[] = [];
+  const seen = new Set<string>();
+  for (let at: string | undefined = roots[0]; at !== undefined && !seen.has(at); at = next.get(at)) {
+    seen.add(at);
+    chain.push({ name: at, step: steps.get(at) });
+  }
+
+  // One check for every way the links fail to be a line: a fork (two versions claiming
+  // the same `previous`), a cycle, or a step naming a version that is not there.
+  const adrift = names.filter((name) => !seen.has(name));
+  if (adrift.length > 0) {
+    throw new Error(`${directory}: ${adrift.join(', ')} follow no version in the chain that starts at ${roots[0]}.`);
+  }
+  return chain;
+}

package/fronds/scaffold/entities/Grant.ts

@@ -0,0 +1,6 @@
+import { entity, text } from "@fougere/schema";
+
+/** `fougere grant <frond>` — vouch for one frond, so any receiver admits it. */
+export default class Grant extends entity({
+  frond: text({ min: 1, description: "Frond to vouch for" }),
+}) {}

package/fronds/scaffold/entities/Keys.ts

@@ -0,0 +1,4 @@
+import { entity } from "@fougere/schema";
+
+/** `fougere keys` — create the root this system's grants are signed by. Once. */
+export default class Keys extends entity({}) {}

package/fronds/scaffold/entities/Serve.ts

@@ -1,7 +1,8 @@
-import { entity, text, number, optional } from "@fougere/schema";
+import { entity, text, number, bool, optional } from "@fougere/schema";
 
 /** `fougere serve <frond>` — run one frond alone in its own process (JSON-RPC over HTTP). */
 export default class Serve extends entity({
   frond: text({ min: 1, description: "Frond to host in its own process" }),
   port: optional(number({ description: "Port to listen on (default 4100)" })),
+  watch: optional(bool({ description: "Rebuild the app when the frond changes" })),
 }) {}

package/fronds/scaffold/handlers/BuildFrondHandler.ts

@@ -1,10 +1,7 @@
 import { execSync } from 'node:child_process';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
 import { join, basename } from 'node:path';
-
-function capitalize(s: string): string {
-  return s[0].toUpperCase() + s.slice(1);
-}
+import { loadConfig, resolveConventions, frondPackage } from '@fougere/core/node';
 
 export default class BuildFrondHandler {
   // cwd is ambient in a CLI — not a DI service (the container resolves by type).
@@ -12,15 +9,16 @@ export default class BuildFrondHandler {
 
   /** Build a frond into a standalone deployable package. */
   async execute(input: { name: string }): Promise<{ path: string; entities: string[] }> {
-    const frondDir = join(this.cwd, 'fronds', input.name);
+    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
+    const frondDir = join(this.cwd, conventions.fronds, input.name);
 
     if (!existsSync(frondDir)) {
       throw new Error(`Frond '${input.name}' not found at ${frondDir}`);
     }
 
-    const entitiesDir = join(frondDir, 'entities');
+    const entitiesDir = join(frondDir, conventions.dirs.entities);
     if (!existsSync(entitiesDir)) {
-      throw new Error(`No entities/ directory in frond '${input.name}'`);
+      throw new Error(`No ${conventions.dirs.entities}/ directory in frond '${input.name}'`);
     }
 
     // Discover entity files
@@ -36,7 +34,7 @@ export default class BuildFrondHandler {
 
     // Generate barrel index.ts
     const indexLines = entityNames.map(
-      (name) => `export { default as ${name} } from './entities/${name}.js';`,
+      (name) => `export { default as ${name} } from './${conventions.dirs.entities}/${name}.js';`,
     );
     writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
 
@@ -53,7 +51,7 @@ export default class BuildFrondHandler {
         esModuleInterop: true,
         skipLibCheck: true,
       },
-      include: ['index.ts', 'entities/**/*.ts'],
+      include: ['index.ts', `${conventions.dirs.entities}/**/*.ts`],
     };
 
     const tsconfigPath = join(frondDir, 'tsconfig.build.json');
@@ -69,16 +67,16 @@ export default class BuildFrondHandler {
     const pkgPath = join(frondDir, 'package.json');
     const pkg = existsSync(pkgPath)
       ? JSON.parse(readFileSync(pkgPath, 'utf-8'))
-      : { name: `@frond/${input.name}`, version: '0.0.1', type: 'module' };
+      : { name: frondPackage(input.name, conventions), version: '0.0.1', type: 'module' };
 
     pkg.exports = {
       '.': {
         types: './dist/index.d.ts',
         default: './dist/index.js',
       },
-      './entities/*': {
-        types: './dist/entities/*.d.ts',
-        default: './dist/entities/*.js',
+      [`./${conventions.dirs.entities}/*`]: {
+        types: `./dist/${conventions.dirs.entities}/*.d.ts`,
+        default: `./dist/${conventions.dirs.entities}/*.js`,
       },
       './package.json': './package.json',
     };

package/fronds/scaffold/handlers/GrantHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The work lives in app/commands/GrantCommand (it prints secrets). This handler
+ * exists only so the runner registers the `grant` subcommand.
+ */
+export default class GrantHandler {
+  /** Bind a frond's name to a fresh key, signed by the root. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/KeysHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The work lives in app/commands/KeysCommand (it writes the root key). This
+ * handler exists only so the runner registers the `keys` subcommand.
+ */
+export default class KeysHandler {
+  /** Create the root key a split deployment's grants are signed by. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/SyncHandler.ts

@@ -4,7 +4,10 @@ import { entitySourceOf, facadeTypeSourceOf, type SchemaDescriptor } from '@foug
 // The card's shape is declared once, in core, and imported here. A private copy of it
 // lived in this file and went stale the day an op stopped being a bare name: nothing
 // compared the copy to the original, so the drift cost nothing until someone read it.
-import type { IdentityCard } from '@fougere/core';
+import { assertIdentityCard, type IdentityCard } from '@fougere/core';
+import {
+  type Conventions, loadConfig, resolveConventions, frondPackage,
+} from '@fougere/core/node';
 
 function assertSafeName(kind: string, name: string): void {
   if (typeof name !== 'string' || !/^[A-Za-z_$][A-Za-z0-9_$-]*$/.test(name)) {
@@ -67,18 +70,12 @@ function assertEntry(kind: string, frondName: string, entry: { name: string; sch
 }
 
 function identityCardOf(value: unknown): IdentityCard {
-  if (!value || typeof value !== 'object' || !Array.isArray((value as IdentityCard).fronds)) {
-    throw new Error('Remote rpc.discover returned an invalid identity card');
-  }
-  const card = value as IdentityCard;
+  // The card's own shape is judged by the package that declares it — `fronds`, and each
+  // frond's `doors`. What stays here is what only a writer of files needs: a name safe to
+  // become one, and the descriptor a class is generated from.
+  const card = assertIdentityCard(value, 'Remote rpc.discover');
   for (const frond of card.fronds) {
-    if (!frond || typeof frond !== 'object') {
-      throw new Error('Remote rpc.discover returned an invalid frond entry');
-    }
     assertSafeName('frond', frond.name);
-    if (!Array.isArray(frond.doors)) {
-      throw new Error(`Remote frond '${frond.name}' has no valid doors array`);
-    }
     // Absent rather than empty is tolerated: a host older than the fact list says nothing
     // about facts, and refusing it would break sync against every previous version for a
     // feature the consumer may not use.
@@ -129,9 +126,15 @@ export default class SyncHandler {
       throw new Error(`Frond '${input.name}' not found on ${baseUrl}. Available: ${card.fronds.map((f) => f.name).join(', ')}`);
     }
 
+    // The consumer's own convention: a synced frond is laid out like the ones they wrote,
+    // and the export map below is what makes `@fronds/<name>/<dir>/X.js` resolve.
+    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
+    const entities = conventions.dirs.entities;
+    const handlers = conventions.dirs.handlers;
+
     const frondDir = join(this.cwd, '.fougere', 'remotes', input.name);
-    const entitiesDir = join(frondDir, 'entities');
-    const handlersDir = join(frondDir, 'handlers');
+    const entitiesDir = join(frondDir, entities);
+    const handlersDir = join(frondDir, handlers);
     mkdirSync(entitiesDir, { recursive: true });
     mkdirSync(handlersDir, { recursive: true });
 
@@ -229,21 +232,21 @@ export default class SyncHandler {
     // One binding carries the value AND the type, because a class is both — the pair of
     // re-exports that stood here was the price of declaring them separately.
     const indexLines = [...generated].flatMap(([name, { row, door }]) => [
-      ...(row ? [`export { default as ${name} } from './entities/${name}.js';`] : []),
-      ...(door ? [`export type { ${name}Handler } from './handlers/${name}Handler.js';`] : []),
+      ...(row ? [`export { default as ${name} } from './${entities}/${name}.js';`] : []),
+      ...(door ? [`export type { ${name}Handler } from './${handlers}/${name}Handler.js';`] : []),
     ]);
     writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
 
     // Package.json
     writeFileSync(join(frondDir, 'package.json'), JSON.stringify({
-      name: `@frond/${input.name}`,
+      name: frondPackage(input.name, conventions),
       version: '0.0.0-synced',
       type: 'module',
       fougere: { frond: input.name, synced: true, source: baseUrl },
       exports: {
         '.': './index.ts',
-        './entities/*': './entities/*.ts',
-        './handlers/*': './handlers/*.ts',
+        [`./${entities}/*`]: `./${entities}/*.ts`,
+        [`./${handlers}/*`]: `./${handlers}/*.ts`,
         './package.json': './package.json',
       },
     }, null, 2) + '\n');
@@ -252,14 +255,14 @@ export default class SyncHandler {
     this.updateRemotesRegistry(input.name, baseUrl, frondDir);
 
     // Update tsconfig paths if tsconfig.json exists (non-Nuxt projects)
-    this.updateTsconfigPaths(input.name, frondDir);
+    this.updateTsconfigPaths(input.name, frondDir, conventions);
 
     /**
      * What the host no longer serves stops being importable here.
      *
      * The barrel is rewritten every run, so a dropped entity loses its export on its own
      * — but the FILE stayed, and the generated `package.json` exports `'./entities/*'` as
-     * a wildcard, so `@frond/blog/entities/Ticket.js` kept resolving to a class nothing
+     * a wildcard, so `@fronds/blog/entities/Ticket.js` kept resolving to a class nothing
      * behind it answers for. The consumer compiles, its local judge accepts, and the call
      * comes back NOT_FOUND at the door — or never leaves, because the page dropped the
      * call and kept the type.
@@ -304,8 +307,8 @@ export default class SyncHandler {
     writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n');
   }
 
-  /** Add @frond/{name} to tsconfig paths if tsconfig.json exists. */
-  private updateTsconfigPaths(name: string, localPath: string): void {
+  /** Add the frond's scoped name to tsconfig paths if tsconfig.json exists. */
+  private updateTsconfigPaths(name: string, localPath: string, conventions: Conventions): void {
     const tsconfigPath = join(this.cwd, 'tsconfig.json');
     if (!existsSync(tsconfigPath)) return;
 
@@ -320,8 +323,8 @@ export default class SyncHandler {
       tsconfig.compilerOptions.paths ??= {};
 
       const relative = localPath.replace(this.cwd, '.').replace(/\\/g, '/');
-      tsconfig.compilerOptions.paths[`@frond/${name}`] = [`${relative}/index.ts`];
-      tsconfig.compilerOptions.paths[`@frond/${name}/*`] = [`${relative}/*`];
+      tsconfig.compilerOptions.paths[frondPackage(name, conventions)] = [`${relative}/index.ts`];
+      tsconfig.compilerOptions.paths[`${frondPackage(name, conventions)}/*`] = [`${relative}/*`];
 
       writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n');
     } catch { /* tsconfig parse error — skip */ }

package/fronds/scaffold/services/ProjectWriter.ts

@@ -1,6 +1,24 @@
 import { cpSync, existsSync, renameSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { type Conventions, DEFAULT_CONVENTIONS, frondPackage } from '@fougere/core/node';
+
+/**
+ * The monorepo's `packages/`, found by its workspace marker rather than counted
+ * in `..` from this file. Counting encoded how deep the CLI itself sat, so the
+ * day `cli/` moved into a family, `--local` linked four packages instead of
+ * twenty-one — silently, because the scan below simply found less.
+ *
+ * Returns undefined outside the monorepo, which is every installed copy.
+ */
+function monorepoPackages(): string | undefined {
+  let d = fileURLToPath(new URL('.', import.meta.url));
+  while (d !== dirname(d)) {
+    if (existsSync(join(d, 'pnpm-workspace.yaml'))) return join(d, 'packages');
+    d = dirname(d);
+  }
+  return undefined;
+}
 
 /**
  * Scaffolds from real template files (create-vite pattern: stdlib copy, no
@@ -50,7 +68,7 @@ export default class ProjectWriter {
 
   /**
    * Put a frond template's directories at the project root. Only the directories: at the
-   * root the app's own `package.json` is the frond's, and `@frond/<name>` comes from the
+   * root the app's own `package.json` is the frond's, and `@fronds/<name>` comes from the
    * directory through the Nuxt module's alias, so the template's package would only
    * duplicate it under a second name.
    */
@@ -64,8 +82,8 @@ export default class ProjectWriter {
   }
 
   /** Add a frond (business hexagon) under fronds/<name>. */
-  addFrond(wsDir: string, template: string, name: string): { path: string } {
-    const dest = join(wsDir, 'fronds', name);
+  addFrond(wsDir: string, template: string, name: string, conventions: Conventions = DEFAULT_CONVENTIONS): { path: string } {
+    const dest = join(wsDir, conventions.fronds, name);
     cpSync(join(TEMPLATES, 'fronds', template), dest, { recursive: true });
     // Only the import name. Carrying the convention is what makes a frond — the scan
     // reads directories. `fougere.frond` IS read now (`scanner.ts`, `frondNameOf`), but
@@ -73,7 +91,7 @@ export default class ProjectWriter {
     const pkgPath = join(dest, 'package.json');
     if (existsSync(pkgPath)) {
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name: string };
-      pkg.name = `@frond/${name}`;
+      pkg.name = frondPackage(name, conventions);
       writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
     }
     return { path: dest };
@@ -102,11 +120,11 @@ export default class ProjectWriter {
    * A template cannot carry it: the frond is named at composition time (`blog:catalog`),
    * so a dependency written into `templates/apps/nuxt` would name the template instead
    * and resolve to nothing. Which is what happened — the generated app imported
-   * `@frond/blog` whatever you had called it, and did not start.
+   * `@fronds/blog` whatever you had called it, and did not start.
    *
    * `fronds/` and `apps/` are the registry, like `listTemplates`: nothing to declare.
    */
-  linkFronds(wsDir: string): void {
+  linkFronds(wsDir: string, conventions: Conventions = DEFAULT_CONVENTIONS): void {
     const dirs = (kind: string): string[] => {
       const dir = join(wsDir, kind);
       if (!existsSync(dir)) return [];
@@ -114,7 +132,7 @@ export default class ProjectWriter {
       return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
     };
 
-    const fronds = dirs('fronds');
+    const fronds = dirs(conventions.fronds);
     if (fronds.length === 0) return;
 
     for (const app of dirs('apps')) {
@@ -123,7 +141,7 @@ export default class ProjectWriter {
 
       const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { dependencies?: Record<string, string> };
       pkg.dependencies ??= {};
-      for (const frond of fronds) pkg.dependencies[`@frond/${frond}`] = 'workspace:*';
+      for (const frond of fronds) pkg.dependencies[frondPackage(frond, conventions)] = 'workspace:*';
       writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
     }
   }
@@ -134,7 +152,8 @@ export default class ProjectWriter {
    * packages aren't on npm yet). No-op once the packages are published.
    */
   linkLocal(wsDir: string): void {
-    const packages = fileURLToPath(new URL('../../../../', import.meta.url));
+    const packages = monorepoPackages();
+    if (!packages) return;
     // Read off the monorepo rather than listed here: a hand-kept map knew the seven
     // packages the default templates use, so the first step beyond the default — a
     // GraphQL surface, auth — added a dependency it had never heard of, which stayed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fougere/cli",
-  "version": "0.2.0-alpha.1",
+  "version": "0.3.0-alpha.0",
   "description": "The Fougere CLI — compose a workspace, serve a frond, call an operation.",
   "keywords": [
     "fougere",
@@ -35,15 +35,17 @@
     "templates"
   ],
   "dependencies": {
+    "@clack/prompts": "^0.10.0",
     "citty": "^0.2.1",
+    "consola": "^3.4.2",
     "jiti": "^2.4.2",
     "picocolors": "^1.1.1",
-    "@fougere/cli-ui": "0.2.0-alpha.1",
-    "@fougere/runtime": "0.2.0-alpha.1",
-    "@fougere/core": "0.2.0-alpha.1",
-    "@fougere/schema": "0.2.0-alpha.1",
-    "@fougere/container": "0.2.0-alpha.1",
-    "@fougere/transport-http": "0.2.0-alpha.1"
+    "@fougere/container": "0.3.0-alpha.0",
+    "@fougere/schema": "0.3.0-alpha.0",
+    "@fougere/adapter-sql": "0.3.0-alpha.0",
+    "@fougere/transport-http": "0.3.0-alpha.0",
+    "@fougere/core": "0.3.0-alpha.0",
+    "@fougere/defaults": "0.3.0-alpha.0"
   },
   "devDependencies": {
     "vitest": "^4.1.0"
@@ -52,7 +54,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && chmod +x dist/bin.js",
+    "build": "rm -rf dist && tsc && chmod +x dist/bin.js && node dist/bin.js build",
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit && tsc -p tsconfig.runtime.json && tsc -p tsconfig.templates.json"

package/templates/admin/fronds/admin/handlers/UserHandler.ts

@@ -13,7 +13,7 @@ export default class UserHandler extends Crud(User) {
     if (!user) {
       throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `User '${id}' not found`, entity: 'user', operation: 'deactivate' });
     }
-    if ((user as { status?: string }).status === 'inactive') {
+    if (user.status === 'inactive') {
       throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already inactive', entity: 'user', operation: 'deactivate' });
     }
     return this.orm.update(id, { status: 'inactive' });
@@ -21,9 +21,7 @@ export default class UserHandler extends Crud(User) {
 
   /** Active users, projected to the card contract. */
   async active(): Promise<UserCard[]> {
-    const all = await this.orm.list();
-    return all
-      .filter((u) => (u as { status?: string }).status === 'active')
-      .map((u) => ({ id: String(u.id), name: String(u.name), status: 'active' })) as UserCard[];
+    const users = await this.orm.list({ where: { status: 'active' } });
+    return users.map(({ id, name, status }) => ({ id, name, status }));
   }
 }

package/templates/admin/fronds/admin/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/admin",
+  "name": "@fronds/admin",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/api/fronds/api/handlers/TaskHandler.ts

@@ -13,7 +13,7 @@ export default class TaskHandler extends Crud(Task) {
     if (!task) {
       throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `Task '${id}' not found`, entity: 'task', operation: 'complete' });
     }
-    if ((task as { status?: string }).status === 'done') {
+    if (task.status === 'done') {
       throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already done', entity: 'task', operation: 'complete' });
     }
     return this.orm.update(id, { status: 'done' });
@@ -21,9 +21,7 @@ export default class TaskHandler extends Crud(Task) {
 
   /** Still-open tasks, projected to the card contract. */
   async open(): Promise<TaskCard[]> {
-    const all = await this.orm.list();
-    return all
-      .filter((t) => (t as { status?: string }).status === 'open')
-      .map((t) => ({ id: String(t.id), title: String(t.title), status: 'open' })) as TaskCard[];
+    const tasks = await this.orm.list({ where: { status: 'open' } });
+    return tasks.map(({ id, title, status }) => ({ id, title, status }));
   }
 }

package/templates/api/fronds/api/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/api",
+  "name": "@fronds/api",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/apps/nuxt/app/pages/index.vue

@@ -3,7 +3,7 @@
 // They take an ENTITY, so this page names none: what is composed here is yours, and a
 // scaffold that guessed at an entity shipped a page that could not run.
 //
-//   import Post from '@frond/<your-frond>/entities/Post'
+//   import Post from '@fronds/<your-frond>/entities/Post'
 //   const { items, loading } = await useQuery(Post, 'list')
 //   const { values, errors, submit } = useFormFor(Post)
 //   const { execute } = useCommand(Post, 'publish')

package/templates/apps/nuxt/package.json

@@ -10,7 +10,7 @@
     "@fougere/core": "latest",
     "@fougere/nuxt": "latest",
     "@fougere/schema": "latest",
-    "@fougere/runtime": "latest",
+    "@fougere/defaults": "latest",
     "better-sqlite3": "^13.0.3",
     "kysely": "^0.28.17",
     "nuxt": "^4.5.1",

package/templates/blog/app/pages/posts/index.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import Post from '@frond/blog/entities/Post';
+import Post from '@fronds/blog/entities/Post';
 
 interface Card { id: string; title: string; status: string }
 const { items: posts, loading, error } = await useQuery<Card>(Post, 'published');

package/templates/blog/app/pages/posts/manage.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import Post from '@frond/blog/entities/Post';
+import Post from '@fronds/blog/entities/Post';
 
 interface Row { id: string; title: string; status: 'draft' | 'published' }
 const { items: posts, loading } = await useQuery<Row>(Post, 'list');

package/templates/blog/app/pages/posts/new.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import Post from '@frond/blog/entities/Post';
+import Post from '@fronds/blog/entities/Post';
 
 const { values, errors, submit, loading, error } = useFormFor(Post);
 

package/templates/blog/fronds/blog/handlers/PostHandler.ts

@@ -19,7 +19,7 @@ export default class PostHandler extends Crud(Post) {
     if (!post) {
       throw new FougereError({ code: ErrorCode.NOT_FOUND, message: `Post '${id}' not found`, entity: 'post', operation: 'publish' });
     }
-    if ((post as { status?: string }).status === 'published') {
+    if (post.status === 'published') {
       throw new FougereError({ code: ErrorCode.CONFLICT, message: 'Already published', entity: 'post', operation: 'publish' });
     }
     return this.orm.update(id, { status: 'published' });
@@ -27,9 +27,7 @@ export default class PostHandler extends Crud(Post) {
 
   /** Only published posts exist for the outside world, projected to the card. */
   async published(): Promise<PostCard[]> {
-    const all = await this.orm.list();
-    return all
-      .filter((p) => (p as { status?: string }).status === 'published')
-      .map((p) => ({ id: String(p.id), title: String(p.title), status: 'published' })) as PostCard[];
+    const posts = await this.orm.list({ where: { status: 'published' } });
+    return posts.map(({ id, title, status }) => ({ id, title, status }));
   }
 }

package/templates/blog/fronds/blog/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@frond/blog",
+  "name": "@fronds/blog",
   "version": "0.0.1",
   "type": "module",
   "exports": {

package/templates/flat/AGENTS.md

@@ -0,0 +1,14 @@
+# 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

@@ -35,8 +35,8 @@ Before adding a surface, reach for its **projection**:
 
 | surface | the call |
 |---|---|
-| REST | `generateRoutes(app)` then `registerRoutes(router, routes)` — `@fougere/schema-rest` |
-| GraphQL | `registerAll(builder, app)` then `registerGraphQL(router, builder.toSchema())` — `@fougere/schema-graphql` |
+| 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 judge on the way. `registerType` / `registerOperations`
@@ -44,7 +44,18 @@ exist to add what a projection cannot derive — never to replace it.
 
 ## Reading data
 
-`EntityOrm`, injected by type, is the only data access:
+Storage is reached through a repository. Never inject `EntityOrm` 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.orm` 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
@@ -56,10 +67,21 @@ 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
-npx tsc -p tsconfig.frond.json    # the compiler — free, immediate, and it catches most of it
+fougere check
+pnpm typecheck
 ```
 
-Run it. It is the first judge, and the cheapest.
+`fougere check` is the Fougere model barrier; tests and TypeScript come after it passes.

package/templates/flat/package.json

@@ -12,7 +12,7 @@
     "@fougere/core": "latest",
     "@fougere/nuxt": "latest",
     "@fougere/schema": "latest",
-    "@fougere/runtime": "latest",
+    "@fougere/defaults": "latest",
     "better-sqlite3": "^13.0.3",
     "kysely": "^0.28.17",
     "nuxt": "^4.5.1",