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

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();
+  });
+});

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

@@ -0,0 +1,33 @@
+export const nextPendingKeyAfter = (
+  orderedKeys: string[],
+  actedKey: string,
+): string | null => {
+  const actedIndex = orderedKeys.indexOf(actedKey);
+  if (actedIndex < 0) {
+    return orderedKeys.length > 0 ? orderedKeys[0] : null;
+  }
+  const nextIndex = actedIndex + 1;
+  return nextIndex < orderedKeys.length ? orderedKeys[nextIndex] : null;
+};
+
+export const nextPendingKeyBrowse = (
+  orderedKeys: string[],
+  currentKey: string,
+): string | null => {
+  const index = orderedKeys.indexOf(currentKey);
+  if (index < 0 || index >= orderedKeys.length - 1) {
+    return null;
+  }
+  return orderedKeys[index + 1];
+};
+
+export const previousPendingKeyBefore = (
+  orderedKeys: string[],
+  currentKey: string,
+): string | null => {
+  const index = orderedKeys.indexOf(currentKey);
+  if (index <= 0) {
+    return null;
+  }
+  return orderedKeys[index - 1];
+};

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

@@ -0,0 +1,34 @@
+import {
+  isVerticallyDominant,
+  resolveSwipeDirection,
+  SWIPE_MIN_DISTANCE,
+} from './swipe';
+
+describe('resolveSwipeDirection', () => {
+  it('reports next for a dominant left swipe', () => {
+    expect(resolveSwipeDirection(-120, 10)).toBe('next');
+  });
+
+  it('reports previous for a dominant right swipe', () => {
+    expect(resolveSwipeDirection(120, 10)).toBe('previous');
+  });
+
+  it('ignores a gesture shorter than the minimum distance', () => {
+    expect(resolveSwipeDirection(-(SWIPE_MIN_DISTANCE - 1), 0)).toBeNull();
+  });
+
+  it('ignores a gesture that is not horizontally dominant', () => {
+    expect(resolveSwipeDirection(-80, 70)).toBeNull();
+  });
+});
+
+describe('isVerticallyDominant', () => {
+  it('is true for a clearly vertical drag', () => {
+    expect(isVerticallyDominant(10, 80)).toBe(true);
+  });
+
+  it('is false for a small or horizontal drag', () => {
+    expect(isVerticallyDominant(80, 10)).toBe(false);
+    expect(isVerticallyDominant(5, 15)).toBe(false);
+  });
+});

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

@@ -0,0 +1,28 @@
+export type ConsoleSwipeDirection = 'next' | 'previous' | null;
+
+export const SWIPE_MIN_DISTANCE = 60;
+export const SWIPE_HORIZONTAL_DOMINANCE = 1.5;
+
+export const resolveSwipeDirection = (
+  deltaX: number,
+  deltaY: number,
+): ConsoleSwipeDirection => {
+  const absDeltaX = Math.abs(deltaX);
+  const absDeltaY = Math.abs(deltaY);
+  if (absDeltaX < SWIPE_MIN_DISTANCE) {
+    return null;
+  }
+  if (absDeltaX <= absDeltaY * SWIPE_HORIZONTAL_DOMINANCE) {
+    return null;
+  }
+  return deltaX < 0 ? 'next' : 'previous';
+};
+
+export const isVerticallyDominant = (
+  deltaX: number,
+  deltaY: number,
+): boolean => {
+  const absDeltaX = Math.abs(deltaX);
+  const absDeltaY = Math.abs(deltaY);
+  return absDeltaY > absDeltaX * SWIPE_HORIZONTAL_DOMINANCE && absDeltaY > 20;
+};

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsoleItemDetailContainer.test.tsx

@@ -55,8 +55,9 @@ const buildOperations = (): ConsoleOperationsApi => ({
 });
 
 describe('ConsoleItemDetailContainer', () => {
-  it('wires the review action to the operations api for a PR item', async () => {
+  it('queues the review action and commits it through the operations api for a PR item', async () => {
     const operations = buildOperations();
+    const onQueueAction = jest.fn();
     const { getByText } = render(
       <ConsoleItemDetailContainer
         tab="prs"
@@ -69,12 +70,19 @@ describe('ConsoleItemDetailContainer', () => {
         storyName="TDPM Console port"
         overlayStatus={null}
         now={Date.parse('2026-06-19T12:00:00.000Z')}
+        onQueueAction={onQueueAction}
       />,
     );
     await waitFor(() => {
       expect(getByText('Approve')).toBeInTheDocument();
     });
     fireEvent.click(getByText('Approve'));
+    expect(onQueueAction).toHaveBeenCalledTimes(1);
+    const input = onQueueAction.mock.calls[0][0];
+    expect(input.kind).toEqual({ type: 'review', action: 'approve' });
+    expect(input.item).toBe(prItem);
+    expect(operations.reviewPullRequest).not.toHaveBeenCalled();
+    input.commit();
     expect(operations.reviewPullRequest).toHaveBeenCalledWith(
       prItem,
       prItem.url,

package/src/adapter/entry-points/console/ui/src/features/console/pages/ConsoleItemDetailContainer.tsx

@@ -4,6 +4,7 @@ import { ConsoleOperationMenu } from '../components/operations/ConsoleOperationM
 import type { ConsoleCaches } from '../hooks/useConsoleCaches';
 import { useConsoleItemDetailData } from '../hooks/useConsoleItemDetailData';
 import type { ConsoleOperationsApi } from '../hooks/useConsoleOperations';
+import type { ConsoleActionKind } from '../logic/actionToast';
 import { resolveStoryColorEnum } from '../logic/grouping';
 import type { ConsoleOperationHandlers } from '../logic/operations';
 import type {
@@ -15,6 +16,12 @@ import type {
   ConsoleTabName,
 } from '../logic/types';
 
+export type ConsoleQueueActionInput = {
+  kind: ConsoleActionKind;
+  item: ConsoleListItem;
+  commit: () => void;
+};
+
 export type ConsoleItemDetailContainerProps = {
   tab: ConsoleTabName;
   item: ConsoleListItem;
@@ -26,6 +33,7 @@ export type ConsoleItemDetailContainerProps = {
   storyName: string | null;
   overlayStatus: ConsoleOverlayStatus | null;
   now: number;
+  onQueueAction: (input: ConsoleQueueActionInput) => void;
 };
 
 export const ConsoleItemDetailContainer = ({
@@ -39,6 +47,7 @@ export const ConsoleItemDetailContainer = ({
   storyName,
   overlayStatus,
   now,
+  onQueueAction,
 }: ConsoleItemDetailContainerProps) => {
   const detail = useConsoleItemDetailData(caches, item);
   const hasPullRequest = item.isPr || detail.relatedPullRequests.length > 0;
@@ -48,22 +57,58 @@ export const ConsoleItemDetailContainer = ({
       const prUrl = item.isPr
         ? item.url
         : (detail.relatedPullRequests[0]?.pullRequest.url ?? item.url);
-      void operations.reviewPullRequest(item, prUrl, action);
+      onQueueAction({
+        kind: { type: 'review', action },
+        item,
+        commit: () => {
+          void operations.reviewPullRequest(item, prUrl, action);
+        },
+      });
     },
     onSetNextActionDate: (action) => {
-      void operations.setNextActionDate(item, action);
+      onQueueAction({
+        kind: { type: 'next_action_date', action },
+        item,
+        commit: () => {
+          void operations.setNextActionDate(item, action);
+        },
+      });
     },
     onSetStory: (option: ConsoleFieldOption) => {
-      void operations.setStory(item, option);
+      onQueueAction({
+        kind: { type: 'set_story', optionName: option.name },
+        item,
+        commit: () => {
+          void operations.setStory(item, option);
+        },
+      });
     },
     onSetStatus: (option: ConsoleFieldOption) => {
-      void operations.setStatus(item, option);
+      onQueueAction({
+        kind: { type: 'set_status', optionName: option.name },
+        item,
+        commit: () => {
+          void operations.setStatus(item, option);
+        },
+      });
     },
     onSetInTmuxByHuman: (option: ConsoleFieldOption) => {
-      void operations.setInTmuxByHuman(item, option);
+      onQueueAction({
+        kind: { type: 'set_in_tmux_by_human', optionName: option.name },
+        item,
+        commit: () => {
+          void operations.setInTmuxByHuman(item, option);
+        },
+      });
     },
     onClose: (action) => {
-      void operations.closeIssue(item, action);
+      onQueueAction({
+        kind: { type: 'close', action },
+        item,
+        commit: () => {
+          void operations.closeIssue(item, action);
+        },
+      });
     },
   };