@jmoyers/harness 0.1.0

package/src/mux/workspace-rail.ts

@@ -0,0 +1,247 @@
+import {
+  createUiSurface,
+  DEFAULT_UI_STYLE,
+  drawUiText,
+  fillUiRow,
+  renderUiSurfaceAnsiRows,
+  type UiStyle,
+} from '../ui/surface.ts';
+import { paintUiRow } from '../ui/kit.ts';
+import { measureDisplayWidth } from '../terminal/snapshot-oracle.ts';
+import { buildWorkspaceRailViewRows } from './workspace-rail-model.ts';
+import { getActiveMuxTheme, type MuxWorkspaceRailTheme } from '../ui/mux-theme.ts';
+
+type WorkspaceRailModel = Parameters<typeof buildWorkspaceRailViewRows>[0];
+type WorkspaceRailViewRow = ReturnType<typeof buildWorkspaceRailViewRows>[number];
+
+const INLINE_THREAD_BUTTON_LABEL = '[+ thread]';
+
+function conversationStatusIconStyle(
+  status: WorkspaceRailViewRow['conversationStatus'],
+  active: boolean,
+  theme: MuxWorkspaceRailTheme,
+): UiStyle {
+  return {
+    fg:
+      status === 'working'
+        ? theme.statusColors.working
+        : status === 'exited'
+          ? theme.statusColors.exited
+          : status === 'needs-action'
+            ? theme.statusColors.needsAction
+            : status === 'starting'
+              ? theme.statusColors.starting
+              : theme.statusColors.idle,
+    bg: active ? theme.activeRowStyle.bg : { kind: 'default' },
+    bold: status === 'working',
+  };
+}
+
+function treeTextStartColumn(text: string): number {
+  let index = 0;
+  while (index < text.length) {
+    const token = text[index]!;
+    if (token === '│' || token === '├' || token === '└' || token === '─' || token === ' ') {
+      index += 1;
+      continue;
+    }
+    break;
+  }
+  return index;
+}
+
+function drawTreeRow(
+  surface: ReturnType<typeof createUiSurface>,
+  rowIndex: number,
+  row: WorkspaceRailViewRow,
+  theme: MuxWorkspaceRailTheme,
+  contentStyle: UiStyle,
+  activeContentStyle: UiStyle | null,
+  options: {
+    buttonLabel?: string;
+    buttonStyle?: UiStyle;
+    alignButtonRight?: boolean;
+  } = {},
+): void {
+  fillUiRow(surface, rowIndex, theme.normalStyle);
+  const buttonLabel = options.buttonLabel;
+  const buttonStyle = options.buttonStyle;
+  const alignButtonRight = options.alignButtonRight ?? false;
+  const buttonTextStart = buttonLabel === undefined ? -1 : row.text.lastIndexOf(buttonLabel);
+  const baseRowText =
+    alignButtonRight && buttonLabel !== undefined && buttonTextStart >= 0
+      ? row.text.slice(0, buttonTextStart).trimEnd()
+      : row.text;
+  const contentStart = treeTextStartColumn(baseRowText);
+  const treePrefix = baseRowText.slice(0, contentStart);
+  const content = baseRowText.slice(contentStart);
+  drawUiText(surface, 0, rowIndex, treePrefix, theme.mutedStyle);
+  drawUiText(
+    surface,
+    contentStart,
+    rowIndex,
+    content,
+    row.active && activeContentStyle !== null ? activeContentStyle : contentStyle,
+  );
+  if (buttonLabel === undefined || buttonStyle === undefined) {
+    return;
+  }
+  if (buttonTextStart < 0) {
+    return;
+  }
+  const buttonWidth = Math.max(1, measureDisplayWidth(buttonLabel));
+  const buttonStart = alignButtonRight ? Math.max(0, surface.cols - buttonWidth) : buttonTextStart;
+  drawUiText(surface, buttonStart, rowIndex, buttonLabel, buttonStyle);
+}
+
+function drawActionRow(
+  surface: ReturnType<typeof createUiSurface>,
+  rowIndex: number,
+  row: WorkspaceRailViewRow,
+  theme: MuxWorkspaceRailTheme,
+): void {
+  fillUiRow(surface, rowIndex, theme.normalStyle);
+  if (row.railAction === 'project.add') {
+    drawUiText(surface, 0, rowIndex, '│', theme.mutedStyle);
+    const buttonStart = Math.max(0, Math.floor((surface.cols - row.text.length) / 2));
+    drawUiText(surface, buttonStart, rowIndex, row.text, theme.actionStyle);
+    return;
+  }
+  drawUiText(surface, 0, rowIndex, row.text, theme.mutedStyle);
+  const buttonStart = row.text.indexOf('[');
+  const buttonEnd = row.text.lastIndexOf(']');
+  const safeButtonStart = Math.max(0, buttonStart);
+  drawUiText(
+    surface,
+    safeButtonStart,
+    rowIndex,
+    row.text.slice(safeButtonStart, Math.max(safeButtonStart, buttonEnd + 1)),
+    theme.actionStyle,
+  );
+}
+
+function drawDirectoryHeaderRow(
+  surface: ReturnType<typeof createUiSurface>,
+  rowIndex: number,
+  row: WorkspaceRailViewRow,
+  theme: MuxWorkspaceRailTheme,
+): void {
+  drawTreeRow(surface, rowIndex, row, theme, theme.headerStyle, theme.activeRowStyle, {
+    buttonLabel: INLINE_THREAD_BUTTON_LABEL,
+    buttonStyle: theme.actionStyle,
+    alignButtonRight: true,
+  });
+}
+
+function drawConversationRow(
+  surface: ReturnType<typeof createUiSurface>,
+  rowIndex: number,
+  row: WorkspaceRailViewRow,
+  theme: MuxWorkspaceRailTheme,
+): void {
+  const rowStyle =
+    row.kind === 'conversation-body' ? theme.conversationBodyStyle : theme.normalStyle;
+  drawTreeRow(surface, rowIndex, row, theme, rowStyle, theme.activeRowStyle);
+  if (row.kind !== 'conversation-title') {
+    return;
+  }
+  const statusStyle = conversationStatusIconStyle(row.conversationStatus, row.active, theme);
+  const statusMatch = row.text.match(/[▲◔◆○■]/u);
+  if (statusMatch === null || statusMatch.index === undefined) {
+    return;
+  }
+  drawUiText(surface, statusMatch.index, rowIndex, statusMatch[0], statusStyle);
+}
+
+function paintWorkspaceRailRow(
+  surface: ReturnType<typeof createUiSurface>,
+  rowIndex: number,
+  row: WorkspaceRailViewRow,
+  theme: MuxWorkspaceRailTheme,
+): void {
+  if (row.kind === 'dir-header') {
+    drawDirectoryHeaderRow(surface, rowIndex, row, theme);
+    return;
+  }
+  if (row.kind === 'dir-meta') {
+    drawTreeRow(surface, rowIndex, row, theme, theme.metaStyle, theme.activeRowStyle);
+    return;
+  }
+  if (row.kind === 'conversation-title' || row.kind === 'conversation-body') {
+    drawConversationRow(surface, rowIndex, row, theme);
+    return;
+  }
+  if (row.kind === 'process-title' || row.kind === 'process-meta') {
+    paintUiRow(surface, rowIndex, row.text, theme.processStyle, theme.normalStyle);
+    return;
+  }
+  if (row.kind === 'repository-header') {
+    const buttonLabel = row.text.endsWith('[+]') ? '[+]' : row.text.endsWith('[-]') ? '[-]' : null;
+    if (buttonLabel === null) {
+      drawTreeRow(surface, rowIndex, row, theme, theme.headerStyle, theme.activeRowStyle);
+    } else {
+      drawTreeRow(surface, rowIndex, row, theme, theme.headerStyle, theme.activeRowStyle, {
+        buttonLabel,
+        buttonStyle: theme.actionStyle,
+      });
+    }
+    return;
+  }
+  if (row.kind === 'repository-row') {
+    paintUiRow(surface, rowIndex, row.text, theme.repositoryRowStyle, theme.normalStyle);
+    return;
+  }
+  if (row.kind === 'shortcut-header') {
+    const buttonLabel = row.text.endsWith('[+]') ? '[+]' : row.text.endsWith('[-]') ? '[-]' : null;
+    if (buttonLabel === null) {
+      drawTreeRow(surface, rowIndex, row, theme, theme.headerStyle, theme.activeRowStyle);
+    } else {
+      drawTreeRow(surface, rowIndex, row, theme, theme.headerStyle, theme.activeRowStyle, {
+        buttonLabel,
+        buttonStyle: theme.actionStyle,
+      });
+    }
+    return;
+  }
+  if (row.kind === 'shortcut-body') {
+    paintUiRow(surface, rowIndex, row.text, theme.shortcutStyle);
+    return;
+  }
+  if (row.kind === 'action') {
+    drawActionRow(surface, rowIndex, row, theme);
+    return;
+  }
+  if (row.kind === 'muted') {
+    paintUiRow(surface, rowIndex, row.text, theme.mutedStyle, theme.normalStyle);
+  }
+}
+
+export function renderWorkspaceRailRowAnsiForTest(
+  row: WorkspaceRailViewRow,
+  width: number,
+): string {
+  const safeWidth = Math.max(1, width);
+  const theme = getActiveMuxTheme().workspaceRail;
+  const surface = createUiSurface(safeWidth, 1, DEFAULT_UI_STYLE);
+  paintWorkspaceRailRow(surface, 0, row, theme);
+  return renderUiSurfaceAnsiRows(surface)[0]!;
+}
+
+export function renderWorkspaceRailAnsiRows(
+  model: WorkspaceRailModel,
+  width: number,
+  maxRows: number,
+): readonly string[] {
+  const safeWidth = Math.max(1, width);
+  const safeRows = Math.max(1, maxRows);
+  const theme = getActiveMuxTheme().workspaceRail;
+  const rows = buildWorkspaceRailViewRows(model, safeRows);
+  const surface = createUiSurface(safeWidth, safeRows, DEFAULT_UI_STYLE);
+
+  for (let rowIndex = 0; rowIndex < safeRows; rowIndex += 1) {
+    const row = rows[rowIndex]!;
+    paintWorkspaceRailRow(surface, rowIndex, row, theme);
+  }
+
+  return renderUiSurfaceAnsiRows(surface);
+}

package/src/perf/perf-core.ts

@@ -0,0 +1,307 @@
+import { closeSync, mkdirSync, openSync, writeSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+
+type PerfAttrValue = boolean | number | string;
+type PerfAttrs = Readonly<Record<string, PerfAttrValue>>;
+
+interface PerfCoreConfig {
+  enabled: boolean;
+  filePath?: string;
+}
+
+interface PerfEventRecord {
+  type: 'event';
+  name: string;
+  'ts-ns': string;
+  'ts-ms': number;
+  attrs?: PerfAttrs;
+}
+
+interface PerfSpanRecord {
+  type: 'span';
+  name: string;
+  'start-ns': string;
+  'duration-ns': string;
+  'end-ms': number;
+  'trace-id': string;
+  'span-id': string;
+  'parent-span-id'?: string;
+  attrs?: PerfAttrs;
+}
+
+type PerfRecord = PerfEventRecord | PerfSpanRecord;
+
+const DEFAULT_FILE_PATH = '.harness/perf.jsonl';
+const DEFAULT_MAX_PENDING_RECORDS = 4096;
+const DEFAULT_EVENT_SAMPLE_RATES: Readonly<Record<string, number>> = {
+  'pty.stdout.chunk': 0.1,
+};
+
+const state: {
+  enabled: boolean;
+  filePath: string;
+  fd: number | null;
+  nextTraceId: number;
+  nextSpanId: number;
+  flushTimer: NodeJS.Timeout | null;
+  pendingRecords: string[];
+  maxPendingRecords: number;
+  sampleRates: Readonly<Record<string, number>>;
+  sampleCounters: Map<string, number>;
+} = {
+  enabled: false,
+  filePath: DEFAULT_FILE_PATH,
+  fd: null,
+  nextTraceId: 1,
+  nextSpanId: 1,
+  flushTimer: null,
+  pendingRecords: [],
+  maxPendingRecords: DEFAULT_MAX_PENDING_RECORDS,
+  sampleRates: DEFAULT_EVENT_SAMPLE_RATES,
+  sampleCounters: new Map(),
+};
+
+function ensureWriter(): void {
+  if (!state.enabled || state.fd !== null) {
+    return;
+  }
+
+  const resolvedPath = resolve(state.filePath);
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  state.fd = openSync(resolvedPath, 'a');
+}
+
+function closeWriter(): void {
+  flushPendingRecords();
+  if (state.flushTimer !== null) {
+    clearTimeout(state.flushTimer);
+    state.flushTimer = null;
+  }
+  if (state.fd === null) {
+    return;
+  }
+
+  closeSync(state.fd);
+  state.fd = null;
+}
+
+function scheduleFlush(): void {
+  if (!state.enabled || state.fd === null || state.flushTimer !== null) {
+    return;
+  }
+  state.flushTimer = setTimeout(() => {
+    state.flushTimer = null;
+    flushPendingRecords();
+  }, 0);
+  state.flushTimer.unref();
+}
+
+function flushPendingRecords(): void {
+  if (state.fd === null || state.pendingRecords.length === 0) {
+    return;
+  }
+  const chunk = state.pendingRecords.join('');
+  state.pendingRecords.length = 0;
+  writeSync(state.fd, chunk);
+}
+
+function writeRecord(record: PerfRecord): void {
+  ensureWriter();
+  if (state.fd === null) {
+    return;
+  }
+  if (state.pendingRecords.length >= state.maxPendingRecords) {
+    state.pendingRecords.shift();
+  }
+  state.pendingRecords.push(`${JSON.stringify(record)}\n`);
+  scheduleFlush();
+}
+
+function shouldRecordEvent(name: string): boolean {
+  const sampleRate = state.sampleRates[name];
+  if (sampleRate === undefined) {
+    return true;
+  }
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+    return false;
+  }
+  if (sampleRate >= 1) {
+    return true;
+  }
+  const sampleEvery = Math.max(1, Math.floor(1 / sampleRate));
+  const previous = state.sampleCounters.get(name) ?? 0;
+  const next = previous + 1;
+  state.sampleCounters.set(name, next);
+  return next % sampleEvery === 0;
+}
+
+function nextTraceId(): string {
+  const traceId = `trace-${state.nextTraceId}`;
+  state.nextTraceId += 1;
+  return traceId;
+}
+
+function nextSpanId(): string {
+  const spanId = `span-${state.nextSpanId}`;
+  state.nextSpanId += 1;
+  return spanId;
+}
+
+function mergeAttrs(base?: PerfAttrs, extra?: PerfAttrs): PerfAttrs | undefined {
+  if (base === undefined && extra === undefined) {
+    return undefined;
+  }
+
+  if (base === undefined) {
+    return extra;
+  }
+
+  if (extra === undefined) {
+    return base;
+  }
+
+  return { ...base, ...extra };
+}
+
+function writeDurationRecord(
+  name: string,
+  startedAtNs: bigint,
+  attrs?: PerfAttrs,
+  traceId?: string,
+  spanId?: string,
+  parentSpanId?: string,
+): void {
+  if (!state.enabled) {
+    return;
+  }
+
+  const endedAtNs = perfNowNs();
+  const endedAtMs = Date.now();
+  const record: PerfSpanRecord = {
+    type: 'span',
+    name,
+    'start-ns': startedAtNs.toString(),
+    'duration-ns': (endedAtNs - startedAtNs).toString(),
+    'end-ms': endedAtMs,
+    'trace-id': traceId ?? nextTraceId(),
+    'span-id': spanId ?? nextSpanId(),
+  };
+
+  if (parentSpanId !== undefined) {
+    record['parent-span-id'] = parentSpanId;
+  }
+  if (attrs !== undefined) {
+    record.attrs = attrs;
+  }
+
+  writeRecord(record);
+}
+
+class ActivePerfSpan {
+  private ended = false;
+  private readonly name: string;
+  private readonly startedAtNs: bigint;
+  private readonly attrs: PerfAttrs | undefined;
+  private readonly traceId: string;
+  private readonly spanId: string;
+  private readonly parentSpanId: string | undefined;
+
+  constructor(
+    name: string,
+    startedAtNs: bigint,
+    attrs: PerfAttrs | undefined,
+    traceId: string,
+    spanId: string,
+    parentSpanId: string | undefined,
+  ) {
+    this.name = name;
+    this.startedAtNs = startedAtNs;
+    this.attrs = attrs;
+    this.traceId = traceId;
+    this.spanId = spanId;
+    this.parentSpanId = parentSpanId;
+  }
+
+  end(extraAttrs?: PerfAttrs): void {
+    if (this.ended) {
+      return;
+    }
+    this.ended = true;
+    writeDurationRecord(
+      this.name,
+      this.startedAtNs,
+      mergeAttrs(this.attrs, extraAttrs),
+      this.traceId,
+      this.spanId,
+      this.parentSpanId,
+    );
+  }
+}
+
+interface PerfSpan {
+  end(extraAttrs?: PerfAttrs): void;
+}
+
+const NOOP_PERF_SPAN: PerfSpan = {
+  end(): void {
+    return;
+  },
+};
+
+export function configurePerfCore(config: PerfCoreConfig): void {
+  const nextFilePath = config.filePath ?? state.filePath;
+  const pathChanged = resolve(nextFilePath) !== resolve(state.filePath);
+
+  if (pathChanged || (!config.enabled && state.enabled)) {
+    closeWriter();
+  }
+
+  state.enabled = config.enabled;
+  state.filePath = nextFilePath;
+  state.sampleCounters.clear();
+
+  if (state.enabled) {
+    ensureWriter();
+  }
+}
+
+export function isPerfCoreEnabled(): boolean {
+  return state.enabled;
+}
+
+export function perfNowNs(): bigint {
+  return process.hrtime.bigint();
+}
+
+export function startPerfSpan(name: string, attrs?: PerfAttrs, parentSpanId?: string): PerfSpan {
+  if (!state.enabled) {
+    return NOOP_PERF_SPAN;
+  }
+
+  return new ActivePerfSpan(name, perfNowNs(), attrs, nextTraceId(), nextSpanId(), parentSpanId);
+}
+
+export function recordPerfDuration(name: string, startedAtNs: bigint, attrs?: PerfAttrs): void {
+  writeDurationRecord(name, startedAtNs, attrs);
+}
+
+export function recordPerfEvent(name: string, attrs?: PerfAttrs): void {
+  if (!state.enabled || !shouldRecordEvent(name)) {
+    return;
+  }
+
+  const record: PerfEventRecord = {
+    type: 'event',
+    name,
+    'ts-ns': perfNowNs().toString(),
+    'ts-ms': Date.now(),
+  };
+  if (attrs !== undefined) {
+    record.attrs = attrs;
+  }
+  writeRecord(record);
+}
+
+export function shutdownPerfCore(): void {
+  closeWriter();
+}