github-issue-tower-defence-management 1.106.0 → 1.108.0

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

@@ -0,0 +1,450 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  buildComposeDashboardInput,
+  composeDashboardText,
+  dashboardComposeFilesPresent,
+} from './dashboardComposeService';
+
+const makeDataDir = (): string =>
+  fs.mkdtempSync(path.join(os.tmpdir(), 'dashboard-compose-'));
+
+const writeProject = (dataDir: string, code: string, body: unknown): void => {
+  fs.mkdirSync(path.join(dataDir, 'projects'), { recursive: true });
+  fs.writeFileSync(
+    path.join(dataDir, 'projects', `${code}.json`),
+    JSON.stringify(body),
+  );
+};
+
+describe('buildComposeDashboardInput', () => {
+  it('reads every requested project code in order and yields null for absent files', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeProject(dataDir, 'um', {
+        pjcode: 'um',
+        capturedAt: 'x',
+        unread: 3,
+        todo: 1,
+        qc: 2,
+        fail: 0,
+        pr: 0,
+        ws: 4,
+        dep: 1,
+        blocker: 0,
+      });
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: ['um', 'xc'],
+      });
+      expect(input.projects).toEqual([
+        {
+          code: 'um',
+          row: {
+            unread: 3,
+            todo: 1,
+            qc: 2,
+            fail: 0,
+            pr: 0,
+            ws: 4,
+            dep: 1,
+            blocker: 0,
+          },
+        },
+        { code: 'xc', row: null },
+      ]);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('treats a project file with a missing field as an absent row', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeProject(dataDir, 'um', { unread: 1, todo: 1 });
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: ['um'],
+      });
+      expect(input.projects[0].row).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('treats malformed JSON as an absent row', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.mkdirSync(path.join(dataDir, 'projects'), { recursive: true });
+      fs.writeFileSync(path.join(dataDir, 'projects', 'um.json'), 'not json');
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: ['um'],
+      });
+      expect(input.projects[0].row).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('reads machine status from machine-status.json', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'machine-status.json'),
+        JSON.stringify({
+          memPct: 55,
+          cpuPct: 62,
+          diskPct: 89,
+          load: [16, 23, 40],
+          cycleMinutes: 14,
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.machineStatus).toEqual({
+        memPct: 55,
+        cpuPct: 62,
+        diskPct: 89,
+        load: [16, 23, 40],
+        cycleMinutes: 14,
+      });
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('preserves a null cycleMinutes from machine-status.json', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'machine-status.json'),
+        JSON.stringify({
+          memPct: 1,
+          cpuPct: 2,
+          diskPct: 3,
+          load: [0, 0, 0],
+          cycleMinutes: null,
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.machineStatus?.cycleMinutes).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('yields a null machine status when the file is absent', () => {
+    const dataDir = makeDataDir();
+    try {
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.machineStatus).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('reads token statuses from token-status.json and skips malformed entries', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [
+            {
+              name: 'alice',
+              fiveHourUtilizationPercent: 10,
+              fiveHourResetSeconds: 3600,
+              sevenDayUtilizationPercent: 12,
+              sevenDayResetSeconds: 432000,
+              color: 'G',
+              prep: 2,
+              hum: 1,
+            },
+            { fiveHourUtilizationPercent: 5 },
+          ],
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.tokens).toEqual([
+        {
+          name: 'alice',
+          fiveHourUtilizationPercent: 10,
+          fiveHourResetSeconds: 3600,
+          sevenDayUtilizationPercent: 12,
+          sevenDayResetSeconds: 432000,
+          color: 'G',
+          prep: 2,
+          hum: 1,
+        },
+      ]);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('defaults an unknown token color to Y and null windows to null', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [
+            {
+              name: 'bob',
+              fiveHourUtilizationPercent: null,
+              fiveHourResetSeconds: null,
+              sevenDayUtilizationPercent: null,
+              sevenDayResetSeconds: null,
+              color: 'purple',
+              prep: 0,
+              hum: 0,
+            },
+          ],
+          capturedAt: 'x',
+        }),
+      );
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.tokens[0].color).toBe('Y');
+      expect(input.tokens[0].fiveHourUtilizationPercent).toBeNull();
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('yields an empty token list when the file is absent', () => {
+    const dataDir = makeDataDir();
+    try {
+      const input = buildComposeDashboardInput({
+        dashboardDataDir: dataDir,
+        projectCodes: [],
+      });
+      expect(input.tokens).toEqual([]);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('composeDashboardText', () => {
+  it('composes the full byte-identical dashboard text from the data files', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeProject(dataDir, 'um', {
+        pjcode: 'um',
+        capturedAt: 'x',
+        unread: 3,
+        todo: 1,
+        qc: 2,
+        fail: 0,
+        pr: 0,
+        ws: 4,
+        dep: 1,
+        blocker: 0,
+      });
+      fs.writeFileSync(
+        path.join(dataDir, 'machine-status.json'),
+        JSON.stringify({
+          memPct: 55,
+          cpuPct: 62,
+          diskPct: 89,
+          load: [16, 23, 40],
+          cycleMinutes: 14,
+          capturedAt: 'x',
+        }),
+      );
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({
+          tokens: [
+            {
+              name: 'alice',
+              fiveHourUtilizationPercent: 10,
+              fiveHourResetSeconds: 3600,
+              sevenDayUtilizationPercent: 12,
+              sevenDayResetSeconds: 432000,
+              color: 'G',
+              prep: 2,
+              hum: 1,
+            },
+          ],
+          capturedAt: 'x',
+        }),
+      );
+      expect(
+        composeDashboardText({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um', 'xc'],
+        }),
+      ).toBe(
+        '<tt>M55%&nbsp;C62%&nbsp;D89%&nbsp;cy14</tt><br>\n' +
+          '<tt>LA&nbsp;16&nbsp;23&nbsp;40</tt><br>\n' +
+          '<tt>pj&nbsp;&nbsp;&nbsp;unr&nbsp;tdo&nbsp;aqc&nbsp;fal&nbsp;prp&nbsp;aws&nbsp;dep</tt><br>\n' +
+          '<tt>🟢um&nbsp;&nbsp;&nbsp;3&nbsp;&nbsp;&nbsp;1&nbsp;&nbsp;&nbsp;2&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;0&nbsp;&nbsp;&nbsp;4&nbsp;&nbsp;&nbsp;1</tt><br>\n' +
+          '<tt>&nbsp;&nbsp;xc&nbsp;&nbsp;--&nbsp;&nbsp;--&nbsp;&nbsp;--&nbsp;&nbsp;--&nbsp;&nbsp;--&nbsp;&nbsp;--&nbsp;&nbsp;--</tt><br>\n' +
+          '<tt></tt><br>\n' +
+          '<tt>🟢alice&nbsp;&nbsp;10%&nbsp;0d01h00&nbsp;&nbsp;12%&nbsp;5d00h00&nbsp;2&nbsp;1</tt><br>\n',
+      );
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('dashboardComposeFilesPresent', () => {
+  const writeMachineAndToken = (dataDir: string): void => {
+    fs.writeFileSync(
+      path.join(dataDir, 'machine-status.json'),
+      JSON.stringify({
+        memPct: 1,
+        cpuPct: 2,
+        diskPct: 3,
+        load: [0, 0, 0],
+        cycleMinutes: null,
+        capturedAt: 'x',
+      }),
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'token-status.json'),
+      JSON.stringify({ tokens: [], capturedAt: 'x' }),
+    );
+  };
+
+  const minimalProject = {
+    pjcode: 'um',
+    capturedAt: 'x',
+    unread: 0,
+    todo: 0,
+    qc: 0,
+    fail: 0,
+    pr: 0,
+    ws: 0,
+    dep: 0,
+    blocker: 0,
+  };
+
+  it('is true when machine, token, and every requested project file are present', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeMachineAndToken(dataDir);
+      writeProject(dataDir, 'um', minimalProject);
+      writeProject(dataDir, 'xc', { ...minimalProject, pjcode: 'xc' });
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um', 'xc'],
+        }),
+      ).toBe(true);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('is false when no data files exist', () => {
+    const dataDir = makeDataDir();
+    try {
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um'],
+        }),
+      ).toBe(false);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('is false when a requested project file is missing', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeMachineAndToken(dataDir);
+      writeProject(dataDir, 'um', minimalProject);
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um', 'xc'],
+        }),
+      ).toBe(false);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('is false when machine-status.json is missing', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'token-status.json'),
+        JSON.stringify({ tokens: [], capturedAt: 'x' }),
+      );
+      writeProject(dataDir, 'um', minimalProject);
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um'],
+        }),
+      ).toBe(false);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('is false when token-status.json is missing', () => {
+    const dataDir = makeDataDir();
+    try {
+      fs.writeFileSync(
+        path.join(dataDir, 'machine-status.json'),
+        JSON.stringify({
+          memPct: 1,
+          cpuPct: 2,
+          diskPct: 3,
+          load: [0, 0, 0],
+          cycleMinutes: null,
+          capturedAt: 'x',
+        }),
+      );
+      writeProject(dataDir, 'um', minimalProject);
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: ['um'],
+        }),
+      ).toBe(false);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+
+  it('is false when no project codes are requested', () => {
+    const dataDir = makeDataDir();
+    try {
+      writeMachineAndToken(dataDir);
+      expect(
+        dashboardComposeFilesPresent({
+          dashboardDataDir: dataDir,
+          projectCodes: [],
+        }),
+      ).toBe(false);
+    } finally {
+      fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -0,0 +1,201 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  ComposeDashboardInput,
+  ComposeDashboardMachineStatus,
+  ComposeDashboardProject,
+  ComposeDashboardUseCase,
+} from '../../../domain/usecases/dashboard/ComposeDashboardUseCase';
+import { DashboardRow } from '../../../domain/usecases/dashboard/GenerateDashboardRowUseCase';
+import {
+  TokenStatus,
+  TokenStatusColor,
+} from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
+
+export type DashboardComposeOptions = {
+  dashboardDataDir: string;
+  projectCodes: string[];
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const readJsonFile = (filePath: string): unknown => {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+};
+
+const asFiniteNumber = (value: unknown): number | null =>
+  typeof value === 'number' && Number.isFinite(value) ? value : null;
+
+const parseDashboardRow = (value: unknown): DashboardRow | null => {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const unread = asFiniteNumber(value.unread);
+  const todo = asFiniteNumber(value.todo);
+  const qc = asFiniteNumber(value.qc);
+  const fail = asFiniteNumber(value.fail);
+  const pr = asFiniteNumber(value.pr);
+  const ws = asFiniteNumber(value.ws);
+  const dep = asFiniteNumber(value.dep);
+  const blocker = asFiniteNumber(value.blocker);
+  if (
+    unread === null ||
+    todo === null ||
+    qc === null ||
+    fail === null ||
+    pr === null ||
+    ws === null ||
+    dep === null ||
+    blocker === null
+  ) {
+    return null;
+  }
+  return { unread, todo, qc, fail, pr, ws, dep, blocker };
+};
+
+const readProjectRow = (
+  dashboardDataDir: string,
+  code: string,
+): DashboardRow | null =>
+  parseDashboardRow(
+    readJsonFile(path.join(dashboardDataDir, 'projects', `${code}.json`)),
+  );
+
+const parseLoad = (value: unknown): [number, number, number] | null => {
+  if (!Array.isArray(value) || value.length !== 3) {
+    return null;
+  }
+  const oneMinute = asFiniteNumber(value[0]);
+  const fiveMinute = asFiniteNumber(value[1]);
+  const fifteenMinute = asFiniteNumber(value[2]);
+  if (oneMinute === null || fiveMinute === null || fifteenMinute === null) {
+    return null;
+  }
+  return [oneMinute, fiveMinute, fifteenMinute];
+};
+
+const readMachineStatus = (
+  dashboardDataDir: string,
+): ComposeDashboardMachineStatus | null => {
+  const value = readJsonFile(
+    path.join(dashboardDataDir, 'machine-status.json'),
+  );
+  if (!isRecord(value)) {
+    return null;
+  }
+  const cycleMinutesRaw = value.cycleMinutes;
+  const cycleMinutes =
+    cycleMinutesRaw === null ? null : asFiniteNumber(cycleMinutesRaw);
+  return {
+    memPct: asFiniteNumber(value.memPct),
+    cpuPct: asFiniteNumber(value.cpuPct),
+    diskPct: asFiniteNumber(value.diskPct),
+    load: parseLoad(value.load),
+    cycleMinutes,
+  };
+};
+
+const isTokenColor = (value: unknown): value is TokenStatusColor =>
+  value === 'G' || value === 'Y' || value === 'K';
+
+const asTokenColor = (value: unknown): TokenStatusColor =>
+  isTokenColor(value) ? value : 'Y';
+
+const asNullableNumber = (value: unknown): number | null =>
+  value === null ? null : asFiniteNumber(value);
+
+const asCount = (value: unknown): number => {
+  const number = asFiniteNumber(value);
+  return number === null ? 0 : number;
+};
+
+const parseTokenStatus = (value: unknown): TokenStatus | null => {
+  if (!isRecord(value) || typeof value.name !== 'string') {
+    return null;
+  }
+  return {
+    name: value.name,
+    fiveHourUtilizationPercent: asNullableNumber(
+      value.fiveHourUtilizationPercent,
+    ),
+    fiveHourResetSeconds: asNullableNumber(value.fiveHourResetSeconds),
+    sevenDayUtilizationPercent: asNullableNumber(
+      value.sevenDayUtilizationPercent,
+    ),
+    sevenDayResetSeconds: asNullableNumber(value.sevenDayResetSeconds),
+    color: asTokenColor(value.color),
+    prep: asCount(value.prep),
+    hum: asCount(value.hum),
+  };
+};
+
+const readTokenStatuses = (dashboardDataDir: string): TokenStatus[] => {
+  const value = readJsonFile(path.join(dashboardDataDir, 'token-status.json'));
+  if (!isRecord(value) || !Array.isArray(value.tokens)) {
+    return [];
+  }
+  const tokens: TokenStatus[] = [];
+  for (const entry of value.tokens) {
+    const token = parseTokenStatus(entry);
+    if (token !== null) {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+};
+
+export const buildComposeDashboardInput = (
+  options: DashboardComposeOptions,
+): ComposeDashboardInput => {
+  const projects: ComposeDashboardProject[] = options.projectCodes.map(
+    (code) => ({
+      code,
+      row: readProjectRow(options.dashboardDataDir, code),
+    }),
+  );
+  return {
+    projects,
+    machineStatus: readMachineStatus(options.dashboardDataDir),
+    tokens: readTokenStatuses(options.dashboardDataDir),
+  };
+};
+
+const isExistingFile = (filePath: string): boolean => {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+};
+
+export const dashboardComposeFilesPresent = (
+  options: DashboardComposeOptions,
+): boolean => {
+  if (options.projectCodes.length === 0) {
+    return false;
+  }
+  const requiredFiles = [
+    path.join(options.dashboardDataDir, 'machine-status.json'),
+    path.join(options.dashboardDataDir, 'token-status.json'),
+    ...options.projectCodes.map((code) =>
+      path.join(options.dashboardDataDir, 'projects', `${code}.json`),
+    ),
+  ];
+  return requiredFiles.every((filePath) => isExistingFile(filePath));
+};
+
+export const composeDashboardText = (
+  options: DashboardComposeOptions,
+): string =>
+  new ComposeDashboardUseCase().run(buildComposeDashboardInput(options));

package/src/adapter/entry-points/console/ui/e2e/consoleTestHarness.ts

@@ -371,6 +371,8 @@ export const startConsoleE2eHarness = async (): Promise<ConsoleE2eHarness> => {
     issueTitleStateCache: new IssueTitleStateCache(),
     inTmuxDataDir: null,
     dashboardDir: null,
+    dashboardDataDir: null,
+    dashboardProjectCodes: [],
     port: 0,
   });