@fougere/cli 0.12.4-alpha.0 → 0.12.6-alpha.0

package/fronds/scaffold/services/ProjectWriter.ts

@@ -1,339 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { cpSync, existsSync, mkdirSync, renameSync, readFileSync, writeFileSync, readdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { type Conventions, DEFAULT_CONVENTIONS, frondPackage } from '@fougere/core';
-
-/**
- * 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
- * token engine). The workspace model composes at every scale:
- *  - a workspace shell (`workspace/`),
- *  - fronds added from `fronds/<template>`  (business hexagons),
- *  - apps added from `apps/<template>`      (consumers: nuxt, cli).
- * The only per-piece edits are the package names.
- */
-const TEMPLATES = fileURLToPath(new URL('../../../templates/', import.meta.url));
-
-/**
- * Where a HOST keeps its starter, or nothing when it ships none.
- *
- * The package that owns the wiring owns the files: `@fougere/nuxt` knows what a
- * `nuxt.config.ts` must say, and a copy of it here would be that knowledge written twice —
- * which is how `templates/apps/` came to hold one host while six were published.
- *
- * Two ways to reach them, and the first is the monorepo's: a host is on disk there, and in
- * every process that installed one for its own reasons.
- */
-function starterOf(pkg: string): string | undefined {
-  return carried(pkg) ?? fetched(pkg);
-}
-
-/**
- * Resolved from the main entry and walked up to the manifest, because a host does not export
- * its own `package.json` and has no reason to.
- *
- * `import.meta.resolve` and not `createRequire().resolve`: a host's `exports` states only the
- * `import` condition, so the CJS resolver answers `ERR_PACKAGE_PATH_NOT_EXPORTED` for every
- * one of them.
- */
-function carried(pkg: string): string | undefined {
-  let dir: string;
-  try {
-    dir = dirname(fileURLToPath(import.meta.resolve(pkg)));
-  } catch { return undefined; }
-
-  while (!existsSync(join(dir, 'package.json')) && dir !== dirname(dir)) dir = dirname(dir);
-  const template = join(dir, 'template');
-
-  return existsSync(template) ? template : undefined;
-}
-
-/**
- * The starter of a host this process does not carry, read out of its published tarball.
- *
- * A host is no longer a `dependencies` entry: what is wanted of it is a directory of files, and
- * npm answers a dependency by installing the whole tree behind it — `next` brought 300 MB and
- * `nuxt` its own, so that 28 files weighing 112 KB could be copied. A tarball is 27 to 388 KB,
- * and the peers it names are the scaffolded app's to install, never this CLI's.
- *
- * Pinned to `scaffoldVersion()` for the reason `pinVersions` states, and extracted under that
- * version, so a second call reuses what the first unpacked and a released CLI never reads the
- * starter of another one.
- */
-function fetched(pkg: string): string | undefined {
-  const dir = join(tmpdir(), 'fougere-starter', `${pkg.replace('/', '-')}@${scaffoldVersion()}`);
-  const template = join(dir, 'package', 'template');
-  if (existsSync(template)) return template;
-
-  try {
-    mkdirSync(dir, { recursive: true });
-    const tarball = execFileSync('npm', ['pack', `${pkg}@${scaffoldVersion()}`, '--pack-destination', dir, '--silent'],
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
-    execFileSync('tar', ['-xzf', join(dir, tarball), '-C', dir, 'package/template'], { stdio: 'ignore' });
-  } catch { return undefined; }
-
-  return existsSync(template) ? template : undefined;
-}
-
-/**
- * The hosts this CLI can scaffold: the `@fougere/*` packages it is developed against.
- *
- * The dependency list IS the registry — nothing to declare, and a host added to the family
- * appears here the day the CLI names it. It names them under `devDependencies`, because what
- * it wants of a host is a directory of files rather than a module to load, and `dependencies`
- * is what had `npm create fougere` install Next.js and Nuxt to copy 28 files.
- *
- * The NAMES are read here and the FILES only where an app is written, so offering the list
- * costs nothing: resolving all six would fetch six tarballs to print six words.
- */
-function hosts(): string[] {
-  const manifest = JSON.parse(readFileSync(fileURLToPath(new URL('../../../package.json', import.meta.url)), 'utf8')) as
-    { devDependencies?: Record<string, string> };
-
-  return Object.keys(manifest.devDependencies ?? {})
-    .filter((pkg) => pkg.startsWith('@fougere/'))
-    .map((pkg) => pkg.slice('@fougere/'.length));
-}
-
-/** The version that scaffolds is the version the templates were written for. */
-const scaffoldVersion = (): string =>
-  (JSON.parse(readFileSync(fileURLToPath(new URL('../../../package.json', import.meta.url)), 'utf8')) as
-    { version: string }).version;
-
-// npm strips a literal .gitignore from published packages — it ships as
-// _gitignore and the name is restored on copy.
-function restoreGitignore(dir: string): void {
-  const gi = join(dir, '_gitignore');
-  if (existsSync(gi)) renameSync(gi, join(dir, '.gitignore'));
-}
-
-function setPackageName(dir: string, name: string): void {
-  const pkgPath = join(dir, 'package.json');
-  if (!existsSync(pkgPath)) return;
-  const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name: string };
-  pkg.name = name;
-  writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-}
-
-export default class ProjectWriter {
-  /** The workspace shell — fougere.config, pnpm-workspace (fronds/* apps/*), package.json. */
-  createWorkspace(dir: string, name: string): { path: string } {
-    cpSync(join(TEMPLATES, 'workspace'), dir, { recursive: true });
-    restoreGitignore(dir);
-    setPackageName(dir, name);
-
-    return { path: dir };
-  }
-
-  /**
-   * The flat shell — one Nuxt app whose root carries the convention, so no `fronds/`
-   * and no workspace. `templates/flat/` is that shell; what separates the two shapes is
-   * only where the domain lands.
-   */
-  createFlat(dir: string, name: string): { path: string } {
-    cpSync(join(TEMPLATES, 'flat'), dir, { recursive: true });
-    restoreGitignore(dir);
-    setPackageName(dir, name);
-
-    return { path: dir };
-  }
-
-  /**
-   * 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 `@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.
-   */
-  addRootFrond(dir: string, template: string): { path: string } {
-    const src = join(TEMPLATES, 'fronds', template);
-    for (const entry of readdirSync(src, { withFileTypes: true })) {
-      if (!entry.isDirectory()) continue;
-      cpSync(join(src, entry.name), join(dir, entry.name), { recursive: true });
-    }
-
-    return { path: dir };
-  }
-
-  /** Add a frond (business hexagon) under 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
-    // it renames the contract, which a freshly scaffolded frond has no reason to do.
-    const pkgPath = join(dest, 'package.json');
-    if (existsSync(pkgPath)) {
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name: string };
-      pkg.name = frondPackage(name, conventions);
-      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-    }
-
-    return { path: dest };
-  }
-
-  /** Add an app (consumer) under apps/<name>, from the host package that owns its wiring. */
-  addApp(wsDir: string, template: string, name: string): { path: string } {
-    const dest = join(wsDir, 'apps', name);
-    const starter = hosts().includes(template) ? starterOf(`@fougere/${template}`) : undefined;
-    if (!starter) throw new Error(`No host ships a starter for '${template}'. Served: ${hosts().join(', ')}.`);
-
-    cpSync(starter, dest, { recursive: true });
-    restoreGitignore(dest);
-    setPackageName(dest, name);
-
-    return { path: dest };
-  }
-
-  /**
-   * What can be scaffolded, of a kind.
-   *
-   * A FROND comes from this package: it is Fougere's own vocabulary, entities and handlers,
-   * and no other package owns it. An APP comes from its HOST — the registry is the hosts this
-   * CLI depends on, so `fougere new` offers what is published rather than what was copied here.
-   */
-  listTemplates(kind: 'fronds' | 'apps'): string[] {
-    if (kind === 'apps') return hosts().sort();
-
-    const dir = join(TEMPLATES, kind);
-    if (!existsSync(dir)) return [];
-
-    return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-  }
-
-  /**
-   * Every app depends on every frond of the workspace — stated once composition is done,
-   * because that is when the names exist.
-   *
-   * 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
-   * `@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, conventions: Conventions = DEFAULT_CONVENTIONS): void {
-    const dirs = (kind: string): string[] => {
-      const dir = join(wsDir, kind);
-      if (!existsSync(dir)) return [];
-
-      return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-    };
-
-    const fronds = dirs(conventions.fronds);
-    if (fronds.length === 0) return;
-
-    for (const app of dirs('apps')) {
-      const pkgPath = join(wsDir, 'apps', app, 'package.json');
-      if (!existsSync(pkgPath)) continue;
-
-      const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { dependencies?: Record<string, string> };
-      pkg.dependencies ??= {};
-      for (const frond of fronds) pkg.dependencies[frondPackage(frond, conventions)] = 'workspace:*';
-      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
-    }
-  }
-
-  /**
-   * Every `@fougere/*` dependency, pinned to the version that scaffolded it.
-   *
-   * The templates say `latest`, which reads as "whatever is current" and is not: pnpm
-   * answers from a metadata cache, and a fresh project installed 0.6 while the registry
-   * said 0.7 — measured. A version is also what makes an install reproducible, which
-   * `latest` never was.
-   *
-   * Read off this CLI's own package, because the scaffold and the packages it names ship
-   * together: the version that wrote the file is the one it was written for.
-   */
-  pinVersions(wsDir: string, conventions: Conventions = DEFAULT_CONVENTIONS): void {
-    const version = scaffoldVersion();
-    const manifests = [
-      join(wsDir, 'package.json'),
-      ...['apps', conventions.fronds].flatMap((kind) => {
-        const dir = join(wsDir, kind);
-        if (!existsSync(dir)) return [];
-
-        return readdirSync(dir, { withFileTypes: true })
-          .filter((e) => e.isDirectory())
-          .map((e) => join(dir, e.name, 'package.json'));
-      }),
-    ];
-
-    for (const path of manifests) {
-      if (!existsSync(path)) continue;
-      const pkg = JSON.parse(readFileSync(path, 'utf8')) as { dependencies?: Record<string, string> };
-      let moved = false;
-      for (const [name, range] of Object.entries(pkg.dependencies ?? {})) {
-        if (!name.startsWith('@fougere/') || range !== 'latest') continue;
-        pkg.dependencies![name] = version;
-        moved = true;
-      }
-      if (moved) writeFileSync(path, JSON.stringify(pkg, null, 2) + '\n');
-    }
-  }
-
-  /**
-   * Dev mode: rewrite every `@fougere/*` dependency in the workspace to a
-   * `link:` into this monorepo, so `pnpm install` resolves offline (the
-   * packages aren't on npm yet). No-op once the packages are published.
-   */
-  linkLocal(wsDir: string): void {
-    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
-    // on `latest` and broke the install. `@fougere/nuxt` lives in `app/nuxt/` and
-    // `@fougere/transport-http` in `transport/http/`, which is exactly why the name is
-    // read from each package.json instead of guessed from its directory.
-    const dirOf = new Map<string, string>();
-    const scan = (dir: string, depth = 0): void => {
-      for (const e of readdirSync(dir, { withFileTypes: true })) {
-        if (!e.isDirectory() || e.name === 'node_modules') continue;
-        const sub = join(dir, e.name);
-        const pkgPath = join(sub, 'package.json');
-        if (existsSync(pkgPath)) {
-          const { name } = JSON.parse(readFileSync(pkgPath, 'utf8')) as { name?: string };
-          if (name?.startsWith('@fougere/')) dirOf.set(name, sub);
-        } else if (depth === 0) {
-          scan(sub, depth + 1);
-        }
-      }
-    };
-    scan(packages);
-    const walk = (d: string): void => {
-      for (const e of readdirSync(d, { withFileTypes: true })) {
-        if (e.name === 'node_modules') continue;
-        const f = join(d, e.name);
-        if (e.isDirectory()) { walk(f); continue; }
-        if (e.name !== 'package.json') continue;
-        const pkg = JSON.parse(readFileSync(f, 'utf8')) as { dependencies?: Record<string, string> };
-        let changed = false;
-        for (const dep of Object.keys(pkg.dependencies ?? {})) {
-          const local = dirOf.get(dep);
-          if (local) { pkg.dependencies![dep] = `link:${local}`; changed = true; }
-        }
-        if (changed) writeFileSync(f, JSON.stringify(pkg, null, 2) + '\n');
-      }
-    };
-    walk(wsDir);
-  }
-}

package/fronds/shims.d.ts

@@ -1,9 +0,0 @@
-// `safe-regex` ships no types, and `@types/safe-regex` describes its version 1 while the
-// package here is version 2. The exported signature did not move between the two, so the
-// shim states it rather than pinning a types package a major behind.
-declare module 'safe-regex' {
-  export default function safeRegex(
-    pattern: string | RegExp,
-    options?: { limit?: number },
-  ): boolean;
-}

package/src/bin.ts

@@ -1,77 +0,0 @@
-#!/usr/bin/env node
-/** fougere CLI — a Fougere app powered by citty. */
-import { createApp, setLogLevel, envLevel, type ScanResult } from '@fougere/core';
-import { scanProject } from '@fougere/compiler';
-import { frondDirsOf, DEFAULT_CONVENTIONS } from '@fougere/core';
-import { getModuleLoader } 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.
- */
-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);

package/src/bridge.ts

@@ -1,118 +0,0 @@
-import { Lifecycle, Role } from '@fougere/schema';
-/** Entity → citty bridge. */
-import type { Fields } from '@fougere/schema';
-import { Shapes, Visibility, type ShapeType } from '@fougere/schema';
-import type { ArgsDef, ArgDef } from 'citty';
-
-function toKebab(name: string): string {
-  return name.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase());
-}
-
-/**
- * What a caller supplies: the fields the axes admit, or the PRIMARY when they admit nothing.
- *
- * `Visibility.input` answers who may WRITE a field, and a primary is the server's — right for a
- * form, wrong for an operation whose whole input is `Product.pick('id')`. That contract asks the
- * caller to NAME a row, and the axes leave it with no argument at all: `product:archive abc-9`
- * answered `Unexpected argument`.
- *
- * Only when nothing else remains, so `create` over a full entity is untouched — its input holds
- * twelve writable fields and the primary stays the server's.
- */
-function suppliedIn(fields: Fields): Fields {
-  const written = Visibility.of(fields).input;
-  if (Object.keys(written).length > 0) return written;
-
-  return Object.fromEntries(
-    Object.entries(fields).filter(([, field]) => Role.of(field).isPrimary()),
-  ) as Fields;
-}
-
-/** Convert an Entity's fields into citty args definition. */
-export function entityToArgs(fields: Fields): ArgsDef {
-  const args: ArgsDef = {};
-  let positionalIndex = 0;
-
-  // The CLI additionally skips ALL relations: a ref is not a flag — supplying related rows is
-  // not a CLI gesture.
-  for (const [key, field] of Object.entries(suppliedIn(fields))) {
-    if (Role.of(field).isRelation()) continue;
-
-    // A `default(v)` travels as the create rule `{ value }` — citty shows it.
-    const defaultValue = Lifecycle.of(field).literal?.value;
-    const { base: shape, nullable } = Shapes.of(field.shape);
-    const type = Shapes.typeOf(field.shape);
-    // Naming a row is required by definition: a generator fills a primary the server writes,
-    // never one a caller hands in to designate.
-    const designates = Role.of(field).isPrimary();
-    const common = {
-      description: field.shape?.description,
-      required: designates || (!nullable && Lifecycle.of(field).requiredAtCreate()),
-    };
-
-    // A closed set is citty's `enum`: the shape already names the legal values, so the
-    // refusal and the `--help` listing come from the declaration rather than a check
-    // written beside it.
-    const options = shape && 'enum' in shape && shape.enum?.length
-      ? shape.enum.filter((value) => value !== null).map(String)
-      : undefined;
-    // First required field becomes positional — but never a boolean, a closed set, or a
-    // date-time, which stay named flags.
-    const positional = positionalIndex === 0
-      && common.required
-      && key !== 'force'
-      && options === undefined
-      && type !== 'boolean'
-      && type !== 'date';
-    if (positional) positionalIndex++;
-
-    args[toKebab(key) === key ? key : toKebab(key)] = argFor(
-      type,
-      common,
-      defaultValue,
-      options,
-      positional,
-    );
-  }
-
-  return args;
-}
-
-/**
- * Which types carry a declared default onto the CLI. A `boolean` is answered above, with
- * its own default; an `object` and an `array` are named and bare.
- */
-const CARRIES_DEFAULT: Record<ShapeType, boolean> = {
-  number: true,
-  integer: true,
-  text: true,
-  date: true,
-  choice: true,
-  boolean: false,
-  object: false,
-  array: false,
-};
-
-/** One arg, built WITH its `type`. */
-function argFor(
-  type: ShapeType | undefined,
-  common: { description?: string; required: boolean },
-  defaultValue: unknown,
-  options: string[] | undefined,
-  positional: boolean,
-): ArgDef {
-  if (type === 'boolean') {
-    return defaultValue === undefined
-      ? { ...common, type: 'boolean' }
-      : { ...common, type: 'boolean', default: defaultValue as boolean };
-  }
-
-  const withDefault = type && CARRIES_DEFAULT[type] && defaultValue !== undefined
-    ? { default: String(defaultValue) }
-    : {};
-
-  if (options) return { ...common, ...withDefault, type: 'enum', options };
-  if (positional) return { ...common, ...withDefault, type: 'positional' };
-
-  return { ...common, ...withDefault, type: 'string' };
-}

package/src/completion.ts

@@ -1,145 +0,0 @@
-/** Shell completion generator — outputs a script for bash/zsh. */
-import type { App } from '@fougere/core';
-import { entityToArgs } from './bridge.js';
-
-function toKebab(name: string): string {
-  return name.replace(/[A-Z]/g, (c) => '-' + c.toLowerCase()).replace(/^-/, '');
-}
-
-/** What a positional names, said by the field's own name — no table to keep in step. */
-const NAMES: Record<string, 'operations' | 'fronds' | undefined> = {
-  operation: 'operations',
-  frond: 'fronds',
-};
-
-interface CommandMeta {
-  name: string;
-  flags: string[];
-  names?: 'operations' | 'fronds';
-}
-
-function extractCommandMeta(app: App): CommandMeta[] {
-  const commands: CommandMeta[] = [];
-
-  for (const frond of app.fronds) {
-    const handlerMap = new Map(frond.handlers.map((h) => [h.address, h]));
-
-    for (const entity of frond.entities) {
-      const handler = handlerMap.get(entity.name);
-      if (!handler) continue;
-
-      let facade: Record<string, Function>;
-      try { facade = app.resolve(handler.name); } catch { continue; }
-      if (typeof facade.execute !== 'function') continue;
-
-      // The same function the runner builds citty's args from, so the positional and the
-      // flags are the ones the command actually has.
-      const args = Object.entries(entityToArgs(entity.entityClass.getFields())) as
-        [string, { type?: string }][];
-      const positional = args.find(([, def]) => def.type === 'positional')?.[0];
-
-      commands.push({
-        name: toKebab(entity.name),
-        flags: args.filter(([, def]) => def.type !== 'positional').map(([key]) => `--${key}`),
-        ...(positional && NAMES[positional] ? { names: NAMES[positional]! } : {}),
-      });
-    }
-  }
-
-  return commands;
-}
-
-export function generateZshCompletion(app: App, binName = 'fougere'): string {
-  const commands = extractCommandMeta(app);
-
-  const valueCases = commands
-    .filter((cmd) => cmd.names)
-    .map((cmd) => `      ${cmd.name}) _${binName}_names ${cmd.names} ;;`)
-    .join('\n');
-
-  const flagCases = commands
-    .map((cmd) => `      ${cmd.name}) flags="${cmd.flags.join(' ')}" ;;`)
-    .join('\n');
-
-  return `# Auto-generated by @fougere/cli
-
-# The project answers; a stale list in this file would not.
-_${binName}_names() {
-  local -a values
-  values=(\${(f)"$(${binName} explain --names $1 2>/dev/null)"})
-  (( \${#values} )) && compadd -- \${values}
-}
-
-_${binName}() {
-  local -a commands flags
-  commands=(${commands.map((c) => `'${c.name}'`).join(' ')})
-
-  if (( CURRENT == 2 )); then
-    _describe 'command' commands
-    return
-  fi
-
-  local cmd=\${words[2]}
-
-  if [[ "\${words[CURRENT]}" != --* ]]; then
-    case "$cmd" in
-${valueCases}
-    esac
-    return
-  fi
-
-  case "$cmd" in
-${flagCases}
-      *) flags="" ;;
-  esac
-  _values 'flags' \${(s: :)flags}
-}
-
-compdef _${binName} ${binName}
-`;
-}
-
-export function generateBashCompletion(app: App, binName = 'fougere'): string {
-  const commands = extractCommandMeta(app);
-  const cmdNames = commands.map((c) => c.name).join(' ');
-
-  const valueCases = commands
-    .filter((cmd) => cmd.names)
-    .map((cmd) => `      ${cmd.name}) names="${cmd.names}" ;;`)
-    .join('\n');
-
-  const flagCases = commands
-    .map((cmd) => `      ${cmd.name}) COMPREPLY=( $(compgen -W "${cmd.flags.join(' ')}" -- "\${cur}") ) ;;`)
-    .join('\n');
-
-  return `# Auto-generated by @fougere/cli
-_${binName}_completions() {
-  local cur cmd names
-  cur="\${COMP_WORDS[COMP_CWORD]}"
-  cmd="\${COMP_WORDS[1]}"
-
-  if [[ \${COMP_CWORD} -eq 1 ]]; then
-    COMPREPLY=( $(compgen -W "${cmdNames}" -- "\${cur}") )
-    return
-  fi
-
-  if [[ "\${cur}" != --* ]]; then
-    names=""
-    case "$cmd" in
-${valueCases}
-    esac
-    if [[ -n "\${names}" ]]; then
-      # The project answers; a stale list in this file would not.
-      COMPREPLY=( $(compgen -W "$(${binName} explain --names "\${names}" 2>/dev/null | tr '\\n' ' ')" -- "\${cur}") )
-      return
-    fi
-  fi
-
-  case "$cmd" in
-${flagCases}
-  esac
-}
-
-complete -F _${binName}_completions ${binName}
-`;
-}

package/src/index.ts

@@ -1 +0,0 @@
-export { run } from './runner.js';