github-issue-tower-defence-management 1.152.3 → 1.153.0

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

@@ -0,0 +1,109 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+import { cleanClosedIssueOwnerCallFiles } from './ownerCallFileCleaner';
+import { ownerCallFileAppend, ownerCallFilePath } from './ownerCallFileStore';
+
+const makeIssue = (overrides: Partial<Issue> = {}): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: 'In Tmux by human',
+  story: null,
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: ['owner-login'],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: '',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-08-01T00:00:00.000Z'),
+  author: '',
+  closingIssueReferenceUrls: [],
+  ...overrides,
+});
+
+describe('cleanClosedIssueOwnerCallFiles', () => {
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-cleaner-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const appendCallFor = (issue: Issue): string => {
+    const sessionName = toTmuxSessionName(issue.url);
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'an unanswered call\n',
+      },
+    });
+    return ownerCallFilePath(dataDir, 'umino', sessionName);
+  };
+
+  it('deletes the owner call file of a session whose issue is closed', () => {
+    const closedIssue = makeIssue({
+      url: 'https://github.com/demo/repo/issues/7',
+      state: 'CLOSED',
+      isClosed: true,
+    });
+    const filePath = appendCallFor(closedIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: 'umino',
+      issues: [closedIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(false);
+  });
+
+  it('keeps the owner call file of a session whose issue is still open', () => {
+    const openIssue = makeIssue();
+    const filePath = appendCallFor(openIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: 'umino',
+      issues: [openIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(true);
+  });
+
+  it('does nothing when the data directory or the project code is not configured', () => {
+    const closedIssue = makeIssue({ isClosed: true, state: 'CLOSED' });
+    const filePath = appendCallFor(closedIssue);
+
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: null,
+      pjcode: 'umino',
+      issues: [closedIssue],
+    });
+    cleanClosedIssueOwnerCallFiles({
+      inTmuxDataOutputDir: dataDir,
+      pjcode: null,
+      issues: [closedIssue],
+    });
+
+    expect(fs.existsSync(filePath)).toBe(true);
+  });
+});

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

@@ -0,0 +1,25 @@
+import { Issue } from '../../../domain/entities/Issue';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+import { ownerCallFileDelete } from './ownerCallFileStore';
+
+export type CleanClosedIssueOwnerCallFilesParams = {
+  inTmuxDataOutputDir: string | null | undefined;
+  pjcode: string | null | undefined;
+  issues: Issue[];
+};
+
+export const cleanClosedIssueOwnerCallFiles = (
+  params: CleanClosedIssueOwnerCallFilesParams,
+): void => {
+  const { inTmuxDataOutputDir, pjcode, issues } = params;
+  if (!inTmuxDataOutputDir || !pjcode) {
+    return;
+  }
+  for (const issue of issues.filter((candidate) => candidate.isClosed)) {
+    ownerCallFileDelete({
+      dataDir: inTmuxDataOutputDir,
+      projectCode: pjcode,
+      sessionName: toTmuxSessionName(issue.url),
+    });
+  }
+};

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

@@ -0,0 +1,286 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { parseAllDocuments } from 'yaml';
+import {
+  ownerCallFileAppend,
+  ownerCallFileDelete,
+  ownerCallFileDeleteInEveryProject,
+  ownerCallFilePath,
+  ownerCallProjectCodeInInTmuxByHumanData,
+} from './ownerCallFileStore';
+import { ownerCallFileRelativePath } from '../../../domain/usecases/intmux/OwnerCallFile';
+import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
+
+const toPlainValue = (document: { toJS: () => unknown }): unknown =>
+  document.toJS();
+
+describe('ownerCallFileStore', () => {
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-store-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const sessionName = 'https_//github_com/OWNER/REPO/issues/1';
+
+  it('creates the file and its project directory on the first append', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+
+    const filePath = path.join(
+      dataDir,
+      ownerCallFileRelativePath('umino', sessionName),
+    );
+    expect(fs.existsSync(filePath)).toBe(true);
+    const documents = parseAllDocuments(fs.readFileSync(filePath, 'utf-8'));
+    expect(documents).toHaveLength(1);
+    expect(documents[0].toJS()).toEqual({
+      sessionName,
+      calledAt: '2026-08-14T04:22:28Z',
+      body: 'the only call\n',
+    });
+  });
+
+  it('appends a second document after the first one, oldest first', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the older call\n',
+      },
+    });
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T05:00:00Z',
+        body: 'the newer call\n',
+      },
+    });
+
+    const documents = parseAllDocuments(
+      fs.readFileSync(
+        ownerCallFilePath(dataDir, 'umino', sessionName),
+        'utf-8',
+      ),
+    );
+    expect(documents.map(toPlainValue)).toEqual([
+      {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the older call\n',
+      },
+      {
+        sessionName,
+        calledAt: '2026-08-14T05:00:00Z',
+        body: 'the newer call\n',
+      },
+    ]);
+  });
+
+  it('writes the file of a session that belongs to no project under NA', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: null,
+      ownerCall: {
+        sessionName: 'secretary',
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'a call from a long running session\n',
+      },
+    });
+
+    expect(
+      fs.existsSync(
+        path.join(dataDir, ownerCallFileRelativePath(null, 'secretary')),
+      ),
+    ).toBe(true);
+  });
+
+  it('removes the file of the named project', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+
+    ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName });
+
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
+    ).toBe(false);
+  });
+
+  it('succeeds when the file to delete is already absent', () => {
+    expect(() =>
+      ownerCallFileDelete({ dataDir, projectCode: 'umino', sessionName }),
+    ).not.toThrow();
+  });
+
+  it('removes the file of a session whose project code the caller does not know', () => {
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'umino',
+      ownerCall: {
+        sessionName,
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'the only call\n',
+      },
+    });
+    ownerCallFileAppend({
+      dataDir,
+      projectCode: 'other',
+      ownerCall: {
+        sessionName: 'other_session',
+        calledAt: '2026-08-14T04:22:28Z',
+        body: 'a call of another session\n',
+      },
+    });
+
+    ownerCallFileDeleteInEveryProject({ dataDir, sessionName });
+
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'umino', sessionName)),
+    ).toBe(false);
+    expect(
+      fs.existsSync(ownerCallFilePath(dataDir, 'other', 'other_session')),
+    ).toBe(true);
+  });
+
+  it('succeeds when no owner call directory exists at all', () => {
+    expect(() =>
+      ownerCallFileDeleteInEveryProject({ dataDir, sessionName }),
+    ).not.toThrow();
+  });
+});
+
+describe('ownerCallProjectCodeInInTmuxByHumanData', () => {
+  const issueUrl = 'https://github.com/OWNER/REPO/issues/1';
+  const otherIssueUrl = 'https://github.com/OWNER/REPO/issues/2';
+  let dataDir = '';
+
+  beforeEach(() => {
+    dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'owner-call-project-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(dataDir, { recursive: true, force: true });
+  });
+
+  const writeProjectData = (projectCode: string, urls: string[]): void => {
+    fs.writeFileSync(
+      path.join(dataDir, `${projectCode}.v4.json`),
+      `${JSON.stringify({
+        version: 4,
+        overviewUrl: 'https://github.com/orgs/OWNER/projects/1',
+        tdpmConsoleUrl: 'http://localhost/projects/code',
+        newIssueUrl: 'https://github.com/OWNER/REPO/issues/new',
+        groups: [
+          {
+            story: 'a story',
+            sessions: urls.map((url) => ({ name: url, description: 'title' })),
+          },
+        ],
+      })}\n`,
+    );
+  };
+
+  it('gives the code of the project whose session list holds the session', () => {
+    writeProjectData('other', [otherIssueUrl]);
+    writeProjectData('umino', [issueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBe('umino');
+  });
+
+  it('gives null when no project lists the session', () => {
+    writeProjectData('umino', [otherIssueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('gives null when the directory holds no in-tmux-by-human data at all', () => {
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('gives null when the directory itself is absent', () => {
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        path.join(dataDir, 'absent'),
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('reads neither the project index nor the older versions of the project data', () => {
+    fs.writeFileSync(
+      path.join(dataDir, 'index.v4.json'),
+      `${JSON.stringify({
+        version: 4,
+        projects: [{ name: 'umino', path: '/in-tmux-by-human/umino.v4.json' }],
+      })}\n`,
+    );
+    fs.writeFileSync(
+      path.join(dataDir, 'umino.v3.json'),
+      `${JSON.stringify({
+        version: 3,
+        groups: [{ story: 'a story', urls: [{ url: issueUrl, title: 't' }] }],
+      })}\n`,
+    );
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBeNull();
+  });
+
+  it('skips a project data file that cannot be read as the expected shape', () => {
+    fs.writeFileSync(path.join(dataDir, 'broken.v4.json'), 'not json at all\n');
+    fs.writeFileSync(
+      path.join(dataDir, 'shapeless.v4.json'),
+      `${JSON.stringify({ version: 4, groups: 'not a list' })}\n`,
+    );
+    writeProjectData('umino', [issueUrl]);
+
+    expect(
+      ownerCallProjectCodeInInTmuxByHumanData(
+        dataDir,
+        toTmuxSessionName(issueUrl),
+      ),
+    ).toBe('umino');
+  });
+});

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

@@ -0,0 +1,145 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  OWNER_CALL_FILE_DIRECTORY_NAME,
+  OwnerCall,
+  OwnerCallProjectSessionNames,
+  ownerCallFileRelativePath,
+  ownerCallProjectCodeOfSession,
+  ownerCallYamlDocument,
+} from '../../../domain/usecases/intmux/OwnerCallFile';
+
+export type OwnerCallFileAppendParams = {
+  dataDir: string;
+  projectCode: string | null;
+  ownerCall: OwnerCall;
+};
+
+export type OwnerCallFileDeleteParams = {
+  dataDir: string;
+  projectCode: string | null;
+  sessionName: string;
+};
+
+export type OwnerCallFileDeleteInEveryProjectParams = {
+  dataDir: string;
+  sessionName: string;
+};
+
+export const ownerCallFilePath = (
+  dataDir: string,
+  projectCode: string | null,
+  sessionName: string,
+): string =>
+  path.join(dataDir, ownerCallFileRelativePath(projectCode, sessionName));
+
+export const ownerCallFileAppend = (
+  params: OwnerCallFileAppendParams,
+): void => {
+  const filePath = ownerCallFilePath(
+    params.dataDir,
+    params.projectCode,
+    params.ownerCall.sessionName,
+  );
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, ownerCallYamlDocument(params.ownerCall));
+};
+
+export const ownerCallFileDelete = (
+  params: OwnerCallFileDeleteParams,
+): void => {
+  fs.rmSync(
+    ownerCallFilePath(params.dataDir, params.projectCode, params.sessionName),
+    { force: true },
+  );
+};
+
+const projectCodeDirectoryNames = (dataDir: string): string[] => {
+  const ownerCallDirectory = path.join(dataDir, OWNER_CALL_FILE_DIRECTORY_NAME);
+  if (!fs.existsSync(ownerCallDirectory)) {
+    return [];
+  }
+  return fs
+    .readdirSync(ownerCallDirectory, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+};
+
+export const ownerCallFileDeleteInEveryProject = (
+  params: OwnerCallFileDeleteInEveryProjectParams,
+): void => {
+  for (const projectCode of projectCodeDirectoryNames(params.dataDir)) {
+    ownerCallFileDelete({
+      dataDir: params.dataDir,
+      projectCode,
+      sessionName: params.sessionName,
+    });
+  }
+};
+
+// The in-tmux-by-human data the scheduled run writes into the same directory
+// serveWeb serves: one `{projectCode}.v4.json` per project, each listing the
+// sessions of that project. `index.v4.json` only names the project files, so
+// it is not read here.
+const IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX = '.v4.json';
+const IN_TMUX_BY_HUMAN_INDEX_FILE_NAME = `index${IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX}`;
+
+const isUnknownArray = (value: unknown): value is unknown[] =>
+  Array.isArray(value);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const arrayOrEmpty = (value: unknown): unknown[] =>
+  isUnknownArray(value) ? value : [];
+
+const propertyOrUndefined = (value: unknown, key: string): unknown =>
+  isRecord(value) ? value[key] : undefined;
+
+const sessionNamesInProjectDataFile = (filePath: string): string[] => {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return [];
+  }
+  return arrayOrEmpty(propertyOrUndefined(parsed, 'groups')).flatMap((group) =>
+    arrayOrEmpty(propertyOrUndefined(group, 'sessions'))
+      .map((session) => propertyOrUndefined(session, 'name'))
+      .filter((name): name is string => typeof name === 'string'),
+  );
+};
+
+const inTmuxByHumanProjectSessionNames = (
+  dataDir: string,
+): OwnerCallProjectSessionNames[] => {
+  if (!fs.existsSync(dataDir)) {
+    return [];
+  }
+  return fs
+    .readdirSync(dataDir, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isFile() &&
+        entry.name.endsWith(IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX) &&
+        entry.name !== IN_TMUX_BY_HUMAN_INDEX_FILE_NAME,
+    )
+    .map((entry) => ({
+      projectCode: entry.name.slice(
+        0,
+        entry.name.length - IN_TMUX_BY_HUMAN_PROJECT_DATA_SUFFIX.length,
+      ),
+      sessionNames: sessionNamesInProjectDataFile(
+        path.join(dataDir, entry.name),
+      ),
+    }));
+};
+
+export const ownerCallProjectCodeInInTmuxByHumanData = (
+  dataDir: string,
+  sessionName: string,
+): string | null =>
+  ownerCallProjectCodeOfSession(
+    inTmuxByHumanProjectSessionNames(dataDir),
+    sessionName,
+  );