bitbucket-gemini-action 1.0.0

package/src/entrypoints/prepare.ts

@@ -0,0 +1,216 @@
+/**
+ * Prepare Entrypoint
+ * Phase 1: Initialize context, validate triggers, prepare for execution
+ */
+
+import { parseBitbucketContext } from "../bitbucket/context.js";
+import { createBitbucketClientFromEnv } from "../bitbucket/api/client.js";
+import { detectMode } from "../modes/registry.js";
+import { validateTrigger } from "../bitbucket/validation/trigger.js";
+import { validateActor } from "../bitbucket/validation/permissions.js";
+import { fetchPRData } from "../bitbucket/data/fetcher.js";
+import { formatPRContext } from "../bitbucket/data/formatter.js";
+import { getEnvConfig, getPipelineUrl, getEnvBool } from "../utils/env.js";
+import type { ParsedBitbucketContext } from "../bitbucket/types.js";
+import type { ModeName } from "../modes/types.js";
+
+export interface PrepareResult {
+  success: boolean;
+  shouldContinue: boolean;
+  context?: ParsedBitbucketContext;
+  prompt?: string;
+  systemPrompt?: string;
+  trackingCommentId?: number;
+  prContext?: ReturnType<typeof formatPRContext>;
+  error?: string;
+}
+
+/**
+ * Main prepare function
+ */
+export async function prepare(): Promise<PrepareResult> {
+  console.log("🚀 Starting Bitbucket Gemini Action - Prepare Phase");
+
+  try {
+    // Load configuration
+    const config = getEnvConfig();
+    console.log(`📋 Workspace: ${config.BITBUCKET_WORKSPACE}`);
+    console.log(`📋 Repository: ${config.BITBUCKET_REPO_SLUG}`);
+    console.log(`📋 Trigger Phrase: ${config.TRIGGER_PHRASE}`);
+
+    // Parse Bitbucket context
+    const context = parseBitbucketContext();
+    console.log(`📋 Event Type: ${context.eventType}`);
+    console.log(`📋 Actor: ${context.actor.display_name}`);
+
+    if (context.entityNumber) {
+      console.log(`📋 PR Number: ${context.entityNumber}`);
+    }
+
+    // Create Bitbucket client
+    const client = createBitbucketClientFromEnv();
+
+    // Validate trigger
+    const triggerResult = validateTrigger(context, {
+      triggerPhrase: config.TRIGGER_PHRASE,
+      prompt: config.PROMPT,
+      botAccountId: config.BOT_ACCOUNT_ID,
+    });
+
+    if (!triggerResult.shouldTrigger) {
+      console.log(`⏭️ Skipping: ${triggerResult.reason}`);
+      return {
+        success: true,
+        shouldContinue: false,
+        error: triggerResult.reason,
+      };
+    }
+
+    console.log(`✅ Trigger validated: ${triggerResult.reason}`);
+
+    // Validate actor permissions
+    const actorResult = await validateActor(
+      client,
+      context.workspace,
+      context.repoSlug,
+      context.actor,
+      {
+        requireWritePermission: true,
+        allowBots: false,
+      }
+    );
+
+    if (!actorResult.valid) {
+      console.log(`⏭️ Skipping: ${actorResult.reason}`);
+      return {
+        success: true,
+        shouldContinue: false,
+        error: actorResult.reason,
+      };
+    }
+
+    console.log("✅ Actor validation passed");
+
+    // Detect mode
+    const { mode, reason } = detectMode(context, {
+      triggerPhrase: config.TRIGGER_PHRASE,
+      prompt: config.PROMPT,
+      mode: config.MODE as ModeName | undefined,
+    });
+
+    console.log(`📋 Mode: ${mode.name} (${reason})`);
+
+    // Prepare mode context
+    const createTrackingComment = getEnvBool("CREATE_TRACKING_COMMENT", true);
+    const modeResult = await mode.prepare({
+      context,
+      client,
+      triggerPhrase: config.TRIGGER_PHRASE,
+      prompt: config.PROMPT,
+      createTrackingComment,
+    });
+
+    if (!modeResult.success) {
+      console.error(`❌ Mode preparation failed: ${modeResult.error}`);
+      return {
+        success: false,
+        shouldContinue: false,
+        context,
+        error: modeResult.error,
+      };
+    }
+
+    // Fetch PR data if in PR context
+    let prContext: ReturnType<typeof formatPRContext> | undefined;
+    if (context.isPR && context.entityNumber) {
+      console.log("📥 Fetching PR data...");
+      const prData = await fetchPRData(client, context, {
+        includeComments: true,
+        includeDiff: true,
+        includeCommits: true,
+        filterCommentsAfter: context.triggerTimestamp,
+      });
+      prContext = formatPRContext(prData);
+      console.log(`📥 Fetched ${prContext.files.length} changed files`);
+    }
+
+    console.log("✅ Prepare phase completed successfully");
+
+    // Output results for next phase
+    outputResults({
+      containsTrigger: true,
+      mode: mode.name,
+      trackingCommentId: modeResult.trackingCommentId,
+      prompt: triggerResult.userMessage || config.PROMPT || "",
+      systemPrompt: modeResult.modeContext.systemPrompt,
+      tools: modeResult.modeContext.tools,
+      pipelineUrl: getPipelineUrl(),
+    });
+
+    return {
+      success: true,
+      shouldContinue: true,
+      context,
+      prompt: triggerResult.userMessage || config.PROMPT,
+      systemPrompt: modeResult.modeContext.systemPrompt,
+      trackingCommentId: modeResult.trackingCommentId,
+      prContext,
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`❌ Prepare phase failed: ${message}`);
+    return {
+      success: false,
+      shouldContinue: false,
+      error: message,
+    };
+  }
+}
+
+/**
+ * Output results for pipeline consumption
+ */
+function outputResults(results: {
+  containsTrigger: boolean;
+  mode: string;
+  trackingCommentId?: number;
+  prompt: string;
+  systemPrompt: string;
+  tools: string[];
+  pipelineUrl?: string;
+}) {
+  // Write to files for pipeline use
+  const fs = require("fs");
+  const outputDir = process.env.BITBUCKET_CLONE_DIR || ".";
+
+  const outputPath = `${outputDir}/.gemini-action-output.json`;
+  fs.writeFileSync(outputPath, JSON.stringify(results, null, 2));
+  console.log(`📝 Output written to ${outputPath}`);
+
+  // Also set environment variables for immediate use
+  console.log(`::set-output name=contains_trigger::${results.containsTrigger}`);
+  console.log(`::set-output name=mode::${results.mode}`);
+  if (results.trackingCommentId) {
+    console.log(
+      `::set-output name=tracking_comment_id::${results.trackingCommentId}`
+    );
+  }
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  prepare()
+    .then((result) => {
+      if (!result.success) {
+        process.exit(1);
+      }
+      if (!result.shouldContinue) {
+        console.log("ℹ️ No action needed");
+        process.exit(0);
+      }
+    })
+    .catch((error) => {
+      console.error("Fatal error:", error);
+      process.exit(1);
+    });
+}

package/src/gemini/client.ts

@@ -0,0 +1,263 @@
+/**
+ * Google Gemini API Client
+ * Wrapper for @google/generative-ai SDK
+ */
+
+import {
+  GoogleGenerativeAI,
+  GenerativeModel,
+  GenerationConfig,
+  Content,
+  Part,
+  FunctionDeclaration,
+  Tool,
+  FunctionCallingMode,
+  type GenerateContentResult,
+} from "@google/generative-ai";
+
+export interface GeminiClientOptions {
+  apiKey: string;
+  model?: string;
+  generationConfig?: GenerationConfig;
+}
+
+export interface GeminiMessage {
+  role: "user" | "model";
+  parts: Part[];
+}
+
+export interface GeminiToolCall {
+  name: string;
+  args: Record<string, unknown>;
+}
+
+export interface GeminiResponse {
+  text: string;
+  toolCalls?: GeminiToolCall[];
+  finishReason: string;
+  usage?: {
+    promptTokenCount: number;
+    candidatesTokenCount: number;
+    totalTokenCount: number;
+  };
+}
+
+const DEFAULT_MODEL = "gemini-2.0-flash";
+
+const DEFAULT_GENERATION_CONFIG: GenerationConfig = {
+  temperature: 0.7,
+  topP: 0.95,
+  topK: 40,
+  maxOutputTokens: 8192,
+};
+
+export class GeminiClient {
+  private genAI: GoogleGenerativeAI;
+  private model: GenerativeModel;
+  private modelName: string;
+  private generationConfig: GenerationConfig;
+
+  constructor(options: GeminiClientOptions) {
+    this.genAI = new GoogleGenerativeAI(options.apiKey);
+    this.modelName = options.model || DEFAULT_MODEL;
+    this.generationConfig = {
+      ...DEFAULT_GENERATION_CONFIG,
+      ...options.generationConfig,
+    };
+    this.model = this.genAI.getGenerativeModel({
+      model: this.modelName,
+      generationConfig: this.generationConfig,
+    });
+  }
+
+  /**
+   * Generate content with a simple prompt
+   */
+  async generateContent(prompt: string): Promise<GeminiResponse> {
+    const result = await this.model.generateContent(prompt);
+    return this.parseResponse(result);
+  }
+
+  /**
+   * Generate content with chat history
+   */
+  async generateWithHistory(
+    history: GeminiMessage[],
+    prompt: string
+  ): Promise<GeminiResponse> {
+    const chat = this.model.startChat({
+      history: history.map((msg) => ({
+        role: msg.role,
+        parts: msg.parts,
+      })),
+      generationConfig: this.generationConfig,
+    });
+
+    const result = await chat.sendMessage(prompt);
+    return this.parseResponse(result);
+  }
+
+  /**
+   * Generate content with system instruction
+   */
+  async generateWithSystemPrompt(
+    systemPrompt: string,
+    userPrompt: string
+  ): Promise<GeminiResponse> {
+    const modelWithSystem = this.genAI.getGenerativeModel({
+      model: this.modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: this.generationConfig,
+    });
+
+    const result = await modelWithSystem.generateContent(userPrompt);
+    return this.parseResponse(result);
+  }
+
+  /**
+   * Generate content with function calling (tools)
+   */
+  async generateWithTools(
+    prompt: string,
+    tools: FunctionDeclaration[],
+    systemPrompt?: string
+  ): Promise<GeminiResponse> {
+    const toolConfig: Tool[] = [
+      {
+        functionDeclarations: tools,
+      },
+    ];
+
+    const modelWithTools = this.genAI.getGenerativeModel({
+      model: this.modelName,
+      systemInstruction: systemPrompt,
+      generationConfig: this.generationConfig,
+      tools: toolConfig,
+      toolConfig: {
+        functionCallingConfig: {
+          mode: FunctionCallingMode.AUTO,
+        },
+      },
+    });
+
+    const result = await modelWithTools.generateContent(prompt);
+    return this.parseResponse(result);
+  }
+
+  /**
+   * Start a chat session for multi-turn conversation
+   */
+  startChat(options?: {
+    history?: Content[];
+    systemInstruction?: string;
+    tools?: FunctionDeclaration[];
+  }) {
+    const modelConfig: {
+      model: string;
+      generationConfig: GenerationConfig;
+      systemInstruction?: string;
+      tools?: Tool[];
+    } = {
+      model: this.modelName,
+      generationConfig: this.generationConfig,
+    };
+
+    if (options?.systemInstruction) {
+      modelConfig.systemInstruction = options.systemInstruction;
+    }
+
+    if (options?.tools) {
+      modelConfig.tools = [
+        {
+          functionDeclarations: options.tools,
+        },
+      ];
+    }
+
+    const model = this.genAI.getGenerativeModel(modelConfig);
+
+    return model.startChat({
+      history: options?.history || [],
+      generationConfig: this.generationConfig,
+    });
+  }
+
+  /**
+   * Count tokens for a given content
+   */
+  async countTokens(content: string | Part[]): Promise<number> {
+    const result = await this.model.countTokens(content);
+    return result.totalTokens;
+  }
+
+  private parseResponse(result: GenerateContentResult): GeminiResponse {
+    const response = result.response;
+    const candidate = response.candidates?.[0];
+
+    if (!candidate) {
+      throw new GeminiApiError("No response candidates returned", "NO_CANDIDATES");
+    }
+
+    const text =
+      candidate.content?.parts
+        ?.filter((part): part is { text: string } => "text" in part)
+        .map((part) => part.text)
+        .join("") || "";
+
+    // Extract function calls if present
+    const toolCalls = candidate.content?.parts
+      ?.filter(
+        (part): part is { functionCall: { name: string; args: Record<string, unknown> } } =>
+          "functionCall" in part
+      )
+      .map((part) => ({
+        name: part.functionCall.name,
+        args: part.functionCall.args,
+      }));
+
+    return {
+      text,
+      toolCalls: toolCalls?.length ? toolCalls : undefined,
+      finishReason: candidate.finishReason || "UNKNOWN",
+      usage: response.usageMetadata
+        ? {
+            promptTokenCount: response.usageMetadata.promptTokenCount || 0,
+            candidatesTokenCount:
+              response.usageMetadata.candidatesTokenCount || 0,
+            totalTokenCount: response.usageMetadata.totalTokenCount || 0,
+          }
+        : undefined,
+    };
+  }
+}
+
+export class GeminiApiError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: unknown
+  ) {
+    super(message);
+    this.name = "GeminiApiError";
+  }
+}
+
+/**
+ * Create Gemini client from environment variables
+ */
+export function createGeminiClientFromEnv(): GeminiClient {
+  const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+
+  if (!apiKey) {
+    throw new Error(
+      "Missing Gemini API key. Set GEMINI_API_KEY or GOOGLE_API_KEY environment variable"
+    );
+  }
+
+  const model = process.env.GEMINI_MODEL || DEFAULT_MODEL;
+
+  return new GeminiClient({
+    apiKey,
+    model,
+  });
+}