github-issue-tower-defence-management 1.152.2 → 1.153.0

package/src/adapter/entry-points/cli/index.test.ts

@@ -1,4 +1,5 @@
 import * as fs from 'fs';
+import * as os from 'os';
 import * as path from 'path';
 import YAML from 'yaml';
 
@@ -21,6 +22,8 @@ import {
 import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
 import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
 import { CheckIssueReviewReadinessUseCase } from '../../../domain/usecases/CheckIssueReviewReadinessUseCase';
+import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
 
 jest.mock('../../../domain/usecases/StartPreparationUseCase');
 jest.mock('../../../domain/usecases/NotifyFinishedIssuePreparationUseCase');
@@ -2371,6 +2374,192 @@ mysteryKey: 'value'
     });
   });
 
+  describe('ownerCallFileAppend and ownerCallFileDelete', () => {
+    const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
+    const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
+    const sessionName = toTmuxSessionName(issueUrl);
+    let ownerCallDataDir = '';
+    let bodyFilePath = '';
+
+    beforeEach(() => {
+      ownerCallDataDir = fs.mkdtempSync(
+        path.join(os.tmpdir(), 'owner-call-cli-'),
+      );
+      bodyFilePath = path.join(ownerCallDataDir, 'body.txt');
+      fs.writeFileSync(bodyFilePath, '  the call body\n\nsecond paragraph\n');
+    });
+
+    afterEach(() => {
+      fs.rmSync(ownerCallDataDir, { recursive: true, force: true });
+    });
+
+    // The in-tmux-by-human data the scheduled run writes into the same
+    // directory serveWeb serves: one file per project, each listing the
+    // sessions of that project by their raw issue url.
+    type InTmuxByHumanProjectData = {
+      projectCode: string;
+      sessionIssueUrls: string[];
+    };
+
+    const writeInTmuxByHumanData = (
+      projects: InTmuxByHumanProjectData[],
+    ): void => {
+      for (const project of projects) {
+        fs.writeFileSync(
+          path.join(ownerCallDataDir, `${project.projectCode}.v4.json`),
+          `${JSON.stringify({
+            version: 4,
+            overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
+            tdpmConsoleUrl: 'http://localhost/projects/code',
+            newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
+            groups: [
+              {
+                story: 'a story',
+                sessions: project.sessionIssueUrls.map((url) => ({
+                  name: url,
+                  description: 'an issue title',
+                })),
+              },
+            ],
+          })}\n`,
+        );
+      }
+    };
+
+    const projectCodeListing = (
+      projects: InTmuxByHumanProjectData[],
+      url: string,
+    ): string | null =>
+      projects.find((project) => project.sessionIssueUrls.includes(url))
+        ?.projectCode ?? null;
+
+    const appendedFilePath = (projectCode: string | null): string =>
+      path.join(
+        ownerCallDataDir,
+        ownerCallFileRelativePath(projectCode, sessionName),
+      );
+
+    const runAppend = (calledAt: string): Promise<unknown> =>
+      program.parseAsync([
+        'node',
+        'test',
+        'ownerCallFileAppend',
+        '--session',
+        sessionName,
+        '--calledAt',
+        calledAt,
+        '--body-file',
+        bodyFilePath,
+        '--inTmuxDataDir',
+        ownerCallDataDir,
+      ]);
+
+    it('appends the call under the directory of the project whose session list holds the session', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'other', sessionIssueUrls: [otherIssueUrl] },
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+      const stdoutSpy = jest
+        .spyOn(process.stdout, 'write')
+        .mockImplementation(() => true);
+
+      await runAppend('2026-08-14T04:22:28Z');
+
+      const documents = YAML.parseAllDocuments(
+        fs.readFileSync(
+          appendedFilePath(projectCodeListing(projects, issueUrl)),
+          'utf-8',
+        ),
+      );
+      expect(documents).toHaveLength(1);
+      expect(documents[0].toJS()).toEqual({
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: '  the call body\n\nsecond paragraph\n',
+      });
+      expect(stdoutSpy).not.toHaveBeenCalled();
+
+      stdoutSpy.mockRestore();
+    });
+
+    it('appends the call under NA when no project lists the session', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'umino', sessionIssueUrls: [otherIssueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+
+      await runAppend('2026-08-14T04:22:28Z');
+
+      expect(projectCodeListing(projects, issueUrl)).toBeNull();
+      expect(fs.existsSync(appendedFilePath(null))).toBe(true);
+    });
+
+    it('rejects a calledAt that is not a UTC ISO-8601 timestamp with second precision', async () => {
+      const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+      const processExitSpy = jest
+        .spyOn(process, 'exit')
+        .mockImplementation(() => {
+          throw new Error('process.exit called');
+        });
+
+      await expect(runAppend('2026-08-14 04:22:28')).rejects.toThrow(
+        'process.exit called',
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
+      expect(fs.existsSync(appendedFilePath(null))).toBe(false);
+
+      consoleErrorSpy.mockRestore();
+      processExitSpy.mockRestore();
+    });
+
+    const runDelete = (): Promise<unknown> =>
+      program.parseAsync([
+        'node',
+        'test',
+        'ownerCallFileDelete',
+        '--session',
+        sessionName,
+        '--inTmuxDataDir',
+        ownerCallDataDir,
+      ]);
+
+    it('deletes the file of the session whichever project directory holds it', async () => {
+      const projects: InTmuxByHumanProjectData[] = [
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ];
+      writeInTmuxByHumanData(projects);
+      await runAppend('2026-08-14T04:22:28Z');
+      const writtenFilePath = appendedFilePath(
+        projectCodeListing(projects, issueUrl),
+      );
+      expect(fs.existsSync(writtenFilePath)).toBe(true);
+
+      await runDelete();
+
+      expect(fs.existsSync(writtenFilePath)).toBe(false);
+    });
+
+    it('deletes the file left behind under the project the session has since left', async () => {
+      writeInTmuxByHumanData([
+        { projectCode: 'umino', sessionIssueUrls: [issueUrl] },
+      ]);
+      await runAppend('2026-08-14T04:22:28Z');
+      writeInTmuxByHumanData([
+        { projectCode: 'umino', sessionIssueUrls: [] },
+        { projectCode: 'other', sessionIssueUrls: [issueUrl] },
+      ]);
+
+      await runDelete();
+
+      expect(fs.existsSync(appendedFilePath('umino'))).toBe(false);
+    });
+
+    it('succeeds when the file to delete is already absent', async () => {
+      await expect(runDelete()).resolves.toBeDefined();
+    });
+  });
+
   describe('runCliProgram', () => {
     const mockCheckUseCaseRejectingWith = (error: Error): void => {
       const MockedCheckUseCase = jest.mocked(CheckIssueReviewReadinessUseCase);

package/src/adapter/entry-points/cli/index.ts

@@ -63,6 +63,12 @@ import {
   loadLiveSessionOauthTokenSelectionSettings,
   resolveFleetConfigFilePath,
 } from './fleetConfig';
+import { isOwnerCallCalledAtValid } from '../../../domain/usecases/intmux/OwnerCallFile';
+import {
+  ownerCallFileAppend,
+  ownerCallFileDeleteInEveryProject,
+  ownerCallProjectCodeInInTmuxByHumanData,
+} from '../handlers/ownerCallFileStore';
 
 type StartDaemonOptions = {
   projectUrl?: string;
@@ -102,6 +108,18 @@ type ServeWebOptions = {
   dashboardProjectNames?: string;
 };
 
+type OwnerCallFileAppendOptions = {
+  session: string;
+  calledAt: string;
+  bodyFile: string;
+  inTmuxDataDir?: string;
+};
+
+type OwnerCallFileDeleteOptions = {
+  session: string;
+  inTmuxDataDir?: string;
+};
+
 const DEFAULT_IN_TMUX_DATA_DIR =
   '/home/hiromi/0_workspaces/workspace1/jsonpub/in-tmux-by-human';
 
@@ -1149,6 +1167,63 @@ program
     }
   });
 
+program
+  .command('ownerCallFileAppend')
+  .description(
+    'Append one owner call as a YAML document to the per-session owner call file. The project the session belongs to is resolved from the in-tmux-by-human data in the data directory, and a session no project lists is written under NA. The file is created when it does not exist, and every later call is appended after the existing documents so the oldest call stays first. Nothing is written to stdout on success.',
+  )
+  .requiredOption('--session <name>', 'tmux session name that raised the call')
+  .requiredOption(
+    '--calledAt <timestamp>',
+    'Time the call was raised, as UTC ISO-8601 with second precision and a trailing Z',
+  )
+  .requiredOption(
+    '--body-file <path>',
+    'Path to the file holding the call body; the body is read from a file because it is multi-line and can be long',
+  )
+  .option(
+    '--inTmuxDataDir <path>',
+    `Directory the owner call files are written under, the same directory serveWeb serves them from (default: ${DEFAULT_IN_TMUX_DATA_DIR})`,
+  )
+  .action((options: OwnerCallFileAppendOptions) => {
+    if (!isOwnerCallCalledAtValid(options.calledAt)) {
+      console.error(
+        '--calledAt must be a UTC ISO-8601 timestamp with second precision and a trailing Z, for example 2026-08-14T04:22:28Z',
+      );
+      return process.exit(1);
+    }
+    const dataDir = options.inTmuxDataDir ?? DEFAULT_IN_TMUX_DATA_DIR;
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        options.session,
+      ),
+      ownerCall: {
+        sessionName: options.session,
+        calledAt: options.calledAt,
+        body: fs.readFileSync(options.bodyFile, 'utf-8'),
+      },
+    });
+  });
+
+program
+  .command('ownerCallFileDelete')
+  .description(
+    'Delete the owner call file of one session, whichever project directory holds it, so a session that moved between projects after its call was appended leaves nothing behind. It succeeds when the file is already absent, so a reset that runs twice is not an error. Nothing is written to stdout on success.',
+  )
+  .requiredOption('--session <name>', 'tmux session name that raised the call')
+  .option(
+    '--inTmuxDataDir <path>',
+    `Directory the owner call files are written under, the same directory serveWeb serves them from (default: ${DEFAULT_IN_TMUX_DATA_DIR})`,
+  )
+  .action((options: OwnerCallFileDeleteOptions) => {
+    ownerCallFileDeleteInEveryProject({
+      dataDir: options.inTmuxDataDir ?? DEFAULT_IN_TMUX_DATA_DIR,
+      sessionName: options.session,
+    });
+  });
+
 export const reportFatalErrorAndExit = (error: unknown): void => {
   console.error(error);
   process.exit(1);

package/src/adapter/entry-points/console/ui/src/features/console/components/detail/ConsoleItemDetail.tsx

@@ -51,7 +51,6 @@ export type ConsoleItemDetailProps = {
   bodyIsLoading: boolean;
   bodyError: string | null;
   comments: ConsoleComment[];
-  hasPostedComment?: boolean;
   commentsAreLoading: boolean;
   commentsError: string | null;
   files: ConsoleChangedFile[];
@@ -83,7 +82,6 @@ export const ConsoleItemDetail = ({
   bodyIsLoading,
   bodyError,
   comments,
-  hasPostedComment = false,
   commentsAreLoading,
   commentsError,
   files,
@@ -277,10 +275,9 @@ export const ConsoleItemDetail = ({
       )}
 
       <ConsolePanel
-        key={hasPostedComment ? 'comments-with-posted' : 'comments'}
         title="Comments"
         count={commentsCount}
-        defaultCollapsed={item.isPr && !hasPostedComment}
+        defaultCollapsed={item.isPr}
       >
         <ConsoleCommentList
           comments={comments}

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

@@ -83,6 +83,20 @@ const buildOperations = (): ConsoleOperationsApi => ({
   addInlineReviewComment: jest.fn(async () => {}),
 });
 
+const findCommentsPanelToggle = (container: HTMLElement): HTMLElement => {
+  const toggle = Array.from(
+    container.querySelectorAll('.console-panel-toggle'),
+  ).find((element) =>
+    element
+      .querySelector('.console-panel-title')
+      ?.textContent?.startsWith('Comments'),
+  );
+  if (toggle === undefined) {
+    throw new Error('Comments panel toggle is not rendered');
+  }
+  return toggle as HTMLElement;
+};
+
 describe('ConsoleItemDetailContainer', () => {
   it('queues the review action and commits it through the operations api for a PR item', async () => {
     const operations = buildOperations();
@@ -182,7 +196,7 @@ describe('ConsoleItemDetailContainer', () => {
     ).toBe(0);
   });
 
-  it('opens the comments panel of a pull request item so the posted comment is on screen', async () => {
+  it('leaves the collapsed comments panel of a pull request item collapsed after a comment is posted', async () => {
     const operations = buildOperations();
     operations.addComment = jest.fn(async (_item, body) => ({
       author: 'HiromiShikata',
@@ -205,16 +219,78 @@ describe('ConsoleItemDetailContainer', () => {
       />,
     );
 
+    await waitFor(() => {
+      expect(findCommentsPanelToggle(container).textContent).toContain(
+        'Comments (0)',
+      );
+    });
+    expect(
+      findCommentsPanelToggle(container).getAttribute('aria-expanded'),
+    ).toBe('false');
+
     fireEvent.change(getByPlaceholderText('Leave a comment…'), {
       target: { value: 'Posted from the pull request item.' },
     });
     fireEvent.click(getByText('Comment'));
 
     await waitFor(() => {
-      expect(
-        container.querySelector('.console-comment-list')?.textContent,
-      ).toContain('Posted from the pull request item.');
+      expect(findCommentsPanelToggle(container).textContent).toContain(
+        'Comments (1)',
+      );
+    });
+    expect(
+      findCommentsPanelToggle(container).getAttribute('aria-expanded'),
+    ).toBe('false');
+    expect(container.querySelector('.console-comment-list')).toBeNull();
+  });
+
+  it('keeps a reader-collapsed comments panel collapsed after a comment is posted on an issue item', async () => {
+    const operations = buildOperations();
+    operations.addComment = jest.fn(async (_item, body) => ({
+      author: 'HiromiShikata',
+      body,
+      createdAt: '2026-06-19T11:58:00.000Z',
+    }));
+    const { container, getByPlaceholderText, getByText } = render(
+      <ConsoleItemDetailContainer
+        tab="unread"
+        item={issueItem}
+        caches={buildCaches()}
+        operations={operations}
+        statusOptions={consoleStatusOptionsFixture}
+        storyOptions={consoleStoryOptionsFixture}
+        storyColors={consoleStoryColorsFixture}
+        storyName="TDPM Console port"
+        overlayStatus={null}
+        now={Date.parse('2026-06-19T12:00:00.000Z')}
+        onQueueAction={jest.fn()}
+      />,
+    );
+
+    await waitFor(() => {
+      expect(findCommentsPanelToggle(container).textContent).toContain(
+        'Comments (0)',
+      );
+    });
+    fireEvent.click(findCommentsPanelToggle(container));
+    expect(
+      findCommentsPanelToggle(container).getAttribute('aria-expanded'),
+    ).toBe('false');
+
+    fireEvent.change(getByPlaceholderText('Leave a comment…'), {
+      target: { value: 'Posted from the issue item.' },
     });
+    fireEvent.click(getByText('Comment'));
+
+    await waitFor(() => {
+      expect(findCommentsPanelToggle(container).textContent).toContain(
+        'Comments (1)',
+      );
+    });
+    expect(
+      findCommentsPanelToggle(container).getAttribute('aria-expanded'),
+    ).toBe('false');
+    expect(container.querySelector('.console-comment-list')).toBeNull();
   });
 
   it('shows Approve for an issue item from the generated related open pull request urls before the related pull requests are fetched', () => {

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

@@ -171,7 +171,6 @@ export const ConsoleItemDetailContainer = ({
       bodyIsLoading={detail.bodyIsLoading}
       bodyError={detail.bodyError}
       comments={mergePostedComments(detail.comments, postedComments)}
-      hasPostedComment={postedComments.length > 0}
       commentsAreLoading={detail.commentsAreLoading}
       commentsError={detail.commentsError}
       files={detail.files}