github-issue-tower-defence-management 1.151.7 → 1.152.1

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

@@ -1,111 +0,0 @@
-import { resolveUnansweredOwnerCallsByTmuxSessionName } from './resolveUnansweredOwnerCalls';
-import { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
-import { InteractiveLiveSession } from '../../../domain/entities/InteractiveLiveSession';
-import { LiveSessionProcessSnapshot } from '../../../domain/entities/LiveSessionProcessSnapshot';
-import { toTmuxSessionName } from '../../../domain/usecases/intmux/InTmuxByHumanSessionReconcileUseCase';
-
-const ISSUE_URL = 'https://github.com/demo/repo/issues/1';
-const TMUX_SESSION_NAME = toTmuxSessionName(ISSUE_URL);
-const CONFIG_DIR = '/home/agent/.claude';
-const SESSION_ID = 'session-id-1';
-
-const snapshotWithSession = (): LiveSessionProcessSnapshot => ({
-  sessions: [{ sessionName: TMUX_SESSION_NAME, panePids: [100] }],
-  processes: [
-    {
-      pid: 100,
-      ppid: 1,
-      commandLine: `claude ${ISSUE_URL}`,
-      sessionId: SESSION_ID,
-      currentSessionId: SESSION_ID,
-      configDir: CONFIG_DIR,
-    },
-  ],
-});
-
-describe('resolveUnansweredOwnerCallsByTmuxSessionName', () => {
-  it('asks the call provider for the transcripts of the live interactive sessions and returns what it reports', async () => {
-    const call: UnansweredOwnerCall = {
-      calledAt: '2026-08-13T10:14:00.000Z',
-      body: 'Please decide whether to merge the release branch',
-    };
-    const requestedTranscriptPaths: Map<string, string>[] = [];
-    const resolvedSessions: InteractiveLiveSession[][] = [];
-
-    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
-      liveSessionProcessSnapshotProvider: {
-        getSnapshot: async () => snapshotWithSession(),
-      },
-      interactiveLiveSessionTranscriptResolver: {
-        resolveTranscriptPaths: (sessions) => {
-          resolvedSessions.push(sessions);
-          return new Map(
-            sessions.map((session) => [
-              session.sessionName,
-              `/transcripts/${session.sessionId}.jsonl`,
-            ]),
-          );
-        },
-      },
-      unansweredOwnerCallListProvider: {
-        listUnansweredOwnerCallsBySessionName: async (
-          transcriptPathBySessionName,
-        ) => {
-          requestedTranscriptPaths.push(transcriptPathBySessionName);
-          return new Map([[TMUX_SESSION_NAME, [call]]]);
-        },
-      },
-    });
-
-    expect(resolvedSessions[0]?.map((session) => session.sessionName)).toEqual([
-      TMUX_SESSION_NAME,
-    ]);
-    expect(requestedTranscriptPaths[0]?.get(TMUX_SESSION_NAME)).toBe(
-      `/transcripts/${SESSION_ID}.jsonl`,
-    );
-    expect(result.get(TMUX_SESSION_NAME)).toEqual([call]);
-  });
-
-  it('keys the returned calls by the tmux session name the reconciler derives from the issue url', async () => {
-    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
-      liveSessionProcessSnapshotProvider: {
-        getSnapshot: async () => snapshotWithSession(),
-      },
-      interactiveLiveSessionTranscriptResolver: {
-        resolveTranscriptPaths: (sessions) =>
-          new Map(
-            sessions.map((session) => [session.sessionName, '/transcript']),
-          ),
-      },
-      unansweredOwnerCallListProvider: {
-        listUnansweredOwnerCallsBySessionName: async (
-          transcriptPathBySessionName,
-        ) =>
-          new Map(
-            [...transcriptPathBySessionName.keys()].map((sessionName) => [
-              sessionName,
-              [{ calledAt: '2026-08-13T10:14:00.000Z', body: 'body' }],
-            ]),
-          ),
-      },
-    });
-
-    expect([...result.keys()]).toEqual([toTmuxSessionName(ISSUE_URL)]);
-  });
-
-  it('returns nothing when no live session exposes a transcript', async () => {
-    const result = await resolveUnansweredOwnerCallsByTmuxSessionName({
-      liveSessionProcessSnapshotProvider: {
-        getSnapshot: async () => ({ sessions: [], processes: [] }),
-      },
-      interactiveLiveSessionTranscriptResolver: {
-        resolveTranscriptPaths: () => new Map(),
-      },
-      unansweredOwnerCallListProvider: {
-        listUnansweredOwnerCallsBySessionName: async () => new Map(),
-      },
-    });
-
-    expect(result.size).toBe(0);
-  });
-});

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

@@ -1,33 +0,0 @@
-import { UnansweredOwnerCall } from '../../../domain/entities/UnansweredOwnerCall';
-import { InteractiveLiveSession } from '../../../domain/entities/InteractiveLiveSession';
-import { ResolveInteractiveLiveSessionsUseCase } from '../../../domain/usecases/ResolveInteractiveLiveSessionsUseCase';
-import { LiveSessionProcessSnapshotProvider } from '../../../domain/usecases/adapter-interfaces/LiveSessionProcessSnapshotProvider';
-import { InteractiveLiveSessionTranscriptResolver } from '../../../domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver';
-
-export type UnansweredOwnerCallListProvider = {
-  listUnansweredOwnerCallsBySessionName: (
-    transcriptPathBySessionName: Map<string, string>,
-  ) => Promise<Map<string, UnansweredOwnerCall[]>>;
-};
-
-export type ResolveUnansweredOwnerCallsParams = {
-  liveSessionProcessSnapshotProvider: LiveSessionProcessSnapshotProvider;
-  interactiveLiveSessionTranscriptResolver: InteractiveLiveSessionTranscriptResolver;
-  unansweredOwnerCallListProvider: UnansweredOwnerCallListProvider;
-};
-
-export const resolveUnansweredOwnerCallsByTmuxSessionName = async (
-  params: ResolveUnansweredOwnerCallsParams,
-): Promise<Map<string, UnansweredOwnerCall[]>> => {
-  const snapshot =
-    await params.liveSessionProcessSnapshotProvider.getSnapshot();
-  const interactiveSessions: InteractiveLiveSession[] =
-    new ResolveInteractiveLiveSessionsUseCase().resolve(snapshot);
-  const transcriptPathBySessionName =
-    params.interactiveLiveSessionTranscriptResolver.resolveTranscriptPaths(
-      interactiveSessions,
-    );
-  return params.unansweredOwnerCallListProvider.listUnansweredOwnerCallsBySessionName(
-    transcriptPathBySessionName,
-  );
-};

package/src/domain/entities/UnansweredOwnerCall.ts

@@ -1,4 +0,0 @@
-export type UnansweredOwnerCall = {
-  calledAt: string;
-  body: string;
-};

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

@@ -1,141 +0,0 @@
-import { Issue } from '../../entities/Issue';
-import { IN_TMUX_STATUS_NAME } from '../../entities/WorkflowStatus';
-import { FieldOption, Project } from '../../entities/Project';
-import { UnansweredOwnerCall } from '../../entities/UnansweredOwnerCall';
-import { IssueRepository } from '../adapter-interfaces/IssueRepository';
-import { TmuxSessionRepository } from '../adapter-interfaces/TmuxSessionRepository';
-import { InTmuxByHumanSessionReconcileUseCase } from './InTmuxByHumanSessionReconcileUseCase';
-import { GenerateInTmuxByHumanDataUseCase } from './GenerateInTmuxByHumanDataUseCase';
-
-const ASSIGNEE = 'owner-login';
-const LAUNCHER = 'cl';
-const NOW = new Date('2026-06-25T12:00:00.000Z');
-const ISSUE_URL = 'https://github.com/demo/repo/issues/1';
-const STORY_NAME = 'Story Alpha';
-
-const fieldOption = (id: string, name: string): FieldOption => ({
-  id,
-  name,
-  color: 'BLUE',
-  description: '',
-});
-
-const projectWithStory: Project = {
-  id: 'project-node-id',
-  url: 'https://github.com/orgs/demo/projects/1',
-  databaseId: 1,
-  name: 'demo',
-  status: {
-    name: 'Status',
-    fieldId: 'status-field',
-    statuses: [fieldOption('st-tmux', IN_TMUX_STATUS_NAME)],
-  },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: {
-    name: 'story',
-    fieldId: 'story-field',
-    databaseId: 2,
-    stories: [fieldOption('s1', STORY_NAME)],
-    workflowManagementStory: { id: 'wm', name: 'workflow management' },
-  },
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-};
-
-const inTmuxIssue: Issue = {
-  nameWithOwner: 'demo/repo',
-  number: 1,
-  title: 'Issue 1',
-  state: 'OPEN',
-  status: IN_TMUX_STATUS_NAME,
-  story: STORY_NAME,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: ISSUE_URL,
-  assignees: [ASSIGNEE],
-  labels: [],
-  org: 'demo',
-  repo: 'repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: NOW,
-  author: '',
-  closingIssueReferenceUrls: [],
-};
-
-const tmuxSessionNameTheReconcilerCreatesFor = async (
-  issue: Issue,
-): Promise<string> => {
-  const launchedSessionNames: string[] = [];
-  const tmuxSessionRepository: TmuxSessionRepository = {
-    listLiveSessionNames: async () => [],
-    listLiveSessionsWithActivity: async () => [],
-    listInteractiveProcessCommandLines: async () => [],
-    launchDetachedSession: async (sessionName: string) => {
-      launchedSessionNames.push(sessionName);
-    },
-    killSession: async () => undefined,
-    killOwnSession: async () => undefined,
-    sendKeys: async () => undefined,
-    launchBareNameLeaderSession: async () => undefined,
-  };
-  const issueStateRepository: Pick<
-    IssueRepository,
-    'getIssueOrPullRequestState'
-  > = {
-    getIssueOrPullRequestState: async () => ({
-      state: 'OPEN',
-      merged: false,
-      isPullRequest: false,
-      title: 'Issue 1',
-    }),
-  };
-
-  await new InTmuxByHumanSessionReconcileUseCase(
-    tmuxSessionRepository,
-    issueStateRepository,
-  ).run({
-    issues: [issue],
-    assigneeLogin: ASSIGNEE,
-    launcherCommand: LAUNCHER,
-    now: NOW,
-  });
-
-  return launchedSessionNames[0];
-};
-
-describe('unanswered owner call session key contract', () => {
-  it('reads the calls under the very tmux session name the reconciler creates for that issue', async () => {
-    const call: UnansweredOwnerCall = {
-      calledAt: '2026-06-25T11:00:00.000Z',
-      body: 'Please decide whether to merge the release branch',
-    };
-    const sessionNameTheReconcilerCreates =
-      await tmuxSessionNameTheReconcilerCreatesFor(inTmuxIssue);
-
-    const result = new GenerateInTmuxByHumanDataUseCase().run({
-      project: projectWithStory,
-      issues: [inTmuxIssue],
-      pjcode: 'demo',
-      assigneeLogin: ASSIGNEE,
-      org: 'demo',
-      repo: 'repo',
-      consoleBaseUrl: 'https://console.example.test',
-      consoleToken: 'test-token-value',
-      unansweredCallsByTmuxSessionName: new Map([
-        [sessionNameTheReconcilerCreates, [call]],
-      ]),
-      now: NOW,
-    });
-
-    expect(result.v5?.groups[0].sessions[0].unansweredCalls).toEqual([call]);
-  });
-});