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

package/app/commands/DevtoolsCommand.ts

@@ -1,92 +0,0 @@
-import { createAppRunner } from '@fougere/core';
-import type { App, CallRecord } from '@fougere/core';
-import type { CallsView } from '../../fronds/analysis/handlers/DevtoolsHandler.js';
-import type { ui as createUi } from '../../src/ui.js';
-import { machineWanted, printMachine } from '../../src/machine.js';
-import pc from 'picocolors';
-
-type Ui = ReturnType<typeof createUi>;
-
-/** How long between two reads. Fast enough to read as a stream, cheap enough to ignore. */
-const EVERY_MS = 500;
-
-const ROUTE = { local: pc.green, remote: pc.cyan, system: pc.magenta } as const;
-
-/**
- * `fougere devtools` — the call log of every running app of this project, followed.
- *
- * A cursor per address, because each app numbers its own ring: asking for what this reader
- * has not seen is the whole protocol, and it is per source or nothing.
- */
-export default class DevtoolsCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    const since: Record<string, number> = {};
-
-    if (machineWanted(raw)) return printMachine(await this.view(raw, since));
-
-    const first = await this.view(raw, since);
-    this.announce(first);
-
-    const told: Record<string, number> = {};
-    for (let view = first; ; view = await this.view(raw, since)) {
-      for (const source of view.sources) {
-        since[source.url] = source.cursor;
-
-        // Said once per address, and only when it grows: a ring that dropped is not a
-        // quiet period, and repeating it every half second would bury the calls.
-        if (source.dropped > (told[source.url] ?? 0)) {
-          this.ui.warn(`${source.url} dropped ${source.dropped - (told[source.url] ?? 0)} call(s) — its ring is smaller than this traffic`);
-          told[source.url] = source.dropped;
-        }
-      }
-
-      for (const call of view.calls) process.stdout.write(render(call, view.sources.length > 1) + '\n');
-      await new Promise((wake) => setTimeout(wake, EVERY_MS));
-    }
-  }
-
-  /** What is being watched, and what refused — stated before the first line scrolls. */
-  private announce(view: CallsView): void {
-    for (const source of view.sources) {
-      const name = source.frond ? `${pc.bold(source.frond)} ${pc.dim(source.url)}` : pc.bold(source.url);
-      if (source.refusal) this.ui.warn(`${name} — ${source.refusal}`);
-      else this.ui.step(`following ${name}`);
-    }
-    this.ui.info(pc.dim('ctrl-c to stop'));
-  }
-
-  private view(raw: Record<string, unknown>, since: Record<string, number>): Promise<CallsView> {
-    return createAppRunner(this.app)(
-      { entity: 'devtools', op: 'execute' },
-      { params: {}, query: {}, input: { ...raw, since }, state: {} },
-    ) as Promise<CallsView>;
-  }
-}
-
-function render(call: CallRecord & { source: string }, many: boolean): string {
-  // Padded BEFORE colouring: an escape sequence counts in a string's length, so padding a
-  // coloured value moves the column by however many bytes the colour took.
-  const at = many ? pc.dim(pad(new URL(call.source).port || call.source, 5)) : '';
-  const frond = pc.dim(pad(call.frond ?? '—', 9));
-  const address = pc.bold(pad(`${call.entity}.${call.operation}${call.surface ? `/${call.surface}` : ''}`, 22));
-  const route = call.route
-    ? (ROUTE[call.route] ?? pc.dim)(pad(call.route, 9))
-    : pc.red(pad('unrouted', 9));
-  const took = pc.dim(lead(call.ms === undefined ? '' : `${call.ms}ms`, 7));
-  const verdict = call.verdict === 'failed'
-    ? pc.red(call.refusal?.code ?? 'failed')
-    : call.verdict === 'ok' ? pc.dim('ok') : pc.yellow('running');
-
-  return [at, frond, address, route, took, verdict, call.trace ? pc.dim(call.trace.slice(3, 11)) : '']
-    .filter(Boolean).join(' ');
-}
-
-function pad(value: string, width: number): string {
-  return value.length >= width ? value : value + ' '.repeat(width - value.length);
-}
-
-function lead(value: string, width: number): string {
-  return value.length >= width ? value : ' '.repeat(width - value.length) + value;
-}

package/app/commands/ExplainCommand.ts

@@ -1,136 +0,0 @@
-import type { App } from '@fougere/core';
-import { createAppRunner } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import type {
-  ExplainResult,
-  ExplainListing,
-  ExplainedBinding,
-} from '../../fronds/analysis/handlers/ExplainHandler.js';
-import pc from 'picocolors';
-import { machineText, printMachine } from '../../src/machine.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-export default class ExplainCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    const names = raw.names as 'operations' | 'fronds' | undefined;
-    const operation = (raw.operation as string | undefined)?.trim();
-
-    // No operation named — the question is what this project serves at all. The same
-    // model answers both, so the facade is the one that was asked, never a guess.
-    if (names || !operation) return this.listing(raw, names);
-
-    const result = await this.ask('execute', raw) as ExplainResult;
-
-    if (raw.json === true) return printMachine(result);
-
-    this.ui.note(renderExplain(result), result.operation);
-  }
-
-  private async listing(raw: Record<string, unknown>, names?: 'operations' | 'fronds') {
-    const listing = await this.ask('list', raw) as ExplainListing;
-
-    // A completion script has no JSON parser: one name per line, nothing else on stdout.
-    if (names) {
-      const values = names === 'fronds'
-        ? listing.fronds.map((frond) => frond.name)
-        : listing.operations;
-      if (values.length > 0) process.stdout.write(values.join('\n') + '\n');
-
-      return;
-    }
-
-    if (raw.json === true) return printMachine(listing);
-
-    this.ui.note(renderListing(listing), 'what this project serves');
-  }
-
-  private ask(op: string, raw: Record<string, unknown>) {
-    return createAppRunner(this.app)(
-      { entity: 'explain', op },
-      { params: {}, query: {}, input: raw, state: {} },
-    );
-  }
-}
-
-/** Kept as the name `tests/explain.test.ts` pins the key order through. */
-export function renderExplainJson(result: ExplainResult): string {
-  return machineText(result);
-}
-
-export function renderExplain(result: ExplainResult): string {
-  const lines = [
-    `${pc.dim('Handler:')}   ${result.handler.class}.${result.handler.method}`,
-    `${pc.dim('Address:')}   ${result.handler.address}.${result.operation.split('.').at(-1)}`,
-    `${pc.dim('Kind:')}      ${result.kind}`,
-    `${pc.dim('Input:')}     ${result.input ?? '—'}`,
-    `${pc.dim('Output:')}    ${result.output ? `${result.output.type}${result.output.cardinality ? ` (${result.output.cardinality})` : ''}` : '—'}`,
-  ];
-
-  if (result.description) lines.push(`${pc.dim('Purpose:')}   ${result.description}`);
-
-  lines.push('', pc.bold('Parameters'));
-  if (result.parameters.length === 0) lines.push('  —');
-  for (const parameter of result.parameters) {
-    const optional = parameter.optional ? '?' : '';
-    lines.push(`  ${parameter.name}${optional}: ${parameter.type ?? 'unknown'} ${pc.dim('→')} ${bindingName(parameter.binding)}`);
-  }
-
-  lines.push('', pc.bold('Collectors'));
-  if (result.collectors.length === 0) lines.push('  —');
-  for (const collector of result.collectors) {
-    lines.push(`  ${collector.typeName} ${pc.dim('→')} ${collector.class}`);
-  }
-
-  lines.push(
-    '',
-    `${pc.dim('Surfaces:')}  ${result.exposure.surfaces.join(', ') || '—'}`,
-    `${pc.dim('Adapters:')}  ${result.exposure.adapters.join(', ') || '—'}`,
-    `${pc.dim('Placement:')} ${result.placement.frond} / ${result.placement.runtime}${result.placement.remote ? ` (${result.placement.remote})` : ''}`,
-    // Where the work GOES, under where it answers. The hop count is what a sampling rate, a
-    // histogram's bounds and a load threshold are all a function of — each hard-coded today.
-    `${pc.dim('Reach:')}     ${renderReach(result.reach)}`,
-  );
-
-  if (result.handler.file) lines.push(`${pc.dim('Source:')}    ${result.handler.file}`);
-
-  return lines.join('\n');
-}
-
-/** What this op reaches, and the part of it that costs a round trip. */
-function renderReach(reach: ExplainResult['reach']): string {
-  if (reach.fronds.length === 0) return pc.dim('nothing outside its own frond');
-
-  const named = reach.fronds
-    .map((one) => (one.runtime === 'remote' ? pc.yellow(one.frond) : pc.cyan(one.frond)))
-    .join(', ');
-
-  return `${named} ${pc.dim(`— ${reach.hops} hop(s)`)}`;
-}
-
-export function renderListing(listing: ExplainListing): string {
-  const lines = [pc.bold('Fronds')];
-  if (listing.fronds.length === 0) lines.push('  —');
-  for (const frond of listing.fronds) {
-    const where = frond.remote ? `remote ${pc.dim(frond.remote)}` : 'local';
-    lines.push(`  ${frond.name} ${pc.dim('→')} ${where}, ${frond.operations} operation(s)`);
-  }
-
-  lines.push('', pc.bold('Operations'));
-  if (listing.operations.length === 0) lines.push('  —');
-  for (const operation of listing.operations) lines.push(`  ${operation}`);
-
-  return lines.join('\n');
-}
-
-function bindingName(binding: ExplainedBinding | null): string {
-  if (!binding) return 'unbound';
-  switch (binding.kind) {
-    case 'collector': return `collector:${binding.typeName}`;
-    case 'fact': return `fact:${binding.factName}`;
-    case 'param': return `param:${binding.name}${binding.coerce ? ` (${binding.coerce})` : ''}`;
-    default: return binding.kind;
-  }
-}

package/app/commands/FreezeCommand.ts

@@ -1,119 +0,0 @@
-import { createAppRunner } from '@fougere/core';
-import type { Change } from '@fougere/schema';
-import type { App } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import type { FreezeInspection } from '../../fronds/analysis/handlers/FreezeHandler.js';
-import pc from 'picocolors';
-import { machineWanted, printMachine } from '../../src/machine.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-/**
- * Cutting a version — inspect, ask what only a human knows, then record.
- *
- * The question is asked between the two ops and nowhere else: a field gone plus a field
- * appeared is either a rename or a drop-and-add, the two produce opposite DDL, and the
- * intent left with the person who made the change. Nothing is written until it is settled.
- */
-export default class FreezeCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    if (!raw.version) {
-      this.ui.error('Usage: fougere freeze <version>');
-
-      return;
-    }
-
-    const freeze = (input: Record<string, unknown>) =>
-      createAppRunner(this.app)({ entity: 'freeze', op: 'execute' }, { params: {}, query: {}, input, state: {} }) as Promise<FreezeInspection>;
-
-    // Idempotent while it refuses: this writes when nothing is ambiguous, and reports
-    // otherwise — so the first call is both the inspection and the happy path.
-    const seen = await freeze(raw);
-
-    // The question below cannot be put to a machine, so the inspection is the answer:
-    // `ambiguous` says what a human still has to settle, and nothing was written.
-    if (machineWanted(raw)) return printMachine(seen);
-
-    if (seen.entities.length === 0) {
-      this.ui.warn('No entities found. Run this from a Fougere project root.');
-
-      return;
-    }
-
-    if (seen.written) {
-      this.report(seen);
-
-      return;
-    }
-
-    const renamed = await this.settle(seen);
-    if (renamed === undefined) return;
-
-    this.report(await freeze({ ...raw, renamed }));
-  }
-
-  /** Turn every ambiguity into a declaration, or `undefined` when the answer is a refusal. */
-  private async settle(seen: FreezeInspection): Promise<Record<string, Record<string, string>> | undefined> {
-    const renamed: Record<string, Record<string, string>> = {};
-    const pending = Object.entries(seen.ambiguous);
-    if (pending.length === 0) return renamed;
-
-    this.ui.warn('A field left and a field of the same shape appeared. Only you know which.');
-
-    for (const [entity, pairs] of pending) {
-      // Grouped by what LEFT: one departed field is one question, however many
-      // candidates carry its shape.
-      const byRemoved = new Map<string, string[]>();
-      for (const { removed, added } of pairs) byRemoved.set(removed, [...(byRemoved.get(removed) ?? []), added]);
-
-      for (const [removed, candidates] of byRemoved) {
-        const answer = await this.ui.select({
-          message: `${entity}.${pc.bold(removed)} — what happened to it?`,
-          options: [
-            ...candidates.map((added) => ({ value: added, label: `renamed to ${added}`, hint: 'the data moves with it' })),
-            { value: '', label: 'dropped', hint: 'the column goes, and what it held goes with it' },
-          ],
-        });
-        // An empty answer is a cancel as much as a "dropped" — writing on either would
-        // record a decision nobody made.
-        if (!answer) {
-          this.ui.warn(`${entity}.${removed} treated as dropped — say so explicitly if that is right.`);
-
-          return undefined;
-        }
-        renamed[entity] = { ...renamed[entity], [removed]: answer };
-      }
-    }
-
-    return renamed;
-  }
-
-  private report(written: FreezeInspection) {
-    const { step } = written;
-    if (!step) {
-      this.ui.success(`${written.version} recorded — ${written.entities.length} entities, and nothing before it`);
-
-      return;
-    }
-
-    const moved = Object.entries(step.entities);
-    const count = moved.reduce((total, [, answer]) => total + answer.changes.length, 0);
-
-    this.ui.success(`${written.version} recorded — ${count} change(s) since ${written.previous}`);
-    for (const [entity, answer] of moved) {
-      this.ui.step(`${pc.bold(entity)} — ${answer.changes.map(describeChange).join(', ')}`);
-    }
-    if (step.entitiesAdded.length > 0) this.ui.step(`new: ${step.entitiesAdded.join(', ')}`);
-    if (step.entitiesRemoved.length > 0) this.ui.step(`gone: ${step.entitiesRemoved.join(', ')}`);
-  }
-}
-
-function describeChange(change: Change): string {
-  if (change.kind === 'renamed') return `${change.from} → ${change.to}`;
-  // An axis that moved names WHICH: "restated title" says nothing a reader can act on.
-  if (change.kind === 'restated') return `${change.field}: ${change.axis} moved`;
-
-  return `${change.kind} ${change.field}`;
-}

package/app/commands/GrantCommand.ts

@@ -1,46 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { generateKeyPair, issueGrant } from '@fougere/core/node';
-import type { App } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import { ROOT_KEY, packed } from './grant-material.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-/**
- * Vouch for one frond: bind its name to a fresh key, signed by the root.
- *
- * The key is printed and never stored — it belongs to the deployment, not to the
- * repository. Re-running issues a NEW key rather than showing the old one, which is
- * what rotation is: run it again, redeploy that frond, and nobody else's config moves.
- */
-export default class GrantCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    const frond = raw.frond as string | undefined;
-    if (!frond) {
-      this.ui.error('Usage: fougere grant <frond>');
-
-      return;
-    }
-
-    let rootPrivateKey: string;
-    try {
-      rootPrivateKey = await readFile(join(process.cwd(), ROOT_KEY), 'utf8');
-    } catch {
-      this.ui.error(`No ${ROOT_KEY} — run \`fougere keys\` first.`);
-
-      return;
-    }
-
-    const { privateKey, publicKey } = generateKeyPair();
-    const grant = issueGrant(rootPrivateKey, frond, publicKey);
-
-    this.ui.success(`granted — '${frond}' will be admitted by any receiver trusting this root`);
-    this.ui.note(
-      `FOUGERE_KEY=${packed(privateKey)}\nFOUGERE_GRANT=${grant}`,
-      `Inject into '${frond}' at launch — secret, shown once`,
-    );
-  }
-}

package/app/commands/GraphCommand.ts

@@ -1,91 +0,0 @@
-import type { GraphResult } from '../../fronds/analysis/handlers/GraphHandler.js';
-import type { DeclaredTopology, EntityNode, DomainCluster, App } from '@fougere/core';
-import { createAppRunner } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import pc from 'picocolors';
-import { machineWanted, printMachine } from '../../src/machine.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-export default class GraphCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    // Ride the call contract — the same envelope every consumer uses.
-    const result = await createAppRunner(this.app)(
-      { entity: 'graph', op: 'execute' },
-      { params: {}, query: {}, input: raw, state: {} },
-    ) as GraphResult;
-
-    if (machineWanted(raw)) return printMachine(result);
-
-    if (result.totalFronds === 0) {
-      this.ui.warn('No fronds found. Run this from a Fougere project root.');
-
-      return;
-    }
-
-    this.ui.step(`${pc.bold(String(result.totalEntities))} entities, ${pc.bold(String(result.totalRefs))} refs, ${pc.bold(String(result.totalFronds))} frond(s)`);
-    this.ui.note(renderFronds(result.declared), 'Fronds');
-    this.ui.note(renderGraph(result.nodes), 'Entity Graph');
-
-    const min = (raw.minEntities as number) ?? 6;
-    if (result.clusters.length > 1 && result.totalEntities >= min) {
-      this.ui.note(renderClusters(result.clusters), 'Suggested Domains');
-    }
-
-    if (result.totalFronds === 1 && result.clusters.length > 1 && result.totalEntities >= min) {
-      this.ui.info(`${pc.dim('Tip:')} ${result.clusters.length} natural domains detected. Consider splitting into separate fronds.`);
-    }
-
-  }
-}
-
-/**
- * Where each frond runs, and which reaches which. Read from `remotes:` and from what handlers
- * ask for — never from a call, so this says the same thing with nothing running.
- */
-function renderFronds(declared: DeclaredTopology): string {
-  const reached = new Map<string, string[]>();
-  for (const edge of declared.edges) {
-    reached.set(edge.from, [...(reached.get(edge.from) ?? []), edge.to]);
-  }
-
-  const width = Math.max(0, ...declared.fronds.map((one) => one.frond.length));
-
-  return declared.fronds.map((one) => {
-    const name = pc.bold(one.frond.padEnd(width));
-    const where = one.placement === 'local' ? pc.dim('local ') : pc.yellow('remote');
-    const at = one.at ? `  ${pc.dim(one.at)}` : '';
-    const calls = reached.get(one.frond);
-    const out = calls ? `  ${pc.dim('→')} ${calls.map((to) => pc.cyan(to)).join(', ')}` : '';
-
-    return `  ${name}  ${where}${at}${out}`;
-  }).join('\n');
-}
-
-function renderGraph(nodes: Record<string, EntityNode>): string {
-  return Object.entries(nodes).map(([name, node]) => {
-    const refs = node.refs.length > 0
-      ? ` ${pc.dim('→')} ${node.refs.map((r) => pc.cyan(r)).join(', ')}`
-      : '';
-    const badge = node.referencedBy.length > 0
-      ? pc.dim(` (${node.referencedBy.length} incoming)`)
-      : '';
-
-    return `  ${pc.bold(name)}${refs}${badge}`;
-  }).join('\n');
-}
-
-function renderClusters(clusters: DomainCluster[]): string {
-  return clusters.map((cluster) => {
-    const header = `  ${pc.green(pc.bold(cluster.name + '/'))}  ${pc.dim(`(${cluster.entities.length} entities)`)}`;
-    const entities = cluster.entities.map((e) => `    ${e}`);
-    const crossRefs = cluster.crossRefs.length > 0
-      ? [`    ${pc.dim('cross-refs:')}`, ...cluster.crossRefs.map((r) =>
-          `      ${r.from} ${pc.dim('→')} ${pc.yellow(r.to)} ${pc.dim(`(${r.targetCluster})`)}`)]
-      : [];
-
-    return [header, ...entities, ...crossRefs, ''].join('\n');
-  }).join('\n');
-}

package/app/commands/KeysCommand.ts

@@ -1,57 +0,0 @@
-import { mkdir, readFile, writeFile, appendFile, access } from 'node:fs/promises';
-import { join } from 'node:path';
-import { generateKeyPair } from '@fougere/core/node';
-import type { App } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import { ROOT_KEY, packed } from './grant-material.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-/**
- * Create the authority — a command, not a service.
- *
- * This is the whole of it: it runs at deployment time and exits. Nothing stays alive,
- * nothing is joined at boot, and no frond reaches anything to prove who it is. What a
- * receiver ends up holding is ONE public key, so a frond granted tomorrow is admitted
- * by a receiver deployed today without its config being touched.
- *
- * The private key is written and never printed: it signs grants, and a grant is the
- * only thing that has to travel.
- */
-export default class KeysCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run() {
-    const path = join(process.cwd(), ROOT_KEY);
-    if (await exists(path)) {
-      this.ui.error(`${ROOT_KEY} already exists — a second root would split the system in two.`);
-      this.ui.info('Delete it deliberately to start over; every grant issued so far stops being recognized.');
-
-      return;
-    }
-
-    const { privateKey, publicKey } = generateKeyPair();
-    await mkdir(join(process.cwd(), '.fougere'), { recursive: true });
-    await writeFile(path, privateKey, { mode: 0o600 });
-    await ignore(ROOT_KEY);
-
-    this.ui.success(`root created — ${ROOT_KEY} (never commit it; added to .gitignore)`);
-    this.ui.note(
-      `FOUGERE_ROOT_KEY=${packed(publicKey)}`,
-      'Every frond that ANSWERS — public, safe in an image or a manifest',
-    );
-    this.ui.info('Then `fougere grant <frond>` for each frond that CALLS.');
-  }
-}
-
-async function exists(path: string): Promise<boolean> {
-  return access(path).then(() => true, () => false);
-}
-
-/** Keep the root out of a commit — the one mistake that cannot be walked back. */
-async function ignore(entry: string): Promise<void> {
-  const path = join(process.cwd(), '.gitignore');
-  const current = await readFile(path, 'utf8').catch(() => '');
-  if (current.split('\n').some((line) => line.trim() === entry)) return;
-  await appendFile(path, `${current.endsWith('\n') || current === '' ? '' : '\n'}${entry}\n`);
-}

package/app/commands/LoadCommand.ts

@@ -1,46 +0,0 @@
-import type { App } from '@fougere/core';
-import { createAppRunner } from '@fougere/core';
-import type { LoadScenario } from '../../fronds/analysis/handlers/LoadHandler.js';
-import type { ui as createUi } from '../../src/ui.js';
-import pc from 'picocolors';
-import { machineWanted, printMachine } from '../../src/machine.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-/**
- * The command the generated header has been naming all along.
- *
- * What it writes is derived — the operations from what the project serves, a body for each from
- * the entity's own fields, the envelope from the one function that states it. What it cannot
- * derive is what the load IS: the weights, the stages and the thresholds are facts about your
- * users, and the file says so where they sit.
- */
-export default class LoadCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    const result = await createAppRunner(this.app)(
-      { entity: 'load', op: 'execute' },
-      { params: {}, query: {}, input: raw, state: {} },
-    ) as LoadScenario;
-
-    if (machineWanted(raw)) return printMachine(result);
-
-    if (result.operations.length === 0) {
-      this.ui.warn('No operation answers the default facade — nothing to put under load.');
-
-      return;
-    }
-
-    if (!result.file) {
-      process.stdout.write(result.script);
-
-      return;
-    }
-
-    this.ui.step(`${pc.bold(String(result.operations.length))} operation(s) against ${pc.dim(result.facade)}`);
-    this.ui.note(result.operations.map((one) => `  ${one}`).join('\n'), 'Under load');
-    this.ui.info(`${pc.dim('Written to')} ${result.file}  ${pc.dim('— edit the weights, the stages and the thresholds.')}`);
-    this.ui.info(`${pc.dim('Then:')} k6 run ${result.file}`);
-  }
-}

package/app/commands/MigrateCommand.ts

@@ -1,61 +0,0 @@
-import { createAppRunner } from '@fougere/core';
-import type { App } from '@fougere/core';
-import type { ui as createUi } from '../../src/ui.js';
-import type { MigrationPlan } from '../../fronds/analysis/handlers/MigrateHandler.js';
-import pc from 'picocolors';
-import { machineWanted, printMachine } from '../../src/machine.js';
-
-type Ui = ReturnType<typeof createUi>;
-
-/**
- * Catching a database up with the frozen chain.
- *
- * Prints by default and moves nothing: what this runs drops and renames columns, so the
- * plan is read before it is agreed to. `--apply` is that agreement.
- */
-export default class MigrateCommand {
-  constructor(private app: App, private ui: Ui) {}
-
-  async run(raw: Record<string, unknown>) {
-    const result = (await createAppRunner(this.app)(
-      { entity: 'migrate', op: 'execute' },
-      { params: {}, query: {}, input: raw, state: {} },
-    )) as MigrationPlan;
-
-    if (machineWanted(raw)) return printMachine(result);
-
-    if (result.chain.length === 0) {
-      this.ui.warn('No frozen step to apply. `fougere freeze <version>` records one.');
-
-      return;
-    }
-
-    if (result.refusals.length > 0) {
-      this.ui.error(`This chain cannot be realised as it stands (${result.chain.join(' → ')}):`);
-      for (const one of result.refusals) this.ui.step(`${pc.bold(`${one.entity}.${one.field}`)} — ${one.reason}`);
-
-      return;
-    }
-
-    if (result.changes.length === 0) {
-      this.ui.success(`Up to date — ${result.chain.join(' → ')} already realised.`);
-
-      return;
-    }
-
-    for (const change of result.changes) {
-      this.ui.step(
-        change.kind === 'renameColumn'
-          ? `${change.table}: ${pc.bold(change.from)} → ${pc.bold(change.to)}`
-          : `${change.table}: drop ${pc.bold(change.column)}`,
-      );
-    }
-
-    if (result.ran.length === 0) {
-      this.ui.info(`${result.changes.length} statement(s) — run again with ${pc.bold('--apply')} to make it so.`);
-
-      return;
-    }
-    this.ui.success(`${result.ran.length} statement(s) run.`);
-  }
-}