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

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

@@ -0,0 +1,266 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Issue } from '../../../domain/entities/Issue';
+import { FieldOption, Project } from '../../../domain/entities/Project';
+import { writeInTmuxByHumanData } from './inTmuxByHumanDataWriter';
+
+const ASSIGNEE = 'owner-login';
+const CONSOLE_BASE_URL = 'https://console.example.test';
+const CONSOLE_TOKEN = 'test-token-value';
+
+const option = (
+  id: string,
+  name: string,
+  color: FieldOption['color'],
+): FieldOption => ({ id, name, color, description: '' });
+
+const project: Project = {
+  id: 'project-node-id',
+  url: 'https://github.com/orgs/demo/projects/1',
+  databaseId: 1,
+  name: 'demo',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field',
+    statuses: [option('st-tmux', 'In Tmux by human', 'RED')],
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story: {
+    name: 'story',
+    fieldId: 'story-field',
+    databaseId: 2,
+    stories: [option('s1', 'Story Alpha', 'BLUE')],
+    workflowManagementStory: { id: 'wm', name: 'workflow management' },
+  },
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+};
+
+const makeIssue = (overrides: Partial<Issue>): Issue => ({
+  nameWithOwner: 'demo/repo',
+  number: 1,
+  title: 'Issue 1',
+  state: 'OPEN',
+  status: 'In Tmux by human',
+  story: 'Story Alpha',
+  nextActionDate: null,
+  nextActionHour: null,
+  estimationMinutes: null,
+  dependedIssueUrls: [],
+  completionDate50PercentConfidence: null,
+  url: 'https://github.com/demo/repo/issues/1',
+  assignees: [ASSIGNEE],
+  labels: [],
+  org: 'demo',
+  repo: 'repo',
+  body: 'should never be written',
+  itemId: 'item-1',
+  isPr: false,
+  isInProgress: false,
+  isClosed: false,
+  createdAt: new Date('2026-06-13T08:18:45.000Z'),
+  author: 'someone',
+  ...overrides,
+});
+
+const baseParams = (outDir: string) => ({
+  inTmuxDataOutputDir: outDir,
+  inTmuxConsoleBaseUrl: CONSOLE_BASE_URL,
+  inTmuxConsoleToken: CONSOLE_TOKEN,
+  inTmuxProjectOrder: ['demo'],
+  pjcode: 'demo',
+  assigneeLogin: ASSIGNEE,
+  org: 'demo-org',
+  repo: 'demo-repo',
+  project,
+  issues: [makeIssue({})],
+});
+
+const readJson = (filePath: string): unknown =>
+  JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+describe('writeInTmuxByHumanData', () => {
+  let outDir: string;
+
+  beforeEach(() => {
+    outDir = fs.mkdtempSync(path.join(os.tmpdir(), 'intmux-out-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(outDir, { recursive: true, force: true });
+  });
+
+  const file = (name: string): string => path.join(outDir, name);
+
+  it('writes the four per-project files and the four index files', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    for (const name of [
+      'demo.json',
+      'demo.v2.json',
+      'demo.v3.json',
+      'demo.v4.json',
+      'index.json',
+      'index.v2.json',
+      'index.v3.json',
+      'index.v4.json',
+    ]) {
+      expect(fs.existsSync(file(name))).toBe(true);
+    }
+  });
+
+  it('writes pretty-printed JSON ending with a trailing newline', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const raw = fs.readFileSync(file('demo.json'), 'utf8');
+    expect(raw.endsWith('\n')).toBe(true);
+    expect(raw).toContain('\n  ');
+  });
+
+  it('writes the v1 shape with a flat url string array', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: ['https://github.com/demo/repo/issues/1'],
+      },
+    ]);
+  });
+
+  it('writes the v2 shape with url and title objects', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v2.json'))).toEqual([
+      {
+        story: 'Story Alpha',
+        urls: [
+          { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+        ],
+      },
+    ]);
+  });
+
+  it('writes the v3 document with overviewUrl and a token-free console url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v3.json'))).toEqual({
+      version: 3,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl: 'https://console.example.test/projects/demo/prs',
+      groups: [
+        {
+          story: 'Story Alpha',
+          urls: [
+            { url: 'https://github.com/demo/repo/issues/1', title: 'Issue 1' },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('writes the v4 document with the token-bearing console url and derived new issue url', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(readJson(file('demo.v4.json'))).toEqual({
+      version: 4,
+      overviewUrl: 'https://github.com/orgs/demo/projects/1',
+      tdpmConsoleUrl:
+        'https://console.example.test/projects/demo/prs?k=test-token-value',
+      newIssueUrl:
+        'https://github.com/demo-org/demo-repo/issues/new?assignees=owner-login',
+      groups: [
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+            },
+          ],
+        },
+      ],
+    });
+  });
+
+  it('writes index files listing configured projects whose per-project file exists', () => {
+    fs.writeFileSync(file('xmile.json'), '[]\n');
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxProjectOrder: ['demo', 'xmile', 'xcare'],
+    });
+    expect(readJson(file('index.json'))).toEqual({
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v2.json'))).toEqual({
+      version: 2,
+      projects: ['demo', 'xmile'],
+    });
+    expect(readJson(file('index.v3.json'))).toEqual({
+      version: 3,
+      projects: ['demo', 'xmile'],
+    });
+  });
+
+  it('builds the v4 index path from the output dir basename and the token', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    const basename = path.basename(outDir);
+    expect(readJson(file('index.v4.json'))).toEqual({
+      version: 4,
+      projects: [
+        { name: 'demo', path: `/${basename}/demo.v4.json?k=test-token-value` },
+      ],
+    });
+  });
+
+  it('skips the v4 file and the v4 index when the token is unset but still writes v1, v2, v3 and v1-v3 index', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleToken: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+    expect(fs.existsSync(file('index.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v3.json'))).toBe(true);
+    expect(fs.existsSync(file('index.v4.json'))).toBe(false);
+  });
+
+  it('skips the v3 and v4 files when the console base url is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxConsoleBaseUrl: undefined,
+    });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v2.json'))).toBe(true);
+    expect(fs.existsSync(file('demo.v3.json'))).toBe(false);
+    expect(fs.existsSync(file('demo.v4.json'))).toBe(false);
+  });
+
+  it('skips the index files when the project order is empty', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), inTmuxProjectOrder: [] });
+    expect(fs.existsSync(file('demo.json'))).toBe(true);
+    expect(fs.existsSync(file('index.json'))).toBe(false);
+  });
+
+  it('does not leave a temp file behind after writing', () => {
+    writeInTmuxByHumanData(baseParams(outDir));
+    expect(fs.existsSync(`${file('demo.json')}.tmp`)).toBe(false);
+  });
+
+  it('is a no-op when the output dir is unset', () => {
+    writeInTmuxByHumanData({
+      ...baseParams(outDir),
+      inTmuxDataOutputDir: undefined,
+    });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+
+  it('is a no-op when pjcode is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), pjcode: '' });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+
+  it('is a no-op when the assignee login is unset', () => {
+    writeInTmuxByHumanData({ ...baseParams(outDir), assigneeLogin: null });
+    expect(fs.readdirSync(outDir)).toHaveLength(0);
+  });
+});

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

@@ -0,0 +1,103 @@
+import fs from 'fs';
+import path from 'path';
+import type { Issue } from '../../../domain/entities/Issue';
+import type { Project } from '../../../domain/entities/Project';
+import {
+  GenerateInTmuxByHumanDataUseCase,
+  InTmuxByHumanData,
+} from '../../../domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase';
+
+export type InTmuxByHumanDataWriterParams = {
+  inTmuxDataOutputDir: string | null | undefined;
+  inTmuxConsoleBaseUrl: string | null | undefined;
+  inTmuxConsoleToken: string | null | undefined;
+  inTmuxProjectOrder: string[] | null | undefined;
+  pjcode: string | null | undefined;
+  assigneeLogin: string | null | undefined;
+  org: string;
+  repo: string;
+  project: Project;
+  issues: Issue[];
+};
+
+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, null, 2)}\n`);
+  fs.renameSync(tmpPath, filePath);
+};
+
+export const writeInTmuxByHumanData = (
+  params: InTmuxByHumanDataWriterParams,
+): void => {
+  const {
+    inTmuxDataOutputDir,
+    inTmuxConsoleBaseUrl,
+    inTmuxConsoleToken,
+    inTmuxProjectOrder,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    project,
+    issues,
+  } = params;
+  if (!inTmuxDataOutputDir || !pjcode || !assigneeLogin) {
+    return;
+  }
+
+  const data: InTmuxByHumanData = new GenerateInTmuxByHumanDataUseCase().run({
+    project,
+    issues,
+    pjcode,
+    assigneeLogin,
+    org,
+    repo,
+    consoleBaseUrl: inTmuxConsoleBaseUrl ?? null,
+    consoleToken: inTmuxConsoleToken ?? null,
+  });
+
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.json`), data.v1);
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, `${pjcode}.v2.json`), data.v2);
+  if (data.v3) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v3.json`),
+      data.v3,
+    );
+  }
+  if (data.v4) {
+    writeJsonAtomic(
+      path.join(inTmuxDataOutputDir, `${pjcode}.v4.json`),
+      data.v4,
+    );
+  }
+
+  if (!inTmuxProjectOrder || inTmuxProjectOrder.length === 0) {
+    return;
+  }
+  const presentProjects = inTmuxProjectOrder.filter((name) =>
+    fs.existsSync(path.join(inTmuxDataOutputDir, `${name}.json`)),
+  );
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.json'), {
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v2.json'), {
+    version: 2,
+    projects: presentProjects,
+  });
+  writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v3.json'), {
+    version: 3,
+    projects: presentProjects,
+  });
+  if (inTmuxConsoleToken) {
+    const outputDirBasename = path.basename(inTmuxDataOutputDir);
+    writeJsonAtomic(path.join(inTmuxDataOutputDir, 'index.v4.json'), {
+      version: 4,
+      projects: presentProjects.map((name) => ({
+        name,
+        path: `/${outputDirBasename}/${name}.v4.json?k=${inTmuxConsoleToken}`,
+      })),
+    });
+  }
+};

package/src/domain/usecases/intmux/GenerateInTmuxByHumanDataUseCase.test.ts

@@ -0,0 +1,285 @@
+import { Issue } from '../../entities/Issue';
+import { FieldOption, Project } from '../../entities/Project';
+import { GenerateInTmuxByHumanDataUseCase } from './GenerateInTmuxByHumanDataUseCase';
+
+const ASSIGNEE = 'owner-login';
+const CONSOLE_BASE_URL = 'https://console.example.test';
+const CONSOLE_TOKEN = 'test-token-value';
+
+const storyOption = (
+  id: string,
+  name: string,
+  color: FieldOption['color'],
+): FieldOption => ({ id, name, color, description: '' });
+
+const STORY_OPTIONS: FieldOption[] = [
+  storyOption('s1', 'Story Alpha', 'BLUE'),
+  storyOption('s2', 'Story Beta', 'GREEN'),
+];
+
+const STATUS_OPTIONS: FieldOption[] = [
+  storyOption('st-unread', 'Unread', 'ORANGE'),
+  storyOption('st-tmux', 'In Tmux by human', 'RED'),
+  storyOption('st-done', 'Done', 'PURPLE'),
+];
+
+const baseProject = (story: Project['story']): Project => ({
+  id: 'project-node-id',
+  url: 'https://github.com/orgs/demo/projects/1',
+  databaseId: 1,
+  name: 'demo',
+  status: {
+    name: 'Status',
+    fieldId: 'status-field',
+    statuses: STATUS_OPTIONS,
+  },
+  nextActionDate: null,
+  nextActionHour: null,
+  story,
+  remainingEstimationMinutes: null,
+  dependedIssueUrlSeparatedByComma: null,
+  completionDate50PercentConfidence: null,
+});
+
+const projectWithStory: Project = baseProject({
+  name: 'story',
+  fieldId: 'story-field',
+  databaseId: 2,
+  stories: STORY_OPTIONS,
+  workflowManagementStory: { id: 'wm', name: 'workflow management' },
+});
+
+const projectWithoutStory: Project = baseProject(null);
+
+let issueCounter = 0;
+const makeIssue = (overrides: Partial<Issue>): Issue => {
+  issueCounter += 1;
+  return {
+    nameWithOwner: 'demo/repo',
+    number: issueCounter,
+    title: `Issue ${issueCounter}`,
+    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/${issueCounter}`,
+    assignees: [ASSIGNEE],
+    labels: [],
+    org: 'demo',
+    repo: 'repo',
+    body: 'should never be projected',
+    itemId: `item-${issueCounter}`,
+    isPr: false,
+    isInProgress: false,
+    isClosed: false,
+    createdAt: new Date('2026-06-13T08:18:45.000Z'),
+    author: 'someone',
+    ...overrides,
+  };
+};
+
+describe('GenerateInTmuxByHumanDataUseCase', () => {
+  const usecase = new GenerateInTmuxByHumanDataUseCase();
+
+  beforeEach(() => {
+    issueCounter = 0;
+  });
+
+  const run = (
+    issues: Issue[],
+    overrides: {
+      project?: Project;
+      consoleBaseUrl?: string | null;
+      consoleToken?: string | null;
+    } = {},
+  ) =>
+    usecase.run({
+      project: overrides.project ?? projectWithStory,
+      issues,
+      pjcode: 'demo',
+      assigneeLogin: ASSIGNEE,
+      org: 'demo-org',
+      repo: 'demo-repo',
+      consoleBaseUrl:
+        overrides.consoleBaseUrl === undefined
+          ? CONSOLE_BASE_URL
+          : overrides.consoleBaseUrl,
+      consoleToken:
+        overrides.consoleToken === undefined
+          ? CONSOLE_TOKEN
+          : overrides.consoleToken,
+    });
+
+  describe('item filter', () => {
+    it('keeps In Tmux by human open issues assigned to the assignee login', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v1).toEqual([
+        {
+          story: 'Story Alpha',
+          urls: ['https://github.com/demo/repo/issues/1'],
+        },
+      ]);
+    });
+
+    it('rejects issues whose status is not In Tmux by human', () => {
+      const result = run([makeIssue({ status: 'Unread' })]);
+      expect(result.v1).toEqual([]);
+    });
+
+    it('rejects closed issues', () => {
+      const result = run([makeIssue({ isClosed: true })]);
+      expect(result.v1).toEqual([]);
+    });
+
+    it('rejects issues not assigned to the assignee login', () => {
+      const result = run([makeIssue({ assignees: ['other-person'] })]);
+      expect(result.v1).toEqual([]);
+    });
+  });
+
+  describe('story grouping and ordering', () => {
+    it('orders groups by the project story option display order', () => {
+      const result = run([
+        makeIssue({ story: 'Story Beta' }),
+        makeIssue({ story: 'Story Alpha' }),
+      ]);
+      expect(result.v2.map((group) => group.story)).toEqual([
+        'Story Alpha',
+        'Story Beta',
+      ]);
+    });
+
+    it('places stories not present in the story options at the tail ordered by story string', () => {
+      const result = run([
+        makeIssue({ story: 'zzz unknown' }),
+        makeIssue({ story: 'Story Alpha' }),
+        makeIssue({ story: 'aaa unknown' }),
+      ]);
+      expect(result.v2.map((group) => group.story)).toEqual([
+        'Story Alpha',
+        'aaa unknown',
+        'zzz unknown',
+      ]);
+    });
+
+    it('maps a null story to the empty string group', () => {
+      const result = run([makeIssue({ story: null })]);
+      expect(result.v1.map((group) => group.story)).toEqual(['']);
+    });
+
+    it('keeps input order of issues within a group', () => {
+      const result = run([
+        makeIssue({ story: 'Story Alpha' }),
+        makeIssue({ story: 'Story Alpha' }),
+      ]);
+      expect(result.v2[0].urls).toEqual([
+        {
+          url: 'https://github.com/demo/repo/issues/1',
+          title: 'Issue 1',
+        },
+        {
+          url: 'https://github.com/demo/repo/issues/2',
+          title: 'Issue 2',
+        },
+      ]);
+    });
+
+    it('uses an empty story order when the project has no story field', () => {
+      const result = run([makeIssue({ story: 'whatever' })], {
+        project: projectWithoutStory,
+      });
+      expect(result.v2.map((group) => group.story)).toEqual(['whatever']);
+    });
+  });
+
+  describe('v3 document', () => {
+    it('builds version 3 with overviewUrl from the project and a token-free console url', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v3).toEqual({
+        version: 3,
+        overviewUrl: 'https://github.com/orgs/demo/projects/1',
+        tdpmConsoleUrl: 'https://console.example.test/projects/demo/prs',
+        groups: result.v2,
+      });
+    });
+
+    it('is null when the console base url is unset', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })], {
+        consoleBaseUrl: null,
+      });
+      expect(result.v3).toBeNull();
+      expect(result.v4).toBeNull();
+    });
+  });
+
+  describe('v4 document', () => {
+    it('builds version 4 with key order version, overviewUrl, tdpmConsoleUrl, newIssueUrl, groups', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v4).not.toBeNull();
+      expect(Object.keys(result.v4 ?? {})).toEqual([
+        'version',
+        'overviewUrl',
+        'tdpmConsoleUrl',
+        'newIssueUrl',
+        'groups',
+      ]);
+    });
+
+    it('embeds the token in the console url and derives the new issue url from org and repo', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })]);
+      expect(result.v4).toEqual({
+        version: 4,
+        overviewUrl: 'https://github.com/orgs/demo/projects/1',
+        tdpmConsoleUrl:
+          'https://console.example.test/projects/demo/prs?k=test-token-value',
+        newIssueUrl:
+          'https://github.com/demo-org/demo-repo/issues/new?assignees=owner-login',
+        groups: [
+          {
+            story: 'Story Alpha',
+            sessions: [
+              {
+                name: 'https://github.com/demo/repo/issues/1',
+                description: 'Issue 1',
+              },
+            ],
+          },
+        ],
+      });
+    });
+
+    it('maps each session to the issue url as name and the issue title as description', () => {
+      const result = run([
+        makeIssue({ story: 'Story Alpha' }),
+        makeIssue({ story: 'Story Alpha' }),
+      ]);
+      expect(result.v4?.groups).toEqual([
+        {
+          story: 'Story Alpha',
+          sessions: [
+            {
+              name: 'https://github.com/demo/repo/issues/1',
+              description: 'Issue 1',
+            },
+            {
+              name: 'https://github.com/demo/repo/issues/2',
+              description: 'Issue 2',
+            },
+          ],
+        },
+      ]);
+    });
+
+    it('is null when the console token is unset while v3 is still produced', () => {
+      const result = run([makeIssue({ story: 'Story Alpha' })], {
+        consoleToken: null,
+      });
+      expect(result.v4).toBeNull();
+      expect(result.v3).not.toBeNull();
+    });
+  });
+});