@jmoyers/harness 0.1.0

package/src/mux/live-mux/rail-layout.ts

@@ -0,0 +1,244 @@
+import { basename } from 'node:path';
+import type { ConversationRailSessionSummary } from '../conversation-rail.ts';
+import { firstShortcutText } from '../input-shortcuts.ts';
+import type { resolveMuxShortcutBindings } from '../input-shortcuts.ts';
+import { buildWorkspaceRailViewRows } from '../workspace-rail-model.ts';
+import { renderWorkspaceRailAnsiRows } from '../workspace-rail.ts';
+import type {
+  StreamSessionController,
+  StreamSessionStatusModel,
+} from '../../control-plane/stream-protocol.ts';
+
+type ResolvedMuxShortcutBindings = ReturnType<typeof resolveMuxShortcutBindings>;
+type WorkspaceRailModel = Parameters<typeof renderWorkspaceRailAnsiRows>[0];
+
+interface GitSummary {
+  readonly branch: string;
+  readonly changedFiles: number;
+  readonly additions: number;
+  readonly deletions: number;
+}
+
+interface GitRepositorySnapshot {
+  readonly normalizedRemoteUrl: string | null;
+  readonly commitCount: number | null;
+  readonly lastCommitAt: string | null;
+  readonly shortCommitHash: string | null;
+  readonly inferredName: string | null;
+  readonly defaultBranch: string | null;
+}
+
+interface MuxRailRepositoryRecord {
+  readonly repositoryId: string;
+  readonly name: string;
+  readonly remoteUrl: string;
+}
+
+interface MuxRailDirectoryRecord {
+  readonly directoryId: string;
+  readonly path: string;
+}
+
+interface MuxRailConversationRecord {
+  readonly sessionId: string;
+  readonly directoryId: string | null;
+  readonly title: string;
+  readonly agentType: string;
+  readonly status: ConversationRailSessionSummary['status'];
+  readonly statusModel: StreamSessionStatusModel | null;
+  readonly attentionReason: string | null;
+  readonly live: boolean;
+  readonly startedAt: string;
+  readonly lastEventAt: string | null;
+  readonly controller: StreamSessionController | null;
+}
+
+interface MuxRailProcessUsageSample {
+  readonly cpuPercent: number | null;
+  readonly memoryMb: number | null;
+}
+
+interface BuildRailModelArgs {
+  readonly repositories: ReadonlyMap<string, MuxRailRepositoryRecord>;
+  readonly repositoryAssociationByDirectoryId: ReadonlyMap<string, string>;
+  readonly directoryRepositorySnapshotByDirectoryId: ReadonlyMap<string, GitRepositorySnapshot>;
+  readonly directories: ReadonlyMap<string, MuxRailDirectoryRecord>;
+  readonly conversations: ReadonlyMap<string, MuxRailConversationRecord>;
+  readonly orderedIds: readonly string[];
+  readonly activeProjectId: string | null;
+  readonly activeRepositoryId: string | null;
+  readonly activeConversationId: string | null;
+  readonly projectSelectionEnabled: boolean;
+  readonly repositorySelectionEnabled: boolean;
+  readonly homeSelectionEnabled: boolean;
+  readonly repositoriesCollapsed: boolean;
+  readonly collapsedRepositoryGroupIds: ReadonlySet<string>;
+  readonly shortcutsCollapsed: boolean;
+  readonly gitSummaryByDirectoryId: ReadonlyMap<string, GitSummary>;
+  readonly processUsageBySessionId: ReadonlyMap<string, MuxRailProcessUsageSample>;
+  readonly shortcutBindings: ResolvedMuxShortcutBindings;
+  readonly loadingGitSummary: GitSummary;
+}
+
+interface BuildRailRowsArgs extends BuildRailModelArgs {
+  readonly layout: {
+    leftCols: number;
+    paneRows: number;
+  };
+}
+
+function shortcutHintText(bindings: ResolvedMuxShortcutBindings): string {
+  const newConversation = firstShortcutText(bindings, 'mux.conversation.new') || 'ctrl+t';
+  const critiqueConversation =
+    firstShortcutText(bindings, 'mux.conversation.critique.open-or-create') || 'ctrl+g';
+  const deleteConversation = firstShortcutText(bindings, 'mux.conversation.delete') || 'ctrl+x';
+  const takeoverConversation = firstShortcutText(bindings, 'mux.conversation.takeover') || 'ctrl+l';
+  const addProject = firstShortcutText(bindings, 'mux.directory.add') || 'ctrl+o';
+  const closeProject = firstShortcutText(bindings, 'mux.directory.close') || 'ctrl+w';
+  const next = firstShortcutText(bindings, 'mux.conversation.next') || 'ctrl+j';
+  const previous = firstShortcutText(bindings, 'mux.conversation.previous') || 'ctrl+k';
+  const interruptConversation = firstShortcutText(bindings, 'mux.conversation.interrupt');
+  const quit = firstShortcutText(bindings, 'mux.app.interrupt-all') || 'ctrl+c';
+  const commandMenu = firstShortcutText(bindings, 'mux.command-menu.toggle') || 'ctrl+p';
+  const profile = firstShortcutText(bindings, 'mux.gateway.profile.toggle') || 'ctrl+shift+p';
+  const statusTimeline =
+    firstShortcutText(bindings, 'mux.gateway.status-timeline.toggle') || 'alt+r';
+  const renderTrace = firstShortcutText(bindings, 'mux.gateway.render-trace.toggle') || 'ctrl+]';
+  const switchHint = next === previous ? next : `${next}/${previous}`;
+  const interruptHint =
+    interruptConversation.length === 0 ? '' : `  ${interruptConversation} interrupt`;
+  return `${commandMenu} menu  ${newConversation} new  ${critiqueConversation} critique  ${deleteConversation} archive  ${takeoverConversation} takeover  ${addProject}/${closeProject} projects  ${switchHint} switch nav  ${profile} profile  ${statusTimeline} status  ${renderTrace} render${interruptHint}  ←/→ collapse/expand  ${quit} quit`;
+}
+
+function conversationSummary(
+  conversation: MuxRailConversationRecord,
+): ConversationRailSessionSummary {
+  return {
+    sessionId: conversation.sessionId,
+    status: conversation.status,
+    statusModel: conversation.statusModel,
+    attentionReason: conversation.attentionReason,
+    live: conversation.live,
+    startedAt: conversation.startedAt,
+    lastEventAt: conversation.lastEventAt,
+  };
+}
+
+export function buildRailModel(args: BuildRailModelArgs): WorkspaceRailModel {
+  const repositoryRows = [...args.repositories.values()].map((repository) => {
+    let associatedProjectCount = 0;
+    let commitCount: number | null = null;
+    let lastCommitAt: string | null = null;
+    let shortCommitHash: string | null = null;
+    for (const [directoryId, repositoryId] of args.repositoryAssociationByDirectoryId.entries()) {
+      if (repositoryId !== repository.repositoryId) {
+        continue;
+      }
+      associatedProjectCount += 1;
+      const snapshot = args.directoryRepositorySnapshotByDirectoryId.get(directoryId);
+      if (snapshot === undefined) {
+        continue;
+      }
+      if (
+        snapshot.commitCount !== null &&
+        (commitCount === null || snapshot.commitCount > commitCount)
+      ) {
+        commitCount = snapshot.commitCount;
+      }
+      const snapshotCommitAtMs =
+        snapshot.lastCommitAt === null ? Number.NaN : Date.parse(snapshot.lastCommitAt);
+      const currentCommitAtMs = lastCommitAt === null ? Number.NaN : Date.parse(lastCommitAt);
+      if (
+        snapshot.lastCommitAt !== null &&
+        (!Number.isFinite(currentCommitAtMs) || snapshotCommitAtMs >= currentCommitAtMs)
+      ) {
+        lastCommitAt = snapshot.lastCommitAt;
+        shortCommitHash = snapshot.shortCommitHash;
+      }
+    }
+    return {
+      repositoryId: repository.repositoryId,
+      name: repository.name,
+      remoteUrl: repository.remoteUrl,
+      associatedProjectCount,
+      commitCount,
+      lastCommitAt,
+      shortCommitHash,
+    };
+  });
+  const directoryRows = [...args.directories.values()].map((directory) => ({
+    key: directory.directoryId,
+    workspaceId: basename(directory.path) || directory.path,
+    worktreeId: directory.path,
+    repositoryId: args.repositoryAssociationByDirectoryId.get(directory.directoryId) ?? null,
+    git: args.gitSummaryByDirectoryId.get(directory.directoryId) ?? args.loadingGitSummary,
+  }));
+  const knownDirectoryKeys = new Set(directoryRows.map((directory) => directory.key));
+  for (const sessionId of args.orderedIds) {
+    const conversation = args.conversations.get(sessionId);
+    const directoryKey = conversation?.directoryId;
+    if (
+      directoryKey === null ||
+      directoryKey === undefined ||
+      knownDirectoryKeys.has(directoryKey)
+    ) {
+      continue;
+    }
+    knownDirectoryKeys.add(directoryKey);
+    directoryRows.push({
+      key: directoryKey,
+      workspaceId: '(untracked)',
+      worktreeId: '(untracked)',
+      repositoryId: args.repositoryAssociationByDirectoryId.get(directoryKey) ?? null,
+      git: args.gitSummaryByDirectoryId.get(directoryKey) ?? args.loadingGitSummary,
+    });
+  }
+
+  return {
+    repositories: repositoryRows,
+    directories: directoryRows,
+    conversations: args.orderedIds
+      .map((sessionId) => {
+        const conversation = args.conversations.get(sessionId);
+        if (conversation === undefined) {
+          return null;
+        }
+        const directoryKey = conversation.directoryId ?? 'directory-missing';
+        return {
+          ...conversationSummary(conversation),
+          directoryKey,
+          title: conversation.title,
+          agentLabel: conversation.agentType,
+          cpuPercent: args.processUsageBySessionId.get(conversation.sessionId)?.cpuPercent ?? null,
+          memoryMb: args.processUsageBySessionId.get(conversation.sessionId)?.memoryMb ?? null,
+          controller: conversation.controller,
+        };
+      })
+      .flatMap((conversation) => (conversation === null ? [] : [conversation])),
+    activeProjectId: args.activeProjectId,
+    activeRepositoryId: args.activeRepositoryId,
+    activeConversationId: args.activeConversationId,
+    showTaskPlanningUi: true,
+    projectSelectionEnabled: args.projectSelectionEnabled,
+    repositorySelectionEnabled: args.repositorySelectionEnabled,
+    homeSelectionEnabled: args.homeSelectionEnabled,
+    repositoriesCollapsed: args.repositoriesCollapsed,
+    collapsedRepositoryGroupIds: [...args.collapsedRepositoryGroupIds],
+    processes: [],
+    shortcutHint: shortcutHintText(args.shortcutBindings),
+    shortcutsCollapsed: args.shortcutsCollapsed,
+    nowMs: Date.now(),
+  };
+}
+
+export function buildRailRows(args: BuildRailRowsArgs): {
+  ansiRows: readonly string[];
+  viewRows: ReturnType<typeof buildWorkspaceRailViewRows>;
+} {
+  const railModel = buildRailModel(args);
+  const viewRows = buildWorkspaceRailViewRows(railModel, args.layout.paneRows);
+  return {
+    ansiRows: renderWorkspaceRailAnsiRows(railModel, args.layout.leftCols, args.layout.paneRows),
+    viewRows,
+  };
+}

package/src/mux/live-mux/render-trace-analysis.ts

@@ -0,0 +1,213 @@
+const ESC = '\u001b';
+
+const SUPPORTED_ESC_SINGLE = new Set(['7', '8', 'D', 'E', 'M', 'H', 'c']);
+const SUPPORTED_CSI_FINALS = new Set([
+  'm',
+  'A',
+  'B',
+  'C',
+  'D',
+  'G',
+  'H',
+  'f',
+  'J',
+  'K',
+  'S',
+  'T',
+  'L',
+  'M',
+  '@',
+  'P',
+  'g',
+  'r',
+  's',
+  'u',
+]);
+const SUPPORTED_PRIVATE_MODE_PARAMS = new Set([
+  6, 25, 1000, 1002, 1003, 1004, 1005, 1006, 1015, 2004, 1047, 1048, 1049,
+]);
+
+type RenderTraceControlIssueKind = 'unsupported-esc' | 'unsupported-csi' | 'unsupported-dcs';
+
+interface RenderTraceControlIssue {
+  readonly kind: RenderTraceControlIssueKind;
+  readonly offset: number;
+  readonly sequence: string;
+  readonly finalByte?: string;
+  readonly rawParams?: string;
+}
+
+function isLikelyCsiQueryPayload(payload: string): boolean {
+  if (/^(?:c|0c|>c|>0c)$/u.test(payload)) {
+    return true;
+  }
+  if (/^[0-9]*n$/u.test(payload)) {
+    return true;
+  }
+  if (/^(?:14|16|18)t$/u.test(payload)) {
+    return true;
+  }
+  if (/^>0q$/u.test(payload)) {
+    return true;
+  }
+  if (/^>4;\?m$/u.test(payload)) {
+    return true;
+  }
+  if (/^\?[0-9;]*\$p$/u.test(payload)) {
+    return true;
+  }
+  if (payload === '?u') {
+    return true;
+  }
+  return false;
+}
+
+function csiSupported(rawParams: string, finalByte: string): boolean {
+  const payload = `${rawParams}${finalByte}`;
+  if (isLikelyCsiQueryPayload(payload)) {
+    return true;
+  }
+
+  const privateMode = rawParams.startsWith('?');
+  if (privateMode && (finalByte === 'h' || finalByte === 'l')) {
+    const params = rawParams
+      .slice(1)
+      .split(';')
+      .map((value) => Number.parseInt(value, 10))
+      .filter((value) => Number.isFinite(value));
+    if (params.length === 0) {
+      return false;
+    }
+    return params.every((value) => SUPPORTED_PRIVATE_MODE_PARAMS.has(value));
+  }
+  if (finalByte === 'q' && rawParams.endsWith(' ')) {
+    return true;
+  }
+  return SUPPORTED_CSI_FINALS.has(finalByte);
+}
+
+export function renderTraceChunkPreview(chunk: Buffer | string, maxChars = 200): string {
+  const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+  const replaced = text
+    .replaceAll('\r', '\\r')
+    .replaceAll('\n', '\\n')
+    .replaceAll('\t', '\\t')
+    .replaceAll(ESC, '\\u001b');
+  if (replaced.length <= maxChars) {
+    return replaced;
+  }
+  return `${replaced.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+
+export function findRenderTraceControlIssues(
+  chunk: Buffer | string,
+  maxIssues = 12,
+): readonly RenderTraceControlIssue[] {
+  const text = typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+  const issues: RenderTraceControlIssue[] = [];
+
+  let index = 0;
+  while (index < text.length && issues.length < maxIssues) {
+    if (text[index] !== ESC) {
+      index += 1;
+      continue;
+    }
+    const next = text[index + 1];
+    if (next === undefined) {
+      break;
+    }
+
+    if (next === '[') {
+      let cursor = index + 2;
+      let resolved = false;
+      while (cursor < text.length) {
+        const code = text.charCodeAt(cursor);
+        if (code >= 0x40 && code <= 0x7e) {
+          const finalByte = text[cursor]!;
+          const rawParams = text.slice(index + 2, cursor);
+          const sequence = text.slice(index, cursor + 1);
+          if (!csiSupported(rawParams, finalByte)) {
+            issues.push({
+              kind: 'unsupported-csi',
+              offset: index,
+              sequence,
+              finalByte,
+              rawParams,
+            });
+          }
+          index = cursor + 1;
+          resolved = true;
+          break;
+        }
+        if (text[cursor] === ESC) {
+          index = cursor;
+          resolved = true;
+          break;
+        }
+        cursor += 1;
+      }
+      if (!resolved) {
+        break;
+      }
+      continue;
+    }
+
+    if (next === ']') {
+      let cursor = index + 2;
+      let resolved = false;
+      while (cursor < text.length) {
+        if (text[cursor] === '\u0007') {
+          index = cursor + 1;
+          resolved = true;
+          break;
+        }
+        if (text[cursor] === ESC && text[cursor + 1] === '\\') {
+          index = cursor + 2;
+          resolved = true;
+          break;
+        }
+        cursor += 1;
+      }
+      if (resolved) {
+        continue;
+      }
+      break;
+    }
+
+    if (next === 'P') {
+      let cursor = index + 2;
+      let resolved = false;
+      while (cursor < text.length) {
+        if (text[cursor] === ESC && text[cursor + 1] === '\\') {
+          issues.push({
+            kind: 'unsupported-dcs',
+            offset: index,
+            sequence: text.slice(index, cursor + 2),
+          });
+          index = cursor + 2;
+          resolved = true;
+          break;
+        }
+        cursor += 1;
+      }
+      if (resolved) {
+        continue;
+      }
+      break;
+    }
+
+    if (SUPPORTED_ESC_SINGLE.has(next)) {
+      index += 2;
+      continue;
+    }
+
+    issues.push({
+      kind: 'unsupported-esc',
+      offset: index,
+      sequence: `${ESC}${next}`,
+    });
+    index += 2;
+  }
+
+  return issues;
+}

package/src/mux/live-mux/render-trace-state.ts

@@ -0,0 +1,84 @@
+import { resolve } from 'node:path';
+
+const RENDER_TRACE_STATE_FILE_NAME = 'active-render-trace.json';
+export const RENDER_TRACE_STATE_VERSION = 1;
+export const RENDER_TRACE_MODE = 'live-mux-render-trace';
+export const DEFAULT_RENDER_TRACE_ROOT_PATH = '.harness/render-traces';
+export const RENDER_TRACE_FILE_NAME = 'render-trace.log';
+
+export interface ActiveRenderTraceState {
+  version: typeof RENDER_TRACE_STATE_VERSION;
+  mode: typeof RENDER_TRACE_MODE;
+  outputPath: string;
+  sessionName: string | null;
+  conversationId: string | null;
+  startedAt: string;
+}
+
+export function resolveRenderTraceStatePath(
+  invocationDirectory: string,
+  sessionName: string | null,
+): string {
+  if (sessionName === null) {
+    return resolve(invocationDirectory, '.harness', RENDER_TRACE_STATE_FILE_NAME);
+  }
+  return resolve(
+    invocationDirectory,
+    '.harness',
+    'sessions',
+    sessionName,
+    RENDER_TRACE_STATE_FILE_NAME,
+  );
+}
+
+export function resolveDefaultRenderTraceOutputPath(
+  invocationDirectory: string,
+  sessionName: string | null,
+): string {
+  if (sessionName === null) {
+    return resolve(invocationDirectory, DEFAULT_RENDER_TRACE_ROOT_PATH, RENDER_TRACE_FILE_NAME);
+  }
+  return resolve(
+    invocationDirectory,
+    DEFAULT_RENDER_TRACE_ROOT_PATH,
+    sessionName,
+    RENDER_TRACE_FILE_NAME,
+  );
+}
+
+export function parseActiveRenderTraceState(raw: unknown): ActiveRenderTraceState | null {
+  if (typeof raw !== 'object' || raw === null) {
+    return null;
+  }
+  const candidate = raw as Record<string, unknown>;
+  if (candidate['version'] !== RENDER_TRACE_STATE_VERSION) {
+    return null;
+  }
+  if (candidate['mode'] !== RENDER_TRACE_MODE) {
+    return null;
+  }
+  const outputPath = candidate['outputPath'];
+  const sessionName = candidate['sessionName'];
+  const conversationId = candidate['conversationId'];
+  const startedAt = candidate['startedAt'];
+  if (typeof outputPath !== 'string' || outputPath.length === 0) {
+    return null;
+  }
+  if (sessionName !== null && typeof sessionName !== 'string') {
+    return null;
+  }
+  if (conversationId !== null && typeof conversationId !== 'string') {
+    return null;
+  }
+  if (typeof startedAt !== 'string' || startedAt.length === 0) {
+    return null;
+  }
+  return {
+    version: RENDER_TRACE_STATE_VERSION,
+    mode: RENDER_TRACE_MODE,
+    outputPath,
+    sessionName,
+    conversationId,
+    startedAt,
+  };
+}