@jmoyers/harness 0.1.11 → 0.1.20

package/src/diff-ui/render.ts

@@ -0,0 +1,337 @@
+import { padOrTrimDisplay } from '../mux/dual-pane-core.ts';
+import { renderSyntaxAnsiLine } from './highlight.ts';
+import type {
+  DiffUiModel,
+  DiffUiRenderOutput,
+  DiffUiRenderTheme,
+  DiffUiState,
+  DiffUiSyntaxMode,
+  DiffUiViewMode,
+  DiffUiVirtualRow,
+  DiffUiWordDiffMode,
+} from './types.ts';
+
+const RESET_ANSI = '\u001b[0m';
+
+function fg(index: number): string {
+  return `\u001b[38;5;${String(index)}m`;
+}
+
+function fgBg(fgIndex: number, bgIndex: number, bold = false): string {
+  const boldCode = bold ? '1;' : '';
+  return `\u001b[${boldCode}38;5;${String(fgIndex)};48;5;${String(bgIndex)}m`;
+}
+
+export const DEFAULT_DIFF_UI_THEME: DiffUiRenderTheme = {
+  headerAnsi: fgBg(231, 24, true),
+  footerAnsi: fgBg(252, 236),
+  fileHeaderAnsi: fgBg(230, 238, true),
+  hunkHeaderAnsi: fgBg(159, 237, true),
+  contextAnsi: fg(252),
+  addAnsi: fgBg(120, 22),
+  delAnsi: fgBg(224, 52),
+  noticeAnsi: fgBg(230, 94, true),
+  gutterAnsi: fg(244),
+  resetAnsi: RESET_ANSI,
+  syntaxKeywordAnsi: fg(81),
+  syntaxStringAnsi: fg(114),
+  syntaxCommentAnsi: fg(245),
+  syntaxNumberAnsi: fg(221),
+};
+
+export function resolveDiffUiTheme(theme: string | null): DiffUiRenderTheme {
+  if (theme === null || theme === 'default') {
+    return DEFAULT_DIFF_UI_THEME;
+  }
+  if (theme === 'plain') {
+    return {
+      ...DEFAULT_DIFF_UI_THEME,
+      headerAnsi: '',
+      footerAnsi: '',
+      fileHeaderAnsi: '',
+      hunkHeaderAnsi: '',
+      contextAnsi: '',
+      addAnsi: '',
+      delAnsi: '',
+      noticeAnsi: '',
+      gutterAnsi: '',
+      syntaxKeywordAnsi: '',
+      syntaxStringAnsi: '',
+      syntaxCommentAnsi: '',
+      syntaxNumberAnsi: '',
+    };
+  }
+  throw new Error(`unknown theme: ${theme}`);
+}
+
+function syntaxEnabled(color: boolean, syntaxMode: DiffUiSyntaxMode): boolean {
+  if (!color) {
+    return false;
+  }
+  if (syntaxMode === 'on') {
+    return true;
+  }
+  if (syntaxMode === 'off') {
+    return false;
+  }
+  return true;
+}
+
+function wordDiffEnabled(color: boolean, wordDiffMode: DiffUiWordDiffMode): boolean {
+  if (!color) {
+    return false;
+  }
+  if (wordDiffMode === 'on') {
+    return true;
+  }
+  if (wordDiffMode === 'off') {
+    return false;
+  }
+  return true;
+}
+
+function formatLineNumber(value: number | null): string {
+  if (value === null) {
+    return '    ';
+  }
+  const text = String(value);
+  return padOrTrimDisplay(text.length > 4 ? text.slice(-4) : text.padStart(4, ' '), 4);
+}
+
+function renderUnifiedRow(row: DiffUiVirtualRow, width: number): string {
+  if (row.kind === 'code-add' || row.kind === 'code-del' || row.kind === 'code-context') {
+    const oldCol = formatLineNumber(row.oldLine);
+    const newCol = formatLineNumber(row.newLine);
+    return padOrTrimDisplay(`${oldCol} ${newCol} ${row.unified}`, width);
+  }
+  return padOrTrimDisplay(row.unified, width);
+}
+
+function renderSplitRow(row: DiffUiVirtualRow, width: number): string {
+  if (row.kind !== 'code-add' && row.kind !== 'code-del' && row.kind !== 'code-context') {
+    return padOrTrimDisplay(row.unified, width);
+  }
+
+  const divider = ' │ ';
+  const half = Math.max(1, Math.floor((width - divider.length) / 2));
+  const left = padOrTrimDisplay(`${formatLineNumber(row.oldLine)} ${row.left}`, half);
+  const right = padOrTrimDisplay(`${formatLineNumber(row.newLine)} ${row.right}`, half);
+  return `${left}${divider}${right}`;
+}
+
+function baseAnsiForRow(row: DiffUiVirtualRow, theme: DiffUiRenderTheme): string {
+  if (row.kind === 'file-header') {
+    return theme.fileHeaderAnsi;
+  }
+  if (row.kind === 'hunk-header') {
+    return theme.hunkHeaderAnsi;
+  }
+  if (row.kind === 'code-add') {
+    return theme.addAnsi;
+  }
+  if (row.kind === 'code-del') {
+    return theme.delAnsi;
+  }
+  if (row.kind === 'notice') {
+    return theme.noticeAnsi;
+  }
+  return theme.contextAnsi;
+}
+
+function applyWordDiffHint(text: string, enabled: boolean): string {
+  if (!enabled) {
+    return text;
+  }
+  return text.replaceAll('\t', '  ');
+}
+
+function decorateRow(input: {
+  readonly row: DiffUiVirtualRow;
+  readonly plainText: string;
+  readonly theme: DiffUiRenderTheme;
+  readonly color: boolean;
+  readonly syntaxMode: DiffUiSyntaxMode;
+  readonly wordDiffMode: DiffUiWordDiffMode;
+}): string {
+  const baseAnsi = baseAnsiForRow(input.row, input.theme);
+  const syntaxOn = syntaxEnabled(input.color, input.syntaxMode);
+  const wordDiffOn = wordDiffEnabled(input.color, input.wordDiffMode);
+  const withWordHint = applyWordDiffHint(input.plainText, wordDiffOn);
+
+  let body = withWordHint;
+  if (
+    syntaxOn &&
+    (input.row.kind === 'code-add' ||
+      input.row.kind === 'code-del' ||
+      input.row.kind === 'code-context')
+  ) {
+    body = renderSyntaxAnsiLine({
+      line: body,
+      language: input.row.language,
+      theme: input.theme,
+      colorEnabled: input.color,
+      baseAnsi,
+    });
+  }
+
+  if (!input.color || baseAnsi.length === 0) {
+    return body;
+  }
+  return `${baseAnsi}${body}${input.theme.resetAnsi}`;
+}
+
+function renderHeader(input: {
+  readonly model: DiffUiModel;
+  readonly state: DiffUiState;
+  readonly width: number;
+  readonly color: boolean;
+  readonly theme: DiffUiRenderTheme;
+}): string {
+  const files = input.model.diff.totals.filesChanged;
+  const hunks = input.model.diff.totals.hunks;
+  const lines = input.model.diff.totals.lines;
+  const text = padOrTrimDisplay(
+    `[diff] mode=${input.model.diff.spec.mode} view=${input.state.effectiveViewMode} files=${files} hunks=${hunks} lines=${lines}`,
+    input.width,
+  );
+  if (!input.color || input.theme.headerAnsi.length === 0) {
+    return text;
+  }
+  return `${input.theme.headerAnsi}${text}${input.theme.resetAnsi}`;
+}
+
+function renderFooter(input: {
+  readonly model: DiffUiModel;
+  readonly state: DiffUiState;
+  readonly width: number;
+  readonly height: number;
+  readonly color: boolean;
+  readonly theme: DiffUiRenderTheme;
+}): string {
+  const maxTop = Math.max(0, input.model.rows.length - Math.max(1, input.height - 2));
+  const text = padOrTrimDisplay(
+    `row=${input.state.topRow + 1}/${Math.max(1, input.model.rows.length)} maxTop~${maxTop} file=${input.state.activeFileIndex + 1}/${Math.max(1, input.model.diff.files.length)} finder=${input.state.finderOpen ? 'open' : 'closed'}`,
+    input.width,
+  );
+  if (!input.color || input.theme.footerAnsi.length === 0) {
+    return text;
+  }
+  return `${input.theme.footerAnsi}${text}${input.theme.resetAnsi}`;
+}
+
+function overlayFinderLines(
+  renderedBodyLines: string[],
+  state: DiffUiState,
+  width: number,
+  color: boolean,
+  theme: DiffUiRenderTheme,
+): void {
+  if (!state.finderOpen || renderedBodyLines.length === 0) {
+    return;
+  }
+
+  const lines: string[] = [];
+  lines.push(padOrTrimDisplay(`find: ${state.finderQuery}`, width));
+  const maxRows = Math.max(0, renderedBodyLines.length - 1);
+  for (let index = 0; index < Math.min(maxRows, state.finderResults.length); index += 1) {
+    const row = state.finderResults[index]!;
+    const marker = index === state.finderSelectedIndex ? '>' : ' ';
+    lines.push(padOrTrimDisplay(`${marker} ${row.path}`, width));
+  }
+
+  for (let index = 0; index < lines.length && index < renderedBodyLines.length; index += 1) {
+    const base = lines[index]!;
+    if (!color || theme.hunkHeaderAnsi.length === 0) {
+      renderedBodyLines[index] = base;
+      continue;
+    }
+    renderedBodyLines[index] = `${theme.hunkHeaderAnsi}${base}${theme.resetAnsi}`;
+  }
+}
+
+export function renderDiffUiViewport(input: {
+  readonly model: DiffUiModel;
+  readonly state: DiffUiState;
+  readonly width: number;
+  readonly height: number;
+  readonly viewMode: DiffUiViewMode;
+  readonly syntaxMode: DiffUiSyntaxMode;
+  readonly wordDiffMode: DiffUiWordDiffMode;
+  readonly color: boolean;
+  readonly theme: DiffUiRenderTheme;
+}): DiffUiRenderOutput {
+  const safeWidth = Math.max(40, Math.floor(input.width));
+  const safeHeight = Math.max(6, Math.floor(input.height));
+  const header = renderHeader({
+    model: input.model,
+    state: input.state,
+    width: safeWidth,
+    color: input.color,
+    theme: input.theme,
+  });
+  const footer = renderFooter({
+    model: input.model,
+    state: input.state,
+    width: safeWidth,
+    height: safeHeight,
+    color: input.color,
+    theme: input.theme,
+  });
+
+  const bodyRows = Math.max(1, safeHeight - 2);
+  const start = Math.max(0, input.state.topRow);
+  const end = Math.min(input.model.rows.length, start + bodyRows);
+  const bodyLines: string[] = [];
+
+  for (let index = start; index < end; index += 1) {
+    const row = input.model.rows[index]!;
+    const plainText =
+      input.state.effectiveViewMode === 'split'
+        ? renderSplitRow(row, safeWidth)
+        : renderUnifiedRow(row, safeWidth);
+    bodyLines.push(
+      decorateRow({
+        row,
+        plainText,
+        theme: input.theme,
+        color: input.color,
+        syntaxMode: input.syntaxMode,
+        wordDiffMode: input.wordDiffMode,
+      }),
+    );
+  }
+
+  while (bodyLines.length < bodyRows) {
+    bodyLines.push(padOrTrimDisplay('', safeWidth));
+  }
+
+  overlayFinderLines(bodyLines, input.state, safeWidth, input.color, input.theme);
+
+  return {
+    state: input.state,
+    lines: [header, ...bodyLines, footer],
+  };
+}
+
+export function renderDiffUiDocument(input: {
+  readonly model: DiffUiModel;
+  readonly syntaxMode: DiffUiSyntaxMode;
+  readonly wordDiffMode: DiffUiWordDiffMode;
+  readonly color: boolean;
+  readonly theme: DiffUiRenderTheme;
+}): readonly string[] {
+  const lines: string[] = [];
+  for (const row of input.model.rows) {
+    lines.push(
+      decorateRow({
+        row,
+        plainText: row.unified,
+        theme: input.theme,
+        color: input.color,
+        syntaxMode: input.syntaxMode,
+        wordDiffMode: input.wordDiffMode,
+      }),
+    );
+  }
+  return lines;
+}

package/src/diff-ui/runtime.ts

@@ -0,0 +1,379 @@
+import { fstatSync, readFileSync } from 'node:fs';
+import { createDiffBuilder } from '../diff/build.ts';
+import type { DiffBuildResult, DiffBuilder } from '../diff/types.ts';
+import { Screen, type ScreenWriter } from '../../packages/harness-ui/src/screen.ts';
+import { parseDiffUiArgs } from './args.ts';
+import { diffUiCommandToStateAction, parseDiffUiCommand } from './commands.ts';
+import { buildDiffUiModel } from './model.ts';
+import {
+  runDiffUiPagerProcess,
+  type DiffUiPagerInputStream,
+  type DiffUiPagerOutputStream,
+} from './pager.ts';
+import { renderDiffUiDocument, renderDiffUiViewport, resolveDiffUiTheme } from './render.ts';
+import { createInitialDiffUiState, reduceDiffUiState } from './state.ts';
+import type { DiffUiCliOptions, DiffUiEvent, DiffUiRunOutput, DiffUiState } from './types.ts';
+
+interface RunDiffUiCliDeps {
+  readonly cwd?: string;
+  readonly env?: NodeJS.ProcessEnv;
+  readonly argv?: readonly string[];
+  readonly writeStdout?: (text: string) => void;
+  readonly writeStderr?: (text: string) => void;
+  readonly stdoutCols?: number;
+  readonly stdoutRows?: number;
+  readonly readStdinText?: () => string;
+  readonly createBuilder?: () => DiffBuilder;
+  readonly isStdoutTty?: boolean;
+  readonly readRpcStdinFromFd0?: () => string;
+  readonly resolveStdinFdKind?: () => StdinFdKind;
+  readonly pagerStdin?: DiffUiPagerInputStream;
+  readonly pagerStdout?: DiffUiPagerOutputStream;
+  readonly createScreen?: (writer: ScreenWriter) => Pick<Screen, 'markDirty' | 'flush'>;
+}
+
+type StdinFdKind = 'tty' | 'pipe' | 'file' | 'other';
+
+interface StdinFdStatLike {
+  isCharacterDevice(): boolean;
+  isFIFO(): boolean;
+  isFile(): boolean;
+}
+
+function viewportFromOptions(
+  options: DiffUiCliOptions,
+  deps: RunDiffUiCliDeps,
+): {
+  readonly width: number;
+  readonly height: number;
+} {
+  const width = options.width ?? deps.stdoutCols ?? process.stdout.columns ?? 120;
+  const height = options.height ?? deps.stdoutRows ?? process.stdout.rows ?? 40;
+  return {
+    width: Math.max(40, Math.floor(width)),
+    height: Math.max(6, Math.floor(height)),
+  };
+}
+
+function emitEvents(events: readonly DiffUiEvent[], writeStdout: (text: string) => void): void {
+  for (const event of events) {
+    writeStdout(`${JSON.stringify(event)}\n`);
+  }
+}
+
+function emitRenderedLines(lines: readonly string[], writeStdout: (text: string) => void): void {
+  if (lines.length === 0) {
+    return;
+  }
+  writeStdout(`${lines.join('\n')}\n`);
+}
+
+function stdinFdKindFromStat(stats: StdinFdStatLike): StdinFdKind {
+  if (stats.isCharacterDevice()) {
+    return 'tty';
+  }
+  if (stats.isFIFO()) {
+    return 'pipe';
+  }
+  if (stats.isFile()) {
+    return 'file';
+  }
+  return 'other';
+}
+
+function readProcessStdinTextFromFd0(
+  readFdText: (fd: number, encoding: BufferEncoding) => string = readFileSync,
+): string {
+  return readFdText(0, 'utf8');
+}
+
+function resolveProcessStdinFdKind(
+  readStat: (fd: number) => StdinFdStatLike = (fd) => fstatSync(fd),
+): StdinFdKind {
+  try {
+    return stdinFdKindFromStat(readStat(0));
+  } catch {
+    return 'other';
+  }
+}
+
+function shouldReadRpcStdinFromFd0(isStdinTty: boolean, stdinFdKind: StdinFdKind): boolean {
+  if (isStdinTty) {
+    return false;
+  }
+  return stdinFdKind === 'pipe' || stdinFdKind === 'file';
+}
+
+function readRpcStdinText(
+  readStdinText: (() => string) | undefined,
+  readRpcStdinFromFd0: (() => string) | undefined,
+  resolveStdinFdKind: (() => StdinFdKind) | undefined,
+): string {
+  if (readStdinText !== undefined) {
+    return readStdinText();
+  }
+  const stdinFdKind = (resolveStdinFdKind ?? resolveProcessStdinFdKind)();
+  if (!shouldReadRpcStdinFromFd0(process.stdin.isTTY === true, stdinFdKind)) {
+    return '';
+  }
+  const readFromFd0 = readRpcStdinFromFd0 ?? readProcessStdinTextFromFd0;
+  return readFromFd0();
+}
+
+function renderCurrentViewport(input: {
+  readonly model: ReturnType<typeof buildDiffUiModel>;
+  readonly state: DiffUiState;
+  readonly options: DiffUiCliOptions;
+  readonly width: number;
+  readonly height: number;
+}): readonly string[] {
+  return renderDiffUiViewport({
+    model: input.model,
+    state: input.state,
+    width: input.width,
+    height: input.height,
+    viewMode: input.options.viewMode,
+    syntaxMode: input.options.syntaxMode,
+    wordDiffMode: input.options.wordDiffMode,
+    color: input.options.color,
+    theme: resolveDiffUiTheme(input.options.theme),
+  }).lines;
+}
+
+function renderDocument(input: {
+  readonly model: ReturnType<typeof buildDiffUiModel>;
+  readonly options: DiffUiCliOptions;
+}): readonly string[] {
+  return renderDiffUiDocument({
+    model: input.model,
+    syntaxMode: input.options.syntaxMode,
+    wordDiffMode: input.options.wordDiffMode,
+    color: input.options.color,
+    theme: resolveDiffUiTheme(input.options.theme),
+  });
+}
+
+async function buildDiffResult(
+  options: DiffUiCliOptions,
+  builder: DiffBuilder,
+): Promise<DiffBuildResult> {
+  const gitOptions =
+    options.renameLimit === null
+      ? {
+          noRenames: options.noRenames,
+        }
+      : {
+          noRenames: options.noRenames,
+          renameLimit: options.renameLimit,
+        };
+
+  const buildOptions = {
+    cwd: options.cwd,
+    mode: options.mode,
+    ...(options.baseRef !== null ? { baseRef: options.baseRef } : {}),
+    ...(options.headRef !== null ? { headRef: options.headRef } : {}),
+    includeGenerated: options.includeGenerated,
+    includeBinary: options.includeBinary,
+    git: gitOptions,
+    budget: options.budget,
+  };
+
+  return await builder.build(buildOptions);
+}
+
+export async function runDiffUiCli(deps: RunDiffUiCliDeps = {}): Promise<DiffUiRunOutput> {
+  const writeStdout = deps.writeStdout ?? ((text) => process.stdout.write(text));
+  const writeStderr = deps.writeStderr ?? ((text) => process.stderr.write(text));
+  const argv = deps.argv ?? process.argv.slice(2);
+  const events: DiffUiEvent[] = [];
+
+  try {
+    const options = parseDiffUiArgs(argv, {
+      ...(deps.cwd !== undefined ? { cwd: deps.cwd } : {}),
+      ...(deps.env !== undefined ? { env: deps.env } : {}),
+      ...(deps.isStdoutTty !== undefined ? { isStdoutTty: deps.isStdoutTty } : {}),
+    });
+
+    if (options.watch) {
+      events.push({
+        type: 'warning',
+        message: '--watch is parsed but not yet implemented; running one-shot render',
+      });
+    }
+
+    const builder = deps.createBuilder?.() ?? createDiffBuilder();
+    const diffResult = await buildDiffResult(options, builder);
+    const model = buildDiffUiModel(diffResult.diff);
+    const viewport = viewportFromOptions(options, deps);
+    const pageSize = Math.max(1, viewport.height - 2);
+
+    events.push({
+      type: 'diff.loaded',
+      files: model.diff.totals.filesChanged,
+      hunks: model.diff.totals.hunks,
+      lines: model.diff.totals.lines,
+      coverageReason: model.diff.coverage.reason,
+    });
+
+    let state = createInitialDiffUiState(model, options.viewMode, viewport.width);
+    let renderedLines: readonly string[] = [];
+
+    if (options.pager) {
+      const pagerResult = await runDiffUiPagerProcess({
+        model,
+        options,
+        initialState: state,
+        writeStdout,
+        writeStderr,
+        stdin: deps.pagerStdin ?? (process.stdin as unknown as DiffUiPagerInputStream),
+        stdout: deps.pagerStdout ?? (process.stdout as unknown as DiffUiPagerOutputStream),
+        createScreen:
+          deps.createScreen ??
+          ((writer) => {
+            return new Screen(writer);
+          }),
+      });
+      state = pagerResult.state;
+      renderedLines = pagerResult.renderedLines;
+      events.push(...pagerResult.events);
+      return {
+        exitCode: 0,
+        events,
+        renderedLines,
+      };
+    }
+
+    if (options.rpcStdio) {
+      renderedLines = renderCurrentViewport({
+        model,
+        state,
+        options,
+        width: viewport.width,
+        height: viewport.height,
+      });
+      events.push({
+        type: 'state.changed',
+        state,
+      });
+      events.push({
+        type: 'render.completed',
+        rows: renderedLines.length,
+        width: viewport.width,
+        height: viewport.height,
+        view: state.effectiveViewMode,
+      });
+
+      const stdinText = readRpcStdinText(
+        deps.readStdinText,
+        deps.readRpcStdinFromFd0,
+        deps.resolveStdinFdKind,
+      );
+      for (const rawLine of stdinText.split('\n')) {
+        const line = rawLine.trim();
+        if (line.length === 0) {
+          continue;
+        }
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          events.push({
+            type: 'warning',
+            message: `invalid json command: ${line}`,
+          });
+          continue;
+        }
+
+        const command = parseDiffUiCommand(parsed);
+        if (command === null) {
+          events.push({
+            type: 'warning',
+            message: `invalid command payload: ${line}`,
+          });
+          continue;
+        }
+        if (command.type === 'session.quit') {
+          events.push({
+            type: 'session.quit',
+          });
+          break;
+        }
+
+        const action = diffUiCommandToStateAction(command, pageSize);
+        state = reduceDiffUiState({
+          model,
+          state,
+          action,
+          viewportWidth: viewport.width,
+          viewportHeight: viewport.height,
+        });
+        renderedLines = renderCurrentViewport({
+          model,
+          state,
+          options,
+          width: viewport.width,
+          height: viewport.height,
+        });
+
+        events.push({
+          type: 'state.changed',
+          state,
+        });
+        events.push({
+          type: 'render.completed',
+          rows: renderedLines.length,
+          width: viewport.width,
+          height: viewport.height,
+          view: state.effectiveViewMode,
+        });
+      }
+    } else {
+      renderedLines = renderDocument({
+        model,
+        options,
+      });
+      events.push({
+        type: 'state.changed',
+        state,
+      });
+      events.push({
+        type: 'render.completed',
+        rows: renderedLines.length,
+        width: viewport.width,
+        height: viewport.height,
+        view: state.effectiveViewMode,
+      });
+    }
+
+    if (options.jsonEvents || options.rpcStdio) {
+      emitEvents(events, writeStdout);
+    } else {
+      emitRenderedLines(renderedLines, writeStdout);
+    }
+
+    return {
+      exitCode: 0,
+      events,
+      renderedLines,
+    };
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeStderr(`[diff-ui] ${message}\n`);
+    const warning: DiffUiEvent = {
+      type: 'warning',
+      message,
+    };
+    return {
+      exitCode: 1,
+      events: [warning],
+      renderedLines: [],
+    };
+  }
+}
+
+export const __diffUiRuntimeInternals = {
+  stdinFdKindFromStat,
+  readProcessStdinTextFromFd0,
+  shouldReadRpcStdinFromFd0,
+  resolveProcessStdinFdKind,
+};