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

package/src/domain/usecases/ReopenedDoneIssueRevertUseCase.test.ts

@@ -1,188 +0,0 @@
-import { ReopenedDoneIssueRevertUseCase } from './ReopenedDoneIssueRevertUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
-import {
-  AWAITING_WORKSPACE_STATUS_NAME,
-  DONE_STATUS_NAME,
-} from '../entities/WorkflowStatus';
-
-type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
-
-const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
-  nameWithOwner: 'user/repo',
-  number: 1,
-  title: 'Test Issue',
-  state: 'OPEN',
-  status: DONE_STATUS_NAME,
-  story: 'Default Story',
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: 'https://github.com/user/repo/issues/1',
-  assignees: [],
-  labels: [],
-  org: 'user',
-  repo: 'repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date(),
-  author: '',
-  closingIssueReferenceUrls: [],
-  agent: null,
-  stateReason: 'REOPENED',
-  ...overrides,
-});
-
-const createMockProject = (): Project => ({
-  id: 'project-1',
-  url: 'https://github.com/orgs/user/projects/1',
-  databaseId: 1,
-  name: 'Test Project',
-  status: {
-    name: 'Status',
-    fieldId: 'status-field-id',
-    statuses: [
-      {
-        id: 'awaiting-workspace-id',
-        name: AWAITING_WORKSPACE_STATUS_NAME,
-        color: 'BLUE',
-        description: '',
-      },
-      {
-        id: 'preparation-id',
-        name: 'Preparation',
-        color: 'YELLOW',
-        description: '',
-      },
-      {
-        id: 'done-id',
-        name: DONE_STATUS_NAME,
-        color: 'PURPLE',
-        description: '',
-      },
-    ],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-  agent: null,
-});
-
-describe('ReopenedDoneIssueRevertUseCase', () => {
-  let useCase: ReopenedDoneIssueRevertUseCase;
-  let mockIssueRepository: Mocked<Pick<IssueRepository, 'updateStatus'>>;
-
-  beforeEach(() => {
-    mockIssueRepository = {
-      updateStatus: jest.fn(),
-    };
-    useCase = new ReopenedDoneIssueRevertUseCase(mockIssueRepository);
-  });
-
-  it('resets a Done issue with stateReason REOPENED to Awaiting Workspace', async () => {
-    const issue = createMockIssue();
-    const project = createMockProject();
-
-    await useCase.run({ project, issues: [issue] });
-
-    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-      project,
-      issue,
-      'awaiting-workspace-id',
-    );
-  });
-
-  it('does not reset a Done issue with stateReason COMPLETED', async () => {
-    const issue = createMockIssue({ stateReason: 'COMPLETED' });
-    const project = createMockProject();
-
-    await useCase.run({ project, issues: [issue] });
-
-    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-  });
-
-  it('does not reset a Done issue with stateReason null', async () => {
-    const issue = createMockIssue({ stateReason: null });
-    const project = createMockProject();
-
-    await useCase.run({ project, issues: [issue] });
-
-    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-  });
-
-  it('does not reset a PR item even when Done and stateReason is REOPENED', async () => {
-    const prIssue = createMockIssue({
-      isPr: true,
-      url: 'https://github.com/user/repo/pull/10',
-    });
-    const project = createMockProject();
-
-    await useCase.run({ project, issues: [prIssue] });
-
-    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-  });
-
-  it('does not reset an issue that is not in Done status', async () => {
-    const issue = createMockIssue({ status: 'Awaiting Workspace' });
-    const project = createMockProject();
-
-    await useCase.run({ project, issues: [issue] });
-
-    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-  });
-
-  it('logs an error and returns 0 when Awaiting Workspace status option is missing', async () => {
-    const issue = createMockIssue();
-    const project = createMockProject();
-    project.status.statuses = project.status.statuses.filter(
-      (s) => s.name !== AWAITING_WORKSPACE_STATUS_NAME,
-    );
-    const consoleSpy = jest
-      .spyOn(console, 'error')
-      .mockImplementation(() => {});
-
-    const result = await useCase.run({ project, issues: [issue] });
-
-    expect(result).toBe(0);
-    expect(mockIssueRepository.updateStatus).not.toHaveBeenCalled();
-    consoleSpy.mockRestore();
-  });
-
-  it('collects updateStatus failures and re-throws as AggregateError after processing all items', async () => {
-    const issue1 = createMockIssue({
-      number: 1,
-      url: 'https://github.com/user/repo/issues/1',
-      itemId: 'item-1',
-    });
-    const issue2 = createMockIssue({
-      number: 2,
-      url: 'https://github.com/user/repo/issues/2',
-      itemId: 'item-2',
-    });
-    const project = createMockProject();
-    const updateError = new Error('updateStatus failed for issue1');
-    mockIssueRepository.updateStatus
-      .mockRejectedValueOnce(updateError)
-      .mockResolvedValueOnce(undefined);
-
-    await expect(
-      useCase.run({ project, issues: [issue1, issue2] }),
-    ).rejects.toBeInstanceOf(AggregateError);
-
-    expect(mockIssueRepository.updateStatus).toHaveBeenCalledTimes(2);
-    expect(mockIssueRepository.updateStatus).toHaveBeenCalledWith(
-      project,
-      issue2,
-      'awaiting-workspace-id',
-    );
-  });
-});

package/src/domain/usecases/ReopenedDoneIssueRevertUseCase.ts

@@ -1,57 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import {
-  AWAITING_WORKSPACE_STATUS_NAME,
-  DONE_STATUS_NAME,
-} from '../entities/WorkflowStatus';
-
-export class ReopenedDoneIssueRevertUseCase {
-  constructor(
-    private readonly issueRepository: Pick<IssueRepository, 'updateStatus'>,
-  ) {}
-
-  run = async (params: {
-    project: Project;
-    issues: Issue[];
-  }): Promise<number> => {
-    const awaitingWorkspaceStatusOption = params.project.status.statuses.find(
-      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
-    );
-    if (!awaitingWorkspaceStatusOption) {
-      console.error(
-        `Awaiting Workspace status option '${AWAITING_WORKSPACE_STATUS_NAME}' not found in project.`,
-      );
-      return 0;
-    }
-
-    const itemsToRevert = params.issues.filter(
-      (issue) =>
-        issue.status === DONE_STATUS_NAME &&
-        issue.stateReason === 'REOPENED' &&
-        !issue.isPr,
-    );
-
-    let revertedCount = 0;
-    const errors: unknown[] = [];
-    for (const issue of itemsToRevert) {
-      try {
-        await this.issueRepository.updateStatus(
-          params.project,
-          issue,
-          awaitingWorkspaceStatusOption.id,
-        );
-        revertedCount++;
-      } catch (error) {
-        errors.push(error);
-      }
-    }
-    if (errors.length > 0) {
-      throw new AggregateError(
-        errors,
-        `Failed to revert ${errors.length} issue(s) from ${DONE_STATUS_NAME} to ${AWAITING_WORKSPACE_STATUS_NAME}`,
-      );
-    }
-    return revertedCount;
-  };
-}

package/src/domain/usecases/ResolveInteractiveLiveSessionsUseCase.test.ts

@@ -1,303 +0,0 @@
-import { ResolveInteractiveLiveSessionsUseCase } from './ResolveInteractiveLiveSessionsUseCase';
-import {
-  LiveSessionProcessInfo,
-  LiveSessionProcessSnapshot,
-} from '../entities/LiveSessionProcessSnapshot';
-
-describe('ResolveInteractiveLiveSessionsUseCase', () => {
-  const useCase = new ResolveInteractiveLiveSessionsUseCase();
-
-  const processInfo = (
-    overrides: Partial<LiveSessionProcessInfo> &
-      Pick<LiveSessionProcessInfo, 'pid' | 'ppid' | 'commandLine'>,
-  ): LiveSessionProcessInfo => ({
-    sessionId: null,
-    currentSessionId: null,
-    configDir: null,
-    ...overrides,
-  });
-
-  it('resolves an issue-url-named session through its pane child process', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [
-        {
-          sessionName: 'https_//github_com/owner/repo/issues/9',
-          panePids: [100],
-        },
-      ],
-      processes: [
-        processInfo({ pid: 100, ppid: 1, commandLine: 'tmux pane shell' }),
-        processInfo({
-          pid: 101,
-          ppid: 100,
-          commandLine: 'claude --model opus --resume abc',
-          sessionId: 'abc',
-          configDir: '/config/issues-9',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'https_//github_com/owner/repo/issues/9',
-        sessionId: 'abc',
-        candidateSessionIds: ['abc'],
-        configDir: '/config/issues-9',
-      },
-    ]);
-  });
-
-  it('puts the rotated current session id before the launch env id', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'workbench', panePids: [200] }],
-      processes: [
-        processInfo({
-          pid: 201,
-          ppid: 200,
-          commandLine: 'claude --name workbench',
-          sessionId: 'launch-uuid',
-          currentSessionId: 'rotated-uuid',
-          configDir: '/config/workbench',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'workbench',
-        sessionId: 'launch-uuid',
-        candidateSessionIds: ['rotated-uuid', 'launch-uuid'],
-        configDir: '/config/workbench',
-      },
-    ]);
-  });
-
-  it('keeps a single candidate id when the current id equals the launch id', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'workbench', panePids: [200] }],
-      processes: [
-        processInfo({
-          pid: 201,
-          ppid: 200,
-          commandLine: 'claude --model opus --name workbench',
-          sessionId: 'wb-uuid',
-          currentSessionId: 'wb-uuid',
-          configDir: '/config/workbench',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'workbench',
-        sessionId: 'wb-uuid',
-        candidateSessionIds: ['wb-uuid'],
-        configDir: '/config/workbench',
-      },
-    ]);
-  });
-
-  it('finds the interactive process several levels below the pane', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'control-room', panePids: [300] }],
-      processes: [
-        processInfo({ pid: 300, ppid: 1, commandLine: 'shell' }),
-        processInfo({ pid: 301, ppid: 300, commandLine: 'node wrapper' }),
-        processInfo({
-          pid: 302,
-          ppid: 301,
-          commandLine: 'claude --name control-room',
-          sessionId: 'cr-uuid',
-          configDir: '/config/control-room',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'control-room',
-        sessionId: 'cr-uuid',
-        candidateSessionIds: ['cr-uuid'],
-        configDir: '/config/control-room',
-      },
-    ]);
-  });
-
-  it('excludes a session whose only claude process is an owner-handover spawn', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'aw-host', panePids: [400] }],
-      processes: [
-        processInfo({ pid: 400, ppid: 1, commandLine: 'shell' }),
-        processInfo({
-          pid: 401,
-          ppid: 400,
-          commandLine:
-            'claude --verbose -p Take ownership of https://example.com/issues/1 and finish it',
-          sessionId: 'aw-uuid',
-          configDir: '/config/aw',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([]);
-  });
-
-  it('skips a session whose interactive process exposes no session id or config dir', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'partial', panePids: [500] }],
-      processes: [
-        processInfo({
-          pid: 501,
-          ppid: 500,
-          commandLine: 'claude --model opus',
-          configDir: '/config/partial',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([]);
-  });
-
-  it('ignores non-claude descendants such as monitors', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'monitored', panePids: [600] }],
-      processes: [
-        processInfo({
-          pid: 601,
-          ppid: 600,
-          commandLine: 'node monitor.js',
-          sessionId: 'mon-uuid',
-          configDir: '/config/monitor',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([]);
-  });
-
-  it('resolves multiple sessions and drops the ones without an interactive process', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [
-        { sessionName: 'workbench', panePids: [700] },
-        { sessionName: 'empty', panePids: [800] },
-      ],
-      processes: [
-        processInfo({
-          pid: 701,
-          ppid: 700,
-          commandLine: 'claude --name workbench',
-          sessionId: 'wb-uuid',
-          configDir: '/config/workbench',
-        }),
-        processInfo({ pid: 801, ppid: 800, commandLine: 'bash idle' }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'workbench',
-        sessionId: 'wb-uuid',
-        candidateSessionIds: ['wb-uuid'],
-        configDir: '/config/workbench',
-      },
-    ]);
-  });
-
-  it('collects the descendant-propagated session id after the own launch id for a non-resume session', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'non-resume', panePids: [900] }],
-      processes: [
-        processInfo({ pid: 900, ppid: 1, commandLine: 'shell' }),
-        processInfo({
-          pid: 901,
-          ppid: 900,
-          commandLine: 'claude --model opus',
-          sessionId: 'launch-id',
-          configDir: '/config/non-resume',
-        }),
-        processInfo({
-          pid: 902,
-          ppid: 901,
-          commandLine: 'node tool worker',
-          sessionId: 'harness-id',
-          configDir: '/config/non-resume',
-        }),
-        processInfo({
-          pid: 903,
-          ppid: 902,
-          commandLine: 'node nested worker',
-          sessionId: 'harness-id',
-          configDir: '/config/non-resume',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'non-resume',
-        sessionId: 'launch-id',
-        candidateSessionIds: ['launch-id', 'harness-id'],
-        configDir: '/config/non-resume',
-      },
-    ]);
-  });
-
-  it('orders the rotated current id, then the launch id, then the descendant id', () => {
-    const snapshot: LiveSessionProcessSnapshot = {
-      sessions: [{ sessionName: 'non-resume', panePids: [910] }],
-      processes: [
-        processInfo({ pid: 910, ppid: 1, commandLine: 'shell' }),
-        processInfo({
-          pid: 911,
-          ppid: 910,
-          commandLine: 'claude --model opus',
-          sessionId: 'launch-id',
-          currentSessionId: 'rotated-id',
-          configDir: '/config/non-resume',
-        }),
-        processInfo({
-          pid: 912,
-          ppid: 911,
-          commandLine: 'node tool worker',
-          sessionId: 'harness-id',
-          configDir: '/config/non-resume',
-        }),
-      ],
-    };
-
-    const result = useCase.resolve(snapshot);
-
-    expect(result).toEqual([
-      {
-        sessionName: 'non-resume',
-        sessionId: 'launch-id',
-        candidateSessionIds: ['rotated-id', 'launch-id', 'harness-id'],
-        configDir: '/config/non-resume',
-      },
-    ]);
-  });
-
-  it('returns an empty list when there are no sessions', () => {
-    const result = useCase.resolve({ sessions: [], processes: [] });
-
-    expect(result).toEqual([]);
-  });
-});

package/src/domain/usecases/ResolveInteractiveLiveSessionsUseCase.ts

@@ -1,155 +0,0 @@
-import { InteractiveLiveSession } from '../entities/InteractiveLiveSession';
-import {
-  LiveSessionProcessInfo,
-  LiveSessionProcessSnapshot,
-} from '../entities/LiveSessionProcessSnapshot';
-
-// Command-line substring that identifies an "owner-handover" agent spawn (for
-// example a background implementation agent started with a prompt beginning
-// "Take ownership of ..."). These spawns are not interactive owner sessions and
-// MUST NOT be notified, so any process whose command line contains this marker
-// is excluded even if it somehow appears under a monitored pane.
-export const OWNER_HANDOVER_COMMAND_MARKER = 'Take ownership of';
-
-// Command-name substring that identifies the interactive Claude Code process.
-const INTERACTIVE_PROCESS_COMMAND_MARKER = 'claude';
-
-const isInteractiveCandidate = (process: LiveSessionProcessInfo): boolean => {
-  if (process.commandLine.includes(OWNER_HANDOVER_COMMAND_MARKER)) {
-    return false;
-  }
-  if (!process.commandLine.includes(INTERACTIVE_PROCESS_COMMAND_MARKER)) {
-    return false;
-  }
-  return process.sessionId !== null && process.configDir !== null;
-};
-
-/**
- * Selects the interactive Claude Code sessions that are eligible for the silent
- * self-check notification, independently of session naming or any GitHub issue
- * linkage.
- *
- * Selection works purely from a process snapshot: for each live tmux session,
- * the descendants of its pane processes are walked, and the first descendant
- * that looks like an interactive Claude Code process (command line contains
- * `claude`, does not contain the owner-handover marker, and exposes both a
- * session id and a config directory in its environment) is taken as the
- * session's interactive process. Because the walk is anchored on tmux panes,
- * background owner-handover spawns, the preparation daemon, and monitor
- * processes — none of which run inside an interactive tmux pane — are naturally
- * excluded; the explicit owner-handover marker check is an additional guard.
- */
-export class ResolveInteractiveLiveSessionsUseCase {
-  resolve = (
-    snapshot: LiveSessionProcessSnapshot,
-  ): InteractiveLiveSession[] => {
-    const processByPid = new Map<number, LiveSessionProcessInfo>();
-    const childrenByPpid = new Map<number, LiveSessionProcessInfo[]>();
-    for (const process of snapshot.processes) {
-      processByPid.set(process.pid, process);
-      const siblings = childrenByPpid.get(process.ppid) ?? [];
-      siblings.push(process);
-      childrenByPpid.set(process.ppid, siblings);
-    }
-
-    const sessions: InteractiveLiveSession[] = [];
-    for (const session of snapshot.sessions) {
-      const interactiveProcess = this.findInteractiveProcess(
-        session.panePids,
-        processByPid,
-        childrenByPpid,
-      );
-      if (
-        interactiveProcess === null ||
-        interactiveProcess.sessionId === null ||
-        interactiveProcess.configDir === null
-      ) {
-        continue;
-      }
-      const candidateSessionIds = this.collectCandidateSessionIds(
-        interactiveProcess,
-        childrenByPpid,
-      );
-      sessions.push({
-        sessionName: session.sessionName,
-        sessionId: interactiveProcess.sessionId,
-        candidateSessionIds,
-        configDir: interactiveProcess.configDir,
-      });
-    }
-    return sessions;
-  };
-
-  /**
-   * Collects the distinct session ids that may name the actively-written
-   * transcript on disk, in priority order. The rotated current session id
-   * recorded for the interactive process is first, because for a resumed or
-   * compacted session the id rotates and the live transcript is named by the
-   * current id. The interactive process's own launch id follows, then the
-   * distinct ids propagated to its descendant processes. For a `--resume`
-   * session these ids coincide, yielding a single id; for a non-resume session
-   * the own (launch) id names no transcript and the live transcript is named by
-   * the descendant-propagated id, which is included here so the resolver can
-   * find the actively-written file.
-   */
-  private collectCandidateSessionIds = (
-    interactiveProcess: LiveSessionProcessInfo,
-    childrenByPpid: Map<number, LiveSessionProcessInfo[]>,
-  ): string[] => {
-    const candidateSessionIds: string[] = [];
-    const seenSessionIds = new Set<string>();
-    const pushSessionId = (sessionId: string | null): void => {
-      if (sessionId !== null && !seenSessionIds.has(sessionId)) {
-        seenSessionIds.add(sessionId);
-        candidateSessionIds.push(sessionId);
-      }
-    };
-    pushSessionId(interactiveProcess.currentSessionId);
-    const visitedPids = new Set<number>();
-    const queue: LiveSessionProcessInfo[] = [interactiveProcess];
-    let head = 0;
-    while (head < queue.length) {
-      const process = queue[head];
-      head += 1;
-      if (visitedPids.has(process.pid)) {
-        continue;
-      }
-      visitedPids.add(process.pid);
-      pushSessionId(process.sessionId);
-      for (const child of childrenByPpid.get(process.pid) ?? []) {
-        if (!visitedPids.has(child.pid)) {
-          queue.push(child);
-        }
-      }
-    }
-    return candidateSessionIds;
-  };
-
-  private findInteractiveProcess = (
-    panePids: number[],
-    processByPid: Map<number, LiveSessionProcessInfo>,
-    childrenByPpid: Map<number, LiveSessionProcessInfo[]>,
-  ): LiveSessionProcessInfo | null => {
-    const visited = new Set<number>();
-    const queue: number[] = [...panePids];
-    let head = 0;
-    while (head < queue.length) {
-      const pid = queue[head];
-      head += 1;
-      if (visited.has(pid)) {
-        continue;
-      }
-      visited.add(pid);
-      const process = processByPid.get(pid);
-      if (process !== undefined && isInteractiveCandidate(process)) {
-        return process;
-      }
-      for (const child of childrenByPpid.get(pid) ?? []) {
-        if (!visited.has(child.pid)) {
-          queue.push(child.pid);
-        }
-      }
-    }
-    return null;
-  };
-}