github-issue-tower-defence-management 1.104.4 → 1.105.0

package/src/adapter/repositories/ProcHostMetricsRepository.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+export type CpuSample = {
+  total: number;
+  idle: number;
+};
+
+export type LoadAverages = {
+  oneMinute: number;
+  fiveMinute: number;
+  fifteenMinute: number;
+};
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const CPU_SAMPLE_INTERVAL_MS = 400;
+
+export const parseMemoryUsedPercent = (meminfoText: string): number => {
+  const fields = new Map<string, number>();
+  for (const line of meminfoText.split('\n')) {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    const valuePart = line
+      .slice(separatorIndex + 1)
+      .trim()
+      .split(/\s+/)[0];
+    const value = Number(valuePart);
+    if (Number.isFinite(value)) {
+      fields.set(key, value);
+    }
+  }
+  const total = fields.get('MemTotal');
+  const available = fields.get('MemAvailable');
+  if (total === undefined || available === undefined) {
+    throw new Error('MemTotal and MemAvailable are required');
+  }
+  if (total <= 0) {
+    throw new Error('MemTotal must be positive');
+  }
+  const used = total - available;
+  return Math.round((used / total) * 100);
+};
+
+export const parseCpuSample = (statText: string): CpuSample => {
+  for (const line of statText.split('\n')) {
+    if (line.startsWith('cpu ')) {
+      const values = line
+        .trim()
+        .split(/\s+/)
+        .slice(1)
+        .map((value) => Number(value));
+      if (values.some((value) => !Number.isFinite(value))) {
+        throw new Error('aggregate cpu line contains non-numeric values');
+      }
+      const idle = values[3] + (values.length > 4 ? values[4] : 0);
+      const total = values.reduce((sum, value) => sum + value, 0);
+      return { total, idle };
+    }
+  }
+  throw new Error('aggregate cpu line not found');
+};
+
+export const cpuUsedPercentFromSamples = (
+  first: CpuSample,
+  second: CpuSample,
+): number => {
+  const totalDelta = second.total - first.total;
+  const idleDelta = second.idle - first.idle;
+  if (totalDelta <= 0) {
+    throw new Error('total delta must be positive');
+  }
+  const busyDelta = totalDelta - idleDelta;
+  return Math.round((busyDelta / totalDelta) * 100);
+};
+
+export const parseLoadAverages = (loadavgText: string): LoadAverages => {
+  const parts = loadavgText.trim().split(/\s+/);
+  const oneMinute = Number(parts[0]);
+  const fiveMinute = Number(parts[1]);
+  const fifteenMinute = Number(parts[2]);
+  if (
+    !Number.isFinite(oneMinute) ||
+    !Number.isFinite(fiveMinute) ||
+    !Number.isFinite(fifteenMinute)
+  ) {
+    throw new Error('loadavg must contain three numeric values');
+  }
+  return { oneMinute, fiveMinute, fifteenMinute };
+};
+
+export const cycleMinutesFromMtimes = (
+  mtimesDescendingSeconds: number[],
+): number | null => {
+  if (mtimesDescendingSeconds.length < 2) {
+    return null;
+  }
+  return Math.round(
+    (mtimesDescendingSeconds[0] - mtimesDescendingSeconds[1]) / 60,
+  );
+};
+
+export class ProcHostMetricsRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+    private readonly sleep: (milliseconds: number) => Promise<void> = (
+      milliseconds,
+    ) =>
+      new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+      }),
+  ) {}
+
+  readMemoryUsedPercent = (): number =>
+    parseMemoryUsedPercent(
+      fs.readFileSync(path.join(this.procDirectory, 'meminfo'), 'utf8'),
+    );
+
+  readCpuUsedPercent = async (): Promise<number> => {
+    const first = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    await this.sleep(CPU_SAMPLE_INTERVAL_MS);
+    const second = parseCpuSample(
+      fs.readFileSync(path.join(this.procDirectory, 'stat'), 'utf8'),
+    );
+    return cpuUsedPercentFromSamples(first, second);
+  };
+
+  readLoadAverages = (): LoadAverages =>
+    parseLoadAverages(
+      fs.readFileSync(path.join(this.procDirectory, 'loadavg'), 'utf8'),
+    );
+}

package/src/adapter/repositories/ProcTakeOwnershipSpawnRepository.test.ts

@@ -0,0 +1,130 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { ProcTakeOwnershipSpawnRepository } from './ProcTakeOwnershipSpawnRepository';
+
+type FakeProcess = {
+  pid: number;
+  cmdline: string;
+  environ: Record<string, string>;
+};
+
+const issueUrl = 'https://github.com/HiromiShikata/example/issues/1';
+const argv = (...parts: string[]): string => `${parts.join('\0')}\0`;
+
+describe('ProcTakeOwnershipSpawnRepository', () => {
+  let procDirectory: string;
+
+  beforeEach(() => {
+    procDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'fake-proc-spawn-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(procDirectory, { recursive: true, force: true });
+  });
+
+  const writeProcess = (fakeProcess: FakeProcess): void => {
+    const processDirectory = path.join(procDirectory, String(fakeProcess.pid));
+    fs.mkdirSync(processDirectory, { recursive: true });
+    fs.writeFileSync(
+      path.join(processDirectory, 'cmdline'),
+      fakeProcess.cmdline,
+    );
+    const environBuffer = Object.entries(fakeProcess.environ)
+      .map(([key, value]) => `${key}=${value}\0`)
+      .join('');
+    fs.writeFileSync(path.join(processDirectory, 'environ'), environBuffer);
+  };
+
+  it('reads the token and log path of a Take ownership spawn', () => {
+    writeProcess({
+      pid: 301,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `claude-agent -p "Take ownership of ${issueUrl}" | tee /home/user/logs-aw/20260626_120000_abc.log`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-a' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-a', logPath: '/logs-aw/20260626_120000_abc.log' },
+    ]);
+  });
+
+  it('ignores a process that is not a Take ownership spawn', () => {
+    writeProcess({
+      pid: 302,
+      cmdline: argv('claude', '--name', issueUrl),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-b' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process whose cmdline carries no log path', () => {
+    writeProcess({
+      pid: 303,
+      cmdline: argv('claude-agent', '-p', `Take ownership of ${issueUrl}`),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-c' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('ignores a Take ownership process without an oauth token', () => {
+    writeProcess({
+      pid: 304,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee /home/user/logs-aw/x.log`,
+      ),
+      environ: { ANTHROPIC_API_KEY: 'api-key' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+
+  it('returns one entry per child process so the use case can dedupe by log path', () => {
+    const fullLogPath = '/home/user/logs-aw/20260626_120000_dup.log';
+    const capturedLogPath = '/logs-aw/20260626_120000_dup.log';
+    writeProcess({
+      pid: 305,
+      cmdline: argv(
+        'bash',
+        '-c',
+        `Take ownership of ${issueUrl} | tee ${fullLogPath}`,
+      ),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+    writeProcess({
+      pid: 306,
+      cmdline: argv('tee', fullLogPath, 'Take ownership marker'),
+      environ: { CLAUDE_CODE_OAUTH_TOKEN: 'token-d' },
+    });
+
+    const repository = new ProcTakeOwnershipSpawnRepository(procDirectory);
+
+    expect(repository.listSpawns()).toEqual([
+      { token: 'token-d', logPath: capturedLogPath },
+      { token: 'token-d', logPath: capturedLogPath },
+    ]);
+  });
+
+  it('returns an empty list when the proc directory does not exist', () => {
+    const repository = new ProcTakeOwnershipSpawnRepository(
+      path.join(procDirectory, 'missing'),
+    );
+
+    expect(repository.listSpawns()).toEqual([]);
+  });
+});

package/src/adapter/repositories/ProcTakeOwnershipSpawnRepository.ts

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  TakeOwnershipSpawn,
+  TakeOwnershipSpawnRepository,
+} from '../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
+
+const DEFAULT_PROC_DIRECTORY = '/proc';
+const OAUTH_TOKEN_ENVIRON_KEY = 'CLAUDE_CODE_OAUTH_TOKEN';
+const TAKE_OWNERSHIP_MARKER = 'Take ownership';
+const LOG_PATH_PATTERN = /\/logs-aw\/[^\0"]+\.log/;
+
+const parseCommandLineArguments = (cmdline: string): string[] =>
+  cmdline.split('\0').filter((argument) => argument.length > 0);
+
+const isTakeOwnershipSpawn = (commandArguments: string[]): boolean =>
+  commandArguments.some((argument) => argument.includes(TAKE_OWNERSHIP_MARKER));
+
+const extractLogPath = (cmdline: string): string | null => {
+  const match = cmdline.match(LOG_PATH_PATTERN);
+  return match === null ? null : match[0];
+};
+
+export class ProcTakeOwnershipSpawnRepository implements TakeOwnershipSpawnRepository {
+  constructor(
+    private readonly procDirectory: string = DEFAULT_PROC_DIRECTORY,
+  ) {}
+
+  listSpawns = (): TakeOwnershipSpawn[] => {
+    const spawns: TakeOwnershipSpawn[] = [];
+    for (const pidDirectory of this.listProcessIdDirectories()) {
+      const spawn = this.readSpawn(pidDirectory);
+      if (spawn !== null) {
+        spawns.push(spawn);
+      }
+    }
+    return spawns;
+  };
+
+  private listProcessIdDirectories = (): string[] => {
+    let entries: string[];
+    try {
+      entries = fs.readdirSync(this.procDirectory);
+    } catch {
+      return [];
+    }
+    return entries.filter((entry) => /^\d+$/.test(entry));
+  };
+
+  private readSpawn = (
+    processIdDirectory: string,
+  ): TakeOwnershipSpawn | null => {
+    const rawCmdline = this.readRawCmdline(processIdDirectory);
+    if (rawCmdline === null) {
+      return null;
+    }
+    const commandArguments = parseCommandLineArguments(rawCmdline);
+    if (!isTakeOwnershipSpawn(commandArguments)) {
+      return null;
+    }
+    const logPath = extractLogPath(rawCmdline);
+    if (logPath === null) {
+      return null;
+    }
+    const environ = this.readEnviron(processIdDirectory);
+    if (environ === null) {
+      return null;
+    }
+    const token = environ.get(OAUTH_TOKEN_ENVIRON_KEY);
+    if (token === undefined || token.length === 0) {
+      return null;
+    }
+    return { token, logPath };
+  };
+
+  private readRawCmdline = (processIdDirectory: string): string | null => {
+    const cmdlinePath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'cmdline',
+    );
+    try {
+      return fs.readFileSync(cmdlinePath, 'utf8');
+    } catch {
+      return null;
+    }
+  };
+
+  private readEnviron = (
+    processIdDirectory: string,
+  ): Map<string, string> | null => {
+    const environPath = path.join(
+      this.procDirectory,
+      processIdDirectory,
+      'environ',
+    );
+    let raw: string;
+    try {
+      raw = fs.readFileSync(environPath, 'utf8');
+    } catch {
+      return null;
+    }
+    const environ = new Map<string, string>();
+    for (const entry of raw.split('\0')) {
+      if (entry.length === 0) {
+        continue;
+      }
+      const separatorIndex = entry.indexOf('=');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+      const key = entry.slice(0, separatorIndex);
+      const value = entry.slice(separatorIndex + 1);
+      environ.set(key, value);
+    }
+    return environ;
+  };
+}

package/src/domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository.ts

@@ -0,0 +1,8 @@
+export type TakeOwnershipSpawn = {
+  token: string;
+  logPath: string;
+};
+
+export interface TakeOwnershipSpawnRepository {
+  listSpawns: () => TakeOwnershipSpawn[];
+}

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.test.ts

@@ -0,0 +1,159 @@
+import { Issue } from '../../entities/Issue';
+import { GenerateDashboardRowUseCase } from './GenerateDashboardRowUseCase';
+
+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: [],
+    ...overrides,
+  };
+};
+
+describe('GenerateDashboardRowUseCase', () => {
+  const usecase = new GenerateDashboardRowUseCase();
+
+  beforeEach(() => {
+    issueCounter = 0;
+  });
+
+  it('returns all-zero counts for an empty issue list', () => {
+    expect(usecase.run({ issues: [], assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts actionable Unread, Todo, Awaiting Quality Check and Awaiting Workspace issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread' }),
+      makeIssue({ status: 'Todo by human' }),
+      makeIssue({ status: 'Awaiting Quality Check' }),
+      makeIssue({ status: 'Awaiting Workspace' }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 1,
+      todo: 1,
+      qc: 1,
+      fail: 0,
+      pr: 0,
+      ws: 1,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('excludes non-actionable issues from actionable status columns', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', nextActionDate: new Date() }),
+      makeIssue({ status: 'Unread', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Awaiting Quality Check',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Todo by human', assignees: ['someone-else'] }),
+      makeIssue({ status: 'Awaiting Workspace', isClosed: true }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 0,
+      pr: 0,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts Preparation and Failed Preparation by whole status without the actionable predicate', () => {
+    const issues = [
+      makeIssue({ status: 'Preparation', nextActionHour: 9 }),
+      makeIssue({
+        status: 'Failed Preparation',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+      makeIssue({ status: 'Preparation', isClosed: true }),
+      makeIssue({ status: 'Failed Preparation', assignees: ['someone-else'] }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toEqual({
+      unread: 0,
+      todo: 0,
+      qc: 0,
+      fail: 1,
+      pr: 1,
+      ws: 0,
+      dep: 0,
+      blocker: 0,
+    });
+  });
+
+  it('counts dep as Awaiting Workspace issues blocked by a dependency, and never as ws', () => {
+    const issues = [
+      makeIssue({ status: 'Awaiting Workspace' }),
+      makeIssue({
+        status: 'Awaiting Workspace',
+        dependedIssueUrls: ['https://github.com/demo/repo/issues/999'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE })).toMatchObject({
+      ws: 1,
+      dep: 1,
+    });
+  });
+
+  it('counts blocker by case-insensitive workflow blocker story membership for non-closed mine issues', () => {
+    const issues = [
+      makeIssue({ status: 'Unread', story: 'Workflow Blocker / urgent' }),
+      makeIssue({ status: 'Awaiting Workspace', story: 'workflow blocker' }),
+      makeIssue({ status: 'Unread', story: 'regular / maintenance' }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        isClosed: true,
+      }),
+      makeIssue({
+        status: 'Unread',
+        story: 'workflow blocker',
+        assignees: ['someone-else'],
+      }),
+    ];
+
+    expect(usecase.run({ issues, assigneeLogin: ASSIGNEE }).blocker).toBe(2);
+  });
+});

package/src/domain/usecases/dashboard/GenerateDashboardRowUseCase.ts

@@ -0,0 +1,72 @@
+import { Issue } from '../../entities/Issue';
+import {
+  AWAITING_QUALITY_CHECK_STATUS_NAME,
+  AWAITING_WORKSPACE_STATUS_NAME,
+  DEFAULT_STATUS_NAME,
+  FAILED_PREPARATION_STATUS_NAME,
+  PREPARATION_STATUS_NAME,
+  TODO_STATUS_NAME,
+} from '../../entities/WorkflowStatus';
+
+export type DashboardRow = {
+  unread: number;
+  todo: number;
+  qc: number;
+  fail: number;
+  pr: number;
+  ws: number;
+  dep: number;
+  blocker: number;
+};
+
+export type GenerateDashboardRowInput = {
+  issues: Issue[];
+  assigneeLogin: string;
+};
+
+const WORKFLOW_BLOCKER_STORY_MARKER = 'workflow blocker';
+
+export class GenerateDashboardRowUseCase {
+  run = (input: GenerateDashboardRowInput): DashboardRow => {
+    const { issues, assigneeLogin } = input;
+
+    const mine = (issue: Issue): boolean =>
+      issue.isClosed === false && issue.assignees.includes(assigneeLogin);
+
+    const actionable = (issue: Issue): boolean =>
+      mine(issue) &&
+      issue.dependedIssueUrls.length === 0 &&
+      issue.nextActionDate === null &&
+      issue.nextActionHour === null;
+
+    const countActionableWithStatus = (statusName: string): number =>
+      issues.filter((issue) => issue.status === statusName && actionable(issue))
+        .length;
+
+    const countMineWithStatus = (statusName: string): number =>
+      issues.filter((issue) => mine(issue) && issue.status === statusName)
+        .length;
+
+    return {
+      unread: countActionableWithStatus(DEFAULT_STATUS_NAME),
+      todo: countActionableWithStatus(TODO_STATUS_NAME),
+      qc: countActionableWithStatus(AWAITING_QUALITY_CHECK_STATUS_NAME),
+      fail: countMineWithStatus(FAILED_PREPARATION_STATUS_NAME),
+      pr: countMineWithStatus(PREPARATION_STATUS_NAME),
+      ws: countActionableWithStatus(AWAITING_WORKSPACE_STATUS_NAME),
+      dep: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          issue.status === AWAITING_WORKSPACE_STATUS_NAME &&
+          issue.dependedIssueUrls.length > 0,
+      ).length,
+      blocker: issues.filter(
+        (issue) =>
+          mine(issue) &&
+          (issue.story ?? '')
+            .toLowerCase()
+            .includes(WORKFLOW_BLOCKER_STORY_MARKER),
+      ).length,
+    };
+  };
+}