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

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',
+  },
+};

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

@@ -0,0 +1,196 @@
+import { fireEvent, render, waitFor } from '@testing-library/react';
+import type { ConsoleStoryEntry } from '../../logic/types';
+import { ConsoleStoryList } from './ConsoleStoryList';
+
+const storyEntries: ConsoleStoryEntry[] = [
+  {
+    storyName: 'TDPM Console port',
+    storyOptionId: '1491051e',
+    color: 'BLUE',
+    openItemCount: 12,
+  },
+  {
+    storyName: 'Move to Okinawa',
+    storyOptionId: '564803ee',
+    color: 'PURPLE',
+    openItemCount: 0,
+  },
+];
+
+describe('ConsoleStoryList', () => {
+  it('renders each story name and its open item count', () => {
+    const { getByText } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    expect(getByText('TDPM Console port')).toBeInTheDocument();
+    expect(getByText('12')).toBeInTheDocument();
+    expect(getByText('Move to Okinawa')).toBeInTheDocument();
+    expect(getByText('0')).toBeInTheDocument();
+  });
+
+  it('renders an Add task button for each story row', () => {
+    const { getAllByRole } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    const buttons = getAllByRole('button', { name: 'Add task' });
+    expect(buttons).toHaveLength(storyEntries.length);
+  });
+
+  it('shows the create form when Add task is clicked', () => {
+    const { getAllByRole, getByPlaceholderText } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    const [firstButton] = getAllByRole('button', { name: 'Add task' });
+    fireEvent.click(firstButton);
+    expect(getByPlaceholderText('Issue title')).toBeInTheDocument();
+  });
+
+  it('hides the form when Add task is clicked again on the same row', () => {
+    const { getAllByRole, queryByPlaceholderText } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    const [firstButton] = getAllByRole('button', { name: 'Add task' });
+    fireEvent.click(firstButton);
+    fireEvent.click(firstButton);
+    expect(queryByPlaceholderText('Issue title')).toBeNull();
+  });
+
+  it('calls onCreateIssue with the correct storyOptionId and title', async () => {
+    const onCreateIssue = jest.fn().mockResolvedValue(undefined);
+    const { getAllByRole, getByPlaceholderText, getByRole } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={onCreateIssue}
+      />,
+    );
+    fireEvent.click(getAllByRole('button', { name: 'Add task' })[0]);
+    fireEvent.change(getByPlaceholderText('Issue title'), {
+      target: { value: 'New feature task' },
+    });
+    fireEvent.click(getByRole('button', { name: 'Create' }));
+    await waitFor(() =>
+      expect(onCreateIssue).toHaveBeenCalledWith(
+        '1491051e',
+        'New feature task',
+      ),
+    );
+  });
+
+  it('shows a validation error when Create is clicked with an empty title', () => {
+    const { getAllByRole, getByRole, getByText } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    fireEvent.click(getAllByRole('button', { name: 'Add task' })[0]);
+    fireEvent.click(getByRole('button', { name: 'Create' }));
+    expect(getByText('Title is required')).toBeInTheDocument();
+  });
+
+  it('closes the form and clears the input after a successful create', async () => {
+    const onCreateIssue = jest.fn().mockResolvedValue(undefined);
+    const {
+      getAllByRole,
+      getByPlaceholderText,
+      getByRole,
+      queryByPlaceholderText,
+    } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={onCreateIssue}
+      />,
+    );
+    fireEvent.click(getAllByRole('button', { name: 'Add task' })[0]);
+    fireEvent.change(getByPlaceholderText('Issue title'), {
+      target: { value: 'My task' },
+    });
+    fireEvent.click(getByRole('button', { name: 'Create' }));
+    await waitFor(() =>
+      expect(queryByPlaceholderText('Issue title')).toBeNull(),
+    );
+  });
+
+  it('shows an API error when onCreateIssue rejects', async () => {
+    const onCreateIssue = jest
+      .fn()
+      .mockRejectedValue(new Error('Network error'));
+    const { getAllByRole, getByPlaceholderText, getByRole, getByText } = render(
+      <ConsoleStoryList
+        stories={storyEntries}
+        isLoading={false}
+        error={null}
+        onCreateIssue={onCreateIssue}
+      />,
+    );
+    fireEvent.click(getAllByRole('button', { name: 'Add task' })[0]);
+    fireEvent.change(getByPlaceholderText('Issue title'), {
+      target: { value: 'My task' },
+    });
+    fireEvent.click(getByRole('button', { name: 'Create' }));
+    await waitFor(() => expect(getByText('Network error')).toBeInTheDocument());
+  });
+
+  it('shows a loading message when isLoading is true', () => {
+    const { getByText } = render(
+      <ConsoleStoryList
+        stories={[]}
+        isLoading={true}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    expect(getByText('Loading stories...')).toBeInTheDocument();
+  });
+
+  it('shows an empty message when there are no stories', () => {
+    const { getByText } = render(
+      <ConsoleStoryList
+        stories={[]}
+        isLoading={false}
+        error={null}
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    expect(getByText('No active stories')).toBeInTheDocument();
+  });
+
+  it('shows an error message when error is set', () => {
+    const { getByRole, getByText } = render(
+      <ConsoleStoryList
+        stories={[]}
+        isLoading={false}
+        error="HTTP 503"
+        onCreateIssue={() => Promise.resolve()}
+      />,
+    );
+    expect(getByRole('alert')).toBeInTheDocument();
+    expect(getByText(/HTTP 503/)).toBeInTheDocument();
+  });
+});

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

@@ -0,0 +1,163 @@
+import { useEffect, useRef, useState } from 'react';
+import { colorFromEnum } from '../../logic/colors';
+import type { ConsoleStoryEntry } from '../../logic/types';
+
+type StoryCreateFormProps = {
+  storyOptionId: string;
+  onSubmit: (storyOptionId: string, title: string) => Promise<void>;
+  onCancel: () => void;
+};
+
+const StoryCreateForm = ({
+  storyOptionId,
+  onSubmit,
+  onCancel,
+}: StoryCreateFormProps) => {
+  const [titleInput, setTitleInput] = useState('');
+  const [submitting, setSubmitting] = useState(false);
+  const [submitError, setSubmitError] = useState<string | null>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+
+  useEffect(() => {
+    inputRef.current?.focus();
+  }, []);
+
+  const handleSubmit = async (): Promise<void> => {
+    const trimmed = titleInput.trim();
+    if (trimmed.length === 0) {
+      setSubmitError('Title is required');
+      return;
+    }
+    setSubmitting(true);
+    setSubmitError(null);
+    try {
+      await onSubmit(storyOptionId, trimmed);
+    } catch (err) {
+      setSubmitError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <form
+      className="console-story-create-form"
+      onSubmit={(event) => {
+        event.preventDefault();
+        void handleSubmit();
+      }}
+    >
+      <input
+        ref={inputRef}
+        type="text"
+        className="console-story-create-input"
+        placeholder="Issue title"
+        value={titleInput}
+        onChange={(e) => setTitleInput(e.target.value)}
+        disabled={submitting}
+      />
+      <button type="submit" className="console-op-button" disabled={submitting}>
+        {submitting ? 'Creating…' : 'Create'}
+      </button>
+      <button
+        type="button"
+        className="console-op-button"
+        onClick={onCancel}
+        disabled={submitting}
+      >
+        Cancel
+      </button>
+      {submitError !== null && (
+        <p role="alert" className="console-list-error">
+          {submitError}
+        </p>
+      )}
+    </form>
+  );
+};
+
+export type ConsoleStoryListProps = {
+  stories: ConsoleStoryEntry[];
+  isLoading: boolean;
+  error: string | null;
+  onCreateIssue: (storyOptionId: string, title: string) => Promise<void>;
+};
+
+export const ConsoleStoryList = ({
+  stories,
+  isLoading,
+  error,
+  onCreateIssue,
+}: ConsoleStoryListProps) => {
+  const [expandedOptionId, setExpandedOptionId] = useState<string | null>(null);
+
+  if (error !== null) {
+    return (
+      <p role="alert" className="console-list-message console-list-error">
+        Failed to load stories: {error}
+      </p>
+    );
+  }
+
+  if (isLoading) {
+    return <p className="console-list-message">Loading stories...</p>;
+  }
+
+  if (stories.length === 0) {
+    return <p className="console-list-empty">No active stories</p>;
+  }
+
+  const handleAddClick = (storyOptionId: string): void => {
+    setExpandedOptionId(
+      expandedOptionId === storyOptionId ? null : storyOptionId,
+    );
+  };
+
+  const handleSubmit = async (
+    storyOptionId: string,
+    title: string,
+  ): Promise<void> => {
+    await onCreateIssue(storyOptionId, title);
+    setExpandedOptionId(null);
+  };
+
+  return (
+    <ul className="console-story-list">
+      {stories.map((entry) => {
+        const palette = colorFromEnum(entry.color);
+        const isExpanded = expandedOptionId === entry.storyOptionId;
+        return (
+          <li key={entry.storyOptionId} className="console-story-list-row">
+            <div className="console-story-list-row-main">
+              <span
+                className="console-storytag"
+                style={{ color: palette.fg, borderColor: palette.border }}
+              >
+                <span
+                  className="console-story-dot"
+                  style={{ backgroundColor: palette.dot }}
+                />
+                {entry.storyName}
+              </span>
+              <span className="console-story-count">{entry.openItemCount}</span>
+              <button
+                type="button"
+                className="console-op-button"
+                onClick={() => handleAddClick(entry.storyOptionId)}
+              >
+                Add task
+              </button>
+            </div>
+            {isExpanded && (
+              <StoryCreateForm
+                storyOptionId={entry.storyOptionId}
+                onSubmit={handleSubmit}
+                onCancel={() => setExpandedOptionId(null)}
+              />
+            )}
+          </li>
+        );
+      })}
+    </ul>
+  );
+};

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

@@ -16,6 +16,7 @@ const counts = (
   'failed-preparation': 0,
   'todo-by-human': 0,
   'todo-by-agent': 0,
+  stories: 0,
   ...overrides,
 });
 

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

@@ -3,6 +3,7 @@ import type {
   ConsoleFieldOption,
   ConsoleListItem,
   ConsoleStoryColorSource,
+  ConsoleStoryEntry,
   ConsoleTabName,
 } from '../logic/types';
 import { CONSOLE_TABS } from '../logic/types';
@@ -13,6 +14,8 @@ export type ConsoleTabSnapshot = {
   statusOptions: ConsoleFieldOption[];
   storyOptions: ConsoleFieldOption[];
   storyColors: ConsoleStoryColorSource;
+  stories: ConsoleStoryEntry[];
+  defaultNameWithOwner: string | null;
 };
 
 export type ConsoleTabDataState = {
@@ -51,6 +54,13 @@ const parseOptions = (value: unknown): ConsoleFieldOption[] => {
   return value.filter(isRecord) as unknown as ConsoleFieldOption[];
 };
 
+const parseStoryEntries = (value: unknown): ConsoleStoryEntry[] => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter(isRecord) as unknown as ConsoleStoryEntry[];
+};
+
 const parseSnapshot = (payload: unknown): ConsoleTabSnapshot => ({
   items: parseItems(payload),
   generatedAt:
@@ -63,6 +73,11 @@ const parseSnapshot = (payload: unknown): ConsoleTabSnapshot => ({
     isRecord(payload) && isRecord(payload.storyColors)
       ? (payload.storyColors as ConsoleStoryColorSource)
       : {},
+  stories: isRecord(payload) ? parseStoryEntries(payload.stories) : [],
+  defaultNameWithOwner:
+    isRecord(payload) && typeof payload.defaultNameWithOwner === 'string'
+      ? payload.defaultNameWithOwner
+      : null,
 });
 
 const emptySnapshots = (): Record<

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

@@ -339,3 +339,32 @@ export const postConsoleReviewComment = async (
     throw new Error(await readOperationErrorReason(response));
   }
 };
+
+export const CREATE_ISSUE_OPERATION_PATH = '/api/createissue';
+
+export type ConsoleCreateIssueRequest = {
+  pjcode: string;
+  title: string;
+  storyOptionId: string;
+  nameWithOwner: string;
+};
+
+export const postConsoleCreateIssue = async (
+  request: ConsoleCreateIssueRequest,
+): Promise<string> => {
+  const response = await fetch(CREATE_ISSUE_OPERATION_PATH, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(request),
+  });
+  if (!response.ok) {
+    throw new Error(await readOperationErrorReason(response));
+  }
+  const payload: unknown = await response.json();
+  const isRecord = (v: unknown): v is Record<string, unknown> =>
+    v !== null && typeof v === 'object' && !Array.isArray(v);
+  if (!isRecord(payload) || typeof payload.issueUrl !== 'string') {
+    throw new Error('issueUrl was not returned');
+  }
+  return payload.issueUrl;
+};

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

@@ -14,6 +14,7 @@ const counts = (
   'failed-preparation': 0,
   'todo-by-human': 0,
   'todo-by-agent': 0,
+  stories: 0,
   ...overrides,
 });