github-issue-tower-defence-management 1.109.1 → 1.110.0

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.test.ts

@@ -0,0 +1,153 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
+import { TmuxSilentSessionNotificationRepository } from './TmuxSilentSessionNotificationRepository';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+const createMockRunner = (): Mocked<LocalCommandRunner> => ({
+  runCommand: jest.fn().mockResolvedValue({
+    stdout: '',
+    stderr: '',
+    exitCode: 0,
+  }),
+});
+
+const createMockCacheRepository = (): Mocked<
+  Pick<LocalStorageCacheRepository, 'getLatest' | 'set'>
+> => ({
+  getLatest: jest.fn().mockResolvedValue(null),
+  set: jest.fn().mockResolvedValue(undefined),
+});
+
+describe('TmuxSilentSessionNotificationRepository', () => {
+  describe('sendSelfCheckNotification', () => {
+    it('sends the message literally then submits it with Enter', async () => {
+      const runner = createMockRunner();
+      const cache = createMockCacheRepository();
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      await repository.sendSelfCheckNotification(
+        'https_//github_com/owner/repo/issues/9',
+        'self check message',
+      );
+
+      expect(runner.runCommand.mock.calls[0]).toEqual([
+        'tmux',
+        [
+          'send-keys',
+          '-t',
+          'https_//github_com/owner/repo/issues/9',
+          '-l',
+          'self check message',
+        ],
+      ]);
+      expect(runner.runCommand.mock.calls[1]).toEqual([
+        'tmux',
+        ['send-keys', '-t', 'https_//github_com/owner/repo/issues/9', 'Enter'],
+      ]);
+    });
+
+    it('throws when sending the message literally fails', async () => {
+      const runner = createMockRunner();
+      runner.runCommand.mockResolvedValueOnce({
+        stdout: '',
+        stderr: "can't find session",
+        exitCode: 1,
+      });
+      const cache = createMockCacheRepository();
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      await expect(
+        repository.sendSelfCheckNotification('missing_session', 'message'),
+      ).rejects.toThrow(
+        'Failed to send notification to tmux session "missing_session"',
+      );
+    });
+  });
+
+  describe('getLastNotifiedEpochSeconds', () => {
+    it('returns the cached epoch seconds for a session', async () => {
+      const runner = createMockRunner();
+      const cache = createMockCacheRepository();
+      cache.getLatest.mockResolvedValue({
+        value: { epochSeconds: 1700000000 },
+        timestamp: new Date(),
+      });
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      const result = await repository.getLastNotifiedEpochSeconds(
+        'https_//github_com/owner/repo/issues/9',
+      );
+
+      expect(result).toBe(1700000000);
+      expect(cache.getLatest).toHaveBeenCalledWith(
+        'silent-session-notification/https___github_com_owner_repo_issues_9',
+      );
+    });
+
+    it('returns null when no cache entry exists', async () => {
+      const runner = createMockRunner();
+      const cache = createMockCacheRepository();
+      cache.getLatest.mockResolvedValue(null);
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      const result = await repository.getLastNotifiedEpochSeconds(
+        'https_//github_com/owner/repo/issues/9',
+      );
+
+      expect(result).toBeNull();
+    });
+
+    it('returns null when the cached value has no numeric epoch', async () => {
+      const runner = createMockRunner();
+      const cache = createMockCacheRepository();
+      cache.getLatest.mockResolvedValue({
+        value: {},
+        timestamp: new Date(),
+      });
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      const result = await repository.getLastNotifiedEpochSeconds(
+        'https_//github_com/owner/repo/issues/9',
+      );
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('setLastNotifiedEpochSeconds', () => {
+    it('persists the epoch seconds keyed by the sanitized session name', async () => {
+      const runner = createMockRunner();
+      const cache = createMockCacheRepository();
+      const repository = new TmuxSilentSessionNotificationRepository(
+        runner,
+        cache,
+      );
+
+      await repository.setLastNotifiedEpochSeconds(
+        'https_//github_com/owner/repo/issues/9',
+        1700000000,
+      );
+
+      expect(cache.set).toHaveBeenCalledWith(
+        'silent-session-notification/https___github_com_owner_repo_issues_9',
+        { epochSeconds: 1700000000 },
+      );
+    });
+  });
+});

package/src/adapter/repositories/TmuxSilentSessionNotificationRepository.ts

@@ -0,0 +1,83 @@
+import { SilentSessionNotificationRepository } from '../../domain/usecases/adapter-interfaces/SilentSessionNotificationRepository';
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { LocalStorageCacheRepository } from './LocalStorageCacheRepository';
+
+const CACHE_KEY_PREFIX = 'silent-session-notification';
+
+const readEpochSeconds = (value: object): number | null => {
+  if (!('epochSeconds' in value)) {
+    return null;
+  }
+  const candidate = value.epochSeconds;
+  if (typeof candidate !== 'number') {
+    return null;
+  }
+  return candidate;
+};
+
+export class TmuxSilentSessionNotificationRepository implements SilentSessionNotificationRepository {
+  constructor(
+    private readonly localCommandRunner: LocalCommandRunner,
+    private readonly cacheRepository: Pick<
+      LocalStorageCacheRepository,
+      'getLatest' | 'set'
+    >,
+  ) {}
+
+  getLastNotifiedEpochSeconds = async (
+    sessionName: string,
+  ): Promise<number | null> => {
+    const cached = await this.cacheRepository.getLatest(
+      this.toCacheKey(sessionName),
+    );
+    if (cached === null) {
+      return null;
+    }
+    return readEpochSeconds(cached.value);
+  };
+
+  setLastNotifiedEpochSeconds = async (
+    sessionName: string,
+    epochSeconds: number,
+  ): Promise<void> => {
+    await this.cacheRepository.set(this.toCacheKey(sessionName), {
+      epochSeconds,
+    });
+  };
+
+  sendSelfCheckNotification = async (
+    sessionName: string,
+    message: string,
+  ): Promise<void> => {
+    const literalResult = await this.localCommandRunner.runCommand('tmux', [
+      'send-keys',
+      '-t',
+      sessionName,
+      '-l',
+      message,
+    ]);
+    if (literalResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to send notification to tmux session "${sessionName}": exit code ${literalResult.exitCode}${
+          literalResult.stderr ? `: ${literalResult.stderr}` : ''
+        }`,
+      );
+    }
+    const submitResult = await this.localCommandRunner.runCommand('tmux', [
+      'send-keys',
+      '-t',
+      sessionName,
+      'Enter',
+    ]);
+    if (submitResult.exitCode !== 0) {
+      throw new Error(
+        `Failed to send notification to tmux session "${sessionName}": exit code ${submitResult.exitCode}${
+          submitResult.stderr ? `: ${submitResult.stderr}` : ''
+        }`,
+      );
+    }
+  };
+
+  private toCacheKey = (sessionName: string): string =>
+    `${CACHE_KEY_PREFIX}/${sessionName.replace(/\//g, '_')}`;
+}

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.test.ts

@@ -0,0 +1,220 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TranscriptOwnerCallStatusProvider } from './TranscriptOwnerCallStatusProvider';
+
+describe('TranscriptOwnerCallStatusProvider', () => {
+  let rootDirectory: string;
+
+  beforeEach(() => {
+    rootDirectory = fs.mkdtempSync(
+      path.join(os.tmpdir(), 'owner-call-status-'),
+    );
+  });
+
+  afterEach(() => {
+    fs.rmSync(rootDirectory, { force: true, recursive: true });
+  });
+
+  const writeTranscript = (sessionName: string, lines: object[]): void => {
+    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
+    const filePath = path.join(rootDirectory, fileName);
+    fs.writeFileSync(
+      filePath,
+      lines.map((line) => JSON.stringify(line)).join('\n'),
+      'utf8',
+    );
+  };
+
+  const assistantWithMarker = (timestamp: string): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      stop_reason: 'end_turn',
+      content: [
+        { type: 'text', text: 'Waiting <<OWNER_CALL>> please decide.' },
+      ],
+    },
+  });
+
+  const assistantPlain = (timestamp: string): object => ({
+    type: 'assistant',
+    timestamp,
+    message: {
+      role: 'assistant',
+      stop_reason: 'end_turn',
+      content: [{ type: 'text', text: 'progress update' }],
+    },
+  });
+
+  const ownerReply = (timestamp: string): object => ({
+    type: 'user',
+    timestamp,
+    message: { role: 'user', content: 'go ahead' },
+  });
+
+  const toolResult = (timestamp: string): object => ({
+    type: 'user',
+    timestamp,
+    message: {
+      role: 'user',
+      content: [{ type: 'tool_result', content: 'ok' }],
+    },
+  });
+
+  it('reports a session as waiting when the last owner call is newer than the last owner reply', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      ownerReply('2026-06-27T10:00:00.000Z'),
+      assistantWithMarker('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(true);
+  });
+
+  it('does not report a session as waiting when a later owner reply followed the call', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      assistantWithMarker('2026-06-27T10:00:00.000Z'),
+      ownerReply('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(false);
+  });
+
+  it('compares full datetimes rather than only the time of day', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      assistantWithMarker('2026-06-27T23:00:00.000Z'),
+      ownerReply('2026-06-28T01:00:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(false);
+  });
+
+  it('treats tool results as not being owner replies', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      assistantWithMarker('2026-06-27T10:00:00.000Z'),
+      toolResult('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(true);
+  });
+
+  it('does not report a session that never raised an owner call', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      assistantPlain('2026-06-27T10:00:00.000Z'),
+      ownerReply('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(false);
+  });
+
+  it('returns an empty set when the root directory is null', async () => {
+    const provider = new TranscriptOwnerCallStatusProvider(
+      null,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      'https_//github_com/owner/repo/issues/9',
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('returns an empty set when the marker is null', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    writeTranscript(sessionName, [
+      ownerReply('2026-06-27T10:00:00.000Z'),
+      assistantWithMarker('2026-06-27T10:05:00.000Z'),
+    ]);
+    const provider = new TranscriptOwnerCallStatusProvider(rootDirectory, null);
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('ignores a session whose transcript file is missing', async () => {
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      'https_//github_com/owner/repo/issues/9',
+    ]);
+
+    expect(result.size).toBe(0);
+  });
+
+  it('ignores malformed transcript lines', async () => {
+    const sessionName = 'https_//github_com/owner/repo/issues/9';
+    const fileName = `${sessionName.replace(/\//g, '_')}.jsonl`;
+    const filePath = path.join(rootDirectory, fileName);
+    fs.writeFileSync(
+      filePath,
+      [
+        'not json',
+        JSON.stringify(assistantWithMarker('2026-06-27T10:05:00.000Z')),
+      ].join('\n'),
+      'utf8',
+    );
+    const provider = new TranscriptOwnerCallStatusProvider(
+      rootDirectory,
+      '<<OWNER_CALL>>',
+    );
+
+    const result = await provider.listSessionNamesWithUnansweredOwnerCall([
+      sessionName,
+    ]);
+
+    expect(result.has(sessionName)).toBe(true);
+  });
+});

package/src/adapter/repositories/TranscriptOwnerCallStatusProvider.ts

@@ -0,0 +1,139 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { OwnerCallStatusProvider } from '../../domain/usecases/adapter-interfaces/OwnerCallStatusProvider';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const readString = (
+  value: Record<string, unknown>,
+  key: string,
+): string | null => {
+  const candidate = value[key];
+  return typeof candidate === 'string' ? candidate : null;
+};
+
+const parseEpochMilliseconds = (timestamp: string | null): number | null => {
+  if (timestamp === null) {
+    return null;
+  }
+  const parsed = Date.parse(timestamp);
+  return Number.isNaN(parsed) ? null : parsed;
+};
+
+const extractText = (content: unknown): string => {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return '';
+  }
+  const texts: string[] = [];
+  for (const block of content) {
+    if (isRecord(block) && block.type === 'text') {
+      const text = readString(block, 'text');
+      if (text !== null) {
+        texts.push(text);
+      }
+    }
+  }
+  return texts.join('\n');
+};
+
+const hasOwnerTextReply = (content: unknown): boolean => {
+  if (typeof content === 'string') {
+    return content.length > 0;
+  }
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  return content.some((block) => isRecord(block) && block.type === 'text');
+};
+
+export class TranscriptOwnerCallStatusProvider implements OwnerCallStatusProvider {
+  constructor(
+    private readonly rootDirectory: string | null,
+    private readonly ownerCallMarker: string | null,
+  ) {}
+
+  listSessionNamesWithUnansweredOwnerCall = async (
+    sessionNames: string[],
+  ): Promise<Set<string>> => {
+    const waiting = new Set<string>();
+    if (
+      this.rootDirectory === null ||
+      this.ownerCallMarker === null ||
+      this.ownerCallMarker.length === 0
+    ) {
+      return waiting;
+    }
+    for (const sessionName of sessionNames) {
+      if (this.isWaitingForOwnerReply(sessionName, this.ownerCallMarker)) {
+        waiting.add(sessionName);
+      }
+    }
+    return waiting;
+  };
+
+  private isWaitingForOwnerReply = (
+    sessionName: string,
+    marker: string,
+  ): boolean => {
+    if (this.rootDirectory === null) {
+      return false;
+    }
+    const filePath = path.join(
+      this.rootDirectory,
+      this.toTranscriptFileName(sessionName),
+    );
+    let content: string;
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      return false;
+    }
+    let lastOwnerCallEpochMs: number | null = null;
+    let lastOwnerReplyEpochMs: number | null = null;
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      let parsed: unknown;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (!isRecord(parsed)) {
+        continue;
+      }
+      const epochMs = parseEpochMilliseconds(readString(parsed, 'timestamp'));
+      if (epochMs === null) {
+        continue;
+      }
+      const type = readString(parsed, 'type');
+      const message = parsed.message;
+      const messageContent = isRecord(message) ? message.content : null;
+      if (
+        type === 'assistant' &&
+        extractText(messageContent).includes(marker)
+      ) {
+        lastOwnerCallEpochMs = epochMs;
+      }
+      if (type === 'user' && hasOwnerTextReply(messageContent)) {
+        lastOwnerReplyEpochMs = epochMs;
+      }
+    }
+    if (lastOwnerCallEpochMs === null) {
+      return false;
+    }
+    return (
+      lastOwnerReplyEpochMs === null ||
+      lastOwnerCallEpochMs > lastOwnerReplyEpochMs
+    );
+  };
+
+  private toTranscriptFileName = (sessionName: string): string =>
+    `${sessionName.replace(/\//g, '_')}.jsonl`;
+}