bitbucket-gemini-action 1.0.0

package/src/bitbucket/validation/trigger.ts

@@ -0,0 +1,175 @@
+/**
+ * Trigger Validation
+ * Validates if a trigger should activate the action
+ */
+
+import type { ParsedBitbucketContext, BitbucketComment } from "../types.js";
+
+export interface TriggerValidationResult {
+  shouldTrigger: boolean;
+  reason: string;
+  triggerType?: "mention" | "label" | "assignee" | "automation" | "manual";
+  userMessage?: string;
+}
+
+export interface TriggerOptions {
+  triggerPhrase: string;
+  labelTrigger?: string;
+  assigneeTrigger?: string;
+  prompt?: string;
+  botAccountId?: string;
+}
+
+/**
+ * Validate if the context should trigger the action
+ */
+export function validateTrigger(
+  context: ParsedBitbucketContext,
+  options: TriggerOptions
+): TriggerValidationResult {
+  // Explicit prompt always triggers (agent mode)
+  if (options.prompt) {
+    return {
+      shouldTrigger: true,
+      reason: "Explicit prompt provided",
+      triggerType: "automation",
+      userMessage: options.prompt,
+    };
+  }
+
+  // Check for manual/schedule triggers
+  if (
+    context.eventType === "manual" ||
+    context.eventType === "schedule"
+  ) {
+    return {
+      shouldTrigger: true,
+      reason: `Triggered by ${context.eventType} event`,
+      triggerType: "manual",
+    };
+  }
+
+  // Check comment-based triggers
+  if (
+    context.eventType === "pullrequest:comment_created" ||
+    context.eventType === "pullrequest:comment_updated"
+  ) {
+    return validateCommentTrigger(context.comment, options);
+  }
+
+  // No trigger matched
+  return {
+    shouldTrigger: false,
+    reason: `Event type ${context.eventType} does not match any trigger`,
+  };
+}
+
+/**
+ * Validate comment-based trigger
+ */
+function validateCommentTrigger(
+  comment: BitbucketComment | undefined,
+  options: TriggerOptions
+): TriggerValidationResult {
+  if (!comment) {
+    return {
+      shouldTrigger: false,
+      reason: "No comment in context",
+    };
+  }
+
+  // Don't respond to own comments (prevent infinite loops)
+  if (options.botAccountId && comment.user.account_id === options.botAccountId) {
+    return {
+      shouldTrigger: false,
+      reason: "Comment is from the bot itself",
+    };
+  }
+
+  // Check for trigger phrase
+  const content = comment.content.raw;
+  const triggerPhrase = options.triggerPhrase.toLowerCase();
+
+  if (!content.toLowerCase().includes(triggerPhrase)) {
+    return {
+      shouldTrigger: false,
+      reason: `Comment does not contain trigger phrase: ${options.triggerPhrase}`,
+    };
+  }
+
+  // Extract user message (remove trigger phrase)
+  const userMessage = extractUserMessage(content, options.triggerPhrase);
+
+  return {
+    shouldTrigger: true,
+    reason: "Trigger phrase found in comment",
+    triggerType: "mention",
+    userMessage,
+  };
+}
+
+/**
+ * Extract user message from comment content
+ */
+function extractUserMessage(content: string, triggerPhrase: string): string {
+  // Remove trigger phrase (case insensitive)
+  const regex = new RegExp(escapeRegex(triggerPhrase), "gi");
+  const cleaned = content.replace(regex, "").trim();
+
+  // Remove leading/trailing whitespace and newlines
+  return cleaned.replace(/^\s+|\s+$/g, "");
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Check if comment was modified after trigger time
+ */
+export function isCommentModifiedAfterTrigger(
+  comment: BitbucketComment,
+  triggerTimestamp: string
+): boolean {
+  const triggerTime = new Date(triggerTimestamp).getTime();
+  const updatedTime = new Date(comment.updated_on).getTime();
+  const createdTime = new Date(comment.created_on).getTime();
+
+  // If updated after created and after trigger, it was modified
+  return updatedTime > createdTime && updatedTime > triggerTime;
+}
+
+/**
+ * Validate comment content for safety
+ */
+export function validateCommentContent(content: string): {
+  safe: boolean;
+  warnings: string[];
+} {
+  const warnings: string[] = [];
+
+  // Check for potential injection attempts
+  const suspiciousPatterns = [
+    /```system/i,
+    /\[INST\]/i,
+    /<\|im_start\|>/i,
+    /<\|im_end\|>/i,
+    /You are now/i,
+    /Ignore previous/i,
+    /Forget all/i,
+  ];
+
+  for (const pattern of suspiciousPatterns) {
+    if (pattern.test(content)) {
+      warnings.push(`Suspicious pattern detected: ${pattern.toString()}`);
+    }
+  }
+
+  return {
+    safe: warnings.length === 0,
+    warnings,
+  };
+}

package/src/entrypoints/execute.ts

@@ -0,0 +1,349 @@
+/**
+ * Execute Entrypoint
+ * Phase 2: Run Gemini and process results
+ */
+
+import { createGeminiClientFromEnv } from "../gemini/client.js";
+import { createBitbucketClientFromEnv } from "../bitbucket/api/client.js";
+import { parseBitbucketContext } from "../bitbucket/context.js";
+import { fetchPRData } from "../bitbucket/data/fetcher.js";
+import { formatPRContext } from "../bitbucket/data/formatter.js";
+import {
+  buildPRReviewPrompt,
+  buildTagModePrompt,
+  buildAgentModePrompt,
+  buildPRReviewPromptWithPresets,
+  buildTagModePromptWithPresets,
+  buildAgentModePromptWithPresets,
+  buildSystemPromptWithPresets,
+} from "../gemini/prompts.js";
+import { getToolsForMode } from "../gemini/tools.js";
+import {
+  updateTrackingComment,
+  createInlineComment,
+  createPRComment,
+} from "../bitbucket/operations/comments.js";
+import { getReviewPresets, getCustomPrompt } from "../utils/env.js";
+import { withRetry, GEMINI_RETRY_OPTIONS } from "../utils/retry.js";
+import type { GeminiToolCall } from "../gemini/client.js";
+
+interface ExecuteOptions {
+  mode: "tag" | "agent";
+  prompt: string;
+  systemPrompt: string;
+  trackingCommentId?: number;
+  userMessage?: string;
+  mentionAuthor?: string;
+}
+
+interface ExecuteResult {
+  success: boolean;
+  response?: string;
+  toolCalls?: GeminiToolCall[];
+  inlineCommentsCreated: number;
+  error?: string;
+}
+
+/**
+ * Main execute function
+ */
+export async function execute(options?: ExecuteOptions): Promise<ExecuteResult> {
+  console.log("🚀 Starting Bitbucket Gemini Action - Execute Phase");
+
+  try {
+    // Load options from prepare phase if not provided
+    const opts = options || loadPrepareOutput();
+    console.log(`📋 Mode: ${opts.mode}`);
+
+    // Create clients
+    const geminiClient = createGeminiClientFromEnv();
+    const bitbucketClient = createBitbucketClientFromEnv();
+
+    // Parse context
+    const context = parseBitbucketContext();
+
+    // Update tracking comment to show progress
+    if (opts.trackingCommentId && context.entityNumber) {
+      await updateTrackingComment(
+        bitbucketClient,
+        context.workspace,
+        context.repoSlug,
+        context.entityNumber,
+        opts.trackingCommentId,
+        {
+          status: "in_progress",
+          message: "Analyzing code changes...",
+        }
+      );
+    }
+
+    // Fetch PR data
+    let prContext;
+    if (context.isPR && context.entityNumber) {
+      console.log("📥 Fetching PR data...");
+      const prData = await fetchPRData(bitbucketClient, context);
+      prContext = formatPRContext(prData);
+    }
+
+    // Get review presets and custom prompt
+    const presetKeys = getReviewPresets();
+    const customPrompt = getCustomPrompt();
+
+    if (presetKeys.length > 0) {
+      console.log(`📋 Review Presets: ${presetKeys.join(", ")}`);
+    }
+    if (customPrompt) {
+      console.log(`📋 Custom Prompt: ${customPrompt.substring(0, 50)}...`);
+    }
+
+    // Build prompt based on mode (with presets if configured)
+    let fullPrompt: string;
+    if (opts.mode === "tag" && prContext) {
+      fullPrompt = presetKeys.length > 0 || customPrompt
+        ? buildTagModePromptWithPresets(
+            prContext,
+            opts.userMessage || opts.prompt,
+            opts.mentionAuthor || "user",
+            presetKeys,
+            customPrompt
+          )
+        : buildTagModePrompt(
+            prContext,
+            opts.userMessage || opts.prompt,
+            opts.mentionAuthor || "user"
+          );
+    } else if (opts.mode === "agent" && prContext) {
+      fullPrompt = presetKeys.length > 0 || customPrompt
+        ? buildAgentModePromptWithPresets(prContext, opts.prompt, presetKeys, customPrompt)
+        : buildAgentModePrompt(prContext, opts.prompt);
+    } else if (prContext) {
+      fullPrompt = presetKeys.length > 0 || customPrompt
+        ? buildPRReviewPromptWithPresets(prContext, presetKeys, customPrompt)
+        : buildPRReviewPrompt(prContext);
+    } else {
+      fullPrompt = opts.prompt;
+    }
+
+    // Apply presets to system prompt if configured
+    const systemPrompt = presetKeys.length > 0 || customPrompt
+      ? buildSystemPromptWithPresets(opts.systemPrompt, presetKeys, customPrompt)
+      : opts.systemPrompt;
+
+    // Get tools for mode
+    const tools = getToolsForMode(opts.mode === "agent" ? "full" : "lightweight");
+
+    console.log("🤖 Calling Gemini API...");
+
+    // Call Gemini with retry
+    const response = await withRetry(
+      () =>
+        geminiClient.generateWithTools(fullPrompt, tools, systemPrompt),
+      GEMINI_RETRY_OPTIONS
+    );
+
+    console.log(`✅ Gemini response received (${response.finishReason})`);
+
+    // Process tool calls
+    let inlineCommentsCreated = 0;
+    if (response.toolCalls && context.entityNumber) {
+      inlineCommentsCreated = await processToolCalls(
+        bitbucketClient,
+        context.workspace,
+        context.repoSlug,
+        context.entityNumber,
+        response.toolCalls,
+        opts.trackingCommentId
+      );
+    }
+
+    // If no tool calls but we have a text response, post it as a comment
+    if (
+      !response.toolCalls?.length &&
+      response.text &&
+      context.entityNumber
+    ) {
+      await createPRComment(
+        bitbucketClient,
+        context.workspace,
+        context.repoSlug,
+        context.entityNumber,
+        response.text
+      );
+    }
+
+    // Update tracking comment with final status
+    if (opts.trackingCommentId && context.entityNumber) {
+      await updateTrackingComment(
+        bitbucketClient,
+        context.workspace,
+        context.repoSlug,
+        context.entityNumber,
+        opts.trackingCommentId,
+        {
+          status: "completed",
+          message: "Review completed successfully.",
+          summary: response.text.substring(0, 500),
+          inlineCommentsCount: inlineCommentsCreated,
+        }
+      );
+    }
+
+    console.log("✅ Execute phase completed successfully");
+
+    return {
+      success: true,
+      response: response.text,
+      toolCalls: response.toolCalls,
+      inlineCommentsCreated,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`❌ Execute phase failed: ${message}`);
+
+    // Try to update tracking comment with error
+    try {
+      const context = parseBitbucketContext();
+      const bitbucketClient = createBitbucketClientFromEnv();
+      const opts = options || loadPrepareOutput();
+
+      if (opts.trackingCommentId && context.entityNumber) {
+        await updateTrackingComment(
+          bitbucketClient,
+          context.workspace,
+          context.repoSlug,
+          context.entityNumber,
+          opts.trackingCommentId,
+          {
+            status: "failed",
+            error: message,
+          }
+        );
+      }
+    } catch {
+      // Ignore errors updating tracking comment
+    }
+
+    return {
+      success: false,
+      inlineCommentsCreated: 0,
+      error: message,
+    };
+  }
+}
+
+/**
+ * Process Gemini tool calls
+ */
+async function processToolCalls(
+  client: ReturnType<typeof createBitbucketClientFromEnv>,
+  workspace: string,
+  repoSlug: string,
+  prId: number,
+  toolCalls: GeminiToolCall[],
+  trackingCommentId?: number
+): Promise<number> {
+  let inlineCommentsCreated = 0;
+
+  for (const toolCall of toolCalls) {
+    console.log(`🔧 Processing tool call: ${toolCall.name}`);
+
+    try {
+      switch (toolCall.name) {
+        case "create_inline_comment": {
+          const args = toolCall.args as {
+            path: string;
+            line: number;
+            content: string;
+          };
+          await createInlineComment(
+            client,
+            workspace,
+            repoSlug,
+            prId,
+            args.path,
+            args.line,
+            args.content
+          );
+          inlineCommentsCreated++;
+          break;
+        }
+
+        case "create_pr_comment": {
+          const args = toolCall.args as { content: string };
+          await createPRComment(client, workspace, repoSlug, prId, args.content);
+          break;
+        }
+
+        case "update_tracking_comment": {
+          if (trackingCommentId) {
+            const args = toolCall.args as {
+              content: string;
+              status: "in_progress" | "completed" | "failed";
+            };
+            await updateTrackingComment(
+              client,
+              workspace,
+              repoSlug,
+              prId,
+              trackingCommentId,
+              {
+                status: args.status,
+                message: args.content,
+              }
+            );
+          }
+          break;
+        }
+
+        default:
+          console.warn(`Unknown tool call: ${toolCall.name}`);
+      }
+    } catch (error) {
+      console.error(
+        `Error processing tool call ${toolCall.name}:`,
+        error instanceof Error ? error.message : error
+      );
+    }
+  }
+
+  return inlineCommentsCreated;
+}
+
+/**
+ * Load output from prepare phase
+ */
+function loadPrepareOutput(): ExecuteOptions {
+  const fs = require("fs");
+  const outputDir = process.env.BITBUCKET_CLONE_DIR || ".";
+  const outputPath = `${outputDir}/.gemini-action-output.json`;
+
+  if (!fs.existsSync(outputPath)) {
+    throw new Error(
+      "Prepare phase output not found. Run prepare phase first."
+    );
+  }
+
+  const data = JSON.parse(fs.readFileSync(outputPath, "utf-8"));
+
+  return {
+    mode: data.mode || "tag",
+    prompt: data.prompt || "",
+    systemPrompt: data.systemPrompt || "",
+    trackingCommentId: data.trackingCommentId,
+  };
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  execute()
+    .then((result) => {
+      if (!result.success) {
+        process.exit(1);
+      }
+      console.log(`📊 Inline comments created: ${result.inlineCommentsCreated}`);
+    })
+    .catch((error) => {
+      console.error("Fatal error:", error);
+      process.exit(1);
+    });
+}