canopycms 0.0.0 → 0.0.2

package/src/github-service.test.ts

@@ -1,312 +0,0 @@
-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

@@ -1,295 +0,0 @@
-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
-  }
-}