npm-cli-gh-issue-preparator 1.0.0

package/src/adapter/repositories/GitHubProjectRepository.ts

@@ -0,0 +1,162 @@
+import { ProjectRepository } from '../../domain/usecases/adapter-interfaces/ProjectRepository';
+import { Project } from '../../domain/entities/Project';
+
+type GitHubProjectField = {
+  name: string;
+  options?: Array<{ name: string }>;
+};
+
+type GitHubProjectV2 = {
+  id: string;
+  title: string;
+  url: string;
+  fields: {
+    nodes: GitHubProjectField[];
+  };
+};
+
+type GitHubApiResponse = {
+  data?: {
+    organization?: {
+      projectV2?: GitHubProjectV2;
+    };
+    user?: {
+      projectV2?: GitHubProjectV2;
+    };
+  };
+};
+
+function isGitHubApiResponse(value: unknown): value is GitHubApiResponse {
+  if (typeof value !== 'object' || value === null) return false;
+  return true;
+}
+
+export class GitHubProjectRepository implements ProjectRepository {
+  constructor(private readonly token: string) {}
+
+  private parseGitHubProjectUrl(url: string): {
+    owner: string;
+    projectNumber: string;
+  } {
+    const orgMatch = url.match(/github\.com\/orgs\/([^/]+)\/projects\/(\d+)/);
+    if (orgMatch) {
+      return {
+        owner: orgMatch[1],
+        projectNumber: orgMatch[2],
+      };
+    }
+
+    const userMatch = url.match(/github\.com\/users\/([^/]+)\/projects\/(\d+)/);
+    if (userMatch) {
+      return {
+        owner: userMatch[1],
+        projectNumber: userMatch[2],
+      };
+    }
+
+    const repoMatch = url.match(
+      /github\.com\/([^/]+)\/([^/]+)\/projects\/(\d+)/,
+    );
+    if (repoMatch) {
+      return {
+        owner: repoMatch[1],
+        projectNumber: repoMatch[3],
+      };
+    }
+
+    throw new Error(`Invalid GitHub project URL: ${url}`);
+  }
+
+  async getByUrl(url: string): Promise<Project> {
+    const { owner, projectNumber } = this.parseGitHubProjectUrl(url);
+
+    const projectQuery = `
+      query($owner: String!, $number: Int!) {
+        organization(login: $owner) {
+          projectV2(number: $number) {
+            id
+            title
+            url
+            fields(first: 100) {
+              nodes {
+                ... on ProjectV2SingleSelectField {
+                  name
+                  options {
+                    name
+                  }
+                }
+                ... on ProjectV2Field {
+                  name
+                }
+              }
+            }
+          }
+        }
+        user(login: $owner) {
+          projectV2(number: $number) {
+            id
+            title
+            url
+            fields(first: 100) {
+              nodes {
+                ... on ProjectV2SingleSelectField {
+                  name
+                  options {
+                    name
+                  }
+                }
+                ... on ProjectV2Field {
+                  name
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    const response = await fetch('https://api.github.com/graphql', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        query: projectQuery,
+        variables: {
+          owner,
+          number: parseInt(projectNumber, 10),
+        },
+      }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`GitHub API error: ${errorText}`);
+    }
+
+    const responseData: unknown = await response.json();
+    if (!isGitHubApiResponse(responseData)) {
+      throw new Error('Invalid API response format');
+    }
+
+    const result: GitHubApiResponse = responseData;
+    const project =
+      result.data?.organization?.projectV2 || result.data?.user?.projectV2;
+    if (!project) {
+      throw new Error(`Project not found: ${url}`);
+    }
+
+    const fields = project.fields.nodes;
+    const statusField = fields.find((f) => f.name === 'Status');
+    const statuses: string[] = statusField?.options?.map((o) => o.name) || [];
+
+    return {
+      id: project.id,
+      url: project.url,
+      name: project.title,
+      statuses,
+      customFieldNames: fields.map((f) => f.name),
+    };
+  }
+}

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

@@ -0,0 +1,80 @@
+const mockExecAsync = jest.fn();
+
+jest.mock('child_process', () => ({
+  exec: jest.fn(),
+}));
+
+jest.mock('util', () => ({
+  promisify: jest.fn(() => mockExecAsync),
+}));
+
+import { NodeLocalCommandRunner } from './NodeLocalCommandRunner';
+
+describe('NodeLocalCommandRunner', () => {
+  let runner: NodeLocalCommandRunner;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    runner = new NodeLocalCommandRunner();
+  });
+
+  describe('runCommand', () => {
+    it('should execute command successfully', async () => {
+      mockExecAsync.mockResolvedValue({
+        stdout: 'command output',
+        stderr: '',
+      });
+
+      const result = await runner.runCommand('echo "test"');
+
+      expect(result).toEqual({
+        stdout: 'command output',
+        stderr: '',
+        exitCode: 0,
+      });
+      expect(mockExecAsync).toHaveBeenCalledWith('echo "test"');
+    });
+
+    it('should handle command errors with exit code', async () => {
+      const error = Object.assign(new Error('Command failed'), {
+        code: 2,
+        stdout: 'partial output',
+        stderr: 'error message',
+      });
+      mockExecAsync.mockRejectedValue(error);
+
+      const result = await runner.runCommand('invalid-command');
+
+      expect(result).toEqual({
+        stdout: 'partial output',
+        stderr: 'error message',
+        exitCode: 2,
+      });
+    });
+
+    it('should default to exit code 1 when code is not a number', async () => {
+      const error = Object.assign(new Error('Command failed'), {
+        code: 'ENOENT',
+        stdout: '',
+        stderr: 'command not found',
+      });
+      mockExecAsync.mockRejectedValue(error);
+
+      const result = await runner.runCommand('nonexistent');
+
+      expect(result).toEqual({
+        stdout: '',
+        stderr: 'command not found',
+        exitCode: 1,
+      });
+    });
+
+    it('should throw error if error format is unexpected', async () => {
+      mockExecAsync.mockRejectedValue(new Error('Unexpected error'));
+
+      await expect(runner.runCommand('command')).rejects.toThrow(
+        'Unexpected error',
+      );
+    });
+  });
+});

package/src/adapter/repositories/NodeLocalCommandRunner.ts

@@ -0,0 +1,37 @@
+import { LocalCommandRunner } from '../../domain/usecases/adapter-interfaces/LocalCommandRunner';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+export class NodeLocalCommandRunner implements LocalCommandRunner {
+  async runCommand(command: string): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }> {
+    try {
+      const { stdout, stderr } = await execAsync(command);
+      return {
+        stdout,
+        stderr,
+        exitCode: 0,
+      };
+    } catch (error) {
+      if (
+        error &&
+        typeof error === 'object' &&
+        'stdout' in error &&
+        'stderr' in error &&
+        'code' in error
+      ) {
+        return {
+          stdout: String(error.stdout),
+          stderr: String(error.stderr),
+          exitCode: typeof error.code === 'number' ? error.code : 1,
+        };
+      }
+      throw error;
+    }
+  }
+}

package/src/domain/entities/Issue.ts

@@ -0,0 +1,7 @@
+export type Issue = {
+  id: string;
+  url: string;
+  title: string;
+  labels: string[];
+  status: string;
+};

package/src/domain/entities/Project.ts

@@ -0,0 +1,7 @@
+export type Project = {
+  id: string;
+  url: string;
+  name: string;
+  statuses: string[];
+  customFieldNames: string[];
+};

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

@@ -0,0 +1,109 @@
+import { NotifyFinishedIssuePreparationUseCase } from './NotifyFinishedIssuePreparationUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+
+describe('NotifyFinishedIssuePreparationUseCase', () => {
+  let useCase: NotifyFinishedIssuePreparationUseCase;
+  let mockProjectRepository: Mocked<ProjectRepository>;
+  let mockIssueRepository: Mocked<IssueRepository>;
+
+  const mockProject: Project = {
+    id: 'project-1',
+    url: 'https://github.com/user/repo',
+    name: 'Test Project',
+    statuses: ['Preparation', 'Awaiting Quality Check', 'Done'],
+    customFieldNames: ['workspace'],
+  };
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+
+    mockProjectRepository = {
+      getByUrl: jest.fn(),
+    };
+
+    mockIssueRepository = {
+      getAllOpened: jest.fn(),
+      get: jest.fn(),
+      update: jest.fn(),
+    };
+
+    useCase = new NotifyFinishedIssuePreparationUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+    );
+  });
+
+  it('should update issue status from Preparation to Awaiting Quality Check', async () => {
+    const issue: Issue = {
+      id: '1',
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Test Issue',
+      labels: [],
+      status: 'Preparation',
+    };
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      preparationStatus: 'Preparation',
+      awaitingQualityCheckStatus: 'Awaiting Quality Check',
+    });
+
+    expect(mockIssueRepository.update).toHaveBeenCalledTimes(1);
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        status: 'Awaiting Quality Check',
+      }),
+      mockProject,
+    );
+  });
+
+  it('should throw IssueNotFoundError when issue does not exist', async () => {
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(null);
+
+    await expect(
+      useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        issueUrl: 'https://github.com/user/repo/issues/999',
+        preparationStatus: 'Preparation',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      }),
+    ).rejects.toThrow(
+      'Issue not found: https://github.com/user/repo/issues/999',
+    );
+  });
+
+  it('should throw IllegalIssueStatusError when issue status is not Preparation', async () => {
+    const issue: Issue = {
+      id: '1',
+      url: 'https://github.com/user/repo/issues/1',
+      title: 'Test Issue',
+      labels: [],
+      status: 'Done',
+    };
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+
+    await expect(
+      useCase.run({
+        projectUrl: 'https://github.com/user/repo',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        preparationStatus: 'Preparation',
+        awaitingQualityCheckStatus: 'Awaiting Quality Check',
+      }),
+    ).rejects.toThrow(
+      'Illegal issue status for https://github.com/user/repo/issues/1: expected Preparation, but got Done',
+    );
+  });
+});

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -0,0 +1,48 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+
+export class IssueNotFoundError extends Error {
+  constructor(issueUrl: string) {
+    super(`Issue not found: ${issueUrl}`);
+    this.name = 'IssueNotFoundError';
+  }
+}
+export class IllegalIssueStatusError extends Error {
+  constructor(issueUrl: string, currentStatus: string, expectedStatus: string) {
+    super(
+      `Illegal issue status for ${issueUrl}: expected ${expectedStatus}, but got ${currentStatus}`,
+    );
+    this.name = 'IllegalIssueStatusError';
+  }
+}
+
+export class NotifyFinishedIssuePreparationUseCase {
+  constructor(
+    private readonly projectRepository: ProjectRepository,
+    private readonly issueRepository: IssueRepository,
+  ) {}
+
+  run = async (params: {
+    projectUrl: string;
+    issueUrl: string;
+    preparationStatus: string;
+    awaitingQualityCheckStatus: string;
+  }): Promise<void> => {
+    const project = await this.projectRepository.getByUrl(params.projectUrl);
+
+    const issue = await this.issueRepository.get(params.issueUrl, project);
+
+    if (!issue) {
+      throw new IssueNotFoundError(params.issueUrl);
+    } else if (issue.status !== params.preparationStatus) {
+      throw new IllegalIssueStatusError(
+        params.issueUrl,
+        issue.status,
+        params.preparationStatus,
+      );
+    }
+
+    issue.status = params.awaitingQualityCheckStatus;
+    await this.issueRepository.update(issue, project);
+  };
+}

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

@@ -0,0 +1,150 @@
+import { StartPreparationUseCase } from './StartPreparationUseCase';
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
+import { Issue } from '../entities/Issue';
+import { Project } from '../entities/Project';
+type Mocked<T> = jest.Mocked<T> & jest.MockedObject<T>;
+describe('StartPreparationUseCase', () => {
+  let useCase: StartPreparationUseCase;
+  let mockProjectRepository: Mocked<ProjectRepository>;
+  let mockIssueRepository: Mocked<IssueRepository>;
+  let mockLocalCommandRunner: Mocked<LocalCommandRunner>;
+  const mockProject: Project = {
+    id: 'project-1',
+    url: 'https://github.com/user/repo',
+    name: 'Test Project',
+    statuses: ['Awaiting Workspace', 'Preparation', 'Done'],
+    customFieldNames: ['workspace'],
+  };
+  beforeEach(() => {
+    jest.resetAllMocks();
+    mockProjectRepository = {
+      getByUrl: jest.fn(),
+    };
+    mockIssueRepository = {
+      getAllOpened: jest.fn(),
+      get: jest.fn(),
+      update: jest.fn(),
+    };
+    mockLocalCommandRunner = {
+      runCommand: jest.fn(),
+    };
+    useCase = new StartPreparationUseCase(
+      mockProjectRepository,
+      mockIssueRepository,
+      mockLocalCommandRunner,
+    );
+  });
+  it('should run aw command for awaiting workspace issues', async () => {
+    const awaitingIssues: Issue[] = [
+      {
+        id: '1',
+        url: 'url1',
+        title: 'Issue 1',
+        labels: ['category:impl'],
+        status: 'Awaiting Workspace',
+      },
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+    });
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(1);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+      id: '1',
+      status: 'Preparation',
+    });
+    expect(mockIssueRepository.update.mock.calls[0][1]).toBe(mockProject);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(1);
+    expect(mockLocalCommandRunner.runCommand.mock.calls[0][0]).toBe(
+      'aw https://github.com/user/repo url1 impl',
+    );
+  });
+  it('should assign workspace to awaiting issues', async () => {
+    const awaitingIssues: Issue[] = [
+      {
+        id: '1',
+        url: 'url1',
+        title: 'Issue 1',
+        labels: [],
+        status: 'Awaiting Workspace',
+      },
+      {
+        id: '2',
+        url: 'url2',
+        title: 'Issue 2',
+        labels: [],
+        status: 'Awaiting Workspace',
+      },
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce(awaitingIssues);
+    mockLocalCommandRunner.runCommand.mockResolvedValue({
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+    });
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+    });
+    expect(mockIssueRepository.update.mock.calls).toHaveLength(2);
+    expect(mockIssueRepository.update.mock.calls[0][0]).toMatchObject({
+      id: '1',
+      status: 'Preparation',
+    });
+    expect(mockIssueRepository.update.mock.calls[0][1]).toBe(mockProject);
+    expect(mockIssueRepository.update.mock.calls[1][0]).toMatchObject({
+      id: '2',
+      status: 'Preparation',
+    });
+    expect(mockIssueRepository.update.mock.calls[1][1]).toBe(mockProject);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(2);
+  });
+  it('should not assign workspace if maximum preparing issues reached', async () => {
+    const preparationIssues: Issue[] = Array.from({ length: 6 }, (_, i) => ({
+      id: `${i + 1}`,
+      url: `url${i + 1}`,
+      title: `Issue ${i + 1}`,
+      labels: [],
+      status: 'Preparation',
+    }));
+    const awaitingIssues: Issue[] = [
+      {
+        id: '7',
+        url: 'url7',
+        title: 'Issue 7',
+        labels: [],
+        status: 'Awaiting Workspace',
+      },
+    ];
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.getAllOpened.mockResolvedValueOnce([
+      ...preparationIssues,
+      ...awaitingIssues,
+    ]);
+    await useCase.run({
+      projectUrl: 'https://github.com/user/repo',
+      awaitingWorkspaceStatus: 'Awaiting Workspace',
+      preparationStatus: 'Preparation',
+      defaultAgentName: 'agent1',
+    });
+    const issue7UpdateCalls = mockIssueRepository.update.mock.calls.filter(
+      (call) => call[0].id === '7',
+    );
+    expect(issue7UpdateCalls).toHaveLength(0);
+    expect(mockLocalCommandRunner.runCommand.mock.calls).toHaveLength(0);
+  });
+});

package/src/domain/usecases/StartPreparationUseCase.ts

@@ -0,0 +1,48 @@
+import { IssueRepository } from './adapter-interfaces/IssueRepository';
+import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
+import { LocalCommandRunner } from './adapter-interfaces/LocalCommandRunner';
+
+export class StartPreparationUseCase {
+  maximumPreparingIssuesCount = 6;
+  constructor(
+    private readonly projectRepository: ProjectRepository,
+    private readonly issueRepository: IssueRepository,
+    private readonly localCommandRunner: LocalCommandRunner,
+  ) {}
+
+  run = async (params: {
+    projectUrl: string;
+    awaitingWorkspaceStatus: string;
+    preparationStatus: string;
+    defaultAgentName: string;
+  }): Promise<void> => {
+    const project = await this.projectRepository.getByUrl(params.projectUrl);
+
+    const allIssues = await this.issueRepository.getAllOpened(project);
+
+    const awaitingWorkspaceIssues = allIssues.filter(
+      (issue) => issue.status === params.awaitingWorkspaceStatus,
+    );
+
+    if (
+      allIssues.filter((issue) => issue.status === params.preparationStatus)
+        .length >= this.maximumPreparingIssuesCount
+    ) {
+      return;
+    }
+
+    for (const issue of awaitingWorkspaceIssues) {
+      const agent =
+        issue.labels
+          .find((label) => label.startsWith('category:'))
+          ?.replace('category:', '')
+          .trim() || params.defaultAgentName;
+      issue.status = params.preparationStatus;
+      await this.issueRepository.update(issue, project);
+
+      await this.localCommandRunner.runCommand(
+        `aw ${project.url} ${issue.url} ${agent}`,
+      );
+    }
+  };
+}

package/src/domain/usecases/adapter-interfaces/IssueRepository.ts

@@ -0,0 +1,8 @@
+import { Issue } from '../../entities/Issue';
+import { Project } from '../../entities/Project';
+
+export interface IssueRepository {
+  getAllOpened(project: Project): Promise<Issue[]>;
+  get(issueUrl: string, project: Project): Promise<Issue | null>;
+  update(issue: Issue, project: Project): Promise<void>;
+}

package/src/domain/usecases/adapter-interfaces/LocalCommandRunner.ts

@@ -0,0 +1,7 @@
+export interface LocalCommandRunner {
+  runCommand(command: string): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }>;
+}

package/src/domain/usecases/adapter-interfaces/ProjectRepository.ts

@@ -0,0 +1,5 @@
+import { Project } from '../../entities/Project';
+
+export interface ProjectRepository {
+  getByUrl(url: string): Promise<Project>;
+}

package/src/index.test.ts

@@ -0,0 +1,7 @@
+import { program } from './index';
+
+describe('index', () => {
+  it('should export program from CLI module', () => {
+    expect(program).toBeDefined();
+  });
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+import { program } from './adapter/entry-points/cli/index';
+
+export { program };