bitbucket-gemini-action 1.0.0

package/src/bitbucket/context.ts

@@ -0,0 +1,196 @@
+/**
+ * Bitbucket Pipeline Context Parser
+ * Parses Bitbucket Pipeline environment variables and webhook payloads
+ */
+
+import type {
+  ParsedBitbucketContext,
+  BitbucketEventType,
+  BitbucketWebhookPayload,
+  BitbucketUser,
+} from "./types.js";
+
+// Bitbucket Pipeline environment variables
+interface PipelineEnvVars {
+  BITBUCKET_WORKSPACE: string;
+  BITBUCKET_REPO_SLUG: string;
+  BITBUCKET_REPO_FULL_NAME: string;
+  BITBUCKET_COMMIT: string;
+  BITBUCKET_BRANCH?: string;
+  BITBUCKET_TAG?: string;
+  BITBUCKET_PR_ID?: string;
+  BITBUCKET_PR_DESTINATION_BRANCH?: string;
+  BITBUCKET_BUILD_NUMBER: string;
+  BITBUCKET_PIPELINE_UUID: string;
+  BITBUCKET_STEP_UUID: string;
+  BITBUCKET_CLONE_DIR: string;
+
+  // Custom variables set by trigger
+  TRIGGER_EVENT?: string;
+  TRIGGER_COMMENT_ID?: string;
+  TRIGGER_ACTOR?: string;
+  TRIGGER_TIMESTAMP?: string;
+  WEBHOOK_PAYLOAD?: string;
+}
+
+export function parseBitbucketContext(): ParsedBitbucketContext {
+  const env = process.env as unknown as PipelineEnvVars;
+
+  // Validate required environment variables
+  if (!env.BITBUCKET_WORKSPACE) {
+    throw new Error("BITBUCKET_WORKSPACE environment variable is required");
+  }
+  if (!env.BITBUCKET_REPO_SLUG) {
+    throw new Error("BITBUCKET_REPO_SLUG environment variable is required");
+  }
+
+  const workspace = env.BITBUCKET_WORKSPACE;
+  const repoSlug = env.BITBUCKET_REPO_SLUG;
+  const fullName =
+    env.BITBUCKET_REPO_FULL_NAME || `${workspace}/${repoSlug}`;
+
+  // Parse webhook payload if available
+  let webhookPayload: BitbucketWebhookPayload | undefined;
+  if (env.WEBHOOK_PAYLOAD) {
+    try {
+      webhookPayload = JSON.parse(env.WEBHOOK_PAYLOAD);
+    } catch {
+      console.warn("Failed to parse WEBHOOK_PAYLOAD");
+    }
+  }
+
+  // Determine event type
+  const eventType = determineEventType(env, webhookPayload);
+
+  // Determine if this is a PR context
+  const isPR = !!env.BITBUCKET_PR_ID || eventType.startsWith("pullrequest:");
+  const entityNumber = env.BITBUCKET_PR_ID
+    ? parseInt(env.BITBUCKET_PR_ID, 10)
+    : undefined;
+
+  // Get actor information
+  const actor = getActor(env, webhookPayload);
+
+  return {
+    eventType,
+    workspace,
+    repoSlug,
+    repository: {
+      workspace,
+      slug: repoSlug,
+      fullName,
+    },
+    actor,
+    pullRequest: webhookPayload?.pullrequest,
+    comment: webhookPayload?.comment,
+    issue: webhookPayload?.issue,
+    isPR,
+    entityNumber,
+    triggerTimestamp: env.TRIGGER_TIMESTAMP || new Date().toISOString(),
+  };
+}
+
+function determineEventType(
+  env: PipelineEnvVars,
+  payload?: BitbucketWebhookPayload
+): BitbucketEventType {
+  // Check explicit trigger event
+  if (env.TRIGGER_EVENT) {
+    return env.TRIGGER_EVENT as BitbucketEventType;
+  }
+
+  // Infer from pipeline context
+  if (env.BITBUCKET_PR_ID) {
+    if (payload?.comment) {
+      return "pullrequest:comment_created";
+    }
+    return "pullrequest:updated";
+  }
+
+  if (env.BITBUCKET_BRANCH) {
+    return "repo:push";
+  }
+
+  return "manual";
+}
+
+function getActor(
+  env: PipelineEnvVars,
+  payload?: BitbucketWebhookPayload
+): BitbucketUser {
+  // Use webhook payload actor if available
+  if (payload?.actor) {
+    return payload.actor;
+  }
+
+  // Try to parse from TRIGGER_ACTOR
+  if (env.TRIGGER_ACTOR) {
+    try {
+      return JSON.parse(env.TRIGGER_ACTOR);
+    } catch {
+      // Fall through to default
+    }
+  }
+
+  // Default actor (pipeline bot)
+  return {
+    uuid: "{pipeline-bot}",
+    account_id: "pipeline-bot",
+    display_name: "Pipeline Bot",
+    nickname: "pipeline-bot",
+    type: "user",
+    links: {
+      self: { href: "" },
+      html: { href: "" },
+      avatar: { href: "" },
+    },
+  };
+}
+
+/**
+ * Check if the context is from a PR-related event
+ */
+export function isPullRequestContext(
+  context: ParsedBitbucketContext
+): boolean {
+  return context.isPR && context.entityNumber !== undefined;
+}
+
+/**
+ * Check if the context is from a comment event
+ */
+export function isCommentContext(context: ParsedBitbucketContext): boolean {
+  return (
+    context.eventType === "pullrequest:comment_created" ||
+    context.eventType === "pullrequest:comment_updated" ||
+    context.eventType === "issue:comment_created"
+  );
+}
+
+/**
+ * Check if the context is from a manual or scheduled trigger
+ */
+export function isAutomationContext(context: ParsedBitbucketContext): boolean {
+  return context.eventType === "manual" || context.eventType === "schedule";
+}
+
+/**
+ * Get the default branch for the repository
+ */
+export function getDefaultBranch(): string {
+  return process.env.BITBUCKET_PR_DESTINATION_BRANCH || "main";
+}
+
+/**
+ * Get the current commit hash
+ */
+export function getCurrentCommit(): string {
+  return process.env.BITBUCKET_COMMIT || "";
+}
+
+/**
+ * Get the current branch name
+ */
+export function getCurrentBranch(): string | undefined {
+  return process.env.BITBUCKET_BRANCH;
+}

package/src/bitbucket/data/fetcher.ts

@@ -0,0 +1,195 @@
+/**
+ * Bitbucket Data Fetcher
+ * Fetches PR/issue data from Bitbucket API
+ */
+
+import type { BitbucketClient } from "../api/client.js";
+import type {
+  BitbucketPullRequest,
+  BitbucketComment,
+  BitbucketDiffStat,
+  BitbucketCommit,
+  ParsedBitbucketContext,
+} from "../types.js";
+
+export interface FetchedPRData {
+  pullRequest: BitbucketPullRequest;
+  comments: BitbucketComment[];
+  diffStats: BitbucketDiffStat[];
+  commits: BitbucketCommit[];
+  diff: string;
+}
+
+export interface FetchOptions {
+  includeComments?: boolean;
+  includeDiff?: boolean;
+  includeCommits?: boolean;
+  filterCommentsAfter?: string; // ISO timestamp
+}
+
+const DEFAULT_FETCH_OPTIONS: FetchOptions = {
+  includeComments: true,
+  includeDiff: true,
+  includeCommits: true,
+};
+
+/**
+ * Fetch all PR data needed for code review
+ */
+export async function fetchPRData(
+  client: BitbucketClient,
+  context: ParsedBitbucketContext,
+  options: FetchOptions = DEFAULT_FETCH_OPTIONS
+): Promise<FetchedPRData> {
+  const { workspace, repoSlug, entityNumber } = context;
+
+  if (!entityNumber) {
+    throw new Error("PR ID is required to fetch PR data");
+  }
+
+  // Fetch PR details first
+  const pullRequest = await client.getPullRequest(
+    workspace,
+    repoSlug,
+    entityNumber
+  );
+
+  // Fetch additional data in parallel
+  const [comments, diffStats, commits, diff] = await Promise.all([
+    options.includeComments
+      ? fetchFilteredComments(
+          client,
+          workspace,
+          repoSlug,
+          entityNumber,
+          options.filterCommentsAfter
+        )
+      : Promise.resolve([]),
+    client.getPullRequestDiffStat(workspace, repoSlug, entityNumber),
+    options.includeCommits
+      ? client.getPullRequestCommits(workspace, repoSlug, entityNumber)
+      : Promise.resolve([]),
+    options.includeDiff
+      ? client.getPullRequestDiff(workspace, repoSlug, entityNumber)
+      : Promise.resolve(""),
+  ]);
+
+  return {
+    pullRequest,
+    comments,
+    diffStats,
+    commits,
+    diff,
+  };
+}
+
+/**
+ * Fetch comments with optional timestamp filtering
+ * Filters out comments created or updated after the trigger time to prevent
+ * processing comments that were added during the review
+ */
+async function fetchFilteredComments(
+  client: BitbucketClient,
+  workspace: string,
+  repoSlug: string,
+  prId: number,
+  filterAfter?: string
+): Promise<BitbucketComment[]> {
+  const comments = await client.getPullRequestComments(
+    workspace,
+    repoSlug,
+    prId
+  );
+
+  if (!filterAfter) {
+    return comments;
+  }
+
+  const filterTimestamp = new Date(filterAfter).getTime();
+
+  return comments.filter((comment) => {
+    // Filter out comments updated after the trigger time
+    const updatedAt = new Date(comment.updated_on).getTime();
+    return updatedAt <= filterTimestamp;
+  });
+}
+
+/**
+ * Check if a comment body is safe to process
+ * Ensures the comment hasn't been modified since the trigger
+ */
+export function isCommentSafeToProcess(
+  comment: BitbucketComment,
+  triggerTimestamp: string
+): boolean {
+  const triggerTime = new Date(triggerTimestamp).getTime();
+  const updatedTime = new Date(comment.updated_on).getTime();
+
+  // Comment is safe if it wasn't updated after the trigger
+  return updatedTime <= triggerTime;
+}
+
+/**
+ * Get file content from a specific commit
+ */
+export async function getFileContent(
+  client: BitbucketClient,
+  workspace: string,
+  repoSlug: string,
+  commitHash: string,
+  filePath: string
+): Promise<string | null> {
+  try {
+    return await client.getFileContent(
+      workspace,
+      repoSlug,
+      commitHash,
+      filePath
+    );
+  } catch (error) {
+    // File might not exist at this commit
+    console.warn(`Failed to get file content for ${filePath}: ${error}`);
+    return null;
+  }
+}
+
+/**
+ * Get the files changed in a PR
+ */
+export function getChangedFiles(
+  diffStats: BitbucketDiffStat[]
+): Array<{
+  path: string;
+  status: string;
+  additions: number;
+  deletions: number;
+}> {
+  return diffStats.map((stat) => ({
+    path: stat.new?.path || stat.old?.path || "",
+    status: stat.status,
+    additions: stat.lines_added,
+    deletions: stat.lines_removed,
+  }));
+}
+
+/**
+ * Extract trigger comment from comments list
+ */
+export function findTriggerComment(
+  comments: BitbucketComment[],
+  triggerPhrase: string,
+  triggerTimestamp: string
+): BitbucketComment | undefined {
+  const triggerTime = new Date(triggerTimestamp).getTime();
+
+  return comments.find((comment) => {
+    const createdTime = new Date(comment.created_on).getTime();
+    const containsTrigger = comment.content.raw
+      .toLowerCase()
+      .includes(triggerPhrase.toLowerCase());
+
+    // Match if contains trigger and was created around the trigger time
+    // (within 1 minute to account for timing differences)
+    return containsTrigger && Math.abs(createdTime - triggerTime) < 60000;
+  });
+}

package/src/bitbucket/data/formatter.ts

@@ -0,0 +1,221 @@
+/**
+ * Bitbucket Data Formatter
+ * Formats PR data for Gemini prompts
+ */
+
+import type {
+  BitbucketPullRequest,
+  BitbucketComment,
+  BitbucketDiffStat,
+  BitbucketCommit,
+} from "../types.js";
+import type { FetchedPRData } from "./fetcher.js";
+import type { PRContext } from "../../gemini/prompts.js";
+
+/**
+ * Convert fetched PR data to PRContext for prompt generation
+ */
+export function formatPRContext(data: FetchedPRData): PRContext {
+  return {
+    title: data.pullRequest.title,
+    description: data.pullRequest.description || "",
+    author: data.pullRequest.author.display_name,
+    sourceBranch: data.pullRequest.source.branch.name,
+    targetBranch: data.pullRequest.destination.branch.name,
+    files: formatChangedFiles(data.diffStats),
+    diff: data.diff,
+    comments: formatComments(data.comments),
+  };
+}
+
+/**
+ * Format changed files for display
+ */
+export function formatChangedFiles(
+  diffStats: BitbucketDiffStat[]
+): PRContext["files"] {
+  return diffStats.map((stat) => ({
+    path: stat.new?.path || stat.old?.path || "unknown",
+    status: stat.status,
+    additions: stat.lines_added,
+    deletions: stat.lines_removed,
+  }));
+}
+
+/**
+ * Format comments for inclusion in prompt
+ */
+export function formatComments(
+  comments: BitbucketComment[]
+): PRContext["comments"] {
+  return comments
+    .filter((c) => !c.deleted)
+    .map((comment) => ({
+      author: comment.user.display_name,
+      content: sanitizeContent(comment.content.raw),
+      path: comment.inline?.path,
+      line: comment.inline?.to || undefined,
+      createdAt: formatTimestamp(comment.created_on),
+    }));
+}
+
+/**
+ * Format commits for display
+ */
+export function formatCommits(
+  commits: BitbucketCommit[]
+): Array<{
+  hash: string;
+  message: string;
+  author: string;
+  date: string;
+}> {
+  return commits.map((commit) => ({
+    hash: commit.hash.substring(0, 7),
+    message: commit.message.split("\n")[0], // First line only
+    author: commit.author.user?.display_name || commit.author.raw,
+    date: formatTimestamp(commit.date),
+  }));
+}
+
+/**
+ * Format PR details as markdown
+ */
+export function formatPRAsMarkdown(pr: BitbucketPullRequest): string {
+  const reviewers = pr.reviewers
+    .map((r) => r.display_name)
+    .join(", ");
+  const participants = pr.participants
+    .filter((p) => p.approved)
+    .map((p) => `✓ ${p.user.display_name}`)
+    .join(", ");
+
+  return `## Pull Request #${pr.id}
+
+**Title**: ${pr.title}
+**Author**: ${pr.author.display_name}
+**State**: ${pr.state}
+**Branch**: \`${pr.source.branch.name}\` → \`${pr.destination.branch.name}\`
+
+### Description
+${pr.description || "_No description provided_"}
+
+${reviewers ? `**Reviewers**: ${reviewers}` : ""}
+${participants ? `**Approvals**: ${participants}` : ""}
+
+**Created**: ${formatTimestamp(pr.created_on)}
+**Updated**: ${formatTimestamp(pr.updated_on)}
+`;
+}
+
+/**
+ * Format diff stats as summary
+ */
+export function formatDiffStatsSummary(diffStats: BitbucketDiffStat[]): string {
+  const totalFiles = diffStats.length;
+  const totalAdditions = diffStats.reduce((sum, s) => sum + s.lines_added, 0);
+  const totalDeletions = diffStats.reduce((sum, s) => sum + s.lines_removed, 0);
+
+  const added = diffStats.filter((s) => s.status === "added").length;
+  const modified = diffStats.filter((s) => s.status === "modified").length;
+  const removed = diffStats.filter((s) => s.status === "removed").length;
+  const renamed = diffStats.filter((s) => s.status === "renamed").length;
+
+  return `**Files Changed**: ${totalFiles} (${added} added, ${modified} modified, ${removed} removed${renamed ? `, ${renamed} renamed` : ""})
+**Lines**: +${totalAdditions} / -${totalDeletions}`;
+}
+
+/**
+ * Format a single file diff for focused review
+ */
+export function formatFileDiff(
+  filePath: string,
+  fullDiff: string
+): string | null {
+  const lines = fullDiff.split("\n");
+  const fileLines: string[] = [];
+  let inFile = false;
+  let foundFile = false;
+
+  for (const line of lines) {
+    if (line.startsWith("diff --git")) {
+      if (inFile) break; // End of current file
+      inFile = line.includes(filePath);
+      if (inFile) foundFile = true;
+    }
+    if (inFile) {
+      fileLines.push(line);
+    }
+  }
+
+  return foundFile ? fileLines.join("\n") : null;
+}
+
+/**
+ * Sanitize content to prevent prompt injection
+ */
+export function sanitizeContent(content: string): string {
+  // Remove potential prompt injection attempts
+  return content
+    .replace(/```system/gi, "```text") // Prevent system prompt injection
+    .replace(/\[INST\]/gi, "[inst]") // Llama-style
+    .replace(/<\|im_start\|>/gi, "") // ChatML style
+    .replace(/<\|im_end\|>/gi, "")
+    .trim();
+}
+
+/**
+ * Format ISO timestamp to readable format
+ */
+export function formatTimestamp(isoTimestamp: string): string {
+  const date = new Date(isoTimestamp);
+  return date.toISOString().replace("T", " ").substring(0, 19) + " UTC";
+}
+
+/**
+ * Truncate diff if too long
+ */
+export function truncateDiff(diff: string, maxLength: number = 50000): string {
+  if (diff.length <= maxLength) {
+    return diff;
+  }
+
+  const truncated = diff.substring(0, maxLength);
+  const lastNewline = truncated.lastIndexOf("\n");
+
+  return (
+    truncated.substring(0, lastNewline) +
+    "\n\n... (diff truncated due to length)"
+  );
+}
+
+/**
+ * Group inline comments by file
+ */
+export function groupCommentsByFile(
+  comments: BitbucketComment[]
+): Map<string, BitbucketComment[]> {
+  const grouped = new Map<string, BitbucketComment[]>();
+
+  for (const comment of comments) {
+    if (comment.inline?.path) {
+      const existing = grouped.get(comment.inline.path) || [];
+      existing.push(comment);
+      grouped.set(comment.inline.path, existing);
+    }
+  }
+
+  // Sort comments within each file by line number
+  for (const [path, fileComments] of grouped) {
+    grouped.set(
+      path,
+      fileComments.sort((a, b) => {
+        const lineA = a.inline?.to || 0;
+        const lineB = b.inline?.to || 0;
+        return lineA - lineB;
+      })
+    );
+  }
+
+  return grouped;
+}