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

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

@@ -1,56 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { FileSystemSubAgentSilentSecondsResolver } from './FileSystemSubAgentSilentSecondsResolver';
-
-const NOW = new Date('2026-06-26T00:00:00.000Z');
-const NOW_EPOCH_SECONDS = Math.floor(NOW.getTime() / 1000);
-
-describe('FileSystemSubAgentSilentSecondsResolver', () => {
-  let rootDirectory: string;
-
-  beforeEach(() => {
-    rootDirectory = fs.mkdtempSync(path.join(os.tmpdir(), 'subagent-out-'));
-  });
-
-  afterEach(() => {
-    fs.rmSync(rootDirectory, { force: true, recursive: true });
-  });
-
-  it('returns 0 when the root directory is not configured', () => {
-    const resolver = new FileSystemSubAgentSilentSecondsResolver(null, NOW);
-    expect(resolver.resolveSilentSeconds('task-a')).toBe(0);
-  });
-
-  it('returns 0 when the output file does not exist', () => {
-    const resolver = new FileSystemSubAgentSilentSecondsResolver(
-      rootDirectory,
-      NOW,
-    );
-    expect(resolver.resolveSilentSeconds('task-a')).toBe(0);
-  });
-
-  it('returns the seconds since the output file was last modified', () => {
-    const filePath = path.join(rootDirectory, 'task-a');
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    const silentEpoch = NOW_EPOCH_SECONDS - 360;
-    fs.utimesSync(filePath, silentEpoch, silentEpoch);
-    const resolver = new FileSystemSubAgentSilentSecondsResolver(
-      rootDirectory,
-      NOW,
-    );
-    expect(resolver.resolveSilentSeconds('task-a')).toBe(360);
-  });
-
-  it('replaces slashes in the label when resolving the file name', () => {
-    const filePath = path.join(rootDirectory, 'group_task-a');
-    fs.writeFileSync(filePath, 'output', 'utf8');
-    const silentEpoch = NOW_EPOCH_SECONDS - 120;
-    fs.utimesSync(filePath, silentEpoch, silentEpoch);
-    const resolver = new FileSystemSubAgentSilentSecondsResolver(
-      rootDirectory,
-      NOW,
-    );
-    expect(resolver.resolveSilentSeconds('group/task-a')).toBe(120);
-  });
-});

package/src/adapter/repositories/FileSystemSubAgentSilentSecondsResolver.ts

@@ -1,32 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { SubAgentSilentSecondsResolver } from '../../domain/usecases/adapter-interfaces/SubAgentSilentSecondsResolver';
-
-export class FileSystemSubAgentSilentSecondsResolver implements SubAgentSilentSecondsResolver {
-  constructor(
-    private readonly rootDirectory: string | null,
-    private readonly now: Date,
-  ) {}
-
-  resolveSilentSeconds = (label: string): number => {
-    if (this.rootDirectory === null) {
-      return 0;
-    }
-    const filePath = path.join(this.rootDirectory, this.toFileName(label));
-    let stats: fs.Stats;
-    try {
-      stats = fs.statSync(filePath);
-    } catch {
-      return 0;
-    }
-    if (!stats.isFile()) {
-      return 0;
-    }
-    const lastOutputEpochSeconds = Math.floor(stats.mtimeMs / 1000);
-    const nowEpochSeconds = Math.floor(this.now.getTime() / 1000);
-    const silentSeconds = nowEpochSeconds - lastOutputEpochSeconds;
-    return silentSeconds > 0 ? silentSeconds : 0;
-  };
-
-  private toFileName = (label: string): string => label.replace(/\//g, '_');
-}

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

@@ -1,68 +0,0 @@
-import * as path from 'path';
-import { FileSystemSubAgentTranscriptDirectoryResolver } from './FileSystemSubAgentTranscriptDirectoryResolver';
-
-describe('FileSystemSubAgentTranscriptDirectoryResolver', () => {
-  const rootDirectory = '/home/user/.claude/projects';
-  const mainTranscriptPath = path.join(
-    rootDirectory,
-    '-home-user-0-workspaces-workspace1-oss-some-repo-worktrees-i123',
-    'ba0637e1-9ff1-41a8-b13c-f45e6a71efc5.jsonl',
-  );
-
-  it('derives the subagents directory next to the resolved main transcript path', () => {
-    const resolver = new FileSystemSubAgentTranscriptDirectoryResolver(
-      rootDirectory,
-    );
-
-    const result = resolver.resolveSubAgentsDirectory(
-      'https_//github_com/owner/repo/issues/9',
-      mainTranscriptPath,
-    );
-
-    expect(result).toBe(
-      path.join(
-        rootDirectory,
-        '-home-user-0-workspaces-workspace1-oss-some-repo-worktrees-i123',
-        'ba0637e1-9ff1-41a8-b13c-f45e6a71efc5',
-        'subagents',
-      ),
-    );
-  });
-
-  it('returns null when the root directory is null', () => {
-    const resolver = new FileSystemSubAgentTranscriptDirectoryResolver(null);
-
-    const result = resolver.resolveSubAgentsDirectory(
-      'https_//github_com/owner/repo/issues/9',
-      mainTranscriptPath,
-    );
-
-    expect(result).toBeNull();
-  });
-
-  it('returns null when the main transcript path is unresolved', () => {
-    const resolver = new FileSystemSubAgentTranscriptDirectoryResolver(
-      rootDirectory,
-    );
-
-    const result = resolver.resolveSubAgentsDirectory(
-      'https_//github_com/owner/repo/issues/9',
-      null,
-    );
-
-    expect(result).toBeNull();
-  });
-
-  it('returns null when the main transcript path is not a .jsonl file', () => {
-    const resolver = new FileSystemSubAgentTranscriptDirectoryResolver(
-      rootDirectory,
-    );
-
-    const result = resolver.resolveSubAgentsDirectory(
-      'https_//github_com/owner/repo/issues/9',
-      path.join(rootDirectory, 'slug', 'no-extension'),
-    );
-
-    expect(result).toBeNull();
-  });
-});

package/src/adapter/repositories/FileSystemSubAgentTranscriptDirectoryResolver.ts

@@ -1,23 +0,0 @@
-import * as path from 'path';
-import { SubAgentTranscriptDirectoryResolver } from '../../domain/usecases/adapter-interfaces/SubAgentTranscriptDirectoryResolver';
-
-export class FileSystemSubAgentTranscriptDirectoryResolver implements SubAgentTranscriptDirectoryResolver {
-  constructor(private readonly rootDirectory: string | null) {}
-
-  resolveSubAgentsDirectory = (
-    _sessionName: string,
-    mainTranscriptPath: string | null,
-  ): string | null => {
-    if (this.rootDirectory === null) {
-      return null;
-    }
-    if (mainTranscriptPath === null) {
-      return null;
-    }
-    const sessionDirectory = mainTranscriptPath.replace(/\.jsonl$/, '');
-    if (sessionDirectory === mainTranscriptPath) {
-      return null;
-    }
-    return path.join(sessionDirectory, 'subagents');
-  };
-}

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

@@ -1,51 +0,0 @@
-import { GitHubIssueCheckpointRepository } from './GitHubIssueCheckpointRepository';
-
-const VALID_URL = 'https://github.com/owner/repo/issues/42';
-const EXPECTED_API_URL =
-  'https://api.github.com/repos/owner/repo/issues/42/comments';
-const EXPECTED_BODY = JSON.stringify({
-  body: 'From: :robot: preparation-daemon (-)\n\n```json\n{"pullRequestRequired": false}\n```\n\nThis implementation session was interrupted by the preparation daemon due to token near exhaustion. The task will be re-dispatched.',
-});
-
-describe('GitHubIssueCheckpointRepository', () => {
-  let repository: GitHubIssueCheckpointRepository;
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    repository = new GitHubIssueCheckpointRepository('test-token');
-  });
-
-  it('posts to the correct GitHub API URL with correct headers and body', async () => {
-    const fetchSpy = jest
-      .spyOn(global, 'fetch')
-      .mockResolvedValue(new Response('{}', { status: 201 }));
-
-    await repository.postCheckpoint(VALID_URL);
-
-    expect(fetchSpy).toHaveBeenCalledWith(EXPECTED_API_URL, {
-      method: 'POST',
-      headers: {
-        Authorization: 'Bearer test-token',
-        Accept: 'application/vnd.github+json',
-        'Content-Type': 'application/json',
-      },
-      body: EXPECTED_BODY,
-    });
-  });
-
-  it('throws when the response is not 2xx', async () => {
-    jest
-      .spyOn(global, 'fetch')
-      .mockResolvedValue(
-        new Response('Forbidden', { status: 403, statusText: 'Forbidden' }),
-      );
-
-    await expect(repository.postCheckpoint(VALID_URL)).rejects.toThrow('403');
-  });
-
-  it('throws when the URL does not match the expected GitHub issue pattern', async () => {
-    await expect(
-      repository.postCheckpoint('https://example.com/not-an-issue'),
-    ).rejects.toThrow('Invalid GitHub issue URL');
-  });
-});

package/src/adapter/repositories/GitHubIssueCheckpointRepository.ts

@@ -1,47 +0,0 @@
-import { IssueCheckpointRepository } from '../../domain/usecases/adapter-interfaces/IssueCheckpointRepository';
-
-const CHECKPOINT_COMMENT_BODY =
-  'From: :robot: preparation-daemon (-)\n\n```json\n{"pullRequestRequired": false}\n```\n\nThis implementation session was interrupted by the preparation daemon due to token near exhaustion. The task will be re-dispatched.';
-
-export class GitHubIssueCheckpointRepository implements IssueCheckpointRepository {
-  constructor(private readonly ghToken: string) {}
-
-  postCheckpoint = async (issueUrl: string): Promise<void> => {
-    const { owner, repo, issueNumber } = this.parseIssueUrl(issueUrl);
-
-    const response = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${this.ghToken}`,
-          Accept: 'application/vnd.github+json',
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ body: CHECKPOINT_COMMENT_BODY }),
-      },
-    );
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to post checkpoint comment to ${issueUrl}: ${response.status} ${response.statusText}`,
-      );
-    }
-  };
-
-  private parseIssueUrl = (
-    issueUrl: string,
-  ): { owner: string; repo: string; issueNumber: number } => {
-    const match = issueUrl.match(
-      /github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/,
-    );
-    if (!match) {
-      throw new Error(`Invalid GitHub issue URL: ${issueUrl}`);
-    }
-    return {
-      owner: match[1],
-      repo: match[2],
-      issueNumber: parseInt(match[4], 10),
-    };
-  };
-}

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

@@ -1,278 +0,0 @@
-import { GitHubIssueCommentRepository } from './GitHubIssueCommentRepository';
-import { Issue } from '../../domain/entities/Issue';
-
-const buildIssue = (url: string): Issue => ({
-  url,
-  nameWithOwner: 'HiromiShikata/test-repo',
-  number: 123,
-  title: 'Test Issue',
-  state: 'OPEN',
-  status: null,
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  assignees: [],
-  labels: [],
-  org: 'HiromiShikata',
-  repo: 'test-repo',
-  body: '',
-  itemId: 'item-1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date('2024-01-01T00:00:00Z'),
-  author: 'testuser',
-  closingIssueReferenceUrls: [],
-  agent: null,
-  stateReason: null,
-});
-
-const TEST_URL = 'https://github.com/HiromiShikata/test-repo/issues/123';
-const EXPECTED_REST_URL =
-  'https://api.github.com/repos/HiromiShikata/test-repo/issues/123/comments?per_page=100&page=1';
-
-describe('GitHubIssueCommentRepository', () => {
-  let repository: GitHubIssueCommentRepository;
-
-  beforeEach(() => {
-    jest.restoreAllMocks();
-    repository = new GitHubIssueCommentRepository('test-token');
-  });
-
-  describe('getCommentsFromIssue', () => {
-    it('fetches single page with correct REST endpoint URL and headers, and maps comments correctly', async () => {
-      const commentPayloads = [
-        {
-          user: { login: 'testuser' },
-          body: 'Comment body',
-          created_at: '2024-01-01T00:00:00Z',
-        },
-      ];
-      const fetchSpy = jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(commentPayloads), { status: 200 }),
-        );
-
-      const result = await repository.getCommentsFromIssue(
-        buildIssue(TEST_URL),
-      );
-
-      expect(fetchSpy).toHaveBeenCalledTimes(1);
-      expect(fetchSpy).toHaveBeenCalledWith(EXPECTED_REST_URL, {
-        headers: {
-          Authorization: 'Bearer test-token',
-          Accept: 'application/vnd.github+json',
-        },
-      });
-      expect(result).toEqual([
-        {
-          author: 'testuser',
-          content: 'Comment body',
-          createdAt: new Date('2024-01-01T00:00:00Z'),
-        },
-      ]);
-    });
-
-    it('fetches two pages when first response contains rel="next" Link header', async () => {
-      const page1Payloads = [
-        {
-          user: { login: 'user1' },
-          body: 'Page 1 comment',
-          created_at: '2024-01-01T00:00:00Z',
-        },
-      ];
-      const page2Payloads = [
-        {
-          user: { login: 'user2' },
-          body: 'Page 2 comment',
-          created_at: '2024-01-02T00:00:00Z',
-        },
-      ];
-
-      const fetchSpy = jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValueOnce(
-          new Response(JSON.stringify(page1Payloads), {
-            status: 200,
-            headers: {
-              Link: '<https://api.github.com/repos/HiromiShikata/test-repo/issues/123/comments?per_page=100&page=2>; rel="next"',
-            },
-          }),
-        )
-        .mockResolvedValueOnce(
-          new Response(JSON.stringify(page2Payloads), { status: 200 }),
-        );
-
-      const result = await repository.getCommentsFromIssue(
-        buildIssue(TEST_URL),
-      );
-
-      expect(fetchSpy).toHaveBeenCalledTimes(2);
-      expect(fetchSpy).toHaveBeenNthCalledWith(
-        1,
-        'https://api.github.com/repos/HiromiShikata/test-repo/issues/123/comments?per_page=100&page=1',
-        expect.anything(),
-      );
-      expect(fetchSpy).toHaveBeenNthCalledWith(
-        2,
-        'https://api.github.com/repos/HiromiShikata/test-repo/issues/123/comments?per_page=100&page=2',
-        expect.anything(),
-      );
-      expect(result).toEqual([
-        {
-          author: 'user1',
-          content: 'Page 1 comment',
-          createdAt: new Date('2024-01-01T00:00:00Z'),
-        },
-        {
-          author: 'user2',
-          content: 'Page 2 comment',
-          createdAt: new Date('2024-01-02T00:00:00Z'),
-        },
-      ]);
-    });
-
-    it('maps author to empty string when user field is null (ghost user)', async () => {
-      const commentPayloads = [
-        {
-          user: null,
-          body: 'Ghost comment',
-          created_at: '2024-01-01T00:00:00Z',
-        },
-      ];
-      jest
-        .spyOn(global, 'fetch')
-        .mockResolvedValue(
-          new Response(JSON.stringify(commentPayloads), { status: 200 }),
-        );
-
-      const result = await repository.getCommentsFromIssue(
-        buildIssue(TEST_URL),
-      );
-
-      expect(result[0].author).toBe('');
-    });
-
-    it('throws an error including status and statusText when response is non-2xx', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response('Not Found', {
-          status: 404,
-          statusText: 'Not Found',
-        }),
-      );
-
-      await expect(
-        repository.getCommentsFromIssue(buildIssue(TEST_URL)),
-      ).rejects.toThrow('404');
-      await expect(
-        repository.getCommentsFromIssue(buildIssue(TEST_URL)),
-      ).rejects.toThrow('Not Found');
-    });
-  });
-
-  describe('createComment', () => {
-    it('should call the REST endpoint with correct URL, headers, and body for an issue', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response(JSON.stringify({ id: 1 }), {
-          status: 201,
-          headers: { 'Content-Type': 'application/json' },
-        }),
-      );
-
-      const issue = buildIssue(
-        'https://github.com/HiromiShikata/test-repository/issues/42',
-      );
-      await repository.createComment(issue, 'hello world');
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'https://api.github.com/repos/HiromiShikata/test-repository/issues/42/comments',
-        {
-          method: 'POST',
-          headers: {
-            Authorization: 'Bearer test-token',
-            Accept: 'application/vnd.github+json',
-            'Content-Type': 'application/json',
-          },
-          body: JSON.stringify({ body: 'hello world' }),
-        },
-      );
-    });
-
-    it('should call the REST endpoint with correct URL for a pull request', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response(JSON.stringify({ id: 2 }), {
-          status: 201,
-          headers: { 'Content-Type': 'application/json' },
-        }),
-      );
-
-      const issue = buildIssue(
-        'https://github.com/HiromiShikata/test-repository/pull/10',
-      );
-      await repository.createComment(issue, 'pr comment');
-
-      expect(global.fetch).toHaveBeenCalledWith(
-        'https://api.github.com/repos/HiromiShikata/test-repository/issues/10/comments',
-        expect.objectContaining({
-          method: 'POST',
-        }),
-      );
-    });
-
-    it('should throw an error when the response is not 2xx', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response('Not Found', {
-          status: 404,
-          statusText: 'Not Found',
-        }),
-      );
-
-      const issue = buildIssue(
-        'https://github.com/HiromiShikata/test-repository/issues/42',
-      );
-
-      await expect(
-        repository.createComment(issue, 'hello world'),
-      ).rejects.toThrow('404');
-    });
-
-    it('should issue exactly one HTTP request per call', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response(JSON.stringify({ id: 3 }), {
-          status: 201,
-          headers: { 'Content-Type': 'application/json' },
-        }),
-      );
-
-      const issue = buildIssue(
-        'https://github.com/HiromiShikata/test-repository/issues/5',
-      );
-      await repository.createComment(issue, 'single request');
-
-      expect(global.fetch).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not call the GraphQL endpoint', async () => {
-      jest.spyOn(global, 'fetch').mockResolvedValue(
-        new Response(JSON.stringify({ id: 4 }), {
-          status: 201,
-          headers: { 'Content-Type': 'application/json' },
-        }),
-      );
-
-      const issue = buildIssue(
-        'https://github.com/HiromiShikata/test-repository/issues/7',
-      );
-      await repository.createComment(issue, 'no graphql');
-
-      expect(global.fetch).not.toHaveBeenCalledWith(
-        'https://api.github.com/graphql',
-        expect.anything(),
-      );
-    });
-  });
-});

package/src/adapter/repositories/GitHubIssueCommentRepository.ts

@@ -1,109 +0,0 @@
-import { IssueCommentRepository } from '../../domain/usecases/adapter-interfaces/IssueCommentRepository';
-import { Issue } from '../../domain/entities/Issue';
-import { Comment } from '../../domain/entities/Comment';
-
-type RestCommentPayload = {
-  user: { login: string } | null;
-  body: string;
-  created_at: string;
-};
-
-function isRestCommentPayloadArray(
-  value: unknown,
-): value is RestCommentPayload[] {
-  if (!Array.isArray(value)) return false;
-  return true;
-}
-
-export class GitHubIssueCommentRepository implements IssueCommentRepository {
-  constructor(private readonly token: string) {}
-
-  private parseIssueUrl(issue: Issue): {
-    owner: string;
-    repo: string;
-    issueNumber: number;
-    isPr: boolean;
-  } {
-    const urlMatch = issue.url.match(
-      /github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/(\d+)/,
-    );
-    if (!urlMatch) {
-      throw new Error(`Invalid GitHub issue URL: ${issue.url}`);
-    }
-    return {
-      owner: urlMatch[1],
-      repo: urlMatch[2],
-      issueNumber: parseInt(urlMatch[4], 10),
-      isPr: urlMatch[3] === 'pull',
-    };
-  }
-
-  async getCommentsFromIssue(issue: Issue): Promise<Comment[]> {
-    const { owner, repo, issueNumber } = this.parseIssueUrl(issue);
-
-    const comments: Comment[] = [];
-    let page = 1;
-    let hasNextPage = true;
-
-    while (hasNextPage) {
-      const url = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments?per_page=100&page=${page}`;
-      const response = await fetch(url, {
-        headers: {
-          Authorization: `Bearer ${this.token}`,
-          Accept: 'application/vnd.github+json',
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error(
-          `Failed to fetch comments from GitHub REST API: ${response.status} ${response.statusText}`,
-        );
-      }
-
-      const responseData: unknown = await response.json();
-      if (!isRestCommentPayloadArray(responseData)) {
-        throw new Error(
-          'Unexpected response shape when fetching comments from GitHub REST API',
-        );
-      }
-
-      for (const payload of responseData) {
-        comments.push({
-          author: payload.user?.login ?? '',
-          content: payload.body,
-          createdAt: new Date(payload.created_at),
-        });
-      }
-
-      const linkHeader = response.headers.get('Link') ?? '';
-      hasNextPage = linkHeader.includes('rel="next"');
-
-      page++;
-    }
-
-    return comments;
-  }
-
-  async createComment(issue: Issue, commentContent: string): Promise<void> {
-    const { owner, repo, issueNumber } = this.parseIssueUrl(issue);
-
-    const response = await fetch(
-      `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`,
-      {
-        method: 'POST',
-        headers: {
-          Authorization: `Bearer ${this.token}`,
-          Accept: 'application/vnd.github+json',
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ body: commentContent }),
-      },
-    );
-
-    if (!response.ok) {
-      throw new Error(
-        `Failed to create comment via GitHub REST API: ${response.status} ${response.statusText}`,
-      );
-    }
-  }
-}