@jmoyers/harness 0.1.10 → 0.1.20

package/src/mux/task-composer.ts

@@ -258,32 +258,39 @@ export function taskComposerMoveVertical(
 
 export function taskComposerVisibleLines(
   buffer: TaskComposerBuffer,
-  cursorToken = '_',
+  cursorToken = '█',
+  cursorVisible = true,
 ): readonly string[] {
   const normalized = normalizeTaskComposerBuffer(buffer);
+  if (!cursorVisible) {
+    return normalized.text.split('\n');
+  }
   const textWithCursor =
-    normalized.text.slice(0, normalized.cursor) +
-    cursorToken +
-    normalized.text.slice(normalized.cursor);
+    normalized.cursor >= normalized.text.length
+      ? `${normalized.text}${cursorToken}`
+      : normalized.text.slice(0, normalized.cursor) +
+        cursorToken +
+        normalized.text.slice(normalized.cursor + 1);
   return textWithCursor.split('\n');
 }
 
-export function taskComposerTextFromTaskFields(title: string, description: string): string {
-  if (description.length === 0) {
-    return title;
+export function taskComposerTextFromTaskFields(title: string, body: string): string {
+  if (body.length > 0) {
+    return body;
   }
-  return `${title}\n${description}`;
+  return title;
 }
 
 export function taskFieldsFromComposerText(text: string): {
-  readonly title: string;
-  readonly description: string;
+  readonly title: string | null;
+  readonly body: string;
 } {
-  const lines = text.split('\n');
+  const normalized = text.replace(/\r\n/gu, '\n');
+  const lines = normalized.split('\n');
   const firstLine = lines[0] ?? '';
-  const rest = lines.slice(1).join('\n');
+  const title = firstLine.trim();
   return {
-    title: firstLine.trim(),
-    description: rest,
+    title: title.length === 0 ? null : title,
+    body: normalized,
   };
 }

package/src/mux/task-focused-pane.ts

@@ -1,11 +1,11 @@
 import { padOrTrimDisplay } from './dual-pane-core.ts';
-import { type TaskStatus } from './harness-core-ui.ts';
-import { formatUiButton } from '../ui/kit.ts';
-import {
-  taskComposerTextFromTaskFields,
-  taskComposerVisibleLines,
-  type TaskComposerBuffer,
-} from './task-composer.ts';
+import type { TaskStatus } from './harness-core-ui.ts';
+import { UiKit } from '../../packages/harness-ui/src/kit.ts';
+import { WrappingInputRenderer } from '../../packages/harness-ui/src/text-layout.ts';
+import { taskComposerTextFromTaskFields, type TaskComposerBuffer } from './task-composer.ts';
+
+const UI_KIT = new UiKit();
+const WRAPPING_INPUT_RENDERER = new WrappingInputRenderer();
 
 export type TaskFocusedPaneAction =
   | 'repository.dropdown.toggle'
@@ -24,6 +24,7 @@ interface ActionCell {
 export interface TaskFocusedPaneRepositoryRecord {
   readonly repositoryId: string;
   readonly name: string;
+  readonly metadata?: Record<string, unknown>;
   readonly archivedAt: string | null;
 }
 
@@ -31,7 +32,7 @@ export interface TaskFocusedPaneTaskRecord {
   readonly taskId: string;
   readonly repositoryId: string | null;
   readonly title: string;
-  readonly description: string;
+  readonly body: string;
   readonly status: TaskStatus;
   readonly orderIndex: number;
   readonly createdAt: string;
@@ -58,6 +59,7 @@ interface BuildTaskFocusedPaneOptions {
   readonly cols: number;
   readonly rows: number;
   readonly scrollTop: number;
+  readonly cursorVisible?: boolean;
 }
 
 interface PaneLine {
@@ -70,6 +72,7 @@ interface PaneLine {
 
 export interface TaskFocusedPaneView {
   readonly rows: readonly string[];
+  readonly plainRows?: readonly string[];
   readonly taskIds: readonly (string | null)[];
   readonly repositoryIds: readonly (string | null)[];
   readonly actions: readonly (TaskFocusedPaneAction | null)[];
@@ -78,52 +81,71 @@ export interface TaskFocusedPaneView {
   readonly selectedRepositoryId: string | null;
 }
 
-const READY_CHIP_LABEL = formatUiButton({
-  label: 'ready',
-  prefixIcon: 'r',
-});
-const DRAFT_CHIP_LABEL = formatUiButton({
-  label: 'queued',
-  prefixIcon: 'd',
-});
-const COMPLETE_CHIP_LABEL = formatUiButton({
-  label: 'complete',
-  prefixIcon: 'c',
-});
-
 function sortedRepositories(
   repositories: ReadonlyMap<string, TaskFocusedPaneRepositoryRecord>,
 ): readonly TaskFocusedPaneRepositoryRecord[] {
-  return [...repositories.values()]
-    .filter((entry) => entry.archivedAt === null)
-    .sort(
-      (left, right) =>
-        left.name.localeCompare(right.name) || left.repositoryId.localeCompare(right.repositoryId),
-    );
+  return [...repositories.values()].filter((repository) => repository.archivedAt === null);
 }
 
 function parseIsoMs(value: string): number {
   return Date.parse(value);
 }
 
-function sortTasksByOrderLocal(
+function taskStatusSortRank(status: TaskStatus): number {
+  if (status === 'in-progress') {
+    return 0;
+  }
+  if (status === 'ready') {
+    return 1;
+  }
+  if (status === 'draft') {
+    return 2;
+  }
+  return 3;
+}
+
+function taskStatusGroupLabel(status: TaskStatus): string {
+  if (status === 'in-progress') {
+    return 'in prog';
+  }
+  if (status === 'ready') {
+    return 'ready';
+  }
+  if (status === 'draft') {
+    return 'draft';
+  }
+  return 'complete';
+}
+
+function compareTasksByOrder(
+  left: TaskFocusedPaneTaskRecord,
+  right: TaskFocusedPaneTaskRecord,
+): number {
+  if (left.orderIndex !== right.orderIndex) {
+    return left.orderIndex - right.orderIndex;
+  }
+  const leftTs = parseIsoMs(left.createdAt);
+  const rightTs = parseIsoMs(right.createdAt);
+  const leftFinite = Number.isFinite(leftTs);
+  const rightFinite = Number.isFinite(rightTs);
+  if (leftFinite && rightFinite && leftTs !== rightTs) {
+    return leftTs - rightTs;
+  }
+  if (leftFinite !== rightFinite) {
+    return leftFinite ? -1 : 1;
+  }
+  return left.taskId.localeCompare(right.taskId);
+}
+
+function sortTasksForDisplay(
   tasks: readonly TaskFocusedPaneTaskRecord[],
 ): readonly TaskFocusedPaneTaskRecord[] {
   return [...tasks].sort((left, right) => {
-    if (left.orderIndex !== right.orderIndex) {
-      return left.orderIndex - right.orderIndex;
+    const statusCompare = taskStatusSortRank(left.status) - taskStatusSortRank(right.status);
+    if (statusCompare !== 0) {
+      return statusCompare;
     }
-    const leftTs = parseIsoMs(left.createdAt);
-    const rightTs = parseIsoMs(right.createdAt);
-    const leftFinite = Number.isFinite(leftTs);
-    const rightFinite = Number.isFinite(rightTs);
-    if (leftFinite && rightFinite && leftTs !== rightTs) {
-      return leftTs - rightTs;
-    }
-    if (leftFinite !== rightFinite) {
-      return leftFinite ? -1 : 1;
-    }
-    return left.taskId.localeCompare(right.taskId);
+    return compareTasksByOrder(left, right);
   });
 }
 
@@ -151,63 +173,26 @@ function truncate(text: string, max: number): string {
   return `${text.slice(0, safeMax - 1)}…`;
 }
 
-function composeRowWithRightChips(
-  left: string,
-  width: number,
-  chips: readonly { label: string; action: TaskFocusedPaneAction }[],
-): { readonly text: string; readonly cells: readonly ActionCell[] } {
-  const joined = chips.map((chip) => chip.label).join(' ');
-  if (joined.length === 0 || joined.length >= width) {
-    return {
-      text: padOrTrimDisplay(left, width),
-      cells: [],
-    };
-  }
-  const startCol = Math.max(0, width - joined.length);
-  const leftMax = Math.max(0, startCol - 1);
-  const leftText = padOrTrimDisplay(truncate(left, leftMax), leftMax);
-  const gap = width - leftText.length - joined.length;
-  let cursor = leftText.length + Math.max(0, gap);
-  const cells: ActionCell[] = [];
-  const parts: string[] = [leftText, ' '.repeat(Math.max(0, gap))];
-  for (let idx = 0; idx < chips.length; idx += 1) {
-    const chip = chips[idx]!;
-    parts.push(chip.label);
-    cells.push({
-      startCol: cursor,
-      endCol: cursor + chip.label.length - 1,
-      action: chip.action,
-    });
-    cursor += chip.label.length;
-    if (idx < chips.length - 1) {
-      parts.push(' ');
-      cursor += 1;
-    }
-  }
-  return {
-    text: padOrTrimDisplay(parts.join(''), width),
-    cells,
-  };
-}
-
 function taskBufferFromRecord(
   task: TaskFocusedPaneTaskRecord,
   overrides: ReadonlyMap<string, TaskComposerBuffer>,
 ): TaskComposerBuffer {
+  const text = taskComposerTextFromTaskFields(task.title, task.body);
   return (
     overrides.get(task.taskId) ?? {
-      text: taskComposerTextFromTaskFields(task.title, task.description),
-      cursor: task.title.length,
+      text,
+      cursor: text.length,
     }
   );
 }
 
 function taskPreviewText(task: TaskFocusedPaneTaskRecord): string {
-  const summary = task.description.split('\n')[0] ?? '';
-  if (summary.length === 0) {
-    return task.title;
+  const summary = task.body.split('\n')[0] ?? '';
+  const trimmed = summary.trim();
+  if (trimmed.length > 0) {
+    return trimmed;
   }
-  return `${task.title} · ${summary}`;
+  return task.title;
 }
 
 export function buildTaskFocusedPaneView(
@@ -224,7 +209,7 @@ export function buildTaskFocusedPaneView(
     repositories[0]?.repositoryId ??
     null;
 
-  const scopedTasks = sortTasksByOrderLocal(
+  const scopedTasks = sortTasksForDisplay(
     [...options.tasks.values()].filter((task) => task.repositoryId === selectedRepositoryId),
   );
 
@@ -251,7 +236,7 @@ export function buildTaskFocusedPaneView(
       ? 'select repository'
       : (repositories.find((entry) => entry.repositoryId === selectedRepositoryId)?.name ??
         '(missing)');
-  const repositoryButton = formatUiButton({
+  const repositoryButton = UI_KIT.formatButton({
     label: truncate(selectedRepositoryName, Math.max(8, safeCols - 16)),
     suffixIcon: 'v',
   });
@@ -291,53 +276,68 @@ export function buildTaskFocusedPaneView(
   } else if (scopedTasks.length === 0) {
     push(' no tasks yet for this repository');
   } else {
+    const statusCounts = new Map<TaskStatus, number>();
+    for (const task of scopedTasks) {
+      statusCounts.set(task.status, (statusCounts.get(task.status) ?? 0) + 1);
+    }
     push(` tasks (${String(scopedTasks.length)})`);
+    let previousStatus: TaskStatus | null = null;
     for (let index = 0; index < scopedTasks.length; index += 1) {
       const task = scopedTasks[index]!;
+      if (task.status !== previousStatus) {
+        if (previousStatus !== null) {
+          push('');
+        }
+        push(
+          ` ${statusGlyph(task.status)} ${taskStatusGroupLabel(task.status)} · ${String(statusCounts.get(task.status) ?? 0)}`,
+        );
+        previousStatus = task.status;
+      }
       const focused =
         options.editorTarget.kind === 'task' && options.editorTarget.taskId === task.taskId;
-      const leftLabel = ` ${focused ? '▸' : ' '} ${statusGlyph(task.status)} ${truncate(taskPreviewText(task), Math.max(8, safeCols - 24))}`;
-      const chips =
-        task.status === 'completed'
-          ? []
-          : [
-              { label: READY_CHIP_LABEL, action: 'task.status.ready' as const },
-              { label: DRAFT_CHIP_LABEL, action: 'task.status.draft' as const },
-              { label: COMPLETE_CHIP_LABEL, action: 'task.status.complete' as const },
-            ];
-      const composed = composeRowWithRightChips(leftLabel, safeCols, chips);
-      push(composed.text, task.taskId, selectedRepositoryId, 'task.focus', composed.cells);
-
       if (focused) {
         const editBuffer = taskBufferFromRecord(task, options.taskBufferById);
-        const linesWithCursor = taskComposerVisibleLines(editBuffer);
-        push(
-          `    ${padOrTrimDisplay('─'.repeat(Math.max(4, Math.min(20, safeCols - 4))), Math.max(0, safeCols - 4))}`,
-        );
+        const editorInnerWidth = Math.max(1, safeCols - 4);
+        const editorPrefix = `${statusGlyph(task.status)} `;
+        const linesWithCursor = WRAPPING_INPUT_RENDERER.renderLines({
+          buffer: editBuffer,
+          width: editorInnerWidth,
+          linePrefix: editorPrefix,
+          cursorToken: '█',
+          cursorVisible: options.cursorVisible ?? true,
+        });
+        push(` ┌${'─'.repeat(editorInnerWidth)}┐`);
         for (const line of linesWithCursor) {
-          push(
-            `    ${truncate(line, Math.max(1, safeCols - 4))}`,
-            task.taskId,
-            selectedRepositoryId,
-            'task.focus',
-          );
+          const content = padOrTrimDisplay(line, editorInnerWidth);
+          push(` │${content}│`, task.taskId, selectedRepositoryId, 'task.focus');
         }
+        push(` └${'─'.repeat(editorInnerWidth)}┘`);
+        continue;
       }
+
+      const leftLabel = `   ${statusGlyph(task.status)} ${truncate(taskPreviewText(task), Math.max(8, safeCols - 6))}`;
+      push(leftLabel, task.taskId, selectedRepositoryId, 'task.focus');
     }
   }
 
   push('');
   const draftFocused = options.editorTarget.kind === 'draft';
   push(` draft ${draftFocused ? '(editing)' : '(saved)'}`);
-  const draftLines = draftFocused
-    ? taskComposerVisibleLines(options.draftBuffer)
-    : options.draftBuffer.text.length === 0
-      ? ['']
-      : options.draftBuffer.text.split('\n');
+  const draftInnerWidth = Math.max(1, safeCols - 4);
+  push(` ┌${'─'.repeat(draftInnerWidth)}┐`);
+  const draftLines = WRAPPING_INPUT_RENDERER.renderLines({
+    buffer: options.draftBuffer,
+    width: draftInnerWidth,
+    cursorToken: '█',
+    cursorVisible: draftFocused && (options.cursorVisible ?? true),
+  });
   for (const line of draftLines) {
-    push(` > ${truncate(line, Math.max(1, safeCols - 3))}`);
+    const content = padOrTrimDisplay(line, draftInnerWidth);
+    push(` │${content}│`);
   }
-  push(' enter ready  tab queue  shift+enter newline  ctrl+g repos');
+  push(` └${'─'.repeat(draftInnerWidth)}┘`);
+  push(' enter ready  tab draft  shift+enter newline');
+  push(' alt+g repos  ctrl+up/down reorder');
 
   const maxTop = Math.max(0, lines.length - safeRows);
   const top = Math.max(0, Math.min(maxTop, options.scrollTop));
@@ -353,6 +353,7 @@ export function buildTaskFocusedPaneView(
   }
   return {
     rows: viewport.map((line) => line.text),
+    plainRows: viewport.map((line) => line.text),
     taskIds: viewport.map((line) => line.taskId),
     repositoryIds: viewport.map((line) => line.repositoryId),
     actions: viewport.map((line) => line.action),

package/src/mux/task-screen-keybindings.ts

@@ -1,3 +1,12 @@
+import {
+  DEFAULT_TASK_SCREEN_KEYBINDINGS_RAW,
+  TASK_SCREEN_KEYBINDING_ACTION_ORDER,
+  type TaskScreenKeybindingAction,
+} from './keybinding-registry.ts';
+
+export { DEFAULT_TASK_SCREEN_KEYBINDINGS_RAW };
+export type { TaskScreenKeybindingAction };
+
 interface KeyStroke {
   readonly key: string;
   readonly ctrl: boolean;
@@ -11,87 +20,7 @@ interface ParsedBinding {
   readonly originalText: string;
 }
 
-export type TaskScreenKeybindingAction =
-  | 'mux.home.repo.dropdown.toggle'
-  | 'mux.home.repo.next'
-  | 'mux.home.repo.previous'
-  | 'mux.home.task.submit'
-  | 'mux.home.task.queue'
-  | 'mux.home.task.newline'
-  | 'mux.home.task.status.ready'
-  | 'mux.home.task.status.draft'
-  | 'mux.home.task.status.complete'
-  | 'mux.home.task.reorder.up'
-  | 'mux.home.task.reorder.down'
-  | 'mux.home.editor.cursor.left'
-  | 'mux.home.editor.cursor.right'
-  | 'mux.home.editor.cursor.up'
-  | 'mux.home.editor.cursor.down'
-  | 'mux.home.editor.line.start'
-  | 'mux.home.editor.line.end'
-  | 'mux.home.editor.word.left'
-  | 'mux.home.editor.word.right'
-  | 'mux.home.editor.delete.backward'
-  | 'mux.home.editor.delete.forward'
-  | 'mux.home.editor.delete.word.backward'
-  | 'mux.home.editor.delete.line.start'
-  | 'mux.home.editor.delete.line.end';
-
-const ACTION_ORDER: readonly TaskScreenKeybindingAction[] = [
-  'mux.home.repo.dropdown.toggle',
-  'mux.home.repo.next',
-  'mux.home.repo.previous',
-  'mux.home.task.submit',
-  'mux.home.task.queue',
-  'mux.home.task.newline',
-  'mux.home.task.status.ready',
-  'mux.home.task.status.draft',
-  'mux.home.task.status.complete',
-  'mux.home.task.reorder.up',
-  'mux.home.task.reorder.down',
-  'mux.home.editor.cursor.left',
-  'mux.home.editor.cursor.right',
-  'mux.home.editor.cursor.up',
-  'mux.home.editor.cursor.down',
-  'mux.home.editor.line.start',
-  'mux.home.editor.line.end',
-  'mux.home.editor.word.left',
-  'mux.home.editor.word.right',
-  'mux.home.editor.delete.backward',
-  'mux.home.editor.delete.forward',
-  'mux.home.editor.delete.word.backward',
-  'mux.home.editor.delete.line.start',
-  'mux.home.editor.delete.line.end',
-] as const;
-
-export const DEFAULT_TASK_SCREEN_KEYBINDINGS_RAW: Readonly<
-  Record<TaskScreenKeybindingAction, readonly string[]>
-> = {
-  'mux.home.repo.dropdown.toggle': ['ctrl+g'],
-  'mux.home.repo.next': ['ctrl+n'],
-  'mux.home.repo.previous': ['ctrl+p'],
-  'mux.home.task.submit': ['enter'],
-  'mux.home.task.queue': ['tab'],
-  'mux.home.task.newline': ['shift+enter'],
-  'mux.home.task.status.ready': ['alt+r'],
-  'mux.home.task.status.draft': ['alt+d'],
-  'mux.home.task.status.complete': ['alt+c'],
-  'mux.home.task.reorder.up': ['alt+up'],
-  'mux.home.task.reorder.down': ['alt+down'],
-  'mux.home.editor.cursor.left': ['left', 'ctrl+b'],
-  'mux.home.editor.cursor.right': ['right', 'ctrl+f'],
-  'mux.home.editor.cursor.up': ['up'],
-  'mux.home.editor.cursor.down': ['down'],
-  'mux.home.editor.line.start': ['ctrl+a', 'home'],
-  'mux.home.editor.line.end': ['ctrl+e', 'end'],
-  'mux.home.editor.word.left': ['alt+b'],
-  'mux.home.editor.word.right': ['alt+f'],
-  'mux.home.editor.delete.backward': ['backspace'],
-  'mux.home.editor.delete.forward': ['delete'],
-  'mux.home.editor.delete.word.backward': ['ctrl+w', 'alt+backspace'],
-  'mux.home.editor.delete.line.start': ['ctrl+u'],
-  'mux.home.editor.delete.line.end': ['ctrl+k'],
-};
+const ACTION_ORDER = TASK_SCREEN_KEYBINDING_ACTION_ORDER;
 
 const KEY_TOKEN_ALIASES = new Map<string, string>([
   ['cmd', 'meta'],
@@ -437,10 +366,18 @@ function parseBinding(input: string): ParsedBinding | null {
 
 function bindingsForAction(raw: readonly string[]): readonly ParsedBinding[] {
   const parsed: ParsedBinding[] = [];
+
+  const pushIfUnique = (candidate: ParsedBinding): void => {
+    if (parsed.some((existing) => strokesEqual(existing.stroke, candidate.stroke))) {
+      return;
+    }
+    parsed.push(candidate);
+  };
+
   for (const value of raw) {
     const next = parseBinding(value);
     if (next !== null) {
-      parsed.push(next);
+      pushIfUnique(next);
     }
   }
   return parsed;