github-issue-tower-defence-management 1.192.0 → 1.194.0

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

@@ -8,6 +8,7 @@ jest.mock('fs', () => {
   return {
     ...actualFs,
     readFileSync: jest.fn(actualFs.readFileSync),
+    existsSync: jest.fn(actualFs.existsSync),
   };
 });
 import {
@@ -70,9 +71,11 @@ const mockRunCommand = jest.fn<
   Promise<{ stdout: string; stderr: string; exitCode: number }>,
   [string, string[]]
 >();
+const mockSpawnInteractive = jest.fn<void, [string, string[]]>();
 jest.mock('../../repositories/NodeLocalCommandRunner', () => ({
   NodeLocalCommandRunner: jest.fn().mockImplementation(() => ({
     runCommand: mockRunCommand,
+    spawnInteractive: mockSpawnInteractive,
   })),
 }));
 jest.mock('../../repositories/OauthAPIClaudeRepository', () => ({
@@ -2463,6 +2466,105 @@ mysteryKey: 'value'
     });
   });
 
+  describe('attachOrCreate', () => {
+    const issueUrl = 'https://github.com/owner/repo/issues/9';
+    let scopeLibPath = '';
+
+    beforeEach(() => {
+      scopeLibPath = path.join(
+        os.tmpdir(),
+        `test-cl-scope-lib-${Date.now()}.sh`,
+      );
+      fs.writeFileSync(scopeLibPath, '#!/bin/bash\n');
+      process.env.CL_SCOPE_LIB_PATH = scopeLibPath;
+    });
+
+    afterEach(() => {
+      if (fs.existsSync(scopeLibPath)) {
+        fs.unlinkSync(scopeLibPath);
+      }
+      delete process.env.CL_SCOPE_LIB_PATH;
+    });
+
+    it('attaches to the registered session when registry returns a live session', async () => {
+      mockRunCommand
+        .mockResolvedValueOnce({ stdout: 'wq7x3mk\n', stderr: '', exitCode: 0 })
+        .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'attachOrCreate',
+        '--issueUrl',
+        issueUrl,
+      ]);
+
+      expect(mockRunCommand.mock.calls[0]).toEqual([
+        'bash',
+        [scopeLibPath, 'registry-get-session', issueUrl],
+      ]);
+      expect(mockRunCommand.mock.calls[1]).toEqual([
+        'tmux',
+        ['has-session', '-t', '=wq7x3mk'],
+      ]);
+      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
+        'attach-session',
+        '-t',
+        '=wq7x3mk',
+      ]);
+    });
+
+    it('creates a new session when no registered session is found', async () => {
+      mockRunCommand.mockResolvedValueOnce({
+        stdout: '',
+        stderr: '',
+        exitCode: 0,
+      });
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'attachOrCreate',
+        '--issueUrl',
+        issueUrl,
+      ]);
+
+      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
+        'new-session',
+        '-A',
+        '-s',
+        issueUrl,
+        'cl',
+        issueUrl,
+      ]);
+    });
+
+    it('creates a new session when no scope lib path is available', async () => {
+      jest
+        .mocked(fs.existsSync)
+        .mockReturnValueOnce(false)
+        .mockReturnValueOnce(false);
+
+      await program.parseAsync([
+        'node',
+        'test',
+        'attachOrCreate',
+        '--issueUrl',
+        issueUrl,
+      ]);
+
+      expect(mockRunCommand.mock.calls).toHaveLength(0);
+      expect(mockSpawnInteractive).toHaveBeenCalledWith('tmux', [
+        'new-session',
+        '-A',
+        '-s',
+        issueUrl,
+        'cl',
+        issueUrl,
+      ]);
+    });
+  });
+
   describe('ownerCallFileAppend and ownerCallFileDelete', () => {
     const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
     const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';

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

@@ -36,6 +36,7 @@ import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwn
 import { DEFAULT_THRESHOLD_FOR_DISPATCH_LOOP } from '../../../domain/usecases/resolveNextStepAgentDispatchRepetition';
 import { ProxyClaudeTokenUsageRepository } from '../../repositories/ProxyClaudeTokenUsageRepository';
 import { SystemDateRepository } from '../../repositories/SystemDateRepository';
+import * as os from 'os';
 import {
   createConsoleGithubTokenResolver,
   createConsoleGithubTokenResolverByItemUrl,
@@ -198,6 +199,27 @@ type KillTmuxSessionOptions = {
   self?: boolean;
 };
 
+type AttachOrCreateOptions = {
+  issueUrl: string;
+};
+
+const resolveScopeLibPath = (): string | null => {
+  const explicitPath = process.env.CL_SCOPE_LIB_PATH;
+  if (explicitPath !== undefined && fs.existsSync(explicitPath)) {
+    return explicitPath;
+  }
+  const defaultPath = path.join(
+    os.homedir(),
+    'git',
+    'secretary',
+    'machine',
+    'sk',
+    'sh',
+    'cl-scope-lib.sh',
+  );
+  return fs.existsSync(defaultPath) ? defaultPath : null;
+};
+
 const buildGithubRepositoryParams = (
   localStorageRepository: LocalStorageRepository,
   token: string,
@@ -1302,6 +1324,27 @@ program
     });
   });
 
+program
+  .command('attachOrCreate')
+  .description(
+    'Attach to an existing tmux session registered for the given issue URL, or create a new one. Looks up the cl session registry via cl-scope-lib.sh to find a registered session name; if that session is still alive it attaches to it, otherwise creates a new interactive session running cl for the issue URL.',
+  )
+  .requiredOption(
+    '--issueUrl <url>',
+    'GitHub issue URL to attach to or create a session for',
+  )
+  .action(async (options: AttachOrCreateOptions) => {
+    const localCommandRunner = new NodeLocalCommandRunner();
+    const tmuxSessionRepository = new NodeTmuxSessionRepository(
+      localCommandRunner,
+    );
+    const scopeLibPath = resolveScopeLibPath();
+    await tmuxSessionRepository.attachOrCreateInteractiveSession(
+      options.issueUrl,
+      scopeLibPath,
+    );
+  });
+
 export const reportFatalErrorAndExit = (error: unknown): void => {
   console.error(error);
   process.exit(1);

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

@@ -12,6 +12,7 @@ import {
   readDoneProjectItemIds,
 } from './consoleDoneStore';
 import {
+  CONFLICT_RETURNED_MESSAGE,
   type ConsoleOperationContext,
   type ConsoleProjectBinding,
   handleAttachmentUpload,
@@ -566,7 +567,7 @@ describe('consoleOperationApi', () => {
       expect(issueRepository.mergePullRequest).not.toHaveBeenCalled();
     });
 
-    it('returns 400 when the pull request has a merge conflict', async () => {
+    it('posts a conflict comment, moves to Awaiting workspace, and returns 200 when the pull request has a merge conflict', async () => {
       issueRepository.getOpenPullRequest.mockResolvedValue({
         url: 'https://github.com/o/r/pull/1',
         branchName: null,
@@ -586,11 +587,24 @@ describe('consoleOperationApi', () => {
         prUrl: 'https://github.com/o/r/pull/1',
         projectItemId: 'PVTI_conflict',
       });
-      expect(response.statusCode).toBe(400);
-      expect(response.body).toMatchObject({
-        error: 'Cannot merge: pull request has a merge conflict',
-      });
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.createCommentByUrl).toHaveBeenCalledWith(
+        'https://github.com/o/r/pull/1',
+        CONFLICT_RETURNED_MESSAGE,
+      );
+      expect(issueRepository.updateStatus).toHaveBeenCalledWith(
+        project,
+        expect.objectContaining({
+          itemId: 'PVTI_conflict',
+          url: 'https://github.com/o/r/pull/1',
+        }),
+        'status_aw',
+      );
       expect(issueRepository.mergePullRequest).not.toHaveBeenCalled();
+      expectRecordedOnlyIn(
+        'PVTI_conflict',
+        CONSOLE_DONE_STATUS_SELECTED_TAB_NAMES,
+      );
     });
 
     it('returns 400 with check names when required checks are not green', async () => {

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

@@ -20,6 +20,8 @@ import {
 import { findConsoleItemUrl } from './consoleItemUrlLookup';
 
 export const AWAITING_WORKSPACE_STATUS_NAME = 'awaiting workspace';
+export const CONFLICT_RETURNED_MESSAGE =
+  'Auto Status Check: CONFLICT\nThis pull request has a merge conflict and has been returned to Awaiting Workspace.';
 export const IN_TMUX_BY_HUMAN_STATUS_NAME = 'in tmux by human';
 export const CHORE_LABEL_NAME = 'chore';
 
@@ -367,7 +369,22 @@ export const handleReview = async (
       );
     }
     if (prStatus.isConflicted) {
-      return badRequest('Cannot merge: pull request has a merge conflict');
+      await issueRepository.createCommentByUrl(
+        prUrl,
+        CONFLICT_RETURNED_MESSAGE,
+      );
+      const conflictFailure = await updateStatusByName(
+        issueRepository,
+        project,
+        prUrl,
+        projectItemId,
+        AWAITING_WORKSPACE_STATUS_NAME,
+      );
+      if (conflictFailure !== null) {
+        return conflictFailure;
+      }
+      recordDoneForStatusChange(context, pjcode, projectItemId);
+      return ok();
     }
     if (!prStatus.isPassedAllCiJob) {
       const missing = prStatus.missingRequiredCheckNames;

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

@@ -420,6 +420,51 @@ test('renders the stories tab with non-gray stories, their open item counts, and
   ).toHaveCount(0);
 });
 
+test('shows and hides gray stories with the Show archived toggle button on the stories tab', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Stories').click();
+  await expect(activeTabLabel(page)).toHaveText('Stories');
+
+  await expect(
+    page.locator('.console-op-button', { hasText: 'Show archived' }),
+  ).toBeVisible();
+
+  await expect(
+    page.locator('.console-story-list-row', {
+      hasText: 'regular / workflow improvement',
+    }),
+  ).toHaveCount(0);
+
+  await page
+    .locator('.console-op-button', { hasText: 'Show archived' })
+    .click();
+
+  await expect(
+    page.locator('.console-story-list-row', {
+      hasText: 'regular / workflow improvement',
+    }),
+  ).toBeVisible();
+  await expect(
+    page.locator('.console-op-button', { hasText: 'Hide archived' }),
+  ).toBeVisible();
+
+  await page
+    .locator('.console-op-button', { hasText: 'Hide archived' })
+    .click();
+
+  await expect(
+    page.locator('.console-story-list-row', {
+      hasText: 'regular / workflow improvement',
+    }),
+  ).toHaveCount(0);
+  await expect(
+    page.locator('.console-op-button', { hasText: 'Show archived' }),
+  ).toBeVisible();
+});
+
 test('shows the agent label and value in the list row and the agent chip in the detail view', async ({
   page,
 }) => {

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

@@ -295,6 +295,13 @@ const CONSOLE_E2E_STORIES_SNAPSHOT = {
       storyViewUrl:
         'https://github.com/orgs/HiromiShikata/projects/6/views/1?sliceBy%5Bvalue%5D=TDPM%20Console%20port',
     },
+    {
+      storyName: 'regular / workflow improvement',
+      storyOptionId: '28415d6c',
+      color: 'GRAY',
+      openItemCount: 1,
+      storyViewUrl: null,
+    },
     {
       storyName: 'Publish product documentation site',
       storyOptionId: 'f7cd5cbc',

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryList.stories.tsx

@@ -47,13 +47,26 @@ const storiesWithUrl = storiesWithoutUrl.map((s) => ({
   storyViewUrl: `${BASE_VIEW_URL}?sliceBy%5Bvalue%5D=${encodeURI(s.storyName).replace(/#/g, '%23').replace(/&/g, '%26')}`,
 }));
 
+const storiesWithArchived = [
+  ...storiesWithoutUrl,
+  {
+    storyName: 'regular / NO STORY; SET STORY FIELD',
+    storyOptionId: '28415d6c',
+    color: 'GRAY' as const,
+    openItemCount: 5,
+    storyViewUrl: null,
+  },
+];
+
 const meta: Meta<typeof ConsoleStoryList> = {
   title: 'Console/ConsoleStoryList',
   component: ConsoleStoryList,
   args: {
+    showGray: false,
     onCreateIssue: () => Promise.resolve(),
     onAddStory: () => Promise.resolve(),
     onSelectColor: () => undefined,
+    onToggleGray: () => undefined,
     optimisticColors: {},
     colorChangeInFlight: null,
     colorErrors: {},
@@ -103,3 +116,21 @@ export const ErrorState: Story = {
     error: 'HTTP 404',
   },
 };
+
+export const WithArchivedHidden: Story = {
+  args: {
+    stories: storiesWithArchived,
+    isLoading: false,
+    error: null,
+    showGray: false,
+  },
+};
+
+export const WithArchivedShown: Story = {
+  args: {
+    stories: storiesWithArchived,
+    isLoading: false,
+    error: null,
+    showGray: true,
+  },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryList.test.tsx

@@ -19,13 +19,25 @@ const storyEntries: ConsoleStoryEntry[] = [
   },
 ];
 
+const grayStoryEntry: ConsoleStoryEntry = {
+  storyName: 'Archived Story',
+  storyOptionId: 'gray-id',
+  color: 'GRAY',
+  openItemCount: 3,
+  storyViewUrl: null,
+};
+
+const entriesWithGray: ConsoleStoryEntry[] = [...storyEntries, grayStoryEntry];
+
 const defaultProps = {
   stories: storyEntries,
   isLoading: false,
   error: null,
+  showGray: false,
   onCreateIssue: () => Promise.resolve(),
   onAddStory: () => Promise.resolve(),
   onSelectColor: () => undefined,
+  onToggleGray: () => undefined,
   optimisticColors: {} as Record<string, ConsoleColor>,
   colorChangeInFlight: null as string | null,
   colorErrors: {} as Record<string, string>,
@@ -370,4 +382,88 @@ describe('ConsoleStoryList', () => {
     });
     expect(writeText).toHaveBeenCalledWith(storyEntries[0].storyName);
   });
+
+  describe('gray story toggle', () => {
+    it('hides gray stories when showGray is false', () => {
+      const { queryByText } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={entriesWithGray}
+          showGray={false}
+        />,
+      );
+      expect(queryByText('Archived Story')).toBeNull();
+      expect(queryByText('TDPM Console port')).toBeInTheDocument();
+    });
+
+    it('shows gray stories when showGray is true', () => {
+      const { getByText } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={entriesWithGray}
+          showGray={true}
+        />,
+      );
+      expect(getByText('Archived Story')).toBeInTheDocument();
+    });
+
+    it('shows the toggle button labeled Show archived when at least one gray story exists and showGray is false', () => {
+      const { getByRole } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={entriesWithGray}
+          showGray={false}
+        />,
+      );
+      expect(
+        getByRole('button', { name: 'Show archived' }),
+      ).toBeInTheDocument();
+    });
+
+    it('shows the toggle button labeled Hide archived when showGray is true', () => {
+      const { getByRole } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={entriesWithGray}
+          showGray={true}
+        />,
+      );
+      expect(
+        getByRole('button', { name: 'Hide archived' }),
+      ).toBeInTheDocument();
+    });
+
+    it('does not show the toggle button when no gray stories exist', () => {
+      const { queryByRole } = render(
+        <ConsoleStoryList {...defaultProps} stories={storyEntries} />,
+      );
+      expect(queryByRole('button', { name: 'Show archived' })).toBeNull();
+      expect(queryByRole('button', { name: 'Hide archived' })).toBeNull();
+    });
+
+    it('calls onToggleGray when the toggle button is clicked', () => {
+      const onToggleGray = jest.fn();
+      const { getByRole } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={entriesWithGray}
+          showGray={false}
+          onToggleGray={onToggleGray}
+        />,
+      );
+      fireEvent.click(getByRole('button', { name: 'Show archived' }));
+      expect(onToggleGray).toHaveBeenCalledTimes(1);
+    });
+
+    it('shows No active stories when all stories are gray and showGray is false', () => {
+      const { getByText } = render(
+        <ConsoleStoryList
+          {...defaultProps}
+          stories={[grayStoryEntry]}
+          showGray={false}
+        />,
+      );
+      expect(getByText('No active stories')).toBeInTheDocument();
+    });
+  });
 });

package/src/adapter/entry-points/console/ui/src/features/console/components/list/ConsoleStoryList.tsx

@@ -132,9 +132,11 @@ export type ConsoleStoryListProps = {
   stories: ConsoleStoryEntry[];
   isLoading: boolean;
   error: string | null;
+  showGray: boolean;
   onCreateIssue: (storyOptionId: string, title: string) => Promise<void>;
   onAddStory: (storyName: string) => Promise<void>;
   onSelectColor: (storyOptionId: string, newColor: ConsoleColor) => void;
+  onToggleGray: () => void;
   optimisticColors: Record<string, ConsoleColor>;
   colorChangeInFlight: string | null;
   colorErrors: Record<string, string>;
@@ -144,9 +146,11 @@ export const ConsoleStoryList = ({
   stories,
   isLoading,
   error,
+  showGray,
   onCreateIssue,
   onAddStory,
   onSelectColor,
+  onToggleGray,
   optimisticColors,
   colorChangeInFlight,
   colorErrors,
@@ -197,13 +201,18 @@ export const ConsoleStoryList = ({
     onSelectColor(storyOptionId, newColor);
   };
 
+  const visibleStories = showGray
+    ? stories
+    : stories.filter((s) => s.color !== 'GRAY');
+  const hasGrayStories = stories.some((s) => s.color === 'GRAY');
+
   return (
     <div className="console-story-list-container">
-      {stories.length === 0 ? (
+      {visibleStories.length === 0 ? (
         <p className="console-list-empty">No active stories</p>
       ) : (
         <ul className="console-story-list">
-          {stories.map((entry) => {
+          {visibleStories.map((entry) => {
             const displayColor: ConsoleColor =
               optimisticColors[entry.storyOptionId] ?? entry.color;
             const palette = colorFromEnum(displayColor);
@@ -285,6 +294,15 @@ export const ConsoleStoryList = ({
           })}
         </ul>
       )}
+      {hasGrayStories && (
+        <button
+          type="button"
+          className="console-op-button"
+          onClick={onToggleGray}
+        >
+          {showGray ? 'Hide archived' : 'Show archived'}
+        </button>
+      )}
       <div className="console-add-story-section">
         <button
           type="button"