github-issue-tower-defence-management 1.146.10 → 1.146.12

package/bin/adapter/entry-points/console/ui-dist/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>TDPM Console</title>
-    <script type="module" crossorigin src="/assets/index-CPY6wV8C.js"></script>
+    <script type="module" crossorigin src="/assets/index-DcDM50gs.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CKX2ny-z.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "github-issue-tower-defence-management",
-  "version": "1.146.10",
+  "version": "1.146.12",
   "description": "",
   "main": "bin/index.js",
   "scripts": {

package/src/adapter/entry-points/console/consoleOperationApi.test.ts

@@ -229,6 +229,92 @@ describe('consoleOperationApi', () => {
       expectRecordedAcrossTabs('PVTI_c');
     });
 
+    it('marks a pull request unnecessary by closing it, labelling the item chore and moving it to Awaiting workspace', async () => {
+      issueRepository.getIssueByUrl.mockResolvedValue({
+        ...issue,
+        url: 'https://github.com/o/r/issues/7',
+        org: 'o',
+        repo: 'r',
+        number: 7,
+        labels: ['bug'],
+      });
+      const response = await handleReview(context, {
+        pjcode: 'acme',
+        action: 'unnecessary',
+        prUrl: 'https://github.com/o/r/pull/1',
+        issueUrl: 'https://github.com/o/r/issues/7',
+        projectItemId: 'PVTI_unnecessary',
+        commentBody: 'This pull request is unnecessary.',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.closePullRequest).toHaveBeenCalledWith(
+        'https://github.com/o/r/pull/1',
+      );
+      expect(issueRepository.createCommentByUrl).toHaveBeenCalledWith(
+        'https://github.com/o/r/pull/1',
+        'This pull request is unnecessary.',
+      );
+      expect(issueRepository.updateLabels).toHaveBeenCalledWith(
+        expect.objectContaining({ url: 'https://github.com/o/r/issues/7' }),
+        ['bug', 'chore'],
+      );
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({ itemId: 'PVTI_unnecessary' }),
+        'status_aw',
+      );
+      expectRecordedAcrossTabs('PVTI_unnecessary');
+    });
+
+    it('keeps the chore label once when the unnecessary item already carries it', async () => {
+      issueRepository.getIssueByUrl.mockResolvedValue({
+        ...issue,
+        url: 'https://github.com/o/r/issues/8',
+        org: 'o',
+        repo: 'r',
+        number: 8,
+        labels: ['chore'],
+      });
+      const response = await handleReview(context, {
+        pjcode: 'acme',
+        action: 'unnecessary',
+        prUrl: 'https://github.com/o/r/pull/2',
+        issueUrl: 'https://github.com/o/r/issues/8',
+        projectItemId: 'PVTI_unnecessary_dup',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.updateLabels).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({ itemId: 'PVTI_unnecessary_dup' }),
+        'status_aw',
+      );
+    });
+
+    it('rejects an unnecessary action without an issueUrl', async () => {
+      const response = await handleReview(context, {
+        pjcode: 'acme',
+        action: 'unnecessary',
+        prUrl: 'https://github.com/o/r/pull/1',
+        projectItemId: 'PVTI_unnecessary_missing',
+      });
+      expect(response.statusCode).toBe(400);
+      expect(issueRepository.closePullRequest).not.toHaveBeenCalled();
+    });
+
+    it('leaves labels and status untouched for the plain close action', async () => {
+      const response = await handleReview(context, {
+        pjcode: 'acme',
+        action: 'close',
+        prUrl: 'https://github.com/o/r/pull/1',
+        projectItemId: 'PVTI_plain_close',
+        commentBody: 'closing',
+      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.updateLabels).not.toHaveBeenCalled();
+      expect(issueRepository.updateStatus).not.toHaveBeenCalled();
+    });
+
     it('rejects an unknown review action', async () => {
       const response = await handleReview(context, {
         pjcode: 'acme',

package/src/adapter/entry-points/console/consoleOperationApi.ts

@@ -10,6 +10,7 @@ import { findConsoleItemUrl } from './consoleItemUrlLookup';
 
 export const AWAITING_WORKSPACE_STATUS_NAME = 'awaiting workspace';
 export const IN_TMUX_BY_HUMAN_STATUS_NAME = 'in tmux by human';
+export const CHORE_LABEL_NAME = 'chore';
 
 export type ConsoleProjectBinding = {
   pjcode: string;
@@ -192,6 +193,24 @@ const updateStatusByName = async (
   return null;
 };
 
+const addChoreLabel = async (
+  issueRepository: IssueRepository,
+  issueUrl: string,
+): Promise<ConsoleOperationResponse | null> => {
+  const issue = await issueRepository.getIssueByUrl(issueUrl);
+  if (issue === null) {
+    return badGateway(`issue "${issueUrl}" could not be loaded`);
+  }
+  if (issue.labels.includes(CHORE_LABEL_NAME)) {
+    return null;
+  }
+  await issueRepository.updateLabels(issue, [
+    ...issue.labels,
+    CHORE_LABEL_NAME,
+  ]);
+  return null;
+};
+
 export const handleReview = async (
   context: ConsoleOperationContext,
   body: Record<string, unknown>,
@@ -230,6 +249,38 @@ export const handleReview = async (
   }
   const { project, pjcode } = binding;
 
+  if (action === 'unnecessary') {
+    const issueUrl = body.issueUrl;
+    if (!isNonEmptyString(issueUrl)) {
+      return badRequest('issueUrl is required for unnecessary');
+    }
+    await context.resolveIssueRepository(prUrl).closePullRequest(prUrl);
+    if (isNonEmptyString(body.commentBody)) {
+      await context
+        .resolveIssueRepository(prUrl)
+        .createCommentByUrl(prUrl, body.commentBody);
+    }
+    const labelFailure = await addChoreLabel(
+      context.resolveIssueRepository(issueUrl),
+      issueUrl,
+    );
+    if (labelFailure !== null) {
+      return labelFailure;
+    }
+    const failure = await updateStatusByName(
+      context.resolveIssueRepository(issueUrl),
+      project,
+      issueUrl,
+      projectItemId,
+      AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (failure !== null) {
+      return failure;
+    }
+    recordDone(context, pjcode, projectItemId);
+    return ok();
+  }
+
   if (action === 'approve') {
     await context.resolveIssueRepository(prUrl).approvePullRequest(prUrl);
     const failure = await updateStatusByName(

package/src/adapter/entry-points/console/ui/e2e/consoleScenario.spec.ts

@@ -82,39 +82,39 @@ test('processing tabs drives auto-advance and keeps emptied badges at zero', asy
   await expect(approveButton).toBeVisible();
   await approveButton.click();
 
-  await expect(activeTabLabel(page)).toHaveText('Triage', { timeout: 8000 });
+  await expect(activeTabLabel(page)).toHaveText('Unread', { timeout: 8000 });
   await expect(tabByLabel(page, 'Awaiting Quality Check')).toHaveCount(0, {
     timeout: 8000,
   });
 
   await itemRowByText(
     page,
-    'Add Sonnet to Opus weekly-limit fallback routing per token',
+    'Scaffold React console UI under entry-points with build bundling',
   ).click();
   await processSelectedItemViaStatus(page);
-  await expect(tabBadge(page, 'Triage')).toHaveText('1', { timeout: 8000 });
-  await tabByLabel(page, 'Triage').click();
+  await expect(tabBadge(page, 'Unread')).toHaveText('1', { timeout: 8000 });
+  await tabByLabel(page, 'Unread').click();
 
   await itemRowByText(
     page,
-    'Publish the generated documentation site to GitHub Pages',
+    'Add server-side console API handlers for read and operation endpoints',
   ).click();
   await processSelectedItemViaStatus(page);
 
-  await expect(activeTabLabel(page)).toHaveText('Unread', { timeout: 8000 });
-  await expect(tabByLabel(page, 'Triage')).toHaveCount(0, {
+  await expect(activeTabLabel(page)).toHaveText('Triage', { timeout: 8000 });
+  await expect(tabByLabel(page, 'Unread')).toHaveCount(0, {
     timeout: 8000,
   });
 
   await tabByLabel(page, 'Todo by human').click();
   await expect(activeTabLabel(page)).toHaveText('Todo by human');
-  await expect(tabByLabel(page, 'Triage')).toHaveCount(0);
+  await expect(tabByLabel(page, 'Unread')).toHaveCount(0);
   await expect(tabBadge(page, 'Todo by human')).toHaveText('1');
 
-  await tabByLabel(page, 'Unread').click();
-  await expect(activeTabLabel(page)).toHaveText('Unread');
-  await expect(tabByLabel(page, 'Triage')).toHaveCount(0);
-  await expect(tabBadge(page, 'Unread')).toHaveText('2');
+  await tabByLabel(page, 'Triage').click();
+  await expect(activeTabLabel(page)).toHaveText('Triage');
+  await expect(tabByLabel(page, 'Unread')).toHaveCount(0);
+  await expect(tabBadge(page, 'Triage')).toHaveText('2');
 });
 
 test('renders the Workflow Blocker tab leftmost and shows its detail operations', async ({

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

@@ -72,7 +72,7 @@ describe('useConsoleOperations', () => {
     });
   });
 
-  it('posts an unnecessary review as a close with the unnecessary comment body', async () => {
+  it('posts an unnecessary review carrying the item url so the server can label it chore', async () => {
     const fetchMock = captureFetch();
     const { result } = setup();
     await act(async () => {
@@ -83,7 +83,8 @@ describe('useConsoleOperations', () => {
       );
     });
     expect(lastBody(fetchMock)).toMatchObject({
-      action: 'close',
+      action: 'unnecessary',
+      issueUrl: prItem.url,
       commentBody: 'This pull request is unnecessary.',
     });
   });

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

@@ -114,9 +114,10 @@ const reviewRequest = (
   }
   return {
     pjcode,
-    action: 'close',
+    action: 'unnecessary',
     prUrl,
     projectItemId: item.projectItemId,
+    issueUrl: item.url,
     commentBody: UNNECESSARY_COMMENT_BODY,
   };
 };

package/src/adapter/entry-points/console/ui/src/features/console/lib/consoleApi.ts

@@ -23,6 +23,7 @@ export type ConsoleReviewRequest = {
   action: string;
   prUrl: string;
   projectItemId: string;
+  issueUrl?: string;
   commentBody?: string;
   changedFilePath?: string;
   line?: number;

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

@@ -2,7 +2,7 @@ import {
   findNextNonEmptyTabToRight,
   resolveDefaultActiveTab,
 } from './tabAdvance';
-import type { ConsoleTabName } from './types';
+import { CONSOLE_TABS, type ConsoleTabName } from './types';
 
 const counts = (
   overrides: Partial<Record<ConsoleTabName, number>>,
@@ -17,6 +17,13 @@ const counts = (
   ...overrides,
 });
 
+describe('CONSOLE_TABS ordering', () => {
+  it('places Unread before Triage so unseen items are worked first', () => {
+    const names = CONSOLE_TABS.map((tab) => tab.name);
+    expect(names.indexOf('unread')).toBeLessThan(names.indexOf('triage'));
+  });
+});
+
 describe('findNextNonEmptyTabToRight', () => {
   it('returns the first non-empty tab to the right of the active tab', () => {
     expect(findNextNonEmptyTabToRight('prs', counts({ unread: 7 }))).toBe(
@@ -45,7 +52,7 @@ describe('findNextNonEmptyTabToRight', () => {
   it('returns the immediately adjacent tab when it is non-empty', () => {
     expect(
       findNextNonEmptyTabToRight('prs', counts({ triage: 12, unread: 7 })),
-    ).toBe('triage');
+    ).toBe('unread');
   });
 
   it('returns null when no tab to the right has any items', () => {

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

@@ -157,8 +157,8 @@ export type ConsoleTab = {
 export const CONSOLE_TABS: ConsoleTab[] = [
   { name: 'workflow-blocker', label: 'Workflow Blocker' },
   { name: 'prs', label: 'Awaiting Quality Check' },
-  { name: 'triage', label: 'Triage' },
   { name: 'unread', label: 'Unread' },
+  { name: 'triage', label: 'Triage' },
   { name: 'failed-preparation', label: 'Failed Preparation' },
   { name: 'todo-by-human', label: 'Todo by human' },
   { name: 'todo-by-agent', label: 'Todo by agent' },