github-issue-tower-defence-management 1.165.0 → 1.166.0

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

@@ -10,6 +10,7 @@ import {
   ConsoleProjectBinding,
   handleAttachmentUpload,
   handleComment,
+  handleCreateIssue,
   handleIntmux,
   handleReview,
   handleReviewComment,
@@ -1428,4 +1429,214 @@ describe('consoleOperationApi', () => {
       });
     });
   });
+
+  describe('handleCreateIssue', () => {
+    const projectWithStory = (): Project => ({
+      ...project,
+      story: {
+        name: 'Story',
+        fieldId: 'storyField',
+        databaseId: 1,
+        stories: [
+          {
+            id: 'opt_blue',
+            name: 'Portal redesign',
+            color: 'BLUE',
+            description: '',
+          },
+          {
+            id: 'opt_green',
+            name: 'Move to Okinawa',
+            color: 'GREEN',
+            description: '',
+          },
+        ],
+        workflowManagementStory: { id: 'wms', name: 'workflow' },
+      },
+    });
+
+    beforeEach(() => {
+      issueRepository.createNewIssue.mockResolvedValue(42);
+      issueRepository.addIssueToProject.mockResolvedValue(undefined);
+    });
+
+    it('creates the issue, adds it to the project, and sets the story', async () => {
+      const storyProject = projectWithStory();
+      const createdIssue: Issue = {
+        ...mock<Issue>(),
+        url: 'https://github.com/acme-labs/portal/issues/42',
+        itemId: 'PVTI_new',
+      };
+      issueRepository.get.mockResolvedValue(createdIssue);
+
+      const response = await handleCreateIssue(
+        contextForProject(storyProject),
+        {
+          pjcode: 'acme',
+          title: 'New task title',
+          storyOptionId: 'opt_blue',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        ok: true,
+        issueUrl: 'https://github.com/acme-labs/portal/issues/42',
+      });
+      expect(issueRepository.createNewIssue).toHaveBeenCalledWith(
+        'acme-labs',
+        'portal',
+        'New task title',
+        '',
+        [],
+        [],
+      );
+      expect(issueRepository.addIssueToProject).toHaveBeenCalledWith(
+        storyProject,
+        'https://github.com/acme-labs/portal/issues/42',
+      );
+      expect(issueRepository.updateStory).toHaveBeenCalledWith(
+        expect.objectContaining({ story: storyProject.story }),
+        createdIssue,
+        'opt_blue',
+      );
+    });
+
+    it('resolves the issue repository from a proxy url of the target repo', async () => {
+      const resolvedUrls: string[] = [];
+      const recordingContext: ConsoleOperationContext = {
+        ...contextForProject(projectWithStory()),
+        resolveIssueRepository: (url: string) => {
+          resolvedUrls.push(url);
+          return issueRepository;
+        },
+      };
+      issueRepository.get.mockResolvedValue(null);
+
+      await handleCreateIssue(recordingContext, {
+        pjcode: 'acme',
+        title: 'Task',
+        storyOptionId: 'opt_blue',
+        nameWithOwner: 'acme-labs/portal',
+      });
+
+      expect(resolvedUrls).toContain(
+        'https://github.com/acme-labs/portal/issues/0',
+      );
+    });
+
+    it('skips updateStory when get returns null after addIssueToProject', async () => {
+      issueRepository.get.mockResolvedValue(null);
+
+      const response = await handleCreateIssue(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          title: 'Task without project item',
+          storyOptionId: 'opt_green',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+
+      expect(response.statusCode).toBe(200);
+      expect(issueRepository.updateStory).not.toHaveBeenCalled();
+    });
+
+    it('rejects when title is missing', async () => {
+      const response = await handleCreateIssue(context, {
+        pjcode: 'acme',
+        storyOptionId: 'opt_blue',
+        nameWithOwner: 'acme-labs/portal',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'title is required' },
+      });
+    });
+
+    it('rejects when storyOptionId is missing', async () => {
+      const response = await handleCreateIssue(context, {
+        pjcode: 'acme',
+        title: 'Task',
+        nameWithOwner: 'acme-labs/portal',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'storyOptionId is required' },
+      });
+    });
+
+    it('rejects when nameWithOwner is missing', async () => {
+      const response = await handleCreateIssue(context, {
+        pjcode: 'acme',
+        title: 'Task',
+        storyOptionId: 'opt_blue',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'nameWithOwner is required' },
+      });
+    });
+
+    it('rejects when nameWithOwner has no slash', async () => {
+      const response = await handleCreateIssue(context, {
+        pjcode: 'acme',
+        title: 'Task',
+        storyOptionId: 'opt_blue',
+        nameWithOwner: 'noslash',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'nameWithOwner must be in owner/repo format' },
+      });
+    });
+
+    it('rejects when pjcode is not configured', async () => {
+      const response = await handleCreateIssue(context, {
+        pjcode: 'unknown',
+        title: 'Task',
+        storyOptionId: 'opt_blue',
+        nameWithOwner: 'acme-labs/portal',
+      });
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'no project configured for pjcode "unknown"' },
+      });
+    });
+
+    it('rejects when the project has no story field', async () => {
+      const projectWithoutStory: Project = { ...project, story: null };
+
+      const response = await handleCreateIssue(
+        contextForProject(projectWithoutStory),
+        {
+          pjcode: 'acme',
+          title: 'Task',
+          storyOptionId: 'opt_blue',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'project does not have a story field' },
+      });
+    });
+
+    it('rejects when the storyOptionId is not found in the project', async () => {
+      const response = await handleCreateIssue(
+        contextForProject(projectWithStory()),
+        {
+          pjcode: 'acme',
+          title: 'Task',
+          storyOptionId: 'nonexistent',
+          nameWithOwner: 'acme-labs/portal',
+        },
+      );
+      expect(response).toEqual({
+        statusCode: 400,
+        body: { error: 'story option "nonexistent" not found in project' },
+      });
+    });
+  });
 });

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

@@ -582,6 +582,69 @@ export const handleAttachmentUpload = async (
   };
 };
 
+export const handleCreateIssue = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const title = body.title;
+  const storyOptionId = body.storyOptionId;
+  const nameWithOwner = body.nameWithOwner;
+  if (!isNonEmptyString(title)) {
+    return badRequest('title is required');
+  }
+  if (!isNonEmptyString(storyOptionId)) {
+    return badRequest('storyOptionId is required');
+  }
+  if (!isNonEmptyString(nameWithOwner)) {
+    return badRequest('nameWithOwner is required');
+  }
+  const slashIndex = nameWithOwner.indexOf('/');
+  if (slashIndex <= 0 || slashIndex === nameWithOwner.length - 1) {
+    return badRequest('nameWithOwner must be in owner/repo format');
+  }
+  const org = nameWithOwner.slice(0, slashIndex);
+  const repo = nameWithOwner.slice(slashIndex + 1);
+
+  const binding = await resolveBinding(context, body);
+  if (isOperationResponse(binding)) {
+    return binding;
+  }
+  const { project } = binding;
+
+  if (project.story === null) {
+    return badRequest('project does not have a story field');
+  }
+  const storyOption = project.story.stories.find((s) => s.id === storyOptionId);
+  if (storyOption === undefined) {
+    return badRequest(`story option "${storyOptionId}" not found in project`);
+  }
+
+  const proxyUrl = `https://github.com/${nameWithOwner}/issues/0`;
+  const issueRepository = context.resolveIssueRepository(proxyUrl);
+  const issueNumber = await issueRepository.createNewIssue(
+    org,
+    repo,
+    title,
+    '',
+    [],
+    [],
+  );
+  const issueUrl = `https://github.com/${nameWithOwner}/issues/${issueNumber}`;
+
+  await issueRepository.addIssueToProject(project, issueUrl);
+
+  const addedIssue = await issueRepository.get(issueUrl, project);
+  if (addedIssue !== null) {
+    await issueRepository.updateStory(
+      { ...project, story: project.story },
+      addedIssue,
+      storyOptionId,
+    );
+  }
+
+  return { statusCode: 200, body: { ok: true, issueUrl } };
+};
+
 export const handleReviewComment = async (
   context: ConsoleOperationContext,
   body: Record<string, unknown>,

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

@@ -8,6 +8,7 @@ export const CONSOLE_LIST_TAB_NAMES: ConsoleTabName[] = [
   'failed-preparation',
   'todo-by-human',
   'todo-by-agent',
+  'stories',
 ];
 
 const UNKNOWN_STORY_SORT_INDEX = 999999;

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

@@ -336,3 +336,64 @@ test('opens the comment input with the item detail, keeps it on screen while the
   )?.height;
   expect(dockHeightAfterPosting).toBe(dockHeightBeforePosting);
 });
+
+test('renders the stories tab with non-gray stories, their open item counts, and an add-task button', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Stories').click();
+  await expect(activeTabLabel(page)).toHaveText('Stories');
+
+  const tdpmRow = page.locator('.console-story-list-row', {
+    hasText: 'TDPM Console port',
+  });
+  await expect(tdpmRow.locator('.console-story-count')).toHaveText('6');
+  await expect(
+    tdpmRow.locator('.console-op-button', { hasText: 'Add task' }),
+  ).toBeVisible();
+
+  const publishRow = page.locator('.console-story-list-row', {
+    hasText: 'Publish product documentation site',
+  });
+  await expect(publishRow.locator('.console-story-count')).toHaveText('1');
+
+  await expect(
+    page.locator('.console-story-list-row', {
+      hasText: 'regular / workflow improvement',
+    }),
+  ).toHaveCount(0);
+});
+
+test('creates an issue for a story when the add-task button and form are used', async ({
+  page,
+}) => {
+  await page.goto(harness.appRootUrl);
+
+  await tabByLabel(page, 'Stories').click();
+
+  const tdpmRow = page.locator('.console-story-list-row', {
+    hasText: 'TDPM Console port',
+  });
+  await tdpmRow.locator('.console-op-button', { hasText: 'Add task' }).click();
+
+  await page
+    .locator('.console-story-create-input')
+    .fill('New task for TDPM Console port');
+  await page
+    .locator('.console-story-create-form .console-op-button', {
+      hasText: 'Create',
+    })
+    .click();
+
+  await expect
+    .poll(() => harness.createIssueCalls.length, { timeout: 10000 })
+    .toBe(1);
+  expect(harness.createIssueCalls[0].title).toBe(
+    'New task for TDPM Console port',
+  );
+  expect(harness.createIssueCalls[0].org).toBe('HiromiShikata');
+  expect(harness.createIssueCalls[0].repo).toBe(
+    'npm-cli-github-issue-tower-defence-management',
+  );
+});

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

@@ -38,6 +38,12 @@ export type ConsoleE2eRequestChangesCall = {
   inlineCommentLocation: { line: number; side: string } | null;
 };
 
+export type ConsoleE2eCreateIssueCall = {
+  org: string;
+  repo: string;
+  title: string;
+};
+
 type ConsoleFixtureListItem = {
   number: number;
   title: string;
@@ -275,6 +281,39 @@ export const CONSOLE_E2E_TAB_ITEMS: Record<string, ConsoleFixtureListItem[]> = {
   ],
 };
 
+const CONSOLE_E2E_STORIES_SNAPSHOT = {
+  pjcode: CONSOLE_E2E_PJCODE,
+  generatedAt: '2026-06-18T01:22:09.000Z',
+  stories: [
+    {
+      storyName: 'TDPM Console port',
+      storyOptionId: '1491051e',
+      color: 'BLUE',
+      openItemCount: 6,
+    },
+    {
+      storyName: 'Publish product documentation site',
+      storyOptionId: 'f7cd5cbc',
+      color: 'GREEN',
+      openItemCount: 1,
+    },
+    {
+      storyName: 'regular / WORKFLOW BLOCKER',
+      storyOptionId: 'a3b9c4d2',
+      color: 'RED',
+      openItemCount: 1,
+    },
+  ],
+  storyOrder: [
+    'TDPM Console port',
+    'regular / workflow improvement',
+    'Publish product documentation site',
+    'regular / WORKFLOW BLOCKER',
+  ],
+  storyColors: STORY_COLORS,
+  defaultNameWithOwner: REPO_NAME_WITH_OWNER,
+};
+
 const writeFixtureData = (consoleDataOutputDir: string): void => {
   for (const [tab, items] of Object.entries(CONSOLE_E2E_TAB_ITEMS)) {
     const tabDir = path.join(consoleDataOutputDir, CONSOLE_E2E_PJCODE, tab);
@@ -284,6 +323,16 @@ const writeFixtureData = (consoleDataOutputDir: string): void => {
       JSON.stringify(buildSnapshot(items)),
     );
   }
+  const storiesTabDir = path.join(
+    consoleDataOutputDir,
+    CONSOLE_E2E_PJCODE,
+    'stories',
+  );
+  fs.mkdirSync(storiesTabDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(storiesTabDir, 'list.json'),
+    JSON.stringify(CONSOLE_E2E_STORIES_SNAPSHOT),
+  );
 };
 
 const buildE2eProject = (): Project => ({
@@ -408,13 +457,21 @@ const inlineCommentPullRequestDetail: PullRequestDetail = {
 const createStubIssueRepository = (
   reviewCommentCalls: ConsoleE2eReviewCommentCall[],
   requestChangesCalls: ConsoleE2eRequestChangesCall[],
+  createIssueCalls: ConsoleE2eCreateIssueCall[],
 ): IssueRepository => ({
   getAllIssues: () => notImplemented('getAllIssues'),
   getIssueByUrl: async (url: string): Promise<Issue | null> =>
     buildIssueForUrl(url),
   getIssueBodyByUrl: async (url: string): Promise<string | null> =>
     buildIssueForUrl(url)?.body ?? null,
-  createNewIssue: () => notImplemented('createNewIssue'),
+  createNewIssue: async (
+    org: string,
+    repo: string,
+    title: string,
+  ): Promise<number> => {
+    createIssueCalls.push({ org, repo, title });
+    return 9001;
+  },
   searchIssue: () => notImplemented('searchIssue'),
   updateIssue: () => notImplemented('updateIssue'),
   updateIssueBody: () => notImplemented('updateIssueBody'),
@@ -507,7 +564,7 @@ const createStubIssueRepository = (
   createCommentByUrl: async (): Promise<void> => undefined,
   getAllOpened: () => notImplemented('getAllOpened'),
   getStoryObjectMap: () => notImplemented('getStoryObjectMap'),
-  addIssueToProject: () => notImplemented('addIssueToProject'),
+  addIssueToProject: async (): Promise<void> => undefined,
   setDependedIssueUrl: () => notImplemented('setDependedIssueUrl'),
   getIssueOrPullRequestBody: async (): Promise<string> =>
     [
@@ -572,6 +629,7 @@ export type ConsoleE2eHarness = {
   consoleDataOutputDir: string;
   reviewCommentCalls: ConsoleE2eReviewCommentCall[];
   requestChangesCalls: ConsoleE2eRequestChangesCall[];
+  createIssueCalls: ConsoleE2eCreateIssueCall[];
   stop: () => Promise<void>;
 };
 
@@ -592,6 +650,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
 
   const reviewCommentCalls: ConsoleE2eReviewCommentCall[] = [];
   const requestChangesCalls: ConsoleE2eRequestChangesCall[] = [];
+  const createIssueCalls: ConsoleE2eCreateIssueCall[] = [];
 
   const server = await startWebServer({
     accessToken: CONSOLE_E2E_TOKEN,
@@ -600,6 +659,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     issueRepository: createStubIssueRepository(
       reviewCommentCalls,
       requestChangesCalls,
+      createIssueCalls,
     ),
     resolveProject,
     isPjcodeConfigured,
@@ -629,6 +689,7 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     consoleDataOutputDir,
     reviewCommentCalls,
     requestChangesCalls,
+    createIssueCalls,
     stop: async (): Promise<void> => {
       await closeServer(server);
       fs.rmSync(tmpRoot, { recursive: true, force: true });

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTabList.stories.tsx

@@ -26,6 +26,7 @@ const counts: Record<ConsoleTabName, number> = {
   'failed-preparation': 2,
   'todo-by-human': 66,
   'todo-by-agent': 24,
+  stories: 3,
 };
 
 export const AllTabsWithCounts: Story = {
@@ -46,6 +47,7 @@ export const ZeroCountTabsHidden: Story = {
       'failed-preparation': 0,
       'todo-by-human': 0,
       'todo-by-agent': 0,
+      stories: 0,
     },
   },
 };
@@ -61,6 +63,7 @@ export const ZeroCountActiveTabStaysVisible: Story = {
       'failed-preparation': 0,
       'todo-by-human': 0,
       'todo-by-agent': 0,
+      stories: 0,
     },
   },
 };
@@ -76,6 +79,7 @@ export const AfterAutoAdvanceToNextTab: Story = {
       'failed-preparation': 2,
       'todo-by-human': 4,
       'todo-by-agent': 0,
+      stories: 0,
     },
     onSelectTab: () => {},
   },

package/src/adapter/entry-points/console/ui/src/features/console/components/layout/ConsoleTabList.test.tsx

@@ -10,6 +10,7 @@ const counts: Record<ConsoleTabName, number> = {
   'failed-preparation': 0,
   'todo-by-human': 2,
   'todo-by-agent': 3,
+  stories: 0,
 };
 
 const baseProps = {

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

@@ -0,0 +1,77 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { ConsoleStoryList } from './ConsoleStoryList';
+
+const stories = [
+  {
+    storyName: 'TDPM Console port',
+    storyOptionId: '1491051e',
+    color: 'BLUE' as const,
+    openItemCount: 12,
+  },
+  {
+    storyName: 'Publish product documentation site',
+    storyOptionId: 'f7cd5cbc',
+    color: 'GREEN' as const,
+    openItemCount: 3,
+  },
+  {
+    storyName: 'Move to Okinawa',
+    storyOptionId: '564803ee',
+    color: 'PURPLE' as const,
+    openItemCount: 0,
+  },
+  {
+    storyName: 'regular / regular payment invoice tax',
+    storyOptionId: 'd7cdcb61',
+    color: 'YELLOW' as const,
+    openItemCount: 7,
+  },
+  {
+    storyName: 'regular / WORKFLOW BLOCKER',
+    storyOptionId: 'e35b3da2',
+    color: 'RED' as const,
+    openItemCount: 2,
+  },
+];
+
+const meta: Meta<typeof ConsoleStoryList> = {
+  title: 'Console/ConsoleStoryList',
+  component: ConsoleStoryList,
+  args: { onCreateIssue: () => Promise.resolve() },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleStoryList>;
+
+export const WithStories: Story = {
+  args: {
+    stories,
+    isLoading: false,
+    error: null,
+  },
+};
+
+export const Loading: Story = {
+  args: {
+    stories: [],
+    isLoading: true,
+    error: null,
+  },
+};
+
+export const Empty: Story = {
+  args: {
+    stories: [],
+    isLoading: false,
+    error: null,
+  },
+};
+
+export const ErrorState: Story = {
+  args: {
+    stories: [],
+    isLoading: false,
+    error: 'HTTP 404',
+  },
+};