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

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

@@ -1,156 +0,0 @@
-import {
-  CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
-  DEFAULT_SELECTION_WEIGHT,
-  type OauthTokenCandidate,
-  type OauthTokenSelectResult,
-  OauthTokenSelectUseCase,
-  type SelectionRandom,
-} from '../../../domain/usecases/OauthTokenSelectUseCase';
-import {
-  cacheDir,
-  FABLE_LIMIT_TYPE,
-  readRateLimit,
-} from '../../proxy/RateLimitCache';
-import { loadTokenEntries } from '../../proxy/TokenListLoader';
-
-export type OauthTokenSelectHandlerInput = {
-  tokenListJsonPath: string | null;
-  cacheDirectory: string | null;
-  nowEpochSeconds: number;
-};
-
-export type OauthTokenSelectHandlerOutput = {
-  selectedToken: string | null;
-  selectedName: string | null;
-  diagnostics: string[];
-};
-
-const DEFAULT_TOKEN_LIST_PATH_ENV = 'CLAUDE_CODE_OAUTH_TOKEN_LIST_JSON_PATH';
-const DEFAULT_CACHE_DIRECTORY_ENV = 'TDPM_RATELIMIT_CACHE_DIR';
-
-export const resolveTokenListJsonPath = (
-  explicitPath: string | null,
-): string | null => {
-  if (explicitPath !== null && explicitPath.length > 0) {
-    return explicitPath;
-  }
-  const fromEnv = process.env[DEFAULT_TOKEN_LIST_PATH_ENV];
-  if (fromEnv !== undefined && fromEnv.length > 0) {
-    return fromEnv;
-  }
-  return null;
-};
-
-export const resolveCacheDirectory = (
-  explicitDirectory: string | null,
-): string => {
-  if (explicitDirectory !== null && explicitDirectory.length > 0) {
-    return explicitDirectory;
-  }
-  const fromEnv = process.env[DEFAULT_CACHE_DIRECTORY_ENV];
-  if (fromEnv !== undefined && fromEnv.length > 0) {
-    return fromEnv;
-  }
-  return cacheDir();
-};
-
-export class OauthTokenSelectHandler {
-  constructor(
-    private readonly useCase: OauthTokenSelectUseCase = new OauthTokenSelectUseCase(),
-    private readonly random: SelectionRandom = Math.random,
-  ) {}
-
-  handle = (
-    input: OauthTokenSelectHandlerInput,
-  ): OauthTokenSelectHandlerOutput => {
-    const tokenListJsonPath = resolveTokenListJsonPath(input.tokenListJsonPath);
-    if (tokenListJsonPath === null) {
-      return {
-        selectedToken: null,
-        selectedName: null,
-        diagnostics: [
-          `No token list path provided. Pass --tokenListJsonPath or set ${DEFAULT_TOKEN_LIST_PATH_ENV}.`,
-        ],
-      };
-    }
-
-    const entries = loadTokenEntries(tokenListJsonPath);
-    if (entries === null) {
-      return {
-        selectedToken: null,
-        selectedName: null,
-        diagnostics: [
-          `No usable token entries loaded from ${tokenListJsonPath}.`,
-        ],
-      };
-    }
-
-    const cacheDirectory = resolveCacheDirectory(input.cacheDirectory);
-
-    const candidates: OauthTokenCandidate[] = entries.map(
-      ({ name, token, selectionWeight }) => {
-        const snapshot = readRateLimit(token, cacheDirectory);
-        const fableLimit = snapshot?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
-        const fableRejected =
-          fableLimit !== undefined &&
-          fableLimit.rejected &&
-          input.nowEpochSeconds <= fableLimit.resetsAt;
-        return {
-          name,
-          token,
-          snapshot:
-            snapshot === null
-              ? null
-              : {
-                  fiveHourUtilization: snapshot.fiveHourUtilization,
-                  fiveHourReset: snapshot.fiveHourReset,
-                  sevenDayUtilization: snapshot.sevenDayUtilization,
-                  sevenDayReset: snapshot.sevenDayReset,
-                },
-          subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
-          unifiedRejected: snapshot?.unifiedRejected ?? false,
-          fableRejected,
-          selectionWeight: selectionWeight ?? DEFAULT_SELECTION_WEIGHT,
-        };
-      },
-    );
-
-    const result = this.useCase.run(
-      candidates,
-      input.nowEpochSeconds,
-      this.random,
-      CL_SCRIPT_OAUTH_TOKEN_SELECTION_THRESHOLDS,
-    );
-
-    return {
-      selectedToken: result.selected?.token ?? null,
-      selectedName: result.selected?.name ?? null,
-      diagnostics: this.formatDiagnostics(result, input.nowEpochSeconds),
-    };
-  };
-
-  private formatDiagnostics = (
-    result: OauthTokenSelectResult,
-    nowEpochSeconds: number,
-  ): string[] => {
-    const lines = result.metrics.map((metric) => {
-      const secondsUntilSevenDayEnd = Math.round(
-        metric.sevenDayEndEpoch - nowEpochSeconds,
-      );
-      const status = metric.eligible
-        ? 'eligible'
-        : `excluded (${metric.exclusionReason})`;
-      return `${metric.name}: 5h ${Math.round(metric.fiveHourFreeRatio * 100)}% free, 7d ${Math.round(metric.sevenDayFreeRatio * 100)}% free, 7d-end in ${secondsUntilSevenDayEnd}s, draw weight ${metric.drawWeight.toFixed(2)} -> ${status}`;
-    });
-
-    if (result.selected === null) {
-      lines.push('No eligible token passed the rate-limit filter.');
-    } else {
-      lines.push(
-        `Selected ${result.selected.name} (weighted by how soon the 7d window resets and how much of it is free among eligible tokens).`,
-      );
-    }
-
-    return lines;
-  };
-}

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

@@ -1,332 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { mock } from 'jest-mock-extended';
-import { Issue } from '../../../domain/entities/Issue';
-import { FieldOption, Project } from '../../../domain/entities/Project';
-import {
-  buildConsoleDataResponse,
-  parseConsoleDataRoute,
-} from '../console/consoleDataDelivery';
-import {
-  CONSOLE_DONE_TAB_NAMES,
-  readDoneProjectItemIds,
-  recordDoneProjectItemId,
-} from '../console/consoleDoneStore';
-import {
-  formatConsoleGeneratedAt,
-  writeConsoleLists,
-} from './consoleListsWriter';
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  value !== null && typeof value === 'object' && !Array.isArray(value);
-
-const isUnknownArray = (value: unknown): value is unknown[] =>
-  Array.isArray(value);
-
-const ASSIGNEE = 'owner-login';
-
-const option = (
-  id: string,
-  name: string,
-  color: FieldOption['color'],
-): FieldOption => ({ id, name, color, description: '' });
-
-const project: Project = {
-  ...mock<Project>(),
-  status: {
-    name: 'Status',
-    fieldId: 'status-field',
-    statuses: [
-      option('st-aw', 'Awaiting Workspace', 'BLUE'),
-      option('st-aqc', 'Awaiting Quality Check', 'GREEN'),
-    ],
-  },
-  story: {
-    name: 'story',
-    fieldId: 'story-field',
-    databaseId: 2,
-    stories: [option('s1', 'Story Alpha', 'BLUE')],
-    workflowManagementStory: { id: 'wm', name: 'workflow management' },
-  },
-};
-
-const makeIssue = (overrides: Partial<Issue>): Issue => ({
-  ...mock<Issue>(),
-  number: 1,
-  title: 'Issue 1',
-  nameWithOwner: 'demo/repo',
-  url: 'https://github.com/demo/repo/issues/1',
-  status: null,
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  dependedIssueUrls: [],
-  assignees: [ASSIGNEE],
-  labels: [],
-  body: 'should never be written',
-  itemId: 'item-1',
-  isPr: false,
-  isClosed: false,
-  createdAt: new Date('2026-06-13T08:18:45.000Z'),
-  ...overrides,
-});
-
-describe('writeConsoleLists', () => {
-  let outDir: string;
-
-  beforeEach(() => {
-    outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'console-out-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(outDir, { recursive: true, force: true });
-  });
-
-  const tabFile = (tab: string): string =>
-    path.join(outDir, 'demo', tab, 'list.json');
-
-  it('writes every console tab list.json file', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    for (const tab of [
-      'workflow-blocker',
-      'prs',
-      'failed-preparation',
-      'todo-by-human',
-      'todo-by-agent',
-    ]) {
-      expect(fs.existsSync(tabFile(tab))).toBe(true);
-    }
-  });
-
-  it('writes workflow-blocker items matched by story name regardless of status or actionability', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [
-        makeIssue({
-          story: 'regular / WORKFLOW BLOCKER',
-          status: 'Awaiting Quality Check',
-          nextActionHour: 9,
-        }),
-        makeIssue({ story: 'Story Alpha', status: 'Unread' }),
-      ],
-      workflowBlockerStoryName: 'regular / WORKFLOW BLOCKER',
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    const raw: unknown = JSON.parse(
-      fs.readFileSync(tabFile('workflow-blocker'), 'utf8'),
-    );
-    expect(isRecord(raw)).toBe(true);
-    const items: unknown = isRecord(raw) ? raw.items : undefined;
-    expect(isUnknownArray(items)).toBe(true);
-    expect(isUnknownArray(items) ? items.length : 0).toBe(1);
-  });
-
-  it('writes an empty workflow-blocker list when no story name is configured', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ story: 'regular / WORKFLOW BLOCKER' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    const raw: unknown = JSON.parse(
-      fs.readFileSync(tabFile('workflow-blocker'), 'utf8'),
-    );
-    const items: unknown = isRecord(raw) ? raw.items : undefined;
-    expect(isUnknownArray(items) ? items.length : 0).toBe(0);
-  });
-
-  it('writes todo-by-human items selected by the Todo by human status', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    const raw: unknown = JSON.parse(
-      fs.readFileSync(tabFile('todo-by-human'), 'utf8'),
-    );
-    expect(isRecord(raw)).toBe(true);
-    const items: unknown = isRecord(raw) ? raw.items : undefined;
-    expect(isUnknownArray(items)).toBe(true);
-    expect(isUnknownArray(items) ? items.length : 0).toBe(1);
-  });
-
-  it('writes todo-by-agent items selected by the Todo by agent status', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by agent' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    const raw: unknown = JSON.parse(
-      fs.readFileSync(tabFile('todo-by-agent'), 'utf8'),
-    );
-    expect(isRecord(raw)).toBe(true);
-    const items: unknown = isRecord(raw) ? raw.items : undefined;
-    expect(isUnknownArray(items)).toBe(true);
-    expect(isUnknownArray(items) ? items.length : 0).toBe(1);
-  });
-
-  it('writes items with no body field', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-
-    const raw: unknown = JSON.parse(
-      fs.readFileSync(tabFile('todo-by-human'), 'utf8'),
-    );
-    expect(isRecord(raw)).toBe(true);
-    const items: unknown = isRecord(raw) ? raw.items : undefined;
-    expect(isUnknownArray(items)).toBe(true);
-    const firstItem: unknown = isUnknownArray(items) ? items[0] : undefined;
-    expect(isRecord(firstItem)).toBe(true);
-    expect(firstItem).not.toHaveProperty('body');
-  });
-
-  it('does not leave a temp file behind after writing', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-    expect(fs.existsSync(`${tabFile('prs')}.tmp`)).toBe(false);
-  });
-
-  it('is a no-op when consoleDataOutputDir is unset', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: undefined,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-    });
-    expect(fs.readdirSync(outDir)).toHaveLength(0);
-  });
-
-  it('is a no-op when pjcode is unset', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: '',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-    });
-    expect(fs.readdirSync(outDir)).toHaveLength(0);
-  });
-
-  it('is a no-op when assigneeLogin is unset', () => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: null,
-      project,
-      issues: [makeIssue({ status: 'Todo by human' })],
-    });
-    expect(fs.readdirSync(outDir)).toHaveLength(0);
-  });
-
-  const regenerateTodoByHuman = (): void => {
-    writeConsoleLists({
-      consoleDataOutputDir: outDir,
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      project,
-      issues: [makeIssue({ status: 'Todo by human', itemId: 'item-1' })],
-      generatedAt: '2026-06-14T07:22:33Z',
-    });
-  };
-
-  const todoByHumanServedItemCount = (): number => {
-    const route = parseConsoleDataRoute(
-      'projects/demo/todo-by-human/list.json',
-    );
-    if (route === null) {
-      throw new Error('route should not be null');
-    }
-    const response = buildConsoleDataResponse(outDir, route);
-    const body: unknown = JSON.parse(response.body);
-    const items: unknown = isRecord(body) ? body.items : undefined;
-    return isUnknownArray(items) ? items.length : 0;
-  };
-
-  it('resets the done file of every tab to an empty record on regeneration', () => {
-    regenerateTodoByHuman();
-
-    for (const tab of CONSOLE_DONE_TAB_NAMES) {
-      const doneFile = path.join(outDir, 'demo', tab, '.done.json');
-      expect(fs.existsSync(doneFile)).toBe(true);
-      const raw: unknown = JSON.parse(fs.readFileSync(doneFile, 'utf8'));
-      expect(raw).toEqual({ projectItemIds: [] });
-    }
-  });
-
-  it('clears a pre-existing accumulated done file on regeneration', () => {
-    for (const id of ['PVTI_1', 'PVTI_2', 'PVTI_3']) {
-      recordDoneProjectItemId(outDir, 'demo', 'todo-by-human', id);
-    }
-    expect(
-      readDoneProjectItemIds(outDir, 'demo', 'todo-by-human'),
-    ).toHaveLength(3);
-
-    regenerateTodoByHuman();
-
-    expect(readDoneProjectItemIds(outDir, 'demo', 'todo-by-human')).toEqual([]);
-  });
-
-  it('serves the full list after regeneration despite a prior accumulated done record', () => {
-    recordDoneProjectItemId(outDir, 'demo', 'todo-by-human', 'item-1');
-
-    regenerateTodoByHuman();
-
-    expect(todoByHumanServedItemCount()).toBe(1);
-  });
-
-  it('serves an item regardless of a done record accumulated between regenerations', () => {
-    regenerateTodoByHuman();
-    expect(todoByHumanServedItemCount()).toBe(1);
-
-    recordDoneProjectItemId(outDir, 'demo', 'todo-by-human', 'item-1');
-    expect(todoByHumanServedItemCount()).toBe(1);
-
-    regenerateTodoByHuman();
-    expect(todoByHumanServedItemCount()).toBe(1);
-  });
-});
-
-describe('formatConsoleGeneratedAt', () => {
-  it('strips milliseconds and keeps the trailing Z', () => {
-    expect(formatConsoleGeneratedAt(new Date('2026-06-14T07:22:33.456Z'))).toBe(
-      '2026-06-14T07:22:33Z',
-    );
-  });
-});

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

@@ -1,60 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import type { Issue } from '../../../domain/entities/Issue';
-import type { Project } from '../../../domain/entities/Project';
-import {
-  ConsoleLists,
-  GenerateConsoleListsUseCase,
-} from '../../../domain/usecases/console/GenerateConsoleListsUseCase';
-import { resetDoneProjectItemIdsAcrossTabs } from '../console/consoleDoneStore';
-import { CONSOLE_LIST_TAB_NAMES } from '../console/consoleTabNames';
-
-export type ConsoleListsWriterParams = {
-  consoleDataOutputDir: string | null | undefined;
-  pjcode: string | null | undefined;
-  assigneeLogin: string | null | undefined;
-  project: Project;
-  issues: Issue[];
-  workflowBlockerStoryName?: string | null | undefined;
-  urlOfStoryView?: string | null;
-  generatedAt?: string;
-};
-
-export const formatConsoleGeneratedAt = (date: Date): string =>
-  date.toISOString().replace(/\.\d{3}Z$/, 'Z');
-
-const writeJsonAtomic = (filePath: string, data: unknown): void => {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(data));
-  fs.renameSync(tmpPath, filePath);
-};
-
-export const writeConsoleLists = (params: ConsoleListsWriterParams): void => {
-  const { consoleDataOutputDir, pjcode, assigneeLogin } = params;
-  if (!consoleDataOutputDir || !pjcode || !assigneeLogin) {
-    return;
-  }
-
-  const generatedAt =
-    params.generatedAt ?? formatConsoleGeneratedAt(new Date());
-  const lists: ConsoleLists = new GenerateConsoleListsUseCase().run({
-    project: params.project,
-    issues: params.issues,
-    pjcode,
-    assigneeLogin,
-    generatedAt,
-    workflowBlockerStoryName: params.workflowBlockerStoryName ?? null,
-    urlOfStoryView: params.urlOfStoryView ?? null,
-  });
-
-  for (const tab of CONSOLE_LIST_TAB_NAMES) {
-    writeJsonAtomic(
-      path.join(consoleDataOutputDir, pjcode, tab, 'list.json'),
-      lists[tab],
-    );
-  }
-
-  resetDoneProjectItemIdsAcrossTabs(consoleDataOutputDir, pjcode);
-};

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

@@ -1,112 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { Issue } from '../../../domain/entities/Issue';
-import { DashboardRowFile, writeDashboardRow } from './dashboardRowWriter';
-
-const readJson = (filePath: string): unknown =>
-  JSON.parse(fs.readFileSync(filePath, 'utf8'));
-
-const ASSIGNEE = 'HiromiShikata';
-
-let issueCounter = 0;
-const makeIssue = (overrides: Partial<Issue>): Issue => {
-  issueCounter += 1;
-  return {
-    nameWithOwner: 'demo/repo',
-    number: issueCounter,
-    title: `Issue ${issueCounter}`,
-    state: 'OPEN',
-    status: null,
-    story: null,
-    nextActionDate: null,
-    nextActionHour: null,
-    estimationMinutes: null,
-    dependedIssueUrls: [],
-    completionDate50PercentConfidence: null,
-    url: `https://github.com/demo/repo/issues/${issueCounter}`,
-    assignees: [ASSIGNEE],
-    labels: [],
-    org: 'demo',
-    repo: 'repo',
-    body: '',
-    itemId: `item-${issueCounter}`,
-    isPr: false,
-    isInProgress: false,
-    isClosed: false,
-    createdAt: new Date('2026-06-13T08:18:45.000Z'),
-    author: 'someone',
-    closingIssueReferenceUrls: [],
-    agent: null,
-    stateReason: null,
-    ...overrides,
-  };
-};
-
-describe('writeDashboardRow', () => {
-  let dir: string;
-
-  beforeEach(() => {
-    issueCounter = 0;
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-row-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(dir, { recursive: true, force: true });
-  });
-
-  it('writes a per-project row file with counts, pjcode and capturedAt', () => {
-    writeDashboardRow({
-      dashboardDataDir: dir,
-      pjcode: 'ac',
-      assigneeLogin: ASSIGNEE,
-      issues: [
-        makeIssue({ status: 'Awaiting Workspace' }),
-        makeIssue({ status: 'Awaiting Quality Check' }),
-      ],
-      generatedAt: '2026-06-26T12:00:00.000Z',
-    });
-
-    const written = readJson(path.join(dir, 'projects', 'ac.json'));
-    const expected: DashboardRowFile = {
-      pjcode: 'ac',
-      capturedAt: '2026-06-26T12:00:00.000Z',
-      todo: 0,
-      qc: 1,
-      fail: 0,
-      pr: 0,
-      ws: 1,
-      dep: 0,
-      blocker: 0,
-    };
-    expect(written).toEqual(expected);
-  });
-
-  it('is a no-op when dashboardDataDir is unset', () => {
-    writeDashboardRow({
-      dashboardDataDir: null,
-      pjcode: 'ac',
-      assigneeLogin: ASSIGNEE,
-      issues: [makeIssue({ status: 'Awaiting Workspace' })],
-    });
-
-    expect(fs.readdirSync(dir)).toEqual([]);
-  });
-
-  it('is a no-op when pjcode or assigneeLogin is missing', () => {
-    writeDashboardRow({
-      dashboardDataDir: dir,
-      pjcode: null,
-      assigneeLogin: ASSIGNEE,
-      issues: [makeIssue({ status: 'Awaiting Workspace' })],
-    });
-    writeDashboardRow({
-      dashboardDataDir: dir,
-      pjcode: 'ac',
-      assigneeLogin: null,
-      issues: [makeIssue({ status: 'Awaiting Workspace' })],
-    });
-
-    expect(fs.readdirSync(dir)).toEqual([]);
-  });
-});

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

@@ -1,51 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import type { Issue } from '../../../domain/entities/Issue';
-import {
-  DashboardRow,
-  GenerateDashboardRowUseCase,
-} from '../../../domain/usecases/dashboard/GenerateDashboardRowUseCase';
-
-export type DashboardRowWriterParams = {
-  dashboardDataDir: string | null | undefined;
-  pjcode: string | null | undefined;
-  assigneeLogin: string | null | undefined;
-  issues: Issue[];
-  generatedAt?: string;
-};
-
-export type DashboardRowFile = DashboardRow & {
-  pjcode: string;
-  capturedAt: string;
-};
-
-const writeJsonAtomic = (filePath: string, data: unknown): void => {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(data));
-  fs.renameSync(tmpPath, filePath);
-};
-
-export const writeDashboardRow = (params: DashboardRowWriterParams): void => {
-  const { dashboardDataDir, pjcode, assigneeLogin, issues } = params;
-  if (!dashboardDataDir || !pjcode || !assigneeLogin) {
-    return;
-  }
-
-  const row: DashboardRow = new GenerateDashboardRowUseCase().run({
-    issues,
-    assigneeLogin,
-  });
-
-  const file: DashboardRowFile = {
-    pjcode,
-    capturedAt: params.generatedAt ?? new Date().toISOString(),
-    ...row,
-  };
-
-  writeJsonAtomic(
-    path.join(dashboardDataDir, 'projects', `${pjcode}.json`),
-    file,
-  );
-};