canopycms 0.0.0

package/src/github-service.test.ts

@@ -0,0 +1,312 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { GitHubService, createGitHubService } from './github-service'
+import type { CanopyConfig } from './config'
+import { mockConsole } from './test-utils/console-spy.js'
+
+describe('GitHubService', () => {
+  describe('parseRemoteUrl', () => {
+    it('should parse HTTPS URL with .git suffix', () => {
+      const result = GitHubService.parseRemoteUrl('https://github.com/owner/repo.git')
+      expect(result).toEqual({ owner: 'owner', repo: 'repo' })
+    })
+
+    it('should parse HTTPS URL without .git suffix', () => {
+      const result = GitHubService.parseRemoteUrl('https://github.com/owner/repo')
+      expect(result).toEqual({ owner: 'owner', repo: 'repo' })
+    })
+
+    it('should parse SSH URL with .git suffix', () => {
+      const result = GitHubService.parseRemoteUrl('git@github.com:owner/repo.git')
+      expect(result).toEqual({ owner: 'owner', repo: 'repo' })
+    })
+
+    it('should parse SSH URL without .git suffix', () => {
+      const result = GitHubService.parseRemoteUrl('git@github.com:owner/repo')
+      expect(result).toEqual({ owner: 'owner', repo: 'repo' })
+    })
+
+    it('should handle HTTP (non-secure) URLs', () => {
+      const result = GitHubService.parseRemoteUrl('http://github.com/owner/repo.git')
+      expect(result).toEqual({ owner: 'owner', repo: 'repo' })
+    })
+
+    it('should throw error for invalid URL format', () => {
+      expect(() => GitHubService.parseRemoteUrl('invalid-url')).toThrow(
+        'Unable to parse GitHub remote URL',
+      )
+    })
+
+    it('should throw error for non-GitHub URL', () => {
+      expect(() => GitHubService.parseRemoteUrl('https://gitlab.com/owner/repo.git')).toThrow(
+        'Unable to parse GitHub remote URL',
+      )
+    })
+  })
+
+  describe('createGitHubService', () => {
+    const mockConfig: CanopyConfig = {
+      gitBotAuthorName: 'Bot',
+      gitBotAuthorEmail: 'bot@example.com',
+      defaultBaseBranch: 'main',
+      mode: 'prod', // Use prod mode for GitHub service tests
+      contentRoot: 'content',
+    }
+
+    beforeEach(() => {
+      // Clear environment variables
+      delete process.env.GITHUB_BOT_TOKEN
+      delete process.env.CANOPYCMS_GITHUB_TOKEN
+    })
+
+    it('should return null for dev mode', () => {
+      const config = { ...mockConfig, mode: 'dev' as const }
+      const service = createGitHubService(config, 'https://github.com/owner/repo.git')
+      expect(service).toBeNull()
+    })
+
+    it('should return null when token is missing', () => {
+      const consoleSpy = mockConsole()
+      const service = createGitHubService(mockConfig, 'https://github.com/owner/repo.git')
+      expect(service).toBeNull()
+      expect(consoleSpy).toHaveWarned('GitHub token not found')
+      consoleSpy.restore()
+    })
+
+    it('should return null when remoteUrl is missing', () => {
+      const consoleSpy = mockConsole()
+      process.env.GITHUB_BOT_TOKEN = 'test-token'
+      const service = createGitHubService(mockConfig)
+      expect(service).toBeNull()
+      expect(consoleSpy).toHaveWarned('requires remoteUrl')
+      consoleSpy.restore()
+    })
+
+    it('should create service with GITHUB_BOT_TOKEN', () => {
+      process.env.GITHUB_BOT_TOKEN = 'test-token'
+      const service = createGitHubService(mockConfig, 'https://github.com/owner/repo.git')
+      expect(service).toBeInstanceOf(GitHubService)
+    })
+
+    it('should create service with CANOPYCMS_GITHUB_TOKEN', () => {
+      process.env.CANOPYCMS_GITHUB_TOKEN = 'test-token'
+      const service = createGitHubService(mockConfig, 'https://github.com/owner/repo.git')
+      expect(service).toBeInstanceOf(GitHubService)
+    })
+
+    it('should create service with custom token env var', () => {
+      process.env.CUSTOM_TOKEN = 'test-token'
+      const config = { ...mockConfig, githubTokenEnvVar: 'CUSTOM_TOKEN' }
+      const service = createGitHubService(config, 'https://github.com/owner/repo.git')
+      expect(service).toBeInstanceOf(GitHubService)
+    })
+
+    it('should return null for invalid remote URL', () => {
+      const consoleSpy = mockConsole()
+      process.env.GITHUB_BOT_TOKEN = 'test-token'
+      const service = createGitHubService(mockConfig, 'invalid-url')
+      expect(service).toBeNull()
+      expect(consoleSpy).toHaveWarned('Failed to parse GitHub remote URL')
+      consoleSpy.restore()
+    })
+
+    it('should use config baseBranch', () => {
+      process.env.GITHUB_BOT_TOKEN = 'test-token'
+      const config = { ...mockConfig, defaultBaseBranch: 'develop' }
+      const service = createGitHubService(config, 'https://github.com/owner/repo.git')
+      expect(service).toBeInstanceOf(GitHubService)
+      // baseBranch is private, but we can verify the service was created successfully
+    })
+  })
+
+  describe('GitHubService methods', () => {
+    let service: GitHubService
+    let mockOctokit: any
+
+    beforeEach(() => {
+      // Create a mock Octokit instance
+      mockOctokit = {
+        pulls: {
+          create: vi.fn(),
+          update: vi.fn(),
+          get: vi.fn(),
+        },
+        graphql: vi.fn(),
+        git: {
+          deleteRef: vi.fn(),
+        },
+      }
+
+      service = new GitHubService({
+        token: 'test-token',
+        owner: 'test-owner',
+        repo: 'test-repo',
+        baseBranch: 'main',
+      })
+
+      // Replace the internal octokit instance with our mock
+      ;(service as any).octokit = mockOctokit
+    })
+
+    describe('createPullRequest', () => {
+      it('should create a pull request', async () => {
+        mockOctokit.pulls.create.mockResolvedValue({
+          data: {
+            number: 123,
+            html_url: 'https://github.com/test-owner/test-repo/pull/123',
+          },
+        })
+
+        const result = await service.createPullRequest({
+          branchName: 'feature-branch',
+          title: 'Test PR',
+          body: 'Test description',
+        })
+
+        expect(result).toEqual({
+          number: 123,
+          url: 'https://github.com/test-owner/test-repo/pull/123',
+        })
+
+        expect(mockOctokit.pulls.create).toHaveBeenCalledWith({
+          owner: 'test-owner',
+          repo: 'test-repo',
+          title: 'Test PR',
+          body: 'Test description',
+          head: 'feature-branch',
+          base: 'main',
+          draft: false,
+        })
+      })
+
+      it('should create a draft pull request', async () => {
+        mockOctokit.pulls.create.mockResolvedValue({
+          data: {
+            number: 123,
+            html_url: 'https://github.com/test-owner/test-repo/pull/123',
+          },
+        })
+
+        await service.createPullRequest({
+          branchName: 'feature-branch',
+          title: 'Test PR',
+          body: 'Test description',
+          draft: true,
+        })
+
+        expect(mockOctokit.pulls.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            draft: true,
+          }),
+        )
+      })
+    })
+
+    describe('updatePullRequest', () => {
+      it('should update a pull request', async () => {
+        mockOctokit.pulls.update.mockResolvedValue({ data: {} })
+
+        await service.updatePullRequest(123, {
+          title: 'Updated title',
+          body: 'Updated body',
+        })
+
+        expect(mockOctokit.pulls.update).toHaveBeenCalledWith({
+          owner: 'test-owner',
+          repo: 'test-repo',
+          pull_number: 123,
+          title: 'Updated title',
+          body: 'Updated body',
+        })
+      })
+    })
+
+    describe('getPullRequest', () => {
+      it('should get pull request details', async () => {
+        mockOctokit.pulls.get.mockResolvedValue({
+          data: {
+            number: 123,
+            html_url: 'https://github.com/test-owner/test-repo/pull/123',
+            state: 'open',
+            merged: false,
+            draft: false,
+          },
+        })
+
+        const result = await service.getPullRequest(123)
+
+        expect(result).toEqual({
+          number: 123,
+          url: 'https://github.com/test-owner/test-repo/pull/123',
+          state: 'open',
+          merged: false,
+          draft: false,
+        })
+      })
+    })
+
+    describe('convertToDraft', () => {
+      it('should convert PR to draft', async () => {
+        mockOctokit.pulls.get.mockResolvedValue({
+          data: {
+            node_id: 'PR_node_123',
+          },
+        })
+        mockOctokit.graphql.mockResolvedValue({})
+
+        await service.convertToDraft(123)
+
+        expect(mockOctokit.graphql).toHaveBeenCalledWith(
+          expect.stringContaining('convertPullRequestToDraft'),
+          { pullRequestId: 'PR_node_123' },
+        )
+      })
+    })
+
+    describe('convertToReady', () => {
+      it('should convert draft PR to ready', async () => {
+        mockOctokit.pulls.get.mockResolvedValue({
+          data: {
+            node_id: 'PR_node_123',
+          },
+        })
+        mockOctokit.graphql.mockResolvedValue({})
+
+        await service.convertToReady(123)
+
+        expect(mockOctokit.graphql).toHaveBeenCalledWith(
+          expect.stringContaining('markPullRequestReadyForReview'),
+          { pullRequestId: 'PR_node_123' },
+        )
+      })
+    })
+
+    describe('closePullRequest', () => {
+      it('should close a pull request', async () => {
+        mockOctokit.pulls.update.mockResolvedValue({ data: {} })
+
+        await service.closePullRequest(123)
+
+        expect(mockOctokit.pulls.update).toHaveBeenCalledWith({
+          owner: 'test-owner',
+          repo: 'test-repo',
+          pull_number: 123,
+          state: 'closed',
+        })
+      })
+    })
+
+    describe('deleteBranch', () => {
+      it('should delete a remote branch', async () => {
+        mockOctokit.git.deleteRef.mockResolvedValue({ data: {} })
+
+        await service.deleteBranch('feature-branch')
+
+        expect(mockOctokit.git.deleteRef).toHaveBeenCalledWith({
+          owner: 'test-owner',
+          repo: 'test-repo',
+          ref: 'heads/feature-branch',
+        })
+      })
+    })
+  })
+})

package/src/github-service.ts

@@ -0,0 +1,295 @@
+import { Octokit } from '@octokit/rest'
+import type { CanopyConfig } from './config'
+import { operatingStrategy } from './operating-mode'
+
+export interface GitHubServiceOptions {
+  token: string
+  owner: string
+  repo: string
+  baseBranch?: string
+}
+
+export interface PullRequestOptions {
+  branchName: string
+  title: string
+  body: string
+  draft?: boolean
+}
+
+export interface PullRequestDetails {
+  number: number
+  url: string
+  state: 'open' | 'closed'
+  merged: boolean
+  draft: boolean
+}
+
+/**
+ * Service for interacting with GitHub API (pull requests, branches, etc.)
+ */
+export class GitHubService {
+  private octokit: Octokit
+  private owner: string
+  private repo: string
+  private baseBranch: string
+
+  constructor(options: GitHubServiceOptions) {
+    this.octokit = new Octokit({ auth: options.token })
+    this.owner = options.owner
+    this.repo = options.repo
+    this.baseBranch = options.baseBranch ?? 'main'
+  }
+
+  /**
+   * Create a new pull request
+   */
+  async createPullRequest(options: PullRequestOptions): Promise<{ number: number; url: string }> {
+    const response = await this.octokit.pulls.create({
+      owner: this.owner,
+      repo: this.repo,
+      title: options.title,
+      body: options.body,
+      head: options.branchName,
+      base: this.baseBranch,
+      draft: options.draft ?? false,
+    })
+
+    return {
+      number: response.data.number,
+      url: response.data.html_url,
+    }
+  }
+
+  /**
+   * Update an existing pull request
+   */
+  async updatePullRequest(
+    prNumber: number,
+    options: Partial<Pick<PullRequestOptions, 'title' | 'body'>>,
+  ): Promise<void> {
+    await this.octokit.pulls.update({
+      owner: this.owner,
+      repo: this.repo,
+      pull_number: prNumber,
+      title: options.title,
+      body: options.body,
+    })
+  }
+
+  /**
+   * Create or update a pull request
+   * If a PR already exists from head to base, update it. Otherwise, create a new one.
+   */
+  async createOrUpdatePR(options: {
+    head: string
+    base: string
+    title: string
+    body: string
+  }): Promise<string> {
+    // Check if PR already exists
+    const existingPRs = await this.octokit.pulls.list({
+      owner: this.owner,
+      repo: this.repo,
+      head: `${this.owner}:${options.head}`,
+      base: options.base,
+      state: 'open',
+    })
+
+    if (existingPRs.data.length > 0) {
+      // Update existing PR
+      const pr = existingPRs.data[0]
+      await this.octokit.pulls.update({
+        owner: this.owner,
+        repo: this.repo,
+        pull_number: pr.number,
+        body: options.body,
+      })
+      return pr.html_url
+    }
+
+    // Create new PR
+    const pr = await this.octokit.pulls.create({
+      owner: this.owner,
+      repo: this.repo,
+      head: options.head,
+      base: options.base,
+      title: options.title,
+      body: options.body,
+    })
+
+    return pr.data.html_url
+  }
+
+  /**
+   * Get pull request details
+   */
+  async getPullRequest(prNumber: number): Promise<PullRequestDetails> {
+    const response = await this.octokit.pulls.get({
+      owner: this.owner,
+      repo: this.repo,
+      pull_number: prNumber,
+    })
+
+    return {
+      number: response.data.number,
+      url: response.data.html_url,
+      state: response.data.state as 'open' | 'closed',
+      merged: response.data.merged ?? false,
+      draft: response.data.draft ?? false,
+    }
+  }
+
+  /**
+   * Convert a pull request to draft
+   */
+  async convertToDraft(prNumber: number): Promise<void> {
+    // Use GraphQL API for draft conversion (not available in REST API)
+    await this.octokit.graphql(
+      `
+      mutation($pullRequestId: ID!) {
+        convertPullRequestToDraft(input: {pullRequestId: $pullRequestId}) {
+          pullRequest {
+            id
+          }
+        }
+      }
+    `,
+      {
+        pullRequestId: await this.getPullRequestNodeId(prNumber),
+      },
+    )
+  }
+
+  /**
+   * Convert a draft pull request to ready for review
+   */
+  async convertToReady(prNumber: number): Promise<void> {
+    // Use GraphQL API for draft conversion (not available in REST API)
+    await this.octokit.graphql(
+      `
+      mutation($pullRequestId: ID!) {
+        markPullRequestReadyForReview(input: {pullRequestId: $pullRequestId}) {
+          pullRequest {
+            id
+          }
+        }
+      }
+    `,
+      {
+        pullRequestId: await this.getPullRequestNodeId(prNumber),
+      },
+    )
+  }
+
+  /**
+   * Close a pull request
+   */
+  async closePullRequest(prNumber: number): Promise<void> {
+    await this.octokit.pulls.update({
+      owner: this.owner,
+      repo: this.repo,
+      pull_number: prNumber,
+      state: 'closed',
+    })
+  }
+
+  /**
+   * Delete a remote branch
+   */
+  async deleteBranch(branchName: string): Promise<void> {
+    await this.octokit.git.deleteRef({
+      owner: this.owner,
+      repo: this.repo,
+      ref: `heads/${branchName}`,
+    })
+  }
+
+  /**
+   * Get the GraphQL node ID for a pull request (needed for draft operations)
+   */
+  private async getPullRequestNodeId(prNumber: number): Promise<string> {
+    const response = await this.octokit.pulls.get({
+      owner: this.owner,
+      repo: this.repo,
+      pull_number: prNumber,
+    })
+    return response.data.node_id
+  }
+
+  /**
+   * Parse GitHub remote URL to extract owner and repo
+   * Supports both HTTPS and SSH formats:
+   * - https://github.com/owner/repo.git
+   * - https://github.com/owner/repo
+   * - git@github.com:owner/repo.git
+   * - git@github.com:owner/repo
+   */
+  static parseRemoteUrl(remoteUrl: string): { owner: string; repo: string } {
+    // Remove .git suffix if present
+    const urlWithoutGit = remoteUrl.replace(/\.git$/, '')
+
+    // Try HTTPS format first
+    const httpsMatch = urlWithoutGit.match(/https?:\/\/github\.com\/([^/]+)\/([^/]+)/)
+    if (httpsMatch) {
+      return {
+        owner: httpsMatch[1],
+        repo: httpsMatch[2],
+      }
+    }
+
+    // Try SSH format
+    const sshMatch = urlWithoutGit.match(/git@github\.com:([^/]+)\/(.+)/)
+    if (sshMatch) {
+      return {
+        owner: sshMatch[1],
+        repo: sshMatch[2],
+      }
+    }
+
+    throw new Error(`Unable to parse GitHub remote URL: ${remoteUrl}`)
+  }
+}
+
+/**
+ * Create a GitHub service instance from config and remote URL
+ * Returns null if not applicable (missing token, not GitHub, etc.)
+ */
+export const createGitHubService = (
+  config: CanopyConfig,
+  remoteUrl?: string,
+): GitHubService | null => {
+  // Only create service for modes that support pull requests
+  const mode = config.mode
+  if (!operatingStrategy(mode).supportsPullRequests()) {
+    return null
+  }
+
+  // Get token from environment
+  const tokenEnvVar = config.githubTokenEnvVar ?? 'GITHUB_BOT_TOKEN'
+  const token = process.env[tokenEnvVar] ?? process.env.CANOPYCMS_GITHUB_TOKEN
+
+  if (!token) {
+    console.warn(`CanopyCMS: GitHub token not found in ${tokenEnvVar} or CANOPYCMS_GITHUB_TOKEN`)
+    return null
+  }
+
+  // Need remote URL to determine owner/repo
+  if (!remoteUrl) {
+    console.warn('CanopyCMS: GitHub service requires remoteUrl to determine repository')
+    return null
+  }
+
+  // Parse remote URL
+  try {
+    const { owner, repo } = GitHubService.parseRemoteUrl(remoteUrl)
+    return new GitHubService({
+      token,
+      owner,
+      repo,
+      baseBranch: config.defaultBaseBranch ?? 'main',
+    })
+  } catch (err) {
+    console.warn('CanopyCMS: Failed to parse GitHub remote URL:', err)
+    return null
+  }
+}