@jmoyers/harness 0.1.0

package/src/mux/new-thread-prompt.ts

@@ -0,0 +1,165 @@
+type ThreadAgentType = 'codex' | 'claude' | 'cursor' | 'terminal' | 'critique';
+
+const EMPTY_NEW_THREAD_PROMPT_INPUT = new Uint8Array();
+
+interface NewThreadPromptState {
+  readonly directoryId: string;
+  readonly selectedAgentType: ThreadAgentType;
+}
+
+interface NewThreadPromptInputResult {
+  readonly nextState: NewThreadPromptState;
+  readonly submit: boolean;
+}
+
+export function createNewThreadPromptState(directoryId: string): NewThreadPromptState {
+  return {
+    directoryId,
+    selectedAgentType: 'codex',
+  };
+}
+
+export function normalizeThreadAgentType(value: string): ThreadAgentType {
+  if (value === 'terminal' || value === 'claude' || value === 'cursor' || value === 'critique') {
+    return value;
+  }
+  return 'codex';
+}
+
+export function nextThreadAgentType(value: ThreadAgentType): ThreadAgentType {
+  if (value === 'codex') {
+    return 'claude';
+  }
+  if (value === 'claude') {
+    return 'cursor';
+  }
+  if (value === 'cursor') {
+    return 'terminal';
+  }
+  if (value === 'terminal') {
+    return 'critique';
+  }
+  return 'codex';
+}
+
+function parseEncodedPromptKeyCode(input: Uint8Array): number | null {
+  if (!input.includes(0x1b)) {
+    return null;
+  }
+  const text = Buffer.from(input).toString('utf8');
+  if (text.startsWith('\u001b[') && text.endsWith('u')) {
+    const kittyPayload = text.slice(2, -1);
+    const kittyMatch = kittyPayload.match(/^(\d+)(?::\d+)?(?:;\d+(?::\d+)?)?$/u);
+    if (kittyMatch !== null) {
+      return Number.parseInt(kittyMatch[1]!, 10);
+    }
+  }
+  if (text.startsWith('\u001b[') && text.endsWith('~')) {
+    const modifyPayload = text.slice(2, -1);
+    const modifyOtherKeysMatch = modifyPayload.match(/^27;\d+;(\d+)$/u);
+    if (modifyOtherKeysMatch !== null) {
+      return Number.parseInt(modifyOtherKeysMatch[1]!, 10);
+    }
+  }
+  return null;
+}
+
+function normalizePromptInputBytes(input: Uint8Array): Uint8Array {
+  const keyCode = parseEncodedPromptKeyCode(input);
+  if (keyCode === null) {
+    return input.includes(0x1b) ? EMPTY_NEW_THREAD_PROMPT_INPUT : input;
+  }
+  if (keyCode < 0 || keyCode > 0xff) {
+    return EMPTY_NEW_THREAD_PROMPT_INPUT;
+  }
+  return Uint8Array.from([keyCode]);
+}
+
+export function reduceNewThreadPromptInput(
+  state: NewThreadPromptState,
+  input: Uint8Array,
+): NewThreadPromptInputResult {
+  const normalizedInput = normalizePromptInputBytes(input);
+  let selectedAgentType = state.selectedAgentType;
+  let submit = false;
+  for (const byte of normalizedInput) {
+    if (byte === 0x0d || byte === 0x0a) {
+      submit = true;
+      break;
+    } else if (byte === 0x09 || byte === 0x20) {
+      selectedAgentType = nextThreadAgentType(selectedAgentType);
+    } else if (byte === 0x31 || byte === 0x63 || byte === 0x43) {
+      selectedAgentType = 'codex';
+    } else if (byte === 0x32 || byte === 0x61 || byte === 0x41) {
+      selectedAgentType = 'claude';
+    } else if (byte === 0x33 || byte === 0x75 || byte === 0x55) {
+      selectedAgentType = 'cursor';
+    } else if (byte === 0x34 || byte === 0x74 || byte === 0x54) {
+      selectedAgentType = 'terminal';
+    } else if (byte === 0x35 || byte === 0x72 || byte === 0x52) {
+      selectedAgentType = 'critique';
+    }
+  }
+  return {
+    nextState: {
+      directoryId: state.directoryId,
+      selectedAgentType,
+    },
+    submit,
+  };
+}
+
+export function resolveNewThreadPromptAgentByRow(
+  overlayTopRowZeroBased: number,
+  rowOneBased: number,
+): ThreadAgentType | null {
+  const codexRow = overlayTopRowZeroBased + 4;
+  const claudeRow = overlayTopRowZeroBased + 5;
+  const cursorRow = overlayTopRowZeroBased + 6;
+  const terminalRow = overlayTopRowZeroBased + 7;
+  const critiqueRow = overlayTopRowZeroBased + 8;
+  if (rowOneBased - 1 === codexRow) {
+    return 'codex';
+  }
+  if (rowOneBased - 1 === claudeRow) {
+    return 'claude';
+  }
+  if (rowOneBased - 1 === cursorRow) {
+    return 'cursor';
+  }
+  if (rowOneBased - 1 === terminalRow) {
+    return 'terminal';
+  }
+  if (rowOneBased - 1 === critiqueRow) {
+    return 'critique';
+  }
+  return null;
+}
+
+export function newThreadPromptBodyLines(
+  state: NewThreadPromptState,
+  labels: {
+    readonly codexButtonLabel: string;
+    readonly claudeButtonLabel: string;
+    readonly cursorButtonLabel: string;
+    readonly terminalButtonLabel: string;
+    readonly critiqueButtonLabel: string;
+  },
+): readonly string[] {
+  const codexSelected = state.selectedAgentType === 'codex';
+  const claudeSelected = state.selectedAgentType === 'claude';
+  const cursorSelected = state.selectedAgentType === 'cursor';
+  const terminalSelected = state.selectedAgentType === 'terminal';
+  const critiqueSelected = state.selectedAgentType === 'critique';
+  return [
+    'choose thread type',
+    '',
+    `${codexSelected ? '●' : '○'} ${labels.codexButtonLabel}`,
+    `${claudeSelected ? '●' : '○'} ${labels.claudeButtonLabel}`,
+    `${cursorSelected ? '●' : '○'} ${labels.cursorButtonLabel}`,
+    `${terminalSelected ? '●' : '○'} ${labels.terminalButtonLabel}`,
+    `${critiqueSelected ? '●' : '○'} ${labels.critiqueButtonLabel}`,
+    '',
+    'c/a/u/t/r toggle',
+  ];
+}

package/src/mux/project-tree.ts

@@ -0,0 +1,295 @@
+import { execFileSync } from 'node:child_process';
+import { readdirSync, type Dirent } from 'node:fs';
+import { basename, join } from 'node:path';
+
+const DEFAULT_PROJECT_TREE_MAX_DEPTH = 3;
+const DEFAULT_PROJECT_TREE_MAX_ENTRIES = 240;
+const DEFAULT_PROJECT_TREE_SKIP_NAMES = new Set<string>([
+  '.git',
+  'node_modules',
+  '.next',
+  '.turbo',
+  'dist',
+  'build',
+  'target',
+]);
+const PROJECT_TREE_KIND_SORT_WEIGHT: Record<ProjectTreeDirectoryEntry['kind'], string> = {
+  directory: '0',
+  file: '1',
+  symlink: '1',
+};
+
+export interface ProjectTreeDirectoryEntry {
+  readonly name: string;
+  readonly kind: 'directory' | 'file' | 'symlink';
+}
+
+type GitLsFilesRunner = (cwd: string, args: readonly string[]) => string | null;
+type ReadDirectoryEntries = (path: string) => readonly ProjectTreeDirectoryEntry[];
+
+interface BuildProjectTreeLinesOptions {
+  readonly maxDepth?: number;
+  readonly maxEntries?: number;
+  readonly skipNames?: ReadonlySet<string> | readonly string[];
+  readonly runGitLsFiles?: GitLsFilesRunner;
+  readonly readDirectoryEntries?: ReadDirectoryEntries;
+}
+
+interface ProjectTreeEmitState {
+  readonly lines: string[];
+  readonly maxDepth: number;
+  readonly maxEntries: number;
+  emitted: number;
+  truncated: boolean;
+}
+
+interface GitTreeNode {
+  readonly directories: Map<string, GitTreeNode>;
+  readonly files: Set<string>;
+}
+
+function formatProjectTreeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+function toPositiveInt(value: number | undefined, fallback: number): number {
+  if (value === undefined) {
+    return fallback;
+  }
+  if (!Number.isFinite(value) || value < 0) {
+    return fallback;
+  }
+  return Math.floor(value);
+}
+
+function resolveSkipNames(
+  value: ReadonlySet<string> | readonly string[] | undefined,
+): ReadonlySet<string> {
+  if (value === undefined) {
+    return DEFAULT_PROJECT_TREE_SKIP_NAMES;
+  }
+  if (value instanceof Set) {
+    return value;
+  }
+  return new Set(value);
+}
+
+function mapDirentToProjectTreeEntry(entry: Dirent): ProjectTreeDirectoryEntry {
+  if (entry.isDirectory()) {
+    return {
+      name: entry.name,
+      kind: 'directory',
+    };
+  }
+  if (entry.isSymbolicLink()) {
+    return {
+      name: entry.name,
+      kind: 'symlink',
+    };
+  }
+  return {
+    name: entry.name,
+    kind: 'file',
+  };
+}
+
+function readDirectoryEntriesFromFilesystem(path: string): readonly ProjectTreeDirectoryEntry[] {
+  return readdirSync(path, { withFileTypes: true }).map(mapDirentToProjectTreeEntry);
+}
+
+function sortProjectTreeEntries(
+  entries: readonly ProjectTreeDirectoryEntry[],
+): ProjectTreeDirectoryEntry[] {
+  return [...entries].sort((left, right) => {
+    const leftKey = `${PROJECT_TREE_KIND_SORT_WEIGHT[left.kind]}:${left.name}`;
+    const rightKey = `${PROJECT_TREE_KIND_SORT_WEIGHT[right.kind]}:${right.name}`;
+    return leftKey.localeCompare(rightKey);
+  });
+}
+
+function runGitLsFilesSync(cwd: string, args: readonly string[]): string | null {
+  try {
+    return execFileSync('git', [...args], {
+      cwd,
+      encoding: 'utf8',
+      timeout: 1500,
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+  } catch {
+    return null;
+  }
+}
+
+function parseGitLsFilesOutput(output: string): readonly string[] {
+  if (output.length === 0) {
+    return [];
+  }
+  return output.split('\0').filter((entry) => entry.length > 0);
+}
+
+function createGitTreeNode(): GitTreeNode {
+  return {
+    directories: new Map<string, GitTreeNode>(),
+    files: new Set<string>(),
+  };
+}
+
+function insertGitTreePath(root: GitTreeNode, value: string): void {
+  const normalized = value.trim().replaceAll('\\', '/').replace(/^\.\//, '').replace(/\/+$/, '');
+  if (normalized.length === 0) {
+    return;
+  }
+  const segments = normalized.split('/').filter((segment) => segment.length > 0);
+  let current = root;
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index]!;
+    const last = index === segments.length - 1;
+    if (last) {
+      current.files.add(segment);
+      continue;
+    }
+    let next = current.directories.get(segment);
+    if (next === undefined) {
+      next = createGitTreeNode();
+      current.directories.set(segment, next);
+    }
+    current = next;
+  }
+}
+
+function emitProjectTreeLine(state: ProjectTreeEmitState, line: string): boolean {
+  if (state.truncated) {
+    return false;
+  }
+  state.lines.push(line);
+  state.emitted += 1;
+  if (state.emitted >= state.maxEntries) {
+    state.truncated = true;
+    return false;
+  }
+  return true;
+}
+
+function walkGitTree(
+  node: GitTreeNode,
+  depth: number,
+  prefix: string,
+  state: ProjectTreeEmitState,
+): void {
+  if (depth >= state.maxDepth) {
+    return;
+  }
+  const directories = [...node.directories.keys()].sort((left, right) => left.localeCompare(right));
+  const files = [...node.files.values()].sort((left, right) => left.localeCompare(right));
+  const entries = [
+    ...directories.map((name) => ({ kind: 'directory' as const, name })),
+    ...files.map((name) => ({ kind: 'file' as const, name })),
+  ];
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    const isLast = index === entries.length - 1;
+    const connector = isLast ? '└─ ' : '├─ ';
+    const suffix = entry.kind === 'directory' ? '/' : '';
+    if (!emitProjectTreeLine(state, `${prefix}${connector}${entry.name}${suffix}`)) {
+      return;
+    }
+    if (entry.kind !== 'directory') {
+      continue;
+    }
+    const child = node.directories.get(entry.name)!;
+    walkGitTree(child, depth + 1, `${prefix}${isLast ? '   ' : '│  '}`, state);
+  }
+}
+
+function walkFilesystemTree(
+  currentPath: string,
+  depth: number,
+  prefix: string,
+  skipNames: ReadonlySet<string>,
+  readDirectoryEntries: ReadDirectoryEntries,
+  state: ProjectTreeEmitState,
+): void {
+  if (depth >= state.maxDepth) {
+    return;
+  }
+  let entries: ProjectTreeDirectoryEntry[];
+  try {
+    entries = sortProjectTreeEntries(
+      readDirectoryEntries(currentPath).filter((entry) => !skipNames.has(entry.name)),
+    );
+  } catch (error: unknown) {
+    void emitProjectTreeLine(state, `${prefix}└─ [unreadable: ${formatProjectTreeError(error)}]`);
+    return;
+  }
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    const isLast = index === entries.length - 1;
+    const connector = isLast ? '└─ ' : '├─ ';
+    const suffix = entry.kind === 'directory' ? '/' : entry.kind === 'symlink' ? '@' : '';
+    if (!emitProjectTreeLine(state, `${prefix}${connector}${entry.name}${suffix}`)) {
+      return;
+    }
+    if (entry.kind !== 'directory') {
+      continue;
+    }
+    walkFilesystemTree(
+      join(currentPath, entry.name),
+      depth + 1,
+      `${prefix}${isLast ? '   ' : '│  '}`,
+      skipNames,
+      readDirectoryEntries,
+      state,
+    );
+  }
+}
+
+function finalizeProjectTreeLines(state: ProjectTreeEmitState): readonly string[] {
+  if (state.truncated) {
+    state.lines.push('└─ …');
+  }
+  return state.lines;
+}
+
+export function buildProjectTreeLines(
+  rootPath: string,
+  options: BuildProjectTreeLinesOptions = {},
+): readonly string[] {
+  const rootLabel = basename(rootPath) || rootPath;
+  const lines: string[] = [`${rootLabel}/`];
+  const state: ProjectTreeEmitState = {
+    lines,
+    maxDepth: toPositiveInt(options.maxDepth, DEFAULT_PROJECT_TREE_MAX_DEPTH),
+    maxEntries: Math.max(1, toPositiveInt(options.maxEntries, DEFAULT_PROJECT_TREE_MAX_ENTRIES)),
+    emitted: 0,
+    truncated: false,
+  };
+  const runGitLsFiles = options.runGitLsFiles ?? runGitLsFilesSync;
+  const gitOutput = runGitLsFiles(rootPath, [
+    'ls-files',
+    '--cached',
+    '--others',
+    '--exclude-standard',
+    '-z',
+  ]);
+  if (gitOutput !== null) {
+    const root = createGitTreeNode();
+    for (const path of parseGitLsFilesOutput(gitOutput)) {
+      insertGitTreePath(root, path);
+    }
+    walkGitTree(root, 0, '', state);
+    return finalizeProjectTreeLines(state);
+  }
+  walkFilesystemTree(
+    rootPath,
+    0,
+    '',
+    resolveSkipNames(options.skipNames),
+    options.readDirectoryEntries ?? readDirectoryEntriesFromFilesystem,
+    state,
+  );
+  return finalizeProjectTreeLines(state);
+}

package/src/mux/render-frame.ts

@@ -0,0 +1,113 @@
+import { padOrTrimDisplay } from './dual-pane-core.ts';
+
+interface RenderCursorStyle {
+  readonly shape: 'block' | 'underline' | 'bar';
+  readonly blinking: boolean;
+}
+
+interface MuxPerfStatusRow {
+  readonly fps: number;
+  readonly kbPerSecond: number;
+  readonly renderAvgMs: number;
+  readonly renderMaxMs: number;
+  readonly outputHandleAvgMs: number;
+  readonly outputHandleMaxMs: number;
+  readonly eventLoopP95Ms: number;
+}
+
+interface MuxPaneLayout {
+  readonly cols: number;
+  readonly paneRows: number;
+  readonly leftCols: number;
+  readonly rightCols: number;
+  readonly separatorCol: number;
+  readonly rightStartCol: number;
+}
+
+interface MuxModalOverlay {
+  readonly left: number;
+  readonly top: number;
+  readonly rows: readonly string[];
+}
+
+const MUTED_SEPARATOR = '\u001b[0;38;5;240m│\u001b[0m';
+
+export function buildRenderRows(
+  layout: MuxPaneLayout,
+  railRows: readonly string[],
+  rightRows: readonly string[],
+  perf: MuxPerfStatusRow,
+  statusRowDetailText?: string,
+): string[] {
+  const rows: string[] = [];
+  const separatorAnchor = `\u001b[${String(layout.separatorCol)}G`;
+  const rightAnchor = `\u001b[${String(layout.rightStartCol)}G`;
+  for (let row = 0; row < layout.paneRows; row += 1) {
+    const left = railRows[row] ?? ' '.repeat(layout.leftCols);
+    const right = rightRows[row] ?? ' '.repeat(layout.rightCols);
+    rows.push(`${left}\u001b[0m${separatorAnchor}${MUTED_SEPARATOR}${rightAnchor}${right}`);
+  }
+  const defaultStatus = `[mux] fps=${perf.fps.toFixed(1)} kb/s=${perf.kbPerSecond.toFixed(1)} render=${perf.renderAvgMs.toFixed(2)}/${perf.renderMaxMs.toFixed(2)}ms output=${perf.outputHandleAvgMs.toFixed(2)}/${perf.outputHandleMaxMs.toFixed(2)}ms loop.p95=${perf.eventLoopP95Ms.toFixed(1)}ms`;
+  const statusText =
+    statusRowDetailText === undefined || statusRowDetailText.length === 0
+      ? defaultStatus
+      : `${defaultStatus}  ${statusRowDetailText}`;
+  const status = padOrTrimDisplay(statusText, layout.cols);
+  rows.push(status);
+  return rows;
+}
+
+export function applyModalOverlay(rows: string[], overlay: MuxModalOverlay): void {
+  for (let rowOffset = 0; rowOffset < overlay.rows.length; rowOffset += 1) {
+    const targetRow = overlay.top + rowOffset;
+    if (targetRow < 0 || targetRow >= rows.length) {
+      continue;
+    }
+    const overlayRow = overlay.rows[rowOffset];
+    if (overlayRow === undefined) {
+      continue;
+    }
+    rows[targetRow] = `${rows[targetRow] ?? ''}\u001b[${String(overlay.left + 1)}G${overlayRow}`;
+  }
+}
+
+export function cursorStyleToDecscusr(style: RenderCursorStyle): string {
+  if (style.shape === 'block') {
+    return style.blinking ? '\u001b[1 q' : '\u001b[2 q';
+  }
+  if (style.shape === 'underline') {
+    return style.blinking ? '\u001b[3 q' : '\u001b[4 q';
+  }
+  return style.blinking ? '\u001b[5 q' : '\u001b[6 q';
+}
+
+export function cursorStyleEqual(
+  left: RenderCursorStyle | null,
+  right: RenderCursorStyle,
+): boolean {
+  if (left === null) {
+    return false;
+  }
+  return left.shape === right.shape && left.blinking === right.blinking;
+}
+
+export function renderCanonicalFrameAnsi(
+  rows: readonly string[],
+  cursorStyle: RenderCursorStyle,
+  cursorVisible: boolean,
+  cursorRow: number,
+  cursorCol: number,
+): string {
+  let output = '\u001b[?25l\u001b[H\u001b[2J';
+  output += cursorStyleToDecscusr(cursorStyle);
+  for (let row = 0; row < rows.length; row += 1) {
+    output += `\u001b[${String(row + 1)};1H\u001b[2K${rows[row] ?? ''}`;
+  }
+  if (cursorVisible) {
+    output += '\u001b[?25h';
+    output += `\u001b[${String(cursorRow + 1)};${String(cursorCol + 1)}H`;
+  } else {
+    output += '\u001b[?25l';
+  }
+  return output;
+}