bitbucket-gemini-action 1.0.0

package/examples/bitbucket-pipelines-full.yml

@@ -0,0 +1,157 @@
+# Full-featured Bitbucket Pipeline for Gemini Code Review
+# Includes webhook triggers for @gemini mentions
+
+image: node:20
+
+definitions:
+  caches:
+    bun: ~/.bun
+
+  scripts:
+    install-bun: &install-bun |
+      curl -fsSL https://bun.sh/install | bash
+      export BUN_INSTALL="$HOME/.bun"
+      export PATH="$BUN_INSTALL/bin:$PATH"
+
+  steps:
+    - step: &setup-gemini-action
+        name: Setup Gemini Action
+        caches:
+          - bun
+          - node
+        artifacts:
+          - .gemini-action/**
+        script:
+          - *install-bun
+          - |
+            if [ ! -d ".gemini-action" ]; then
+              git clone --depth 1 https://github.com/your-org/bitbucket-gemini-action.git .gemini-action
+            fi
+          - cd .gemini-action && bun install
+
+    - step: &run-gemini-prepare
+        name: Prepare Review
+        caches:
+          - bun
+        script:
+          - *install-bun
+          - bun run .gemini-action/src/entrypoints/prepare.ts
+        artifacts:
+          - .gemini-action-output.json
+
+    - step: &run-gemini-execute
+        name: Execute Review
+        caches:
+          - bun
+        script:
+          - *install-bun
+          - |
+            if [ -f ".gemini-action-output.json" ]; then
+              SHOULD_CONTINUE=$(cat .gemini-action-output.json | jq -r '.containsTrigger')
+              if [ "$SHOULD_CONTINUE" = "true" ]; then
+                bun run .gemini-action/src/entrypoints/execute.ts
+              else
+                echo "Skipping: No trigger detected"
+              fi
+            else
+              echo "Skipping: No prepare output found"
+            fi
+
+pipelines:
+  # Automatic review on all PRs
+  pull-requests:
+    '**':
+      - step: *setup-gemini-action
+      - step:
+          <<: *run-gemini-prepare
+          name: Check for @gemini mentions
+      - step:
+          <<: *run-gemini-execute
+          name: Run Gemini Review
+
+  # Webhook-triggered review (for comment events)
+  custom:
+    # Triggered by webhook when @gemini is mentioned
+    on-mention:
+      - variables:
+          - name: WEBHOOK_PAYLOAD
+          - name: TRIGGER_EVENT
+            default: "pullrequest:comment_created"
+      - step: *setup-gemini-action
+      - step: *run-gemini-prepare
+      - step: *run-gemini-execute
+
+    # Manual full review
+    full-review:
+      - variables:
+          - name: PR_ID
+            description: "Pull Request ID to review"
+          - name: REVIEW_TYPE
+            default: "comprehensive"
+            allowed-values:
+              - "quick"
+              - "comprehensive"
+              - "security"
+      - step: *setup-gemini-action
+      - step:
+          name: Run Full Review
+          caches:
+            - bun
+          script:
+            - *install-bun
+            - |
+              case "$REVIEW_TYPE" in
+                "quick")
+                  PROMPT="Quick review: Check for obvious bugs and issues"
+                  ;;
+                "security")
+                  PROMPT="Security-focused review: Check for vulnerabilities, injection risks, auth issues"
+                  ;;
+                *)
+                  PROMPT="Comprehensive review: bugs, security, performance, code quality, best practices"
+                  ;;
+              esac
+              export PROMPT
+              export MODE="agent"
+              export BITBUCKET_PR_ID="$PR_ID"
+            - bun run .gemini-action/src/entrypoints/prepare.ts
+            - bun run .gemini-action/src/entrypoints/execute.ts
+
+    # Scheduled review of open PRs
+    scheduled-review:
+      - step:
+          name: Review Stale PRs
+          script:
+            - *install-bun
+            - |
+              # Get list of open PRs older than 3 days
+              STALE_PRS=$(curl -s -u "$BITBUCKET_USERNAME:$BITBUCKET_APP_PASSWORD" \
+                "https://api.bitbucket.org/2.0/repositories/$BITBUCKET_WORKSPACE/$BITBUCKET_REPO_SLUG/pullrequests?state=OPEN" \
+                | jq -r '.values[] | select(.created_on < (now - 259200 | todate)) | .id')
+
+              for PR_ID in $STALE_PRS; do
+                echo "Reviewing stale PR #$PR_ID"
+                export BITBUCKET_PR_ID="$PR_ID"
+                export MODE="agent"
+                export PROMPT="This PR has been open for a while. Please review and suggest how to move it forward."
+                bun run .gemini-action/src/entrypoints/prepare.ts
+                bun run .gemini-action/src/entrypoints/execute.ts
+              done
+
+# Branch-specific configurations
+branches:
+  main:
+    - step:
+        name: Security Review
+        script:
+          - *install-bun
+          - |
+            export MODE="agent"
+            export PROMPT="Security review for main branch merge"
+          - bun run .gemini-action/src/entrypoints/prepare.ts
+          - bun run .gemini-action/src/entrypoints/execute.ts
+
+# Schedule daily review of stale PRs
+schedules:
+  - cron: "0 9 * * 1-5"  # 9 AM weekdays
+    pipeline: custom/scheduled-review

package/examples/bitbucket-pipelines-minimal.yml

@@ -0,0 +1,22 @@
+# Minimal Bitbucket Pipeline for Gemini Code Review
+# Copy this to your repository's bitbucket-pipelines.yml
+
+image: node:20
+
+pipelines:
+  pull-requests:
+    '**':
+      - step:
+          name: AI Code Review
+          script:
+            # Install Bun
+            - curl -fsSL https://bun.sh/install | bash
+            - export BUN_INSTALL="$HOME/.bun"
+            - export PATH="$BUN_INSTALL/bin:$PATH"
+
+            # Install and run gemini action
+            - npx bitbucket-gemini-action
+
+# Required repository variables (Settings > Repository settings > Repository variables):
+# - GEMINI_API_KEY: Your Google Gemini API key
+# - BITBUCKET_ACCESS_TOKEN: Token with PR read/write permissions

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "bitbucket-gemini-action",
+  "version": "1.0.0",
+  "description": "Bitbucket Pipeline action for AI-powered code review using Google Gemini",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "bun build src/entrypoints/prepare.ts --outdir=dist --target=node",
+    "test": "bun test",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "dev": "bun run src/entrypoints/prepare.ts"
+  },
+  "dependencies": {
+    "@google/generative-ai": "^0.21.0",
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "node-fetch": "^3.3.2",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.14",
+    "@types/node": "^22.10.2",
+    "prettier": "^3.4.2",
+    "typescript": "^5.7.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "",
+  "license": "MIT",
+  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+}

package/src/bitbucket/api/client.ts

@@ -0,0 +1,406 @@
+/**
+ * Bitbucket Cloud API Client
+ * REST API v2.0 implementation
+ */
+
+import type {
+  BitbucketPullRequest,
+  BitbucketComment,
+  BitbucketDiffStat,
+  BitbucketCommit,
+  BitbucketBranch,
+  BitbucketIssue,
+  BitbucketRepository,
+  PaginatedResponse,
+} from "../types.js";
+
+const BITBUCKET_API_BASE = "https://api.bitbucket.org/2.0";
+
+export interface BitbucketClientOptions {
+  username?: string;
+  appPassword?: string;
+  accessToken?: string;
+  baseUrl?: string;
+}
+
+export class BitbucketClient {
+  private baseUrl: string;
+  private authHeader: string;
+
+  constructor(options: BitbucketClientOptions) {
+    this.baseUrl = options.baseUrl || BITBUCKET_API_BASE;
+
+    if (options.accessToken) {
+      this.authHeader = `Bearer ${options.accessToken}`;
+    } else if (options.username && options.appPassword) {
+      const credentials = Buffer.from(
+        `${options.username}:${options.appPassword}`
+      ).toString("base64");
+      this.authHeader = `Basic ${credentials}`;
+    } else {
+      throw new Error(
+        "BitbucketClient requires either accessToken or username/appPassword"
+      );
+    }
+  }
+
+  private async request<T>(
+    endpoint: string,
+    options: RequestInit = {}
+  ): Promise<T> {
+    const url = endpoint.startsWith("http")
+      ? endpoint
+      : `${this.baseUrl}${endpoint}`;
+
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        Authorization: this.authHeader,
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new BitbucketApiError(
+        `Bitbucket API error: ${response.status} ${response.statusText}`,
+        response.status,
+        errorBody
+      );
+    }
+
+    if (response.status === 204) {
+      return {} as T;
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  private async paginatedRequest<T>(
+    endpoint: string,
+    maxPages = 10
+  ): Promise<T[]> {
+    const results: T[] = [];
+    let nextUrl: string | undefined = endpoint;
+    let pageCount = 0;
+
+    while (nextUrl && pageCount < maxPages) {
+      const page: PaginatedResponse<T> = await this.request<PaginatedResponse<T>>(nextUrl);
+      results.push(...page.values);
+      nextUrl = page.next;
+      pageCount++;
+    }
+
+    return results;
+  }
+
+  // Repository operations
+  async getRepository(
+    workspace: string,
+    repoSlug: string
+  ): Promise<BitbucketRepository> {
+    return this.request<BitbucketRepository>(
+      `/repositories/${workspace}/${repoSlug}`
+    );
+  }
+
+  // Pull Request operations
+  async getPullRequest(
+    workspace: string,
+    repoSlug: string,
+    prId: number
+  ): Promise<BitbucketPullRequest> {
+    return this.request<BitbucketPullRequest>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}`
+    );
+  }
+
+  async getPullRequestDiff(
+    workspace: string,
+    repoSlug: string,
+    prId: number
+  ): Promise<string> {
+    const url = `${this.baseUrl}/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/diff`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: this.authHeader,
+        Accept: "text/plain",
+      },
+    });
+
+    if (!response.ok) {
+      throw new BitbucketApiError(
+        `Failed to get PR diff: ${response.status}`,
+        response.status
+      );
+    }
+
+    return response.text();
+  }
+
+  async getPullRequestDiffStat(
+    workspace: string,
+    repoSlug: string,
+    prId: number
+  ): Promise<BitbucketDiffStat[]> {
+    return this.paginatedRequest<BitbucketDiffStat>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/diffstat`
+    );
+  }
+
+  async getPullRequestComments(
+    workspace: string,
+    repoSlug: string,
+    prId: number
+  ): Promise<BitbucketComment[]> {
+    return this.paginatedRequest<BitbucketComment>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`
+    );
+  }
+
+  async getPullRequestCommits(
+    workspace: string,
+    repoSlug: string,
+    prId: number
+  ): Promise<BitbucketCommit[]> {
+    return this.paginatedRequest<BitbucketCommit>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/commits`
+    );
+  }
+
+  async createPullRequestComment(
+    workspace: string,
+    repoSlug: string,
+    prId: number,
+    content: string,
+    inline?: { path: string; line: number }
+  ): Promise<BitbucketComment> {
+    const body: Record<string, unknown> = {
+      content: {
+        raw: content,
+      },
+    };
+
+    if (inline) {
+      body.inline = {
+        to: inline.line,
+        path: inline.path,
+      };
+    }
+
+    return this.request<BitbucketComment>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments`,
+      {
+        method: "POST",
+        body: JSON.stringify(body),
+      }
+    );
+  }
+
+  async updatePullRequestComment(
+    workspace: string,
+    repoSlug: string,
+    prId: number,
+    commentId: number,
+    content: string
+  ): Promise<BitbucketComment> {
+    return this.request<BitbucketComment>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`,
+      {
+        method: "PUT",
+        body: JSON.stringify({
+          content: {
+            raw: content,
+          },
+        }),
+      }
+    );
+  }
+
+  async deletePullRequestComment(
+    workspace: string,
+    repoSlug: string,
+    prId: number,
+    commentId: number
+  ): Promise<void> {
+    await this.request<void>(
+      `/repositories/${workspace}/${repoSlug}/pullrequests/${prId}/comments/${commentId}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  // Branch operations
+  async getBranch(
+    workspace: string,
+    repoSlug: string,
+    branchName: string
+  ): Promise<BitbucketBranch> {
+    return this.request<BitbucketBranch>(
+      `/repositories/${workspace}/${repoSlug}/refs/branches/${encodeURIComponent(branchName)}`
+    );
+  }
+
+  async createBranch(
+    workspace: string,
+    repoSlug: string,
+    branchName: string,
+    targetCommit: string
+  ): Promise<BitbucketBranch> {
+    return this.request<BitbucketBranch>(
+      `/repositories/${workspace}/${repoSlug}/refs/branches`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          name: branchName,
+          target: {
+            hash: targetCommit,
+          },
+        }),
+      }
+    );
+  }
+
+  async deleteBranch(
+    workspace: string,
+    repoSlug: string,
+    branchName: string
+  ): Promise<void> {
+    await this.request<void>(
+      `/repositories/${workspace}/${repoSlug}/refs/branches/${encodeURIComponent(branchName)}`,
+      {
+        method: "DELETE",
+      }
+    );
+  }
+
+  // Commit operations
+  async getCommit(
+    workspace: string,
+    repoSlug: string,
+    commitHash: string
+  ): Promise<BitbucketCommit> {
+    return this.request<BitbucketCommit>(
+      `/repositories/${workspace}/${repoSlug}/commit/${commitHash}`
+    );
+  }
+
+  async getFileContent(
+    workspace: string,
+    repoSlug: string,
+    commitHash: string,
+    filePath: string
+  ): Promise<string> {
+    const url = `${this.baseUrl}/repositories/${workspace}/${repoSlug}/src/${commitHash}/${encodeURIComponent(filePath)}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: this.authHeader,
+      },
+    });
+
+    if (!response.ok) {
+      throw new BitbucketApiError(
+        `Failed to get file content: ${response.status}`,
+        response.status
+      );
+    }
+
+    return response.text();
+  }
+
+  // Issue operations (if issue tracker is enabled)
+  async getIssue(
+    workspace: string,
+    repoSlug: string,
+    issueId: number
+  ): Promise<BitbucketIssue> {
+    return this.request<BitbucketIssue>(
+      `/repositories/${workspace}/${repoSlug}/issues/${issueId}`
+    );
+  }
+
+  async getIssueComments(
+    workspace: string,
+    repoSlug: string,
+    issueId: number
+  ): Promise<BitbucketComment[]> {
+    return this.paginatedRequest<BitbucketComment>(
+      `/repositories/${workspace}/${repoSlug}/issues/${issueId}/comments`
+    );
+  }
+
+  async createIssueComment(
+    workspace: string,
+    repoSlug: string,
+    issueId: number,
+    content: string
+  ): Promise<BitbucketComment> {
+    return this.request<BitbucketComment>(
+      `/repositories/${workspace}/${repoSlug}/issues/${issueId}/comments`,
+      {
+        method: "POST",
+        body: JSON.stringify({
+          content: {
+            raw: content,
+          },
+        }),
+      }
+    );
+  }
+
+  // User operations
+  async getCurrentUser(): Promise<{
+    uuid: string;
+    display_name: string;
+    account_id: string;
+  }> {
+    return this.request("/user");
+  }
+
+  async checkUserPermissions(
+    workspace: string,
+    repoSlug: string,
+    userId: string
+  ): Promise<{ permission: "read" | "write" | "admin" }> {
+    const response = await this.request<{
+      values: Array<{ permission: "read" | "write" | "admin" }>;
+    }>(
+      `/repositories/${workspace}/${repoSlug}/permissions-config/users/${userId}`
+    );
+
+    return { permission: response.values[0]?.permission || "read" };
+  }
+}
+
+export class BitbucketApiError extends Error {
+  constructor(
+    message: string,
+    public statusCode: number,
+    public responseBody?: string
+  ) {
+    super(message);
+    this.name = "BitbucketApiError";
+  }
+}
+
+// Factory function for creating client from environment variables
+export function createBitbucketClientFromEnv(): BitbucketClient {
+  const accessToken = process.env.BITBUCKET_ACCESS_TOKEN;
+  const username = process.env.BITBUCKET_USERNAME;
+  const appPassword = process.env.BITBUCKET_APP_PASSWORD;
+
+  if (accessToken) {
+    return new BitbucketClient({ accessToken });
+  }
+
+  if (username && appPassword) {
+    return new BitbucketClient({ username, appPassword });
+  }
+
+  throw new Error(
+    "Missing Bitbucket credentials. Set BITBUCKET_ACCESS_TOKEN or BITBUCKET_USERNAME and BITBUCKET_APP_PASSWORD"
+  );
+}