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

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

@@ -1,188 +0,0 @@
-import { Issue } from '../../entities/Issue';
-import { FieldOption, Project } from '../../entities/Project';
-
-export type InTmuxByHumanUrlEntry = {
-  url: string;
-  title: string;
-};
-
-export type InTmuxByHumanGroupV1 = {
-  story: string;
-  urls: string[];
-};
-
-export type InTmuxByHumanGroupV2 = {
-  story: string;
-  urls: InTmuxByHumanUrlEntry[];
-};
-
-export type InTmuxByHumanSession = {
-  name: string;
-  description: string;
-};
-
-export type InTmuxByHumanGroupV4 = {
-  story: string;
-  sessions: InTmuxByHumanSession[];
-};
-
-export type InTmuxByHumanV3 = {
-  version: 3;
-  overviewUrl: string;
-  tdpmConsoleUrl: string;
-  groups: InTmuxByHumanGroupV2[];
-};
-
-export type InTmuxByHumanV4 = {
-  version: 4;
-  overviewUrl: string;
-  tdpmConsoleUrl: string;
-  newIssueUrl: string;
-  groups: InTmuxByHumanGroupV4[];
-};
-
-export type InTmuxByHumanData = {
-  v1: InTmuxByHumanGroupV1[];
-  v2: InTmuxByHumanGroupV2[];
-  v3: InTmuxByHumanV3 | null;
-  v4: InTmuxByHumanV4 | null;
-};
-
-export type GenerateInTmuxByHumanDataInput = {
-  project: Project;
-  issues: Issue[];
-  pjcode: string;
-  assigneeLogin: string;
-  org: string;
-  repo: string;
-  newIssueRepo?: string;
-  consoleBaseUrl: string | null;
-  consoleToken: string | null;
-  now: Date;
-};
-
-type InTmuxByHumanStoryGroup = {
-  story: string;
-  issues: Issue[];
-};
-
-const IN_TMUX_BY_HUMAN_STATUS_NAME = 'In Tmux by human';
-const UNKNOWN_STORY_SORT_INDEX = 999999;
-
-export class GenerateInTmuxByHumanDataUseCase {
-  run = (input: GenerateInTmuxByHumanDataInput): InTmuxByHumanData => {
-    const {
-      project,
-      issues,
-      pjcode,
-      assigneeLogin,
-      org,
-      repo,
-      newIssueRepo,
-      consoleBaseUrl,
-      consoleToken,
-    } = input;
-
-    const storyOrder = project.story
-      ? project.story.stories.map((option: FieldOption) => option.name)
-      : [];
-
-    const selectedIssues = issues.filter((issue) =>
-      this.isInTmuxByHuman(issue, assigneeLogin),
-    );
-
-    const groups = this.groupByStoryOrder(selectedIssues, storyOrder);
-
-    const v2: InTmuxByHumanGroupV2[] = groups.map((group) => ({
-      story: group.story,
-      urls: group.issues.map((issue) => ({
-        url: issue.url,
-        title: issue.title,
-      })),
-    }));
-
-    const v1: InTmuxByHumanGroupV1[] = groups.map((group) => ({
-      story: group.story,
-      urls: group.issues.map((issue) => issue.url),
-    }));
-
-    const v4Groups: InTmuxByHumanGroupV4[] = groups.map((group) => ({
-      story: group.story,
-      sessions: group.issues.map((issue) => ({
-        name: issue.url,
-        description: issue.title,
-      })),
-    }));
-
-    const overviewUrl = project.url;
-    const tdpmConsoleUrl = consoleBaseUrl
-      ? `${consoleBaseUrl}/projects/${pjcode}`
-      : null;
-
-    const v3: InTmuxByHumanV3 | null = tdpmConsoleUrl
-      ? {
-          version: 3,
-          overviewUrl,
-          tdpmConsoleUrl,
-          groups: v2,
-        }
-      : null;
-
-    const v4: InTmuxByHumanV4 | null =
-      tdpmConsoleUrl && consoleToken
-        ? {
-            version: 4,
-            overviewUrl,
-            tdpmConsoleUrl: `${tdpmConsoleUrl}?k=${consoleToken}`,
-            newIssueUrl: `https://github.com/${org}/${newIssueRepo ?? repo}/issues/new?assignees=${assigneeLogin}`,
-            groups: v4Groups,
-          }
-        : null;
-
-    return { v1, v2, v3, v4 };
-  };
-
-  private isInTmuxByHuman = (issue: Issue, assigneeLogin: string): boolean =>
-    issue.status === IN_TMUX_BY_HUMAN_STATUS_NAME &&
-    issue.isClosed === false &&
-    issue.assignees.includes(assigneeLogin) &&
-    issue.dependedIssueUrls.length === 0 &&
-    issue.nextActionDate === null &&
-    issue.nextActionHour === null;
-
-  private groupByStoryOrder = (
-    issues: Issue[],
-    storyOrder: string[],
-  ): InTmuxByHumanStoryGroup[] => {
-    const indexByStory = new Map(
-      storyOrder.map((name, index) => [name, index]),
-    );
-    const issuesByStory = new Map<string, Issue[]>();
-    for (const issue of issues) {
-      const story = issue.story ?? '';
-      const existing = issuesByStory.get(story);
-      if (existing) {
-        existing.push(issue);
-      } else {
-        issuesByStory.set(story, [issue]);
-      }
-    }
-    return [...issuesByStory.entries()]
-      .map(([story, groupedIssues]) => ({
-        story,
-        issues: groupedIssues,
-        sortIndex: indexByStory.get(story) ?? UNKNOWN_STORY_SORT_INDEX,
-      }))
-      .sort((left, right) =>
-        left.sortIndex !== right.sortIndex
-          ? left.sortIndex - right.sortIndex
-          : left.story < right.story
-            ? -1
-            : 1,
-      )
-      .map(({ story, issues: groupedIssues }) => ({
-        story,
-        issues: groupedIssues,
-      }));
-  };
-}

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

@@ -1,389 +0,0 @@
-import { Issue } from '../../entities/Issue';
-import { IN_TMUX_STATUS_NAME } from '../../entities/WorkflowStatus';
-import { IssueRepository } from '../adapter-interfaces/IssueRepository';
-import { TmuxSessionRepository } from '../adapter-interfaces/TmuxSessionRepository';
-import {
-  InTmuxByHumanSessionReconcileUseCase,
-  toTmuxSessionName,
-} from './InTmuxByHumanSessionReconcileUseCase';
-
-const ASSIGNEE = 'owner-login';
-const LAUNCHER = 'cl';
-const NOW = new Date('2026-06-25T12:00:00.000Z');
-
-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_STATUS_NAME,
-    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(),
-    author: '',
-    closingIssueReferenceUrls: [],
-    agent: null,
-    stateReason: null,
-    ...overrides,
-  };
-};
-
-const createFakeTmuxSessionRepository = (state: {
-  liveSessionNames: string[];
-  processCommandLines: string[];
-}): TmuxSessionRepository & {
-  launches: {
-    sessionName: string;
-    launcherCommand: string;
-    issueUrl: string;
-  }[];
-} => {
-  const launches: {
-    sessionName: string;
-    launcherCommand: string;
-    issueUrl: string;
-  }[] = [];
-  return {
-    launches,
-    listLiveSessionNames: async () => state.liveSessionNames,
-    listLiveSessionsWithActivity: async () =>
-      state.liveSessionNames.map((sessionName) => ({
-        sessionName,
-        activityEpochSeconds: 0,
-      })),
-    listInteractiveProcessCommandLines: async () => state.processCommandLines,
-    launchDetachedSession: async (sessionName, launcherCommand, issueUrl) => {
-      launches.push({ sessionName, launcherCommand, issueUrl });
-    },
-    killSession: async () => undefined,
-    killOwnSession: async () => undefined,
-    sendKeys: async () => undefined,
-    launchBareNameLeaderSession: async () => undefined,
-    attachOrCreateInteractiveSession: async () => undefined,
-  };
-};
-
-const createFakeIssueStateRepository = (
-  stateByUrl: Record<string, string> = {},
-): Pick<IssueRepository, 'getIssueOrPullRequestState'> & {
-  fetchedUrls: string[];
-} => {
-  const fetchedUrls: string[] = [];
-  return {
-    fetchedUrls,
-    getIssueOrPullRequestState: async (url: string) => {
-      fetchedUrls.push(url);
-      return {
-        state: stateByUrl[url] ?? 'open',
-        merged: false,
-        isPullRequest: false,
-        title: `Title of ${url}`,
-      };
-    },
-  };
-};
-
-describe('InTmuxByHumanSessionReconcileUseCase', () => {
-  beforeEach(() => {
-    issueCounter = 0;
-  });
-
-  it('launches a detached session for an In Tmux by human issue with no live session', async () => {
-    const issue = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [issue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toEqual([
-      {
-        sessionName: toTmuxSessionName(issue.url),
-        launcherCommand: LAUNCHER,
-        issueUrl: issue.url,
-      },
-    ]);
-    expect(result.launchedIssueUrls).toEqual([issue.url]);
-  });
-
-  it('does not launch when a live session already exists for the issue', async () => {
-    const issue = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [toTmuxSessionName(issue.url)],
-      processCommandLines: [
-        `claude --model opus --agent leader --name ${issue.url}`,
-      ],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [issue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toEqual([]);
-    expect(result.launchedIssueUrls).toEqual([]);
-  });
-
-  it('treats a session as missing when the tmux session exists but no process advertises the issue url', async () => {
-    const issue = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [toTmuxSessionName(issue.url)],
-      processCommandLines: ['claude --model opus --name some-other-task'],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [issue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toHaveLength(1);
-    expect(result.launchedIssueUrls).toEqual([issue.url]);
-  });
-
-  it('launches only the missing sessions across multiple In Tmux by human issues', async () => {
-    const liveIssue = makeIssue();
-    const missingIssueOne = makeIssue();
-    const missingIssueTwo = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [toTmuxSessionName(liveIssue.url)],
-      processCommandLines: [`claude --model opus --name ${liveIssue.url}`],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [liveIssue, missingIssueOne, missingIssueTwo],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(result.launchedIssueUrls).toEqual([
-      missingIssueOne.url,
-      missingIssueTwo.url,
-    ]);
-    expect(repository.launches.map((launch) => launch.issueUrl)).toEqual([
-      missingIssueOne.url,
-      missingIssueTwo.url,
-    ]);
-  });
-
-  it('ignores issues that are not In Tmux by human, closed, or assigned to another login', async () => {
-    const otherStatusIssue = makeIssue({ status: 'Done' });
-    const closedIssue = makeIssue({ isClosed: true });
-    const otherAssigneeIssue = makeIssue({ assignees: ['someone-else'] });
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [otherStatusIssue, closedIssue, otherAssigneeIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toEqual([]);
-    expect(result.launchedIssueUrls).toEqual([]);
-  });
-
-  it('excludes an issue whose next action date is in the future', async () => {
-    const futureIssue = makeIssue({
-      nextActionDate: new Date(NOW.getTime() + 24 * 60 * 60 * 1000),
-    });
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [futureIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toEqual([]);
-    expect(result.launchedIssueUrls).toEqual([]);
-  });
-
-  it('excludes an issue whose next action hour is set', async () => {
-    const hourIssue = makeIssue({ nextActionHour: 9 });
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [hourIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(repository.launches).toEqual([]);
-    expect(result.launchedIssueUrls).toEqual([]);
-  });
-
-  it('includes an issue whose next action date is in the past and is now due', async () => {
-    const dueIssue = makeIssue({
-      nextActionDate: new Date(NOW.getTime() - 24 * 60 * 60 * 1000),
-    });
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      createFakeIssueStateRepository(),
-    );
-
-    const result = await useCase.run({
-      issues: [dueIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(result.launchedIssueUrls).toEqual([dueIssue.url]);
-  });
-
-  it('does not launch a session for an issue whose live GitHub state is closed even when the cached issue still reports it as open', async () => {
-    const staleCachedIssue = makeIssue({ isClosed: false });
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const issueStateRepository = createFakeIssueStateRepository({
-      [staleCachedIssue.url]: 'closed',
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      issueStateRepository,
-    );
-
-    const result = await useCase.run({
-      issues: [staleCachedIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(issueStateRepository.fetchedUrls).toEqual([staleCachedIssue.url]);
-    expect(repository.launches).toEqual([]);
-    expect(result.launchedIssueUrls).toEqual([]);
-  });
-
-  it('launches only the issues whose live GitHub state is open when a stale cached issue is mixed in', async () => {
-    const staleClosedIssue = makeIssue({ isClosed: false });
-    const openIssue = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [],
-      processCommandLines: [],
-    });
-    const issueStateRepository = createFakeIssueStateRepository({
-      [staleClosedIssue.url]: 'closed',
-      [openIssue.url]: 'open',
-    });
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      issueStateRepository,
-    );
-
-    const result = await useCase.run({
-      issues: [staleClosedIssue, openIssue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(result.launchedIssueUrls).toEqual([openIssue.url]);
-    expect(repository.launches.map((launch) => launch.issueUrl)).toEqual([
-      openIssue.url,
-    ]);
-  });
-
-  it('does not fetch the live state for an issue that already has a live session', async () => {
-    const issue = makeIssue();
-    const repository = createFakeTmuxSessionRepository({
-      liveSessionNames: [toTmuxSessionName(issue.url)],
-      processCommandLines: [
-        `claude --model opus --agent leader --name ${issue.url}`,
-      ],
-    });
-    const issueStateRepository = createFakeIssueStateRepository();
-    const useCase = new InTmuxByHumanSessionReconcileUseCase(
-      repository,
-      issueStateRepository,
-    );
-
-    await useCase.run({
-      issues: [issue],
-      assigneeLogin: ASSIGNEE,
-      launcherCommand: LAUNCHER,
-      now: NOW,
-    });
-
-    expect(issueStateRepository.fetchedUrls).toEqual([]);
-  });
-
-  it('transforms an issue url into the same session name tmux derives from the raw url, replacing only "." and ":" and keeping "/"', () => {
-    expect(toTmuxSessionName('https://github.com/demo/repo/issues/42')).toBe(
-      'https_//github_com/demo/repo/issues/42',
-    );
-  });
-});

package/src/domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase.ts

@@ -1,103 +0,0 @@
-import { Issue } from '../../entities/Issue';
-import { IN_TMUX_STATUS_NAME } from '../../entities/WorkflowStatus';
-import { IssueRepository } from '../adapter-interfaces/IssueRepository';
-import { TmuxSessionRepository } from '../adapter-interfaces/TmuxSessionRepository';
-
-export type InTmuxByHumanSessionReconcileInput = {
-  issues: Issue[];
-  assigneeLogin: string;
-  launcherCommand: string;
-  now: Date;
-};
-
-export type InTmuxByHumanSessionReconcileResult = {
-  launchedIssueUrls: string[];
-};
-
-// tmux sanitizes a requested session name by replacing only `.` and `:` with
-// `_`, while keeping every other character (including `/`). The Termux app
-// launches each agent with `tmux new -A -s {ISSUE_URL}`, so tmux derives the
-// authoritative session name from the raw issue URL. This function MUST return
-// exactly that derived name so the reconciler recognizes the app's existing
-// session instead of creating a duplicate under a differently-normalized name.
-// For example `https://github.com/owner/repo/issues/9` becomes
-// `https_//github_com/owner/repo/issues/9`.
-export const toTmuxSessionName = (issueUrl: string): string =>
-  issueUrl.replace(/[.:]/g, '_');
-
-export class InTmuxByHumanSessionReconcileUseCase {
-  constructor(
-    private readonly tmuxSessionRepository: TmuxSessionRepository,
-    private readonly issueStateRepository: Pick<
-      IssueRepository,
-      'getIssueOrPullRequestState'
-    >,
-  ) {}
-
-  run = async (
-    input: InTmuxByHumanSessionReconcileInput,
-  ): Promise<InTmuxByHumanSessionReconcileResult> => {
-    const { issues, assigneeLogin, launcherCommand, now } = input;
-
-    const targetIssues = issues.filter((issue) =>
-      this.isInTmuxByHuman(issue, assigneeLogin, now),
-    );
-    if (targetIssues.length === 0) {
-      return { launchedIssueUrls: [] };
-    }
-
-    const liveSessionNames = new Set(
-      await this.tmuxSessionRepository.listLiveSessionNames(),
-    );
-    const processCommandLines =
-      await this.tmuxSessionRepository.listInteractiveProcessCommandLines();
-
-    const launchedIssueUrls: string[] = [];
-    for (const issue of targetIssues) {
-      if (
-        this.hasLiveSession(issue.url, liveSessionNames, processCommandLines)
-      ) {
-        continue;
-      }
-      const liveState =
-        await this.issueStateRepository.getIssueOrPullRequestState(issue.url);
-      if (liveState.state.toLowerCase() !== 'open') {
-        continue;
-      }
-      await this.tmuxSessionRepository.launchDetachedSession(
-        toTmuxSessionName(issue.url),
-        launcherCommand,
-        issue.url,
-      );
-      launchedIssueUrls.push(issue.url);
-    }
-
-    return { launchedIssueUrls };
-  };
-
-  private isInTmuxByHuman = (
-    issue: Issue,
-    assigneeLogin: string,
-    now: Date,
-  ): boolean =>
-    issue.status === IN_TMUX_STATUS_NAME &&
-    issue.isClosed === false &&
-    issue.assignees.includes(assigneeLogin) &&
-    (issue.nextActionDate === null ||
-      issue.nextActionDate.getTime() <= now.getTime()) &&
-    issue.nextActionHour === null;
-
-  private hasLiveSession = (
-    issueUrl: string,
-    liveSessionNames: Set<string>,
-    processCommandLines: string[],
-  ): boolean => {
-    const sessionName = toTmuxSessionName(issueUrl);
-    if (!liveSessionNames.has(sessionName)) {
-      return false;
-    }
-    return processCommandLines.some((commandLine) =>
-      commandLine.includes(issueUrl),
-    );
-  };
-}