github-issue-tower-defence-management 2.19.1 → 2.19.2

package/src/adapter/entry-points/function/getStoryObjectMap.ts

@@ -1,3 +0,0 @@
-import { GetStoryObjectMapUseCaseHandler } from '../handlers/GetStoryObjectMapUseCaseHandler';
-
-export const getStoryObjectMap = new GetStoryObjectMapUseCaseHandler().handle;

package/src/adapter/entry-points/handlers/FileSystemConsoleTabsRepository.test.ts

@@ -1,218 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { FileSystemConsoleTabsRepository } from './FileSystemConsoleTabsRepository';
-import { readDoneProjectItemIds } from '../console/consoleDoneStore';
-import type { ConsoleListItem } from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
-
-const makeItem = (
-  overrides: Partial<ConsoleListItem> = {},
-): ConsoleListItem => ({
-  number: 1,
-  title: 'Test Issue',
-  url: 'https://github.com/user/repo/issues/1',
-  repo: 'user/repo',
-  nameWithOwner: 'user/repo',
-  projectItemId: 'item-1',
-  itemId: 'item-1',
-  isPr: false,
-  story: 'Story A',
-  status: 'Awaiting Quality Check',
-  agent: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  dependedIssueUrls: [],
-  labels: [],
-  createdAt: new Date('2024-01-01T00:00:00Z').toISOString(),
-  relatedOpenPullRequestUrls: [],
-  ...overrides,
-});
-
-const makeStatusTab = (
-  pjcode: string,
-  items: ConsoleListItem[],
-  storyOrder: string[] = ['Story A', 'Story B'],
-) => ({
-  pjcode,
-  generatedAt: '2026-08-16T04:19:32Z',
-  statusOptions: [],
-  storyOrder,
-  storyColors: {},
-  items,
-});
-
-describe('FileSystemConsoleTabsRepository', () => {
-  let dir: string;
-  const PJCODE = 'test-project';
-
-  beforeEach(() => {
-    dir = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'console-tabs-repository-test-'),
-    );
-  });
-
-  afterEach(() => {
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-
-  const writeTabFile = (tab: string, data: unknown): void => {
-    const tabDir = path.join(dir, PJCODE, tab);
-    fs.mkdirSync(tabDir, { recursive: true });
-    fs.writeFileSync(path.join(tabDir, 'list.json'), JSON.stringify(data));
-  };
-
-  const readTabFile = (tab: string): unknown => {
-    const filePath = path.join(dir, PJCODE, tab, 'list.json');
-    const data: unknown = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-    return data;
-  };
-
-  it('inserts the item into the prs tab when transitioning to Awaiting Quality Check', () => {
-    writeTabFile('prs', makeStatusTab(PJCODE, []));
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem({ status: 'Awaiting Quality Check' });
-
-    repo.patchIssueTabTransition({
-      projectItemId: item.projectItemId,
-      item,
-      targetTabName: 'prs',
-    });
-
-    expect(readTabFile('prs')).toMatchObject({
-      items: [{ projectItemId: 'item-1' }],
-    });
-  });
-
-  it('preserves generatedAt in the patched tab file', () => {
-    writeTabFile('prs', makeStatusTab(PJCODE, []));
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem();
-
-    repo.patchIssueTabTransition({
-      projectItemId: item.projectItemId,
-      item,
-      targetTabName: 'prs',
-    });
-
-    expect(readTabFile('prs')).toHaveProperty(
-      'generatedAt',
-      '2026-08-16T04:19:32Z',
-    );
-  });
-
-  it('removes the item from any tab it previously appeared in', () => {
-    const existingItem = makeItem({ projectItemId: 'item-1' });
-    writeTabFile('todo-by-human', makeStatusTab(PJCODE, [existingItem]));
-    writeTabFile('prs', makeStatusTab(PJCODE, []));
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem({ status: 'Awaiting Quality Check' });
-
-    repo.patchIssueTabTransition({
-      projectItemId: 'item-1',
-      item,
-      targetTabName: 'prs',
-    });
-
-    expect(readTabFile('todo-by-human')).toMatchObject({ items: [] });
-    expect(readTabFile('prs')).toMatchObject({
-      items: [{ projectItemId: 'item-1' }],
-    });
-  });
-
-  it('removes the projectItemId from the target tab .done.json', () => {
-    writeTabFile('prs', makeStatusTab(PJCODE, []));
-    const doneFilePath = path.join(dir, PJCODE, 'prs', '.done.json');
-    fs.writeFileSync(
-      doneFilePath,
-      JSON.stringify({ projectItemIds: ['item-1', 'item-2'] }),
-    );
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem();
-
-    repo.patchIssueTabTransition({
-      projectItemId: 'item-1',
-      item,
-      targetTabName: 'prs',
-    });
-
-    const ids = readDoneProjectItemIds(dir, PJCODE, 'prs');
-    expect(ids).not.toContain('item-1');
-    expect(ids).toContain('item-2');
-  });
-
-  it('is a no-op when the target tab file does not exist', () => {
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem();
-
-    expect(() =>
-      repo.patchIssueTabTransition({
-        projectItemId: item.projectItemId,
-        item,
-        targetTabName: 'prs',
-      }),
-    ).not.toThrow();
-    expect(fs.existsSync(path.join(dir, PJCODE, 'prs', 'list.json'))).toBe(
-      false,
-    );
-  });
-
-  it('removes the item from any tab and writes nothing when targetTabName is null', () => {
-    const existingItem = makeItem({ projectItemId: 'item-1' });
-    writeTabFile('prs', makeStatusTab(PJCODE, [existingItem]));
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem({ status: 'Awaiting Workspace' });
-
-    repo.patchIssueTabTransition({
-      projectItemId: 'item-1',
-      item,
-      targetTabName: null,
-    });
-
-    expect(readTabFile('prs')).toMatchObject({ items: [] });
-  });
-
-  it('maintains story order after inserting the new item', () => {
-    const itemInStoryB = makeItem({
-      projectItemId: 'item-2',
-      story: 'Story B',
-    });
-    writeTabFile('prs', makeStatusTab(PJCODE, [itemInStoryB]));
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem({
-      projectItemId: 'item-1',
-      story: 'Story A',
-      status: 'Awaiting Quality Check',
-    });
-
-    repo.patchIssueTabTransition({
-      projectItemId: 'item-1',
-      item,
-      targetTabName: 'prs',
-    });
-
-    expect(readTabFile('prs')).toMatchObject({
-      items: [{ story: 'Story A' }, { story: 'Story B' }],
-    });
-  });
-
-  it('does not write to tab files that do not contain the item when targetTabName is null', () => {
-    const otherItem = makeItem({ projectItemId: 'item-99' });
-    writeTabFile('prs', makeStatusTab(PJCODE, [otherItem]));
-    const mtimeBefore = fs.statSync(
-      path.join(dir, PJCODE, 'prs', 'list.json'),
-    ).mtimeMs;
-    const repo = new FileSystemConsoleTabsRepository(dir, PJCODE);
-    const item = makeItem({ projectItemId: 'item-1' });
-
-    repo.patchIssueTabTransition({
-      projectItemId: 'item-1',
-      item,
-      targetTabName: null,
-    });
-
-    const mtimeAfter = fs.statSync(
-      path.join(dir, PJCODE, 'prs', 'list.json'),
-    ).mtimeMs;
-    expect(mtimeAfter).toBe(mtimeBefore);
-  });
-});

package/src/adapter/entry-points/handlers/FileSystemConsoleTabsRepository.ts

@@ -1,113 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import type {
-  ConsoleListItem,
-  ConsoleTabName,
-} from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
-import type { ConsoleTabsRepository } from '../../../domain/usecases/adapter-interfaces/ConsoleTabsRepository';
-import {
-  CONSOLE_LIST_TAB_NAMES,
-  sortByStoryOrder,
-} from '../console/consoleTabNames';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-const writeJsonAtomic = (filePath: string, data: unknown): void => {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(data));
-  fs.renameSync(tmpPath, filePath);
-};
-
-const readTabListJson = (filePath: string): Record<string, unknown> | null => {
-  try {
-    const raw = fs.readFileSync(filePath, 'utf-8');
-    const parsed: unknown = JSON.parse(raw);
-    if (!isRecord(parsed) || !Array.isArray(parsed.items)) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-};
-
-const clearProjectItemIdFromDoneJson = (
-  doneFilePath: string,
-  projectItemId: string,
-): void => {
-  let existingIds: string[] = [];
-  try {
-    const raw = fs.readFileSync(doneFilePath, 'utf-8');
-    const parsed: unknown = JSON.parse(raw);
-    if (isRecord(parsed)) {
-      const rawIds = parsed.projectItemIds;
-      if (Array.isArray(rawIds)) {
-        existingIds = rawIds.filter(
-          (id): id is string => typeof id === 'string',
-        );
-      }
-    }
-  } catch {
-    // File does not exist; start with empty list
-  }
-  writeJsonAtomic(doneFilePath, {
-    projectItemIds: existingIds.filter((id) => id !== projectItemId),
-  });
-};
-
-export class FileSystemConsoleTabsRepository implements ConsoleTabsRepository {
-  constructor(
-    private readonly consoleDataOutputDir: string,
-    private readonly pjcode: string,
-  ) {}
-
-  patchIssueTabTransition(params: {
-    projectItemId: string;
-    item: ConsoleListItem;
-    targetTabName: ConsoleTabName | null;
-  }): void {
-    const { projectItemId, item, targetTabName } = params;
-
-    for (const tabName of CONSOLE_LIST_TAB_NAMES) {
-      const filePath = path.join(
-        this.consoleDataOutputDir,
-        this.pjcode,
-        tabName,
-        'list.json',
-      );
-      const existing = readTabListJson(filePath);
-      if (existing === null) {
-        continue;
-      }
-
-      const rawItems = existing.items;
-      const items: unknown[] = Array.isArray(rawItems) ? rawItems : [];
-      const withoutThisItem = items.filter(
-        (i) => !(isRecord(i) && i.projectItemId === projectItemId),
-      );
-
-      if (tabName === targetTabName) {
-        const rawStoryOrder = existing.storyOrder;
-        const storyOrder = Array.isArray(rawStoryOrder)
-          ? rawStoryOrder.filter((s): s is string => typeof s === 'string')
-          : [];
-        const newItems = sortByStoryOrder(
-          [...withoutThisItem, item],
-          storyOrder,
-        );
-        writeJsonAtomic(filePath, { ...existing, items: newItems });
-        const doneFilePath = path.join(
-          this.consoleDataOutputDir,
-          this.pjcode,
-          tabName,
-          '.done.json',
-        );
-        clearProjectItemIdFromDoneJson(doneFilePath, projectItemId);
-      } else if (withoutThisItem.length !== items.length) {
-        writeJsonAtomic(filePath, { ...existing, items: withoutThisItem });
-      }
-    }
-  }
-}

package/src/adapter/entry-points/handlers/GetStoryObjectMapUseCaseHandler.test.ts

@@ -1,110 +0,0 @@
-import fs from 'fs';
-import YAML from 'yaml';
-
-jest.mock('fs');
-jest.mock('../../repositories/LocalStorageRepository');
-jest.mock('../../repositories/GraphqlProjectRepository');
-jest.mock('../../repositories/issue/ApiV3IssueRepository');
-jest.mock('../../repositories/issue/RestIssueRepository');
-jest.mock('../../repositories/issue/GraphqlProjectItemRepository');
-jest.mock('../../repositories/issue/ApiV3CheerioRestIssueRepository');
-jest.mock('../../repositories/LocalStorageCacheRepository');
-jest.mock('../../repositories/BaseGitHubRepository');
-
-const mockRun = jest.fn().mockResolvedValue({
-  project: {},
-  issues: [],
-  cacheUsed: false,
-  storyObjectMap: new Map(),
-});
-
-jest.mock('../../../domain/usecases/GetStoryObjectMapUseCase', () => ({
-  GetStoryObjectMapUseCase: jest.fn().mockImplementation(() => ({
-    run: mockRun,
-  })),
-}));
-
-import { GetStoryObjectMapUseCaseHandler } from './GetStoryObjectMapUseCaseHandler';
-import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
-import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
-import { RestIssueRepository } from '../../repositories/issue/RestIssueRepository';
-import { GraphqlProjectItemRepository } from '../../repositories/issue/GraphqlProjectItemRepository';
-import { ApiV3CheerioRestIssueRepository } from '../../repositories/issue/ApiV3CheerioRestIssueRepository';
-
-const MockedGraphqlProjectRepository = jest.mocked(GraphqlProjectRepository);
-const MockedApiV3IssueRepository = jest.mocked(ApiV3IssueRepository);
-const MockedRestIssueRepository = jest.mocked(RestIssueRepository);
-const MockedGraphqlProjectItemRepository = jest.mocked(
-  GraphqlProjectItemRepository,
-);
-const MockedApiV3CheerioRestIssueRepository = jest.mocked(
-  ApiV3CheerioRestIssueRepository,
-);
-
-const validConfig = {
-  projectUrl: 'https://github.com/orgs/test/projects/1',
-  projectName: 'test-project',
-  credentials: {
-    bot: {
-      github: {
-        token: 'test-token',
-      },
-    },
-  },
-};
-
-describe('GetStoryObjectMapUseCaseHandler', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify(validConfig));
-  });
-
-  it('should throw when required credential fields are missing from config', async () => {
-    jest.mocked(fs.readFileSync).mockReturnValue(YAML.stringify({}));
-    const handler = new GetStoryObjectMapUseCaseHandler();
-    await expect(handler.handle('config.yml', false)).rejects.toThrow(
-      'Invalid input',
-    );
-  });
-
-  it('should pass the parsed config to the use case', async () => {
-    const handler = new GetStoryObjectMapUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    expect(mockRun).toHaveBeenCalledWith(
-      expect.objectContaining({
-        projectUrl: 'https://github.com/orgs/test/projects/1',
-      }),
-    );
-  });
-
-  it('should pass bot token to repository constructors', async () => {
-    const handler = new GetStoryObjectMapUseCaseHandler();
-    await handler.handle('config.yml', false);
-
-    for (const MockedClass of [
-      MockedApiV3IssueRepository,
-      MockedRestIssueRepository,
-      MockedGraphqlProjectItemRepository,
-    ]) {
-      expect(MockedClass).toHaveBeenCalledWith(expect.anything(), 'test-token');
-    }
-
-    expect(MockedGraphqlProjectRepository).toHaveBeenCalledWith(
-      expect.anything(),
-      'test-token',
-      expect.anything(),
-    );
-
-    expect(MockedApiV3CheerioRestIssueRepository).toHaveBeenCalledWith(
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      expect.anything(),
-      'test-token',
-    );
-  });
-});

package/src/adapter/entry-points/handlers/GetStoryObjectMapUseCaseHandler.ts

@@ -1,116 +0,0 @@
-import YAML from 'yaml';
-import fs from 'fs';
-import { LocalStorageRepository } from '../../repositories/LocalStorageRepository';
-import { GraphqlProjectRepository } from '../../repositories/GraphqlProjectRepository';
-import { ApiV3IssueRepository } from '../../repositories/issue/ApiV3IssueRepository';
-import { RestIssueRepository } from '../../repositories/issue/RestIssueRepository';
-import { GraphqlProjectItemRepository } from '../../repositories/issue/GraphqlProjectItemRepository';
-import { ApiV3CheerioRestIssueRepository } from '../../repositories/issue/ApiV3CheerioRestIssueRepository';
-import { LocalStorageCacheRepository } from '../../repositories/LocalStorageCacheRepository';
-import { projectCacheDirectory } from '../../repositories/localStorageCacheDirectory';
-import { SystemDateRepository } from '../../repositories/SystemDateRepository';
-import { Issue } from '../../../domain/entities/Issue';
-import { Project } from '../../../domain/entities/Project';
-import { BaseGitHubRepository } from '../../repositories/BaseGitHubRepository';
-import { GetStoryObjectMapUseCase } from '../../../domain/usecases/GetStoryObjectMapUseCase';
-import { StoryObjectMap } from '../../../domain/entities/StoryObjectMap';
-
-export class GetStoryObjectMapUseCaseHandler {
-  handle = async (
-    configFilePath: string,
-    _verbose: boolean,
-  ): Promise<{
-    project: Project;
-    issues: Issue[];
-    cacheUsed: boolean;
-    storyObjectMap: StoryObjectMap;
-  }> => {
-    const configFileContent = fs.readFileSync(configFilePath, 'utf8');
-    const input: unknown = YAML.parse(configFileContent);
-    type inputType = Parameters<GetStoryObjectMapUseCase['run']>[0] & {
-      projectName: string;
-      credentials: {
-        bot: {
-          github: {
-            token: string;
-          };
-        };
-      };
-    };
-
-    const isInputType = (v: unknown): v is inputType => {
-      if (typeof v !== 'object' || v === null) return false;
-      if (!('projectName' in v) || typeof v.projectName !== 'string')
-        return false;
-      if (
-        !('credentials' in v) ||
-        typeof v.credentials !== 'object' ||
-        v.credentials === null
-      )
-        return false;
-      const credentials = v.credentials;
-      if (
-        !('bot' in credentials) ||
-        typeof credentials.bot !== 'object' ||
-        credentials.bot === null
-      )
-        return false;
-      const bot = credentials.bot;
-      if (
-        !('github' in bot) ||
-        typeof bot.github !== 'object' ||
-        bot.github === null
-      )
-        return false;
-      const github = bot.github;
-      if (!('token' in github) || typeof github.token !== 'string')
-        return false;
-      return true;
-    };
-    if (!isInputType(input)) {
-      throw new Error(
-        `Invalid input: required fields projectName and credentials.bot.github.token must be strings. Got: ${JSON.stringify(input)}`,
-      );
-    }
-    const localStorageRepository = new LocalStorageRepository();
-    const cachePath = projectCacheDirectory(input.projectName);
-    const localStorageCacheRepository = new LocalStorageCacheRepository(
-      localStorageRepository,
-      cachePath,
-    );
-    const githubRepositoryParams: ConstructorParameters<
-      typeof BaseGitHubRepository
-    > = [localStorageRepository, input.credentials.bot.github.token];
-    const projectRepository = {
-      ...new GraphqlProjectRepository(
-        ...githubRepositoryParams,
-        localStorageCacheRepository,
-      ),
-    };
-    const apiV3IssueRepository = new ApiV3IssueRepository(
-      ...githubRepositoryParams,
-    );
-    const restIssueRepository = new RestIssueRepository(
-      ...githubRepositoryParams,
-    );
-    const graphqlProjectItemRepository = new GraphqlProjectItemRepository(
-      ...githubRepositoryParams,
-    );
-    const issueRepository = new ApiV3CheerioRestIssueRepository(
-      apiV3IssueRepository,
-      restIssueRepository,
-      graphqlProjectItemRepository,
-      localStorageCacheRepository,
-      projectRepository,
-      new SystemDateRepository(),
-      ...githubRepositoryParams,
-    );
-
-    const getStoryObjectMapUseCase = new GetStoryObjectMapUseCase(
-      projectRepository,
-      issueRepository,
-    );
-
-    return await getStoryObjectMapUseCase.run(input);
-  };
-}