@fougere/cli 0.12.5-alpha.0 → 0.12.6-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,
-  };
-}