@jmoyers/harness 0.1.10 → 0.1.20

package/src/mux/live-mux/input-forwarding.ts

@@ -17,7 +17,7 @@ type RoutedInputToken =
 
 interface RouteInputTokensForConversationOptions {
   tokens: readonly RoutedInputToken[];
-  mainPaneMode: 'conversation' | 'project' | 'home';
+  mainPaneMode: 'conversation' | 'project' | 'home' | 'nim';
   normalizeMuxKeyboardInputForPty: (input: Buffer) => Buffer;
   classifyPaneAt: (col: number, row: number) => string;
   wheelDeltaRowsFromCode: (code: number) => number | null;
@@ -27,8 +27,31 @@ interface RouteInputTokensForConversationOptions {
     rightCols: number;
     rightStartCol: number;
   };
-  snapshotForInput: Pick<TerminalSnapshotFrameCore, 'activeScreen' | 'viewport'> | null;
+  snapshotForInput:
+    | (Pick<TerminalSnapshotFrameCore, 'activeScreen' | 'viewport'> & {
+        lines?: readonly string[];
+      })
+    | null;
   appMouseTrackingEnabled: boolean;
+  hasMetaModifier?: (code: number) => boolean;
+  handleMetaClick?: (input: {
+    event: {
+      col: number;
+      row: number;
+      code: number;
+      final: 'M' | 'm';
+    };
+    layout: {
+      paneRows: number;
+      rightCols: number;
+      rightStartCol: number;
+    };
+    snapshotForInput:
+      | (Pick<TerminalSnapshotFrameCore, 'activeScreen' | 'viewport'> & {
+          lines?: readonly string[];
+        })
+      | null;
+  }) => boolean;
 }
 
 interface RouteInputTokensForConversationResult {
@@ -40,6 +63,28 @@ function encodeSgrMouseEvent(code: number, col: number, row: number, final: 'M'
   return Buffer.from(`\u001b[<${String(code)};${String(col)};${String(row)}${final}`, 'utf8');
 }
 
+function isWheelMouseCode(code: number): boolean {
+  return (code & 0b0100_0000) !== 0;
+}
+
+function isMotionMouseCode(code: number): boolean {
+  return (code & 0b0010_0000) !== 0;
+}
+
+function isLeftButtonPress(code: number, final: 'M' | 'm'): boolean {
+  if (final !== 'M') {
+    return false;
+  }
+  if (isWheelMouseCode(code) || isMotionMouseCode(code)) {
+    return false;
+  }
+  return (code & 0b0000_0011) === 0;
+}
+
+function hasMetaModifier(code: number): boolean {
+  return (code & 0b0000_1000) !== 0;
+}
+
 function shouldPassThroughMouseToConversation(
   options: Pick<
     RouteInputTokensForConversationOptions,
@@ -85,6 +130,18 @@ export function routeInputTokensForConversation(
     if (options.mainPaneMode !== 'conversation') {
       continue;
     }
+    if (
+      options.handleMetaClick !== undefined &&
+      isLeftButtonPress(token.event.code, token.event.final) &&
+      (options.hasMetaModifier ?? hasMetaModifier)(token.event.code)
+    ) {
+      const handled = options.handleMetaClick({
+        event: token.event,
+        layout: options.layout,
+        snapshotForInput: options.snapshotForInput,
+      });
+      if (handled) continue;
+    }
     if (shouldPassThroughMouseToConversation(options, token.event.code)) {
       const sessionCol = Math.max(
         1,

package/src/mux/live-mux/left-nav-activation.ts

@@ -5,33 +5,81 @@ interface ActivateLeftNavTargetOptions {
   target: LeftNavSelection;
   direction: 'next' | 'previous';
   enterHomePane: () => void;
+  enterNimPane?: () => void;
+  enterTasksPane?: () => void;
   firstDirectoryForRepositoryGroup: (repositoryGroupId: string) => string | null;
   enterProjectPane: (directoryId: string) => void;
+  enterGitHubPane?: (directoryId: string) => void;
   setMainPaneProjectMode: () => void;
   selectLeftNavRepository: (repositoryGroupId: string) => void;
+  selectLeftNavConversation?: (sessionId: string) => void;
   markDirty: () => void;
   directoriesHas: (directoryId: string) => boolean;
   visibleTargetsForState: () => readonly LeftNavSelection[];
   conversationDirectoryId: (sessionId: string) => string | null;
   queueControlPlaneOp: (task: () => Promise<void>, label: string) => void;
-  activateConversation: (sessionId: string) => Promise<void>;
+  queueLatestControlPlaneOp?: (
+    key: string,
+    task: (options: { readonly signal: AbortSignal }) => Promise<void>,
+    label: string,
+  ) => void;
+  activateConversation: (
+    sessionId: string,
+    options?: { readonly signal?: AbortSignal },
+  ) => Promise<void>;
   conversationsHas: (sessionId: string) => boolean;
 }
 
+const LEFT_NAV_ACTIVATION_KEY = 'left-nav:activate-conversation';
+
+function queueLeftNavConversationActivation(
+  options: Pick<
+    ActivateLeftNavTargetOptions,
+    'queueControlPlaneOp' | 'queueLatestControlPlaneOp' | 'activateConversation'
+  > & {
+    readonly sessionId: string;
+    readonly label: string;
+  },
+): void {
+  if (options.queueLatestControlPlaneOp !== undefined) {
+    options.queueLatestControlPlaneOp(
+      LEFT_NAV_ACTIVATION_KEY,
+      async ({ signal }) => {
+        if (signal.aborted) {
+          return;
+        }
+        await options.activateConversation(options.sessionId, {
+          signal,
+        });
+      },
+      options.label,
+    );
+    return;
+  }
+  options.queueControlPlaneOp(async () => {
+    await options.activateConversation(options.sessionId);
+  }, options.label);
+}
+
 export function activateLeftNavTarget(options: ActivateLeftNavTargetOptions): void {
   const {
     target,
     direction,
     enterHomePane,
+    enterNimPane,
+    enterTasksPane,
     firstDirectoryForRepositoryGroup,
     enterProjectPane,
+    enterGitHubPane,
     setMainPaneProjectMode,
     selectLeftNavRepository,
+    selectLeftNavConversation,
     markDirty,
     directoriesHas,
     visibleTargetsForState,
     conversationDirectoryId,
     queueControlPlaneOp,
+    queueLatestControlPlaneOp,
     activateConversation,
     conversationsHas,
   } = options;
@@ -39,6 +87,22 @@ export function activateLeftNavTarget(options: ActivateLeftNavTargetOptions): vo
     enterHomePane();
     return;
   }
+  if (target.kind === 'nim') {
+    if (enterNimPane !== undefined) {
+      enterNimPane();
+      return;
+    }
+    enterHomePane();
+    return;
+  }
+  if (target.kind === 'tasks') {
+    if (enterTasksPane !== undefined) {
+      enterTasksPane();
+      return;
+    }
+    enterHomePane();
+    return;
+  }
   if (target.kind === 'repository') {
     const firstDirectoryId = firstDirectoryForRepositoryGroup(target.repositoryId);
     if (firstDirectoryId !== null) {
@@ -63,18 +127,71 @@ export function activateLeftNavTarget(options: ActivateLeftNavTargetOptions): vo
         conversationDirectoryId(entry.sessionId) === target.directoryId,
     );
     if (fallbackConversation !== undefined) {
-      queueControlPlaneOp(async () => {
-        await activateConversation(fallbackConversation.sessionId);
-      }, `shortcut-activate-${direction}-directory-fallback`);
+      selectLeftNavConversation?.(fallbackConversation.sessionId);
+      markDirty();
+      queueLeftNavConversationActivation({
+        queueControlPlaneOp,
+        ...(queueLatestControlPlaneOp === undefined
+          ? {}
+          : {
+              queueLatestControlPlaneOp,
+            }),
+        activateConversation,
+        sessionId: fallbackConversation.sessionId,
+        label: `shortcut-activate-${direction}-directory-fallback`,
+      });
+    }
+    return;
+  }
+  if (target.kind === 'github') {
+    if (directoriesHas(target.directoryId)) {
+      if (enterGitHubPane !== undefined) {
+        enterGitHubPane(target.directoryId);
+      } else {
+        enterProjectPane(target.directoryId);
+      }
+      markDirty();
+      return;
+    }
+    const visibleTargets = visibleTargetsForState();
+    const fallbackConversation = visibleTargets.find(
+      (entry): entry is Extract<LeftNavSelection, { kind: 'conversation' }> =>
+        entry.kind === 'conversation' &&
+        conversationDirectoryId(entry.sessionId) === target.directoryId,
+    );
+    if (fallbackConversation !== undefined) {
+      selectLeftNavConversation?.(fallbackConversation.sessionId);
+      markDirty();
+      queueLeftNavConversationActivation({
+        queueControlPlaneOp,
+        ...(queueLatestControlPlaneOp === undefined
+          ? {}
+          : {
+              queueLatestControlPlaneOp,
+            }),
+        activateConversation,
+        sessionId: fallbackConversation.sessionId,
+        label: `shortcut-activate-${direction}-github-fallback`,
+      });
     }
     return;
   }
   if (!conversationsHas(target.sessionId)) {
     return;
   }
-  queueControlPlaneOp(async () => {
-    await activateConversation(target.sessionId);
-  }, `shortcut-activate-${direction}`);
+  selectLeftNavConversation?.(target.sessionId);
+  markDirty();
+  queueLeftNavConversationActivation({
+    queueControlPlaneOp,
+    ...(queueLatestControlPlaneOp === undefined
+      ? {}
+      : {
+          queueLatestControlPlaneOp,
+        }),
+    activateConversation,
+    sessionId: target.sessionId,
+    label: `shortcut-activate-${direction}`,
+  });
 }
 
 interface CycleLeftNavSelectionOptions {

package/src/mux/live-mux/left-nav.ts

@@ -4,6 +4,12 @@ export type LeftNavSelection =
   | {
       readonly kind: 'home';
     }
+  | {
+      readonly kind: 'nim';
+    }
+  | {
+      readonly kind: 'tasks';
+    }
   | {
       readonly kind: 'repository';
       readonly repositoryId: string;
@@ -12,6 +18,10 @@ export type LeftNavSelection =
       readonly kind: 'project';
       readonly directoryId: string;
     }
+  | {
+      readonly kind: 'github';
+      readonly directoryId: string;
+    }
   | {
       readonly kind: 'conversation';
       readonly sessionId: string;
@@ -21,12 +31,21 @@ export function leftNavTargetKey(target: LeftNavSelection): string {
   if (target.kind === 'home') {
     return 'home';
   }
+  if (target.kind === 'nim') {
+    return 'nim';
+  }
+  if (target.kind === 'tasks') {
+    return 'tasks';
+  }
   if (target.kind === 'repository') {
     return `repository:${target.repositoryId}`;
   }
   if (target.kind === 'project') {
     return `directory:${target.directoryId}`;
   }
+  if (target.kind === 'github') {
+    return `github:${target.directoryId}`;
+  }
   return `conversation:${target.sessionId}`;
 }
 
@@ -43,6 +62,16 @@ function leftNavTargetFromRow(
       kind: 'home',
     };
   }
+  if (row.railAction === 'nim.open') {
+    return {
+      kind: 'nim',
+    };
+  }
+  if (row.railAction === 'tasks.open') {
+    return {
+      kind: 'tasks',
+    };
+  }
   if (row.kind === 'repository-header' && row.repositoryId !== null) {
     return {
       kind: 'repository',
@@ -55,6 +84,12 @@ function leftNavTargetFromRow(
       directoryId: row.directoryKey,
     };
   }
+  if (row.kind === 'github-header' && row.directoryKey !== null) {
+    return {
+      kind: 'github',
+      directoryId: row.directoryKey,
+    };
+  }
   if (row.kind === 'conversation-title' && row.conversationSessionId !== null) {
     return {
       kind: 'conversation',

package/src/mux/live-mux/link-click.ts

@@ -0,0 +1,292 @@
+import { isAbsolute, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import type { ResolvedCommandMenuOpenInTarget } from './command-menu-open-in.ts';
+
+const TOKEN_REGEX = /\S+/gu;
+const LEADING_WRAP_CHARS = new Set(['"', "'", '`', '(', '[', '{', '<']);
+const TRAILING_WRAP_CHARS = new Set(['"', "'", '`', ')', ']', '}', '>', ',', '.', ';', '!', '?']);
+const EDITOR_LINE_TARGET_IDS = new Set(['zed', 'cursor', 'vscode']);
+
+type TerminalLinkTarget = TerminalUrlLinkTarget | TerminalFileLinkTarget;
+
+interface TerminalUrlLinkTarget {
+  readonly kind: 'url';
+  readonly url: string;
+}
+
+interface TerminalFileLinkTarget {
+  readonly kind: 'file';
+  readonly path: string;
+  readonly line: number | null;
+  readonly column: number | null;
+}
+
+function trimTokenWrapper(token: string): string {
+  let start = 0;
+  let end = token.length;
+  while (start < end && LEADING_WRAP_CHARS.has(token[start]!)) {
+    start += 1;
+  }
+  while (end > start && TRAILING_WRAP_CHARS.has(token[end - 1]!)) {
+    end -= 1;
+  }
+  return token.slice(start, end);
+}
+
+function parsePositiveInteger(value: string): number | null {
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+  return parsed;
+}
+
+function splitTrailingLineColumn(value: string): {
+  readonly path: string;
+  readonly line: number | null;
+  readonly column: number | null;
+} {
+  let remainder = value;
+  let column: number | null = null;
+  let line: number | null = null;
+
+  const trailingColumn = /:(\d+)$/u.exec(remainder);
+  if (trailingColumn !== null) {
+    const parsed = parsePositiveInteger(trailingColumn[1]!);
+    if (parsed !== null) {
+      column = parsed;
+      remainder = remainder.slice(0, -trailingColumn[0].length);
+    }
+  }
+
+  const trailingLine = /:(\d+)$/u.exec(remainder);
+  if (trailingLine !== null) {
+    const parsed = parsePositiveInteger(trailingLine[1]!);
+    if (parsed !== null) {
+      line = parsed;
+      remainder = remainder.slice(0, -trailingLine[0].length);
+    }
+  } else if (column !== null) {
+    line = column;
+    column = null;
+  }
+
+  return {
+    path: remainder,
+    line,
+    column,
+  };
+}
+
+function parseUrlTarget(candidate: string): TerminalUrlLinkTarget | null {
+  if (!/^https?:\/\//iu.test(candidate)) {
+    return null;
+  }
+  let parsed: URL;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    return null;
+  }
+  return {
+    kind: 'url',
+    url: parsed.toString(),
+  };
+}
+
+function looksLikeFilePath(pathLike: string, hasLineOrColumnSuffix: boolean): boolean {
+  if (pathLike.length === 0 || /\s/u.test(pathLike) || pathLike.includes('://')) {
+    return false;
+  }
+  if (
+    pathLike.startsWith('/') ||
+    pathLike.startsWith('./') ||
+    pathLike.startsWith('../') ||
+    pathLike.startsWith('~/')
+  ) {
+    return true;
+  }
+  if (pathLike.includes('/') || pathLike.includes('\\') || /^[A-Za-z]:[\\/]/u.test(pathLike)) {
+    return true;
+  }
+  if (hasLineOrColumnSuffix) {
+    return /^[A-Za-z0-9._-]+$/u.test(pathLike);
+  }
+  return /^[A-Za-z0-9._-]+\.[A-Za-z0-9._-]+$/u.test(pathLike);
+}
+
+function parseFileTarget(candidate: string): TerminalFileLinkTarget | null {
+  if (candidate.startsWith('file://')) {
+    try {
+      const fileUrl = new URL(candidate);
+      return {
+        kind: 'file',
+        path: fileURLToPath(fileUrl),
+        line: null,
+        column: null,
+      };
+    } catch {
+      return null;
+    }
+  }
+  const split = splitTrailingLineColumn(candidate);
+  const hasLineOrColumnSuffix = split.line !== null || split.column !== null;
+  if (!looksLikeFilePath(split.path, hasLineOrColumnSuffix)) {
+    return null;
+  }
+  return {
+    kind: 'file',
+    path: split.path,
+    line: split.line,
+    column: split.column,
+  };
+}
+
+export function resolveTerminalLinkTargetAtCell(options: {
+  readonly lines: readonly string[];
+  readonly row: number;
+  readonly col: number;
+}): TerminalLinkTarget | null {
+  if (options.row < 1 || options.col < 1) {
+    return null;
+  }
+  const line = options.lines[options.row - 1];
+  if (line === undefined || line.length === 0) {
+    return null;
+  }
+  const targetColIndex = options.col - 1;
+  for (const match of line.matchAll(TOKEN_REGEX)) {
+    const token = match[0];
+    const start = match.index ?? -1;
+    const end = start + token.length;
+    if (start < 0 || targetColIndex < start || targetColIndex >= end) {
+      continue;
+    }
+    const trimmed = trimTokenWrapper(token);
+    if (trimmed.length === 0) {
+      return null;
+    }
+    const urlTarget = parseUrlTarget(trimmed);
+    if (urlTarget !== null) {
+      return urlTarget;
+    }
+    return parseFileTarget(trimmed);
+  }
+  return null;
+}
+
+export function resolveFileLinkPath(options: {
+  readonly path: string;
+  readonly directoryPath: string | null;
+  readonly homeDirectory: string;
+}): string {
+  const normalized = options.path.trim();
+  if (normalized.startsWith('~/')) {
+    return resolve(options.homeDirectory, normalized.slice(2));
+  }
+  if (isAbsolute(normalized) || /^[A-Za-z]:[\\/]/u.test(normalized)) {
+    return normalized;
+  }
+  if (options.directoryPath !== null && options.directoryPath.trim().length > 0) {
+    return resolve(options.directoryPath, normalized);
+  }
+  return normalized;
+}
+
+export function buildFileLinkPathArgumentForTarget(options: {
+  readonly targetId: string;
+  readonly path: string;
+  readonly line: number | null;
+  readonly column: number | null;
+}): string {
+  if (options.line === null || !EDITOR_LINE_TARGET_IDS.has(options.targetId)) {
+    return options.path;
+  }
+  if (options.column === null) {
+    return `${options.path}:${String(options.line)}`;
+  }
+  return `${options.path}:${String(options.line)}:${String(options.column)}`;
+}
+
+export function prioritizeOpenInTargetsForFileLinks(
+  targets: readonly ResolvedCommandMenuOpenInTarget[],
+): readonly ResolvedCommandMenuOpenInTarget[] {
+  const preferred = targets.filter((target) => target.id === 'zed');
+  const remainder = targets.filter((target) => target.id !== 'zed');
+  return [...preferred, ...remainder];
+}
+
+function valueForPlaceholder(
+  placeholder: string,
+  values: {
+    readonly path?: string | null;
+    readonly url?: string | null;
+    readonly line?: number | null;
+    readonly column?: number | null;
+  },
+): string | null {
+  if (placeholder === '{path}') {
+    const value = values.path;
+    return typeof value === 'string' && value.length > 0 ? value : null;
+  }
+  if (placeholder === '{url}') {
+    const value = values.url;
+    return typeof value === 'string' && value.length > 0 ? value : null;
+  }
+  if (placeholder === '{line}') {
+    return typeof values.line === 'number' && values.line > 0 ? String(values.line) : null;
+  }
+  if (placeholder === '{column}') {
+    return typeof values.column === 'number' && values.column > 0 ? String(values.column) : null;
+  }
+  return null;
+}
+
+export function resolveLinkCommandFromTemplate(options: {
+  readonly template: readonly string[] | null;
+  readonly values: {
+    readonly path?: string | null;
+    readonly url?: string | null;
+    readonly line?: number | null;
+    readonly column?: number | null;
+  };
+  readonly appendPrimaryPlaceholder: '{path}' | '{url}';
+}): { command: string; args: readonly string[] } | null {
+  if (options.template === null || options.template.length === 0) {
+    return null;
+  }
+  const command = options.template[0]?.trim() ?? '';
+  if (command.length === 0) {
+    return null;
+  }
+  const args: string[] = [];
+  let injectedPrimary = false;
+  for (const rawPart of options.template.slice(1)) {
+    const part = rawPart.trim();
+    if (part.length === 0) {
+      continue;
+    }
+    const placeholderValue = valueForPlaceholder(part, options.values);
+    if (placeholderValue !== null) {
+      args.push(placeholderValue);
+      if (part === options.appendPrimaryPlaceholder) {
+        injectedPrimary = true;
+      }
+      continue;
+    }
+    if (part === '{path}' || part === '{url}' || part === '{line}' || part === '{column}') {
+      continue;
+    }
+    args.push(part);
+  }
+  if (!injectedPrimary) {
+    const fallbackValue = valueForPlaceholder(options.appendPrimaryPlaceholder, options.values);
+    if (fallbackValue !== null) {
+      args.push(fallbackValue);
+    }
+  }
+  return {
+    command,
+    args,
+  };
+}