@fougere/cli 0.1.0-alpha.0

package/dist/index.js

@@ -0,0 +1,4 @@
+export { run } from './runner.js';
+export { entityToArgs } from './bridge.js';
+export { generateZshCompletion, generateBashCompletion } from './completion.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/runner.d.ts

@@ -0,0 +1,12 @@
+/**
+ * CLI runner — scans frond entities for flags, looks for app commands
+ * for presentation, dispatches via citty.
+ *
+ * Architecture:
+ * - fronds/  → entities (flags) + handlers (domain logic)
+ * - app/     → commands (prompts, TUI, presentation)
+ * - src/     → runner + bridge (framework)
+ */
+import type { App } from '@fougere/core';
+export declare function run(app: App): Promise<void>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,eAAe,CAAC;AA2CzC,wBAAsB,GAAG,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAsFjD"}

package/dist/runner.js

@@ -0,0 +1,113 @@
+import { createAppRunner } from '@fougere/core';
+import { toRegistrationName } from '@fougere/core/contract';
+import { defineCommand, runMain } from 'citty';
+import { ui } from '@fougere/cli-ui';
+import { entityToArgs } from './bridge.js';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+function toKebab(name) {
+    return name.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase()).replace(/^-/, '');
+}
+function capitalize(name) {
+    return name.charAt(0).toUpperCase() + name.slice(1);
+}
+function toCamel(kebab) {
+    return kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+/** Scan app/commands/ for command classes. */
+async function loadAppCommands(cliRoot, loader) {
+    const map = new Map();
+    const dir = join(cliRoot, '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;
+}
+export async function run(app) {
+    const terminal = ui();
+    const cliRoot = new URL('..', import.meta.url).pathname;
+    // Load app commands (presentation layer)
+    const { createJiti } = await import('jiti');
+    const jiti = createJiti(import.meta.url, { interopDefault: true });
+    const loader = (path) => jiti.import(path);
+    const appCommands = await loadAppCommands(cliRoot, loader);
+    const subCommands = {};
+    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;
+            try {
+                handler = app.resolve(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 door (`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 }) => {
+                    if (cmdName !== 'completion')
+                        terminal.intro();
+                    // citty adds `_` (raw positionals) and `--` (passthrough); strip them
+                    // so only the entity's own fields reach the handler.
+                    const input = { ...parsed };
+                    delete input._;
+                    delete input['--'];
+                    try {
+                        if (AppCommand) {
+                            const cmd = new AppCommand(app, terminal);
+                            await cmd.run(input);
+                        }
+                        else {
+                            // Ride the call contract — the same envelope every consumer uses.
+                            await createAppRunner(app)({ entity: toRegistrationName(entity.name), op: 'execute' }, { params: {}, query: {}, body: input, state: {} });
+                        }
+                    }
+                    catch (err) {
+                        terminal.error(err instanceof Error ? err.message : String(err));
+                        process.exit(1);
+                    }
+                },
+            });
+        }
+    }
+    const main = defineCommand({
+        meta: { name: 'fougere', description: 'Fougere CLI' },
+        subCommands,
+    });
+    await runMain(main);
+}
+//# sourceMappingURL=runner.js.map

package/dist/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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"}

package/fronds/analysis/entities/Check.ts

@@ -0,0 +1,5 @@
+import { entity, text } from '@fougere/schema';
+
+export default class Check extends entity({
+  root: text({ description: 'Project root directory (default: cwd)' }),
+}) {}

package/fronds/analysis/entities/Graph.ts

@@ -0,0 +1,6 @@
+import { entity, text, number } from '@fougere/schema';
+
+export default class Graph extends entity({
+  root: text({ description: 'Project root directory (default: cwd)' }),
+  minEntities: number({ default: 6, description: 'Minimum entities before suggesting split' }),
+}) {}

package/fronds/analysis/handlers/CheckHandler.ts

@@ -0,0 +1,90 @@
+import { resolveContracts, crossFrondImports, type ScanDiagnostic } from '@fougere/core';
+import ProjectScan from '../services/ProjectScan.js';
+
+/** One thing that does not hold, in the terms of whoever has to fix it. */
+export interface Finding {
+  severity: 'blocking' | 'warning';
+  /** Stable rule name — the same vocabulary a scan diagnostic uses. */
+  code: string;
+  /** Where to go and look. */
+  filePath: string;
+  /** What is wrong, and what it costs. One sentence. */
+  message: string;
+}
+
+export interface CheckResult {
+  fronds: number;
+  handlers: number;
+  findings: Finding[];
+}
+
+/**
+ * What does not hold in this app — derived from its declarations, not from tests.
+ *
+ * It scans rather than boots — see `ProjectScan`, which states what that costs.
+ *
+ * Two rules today, and the shape for the rest:
+ *
+ *   - what the scan could not do (`ScanResult.diagnostics`) — an unreadable
+ *     directory, a handler that would not parse, an `extends` it could not follow;
+ *   - an operation whose parameters have no binding plan — it is served, and it
+ *     receives nothing;
+ *   - a relative import that resolves into another frond — a colocation constraint
+ *     nothing declares, which holds until the day the other frond is not on this disk.
+ *
+ * A rule about an ABSENCE is only sound if the analysis attests it looked, which
+ * is why the first bullet had to exist before this command could.
+ */
+export default class CheckHandler {
+  constructor(private projectScan: ProjectScan) {}
+
+  /** Report what does not hold in a Fougere app, without booting it. */
+  async execute(input: { root?: string }): Promise<CheckResult> {
+    const { fronds, diagnostics } = await this.projectScan.at(input.root);
+    const findings: Finding[] = diagnostics.map(asFinding);
+    let handlers = 0;
+
+    for (const frond of fronds) {
+      const collectorEntityNames = new Set(frond.collectors.map((c) => c.entityName));
+      for (const handler of frond.handlers) {
+        handlers++;
+        // The same merge the façade performs — asked for, not redone. A second
+        // opinion here would report a contract the runtime does not serve.
+        const contracts = resolveContracts(handler, frond.operationsOverrides, collectorEntityNames);
+
+        for (const [op, contract] of contracts) {
+          const params = contract.signature?.params.length ?? 0;
+          if (params > 0 && !contract.binding) {
+            findings.push({
+              severity: 'blocking',
+              code: 'operation-unbound',
+              filePath: handler.filePath,
+              message: `${handler.ctor.name}.${op} declares ${params} parameter(s) and has no `
+                + `binding plan — it is served, and it receives none of them.`,
+            });
+          }
+        }
+      }
+    }
+
+    /**
+     * A warning, not a refusal: it resolves today and the app runs. What it costs is
+     * paid once, late — the day the frond it reaches into is deployed on its own.
+     */
+    for (const reach of await crossFrondImports(fronds)) {
+      findings.push({
+        severity: 'warning',
+        code: reach.rule,
+        filePath: reach.filePath,
+        message: reach.message,
+      });
+    }
+
+    return { fronds: fronds.length, handlers, findings };
+  }
+}
+
+/** A scan diagnostic IS a finding — same vocabulary, so the renderer has one shape. */
+function asFinding(d: ScanDiagnostic): Finding {
+  return { severity: d.severity, code: d.code, filePath: d.filePath, message: d.message };
+}

package/fronds/analysis/handlers/GraphHandler.ts

@@ -0,0 +1,32 @@
+import {
+  buildGraph, suggestSplit,
+  type EntityNode, type DomainCluster, type FrondDescriptor,
+} from '@fougere/core';
+import ProjectScan from '../services/ProjectScan.js';
+
+export interface GraphResult {
+  fronds: FrondDescriptor[];
+  nodes: Map<string, EntityNode>;
+  clusters: DomainCluster[];
+  totalEntities: number;
+  totalRefs: number;
+}
+
+export default class GraphHandler {
+  constructor(private projectScan: ProjectScan) {}
+
+  /** Report how a workspace's fronds and entities reference each other. */
+  async execute(input: { root?: string; minEntities?: number }): Promise<GraphResult> {
+    const { fronds } = await this.projectScan.at(input.root);
+    const nodes = buildGraph(fronds);
+    const clusters = suggestSplit(nodes);
+
+    return {
+      fronds,
+      nodes,
+      clusters,
+      totalEntities: nodes.size,
+      totalRefs: [...nodes.values()].reduce((sum, n) => sum + n.refs.length, 0),
+    };
+  }
+}

package/fronds/analysis/services/ProjectScan.ts

@@ -0,0 +1,35 @@
+import { scanProject, frondAliases, setModuleLoader, type ScanResult } from '@fougere/core';
+import { resolve } from 'node:path';
+
+/**
+ * Read a target project without booting it — what every analysis command needs first.
+ *
+ * `graph` and `check` had the same five lines each: resolve the root against the
+ * CLI's cwd, install a jiti loader so the scan can import TypeScript sources, scan.
+ * Two copies of one gesture, and the second was written by copying the first.
+ *
+ * Not a boot: `bootAppFromConfig` runs migrations and seeds, so an analysis command
+ * that booted would write to the target's database. The cost is stated rather than
+ * hidden, though — the scan IMPORTS the modules it reads, so a frond's top-level
+ * code runs. "No application cycle, no database", not "no side effect".
+ */
+export default class ProjectScan {
+  // cwd is ambient in a CLI — not a DI service (the container resolves by type).
+  private cwd = process.cwd();
+
+  /** Scan the project at `root`, relative to where the command was invoked. */
+  async at(root?: string): Promise<ScanResult & { root: string }> {
+    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>>);
+
+    return { root: target, ...(await scanProject(target)) };
+  }
+}

package/fronds/scaffold/entities/BuildFrond.ts

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

package/fronds/scaffold/entities/Call.ts

@@ -0,0 +1,6 @@
+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)" }),
+}) {}

package/fronds/scaffold/entities/Completion.ts

@@ -0,0 +1,5 @@
+import { entity, oneOf } from '@fougere/schema';
+
+export default class Completion extends entity({
+  shell: oneOf('zsh', 'bash', { description: 'Shell type (default: auto-detect)' }),
+}) {}

package/fronds/scaffold/entities/New.ts

@@ -0,0 +1,19 @@
+import { entity, text, bool } from "@fougere/schema";
+
+/**
+ * `fougere new [name]` — the workspace composer.
+ *
+ * Guided when it has a TTY and nothing to compose from; stated when `--frond` or
+ * `--app` is given, which is the only form a script, a CI job or an agent can drive.
+ * `--bare` is the third: the empty shell, nothing composed. `--flat` is the fourth, and
+ * it selects a SHAPE rather than a composition: one app that is its own domain.
+ */
+export default class New extends entity({
+  name: text({ description: "Workspace name" }),
+  force: bool({ description: "Overwrite existing directory", default: false }),
+  bare: bool({ description: "Skip the guided flow — just the empty shell", default: false }),
+  flat: bool({ description: "One domain: no fronds/ — the app root is the frond", default: false }),
+  local: bool({ description: "Link @fougere/* to this monorepo (dev — installs offline)", default: false }),
+  frond: text({ description: "Fronds to add, no prompt — 'blog' or 'blog:shop', comma-separated", default: "" }),
+  app: text({ description: "Apps to add, no prompt — 'nuxt' or 'nuxt:web', comma-separated", default: "" }),
+}) {}

package/fronds/scaffold/entities/Serve.ts

@@ -0,0 +1,7 @@
+import { entity, text, number, 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)" })),
+}) {}

package/fronds/scaffold/entities/Sync.ts

@@ -0,0 +1,6 @@
+import { entity, text } from '@fougere/schema';
+
+export default class Sync extends entity({
+  name: 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

@@ -0,0 +1,97 @@
+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);
+}
+
+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);
+
+    if (!existsSync(frondDir)) {
+      throw new Error(`Frond '${input.name}' not found at ${frondDir}`);
+    }
+
+    const entitiesDir = join(frondDir, 'entities');
+    if (!existsSync(entitiesDir)) {
+      throw new Error(`No entities/ directory in frond '${input.name}'`);
+    }
+
+    // Discover entity files
+    const entityFiles = readdirSync(entitiesDir)
+      .filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'))
+      .sort();
+
+    if (entityFiles.length === 0) {
+      throw new Error(`No .ts files in ${entitiesDir}`);
+    }
+
+    const entityNames = entityFiles.map((f) => basename(f, '.ts'));
+
+    // Generate barrel index.ts
+    const indexLines = entityNames.map(
+      (name) => `export { default as ${name} } from './entities/${name}.js';`,
+    );
+    writeFileSync(join(frondDir, 'index.ts'), indexLines.join('\n') + '\n');
+
+    // Generate tsconfig.build.json
+    const tsconfig = {
+      compilerOptions: {
+        target: 'ES2022',
+        module: 'Node16',
+        moduleResolution: 'Node16',
+        declaration: true,
+        outDir: './dist',
+        rootDir: '.',
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+      },
+      include: ['index.ts', 'entities/**/*.ts'],
+    };
+
+    const tsconfigPath = join(frondDir, 'tsconfig.build.json');
+    writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2));
+
+    try {
+      execSync('npx tsc -p tsconfig.build.json', { cwd: frondDir, stdio: 'inherit' });
+    } finally {
+      try { unlinkSync(tsconfigPath); } catch { /* ignore */ }
+    }
+
+    // Update package.json
+    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' };
+
+    pkg.exports = {
+      '.': {
+        types: './dist/index.d.ts',
+        default: './dist/index.js',
+      },
+      './entities/*': {
+        types: './dist/entities/*.d.ts',
+        default: './dist/entities/*.js',
+      },
+      './package.json': './package.json',
+    };
+
+    // Only publish dist + package.json
+    pkg.files = ['dist', 'package.json'];
+
+    // Ensure peerDependencies on @fougere/schema
+    pkg.peerDependencies ??= {};
+    pkg.peerDependencies['@fougere/schema'] ??= '*';
+
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+
+    return { path: join(frondDir, 'dist'), entities: entityNames };
+  }
+}

package/fronds/scaffold/handlers/CallHandler.ts

@@ -0,0 +1,9 @@
+/**
+ * The client end lives in app/commands/CallCommand (it boots the project app
+ * and drives one operation). This handler exists only so the runner registers
+ * the `call` subcommand.
+ */
+export default class CallHandler {
+  /** Invoke one operation of a frond from the terminal. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/CompletionHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The completion script is produced by CompletionCommand (it holds the app and
+ * prints it). This handler exists only so the runner registers the subcommand.
+ */
+export default class CompletionHandler {
+  /** Print the shell completion script for this CLI. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/NewHandler.ts

@@ -0,0 +1,8 @@
+/**
+ * The guided flow lives in app/commands/NewCommand (it prompts and composes).
+ * This handler exists only so the runner registers the `new` subcommand.
+ */
+export default class NewHandler {
+  /** Create a Fougere project, workspace or flat. */
+  async execute(): Promise<void> {}
+}

package/fronds/scaffold/handlers/ServeHandler.ts

@@ -0,0 +1,9 @@
+/**
+ * The host lives in app/commands/ServeCommand (it boots the frond alone and
+ * exposes it over HTTP). This handler exists only so the runner registers the
+ * `serve` subcommand.
+ */
+export default class ServeHandler {
+  /** Host a frond in its own process, behind JSON-RPC. */
+  async execute(): Promise<void> {}
+}