@prisma-next/cli 0.11.0-dev.48 → 0.11.0-dev.49

package/src/utils/formatters/migration-list-graph-layout.ts

@@ -0,0 +1,268 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import {
+  classifyMigrationListGraphTopology,
+  type MigrationEdgeKind,
+  type MigrationListGraphTopology,
+} from '@prisma-next/migration-tools/migration-list-graph-topology';
+import type { MigrationListEntry } from '@prisma-next/migration-tools/migration-list-types';
+
+export type ConnectorKind = 'fanBelow' | 'joinAbove';
+
+export interface MigrationLayoutRow {
+  readonly kind: 'migration';
+  readonly entry: MigrationListEntry;
+  readonly edgeKind: MigrationEdgeKind;
+  readonly laneIndex: number;
+  readonly passThroughLanes: readonly number[];
+  readonly woven: boolean;
+}
+
+export interface NodeLineLayoutRow {
+  readonly kind: 'nodeLine';
+  readonly contractHash: string;
+  readonly laneIndex: number;
+}
+
+export interface ConnectorLayoutRow {
+  readonly kind: 'connector';
+  readonly connectorKind: ConnectorKind;
+  readonly contractHash: string;
+  readonly startLane: number;
+  readonly endLane: number;
+  readonly branchCount: number;
+}
+
+export type LayoutRow = MigrationLayoutRow | NodeLineLayoutRow | ConnectorLayoutRow;
+
+export interface MigrationListGraphLayout {
+  readonly rows: readonly LayoutRow[];
+}
+
+interface LaneState {
+  want: string;
+  active: boolean;
+}
+
+function canonicalFrom(from: string | null): string {
+  return from ?? EMPTY_CONTRACT_HASH;
+}
+
+function forwardInDegree(topology: MigrationListGraphTopology, hash: string): number {
+  return topology.forwardInDegree.get(hash) ?? 0;
+}
+
+function forwardOutDegree(topology: MigrationListGraphTopology, hash: string): number {
+  return topology.forwardOutDegree.get(hash) ?? 0;
+}
+
+function buildForwardProducersByTo(
+  entries: readonly MigrationListEntry[],
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
+): Map<string, MigrationListEntry[]> {
+  const byTo = new Map<string, MigrationListEntry[]>();
+  for (const entry of entries) {
+    if (kindByMigrationHash.get(entry.migrationHash) !== 'forward') continue;
+    const bucket = byTo.get(entry.to);
+    if (bucket) bucket.push(entry);
+    else byTo.set(entry.to, [entry]);
+  }
+  return byTo;
+}
+
+function countForwardProducersTo(
+  forwardProducersByTo: Map<string, MigrationListEntry[]>,
+  contract: string,
+): number {
+  return forwardProducersByTo.get(contract)?.length ?? 0;
+}
+
+function hasLaterForwardDepartingFrom(
+  entries: readonly MigrationListEntry[],
+  startIndex: number,
+  contract: string,
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
+): boolean {
+  for (let index = startIndex + 1; index < entries.length; index++) {
+    const later = entries[index];
+    if (later === undefined) continue;
+    if (kindByMigrationHash.get(later.migrationHash) !== 'forward') continue;
+    if (canonicalFrom(later.from) === contract) return true;
+  }
+  return false;
+}
+
+export function computeMigrationListGraphLayout(
+  entries: readonly MigrationListEntry[],
+  topology: MigrationListGraphTopology = classifyMigrationListGraphTopology(entries),
+): MigrationListGraphLayout {
+  const { kindByMigrationHash } = topology;
+  const forwardProducersByTo = buildForwardProducersByTo(entries, kindByMigrationHash);
+  const convergencesEmitted = new Set<string>();
+  const producerLaneByHash = new Map<string, number>();
+  const lanes: LaneState[] = [];
+  const rows: LayoutRow[] = [];
+
+  function emitNodeLine(contractHash: string): void {
+    rows.push({ kind: 'nodeLine', contractHash, laneIndex: 0 });
+  }
+
+  function emitConnector(
+    connectorKind: ConnectorKind,
+    contractHash: string,
+    startLane: number,
+    endLane: number,
+    branchCount: number,
+  ): void {
+    rows.push({
+      kind: 'connector',
+      connectorKind,
+      contractHash,
+      startLane,
+      endLane,
+      branchCount,
+    });
+  }
+
+  function activeLaneIndices(): number[] {
+    const indices: number[] = [];
+    for (let index = 0; index < lanes.length; index++) {
+      if (lanes[index]?.active) indices.push(index);
+    }
+    return indices;
+  }
+
+  function lanesWanting(contract: string): number[] {
+    const indices: number[] = [];
+    for (let index = 0; index < lanes.length; index++) {
+      const lane = lanes[index];
+      if (lane?.active && lane.want === contract) indices.push(index);
+    }
+    return indices;
+  }
+
+  function ensureLane(index: number): void {
+    while (lanes.length <= index) {
+      lanes.push({ want: '', active: false });
+    }
+  }
+
+  function openLaneAtRight(want: string): number {
+    const index = lanes.length;
+    lanes.push({ want, active: true });
+    return index;
+  }
+
+  function closeLane(index: number): void {
+    ensureLane(index);
+    const lane = lanes[index];
+    if (lane) lane.active = false;
+  }
+
+  function emitJoinAbove(contractHash: string, laneIndices: readonly number[]): void {
+    if (laneIndices.length < 2) return;
+    const startLane = Math.min(...laneIndices);
+    const endLane = Math.max(...laneIndices);
+    emitConnector('joinAbove', contractHash, startLane, endLane, laneIndices.length);
+    for (const index of laneIndices) {
+      if (index !== startLane) closeLane(index);
+    }
+  }
+
+  function emitConvergencePreamble(contract: string): void {
+    if (convergencesEmitted.has(contract)) return;
+    if (forwardInDegree(topology, contract) < 2) return;
+
+    const consumersWanting = lanesWanting(contract);
+    if (forwardOutDegree(topology, contract) >= 2 && consumersWanting.length >= 2) {
+      emitJoinAbove(contract, consumersWanting);
+    }
+
+    emitNodeLine(contract);
+    const producers = forwardProducersByTo.get(contract) ?? [];
+    if (producers.length >= 2) {
+      emitConnector('fanBelow', contract, 0, producers.length - 1, producers.length);
+    }
+
+    for (const [producerIndex, producer] of producers.entries()) {
+      ensureLane(producerIndex);
+      lanes[producerIndex] = { want: canonicalFrom(producer.from), active: true };
+      producerLaneByHash.set(producer.migrationHash, producerIndex);
+    }
+
+    convergencesEmitted.add(contract);
+  }
+
+  function placeWoven(
+    entry: MigrationListEntry,
+    edgeKind: MigrationEdgeKind,
+    laneIndex: number,
+  ): void {
+    const passThroughLanes = activeLaneIndices().filter((index) => index !== laneIndex);
+    rows.push({
+      kind: 'migration',
+      entry,
+      edgeKind,
+      laneIndex,
+      passThroughLanes,
+      woven: true,
+    });
+    ensureLane(laneIndex);
+    lanes[laneIndex] = { want: canonicalFrom(entry.from), active: true };
+  }
+
+  function placeUnwoven(entry: MigrationListEntry, edgeKind: MigrationEdgeKind): void {
+    const passThroughLanes = activeLaneIndices();
+    const laneIndex = passThroughLanes.length === 0 ? 0 : Math.max(...passThroughLanes) + 1;
+    rows.push({
+      kind: 'migration',
+      entry,
+      edgeKind,
+      laneIndex,
+      passThroughLanes,
+      woven: false,
+    });
+  }
+
+  for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
+    const entry = entries[entryIndex]!;
+    const edgeKind = kindByMigrationHash.get(entry.migrationHash) ?? 'forward';
+    const to = entry.to;
+
+    if (edgeKind !== 'forward') {
+      placeUnwoven(entry, edgeKind);
+      continue;
+    }
+
+    if (forwardInDegree(topology, to) >= 2 && !convergencesEmitted.has(to)) {
+      emitConvergencePreamble(to);
+    }
+
+    const presetLane = producerLaneByHash.get(entry.migrationHash);
+    const wantingTo = lanesWanting(to);
+
+    if (wantingTo.length >= 2 && countForwardProducersTo(forwardProducersByTo, to) === 1) {
+      emitJoinAbove(to, wantingTo);
+    }
+
+    if (presetLane !== undefined) {
+      placeWoven(entry, edgeKind, presetLane);
+      continue;
+    }
+
+    const firstWanting = wantingTo[0];
+    if (firstWanting !== undefined) {
+      placeWoven(entry, edgeKind, firstWanting);
+      continue;
+    }
+
+    if (hasLaterForwardDepartingFrom(entries, entryIndex, to, kindByMigrationHash)) {
+      placeUnwoven(entry, edgeKind);
+      continue;
+    }
+
+    const tipLaneIndex = openLaneAtRight(canonicalFrom(entry.from));
+    placeWoven(entry, edgeKind, tipLaneIndex);
+  }
+
+  return { rows };
+}

package/src/utils/formatters/migration-list-graph-render.ts

@@ -1,85 +1,67 @@
-import type {
-  ConnectorLayoutRow,
-  LayoutRow,
-  MigrationLayoutRow,
-  MigrationListGraphLayout,
-  NodeLineLayoutRow,
-} from '@prisma-next/migration-tools/migration-list-graph-layout';
-import { computeMigrationListGraphLayout } from '@prisma-next/migration-tools/migration-list-graph-layout';
-import type { EdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
+import type { MigrationListGraphTopology } from '@prisma-next/migration-tools/migration-list-graph-topology';
 import type {
   MigrationListEntry,
   MigrationListResult,
 } from '@prisma-next/migration-tools/migration-list-types';
+import type { GlyphMode } from '../glyph-mode';
 import {
   abbreviateContractHash,
   computeMigrationDirNameWidth,
   formatMigrationDataColumn,
   formatNodeLineDataColumn,
-  MIGRATION_LIST_EMPTY_SOURCE,
-  MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+  MIGRATION_LIST_ASCII_KIND_GLYPH,
+  MIGRATION_LIST_UNICODE_KIND_GLYPH,
+  migrationListEmptySource,
+  migrationListForwardArrow,
 } from './migration-list-data-column';
+import type {
+  ConnectorLayoutRow,
+  LayoutRow,
+  MigrationLayoutRow,
+  MigrationListGraphLayout,
+  NodeLineLayoutRow,
+} from './migration-list-graph-layout';
+import { computeMigrationListGraphLayout } from './migration-list-graph-layout';
 import type { MigrationListStyler } from './migration-list-render';
 
-export type GlyphMode = 'unicode' | 'ascii';
-
-export interface GlyphModeInput {
-  readonly isTTY: boolean;
-  readonly env: Readonly<Record<string, string | undefined>>;
-}
+export type { GlyphMode } from '../glyph-mode';
 
 interface GlyphPalette {
   readonly lane: string;
   readonly node: string;
   readonly forwardArrow: string;
   readonly emptySource: string;
-  readonly kind: Record<EdgeKind, string>;
+  readonly kind: typeof MIGRATION_LIST_UNICODE_KIND_GLYPH;
   readonly fanBelow: (branchCount: number) => string;
-  readonly joinBelow: (branchCount: number) => string;
+  readonly joinAbove: (branchCount: number) => string;
 }
 
 const UNICODE_PALETTE: GlyphPalette = {
   lane: '│',
   node: 'o',
-  forwardArrow: MIGRATION_LIST_FORWARD_EDGE_GLYPH,
-  emptySource: MIGRATION_LIST_EMPTY_SOURCE,
-  kind: { forward: '*', rollback: '↩', self: '⟲' },
+  forwardArrow: migrationListForwardArrow('unicode'),
+  emptySource: migrationListEmptySource('unicode'),
+  kind: MIGRATION_LIST_UNICODE_KIND_GLYPH,
   fanBelow: (branchCount) => (branchCount === 2 ? '├─┐' : '├─┬─┐'),
-  joinBelow: (branchCount) => (branchCount === 2 ? '├─┘' : '└─┴─┘'),
+  joinAbove: (branchCount) => (branchCount === 2 ? '├─┘' : '└─┴─┘'),
 };
 
 const ASCII_PALETTE: GlyphPalette = {
   lane: '|',
   node: 'o',
-  forwardArrow: '->',
-  emptySource: '-',
-  kind: { forward: '*', rollback: '<', self: '~' },
+  forwardArrow: migrationListForwardArrow('ascii'),
+  emptySource: migrationListEmptySource('ascii'),
+  kind: MIGRATION_LIST_ASCII_KIND_GLYPH,
   fanBelow: (branchCount) => (branchCount === 2 ? '+-\\' : '+-|-\\'),
-  joinBelow: (branchCount) => (branchCount === 2 ? '+-/' : '/-+-/'),
+  joinAbove: (branchCount) => (branchCount === 2 ? '+-/' : '/-+-/'),
 };
 
 function paletteFor(mode: GlyphMode): GlyphPalette {
   return mode === 'ascii' ? ASCII_PALETTE : UNICODE_PALETTE;
 }
 
-function localeString(env: Readonly<Record<string, string | undefined>>): string {
-  return env['LC_ALL'] ?? env['LC_CTYPE'] ?? env['LANG'] ?? '';
-}
-
-function isUtf8Locale(env: Readonly<Record<string, string | undefined>>): boolean {
-  const locale = localeString(env);
-  if (locale.length === 0) return false;
-  return /UTF-8|utf8/i.test(locale);
-}
-
-export function detectGlyphMode(input: GlyphModeInput): GlyphMode {
-  if (!input.isTTY) return 'ascii';
-  if (!isUtf8Locale(input.env)) return 'ascii';
-  return 'unicode';
-}
-
-function migrationEntries(layout: MigrationListGraphLayout) {
-  const entries = [];
+function migrationEntries(layout: MigrationListGraphLayout): MigrationListEntry[] {
+  const entries: MigrationListEntry[] = [];
   for (const row of layout.rows) {
     if (row.kind === 'migration') entries.push(row.entry);
   }
@@ -117,7 +99,7 @@ function renderMigrationGutter(
   const cells: string[] = [];
   for (let lane = 0; lane <= maxLane; lane++) {
     if (lane === row.laneIndex) {
-      cells.push(laneCell(palette.kind[row.edgeKind]));
+      cells.push(laneCell(style.kind(palette.kind[row.edgeKind])));
     } else if (row.passThroughLanes.includes(lane)) {
       cells.push(laneCell(style.lane(palette.lane)));
     } else {
@@ -159,7 +141,7 @@ function renderConnectorGutter(
   let spanGlyph = (
     row.connectorKind === 'fanBelow'
       ? palette.fanBelow(row.branchCount)
-      : palette.joinBelow(row.branchCount)
+      : palette.joinAbove(row.branchCount)
   )
     .padEnd(spanWidth, ' ')
     .slice(0, spanWidth);
@@ -245,7 +227,7 @@ export function renderMigrationListGraphWithStyle(
     openLanes = advanceOpenLanes(row, openLanes);
   }
 
-  return lines.join('\n');
+  return lines.map((line) => line.trimEnd()).join('\n');
 }
 
 export function renderMigrationListGraph(
@@ -270,6 +252,7 @@ function renderGraphSpaceBlock(
   multiSpace: boolean,
   style: MigrationListStyler,
   glyphMode: GlyphMode,
+  topology: MigrationListGraphTopology,
 ): readonly string[] {
   if (migrations.length === 0) {
     const emptyLine = formatGraphEmptyStateLine(spaceId, style);
@@ -279,7 +262,7 @@ function renderGraphSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const layout = computeMigrationListGraphLayout(migrations);
+  const layout = computeMigrationListGraphLayout(migrations, topology);
   const graphBody = renderMigrationListGraphWithStyle(layout, style, glyphMode);
   const rows = graphBody.split('\n');
   if (!multiSpace) {
@@ -292,6 +275,7 @@ export function renderMigrationListGraphResult(
   result: MigrationListResult,
   style: MigrationListStyler,
   glyphMode: GlyphMode,
+  topologyBySpaceId: ReadonlyMap<string, MigrationListGraphTopology>,
 ): string {
   const multiSpace = result.spaces.length > 1;
   const lines: string[] = [];
@@ -301,8 +285,19 @@ export function renderMigrationListGraphResult(
     if (index > 0) {
       lines.push('');
     }
+    const topology = topologyBySpaceId.get(space.spaceId);
+    if (topology === undefined) {
+      throw new Error(`missing topology for space ${space.spaceId}`);
+    }
     lines.push(
-      ...renderGraphSpaceBlock(space.spaceId, space.migrations, multiSpace, style, glyphMode),
+      ...renderGraphSpaceBlock(
+        space.spaceId,
+        space.migrations,
+        multiSpace,
+        style,
+        glyphMode,
+        topology,
+      ),
     );
   }
 

package/src/utils/formatters/migration-list-render.ts

@@ -1,30 +1,28 @@
 import {
   classifyMigrationListGraphTopology,
-  type EdgeKind,
+  type MigrationEdgeKind,
+  type MigrationListGraphTopology,
 } from '@prisma-next/migration-tools/migration-list-graph-topology';
 import type {
   MigrationListEntry,
   MigrationListResult,
 } from '@prisma-next/migration-tools/migration-list-types';
+import type { GlyphMode } from '../glyph-mode';
 import {
   computeMigrationDirNameWidth,
   formatMigrationDataColumn,
-  MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+  migrationListEmptySource,
+  migrationListForwardArrow,
+  migrationListKindGlyph,
 } from './migration-list-data-column';
 
-export type { EdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
-
+export type { MigrationEdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
 export type {
   MigrationListEntry,
   MigrationListResult,
   MigrationSpaceListEntry,
 } from '@prisma-next/migration-tools/migration-list-types';
-
-const KIND_GLYPH: Record<EdgeKind, string> = {
-  forward: '*',
-  rollback: '↩',
-  self: '⟲',
-};
+export type { GlyphMode } from '../glyph-mode';
 
 /**
  * Semantic styler for `migration list` output tokens. Token-typed so
@@ -69,23 +67,25 @@ export const IDENTITY_MIGRATION_LIST_STYLER: MigrationListStyler = {
 
 function resolveEdgeKind(
   migrationHash: string,
-  kindByMigrationHash: ReadonlyMap<string, EdgeKind>,
-): EdgeKind {
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
+): MigrationEdgeKind {
   return kindByMigrationHash.get(migrationHash) ?? 'forward';
 }
 
 function formatMigrationRow(
   migration: MigrationListEntry,
   dirNameWidth: number,
-  edgeKind: EdgeKind,
+  edgeKind: MigrationEdgeKind,
+  glyphMode: GlyphMode,
   style: MigrationListStyler,
 ): string {
-  const kindColumn = `${style.kind(KIND_GLYPH[edgeKind])} `;
+  const kindColumn = `${style.kind(migrationListKindGlyph(glyphMode, edgeKind))} `;
   const data = formatMigrationDataColumn(migration, {
     dirNameWidth,
     edgeKind,
     style,
-    forwardArrow: MIGRATION_LIST_FORWARD_EDGE_GLYPH,
+    forwardArrow: migrationListForwardArrow(glyphMode),
+    emptySource: migrationListEmptySource(glyphMode),
   });
   return `${kindColumn}${data}`;
 }
@@ -98,6 +98,8 @@ function renderSpaceBlock(
   spaceId: string,
   migrations: readonly MigrationListEntry[],
   multiSpace: boolean,
+  glyphMode: GlyphMode,
+  kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>,
   style: MigrationListStyler,
 ): readonly string[] {
   if (migrations.length === 0) {
@@ -108,13 +110,13 @@ function renderSpaceBlock(
     return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
   }
 
-  const kindByMigrationHash = classifyMigrationListGraphTopology(migrations).kindByMigrationHash;
   const dirNameWidth = computeMigrationDirNameWidth(migrations);
   const rows = migrations.map((entry) =>
     formatMigrationRow(
       entry,
       dirNameWidth,
       resolveEdgeKind(entry.migrationHash, kindByMigrationHash),
+      glyphMode,
       style,
     ),
   );
@@ -124,6 +126,16 @@ function renderSpaceBlock(
   return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
 }
 
+export function buildMigrationListTopologyBySpace(
+  result: MigrationListResult,
+): ReadonlyMap<string, MigrationListGraphTopology> {
+  const topologyBySpaceId = new Map<string, MigrationListGraphTopology>();
+  for (const space of result.spaces) {
+    topologyBySpaceId.set(space.spaceId, classifyMigrationListGraphTopology(space.migrations));
+  }
+  return topologyBySpaceId;
+}
+
 /**
  * Compose the styled `migration list` output. The renderer is
  * presentation-neutral — every token passes through `style` before
@@ -135,6 +147,11 @@ function renderSpaceBlock(
 export function renderMigrationListWithStyle(
   result: MigrationListResult,
   style: MigrationListStyler,
+  glyphMode: GlyphMode = 'unicode',
+  topologyBySpaceId: ReadonlyMap<
+    string,
+    MigrationListGraphTopology
+  > = buildMigrationListTopologyBySpace(result),
 ): string {
   const multiSpace = result.spaces.length > 1;
   const lines: string[] = [];
@@ -144,7 +161,20 @@ export function renderMigrationListWithStyle(
     if (index > 0) {
       lines.push('');
     }
-    lines.push(...renderSpaceBlock(space.spaceId, space.migrations, multiSpace, style));
+    const topology = topologyBySpaceId.get(space.spaceId);
+    const kindByMigrationHash =
+      topology?.kindByMigrationHash ??
+      classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
+    lines.push(
+      ...renderSpaceBlock(
+        space.spaceId,
+        space.migrations,
+        multiSpace,
+        glyphMode,
+        kindByMigrationHash,
+        style,
+      ),
+    );
   }
 
   const totalMigrations = result.spaces.reduce(

package/src/utils/formatters/migration-list-styler.ts

@@ -24,6 +24,7 @@ function styleRefName(name: string): string {
  * - `dirName`: bold
  * - `sourceHash`: dim cyan
  * - `destHash`: bright cyan
+ * - `kind` (`*` / `↩` / `⟲`): bright — the signal; lanes and arrows dim
  * - `glyph` (`→` / `⟲` / `∅`): dim
  * - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
  * - `invariants` (`{...}`): yellow
@@ -39,7 +40,8 @@ export function createAnsiMigrationListStyler(opts: {
     return IDENTITY_MIGRATION_LIST_STYLER;
   }
   return {
-    kind: (text) => dim(text),
+    // Kind glyphs stay bright in both flat and graph views; lanes carry the dim gutter.
+    kind: (text) => text,
     dirName: (text) => bold(text),
     sourceHash: (text) => dim(cyan(text)),
     destHash: (text) => cyanBright(text),

package/src/utils/glyph-mode.ts

@@ -0,0 +1,22 @@
+export type GlyphMode = 'unicode' | 'ascii';
+
+export interface GlyphModeInput {
+  readonly isTTY: boolean;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}
+
+function localeString(env: Readonly<Record<string, string | undefined>>): string {
+  return env['LC_ALL'] ?? env['LC_CTYPE'] ?? env['LANG'] ?? '';
+}
+
+function isUtf8Locale(env: Readonly<Record<string, string | undefined>>): boolean {
+  const locale = localeString(env);
+  if (locale.length === 0) return false;
+  return /UTF-8|utf8/i.test(locale);
+}
+
+export function detectGlyphMode(input: GlyphModeInput): GlyphMode {
+  if (!input.isTTY) return 'ascii';
+  if (!isUtf8Locale(input.env)) return 'ascii';
+  return 'unicode';
+}

package/src/utils/terminal-ui.ts

@@ -1,11 +1,7 @@
 import * as clack from '@clack/prompts';
 import { bold, cyan, dim, green, red, yellow } from 'colorette';
-import {
-  detectGlyphMode,
-  type GlyphMode,
-  type GlyphModeInput,
-} from './formatters/migration-list-graph-render';
 import type { GlobalFlags } from './global-flags';
+import { detectGlyphMode, type GlyphMode, type GlyphModeInput } from './glyph-mode';
 import { shutdownSignal } from './shutdown';
 
 export interface TerminalUIRuntime extends GlyphModeInput {}