github-issue-tower-defence-management 1.87.0 → 1.88.1

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

@@ -0,0 +1,184 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  buildConsoleDataResponse,
+  parseConsoleDataRoute,
+} from './consoleDataDelivery';
+import { recordDoneProjectItemId } from './consoleDoneStore';
+
+describe('parseConsoleDataRoute', () => {
+  it('parses a list route', () => {
+    expect(parseConsoleDataRoute('/projects/umino/prs/list.json')).toEqual({
+      kind: 'list',
+      pjcode: 'umino',
+      tab: 'prs',
+    });
+  });
+
+  it('parses a list route for todo-by-human', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/todo-by-human/list.json'),
+    ).toEqual({ kind: 'list', pjcode: 'umino', tab: 'todo-by-human' });
+  });
+
+  it('parses a detail route', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/triage/detail/123.json'),
+    ).toEqual({
+      kind: 'detail',
+      pjcode: 'umino',
+      tab: 'triage',
+      key: '123.json',
+    });
+  });
+
+  it('parses an in-tmux route', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/in-tmux-by-human/list.json'),
+    ).toEqual({
+      kind: 'in-tmux',
+      pjcode: 'umino',
+      relativePath: 'list.json',
+    });
+  });
+
+  it('parses a nested in-tmux route', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/in-tmux-by-human/sub/data.json'),
+    ).toEqual({
+      kind: 'in-tmux',
+      pjcode: 'umino',
+      relativePath: 'sub/data.json',
+    });
+  });
+
+  it('rejects unknown tabs', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/unknown/list.json'),
+    ).toBeNull();
+  });
+
+  it('rejects a non-projects prefix', () => {
+    expect(parseConsoleDataRoute('/other/umino/prs/list.json')).toBeNull();
+  });
+
+  it('rejects dot segments in pjcode or tab', () => {
+    expect(parseConsoleDataRoute('/projects/../prs/list.json')).toBeNull();
+    expect(parseConsoleDataRoute('/projects/umino/../list.json')).toBeNull();
+  });
+
+  it('rejects a non-json detail key', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/prs/detail/123.txt'),
+    ).toBeNull();
+  });
+
+  it('rejects an empty in-tmux relative path', () => {
+    expect(
+      parseConsoleDataRoute('/projects/umino/in-tmux-by-human'),
+    ).toBeNull();
+  });
+});
+
+describe('buildConsoleDataResponse', () => {
+  let baseDir: string;
+
+  beforeEach(() => {
+    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-data-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  });
+
+  const writeJson = (relativePath: string, data: unknown): void => {
+    const filePath = path.join(baseDir, relativePath);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(data));
+  };
+
+  it('returns 404 when the list file is absent', () => {
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'list',
+      pjcode: 'umino',
+      tab: 'prs',
+    });
+    expect(response.statusCode).toBe(404);
+  });
+
+  it('serves a list file and applies the done exclusion', () => {
+    writeJson('umino/prs/list.json', {
+      pjcode: 'umino',
+      items: [
+        { projectItemId: 'PVTI_1', title: 'keep' },
+        { projectItemId: 'PVTI_2', title: 'drop' },
+      ],
+    });
+    recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_2');
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'list',
+      pjcode: 'umino',
+      tab: 'prs',
+    });
+    expect(response.statusCode).toBe(200);
+    const parsed: unknown = JSON.parse(response.body);
+    expect(parsed).toEqual({
+      pjcode: 'umino',
+      items: [{ projectItemId: 'PVTI_1', title: 'keep' }],
+    });
+  });
+
+  it('serves a list file without an items array unchanged', () => {
+    writeJson('umino/prs/list.json', { pjcode: 'umino' });
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'list',
+      pjcode: 'umino',
+      tab: 'prs',
+    });
+    expect(response.statusCode).toBe(200);
+    expect(JSON.parse(response.body)).toEqual({ pjcode: 'umino' });
+  });
+
+  it('serves a detail file without exclusion', () => {
+    writeJson('umino/triage/detail/123.json', { number: 123 });
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'detail',
+      pjcode: 'umino',
+      tab: 'triage',
+      key: '123.json',
+    });
+    expect(response.statusCode).toBe(200);
+    expect(JSON.parse(response.body)).toEqual({ number: 123 });
+  });
+
+  it('returns 404 when the detail file is absent', () => {
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'detail',
+      pjcode: 'umino',
+      tab: 'triage',
+      key: '404.json',
+    });
+    expect(response.statusCode).toBe(404);
+  });
+
+  it('serves an in-tmux file', () => {
+    writeJson('umino/in-tmux-by-human/list.json', { items: [] });
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'in-tmux',
+      pjcode: 'umino',
+      relativePath: 'list.json',
+    });
+    expect(response.statusCode).toBe(200);
+    expect(JSON.parse(response.body)).toEqual({ items: [] });
+  });
+
+  it('returns 404 when the in-tmux file is absent', () => {
+    const response = buildConsoleDataResponse(baseDir, {
+      kind: 'in-tmux',
+      pjcode: 'umino',
+      relativePath: 'missing.json',
+    });
+    expect(response.statusCode).toBe(404);
+  });
+});

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

@@ -0,0 +1,169 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { readDoneProjectItemIds } from './consoleDoneStore';
+
+export const CONSOLE_LIST_TAB_NAMES: string[] = [
+  'prs',
+  'triage',
+  'unread',
+  'failed-preparation',
+  'todo-by-human',
+];
+
+export type ConsoleDataRoute =
+  | { kind: 'list'; pjcode: string; tab: string }
+  | { kind: 'detail'; pjcode: string; tab: string; key: string }
+  | { kind: 'in-tmux'; pjcode: string; relativePath: string };
+
+const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/;
+
+const isSafeSegment = (segment: string): boolean =>
+  SAFE_SEGMENT.test(segment) && !segment.startsWith('.');
+
+export const parseConsoleDataRoute = (
+  requestPath: string,
+): ConsoleDataRoute | null => {
+  const segments = requestPath
+    .split('/')
+    .filter((segment) => segment.length > 0);
+  if (segments.length < 3 || segments[0] !== 'projects') {
+    return null;
+  }
+  const pjcode = segments[1];
+  if (!isSafeSegment(pjcode)) {
+    return null;
+  }
+  const tab = segments[2];
+  if (!isSafeSegment(tab)) {
+    return null;
+  }
+  if (tab === 'in-tmux-by-human') {
+    const rest = segments.slice(3);
+    if (rest.length === 0 || rest.some((segment) => !isSafeSegment(segment))) {
+      return null;
+    }
+    return { kind: 'in-tmux', pjcode, relativePath: rest.join('/') };
+  }
+  if (!CONSOLE_LIST_TAB_NAMES.includes(tab)) {
+    return null;
+  }
+  if (segments.length === 4 && segments[3] === 'list.json') {
+    return { kind: 'list', pjcode, tab };
+  }
+  if (segments.length === 5 && segments[3] === 'detail') {
+    const key = segments[4];
+    if (!isSafeSegment(key) || !key.endsWith('.json')) {
+      return null;
+    }
+    return { kind: 'detail', pjcode, tab, key };
+  }
+  return null;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+type ReadJsonResult = { found: false } | { found: true; data: unknown };
+
+const readJsonFile = (filePath: string): ReadJsonResult => {
+  let raw: string;
+  try {
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+      return { found: false };
+    }
+    raw = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return { found: false };
+  }
+  const data: unknown = JSON.parse(raw);
+  return { found: true, data };
+};
+
+const isExcludedItem = (item: unknown, doneSet: Set<string>): boolean => {
+  if (!isRecord(item)) {
+    return false;
+  }
+  const projectItemId = item.projectItemId;
+  return typeof projectItemId === 'string' && doneSet.has(projectItemId);
+};
+
+const applyDoneExclusion = (
+  listData: unknown,
+  doneProjectItemIds: string[],
+): unknown => {
+  if (!isRecord(listData) || !Array.isArray(listData.items)) {
+    return listData;
+  }
+  const doneSet = new Set(doneProjectItemIds);
+  const items = listData.items.filter((item) => !isExcludedItem(item, doneSet));
+  return { ...listData, items };
+};
+
+export type ConsoleDataResponse = {
+  statusCode: number;
+  contentType: string;
+  body: string;
+};
+
+export const buildConsoleDataResponse = (
+  consoleDataOutputDir: string,
+  route: ConsoleDataRoute,
+): ConsoleDataResponse => {
+  if (route.kind === 'list') {
+    const filePath = path.join(
+      consoleDataOutputDir,
+      route.pjcode,
+      route.tab,
+      'list.json',
+    );
+    const listResult = readJsonFile(filePath);
+    if (!listResult.found) {
+      return notFoundJson();
+    }
+    const doneProjectItemIds = readDoneProjectItemIds(
+      consoleDataOutputDir,
+      route.pjcode,
+      route.tab,
+    );
+    const filtered = applyDoneExclusion(listResult.data, doneProjectItemIds);
+    return okJson(filtered);
+  }
+  if (route.kind === 'detail') {
+    const filePath = path.join(
+      consoleDataOutputDir,
+      route.pjcode,
+      route.tab,
+      'detail',
+      route.key,
+    );
+    const detailResult = readJsonFile(filePath);
+    if (!detailResult.found) {
+      return notFoundJson();
+    }
+    return okJson(detailResult.data);
+  }
+  const inTmuxFilePath = path.join(
+    consoleDataOutputDir,
+    route.pjcode,
+    'in-tmux-by-human',
+    route.relativePath,
+  );
+  const inTmuxResult = readJsonFile(inTmuxFilePath);
+  if (!inTmuxResult.found) {
+    return notFoundJson();
+  }
+  return okJson(inTmuxResult.data);
+};
+
+const okJson = (data: unknown): ConsoleDataResponse => ({
+  statusCode: 200,
+  contentType: 'application/json; charset=utf-8',
+  body: JSON.stringify(data),
+});
+
+const notFoundJson = (): ConsoleDataResponse => ({
+  statusCode: 404,
+  contentType: 'text/plain; charset=utf-8',
+  body: 'Not Found',
+});

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

@@ -0,0 +1,98 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  CONSOLE_DONE_FILE_NAME,
+  CONSOLE_DONE_TAB_NAMES,
+  doneFilePathForTab,
+  readDoneProjectItemIds,
+  recordDoneProjectItemId,
+  recordDoneProjectItemIdAcrossTabs,
+} from './consoleDoneStore';
+
+describe('consoleDoneStore', () => {
+  let baseDir: string;
+
+  beforeEach(() => {
+    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-done-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  });
+
+  describe('doneFilePathForTab', () => {
+    it('places the done file under pjcode/tab', () => {
+      expect(doneFilePathForTab(baseDir, 'umino', 'prs')).toBe(
+        path.join(baseDir, 'umino', 'prs', CONSOLE_DONE_FILE_NAME),
+      );
+    });
+  });
+
+  describe('readDoneProjectItemIds', () => {
+    it('returns an empty array when the file is absent', () => {
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+    });
+
+    it('returns the persisted project item ids', () => {
+      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
+      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_2');
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+        'PVTI_1',
+        'PVTI_2',
+      ]);
+    });
+
+    it('returns an empty array for malformed json', () => {
+      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, '{ not json');
+      expect(() => readDoneProjectItemIds(baseDir, 'umino', 'prs')).toThrow();
+    });
+
+    it('returns an empty array when projectItemIds is not an array', () => {
+      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(filePath, JSON.stringify({ projectItemIds: 'x' }));
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+    });
+
+    it('filters out non-string entries', () => {
+      const filePath = doneFilePathForTab(baseDir, 'umino', 'prs');
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      fs.writeFileSync(
+        filePath,
+        JSON.stringify({ projectItemIds: ['PVTI_1', 1, null, ''] }),
+      );
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+        'PVTI_1',
+      ]);
+    });
+  });
+
+  describe('recordDoneProjectItemId', () => {
+    it('does not record an empty id', () => {
+      recordDoneProjectItemId(baseDir, 'umino', 'prs', '');
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([]);
+    });
+
+    it('does not duplicate an already recorded id', () => {
+      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
+      recordDoneProjectItemId(baseDir, 'umino', 'prs', 'PVTI_1');
+      expect(readDoneProjectItemIds(baseDir, 'umino', 'prs')).toEqual([
+        'PVTI_1',
+      ]);
+    });
+  });
+
+  describe('recordDoneProjectItemIdAcrossTabs', () => {
+    it('records the id into every tab done file', () => {
+      recordDoneProjectItemIdAcrossTabs(baseDir, 'umino', 'PVTI_99');
+      for (const tab of CONSOLE_DONE_TAB_NAMES) {
+        expect(readDoneProjectItemIds(baseDir, 'umino', tab)).toEqual([
+          'PVTI_99',
+        ]);
+      }
+    });
+  });
+});

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

@@ -0,0 +1,91 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export const CONSOLE_DONE_FILE_NAME = '.done.json';
+
+export type ConsoleDoneRecord = {
+  projectItemIds: string[];
+};
+
+const isValidProjectItemId = (value: unknown): value is string =>
+  typeof value === 'string' && value.length > 0;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const parseDoneRecord = (raw: string): ConsoleDoneRecord => {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) {
+    return { projectItemIds: [] };
+  }
+  const rawProjectItemIds = parsed.projectItemIds;
+  if (!Array.isArray(rawProjectItemIds)) {
+    return { projectItemIds: [] };
+  }
+  const projectItemIds = rawProjectItemIds.filter(isValidProjectItemId);
+  return { projectItemIds };
+};
+
+export const doneFilePathForTab = (
+  consoleDataOutputDir: string,
+  pjcode: string,
+  tab: string,
+): string =>
+  path.join(consoleDataOutputDir, pjcode, tab, CONSOLE_DONE_FILE_NAME);
+
+export const readDoneProjectItemIds = (
+  consoleDataOutputDir: string,
+  pjcode: string,
+  tab: string,
+): string[] => {
+  const filePath = doneFilePathForTab(consoleDataOutputDir, pjcode, tab);
+  let raw: string;
+  try {
+    raw = fs.readFileSync(filePath, 'utf-8');
+  } catch {
+    return [];
+  }
+  return parseDoneRecord(raw).projectItemIds;
+};
+
+export const recordDoneProjectItemId = (
+  consoleDataOutputDir: string,
+  pjcode: string,
+  tab: string,
+  projectItemId: string,
+): void => {
+  if (!isValidProjectItemId(projectItemId)) {
+    return;
+  }
+  const filePath = doneFilePathForTab(consoleDataOutputDir, pjcode, tab);
+  const existing = readDoneProjectItemIds(consoleDataOutputDir, pjcode, tab);
+  if (existing.includes(projectItemId)) {
+    return;
+  }
+  const updated: ConsoleDoneRecord = {
+    projectItemIds: [...existing, projectItemId],
+  };
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs.writeFileSync(tmpPath, JSON.stringify(updated));
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const CONSOLE_DONE_TAB_NAMES: string[] = [
+  'prs',
+  'triage',
+  'unread',
+  'failed-preparation',
+  'todo-by-human',
+  'in-tmux-by-human',
+];
+
+export const recordDoneProjectItemIdAcrossTabs = (
+  consoleDataOutputDir: string,
+  pjcode: string,
+  projectItemId: string,
+): void => {
+  for (const tab of CONSOLE_DONE_TAB_NAMES) {
+    recordDoneProjectItemId(consoleDataOutputDir, pjcode, tab, projectItemId);
+  }
+};