@fougere/cli 0.2.0-alpha.2 → 0.4.0-alpha.0

package/fronds/analysis/services/ProjectScan.ts

@@ -1,4 +1,7 @@
-import { scanProject, frondAliases, setModuleLoader, type ScanResult } from '@fougere/core';
+import { type FougereConfig, type ScanResult } from '@fougere/core';
+import {
+  scanProject, frondAliases, setModuleLoader, loadConfig, resolveConventions,
+} from '@fougere/core/node';
 import { resolve } from 'node:path';
 
 /**
@@ -18,18 +21,31 @@ export default class ProjectScan {
   private cwd = process.cwd();
 
   /** Scan the project at `root`, relative to where the command was invoked. */
-  async at(root?: string): Promise<ScanResult & { root: string }> {
+  async at(root?: string): Promise<ScanResult & { root: string; config: FougereConfig }> {
     const target = resolve(this.cwd, root || '.');
 
     // The scan reads `.ts` sources; the default loader is a plain `import`, which
     // cannot. Installed once per call because the loader is module-global — the
     // CLI's own app was loaded with its own, and this replaces it for the target.
     const { createJiti } = await import('jiti');
-    // `@frond/<name>` is the framework's own convention; the loader has to know it,
-    // or a frond naming its neighbour is unreadable to the very tool that checks it.
-    const jiti = createJiti(import.meta.url, { interopDefault: true, alias: await frondAliases(target) });
-    setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
+    const install = (alias?: Record<string, string>): void => {
+      const jiti = createJiti(import.meta.url, { interopDefault: true, ...(alias ? { alias } : {}) });
+      setModuleLoader((filePath) => jiti.import(filePath) as Promise<Record<string, unknown>>);
+    };
 
-    return { root: target, ...(await scanProject(target)) };
+    /**
+     * The config is read BEFORE the aliases, because it names the scope they are built
+     * from. Safe because nothing in `fougere.config.ts` may import `@fronds/*` — the one
+     * import that would need the name to read the file that declares it.
+     */
+    install();
+    const config = await loadConfig(target);
+    const conventions = resolveConventions(config.conventions);
+
+    // The scope is the framework's own convention; the loader has to know it, or a frond
+    // naming its neighbour is unreadable to the very tool that checks it.
+    install(await frondAliases(target, conventions));
+
+    return { root: target, config, ...(await scanProject(target, undefined, conventions)) };
   }
 }

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/BuildFrond.ts

@@ -1,5 +1,5 @@
 import { entity, text } from '@fougere/schema';
 
 export default class BuildFrond extends entity({
-  name: text({ description: 'Frond name to build (e.g. blog)' }),
+  frond: text({ description: 'Frond name to build (e.g. blog)' }),
 }) {}

package/fronds/scaffold/entities/Call.ts

@@ -2,5 +2,5 @@ import { entity, text } from "@fougere/schema";
 
 /** `fougere call <entity>.<op> [--field value …]` — invoke one operation, print the result. */
 export default class Call extends entity({
-  target: text({ min: 1, description: "entity.op to invoke (e.g. post.create)" }),
+  operation: text({ min: 1, description: "entity.op to invoke (e.g. post.create)" }),
 }) {}

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/entities/Sync.ts

@@ -1,6 +1,6 @@
 import { entity, text } from '@fougere/schema';
 
 export default class Sync extends entity({
-  name: text({ description: 'Frond name to sync (e.g. blog)' }),
+  frond: text({ description: 'Frond name to sync (e.g. blog)' }),
   from: text({ description: 'Remote URL (e.g. http://blog-service:3000)' }),
 }) {}

package/fronds/scaffold/handlers/BuildFrondHandler.ts

@@ -1,26 +1,24 @@
 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).
   private cwd = process.cwd();
 
   /** 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);
+  async execute(input: { frond: string }): Promise<{ path: string; entities: string[] }> {
+    const conventions = resolveConventions((await loadConfig(this.cwd)).conventions);
+    const frondDir = join(this.cwd, conventions.fronds, input.frond);
 
     if (!existsSync(frondDir)) {
-      throw new Error(`Frond '${input.name}' not found at ${frondDir}`);
+      throw new Error(`Frond '${input.frond}' 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.frond}'`);
     }
 
     // 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.frond, 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

@@ -1,10 +1,13 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
-import { entitySourceOf, facadeTypeSourceOf, type SchemaDescriptor } from '@fougere/schema';
+import { upperFirst, EntityTypeSource, FacadeTypeSource, type SchemaDescriptor } from '@fougere/schema';
 // 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)) {
@@ -23,7 +26,7 @@ export function entityClassName(name: string): string {
   const identifier = name
     .split('-')
     .filter(Boolean)
-    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .map(upperFirst)
     .join('');
   if (!/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(identifier)) {
     throw new Error(`Entity name '${name}' cannot be represented as a TypeScript identifier`);
@@ -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.
@@ -96,8 +93,8 @@ export default class SyncHandler {
   private cwd = process.cwd();
 
   /** Mirror a remote frond's contract into local entities. */
-  async execute(input: { name: string; from: string }): Promise<{ path: string; entities: string[]; removed: string[] }> {
-    assertSafeName('frond', input.name);
+  async execute(input: { frond: string; from: string }): Promise<{ path: string; entities: string[]; removed: string[] }> {
+    assertSafeName('frond', input.frond);
     let remoteUrl: URL;
     try {
       remoteUrl = new URL(input.from);
@@ -124,14 +121,20 @@ export default class SyncHandler {
     if (rpc.error) throw new Error(`Remote error: ${rpc.error.message}`);
     const card = identityCardOf(rpc.result);
 
-    const target = card.fronds.find((f) => f.name === input.name);
+    const target = card.fronds.find((f) => f.name === input.frond);
     if (!target) {
-      throw new Error(`Frond '${input.name}' not found on ${baseUrl}. Available: ${card.fronds.map((f) => f.name).join(', ')}`);
+      throw new Error(`Frond '${input.frond}' not found on ${baseUrl}. Available: ${card.fronds.map((f) => f.name).join(', ')}`);
     }
 
-    const frondDir = join(this.cwd, '.fougere', 'remotes', input.name);
-    const entitiesDir = join(frondDir, 'entities');
-    const handlersDir = join(frondDir, 'handlers');
+    // 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.frond);
+    const entitiesDir = join(frondDir, entities);
+    const handlersDir = join(frondDir, handlers);
     mkdirSync(entitiesDir, { recursive: true });
     mkdirSync(handlersDir, { recursive: true });
 
@@ -155,7 +158,7 @@ export default class SyncHandler {
     /**
      * One card, one class.
      *
-     * `reconstruct` gives the JUDGE — validate, from, getFields — and now takes the
+     * `Card.toSchema` gives the JUDGE — validate, from, getFields — and now takes the
      * row shape as a type argument, so the same declaration gives the TYPE. Both
      * come off the same card: nothing to keep in step, and the file a consumer reads
      * has the shape of the one they would have written by hand
@@ -164,10 +167,10 @@ export default class SyncHandler {
     const writeRow = (className: string, descriptor: SchemaDescriptor): void => {
       written.add(join(entitiesDir, `${className}.ts`));
       writeFileSync(join(entitiesDir, `${className}.ts`), [
-        `import { reconstruct } from '@fougere/schema';`,
+        `import { Card } from '@fougere/schema';`,
         ``,
         `// Generated by \`fougere sync\` from ${baseUrl} — do not edit.`,
-        entitySourceOf(descriptor, { name: className }),
+        EntityTypeSource.of(descriptor).render({ name: className }),
         ``,
         `export default ${className};`,
         ``,
@@ -200,7 +203,7 @@ export default class SyncHandler {
         `// contract, and a contract that drags a runtime dependency is not one.`,
         `type Invocation = { params?: Record<string, string>; query?: Record<string, unknown>; body?: unknown; state?: Record<string, unknown> };`,
         ``,
-        facadeTypeSourceOf(ops ?? [], {
+        FacadeTypeSource.of(ops ?? []).render({
           name: `${className}Handler`,
           ...(descriptor !== undefined ? { rowType: className } : {}),
         }),
@@ -229,37 +232,37 @@ 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.frond, conventions),
       version: '0.0.0-synced',
       type: 'module',
-      fougere: { frond: input.name, synced: true, source: baseUrl },
+      fougere: { frond: input.frond, 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');
 
     // Update .fougere/remotes.json — central registry of synced remotes
-    this.updateRemotesRegistry(input.name, baseUrl, frondDir);
+    this.updateRemotesRegistry(input.frond, baseUrl, frondDir);
 
     // Update tsconfig paths if tsconfig.json exists (non-Nuxt projects)
-    this.updateTsconfigPaths(input.name, frondDir);
+    this.updateTsconfigPaths(input.frond, 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,7 @@
 import { cpSync, existsSync, renameSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
 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
@@ -67,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.
    */
@@ -81,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
@@ -90,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 };
@@ -119,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 [];
@@ -131,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')) {
@@ -140,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');
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fougere/cli",
-  "version": "0.2.0-alpha.2",
+  "version": "0.4.0-alpha.0",
   "description": "The Fougere CLI — compose a workspace, serve a frond, call an operation.",
   "keywords": [
     "fougere",
@@ -32,7 +32,8 @@
     "dist",
     "app",
     "fronds",
-    "templates"
+    "templates",
+    "src"
   ],
   "dependencies": {
     "@clack/prompts": "^0.10.0",
@@ -40,11 +41,12 @@
     "consola": "^3.4.2",
     "jiti": "^2.4.2",
     "picocolors": "^1.1.1",
-    "@fougere/schema": "0.2.0-alpha.2",
-    "@fougere/container": "0.2.0-alpha.2",
-    "@fougere/core": "0.2.0-alpha.2",
-    "@fougere/defaults": "0.2.0-alpha.2",
-    "@fougere/transport-http": "0.2.0-alpha.2"
+    "@fougere/adapter-sql": "0.4.0-alpha.0",
+    "@fougere/defaults": "0.4.0-alpha.0",
+    "@fougere/transport-http": "0.4.0-alpha.0",
+    "@fougere/core": "0.4.0-alpha.0",
+    "@fougere/schema": "0.4.0-alpha.0",
+    "@fougere/container": "0.4.0-alpha.0"
   },
   "devDependencies": {
     "vitest": "^4.1.0"
@@ -53,7 +55,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/src/bin.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * fougere CLI — a Fougere app powered by citty.
+ *
+ * src/   → compiled (tsc → dist/)
+ * fronds/ → loaded at runtime by jiti (domain)
+ * app/   → loaded at runtime by jiti (presentation)
+ */
+import { createApp, setLogLevel, envLevel, type ScanResult } from '@fougere/core';
+import { scanProject, getModuleLoader, frondDirsOf, DEFAULT_CONVENTIONS } from '@fougere/core/node';
+import { readdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createContainer } from '@fougere/container';
+import { ui } from './ui.js';
+import { run } from './runner.js';
+import { installLoader } from './loader.js';
+
+await installLoader(process.cwd());
+
+const cliRoot = new URL('..', import.meta.url).pathname;
+const container = createContainer();
+const terminal = ui();
+container.registerValue('ui', terminal);
+container.registerValue('cwd', process.cwd());
+
+// The CLI is a Fougere app — silence its boot chatter unless explicitly asked. The
+// threshold is SET, not only announced: a static import evaluates the logger module,
+// its env read included, before this line runs.
+process.env.FOUGERE_LOG_LEVEL ??= 'warn';
+setLogLevel(envLevel() ?? 'warn');
+
+/** The newest declaration under `fronds/`, or 0 when there is none to compare against. */
+async function newestDeclaration(root: string): Promise<number> {
+  const frondsDir = join(root, DEFAULT_CONVENTIONS.fronds);
+  const names = await readdir(frondsDir, { withFileTypes: true }).catch(() => []);
+  const dirs = names.filter((entry) => entry.isDirectory())
+    .flatMap((entry) => [
+      join(frondsDir, entry.name),
+      ...frondDirsOf(DEFAULT_CONVENTIONS).map((dir) => join(frondsDir, entry.name, dir)),
+    ]);
+
+  const times = await Promise.all(dirs.map(async (dir) => {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const stats = await Promise.all(entries
+      .filter((entry) => entry.isFile() && entry.name.endsWith('.ts'))
+      .map((entry) => stat(join(dir, entry.name)).then((s) => s.mtimeMs).catch(() => 0)));
+    return Math.max(0, ...stats);
+  }));
+  return Math.max(0, ...times);
+}
+
+/**
+ * The CLI is a Fougere app, so it reads its own written-down scan like any deployment —
+ * producing the description reads the project, consuming it does not.
+ *
+ * Reading its own 44 declarations through the compiler cost 617 ms on every invocation,
+ * for a domain fixed at publish time. Staleness is decided by mtime rather than by a flag:
+ * editing a frond must not need a command, and a published package has nothing newer than
+ * its artefact.
+ */
+async function scanOf(root: string): Promise<ScanResult> {
+  const written = join(root, '.fougere/scan.generated.ts');
+  const writtenAt = await stat(written).then((s) => s.mtimeMs).catch(() => 0);
+  if (writtenAt > 0 && writtenAt >= await newestDeclaration(root)) {
+    return ((await getModuleLoader()(written)) as unknown as { scan: ScanResult }).scan;
+  }
+
+  // The only slow phase, and it announced nothing: the boot states it at `info`, which the
+  // threshold above lowers to `warn`. The terminal says it instead, and a pipe keeps its
+  // output parsable.
+  const spin = process.stdout.isTTY ? terminal.spinner('reading fronds') : undefined;
+  const scan = await scanProject(root);
+  spin?.stop(`${scan.fronds.length} frond(s)`);
+  return scan;
+}
+
+const scan = await scanOf(cliRoot);
+
+const app = await createApp({ scan, createContainer: () => container });
+
+container.registerValue('app', app);
+
+await run(app);