@jmoyers/harness 0.1.10 → 0.1.20

package/src/ui/panes/home-gridfire.ts

@@ -1,5 +1,5 @@
 import { measureDisplayWidth } from '../../terminal/snapshot-oracle.ts';
-import { createUiSurface, renderUiSurfaceAnsiRows, type UiStyle } from '../surface.ts';
+import { SurfaceBuffer, type UiStyle } from '../../../packages/harness-ui/src/surface.ts';
 
 interface HomeGridfireOptions {
   readonly cols: number;
@@ -8,6 +8,7 @@ interface HomeGridfireOptions {
   readonly timeMs: number;
   readonly overlayTitle: string | null;
   readonly overlaySubtitle: string | null;
+  readonly overlayPlacement?: 'center' | 'bottom';
 }
 
 type RgbTriplet = readonly [number, number, number];
@@ -26,25 +27,25 @@ const GRID_CHARS = {
 } as const;
 
 const FG_PALETTE: readonly RgbTriplet[] = [
-  [14, 11, 28],
-  [28, 20, 55],
-  [50, 30, 100],
-  [75, 45, 155],
-  [55, 85, 200],
-  [90, 140, 240],
-  [150, 190, 255],
-  [220, 235, 255],
+  [8, 20, 24],
+  [10, 35, 42],
+  [14, 58, 70],
+  [20, 86, 105],
+  [28, 118, 146],
+  [42, 154, 188],
+  [90, 198, 220],
+  [180, 236, 244],
 ];
 
 const BG_PALETTE: readonly RgbTriplet[] = [
-  [8, 6, 16],
-  [12, 10, 22],
-  [16, 13, 30],
-  [20, 16, 38],
-  [18, 20, 45],
-  [16, 24, 50],
-  [20, 28, 55],
-  [24, 32, 58],
+  [2, 10, 12],
+  [4, 16, 18],
+  [6, 22, 24],
+  [8, 28, 30],
+  [10, 34, 36],
+  [12, 42, 44],
+  [14, 50, 54],
+  [18, 62, 66],
 ];
 
 function lerp(start: number, end: number, t: number): number {
@@ -90,7 +91,7 @@ function styleFromColors(fg: RgbTriplet, bg: RgbTriplet, bold = false): UiStyle
 }
 
 function writeGlyph(
-  surface: ReturnType<typeof createUiSurface>,
+  surface: SurfaceBuffer,
   row: number,
   col: number,
   glyph: string,
@@ -198,7 +199,7 @@ function pickGridGlyph(
         : GRID_CHARS.empty;
 }
 
-function paintBackground(surface: ReturnType<typeof createUiSurface>, phase: number): void {
+function paintBackground(surface: SurfaceBuffer, phase: number): void {
   for (let row = 0; row < surface.rows; row += 1) {
     for (let col = 0; col < surface.cols; col += 1) {
       const energy = gridEnergy(col, row, surface.cols, surface.rows, phase);
@@ -211,7 +212,7 @@ function paintBackground(surface: ReturnType<typeof createUiSurface>, phase: num
 }
 
 function paintOverlayTextRow(
-  surface: ReturnType<typeof createUiSurface>,
+  surface: SurfaceBuffer,
   row: number,
   text: string,
   phase: number,
@@ -242,7 +243,7 @@ function paintOverlayTextRow(
 }
 
 function paintCenteredLabel(
-  surface: ReturnType<typeof createUiSurface>,
+  surface: SurfaceBuffer,
   row: number,
   text: string | null,
   phase: number,
@@ -279,7 +280,7 @@ function paintCenteredLabel(
 export function renderHomeGridfireAnsiRows(options: HomeGridfireOptions): readonly string[] {
   const safeCols = Math.max(1, options.cols);
   const safeRows = Math.max(1, options.rows);
-  const surface = createUiSurface(safeCols, safeRows);
+  const surface = new SurfaceBuffer(safeCols, safeRows);
   const phase = options.timeMs / 1000;
 
   paintBackground(surface, phase);
@@ -289,14 +290,22 @@ export function renderHomeGridfireAnsiRows(options: HomeGridfireOptions): readon
     paintOverlayTextRow(surface, row, line, phase);
   }
 
-  const centerRow = Math.floor(safeRows / 2);
-  paintCenteredLabel(surface, centerRow, options.overlayTitle, phase);
-  paintCenteredLabel(
-    surface,
-    Math.min(safeRows - 1, centerRow + 2),
-    options.overlaySubtitle,
-    phase,
-  );
+  const overlayPlacement = options.overlayPlacement ?? 'center';
+  if (overlayPlacement === 'bottom') {
+    const subtitleRow = Math.max(0, safeRows - 2);
+    const titleRow = Math.max(0, subtitleRow - 1);
+    paintCenteredLabel(surface, titleRow, options.overlayTitle, phase);
+    paintCenteredLabel(surface, subtitleRow, options.overlaySubtitle, phase);
+  } else {
+    const centerRow = Math.floor(safeRows / 2);
+    paintCenteredLabel(surface, centerRow, options.overlayTitle, phase);
+    paintCenteredLabel(
+      surface,
+      Math.min(safeRows - 1, centerRow + 2),
+      options.overlaySubtitle,
+      phase,
+    );
+  }
 
-  return renderUiSurfaceAnsiRows(surface);
+  return surface.renderAnsiRows();
 }

package/src/ui/panes/home.ts

@@ -29,6 +29,7 @@ interface HomePaneRenderInput {
   readonly layout: HomePaneLayout;
   readonly repositories: ReadonlyMap<string, TaskFocusedPaneRepositoryRecord>;
   readonly tasks: ReadonlyMap<string, TaskFocusedPaneTaskRecord>;
+  readonly showTaskPlanningUi?: boolean;
   readonly selectedRepositoryId: string | null;
   readonly repositoryDropdownOpen: boolean;
   readonly editorTarget: TaskFocusedPaneEditorTarget;
@@ -69,6 +70,7 @@ export class HomePane {
     const rows = Array.from({ length: safeRows }, () => blankRow);
     return {
       rows,
+      plainRows: rows,
       taskIds: Array.from({ length: safeRows }, () => null),
       repositoryIds: Array.from({ length: safeRows }, () => null),
       actions: Array.from({ length: safeRows }, () => null),
@@ -79,7 +81,10 @@ export class HomePane {
   }
 
   render(input: HomePaneRenderInput): TaskFocusedPaneView {
-    const view = this.showTaskPlanningUi
+    const showTaskPlanningUi = input.showTaskPlanningUi ?? this.showTaskPlanningUi;
+    const nowMs = this.animateBackground ? this.nowMs() : this.staticBackgroundTimeMs;
+    const cursorVisible = Math.floor(nowMs / 530) % 2 === 0;
+    const view = showTaskPlanningUi
       ? this.renderTaskFocusedPaneView({
           repositories: input.repositories,
           tasks: input.tasks,
@@ -92,17 +97,20 @@ export class HomePane {
           cols: input.layout.rightCols,
           rows: input.layout.paneRows,
           scrollTop: input.scrollTop,
+          cursorVisible,
         })
       : this.hiddenTaskPlanningView(input.layout);
     return {
       ...view,
+      plainRows: view.rows,
       rows: this.renderBackgroundRows({
         cols: input.layout.rightCols,
         rows: input.layout.paneRows,
         contentRows: view.rows,
-        timeMs: this.animateBackground ? this.nowMs() : this.staticBackgroundTimeMs,
+        timeMs: nowMs,
         overlayTitle: 'GSV Sleeper Service',
         overlaySubtitle: this.overlaySubtitle,
+        overlayPlacement: showTaskPlanningUi ? 'bottom' : 'center',
       }),
     };
   }

package/src/ui/panes/nim.ts

@@ -0,0 +1,315 @@
+import {
+  DEFAULT_UI_STYLE,
+  SurfaceBuffer,
+  type UiColor,
+  type UiStyle,
+} from '../../../packages/harness-ui/src/surface.ts';
+import { UiKit } from '../../../packages/harness-ui/src/kit.ts';
+import { measureDisplayWidth } from '../../terminal/snapshot-oracle.ts';
+import { getActiveMuxTheme } from '../mux-theme.ts';
+
+interface NimPaneLayout {
+  readonly rightCols: number;
+  readonly paneRows: number;
+}
+
+interface NimPaneRenderInput {
+  readonly layout: NimPaneLayout;
+  readonly viewModel: NimPaneViewModel;
+}
+
+interface NimPaneRenderResult {
+  readonly rows: readonly string[];
+}
+
+const HEADER = 'nim';
+const COMPOSER_PROMPT = 'nim> ';
+const USER_TRANSCRIPT_PREFIX = 'you> ';
+const ASSISTANT_TRANSCRIPT_PREFIX = 'nim> ';
+const uiKit = new UiKit();
+
+export interface NimPaneViewModel {
+  readonly sessionId: string | null;
+  readonly status: 'thinking' | 'tool-calling' | 'responding' | 'idle';
+  readonly uiMode: 'debug' | 'user';
+  readonly composerText: string;
+  readonly queuedCount: number;
+  readonly transcriptLines: readonly string[];
+  readonly assistantDraftText: string;
+}
+
+export class NimPane {
+  render(input: NimPaneRenderInput): NimPaneRenderResult {
+    const viewModel = input.viewModel;
+    const safeRows = Math.max(0, input.layout.paneRows);
+    const safeCols = Math.max(1, input.layout.rightCols);
+    if (safeRows === 0) {
+      return { rows: [] };
+    }
+    const theme = getActiveMuxTheme();
+    const railTheme = theme.workspaceRail;
+    const conversationTheme = theme.conversationRail;
+    const surface = new SurfaceBuffer(safeCols, safeRows, DEFAULT_UI_STYLE);
+    const backgroundStyle = withStyle(railTheme.normalStyle, {
+      bg: resolveDefaultBackgroundColor(theme),
+    });
+    for (let row = 0; row < safeRows; row += 1) {
+      surface.fillRow(row, backgroundStyle);
+    }
+    const topBandFill = withStyle(conversationTheme.headerStyle, {
+      bg: resolveTopBandBackgroundColor(theme),
+      dim: false,
+    });
+    const topBandText = withStyle(railTheme.headerStyle, {
+      bg: topBandFill.bg,
+      bold: true,
+    });
+    const bodyText = withStyle(railTheme.normalStyle, {
+      bg: backgroundStyle.bg,
+    });
+    const mutedText = withStyle(railTheme.mutedStyle, {
+      bg: backgroundStyle.bg,
+      dim: true,
+    });
+    const actionText = withStyle(railTheme.actionStyle, {
+      bg: backgroundStyle.bg,
+      bold: true,
+    });
+    const statusBadge = statusBadgeStyle(viewModel.status, railTheme.statusColors);
+
+    paintRow(surface, 0, ` ${HEADER}`, topBandText, topBandFill);
+    drawStatusChip(surface, 0, safeCols, viewModel.status, statusBadge);
+    if (safeRows > 1) {
+      const sessionLabel =
+        viewModel.sessionId === null ? 'no-session' : viewModel.sessionId.slice(0, 8);
+      paintRow(
+        surface,
+        1,
+        ` session:${sessionLabel}  mode:${viewModel.uiMode}  queued:${String(viewModel.queuedCount)}`,
+        withStyle(railTheme.metaStyle, {
+          bg: topBandFill.bg,
+        }),
+        topBandFill,
+      );
+    }
+    if (safeRows > 2) {
+      paintRow(
+        surface,
+        2,
+        ' enter=send/steer  tab=queue  esc=abort  /mode debug|user',
+        mutedText,
+        topBandFill,
+      );
+    }
+    if (safeRows > 3) {
+      paintSectionDivider(surface, 3, 'transcript', mutedText, backgroundStyle);
+    }
+
+    const composerDividerRow = Math.max(0, safeRows - 2);
+    const composerRow = Math.max(0, safeRows - 1);
+    const composerFill = withStyle(railTheme.activeRowStyle, {
+      bg: resolveComposerBackgroundColor(theme),
+    });
+    paintSectionDivider(surface, composerDividerRow, 'composer', mutedText, composerFill);
+    surface.fillRow(composerRow, composerFill);
+    const promptWidth = measureDisplayWidth(COMPOSER_PROMPT);
+    surface.drawText(0, composerRow, COMPOSER_PROMPT, actionText);
+    surface.drawText(promptWidth, composerRow, viewModel.composerText, bodyText);
+
+    const transcriptStartRow = Math.min(4, safeRows - 1);
+    const transcriptEndRow = Math.max(transcriptStartRow - 1, composerDividerRow - 1);
+    const transcriptCapacity = Math.max(0, transcriptEndRow - transcriptStartRow + 1);
+    const assistantDraftRow =
+      viewModel.assistantDraftText.length > 0 ? [`nim> ${viewModel.assistantDraftText}`] : [];
+    const transcriptRows = [...viewModel.transcriptLines, ...assistantDraftRow];
+    const visibleRows =
+      transcriptCapacity === 0
+        ? []
+        : transcriptRows.slice(Math.max(0, transcriptRows.length - transcriptCapacity));
+    for (let index = 0; index < visibleRows.length; index += 1) {
+      const row = visibleRows[index];
+      if (row === undefined) {
+        continue;
+      }
+      const rowIndex = transcriptStartRow + index;
+      const formatted = formatTranscriptLine(row);
+      surface.fillRow(rowIndex, backgroundStyle);
+      surface.drawText(1, rowIndex, formatted.symbol, formatted.symbolStyle);
+      uiKit.paintRow(
+        surface,
+        rowIndex,
+        `  ${formatted.text}`,
+        formatted.textStyle,
+        backgroundStyle,
+      );
+    }
+
+    return {
+      rows: surface.renderAnsiRows(),
+    };
+  }
+}
+
+function formatTranscriptLine(line: string): {
+  readonly symbol: string;
+  readonly symbolStyle: UiStyle;
+  readonly text: string;
+  readonly textStyle: UiStyle;
+} {
+  const theme = getActiveMuxTheme();
+  const railTheme = theme.workspaceRail;
+  const bodyText = withStyle(railTheme.normalStyle, {
+    bg: resolveDefaultBackgroundColor(theme),
+  });
+  const mutedText = withStyle(railTheme.mutedStyle, {
+    bg: resolveDefaultBackgroundColor(theme),
+    dim: true,
+  });
+  const accentText = withStyle(railTheme.actionStyle, {
+    bg: resolveDefaultBackgroundColor(theme),
+    bold: false,
+  });
+  if (line.startsWith(USER_TRANSCRIPT_PREFIX)) {
+    return {
+      symbol: '›',
+      symbolStyle: accentText,
+      text: line,
+      textStyle: accentText,
+    };
+  }
+  if (line.startsWith(ASSISTANT_TRANSCRIPT_PREFIX)) {
+    return {
+      symbol: '•',
+      symbolStyle: bodyText,
+      text: line,
+      textStyle: bodyText,
+    };
+  }
+  if (line.startsWith('[error]')) {
+    return {
+      symbol: '!',
+      symbolStyle: withStyle(railTheme.actionStyle, {
+        fg: railTheme.statusColors.exited,
+        bg: resolveDefaultBackgroundColor(theme),
+        bold: true,
+      }),
+      text: line,
+      textStyle: withStyle(railTheme.metaStyle, {
+        fg: railTheme.statusColors.exited,
+        bg: resolveDefaultBackgroundColor(theme),
+      }),
+    };
+  }
+  if (line.startsWith('[tool:')) {
+    return {
+      symbol: '↳',
+      symbolStyle: withStyle(railTheme.metaStyle, {
+        fg: railTheme.statusColors.starting,
+        bg: resolveDefaultBackgroundColor(theme),
+      }),
+      text: line,
+      textStyle: mutedText,
+    };
+  }
+  return {
+    symbol: '•',
+    symbolStyle: mutedText,
+    text: line,
+    textStyle: mutedText,
+  };
+}
+
+function paintRow(
+  surface: SurfaceBuffer,
+  row: number,
+  text: string,
+  textStyle: UiStyle,
+  fillStyle: UiStyle,
+): void {
+  surface.fillRow(row, fillStyle);
+  uiKit.paintRow(surface, row, text, textStyle, fillStyle);
+}
+
+function paintSectionDivider(
+  surface: SurfaceBuffer,
+  row: number,
+  label: string,
+  textStyle: UiStyle,
+  fillStyle: UiStyle,
+): void {
+  const divider = ` ${'-'.repeat(Math.max(0, surface.cols - label.length - 3))} ${label}`;
+  paintRow(surface, row, divider, textStyle, fillStyle);
+}
+
+function withStyle(base: UiStyle, overrides: Partial<UiStyle>): UiStyle {
+  return {
+    fg: overrides.fg ?? base.fg,
+    bg: overrides.bg ?? base.bg,
+    bold: overrides.bold ?? base.bold,
+    ...(resolveStyleFlag(base.dim, overrides.dim) ? { dim: true } : {}),
+    ...(resolveStyleFlag(base.italic, overrides.italic) ? { italic: true } : {}),
+    ...(resolveStyleFlag(base.underline, overrides.underline) ? { underline: true } : {}),
+    ...(resolveStyleFlag(base.inverse, overrides.inverse) ? { inverse: true } : {}),
+  };
+}
+
+function resolveStyleFlag(base: boolean | undefined, override: boolean | undefined): boolean {
+  if (override === undefined) {
+    return base === true;
+  }
+  return override;
+}
+
+function resolveDefaultBackgroundColor(theme: ReturnType<typeof getActiveMuxTheme>): UiColor {
+  const bg = theme.conversationRail.normalRowStyle.bg;
+  return bg.kind === 'default' ? theme.workspaceRail.normalStyle.bg : bg;
+}
+
+function resolveTopBandBackgroundColor(theme: ReturnType<typeof getActiveMuxTheme>): UiColor {
+  const bg = theme.conversationRail.headerStyle.bg;
+  return bg.kind === 'default' ? resolveDefaultBackgroundColor(theme) : bg;
+}
+
+function resolveComposerBackgroundColor(theme: ReturnType<typeof getActiveMuxTheme>): UiColor {
+  const bg = theme.workspaceRail.activeRowStyle.bg;
+  return bg.kind === 'default' ? resolveTopBandBackgroundColor(theme) : bg;
+}
+
+function statusBadgeStyle(
+  status: NimPaneViewModel['status'],
+  colors: {
+    readonly working: UiColor;
+    readonly exited: UiColor;
+    readonly needsAction: UiColor;
+    readonly starting: UiColor;
+    readonly idle: UiColor;
+  },
+): UiStyle {
+  const color =
+    status === 'thinking'
+      ? colors.starting
+      : status === 'tool-calling'
+        ? colors.needsAction
+        : status === 'responding'
+          ? colors.working
+          : colors.idle;
+  return {
+    fg: color,
+    bg: { kind: 'default' },
+    bold: true,
+    inverse: true,
+  };
+}
+
+function drawStatusChip(
+  surface: SurfaceBuffer,
+  row: number,
+  cols: number,
+  status: NimPaneViewModel['status'],
+  style: UiStyle,
+): void {
+  const label = ` ${status} `;
+  const width = measureDisplayWidth(label);
+  const col = Math.max(0, cols - width - 1);
+  surface.drawText(col, row, label, style);
+}

package/src/mux/live-mux/actions-task.ts

@@ -1,115 +0,0 @@
-import type { TaskPaneAction } from '../harness-core-ui.ts';
-
-interface TaskRecordActionState {
-  readonly taskId: string;
-  readonly status: string;
-}
-
-interface RunTaskPaneActionOptions {
-  action: TaskPaneAction;
-  openTaskCreatePrompt: () => void;
-  openRepositoryPromptForCreate: () => void;
-  selectedRepositoryId: string | null;
-  repositoryExists: (repositoryId: string) => boolean;
-  setTaskPaneNotice: (notice: string | null) => void;
-  markDirty: () => void;
-  setTaskPaneSelectionFocus: (focus: 'task' | 'repository') => void;
-  openRepositoryPromptForEdit: (repositoryId: string) => void;
-  queueArchiveRepository: (repositoryId: string) => void;
-  selectedTask: TaskRecordActionState | null;
-  openTaskEditPrompt: (taskId: string) => void;
-  queueDeleteTask: (taskId: string) => void;
-  queueTaskReady: (taskId: string) => void;
-  queueTaskDraft: (taskId: string) => void;
-  queueTaskComplete: (taskId: string) => void;
-  orderedTaskRecords: () => readonly TaskRecordActionState[];
-  queueTaskReorderByIds: (orderedTaskIds: readonly string[], label: string) => void;
-}
-
-export function runTaskPaneAction(options: RunTaskPaneActionOptions): void {
-  if (options.action === 'task.create') {
-    options.openTaskCreatePrompt();
-    return;
-  }
-  if (options.action === 'repository.create') {
-    options.setTaskPaneNotice(null);
-    options.openRepositoryPromptForCreate();
-    return;
-  }
-  if (options.action === 'repository.edit') {
-    const selectedRepositoryId = options.selectedRepositoryId;
-    if (selectedRepositoryId === null || !options.repositoryExists(selectedRepositoryId)) {
-      options.setTaskPaneNotice('select a repository first');
-      options.markDirty();
-      return;
-    }
-    options.setTaskPaneSelectionFocus('repository');
-    options.setTaskPaneNotice(null);
-    options.openRepositoryPromptForEdit(selectedRepositoryId);
-    return;
-  }
-  if (options.action === 'repository.archive') {
-    const selectedRepositoryId = options.selectedRepositoryId;
-    if (selectedRepositoryId === null || !options.repositoryExists(selectedRepositoryId)) {
-      options.setTaskPaneNotice('select a repository first');
-      options.markDirty();
-      return;
-    }
-    options.setTaskPaneSelectionFocus('repository');
-    options.queueArchiveRepository(selectedRepositoryId);
-    return;
-  }
-  const selected = options.selectedTask;
-  if (selected === null) {
-    options.setTaskPaneNotice('select a task first');
-    options.markDirty();
-    return;
-  }
-  if (options.action === 'task.edit') {
-    options.setTaskPaneSelectionFocus('task');
-    options.openTaskEditPrompt(selected.taskId);
-    return;
-  }
-  if (options.action === 'task.delete') {
-    options.setTaskPaneSelectionFocus('task');
-    options.queueDeleteTask(selected.taskId);
-    return;
-  }
-  if (options.action === 'task.ready') {
-    options.setTaskPaneSelectionFocus('task');
-    options.queueTaskReady(selected.taskId);
-    return;
-  }
-  if (options.action === 'task.draft') {
-    options.setTaskPaneSelectionFocus('task');
-    options.queueTaskDraft(selected.taskId);
-    return;
-  }
-  if (options.action === 'task.complete') {
-    options.setTaskPaneSelectionFocus('task');
-    options.queueTaskComplete(selected.taskId);
-    return;
-  }
-  if (options.action === 'task.reorder-up' || options.action === 'task.reorder-down') {
-    const activeTasks = options.orderedTaskRecords().filter((task) => task.status !== 'completed');
-    const selectedIndex = activeTasks.findIndex((task) => task.taskId === selected.taskId);
-    if (selectedIndex < 0) {
-      options.setTaskPaneNotice('cannot reorder completed tasks');
-      options.markDirty();
-      return;
-    }
-    const swapIndex = options.action === 'task.reorder-up' ? selectedIndex - 1 : selectedIndex + 1;
-    if (swapIndex < 0 || swapIndex >= activeTasks.length) {
-      return;
-    }
-    const reordered = [...activeTasks];
-    const currentTask = reordered[selectedIndex]!;
-    reordered[selectedIndex] = reordered[swapIndex]!;
-    reordered[swapIndex] = currentTask;
-    options.setTaskPaneSelectionFocus('task');
-    options.queueTaskReorderByIds(
-      reordered.map((task) => task.taskId),
-      options.action === 'task.reorder-up' ? 'tasks-reorder-up' : 'tasks-reorder-down',
-    );
-  }
-}