github-issue-tower-defence-management 1.156.3 → 1.157.0

package/src/adapter/entry-points/handlers/FileSystemConsoleTabsRepository.test.ts

@@ -0,0 +1,217 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { FileSystemConsoleTabsRepository } from './FileSystemConsoleTabsRepository';
+import { readDoneProjectItemIds } from '../console/consoleDoneStore';
+import type { ConsoleListItem } from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
+
+const makeItem = (
+  overrides: Partial<ConsoleListItem> = {},
+): ConsoleListItem => ({
+  number: 1,
+  title: 'Test Issue',
+  url: 'https://github.com/user/repo/issues/1',
+  repo: 'user/repo',
+  nameWithOwner: 'user/repo',
+  projectItemId: 'item-1',
+  itemId: 'item-1',
+  isPr: false,
+  story: 'Story A',
+  status: 'Awaiting Quality Check',
+  nextActionDate: null,
+  nextActionHour: null,
+  dependedIssueUrls: [],
+  labels: [],
+  createdAt: new Date('2024-01-01T00:00:00Z').toISOString(),
+  relatedOpenPullRequestUrls: [],
+  ...overrides,
+});
+
+const makeStatusTab = (
+  pjcode: string,
+  items: ConsoleListItem[],
+  storyOrder: string[] = ['Story A', 'Story B'],
+) => ({
+  pjcode,
+  generatedAt: '2026-08-16T04:19:32Z',
+  statusOptions: [],
+  storyOrder,
+  storyColors: {},
+  items,
+});
+
+describe('FileSystemConsoleTabsRepository', () => {
+  let dir: string;
+  const PJCODE = 'test-project';
+
+  beforeEach(() => {
+    dir = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'console-tabs-repository-test-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  const writeTabFile = (tab: string, data: unknown): void => {
+    const tabDir = path.join(dir, PJCODE, tab);
+    fs.mkdirSync(tabDir, { recursive: true });
+    fs.writeFileSync(path.join(tabDir, 'list.json'), JSON.stringify(data));
+  };
+
+  const readTabFile = (tab: string): unknown => {
+    const filePath = path.join(dir, PJCODE, tab, 'list.json');
+    const data: unknown = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    return data;
+  };
+
+  it('inserts the item into the prs tab when transitioning to Awaiting Quality Check', () => {
+    writeTabFile('prs', makeStatusTab(PJCODE, []));
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem({ status: 'Awaiting Quality Check' });
+
+    repo.patchIssueTabTransition({
+      projectItemId: item.projectItemId,
+      item,
+      targetTabName: 'prs',
+    });
+
+    expect(readTabFile('prs')).toMatchObject({
+      items: [{ projectItemId: 'item-1' }],
+    });
+  });
+
+  it('preserves generatedAt in the patched tab file', () => {
+    writeTabFile('prs', makeStatusTab(PJCODE, []));
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem();
+
+    repo.patchIssueTabTransition({
+      projectItemId: item.projectItemId,
+      item,
+      targetTabName: 'prs',
+    });
+
+    expect(readTabFile('prs')).toHaveProperty(
+      'generatedAt',
+      '2026-08-16T04:19:32Z',
+    );
+  });
+
+  it('removes the item from any tab it previously appeared in', () => {
+    const existingItem = makeItem({ projectItemId: 'item-1' });
+    writeTabFile('todo-by-human', makeStatusTab(PJCODE, [existingItem]));
+    writeTabFile('prs', makeStatusTab(PJCODE, []));
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem({ status: 'Awaiting Quality Check' });
+
+    repo.patchIssueTabTransition({
+      projectItemId: 'item-1',
+      item,
+      targetTabName: 'prs',
+    });
+
+    expect(readTabFile('todo-by-human')).toMatchObject({ items: [] });
+    expect(readTabFile('prs')).toMatchObject({
+      items: [{ projectItemId: 'item-1' }],
+    });
+  });
+
+  it('removes the projectItemId from the target tab .done.json', () => {
+    writeTabFile('prs', makeStatusTab(PJCODE, []));
+    const doneFilePath = path.join(dir, PJCODE, 'prs', '.done.json');
+    fs.writeFileSync(
+      doneFilePath,
+      JSON.stringify({ projectItemIds: ['item-1', 'item-2'] }),
+    );
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem();
+
+    repo.patchIssueTabTransition({
+      projectItemId: 'item-1',
+      item,
+      targetTabName: 'prs',
+    });
+
+    const ids = readDoneProjectItemIds(dir, PJCODE, 'prs');
+    expect(ids).not.toContain('item-1');
+    expect(ids).toContain('item-2');
+  });
+
+  it('is a no-op when the target tab file does not exist', () => {
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem();
+
+    expect(() =>
+      repo.patchIssueTabTransition({
+        projectItemId: item.projectItemId,
+        item,
+        targetTabName: 'prs',
+      }),
+    ).not.toThrow();
+    expect(fs.existsSync(path.join(dir, PJCODE, 'prs', 'list.json'))).toBe(
+      false,
+    );
+  });
+
+  it('removes the item from any tab and writes nothing when targetTabName is null', () => {
+    const existingItem = makeItem({ projectItemId: 'item-1' });
+    writeTabFile('prs', makeStatusTab(PJCODE, [existingItem]));
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem({ status: 'Awaiting Workspace' });
+
+    repo.patchIssueTabTransition({
+      projectItemId: 'item-1',
+      item,
+      targetTabName: null,
+    });
+
+    expect(readTabFile('prs')).toMatchObject({ items: [] });
+  });
+
+  it('maintains story order after inserting the new item', () => {
+    const itemInStoryB = makeItem({
+      projectItemId: 'item-2',
+      story: 'Story B',
+    });
+    writeTabFile('prs', makeStatusTab(PJCODE, [itemInStoryB]));
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem({
+      projectItemId: 'item-1',
+      story: 'Story A',
+      status: 'Awaiting Quality Check',
+    });
+
+    repo.patchIssueTabTransition({
+      projectItemId: 'item-1',
+      item,
+      targetTabName: 'prs',
+    });
+
+    expect(readTabFile('prs')).toMatchObject({
+      items: [{ story: 'Story A' }, { story: 'Story B' }],
+    });
+  });
+
+  it('does not write to tab files that do not contain the item when targetTabName is null', () => {
+    const otherItem = makeItem({ projectItemId: 'item-99' });
+    writeTabFile('prs', makeStatusTab(PJCODE, [otherItem]));
+    const mtimeBefore = fs.statSync(
+      path.join(dir, PJCODE, 'prs', 'list.json'),
+    ).mtimeMs;
+    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
+    const item = makeItem({ projectItemId: 'item-1' });
+
+    repo.patchIssueTabTransition({
+      projectItemId: 'item-1',
+      item,
+      targetTabName: null,
+    });
+
+    const mtimeAfter = fs.statSync(
+      path.join(dir, PJCODE, 'prs', 'list.json'),
+    ).mtimeMs;
+    expect(mtimeAfter).toBe(mtimeBefore);
+  });
+});

package/src/adapter/entry-points/handlers/FileSystemConsoleTabsRepository.ts

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+import type {
+  ConsoleListItem,
+  ConsoleTabName,
+} from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
+import type { ConsoleTabsRepository } from '../../../domain/usecases/adapter-interfaces/ConsoleTabsRepository';
+import {
+  CONSOLE_LIST_TAB_NAMES,
+  sortByStoryOrder,
+} from '../console/consoleTabNames';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const writeJsonAtomic = (filePath: string, data: unknown): void => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(data));
+  fs.renameSync(tmpPath, filePath);
+};
+
+const readTabListJson = (filePath: string): Record<string, unknown> | null => {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf-8');
+    const parsed: unknown = JSON.parse(raw);
+    if (!isRecord(parsed) || !Array.isArray(parsed.items)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+
+const clearProjectItemIdFromDoneJson = (
+  doneFilePath: string,
+  projectItemId: string,
+): void => {
+  let existingIds: string[] = [];
+  try {
+    const raw = fs.readFileSync(doneFilePath, 'utf-8');
+    const parsed: unknown = JSON.parse(raw);
+    if (isRecord(parsed)) {
+      const rawIds = parsed.projectItemIds;
+      if (Array.isArray(rawIds)) {
+        existingIds = rawIds.filter(
+          (id): id is string => typeof id === 'string',
+        );
+      }
+    }
+  } catch {
+    // File does not exist; start with empty list
+  }
+  writeJsonAtomic(doneFilePath, {
+    projectItemIds: existingIds.filter((id) => id !== projectItemId),
+  });
+};
+
+export class FileSystemConsoleTabsRepository implements ConsoleTabsRepository {
+  constructor(
+    private readonly consoleDataOutputDir: string,
+    private readonly pjcode: string,
+  ) {}
+
+  patchIssueTabTransition(params: {
+    projectItemId: string;
+    item: ConsoleListItem;
+    targetTabName: ConsoleTabName | null;
+  }): void {
+    const { projectItemId, item, targetTabName } = params;
+
+    for (const tabName of CONSOLE_LIST_TAB_NAMES) {
+      const filePath = path.join(
+        this.consoleDataOutputDir,
+        this.pjcode,
+        tabName,
+        'list.json',
+      );
+      const existing = readTabListJson(filePath);
+      if (existing === null) {
+        continue;
+      }
+
+      const rawItems = existing.items;
+      const items: unknown[] = Array.isArray(rawItems) ? rawItems : [];
+      const withoutThisItem = items.filter(
+        (i) => !(isRecord(i) && i.projectItemId === projectItemId),
+      );
+
+      if (tabName === targetTabName) {
+        const rawStoryOrder = existing.storyOrder;
+        const storyOrder = Array.isArray(rawStoryOrder)
+          ? rawStoryOrder.filter((s): s is string => typeof s === 'string')
+          : [];
+        const newItems = sortByStoryOrder(
+          [...withoutThisItem, item],
+          storyOrder,
+        );
+        writeJsonAtomic(filePath, { ...existing, items: newItems });
+        const doneFilePath = path.join(
+          this.consoleDataOutputDir,
+          this.pjcode,
+          tabName,
+          '.done.json',
+        );
+        clearProjectItemIdFromDoneJson(doneFilePath, projectItemId);
+      } else if (withoutThisItem.length !== items.length) {
+        writeJsonAtomic(filePath, { ...existing, items: withoutThisItem });
+      }
+    }
+  }
+}

package/src/adapter/entry-points/handlers/consoleListsWriter.ts

@@ -4,10 +4,10 @@ import type { Issue } from '../../../domain/entities/Issue';
 import type { Project } from '../../../domain/entities/Project';
 import {
   ConsoleLists,
-  ConsoleTabName,
   GenerateConsoleListsUseCase,
 } from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
 import { resetDoneProjectItemIdsAcrossTabs } from '../console/consoleDoneStore';
+import { CONSOLE_LIST_TAB_NAMES } from '../console/consoleTabNames';
 
 export type ConsoleListsWriterParams = {
   consoleDataOutputDir: string | null | undefined;
@@ -19,16 +19,6 @@ export type ConsoleListsWriterParams = {
   generatedAt?: string;
 };
 
-const CONSOLE_TAB_NAMES: ConsoleTabName[] = [
-  'workflow-blocker',
-  'prs',
-  'triage',
-  'unread',
-  'failed-preparation',
-  'todo-by-human',
-  'todo-by-agent',
-];
-
 export const formatConsoleGeneratedAt = (date: Date): string =>
   date.toISOString().replace(/\.\d{3}Z$/, 'Z');
 
@@ -57,7 +47,7 @@ export const writeConsoleLists = (params: ConsoleListsWriterParams): void => {
     workflowBlockerStoryName: params.workflowBlockerStoryName ?? null,
   });
 
-  for (const tab of CONSOLE_TAB_NAMES) {
+  for (const tab of CONSOLE_LIST_TAB_NAMES) {
     writeJsonAtomic(
       path.join(consoleDataOutputDir, pjcode, tab, 'list.json'),
       lists[tab],

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.test.ts

@@ -69,7 +69,7 @@ describe('FileSystemSubAgentLivenessResolver', () => {
     expect(result).toEqual(new Set());
   });
 
-  it('returns an empty set when the runtime root exists and the session has no running file', async () => {
+  it('returns null when the runtime root exists and the session has no running file', async () => {
     const resolver = new FileSystemSubAgentLivenessResolver(runtimeRoot);
 
     const result = await resolver.resolveLiveSubAgentIds({
@@ -77,7 +77,7 @@ describe('FileSystemSubAgentLivenessResolver', () => {
       mainTranscriptPath,
     });
 
-    expect(result).toEqual(new Set());
+    expect(result).toBeNull();
   });
 
   it('returns null when the configured runtime root directory does not exist', async () => {
@@ -192,7 +192,7 @@ describe('running-subagents record agent id contract with TranscriptSessionSubAg
     ]);
   });
 
-  it('reports no sub-agent when the runtime root exists and the session has no running-subagents record', async () => {
+  it('detects a working sub-agent when the runtime root exists and the session has no running-subagents record', async () => {
     const subAgentsDirectory = path.join(
       transcriptRoot,
       cwdSlug,
@@ -224,6 +224,14 @@ describe('running-subagents record agent id contract with TranscriptSessionSubAg
       new Map([[sessionName, mainTranscriptPath]]),
     );
 
-    expect(result.get(sessionName)).toBeUndefined();
+    expect(result.get(sessionName)).toEqual([
+      {
+        label: `agent-${liveAgentId}`,
+        silentSeconds: 0,
+        runningSeconds: 694800,
+        waitingOnExternalProcess: false,
+        finishedResultUnconsumed: false,
+      },
+    ]);
   });
 });

package/src/adapter/repositories/FileSystemSubAgentLivenessResolver.ts

@@ -4,12 +4,6 @@ import { SubAgentLivenessResolver } from '../../domain/usecases/adapter-interfac
 
 const RUNNING_SUBAGENTS_FILE_NAME = 'running-subagents.txt';
 
-const isMissingFileError = (error: unknown): boolean =>
-  typeof error === 'object' &&
-  error !== null &&
-  'code' in error &&
-  error.code === 'ENOENT';
-
 export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResolver {
   constructor(private readonly runtimeRootDirectory: string | null) {}
 
@@ -26,10 +20,7 @@ export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResol
     let content: string;
     try {
       content = fs.readFileSync(runningFilePath, 'utf8');
-    } catch (error) {
-      if (isMissingFileError(error) && this.hasReadableRuntimeRootDirectory()) {
-        return new Set();
-      }
+    } catch {
       return null;
     }
     const liveIds = new Set<string>();
@@ -42,17 +33,6 @@ export class FileSystemSubAgentLivenessResolver implements SubAgentLivenessResol
     return liveIds;
   };
 
-  private hasReadableRuntimeRootDirectory = (): boolean => {
-    if (this.runtimeRootDirectory === null) {
-      return false;
-    }
-    try {
-      return fs.statSync(this.runtimeRootDirectory).isDirectory();
-    } catch {
-      return false;
-    }
-  };
-
   private resolveRunningSubAgentsFilePath = (
     mainTranscriptPath: string | null,
   ): string | null => {

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.test.ts

@@ -3363,4 +3363,163 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       expect(mockIssueRepository.approvePullRequest).not.toHaveBeenCalled();
     });
   });
+
+  describe('consoleTabsRepository integration', () => {
+    let mockConsoleTabsRepository: {
+      patchIssueTabTransition: jest.Mock;
+    };
+
+    beforeEach(() => {
+      mockConsoleTabsRepository = {
+        patchIssueTabTransition: jest.fn(),
+      };
+      useCase = new NotifyFinishedIssuePreparationUseCase(
+        mockProjectRepository,
+        mockIssueRepository,
+        mockIssueCommentRepository,
+        mockWebhookRepository,
+        mockConsoleTabsRepository,
+      );
+    });
+
+    it('calls patchIssueTabTransition with prs tab when issue transitions to Awaiting Quality Check', async () => {
+      const issue = createMockIssue({
+        status: 'Preparation',
+        itemId: 'item-1',
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockConsoleTabsRepository.patchIssueTabTransition,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectItemId: 'item-1',
+          targetTabName: 'prs',
+        }),
+      );
+    });
+
+    it('calls patchIssueTabTransition with null tab when issue transitions to Awaiting Workspace', async () => {
+      const issue = createMockIssue({
+        status: 'Preparation',
+        itemId: 'item-2',
+        dependedIssueUrls: ['https://github.com/user/repo/issues/99'],
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(
+        mockConsoleTabsRepository.patchIssueTabTransition,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          projectItemId: 'item-2',
+          targetTabName: null,
+        }),
+      );
+    });
+
+    it('passes relatedOpenPullRequestUrls from findRelatedOpenPRs into the prs tab item', async () => {
+      const issue = createMockIssue({
+        status: 'Preparation',
+        itemId: 'item-1',
+        isPr: false,
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({ content: 'From: :robot: report' }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/42',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      let capturedArg: unknown = undefined;
+      mockConsoleTabsRepository.patchIssueTabTransition.mockImplementation(
+        (arg: unknown) => {
+          capturedArg = arg;
+        },
+      );
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(capturedArg).toMatchObject({
+        targetTabName: 'prs',
+        item: {
+          relatedOpenPullRequestUrls: ['https://github.com/user/repo/pull/42'],
+        },
+      });
+    });
+
+    it('does not call patchIssueTabTransition when consoleTabsRepository is not provided', async () => {
+      useCase = new NotifyFinishedIssuePreparationUseCase(
+        mockProjectRepository,
+        mockIssueRepository,
+        mockIssueCommentRepository,
+        mockWebhookRepository,
+      );
+      const issue = createMockIssue({
+        status: 'Preparation',
+        dependedIssueUrls: ['https://github.com/user/repo/issues/99'],
+      });
+      mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+      mockIssueRepository.get.mockResolvedValue(issue);
+
+      await expect(
+        useCase.run({
+          projectUrl: 'https://github.com/users/user/projects/1',
+          issueUrl: 'https://github.com/user/repo/issues/1',
+          thresholdForAutoReject: 3,
+          workflowBlockerResolvedWebhookUrl: null,
+          allowedIssueAuthors: null,
+        }),
+      ).resolves.not.toThrow();
+      expect(
+        mockConsoleTabsRepository.patchIssueTabTransition,
+      ).not.toHaveBeenCalled();
+    });
+  });
 });