github-issue-tower-defence-management 1.90.0 → 1.91.1

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

@@ -0,0 +1,96 @@
+import { mock } from 'jest-mock-extended';
+import { Project } from '../../../domain/entities/Project';
+import {
+  buildPjcodeToProjectUrl,
+  createConsoleProjectResolver,
+} from './consoleProjectResolver';
+
+describe('buildPjcodeToProjectUrl', () => {
+  it('adds the default pjcode entry when it is not already present', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      { xmile: 'https://github.com/orgs/xmile/projects/2' },
+    );
+    expect(mapping).toEqual({
+      umino: 'https://github.com/orgs/umino/projects/1',
+      xmile: 'https://github.com/orgs/xmile/projects/2',
+    });
+  });
+
+  it('keeps an explicit default pjcode entry from consoleProjects', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      { umino: 'https://github.com/orgs/umino/projects/9' },
+    );
+    expect(mapping.umino).toBe('https://github.com/orgs/umino/projects/9');
+  });
+
+  it('uses only the default entry when no consoleProjects mapping is configured', () => {
+    const mapping = buildPjcodeToProjectUrl(
+      'umino',
+      'https://github.com/orgs/umino/projects/1',
+      null,
+    );
+    expect(mapping).toEqual({
+      umino: 'https://github.com/orgs/umino/projects/1',
+    });
+  });
+});
+
+describe('createConsoleProjectResolver', () => {
+  const uminoProject: Project = { ...mock<Project>(), id: 'PVT_umino' };
+  const xmileProject: Project = { ...mock<Project>(), id: 'PVT_xmile' };
+
+  it('resolves a known pjcode to its loaded project', async () => {
+    const loadProject = jest.fn(async (url: string) =>
+      url.includes('umino') ? uminoProject : xmileProject,
+    );
+    const resolver = createConsoleProjectResolver(
+      {
+        umino: 'https://github.com/orgs/umino/projects/1',
+        xmile: 'https://github.com/orgs/xmile/projects/2',
+      },
+      loadProject,
+    );
+    await expect(resolver('umino')).resolves.toEqual({
+      pjcode: 'umino',
+      project: uminoProject,
+    });
+    await expect(resolver('xmile')).resolves.toEqual({
+      pjcode: 'xmile',
+      project: xmileProject,
+    });
+  });
+
+  it('returns null for a pjcode that has no configured project url', async () => {
+    const loadProject = jest.fn(async () => uminoProject);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await expect(resolver('unknown')).resolves.toBeNull();
+    expect(loadProject).not.toHaveBeenCalled();
+  });
+
+  it('returns null when the project fails to load', async () => {
+    const loadProject = jest.fn(async () => null);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await expect(resolver('umino')).resolves.toBeNull();
+  });
+
+  it('loads each project at most once and serves later calls from cache', async () => {
+    const loadProject = jest.fn(async () => uminoProject);
+    const resolver = createConsoleProjectResolver(
+      { umino: 'https://github.com/orgs/umino/projects/1' },
+      loadProject,
+    );
+    await resolver('umino');
+    await resolver('umino');
+    expect(loadProject).toHaveBeenCalledTimes(1);
+  });
+});

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

@@ -0,0 +1,50 @@
+import { Project } from '../../../domain/entities/Project';
+import {
+  ConsoleProjectBinding,
+  ConsoleProjectResolver,
+} from './consoleOperationApi';
+
+export type ConsoleProjectLoader = (
+  projectUrl: string,
+) => Promise<Project | null>;
+
+export const buildPjcodeToProjectUrl = (
+  defaultPjcode: string,
+  defaultProjectUrl: string,
+  consoleProjects: Record<string, string> | null,
+): Record<string, string> => {
+  const mapping: Record<string, string> = {};
+  if (consoleProjects !== null) {
+    for (const [pjcode, projectUrl] of Object.entries(consoleProjects)) {
+      mapping[pjcode] = projectUrl;
+    }
+  }
+  if (!(defaultPjcode in mapping)) {
+    mapping[defaultPjcode] = defaultProjectUrl;
+  }
+  return mapping;
+};
+
+export const createConsoleProjectResolver = (
+  pjcodeToProjectUrl: Record<string, string>,
+  loadProject: ConsoleProjectLoader,
+): ConsoleProjectResolver => {
+  const cache = new Map<string, ConsoleProjectBinding>();
+  return async (pjcode: string): Promise<ConsoleProjectBinding | null> => {
+    const cached = cache.get(pjcode);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const projectUrl = pjcodeToProjectUrl[pjcode];
+    if (projectUrl === undefined) {
+      return null;
+    }
+    const project = await loadProject(projectUrl);
+    if (project === null) {
+      return null;
+    }
+    const binding: ConsoleProjectBinding = { pjcode, project };
+    cache.set(pjcode, binding);
+    return binding;
+  };
+};

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

@@ -480,7 +480,6 @@ describe('consoleServer new routes integration', () => {
       accessToken: testToken,
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: dataDir,
-      pjcode: 'umino',
       port: 0,
     });
     try {
@@ -546,9 +545,9 @@ describe('consoleServer new routes integration', () => {
       accessToken: testToken,
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: dataDir,
-      pjcode: 'umino',
       issueRepository,
-      project: buildProject(),
+      resolveProject: async (pjcode) =>
+        pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
       port: 0,
     });
     try {
@@ -557,6 +556,7 @@ describe('consoleServer new routes integration', () => {
         'POST',
         `/api/review?k=${testToken}`,
         {
+          pjcode: 'umino',
           action: 'approve',
           prUrl: 'https://github.com/o/r/pull/1',
           projectItemId: 'PVTI_op',
@@ -583,7 +583,8 @@ describe('consoleServer new routes integration', () => {
       uiDistDir: path.join(tmpDir, 'ui-dist'),
       consoleDataOutputDir: null,
       issueRepository,
-      project: buildProject(),
+      resolveProject: async (pjcode) =>
+        pjcode === 'umino' ? { pjcode, project: buildProject() } : null,
       port: 0,
     });
     try {

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

@@ -2,7 +2,6 @@ import * as http from 'http';
 import * as fs from 'fs';
 import * as path from 'path';
 import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
-import { Project } from '../../../domain/entities/Project';
 import {
   CONSOLE_LIST_TAB_NAMES,
   buildConsoleDataResponse,
@@ -19,6 +18,7 @@ import {
 } from './consoleReadApi';
 import {
   ConsoleOperationContext,
+  ConsoleProjectResolver,
   handleIntmux,
   handleReview,
   handleTriage,
@@ -153,9 +153,8 @@ export type ConsoleServerOptions = {
   accessToken: string;
   uiDistDir: string;
   consoleDataOutputDir: string | null;
-  pjcode?: string | null;
   issueRepository?: IssueRepository | null;
-  project?: Project | null;
+  resolveProject?: ConsoleProjectResolver | null;
   issueTitleStateCache?: IssueTitleStateCache | null;
 };
 
@@ -291,15 +290,14 @@ const handleOperationApi = async (
   body: Record<string, unknown>,
 ): Promise<{ statusCode: number; body: unknown } | null> => {
   const issueRepository = options.issueRepository ?? null;
-  const project = options.project ?? null;
-  if (issueRepository === null || project === null) {
+  const resolveProject = options.resolveProject ?? null;
+  if (issueRepository === null || resolveProject === null) {
     return null;
   }
   const context: ConsoleOperationContext = {
     issueRepository,
-    project,
+    resolveProject,
     consoleDataOutputDir: options.consoleDataOutputDir,
-    pjcode: options.pjcode ?? null,
   };
   switch (requestPath) {
     case '/api/review':

package/src/adapter/entry-points/console/ui/jest.setup.ts

@@ -0,0 +1 @@
+import '@testing-library/jest-dom';

package/src/adapter/entry-points/console/ui/jest.styleMock.js

@@ -0,0 +1 @@
+module.exports = {};

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMarkdownContent.stories.tsx

@@ -0,0 +1,27 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import {
+  consoleMarkdownBodyFixture,
+  consoleMermaidBodyFixture,
+} from '../../testing/fixtures';
+import { ConsoleMarkdownContent } from './ConsoleMarkdownContent';
+
+const meta: Meta<typeof ConsoleMarkdownContent> = {
+  title: 'Console/ConsoleMarkdownContent',
+  component: ConsoleMarkdownContent,
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleMarkdownContent>;
+
+export const RichMarkdown: Story = {
+  args: { body: consoleMarkdownBodyFixture },
+};
+
+export const WithMermaidFence: Story = {
+  args: { body: consoleMermaidBodyFixture },
+};
+
+export const Empty: Story = {
+  args: { body: '' },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMarkdownContent.test.tsx

@@ -0,0 +1,36 @@
+import { render, waitFor } from '@testing-library/react';
+import { ConsoleMarkdownContent } from './ConsoleMarkdownContent';
+
+jest.mock('../../lib/mermaidLoader', () => ({
+  renderMermaidToSvg: jest.fn(
+    async () => '<svg data-testid="mermaid-svg"></svg>',
+  ),
+}));
+
+describe('ConsoleMarkdownContent', () => {
+  it('renders markdown body content', () => {
+    const { container } = render(
+      <ConsoleMarkdownContent body={'## Heading\n\n- bullet'} />,
+    );
+    expect(container.querySelector('h2')).not.toBeNull();
+    expect(container.querySelector('li')).not.toBeNull();
+  });
+
+  it('shows the empty message for a blank body', () => {
+    const { getByText } = render(<ConsoleMarkdownContent body="   " />);
+    expect(getByText('No description provided.')).toBeInTheDocument();
+  });
+
+  it('renders a mermaid fence via the diagram component', async () => {
+    const { container } = render(
+      <ConsoleMarkdownContent
+        body={'intro\n\n```mermaid\ngraph TD; A-->B;\n```'}
+      />,
+    );
+    await waitFor(() => {
+      expect(
+        container.querySelector('.console-mermaid-rendered'),
+      ).not.toBeNull();
+    });
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMarkdownContent.tsx

@@ -0,0 +1,50 @@
+import { useEffect, useMemo, useRef } from 'react';
+import {
+  renderMarkdownToSafeHtml,
+  splitMarkdownSegments,
+} from '../../lib/markdown';
+import { ConsoleMermaidDiagram } from './ConsoleMermaidDiagram';
+
+export type ConsoleMarkdownViewProps = {
+  body: string;
+};
+
+type ConsoleMarkdownHtmlBlockProps = {
+  source: string;
+};
+
+const ConsoleMarkdownHtmlBlock = ({
+  source,
+}: ConsoleMarkdownHtmlBlockProps) => {
+  const html = useMemo(() => renderMarkdownToSafeHtml(source), [source]);
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    const container = containerRef.current;
+    if (container !== null) {
+      container.innerHTML = html;
+    }
+  }, [html]);
+
+  return <div ref={containerRef} className="console-markdown" />;
+};
+
+export const ConsoleMarkdownContent = ({ body }: ConsoleMarkdownViewProps) => {
+  const segments = useMemo(() => splitMarkdownSegments(body), [body]);
+
+  if (body.trim() === '') {
+    return <p className="console-markdown-empty">No description provided.</p>;
+  }
+
+  return (
+    <div className="console-markdown-view">
+      {segments.map((segment) =>
+        segment.kind === 'mermaid' ? (
+          <ConsoleMermaidDiagram key={segment.key} code={segment.code} />
+        ) : (
+          <ConsoleMarkdownHtmlBlock key={segment.key} source={segment.source} />
+        ),
+      )}
+    </div>
+  );
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMermaidDiagram.stories.tsx

@@ -0,0 +1,22 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleMermaidCodeFixture } from '../../testing/fixtures';
+import { ConsoleMermaidDiagram } from './ConsoleMermaidDiagram';
+
+const meta: Meta<typeof ConsoleMermaidDiagram> = {
+  title: 'Console/ConsoleMermaidDiagram',
+  component: ConsoleMermaidDiagram,
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleMermaidDiagram>;
+
+export const SequenceDiagram: Story = {
+  args: { code: consoleMermaidCodeFixture },
+};
+
+export const FlowDiagram: Story = {
+  args: {
+    code: 'graph TD;\n  Start-->Fetch;\n  Fetch-->Render;\n  Render-->Done;',
+  },
+};

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMermaidDiagram.test.tsx

@@ -0,0 +1,38 @@
+import { render, waitFor } from '@testing-library/react';
+import { renderMermaidToSvg } from '../../lib/mermaidLoader';
+import { ConsoleMermaidDiagram } from './ConsoleMermaidDiagram';
+
+jest.mock('../../lib/mermaidLoader', () => ({
+  renderMermaidToSvg: jest.fn(),
+}));
+
+const mockedRender = renderMermaidToSvg as jest.MockedFunction<
+  typeof renderMermaidToSvg
+>;
+
+describe('ConsoleMermaidDiagram', () => {
+  beforeEach(() => {
+    mockedRender.mockReset();
+  });
+
+  it('renders the sanitized svg once ready', async () => {
+    mockedRender.mockResolvedValue('<svg id="ok"></svg>');
+    const { container } = render(
+      <ConsoleMermaidDiagram code="graph TD; A-->B;" />,
+    );
+    await waitFor(() => {
+      expect(container.querySelector('svg#ok')).not.toBeNull();
+    });
+  });
+
+  it('shows the source and an error note when rendering fails', async () => {
+    mockedRender.mockRejectedValue(new Error('parse error'));
+    const { getByText } = render(<ConsoleMermaidDiagram code="bad diagram" />);
+    await waitFor(() => {
+      expect(
+        getByText(/Mermaid render error: parse error/),
+      ).toBeInTheDocument();
+    });
+    expect(getByText('bad diagram')).toBeInTheDocument();
+  });
+});

package/src/adapter/entry-points/console/ui/src/features/console/components/content/ConsoleMermaidDiagram.tsx

@@ -0,0 +1,65 @@
+import { useEffect, useRef, useState } from 'react';
+import { renderMermaidToSvg } from '../../lib/mermaidLoader';
+
+export type ConsoleMermaidDiagramProps = {
+  code: string;
+};
+
+type MermaidRenderState =
+  | { status: 'loading' }
+  | { status: 'ready'; svg: string }
+  | { status: 'error'; message: string };
+
+export const ConsoleMermaidDiagram = ({ code }: ConsoleMermaidDiagramProps) => {
+  const [state, setState] = useState<MermaidRenderState>({ status: 'loading' });
+  const containerRef = useRef<HTMLDivElement>(null);
+
+  useEffect(() => {
+    let cancelled = false;
+    setState({ status: 'loading' });
+    renderMermaidToSvg(code)
+      .then((svg) => {
+        if (!cancelled) {
+          setState({ status: 'ready', svg });
+        }
+      })
+      .catch((cause: unknown) => {
+        if (!cancelled) {
+          setState({
+            status: 'error',
+            message: cause instanceof Error ? cause.message : String(cause),
+          });
+        }
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [code]);
+
+  useEffect(() => {
+    const container = containerRef.current;
+    if (container === null) {
+      return;
+    }
+    container.innerHTML = state.status === 'ready' ? state.svg : '';
+  }, [state]);
+
+  if (state.status === 'loading') {
+    return <div className="console-mermaid-loading">Rendering diagram...</div>;
+  }
+
+  if (state.status === 'error') {
+    return (
+      <div className="console-mermaid">
+        <div className="console-mermaid-error">
+          Mermaid render error: {state.message}
+        </div>
+        <pre className="console-mermaid-source">
+          <code>{code}</code>
+        </pre>
+      </div>
+    );
+  }
+
+  return <div ref={containerRef} className="console-mermaid-rendered" />;
+};

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

@@ -0,0 +1,28 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleChangedFilesFixture } from '../../testing/fixtures';
+import { ConsoleChangedFileList } from './ConsoleChangedFileList';
+
+const meta: Meta<typeof ConsoleChangedFileList> = {
+  title: 'Console/ConsoleChangedFileList',
+  component: ConsoleChangedFileList,
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleChangedFileList>;
+
+export const WithFiles: Story = {
+  args: { files: consoleChangedFilesFixture, isLoading: false, error: null },
+};
+
+export const Loading: Story = {
+  args: { files: [], isLoading: true, error: null },
+};
+
+export const Empty: Story = {
+  args: { files: [], isLoading: false, error: null },
+};
+
+export const ErrorState: Story = {
+  args: { files: [], isLoading: false, error: 'HTTP 502' },
+};

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

@@ -0,0 +1,42 @@
+import { render } from '@testing-library/react';
+import { consoleChangedFilesFixture } from '../../testing/fixtures';
+import { ConsoleChangedFileList } from './ConsoleChangedFileList';
+
+describe('ConsoleChangedFileList', () => {
+  it('renders each file path, status badge and additions/deletions', () => {
+    const { getByText, getAllByText } = render(
+      <ConsoleChangedFileList
+        files={consoleChangedFilesFixture}
+        isLoading={false}
+        error={null}
+      />,
+    );
+    expect(
+      getByText('src/adapter/entry-points/console/consoleServer.ts'),
+    ).toBeInTheDocument();
+    expect(getByText('+312')).toBeInTheDocument();
+    expect(getAllByText('A').length).toBe(2);
+    expect(getByText('M')).toBeInTheDocument();
+  });
+
+  it('shows the loading state', () => {
+    const { getByText } = render(
+      <ConsoleChangedFileList files={[]} isLoading error={null} />,
+    );
+    expect(getByText('Loading changed files...')).toBeInTheDocument();
+  });
+
+  it('shows the empty state', () => {
+    const { getByText } = render(
+      <ConsoleChangedFileList files={[]} isLoading={false} error={null} />,
+    );
+    expect(getByText('No changed files.')).toBeInTheDocument();
+  });
+
+  it('shows the error state', () => {
+    const { getByRole } = render(
+      <ConsoleChangedFileList files={[]} isLoading={false} error="HTTP 502" />,
+    );
+    expect(getByRole('alert')).toHaveTextContent('HTTP 502');
+  });
+});

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

@@ -0,0 +1,55 @@
+import { fileStatusBadge } from '../../logic/fileStatus';
+import type { ConsoleChangedFile } from '../../logic/types';
+
+export type ConsoleChangedFileListProps = {
+  files: ConsoleChangedFile[];
+  isLoading: boolean;
+  error: string | null;
+};
+
+export const ConsoleChangedFileList = ({
+  files,
+  isLoading,
+  error,
+}: ConsoleChangedFileListProps) => {
+  if (error !== null) {
+    return (
+      <p role="alert" className="console-files-error">
+        Failed to load changed files: {error}
+      </p>
+    );
+  }
+
+  if (isLoading) {
+    return <p className="console-files-loading">Loading changed files...</p>;
+  }
+
+  if (files.length === 0) {
+    return <p className="console-files-empty">No changed files.</p>;
+  }
+
+  return (
+    <ul className="console-files">
+      {files.map((file) => {
+        const badge = fileStatusBadge(file.status);
+        return (
+          <li key={file.path} className="console-file">
+            <span
+              className="console-file-badge"
+              style={{ color: badge.color, borderColor: badge.color }}
+            >
+              {badge.label}
+            </span>
+            <span className="console-file-path">{file.path}</span>
+            <span className="console-file-stat console-file-add">
+              +{file.additions}
+            </span>
+            <span className="console-file-stat console-file-del">
+              -{file.deletions}
+            </span>
+          </li>
+        );
+      })}
+    </ul>
+  );
+};

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

@@ -0,0 +1,29 @@
+import type { Meta, StoryObj } from '@storybook/react-vite';
+import { consoleCommentsFixture } from '../../testing/fixtures';
+import { ConsoleCommentList } from './ConsoleCommentList';
+
+const meta: Meta<typeof ConsoleCommentList> = {
+  title: 'Console/ConsoleCommentList',
+  component: ConsoleCommentList,
+  args: { now: Date.parse('2026-06-19T12:00:00.000Z') },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof ConsoleCommentList>;
+
+export const WithComments: Story = {
+  args: { comments: consoleCommentsFixture, isLoading: false, error: null },
+};
+
+export const Loading: Story = {
+  args: { comments: [], isLoading: true, error: null },
+};
+
+export const Empty: Story = {
+  args: { comments: [], isLoading: false, error: null },
+};
+
+export const ErrorState: Story = {
+  args: { comments: [], isLoading: false, error: 'HTTP 500' },
+};