github-issue-tower-defence-management 1.92.1 → 1.93.0

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleSwipeNavigation.test.ts

@@ -0,0 +1,115 @@
+import { renderHook } from '@testing-library/react';
+import { useConsoleSwipeNavigation } from './useConsoleSwipeNavigation';
+
+const touchEvent = (
+  type: string,
+  point: { clientX: number; clientY: number },
+  property: 'touches' | 'changedTouches',
+): TouchEvent => {
+  const event = new Event(type, { bubbles: true }) as TouchEvent;
+  Object.defineProperty(event, property, {
+    value: [point],
+    configurable: true,
+  });
+  return event;
+};
+
+const swipe = (
+  element: HTMLElement,
+  from: { clientX: number; clientY: number },
+  to: { clientX: number; clientY: number },
+): void => {
+  element.dispatchEvent(touchEvent('touchstart', from, 'touches'));
+  element.dispatchEvent(touchEvent('touchmove', to, 'touches'));
+  element.dispatchEvent(touchEvent('touchend', to, 'changedTouches'));
+};
+
+describe('useConsoleSwipeNavigation', () => {
+  it('reports next for a dominant left swipe', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    const onSwipe = jest.fn();
+    const { result } = renderHook(() => useConsoleSwipeNavigation(onSwipe));
+    result.current(element);
+    swipe(
+      element,
+      { clientX: 200, clientY: 100 },
+      { clientX: 60, clientY: 110 },
+    );
+    expect(onSwipe).toHaveBeenCalledWith('next');
+    document.body.removeChild(element);
+  });
+
+  it('reports previous for a dominant right swipe', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    const onSwipe = jest.fn();
+    const { result } = renderHook(() => useConsoleSwipeNavigation(onSwipe));
+    result.current(element);
+    swipe(
+      element,
+      { clientX: 60, clientY: 100 },
+      { clientX: 200, clientY: 110 },
+    );
+    expect(onSwipe).toHaveBeenCalledWith('previous');
+    document.body.removeChild(element);
+  });
+
+  it('ignores a mostly vertical drag', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    const onSwipe = jest.fn();
+    const { result } = renderHook(() => useConsoleSwipeNavigation(onSwipe));
+    result.current(element);
+    swipe(
+      element,
+      { clientX: 100, clientY: 50 },
+      { clientX: 110, clientY: 200 },
+    );
+    expect(onSwipe).not.toHaveBeenCalled();
+    document.body.removeChild(element);
+  });
+
+  it('does not navigate when the gesture starts in a horizontally scrollable element', () => {
+    const element = document.createElement('div');
+    const scroller = document.createElement('div');
+    Object.defineProperty(scroller, 'scrollWidth', {
+      value: 500,
+      configurable: true,
+    });
+    Object.defineProperty(scroller, 'clientWidth', {
+      value: 100,
+      configurable: true,
+    });
+    scroller.style.overflowX = 'auto';
+    element.appendChild(scroller);
+    document.body.appendChild(element);
+    const onSwipe = jest.fn();
+    const { result } = renderHook(() => useConsoleSwipeNavigation(onSwipe));
+    result.current(element);
+    scroller.dispatchEvent(
+      touchEvent('touchstart', { clientX: 200, clientY: 100 }, 'touches'),
+    );
+    scroller.dispatchEvent(
+      touchEvent('touchend', { clientX: 60, clientY: 100 }, 'changedTouches'),
+    );
+    expect(onSwipe).not.toHaveBeenCalled();
+    document.body.removeChild(element);
+  });
+
+  it('detaches listeners when the element is unmounted', () => {
+    const element = document.createElement('div');
+    document.body.appendChild(element);
+    const onSwipe = jest.fn();
+    const { result } = renderHook(() => useConsoleSwipeNavigation(onSwipe));
+    result.current(element);
+    result.current(null);
+    swipe(
+      element,
+      { clientX: 200, clientY: 100 },
+      { clientX: 60, clientY: 110 },
+    );
+    expect(onSwipe).not.toHaveBeenCalled();
+    document.body.removeChild(element);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/hooks/useConsoleSwipeNavigation.ts

@@ -0,0 +1,115 @@
+import { useCallback, useEffect, useRef } from 'react';
+import {
+  type ConsoleSwipeDirection,
+  isVerticallyDominant,
+  resolveSwipeDirection,
+} from '../logic/swipe';
+
+const isHorizontallyScrollable = (start: EventTarget | null): boolean => {
+  let node = start instanceof Element ? start : null;
+  while (node !== null && node !== document.body) {
+    const style = window.getComputedStyle(node);
+    const overflowX = style.overflowX;
+    if (
+      (overflowX === 'auto' || overflowX === 'scroll') &&
+      node.scrollWidth > node.clientWidth
+    ) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+};
+
+export const useConsoleSwipeNavigation = (
+  onSwipe: (direction: ConsoleSwipeDirection) => void,
+): ((element: HTMLElement | null) => void) => {
+  const onSwipeRef = useRef(onSwipe);
+  onSwipeRef.current = onSwipe;
+
+  const detachRef = useRef<(() => void) | null>(null);
+
+  const attach = useCallback((element: HTMLElement): (() => void) => {
+    let startX = 0;
+    let startY = 0;
+    let tracking = false;
+
+    const onTouchStart = (event: TouchEvent): void => {
+      if (event.touches.length !== 1) {
+        tracking = false;
+        return;
+      }
+      if (isHorizontallyScrollable(event.target)) {
+        tracking = false;
+        return;
+      }
+      const touch = event.touches[0];
+      startX = touch.clientX;
+      startY = touch.clientY;
+      tracking = true;
+    };
+
+    const onTouchMove = (event: TouchEvent): void => {
+      if (!tracking) {
+        return;
+      }
+      const touch = event.touches[0];
+      if (
+        isVerticallyDominant(touch.clientX - startX, touch.clientY - startY)
+      ) {
+        tracking = false;
+      }
+    };
+
+    const onTouchEnd = (event: TouchEvent): void => {
+      if (!tracking) {
+        return;
+      }
+      tracking = false;
+      if (event.changedTouches.length !== 1) {
+        return;
+      }
+      const touch = event.changedTouches[0];
+      const direction = resolveSwipeDirection(
+        touch.clientX - startX,
+        touch.clientY - startY,
+      );
+      if (direction !== null) {
+        onSwipeRef.current(direction);
+      }
+    };
+
+    element.addEventListener('touchstart', onTouchStart, { passive: true });
+    element.addEventListener('touchmove', onTouchMove, { passive: true });
+    element.addEventListener('touchend', onTouchEnd, { passive: true });
+    return () => {
+      element.removeEventListener('touchstart', onTouchStart);
+      element.removeEventListener('touchmove', onTouchMove);
+      element.removeEventListener('touchend', onTouchEnd);
+    };
+  }, []);
+
+  const swipeRef = useCallback(
+    (element: HTMLElement | null): void => {
+      if (detachRef.current !== null) {
+        detachRef.current();
+        detachRef.current = null;
+      }
+      if (element !== null) {
+        detachRef.current = attach(element);
+      }
+    },
+    [attach],
+  );
+
+  useEffect(() => {
+    return () => {
+      if (detachRef.current !== null) {
+        detachRef.current();
+        detachRef.current = null;
+      }
+    };
+  }, []);
+
+  return swipeRef;
+};

package/src/adapter/entry-points/console/ui/src/features/console/logic/actionToast.test.ts

@@ -0,0 +1,153 @@
+import { consoleListItemsFixture } from '../testing/fixtures';
+import {
+  ACTION_TOAST_DELAY_MS,
+  actionAdvances,
+  actionToastColor,
+  actionToastMessage,
+  type ConsoleActionKind,
+  formatActionToast,
+  itemToastLabel,
+} from './actionToast';
+
+const prItem = consoleListItemsFixture[0];
+const issueItem = consoleListItemsFixture[2];
+
+describe('ACTION_TOAST_DELAY_MS', () => {
+  it('is the five second cancellable window', () => {
+    expect(ACTION_TOAST_DELAY_MS).toBe(5000);
+  });
+});
+
+describe('itemToastLabel', () => {
+  it('prefixes pull requests with PR #', () => {
+    expect(itemToastLabel(prItem)).toBe(`PR #${prItem.number}`);
+  });
+
+  it('prefixes issues with #', () => {
+    expect(itemToastLabel(issueItem)).toBe(`#${issueItem.number}`);
+  });
+});
+
+describe('actionToastMessage', () => {
+  it('labels review actions', () => {
+    expect(
+      actionToastMessage({ type: 'review', action: 'approve' }, 'prs'),
+    ).toBe('Approved');
+    expect(
+      actionToastMessage({ type: 'review', action: 'request_changes' }, 'prs'),
+    ).toBe('Rejected');
+    expect(
+      actionToastMessage({ type: 'review', action: 'totally_wrong' }, 'prs'),
+    ).toBe('Marked totally wrong');
+    expect(
+      actionToastMessage({ type: 'review', action: 'unnecessary' }, 'prs'),
+    ).toBe('Marked unnecessary');
+  });
+
+  it('labels the +1 week snooze differently on the todo-by-human tab', () => {
+    const kind: ConsoleActionKind = {
+      type: 'next_action_date',
+      action: 'snooze_1week',
+    };
+    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Date +1 week');
+    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
+      'Next Action Date +1 week and skip',
+    );
+  });
+
+  it('labels the +1 day snooze the same on every tab', () => {
+    const kind: ConsoleActionKind = {
+      type: 'next_action_date',
+      action: 'snooze_1day',
+    };
+    expect(actionToastMessage(kind, 'prs')).toBe('Next Action Date +1 day');
+    expect(actionToastMessage(kind, 'todo-by-human')).toBe(
+      'Next Action Date +1 day',
+    );
+  });
+
+  it('labels close actions', () => {
+    expect(actionToastMessage({ type: 'close', action: 'close' }, 'prs')).toBe(
+      'Closed',
+    );
+    expect(
+      actionToastMessage({ type: 'close', action: 'close_not_planned' }, 'prs'),
+    ).toBe('Closed as not planned');
+  });
+
+  it('labels the in-tmux-by-human action', () => {
+    expect(
+      actionToastMessage(
+        { type: 'set_in_tmux_by_human', optionName: 'In Tmux by human' },
+        'prs',
+      ),
+    ).toBe('Added to In Tmux by human');
+  });
+
+  it('labels field updates with the chosen option name', () => {
+    expect(
+      actionToastMessage(
+        { type: 'set_status', optionName: 'Awaiting Workspace' },
+        'prs',
+      ),
+    ).toBe('Status → Awaiting Workspace');
+    expect(
+      actionToastMessage(
+        { type: 'set_story', optionName: 'Move to Okinawa' },
+        'triage',
+      ),
+    ).toBe('Story → Move to Okinawa');
+  });
+});
+
+describe('actionToastColor', () => {
+  it('colors each action group like the reference', () => {
+    expect(actionToastColor({ type: 'review', action: 'approve' })).toBe(
+      'green',
+    );
+    expect(
+      actionToastColor({ type: 'review', action: 'request_changes' }),
+    ).toBe('amber');
+    expect(actionToastColor({ type: 'review', action: 'totally_wrong' })).toBe(
+      'red',
+    );
+    expect(actionToastColor({ type: 'review', action: 'unnecessary' })).toBe(
+      'gray',
+    );
+    expect(
+      actionToastColor({ type: 'set_status', optionName: 'Todo by human' }),
+    ).toBe('blue');
+    expect(
+      actionToastColor({ type: 'next_action_date', action: 'snooze_1day' }),
+    ).toBe('amber');
+    expect(actionToastColor({ type: 'close', action: 'close' })).toBe('red');
+  });
+});
+
+describe('actionAdvances', () => {
+  it('advances every non-snooze action in every tab', () => {
+    expect(actionAdvances({ type: 'review', action: 'approve' }, 'prs')).toBe(
+      true,
+    );
+    expect(actionAdvances({ type: 'set_status', optionName: 'x' }, 'prs')).toBe(
+      true,
+    );
+  });
+
+  it('does not advance a snooze except on the todo-by-human tab', () => {
+    const kind: ConsoleActionKind = {
+      type: 'next_action_date',
+      action: 'snooze_1week',
+    };
+    expect(actionAdvances(kind, 'prs')).toBe(false);
+    expect(actionAdvances(kind, 'todo-by-human')).toBe(true);
+  });
+});
+
+describe('formatActionToast', () => {
+  it('combines the message and the item label', () => {
+    expect(
+      formatActionToast({ type: 'review', action: 'approve' }, prItem, 'prs'),
+    ).toBe(`Approved — PR #${prItem.number}`);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/logic/actionToast.ts

@@ -0,0 +1,103 @@
+import type {
+  ConsoleCloseAction,
+  ConsoleNextActionDateAction,
+  ConsoleReviewAction,
+} from './operations';
+import type { ConsoleListItem, ConsoleTabName } from './types';
+
+export type ConsoleToastColor =
+  | 'green'
+  | 'amber'
+  | 'red'
+  | 'gray'
+  | 'blue'
+  | 'error';
+
+export type ConsoleActionKind =
+  | { type: 'review'; action: ConsoleReviewAction }
+  | { type: 'next_action_date'; action: ConsoleNextActionDateAction }
+  | { type: 'set_story'; optionName: string }
+  | { type: 'set_status'; optionName: string }
+  | { type: 'set_in_tmux_by_human'; optionName: string }
+  | { type: 'close'; action: ConsoleCloseAction };
+
+export const ACTION_TOAST_DELAY_MS = 5000;
+
+export const itemToastLabel = (item: ConsoleListItem): string =>
+  `${item.isPr ? 'PR #' : '#'}${item.number}`;
+
+export const actionToastMessage = (
+  kind: ConsoleActionKind,
+  tab: ConsoleTabName,
+): string => {
+  switch (kind.type) {
+    case 'review':
+      if (kind.action === 'approve') {
+        return 'Approved';
+      }
+      if (kind.action === 'request_changes') {
+        return 'Rejected';
+      }
+      if (kind.action === 'totally_wrong') {
+        return 'Marked totally wrong';
+      }
+      return 'Marked unnecessary';
+    case 'next_action_date':
+      if (kind.action === 'snooze_1day') {
+        return 'Next Action Date +1 day';
+      }
+      return tab === 'todo-by-human'
+        ? 'Next Action Date +1 week and skip'
+        : 'Next Action Date +1 week';
+    case 'set_story':
+      return `Story → ${kind.optionName}`;
+    case 'set_status':
+      return `Status → ${kind.optionName}`;
+    case 'set_in_tmux_by_human':
+      return 'Added to In Tmux by human';
+    case 'close':
+      return kind.action === 'close' ? 'Closed' : 'Closed as not planned';
+  }
+};
+
+export const actionToastColor = (
+  kind: ConsoleActionKind,
+): ConsoleToastColor => {
+  switch (kind.type) {
+    case 'review':
+      if (kind.action === 'approve') {
+        return 'green';
+      }
+      if (kind.action === 'request_changes') {
+        return 'amber';
+      }
+      if (kind.action === 'totally_wrong') {
+        return 'red';
+      }
+      return 'gray';
+    case 'next_action_date':
+      return 'amber';
+    case 'set_story':
+    case 'set_status':
+    case 'set_in_tmux_by_human':
+      return 'blue';
+    case 'close':
+      return 'red';
+  }
+};
+
+export const actionAdvances = (
+  kind: ConsoleActionKind,
+  tab: ConsoleTabName,
+): boolean => {
+  if (kind.type === 'next_action_date') {
+    return tab === 'todo-by-human';
+  }
+  return true;
+};
+
+export const formatActionToast = (
+  kind: ConsoleActionKind,
+  item: ConsoleListItem,
+  tab: ConsoleTabName,
+): string => `${actionToastMessage(kind, tab)} — ${itemToastLabel(item)}`;

package/src/adapter/entry-points/console/ui/src/features/console/logic/diff.test.ts

@@ -0,0 +1,81 @@
+import { parseUnifiedDiff } from './diff';
+
+describe('parseUnifiedDiff', () => {
+  it('marks a hunk header with no line numbers', () => {
+    const rows = parseUnifiedDiff('@@ -54,7 +54,12 @@ jobs:');
+    expect(rows).toEqual([
+      {
+        kind: 'hunk',
+        oldLineNumber: null,
+        newLineNumber: null,
+        content: '@@ -54,7 +54,12 @@ jobs:',
+      },
+    ]);
+  });
+
+  it('numbers context lines on both sides starting from the hunk header', () => {
+    const rows = parseUnifiedDiff(
+      ['@@ -10,2 +20,2 @@', ' context one', ' context two'].join('\n'),
+    );
+    expect(rows[1]).toEqual({
+      kind: 'ctx',
+      oldLineNumber: 10,
+      newLineNumber: 20,
+      content: ' context one',
+    });
+    expect(rows[2]).toEqual({
+      kind: 'ctx',
+      oldLineNumber: 11,
+      newLineNumber: 21,
+      content: ' context two',
+    });
+  });
+
+  it('numbers added lines only on the new side', () => {
+    const rows = parseUnifiedDiff(
+      ['@@ -1,1 +1,2 @@', ' kept', '+added line'].join('\n'),
+    );
+    expect(rows[2]).toEqual({
+      kind: 'add',
+      oldLineNumber: null,
+      newLineNumber: 2,
+      content: '+added line',
+    });
+  });
+
+  it('numbers removed lines only on the old side', () => {
+    const rows = parseUnifiedDiff(
+      ['@@ -1,2 +1,1 @@', ' kept', '-removed line'].join('\n'),
+    );
+    expect(rows[2]).toEqual({
+      kind: 'del',
+      oldLineNumber: 2,
+      newLineNumber: null,
+      content: '-removed line',
+    });
+  });
+
+  it('keeps the old and new counters independent across a mixed hunk', () => {
+    const rows = parseUnifiedDiff(
+      [
+        '@@ -54,7 +54,12 @@ jobs:',
+        ' loose-matching: true',
+        '-          npm install',
+        '+          npm ci',
+        '+          npm run build',
+        ' after',
+      ].join('\n'),
+    );
+    expect(rows.map((row) => row.kind)).toEqual([
+      'hunk',
+      'ctx',
+      'del',
+      'add',
+      'add',
+      'ctx',
+    ]);
+    const lastContext = rows[5];
+    expect(lastContext.oldLineNumber).toBe(56);
+    expect(lastContext.newLineNumber).toBe(57);
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/logic/diff.ts

@@ -0,0 +1,61 @@
+export type ConsoleDiffLineKind = 'hunk' | 'add' | 'del' | 'ctx';
+
+export type ConsoleDiffLine = {
+  kind: ConsoleDiffLineKind;
+  oldLineNumber: number | null;
+  newLineNumber: number | null;
+  content: string;
+};
+
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/;
+
+export const parseUnifiedDiff = (patch: string): ConsoleDiffLine[] => {
+  const rows: ConsoleDiffLine[] = [];
+  let oldLineNumber = 0;
+  let newLineNumber = 0;
+  for (const line of patch.split('\n')) {
+    if (line.startsWith('@@')) {
+      const match = line.match(HUNK_HEADER);
+      if (match !== null) {
+        oldLineNumber = Number(match[1]);
+        newLineNumber = Number(match[2]);
+      }
+      rows.push({
+        kind: 'hunk',
+        oldLineNumber: null,
+        newLineNumber: null,
+        content: line,
+      });
+      continue;
+    }
+    if (line.startsWith('+')) {
+      rows.push({
+        kind: 'add',
+        oldLineNumber: null,
+        newLineNumber: newLineNumber,
+        content: line,
+      });
+      newLineNumber += 1;
+      continue;
+    }
+    if (line.startsWith('-')) {
+      rows.push({
+        kind: 'del',
+        oldLineNumber: oldLineNumber,
+        newLineNumber: null,
+        content: line,
+      });
+      oldLineNumber += 1;
+      continue;
+    }
+    rows.push({
+      kind: 'ctx',
+      oldLineNumber: oldLineNumber,
+      newLineNumber: newLineNumber,
+      content: line,
+    });
+    oldLineNumber += 1;
+    newLineNumber += 1;
+  }
+  return rows;
+};

package/src/adapter/entry-points/console/ui/src/features/console/logic/navigation.test.ts

@@ -0,0 +1,53 @@
+import {
+  nextPendingKeyAfter,
+  nextPendingKeyBrowse,
+  previousPendingKeyBefore,
+} from './navigation';
+
+const keys = ['a', 'b', 'c', 'd'];
+
+describe('nextPendingKeyAfter', () => {
+  it('returns the key immediately after the acted key', () => {
+    expect(nextPendingKeyAfter(keys, 'b')).toBe('c');
+  });
+
+  it('returns null when the acted key is last so the caller returns to the list', () => {
+    expect(nextPendingKeyAfter(keys, 'd')).toBeNull();
+  });
+
+  it('falls back to the first key when the acted key is absent', () => {
+    expect(nextPendingKeyAfter(keys, 'missing')).toBe('a');
+  });
+
+  it('returns null for an empty list', () => {
+    expect(nextPendingKeyAfter([], 'a')).toBeNull();
+  });
+});
+
+describe('nextPendingKeyBrowse', () => {
+  it('returns the next key in display order', () => {
+    expect(nextPendingKeyBrowse(keys, 'a')).toBe('b');
+  });
+
+  it('returns null at the end of the list', () => {
+    expect(nextPendingKeyBrowse(keys, 'd')).toBeNull();
+  });
+
+  it('returns null when the current key is absent', () => {
+    expect(nextPendingKeyBrowse(keys, 'missing')).toBeNull();
+  });
+});
+
+describe('previousPendingKeyBefore', () => {
+  it('returns the previous key in display order', () => {
+    expect(previousPendingKeyBefore(keys, 'c')).toBe('b');
+  });
+
+  it('returns null at the start of the list', () => {
+    expect(previousPendingKeyBefore(keys, 'a')).toBeNull();
+  });
+
+  it('returns null when the current key is absent', () => {
+    expect(previousPendingKeyBefore(keys, 'missing')).toBeNull();
+  });
+});