create-app-release 1.1.0 → 1.3.0

package/.prettierignore

@@ -4,3 +4,4 @@ build
 coverage
 .next
 package-lock.json
+pnpm-lock.yaml

package/CHANGELOG.md

@@ -5,6 +5,28 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.3.0] - 2026-01-29
+
+### Added
+
+- Added support for Google Gemini as an AI provider (API key and CLI integration).
+- Introduced `--ai-provider` option to select between OpenAI, Gemini API, and Gemini CLI.
+- Added `--gemini-key` and `--gemini-model` options for configuring Gemini API.
+- Enabled direct integration with `gemini-cli` for summary generation.
+
+## [1.2.0] - 2025-03-18
+
+### Added
+
+- Auto suggest repositories based on recent activities
+- Added filter for listed pull requests for easy tracking
+- Dynamic release version suggestion based on previous releases
+- Added suggestion for source and target branches
+
+### Changed
+
+- Updated release summary generation to exclude heading
+
 ## [1.1.0] - 2025-02-12
 
 ### Added
@@ -59,4 +81,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - ora - Terminal spinners
 - dotenv - Environment variable management
 
+[1.3.0]: https://github.com/jamesgordo/create-app-release/releases/tag/v1.3.0
+[1.2.0]: https://github.com/jamesgordo/create-app-release/releases/tag/v1.2.0
+[1.1.0]: https://github.com/jamesgordo/create-app-release/releases/tag/v1.1.0
 [1.0.0]: https://github.com/jamesgordo/create-app-release/releases/tag/v1.0.0

package/README.md

@@ -7,25 +7,24 @@ An AI-powered GitHub release automation tool that helps you create release pull
 
 ## Features
 
-- 🤖 AI-powered release notes generation using GPT-4
-- 🔄 Flexible LLM support:
-  - OpenAI models (GPT-4o, GPT-3.5-turbo)
-  - Deepseek models
-  - QwenAI models
-  - Local LLM deployments
-- 📦 Zero configuration - works right out of the box
-- 🔑 Secure token management through git config
-- 🎯 Interactive pull request selection
-- ✨ Professional markdown formatting
-- 📝 Smart categorization of changes
-- 🌟 User-friendly CLI interface
+- 🤖 AI-powered release notes generation.
+- 🔄 **Flexible LLM Support**: Seamlessly switch between OpenAI, Google Gemini, and any OpenAI-compatible API.
+  - **OpenAI**: `gpt-4o`, `gpt-3.5-turbo`.
+  - **Google Gemini**: `gemini-pro` via API key or local `gemini-cli`.
+  - **OpenAI-Compatible**: Supports providers like Deepseek, QwenAI, or local LLMs via a custom base URL.
+- 📦 Zero configuration - works right out of the box.
+- 🔑 Secure token management through `git config`.
+- 🎯 Interactive pull request selection.
+- ✨ Professional markdown formatting.
+- 📝 Smart categorization of changes.
+- 🌟 User-friendly CLI interface.
 
 ## Prerequisites
 
 - Node.js 14 or higher
 - Git installed and configured
-- GitHub account with repository access
-- OpenAI account (for GPT-4 access)
+- A GitHub account with repository access
+- An account with an AI provider (e.g., OpenAI, Google Gemini) if using an API key.
 
 ## Usage
 
@@ -35,57 +34,65 @@ Run the tool directly using npx:
 npx create-app-release
 ```
 
-On first run, the tool will guide you through:
-
-1. Setting up your GitHub token (stored in git config)
-2. Configuring your OpenAI API key (stored in git config)
-3. Selecting pull requests for the release
-4. Reviewing the AI-generated summary
-5. Creating the release pull request
+On the first run, the tool will guide you through setting up the necessary tokens and configurations.
 
 ### Token Setup
 
-You'll need two tokens to use this tool:
+You will need a **GitHub Token** and an API key for your chosen AI provider.
 
-1. **GitHub Token** - Create at [GitHub Token Settings](https://github.com/settings/tokens/new)
+1.  **GitHub Token** - Create at [GitHub Token Settings](https://github.com/settings/tokens/new)
+    - Required scope: `repo`
+    - Stored in git config as `github.token`
 
-   - Required scope: `repo`
-   - Will be stored in git config as `github.token`
+2.  **OpenAI API Key** - Get from [OpenAI Platform](https://platform.openai.com/api-keys)
+    - Required if using the `openai` provider.
+    - Stored in git config as `openai.token`
 
-2. **OpenAI API Key** - Get from [OpenAI Platform](https://platform.openai.com/api-keys)
-   - Will be stored in git config as `openai.token`
+3.  **Gemini API Key** - Get from [Google AI Studio](https://makersuite.google.com/app/apikey)
+    - Required if using the `gemini` provider.
+    - Stored in git config as `gemini.token`
 
 ### Command-Line Options
 
-Customize the tool's behavior using these command-line options:
+#### General Options
 
-```bash
-# Set OpenAI API key directly (alternative to env/git config)
---openai-key <key>
+`--ai-provider <provider>`
+: Select the AI provider.
+: **Options**: `openai`, `gemini`, `gemini-cli`.
+: If not specified, you will be prompted to choose.
 
-# Choose OpenAI model (default: "gpt-4o")
---openai-model <model>
-# Examples: gpt-4o, gpt-3.5-turbo, deepseek-r1, qwen2.5
+---
 
-# Set custom OpenAI API base URL
---openai-base-url <url>
-# Examples:
-# - Deepseek: https://api.deepseek.com/v1
-# - QwenAI: https://api.qwen.ai/v1
-# - Local: http://localhost:8000/v1
-# - Custom: https://custom-openai-endpoint.com/v1
+#### OpenAI Provider (`--ai-provider openai`)
 
-# Full example with different providers:
+`--openai-key <key>`
+: Set your OpenAI API key directly.
 
-# Using Deepseek
-npx create-app-release --openai-base-url https://api.deepseek.com/v1 --openai-key your_deepseek_key --openai-model deepseek-chat
+`--openai-model <model>`
+: Choose the OpenAI model (default: `"gpt-4o"`).
 
-# Using QwenAI
-npx create-app-release --openai-base-url https://api.qwen.ai/v1 --openai-key your_qwen_key --openai-model qwen-14b-chat
+`--openai-base-url <url>`
+: Set a custom base URL for OpenAI-compatible APIs (e.g., Deepseek, QwenAI, local LLMs).
+: **Examples**:
+: - `https://api.deepseek.com/v1`
+: - `https://api.qwen.ai/v1`
+: - `http://localhost:8000/v1`
 
-# Using Local LLM
-npx create-app-release --openai-base-url http://localhost:8000/v1 --openai-model local-model
-```
+---
+
+#### Gemini Provider (`--ai-provider gemini`)
+
+`--gemini-key <key>`
+: Set your Gemini API key directly.
+
+`--gemini-model <model>`
+: Set the Gemini model to use (default: `"gemini-pro"`).
+
+---
+
+#### Gemini CLI Provider (`--ai-provider gemini-cli`)
+
+This option uses a local `gemini` command-line tool, which must be installed and available in your system's `PATH`. The script will execute the `gemini` command, passing the prompt to its standard input. No API key is required for this provider option.
 
 ### Environment Variables (Optional)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-app-release",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "AI-powered GitHub release automation tool",
   "main": "src/index.js",
   "type": "module",
@@ -45,6 +45,7 @@
     ]
   },
   "dependencies": {
+    "@google/generative-ai": "^0.24.1",
     "@octokit/rest": "^20.0.2",
     "chalk": "^5.3.0",
     "commander": "^11.1.0",

package/src/index.js

@@ -6,10 +6,14 @@ import { Octokit } from '@octokit/rest';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
 import ora from 'ora';
+import { GoogleGenerativeAI } from '@google/generative-ai';
 import OpenAI from 'openai';
 import { promisify } from 'util';
 import { exec as execCallback } from 'child_process';
 import { createRequire } from 'module';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { writeFile, unlink } from 'fs/promises';
 
 // Initialize utilities
 const exec = promisify(execCallback);
@@ -98,12 +102,13 @@ async function configureToken({ envKey, gitKey, name, createUrl, additionalInfo
 // Initialize API clients
 let octokit;
 let openai;
+let gemini;
 
 /**
- * Initialize GitHub and OpenAI tokens
- * @returns {Promise<Object>} Object containing both tokens
+ * Initialize GitHub token
+ * @returns {Promise<string>} The GitHub token
  */
-async function initializeTokens() {
+async function initializeGitHubToken() {
   const githubToken = await configureToken({
     envKey: 'GITHUB_TOKEN',
     gitKey: 'github.token',
@@ -111,15 +116,7 @@ async function initializeTokens() {
     createUrl: 'https://github.com/settings/tokens/new',
     additionalInfo: "Make sure to enable the 'repo' scope.",
   });
-
-  const openaiToken = await configureToken({
-    envKey: 'OPENAI_API_KEY',
-    gitKey: 'openai.token',
-    name: 'OpenAI',
-    createUrl: 'https://platform.openai.com/api-keys',
-  });
-
-  return { githubToken, openaiToken };
+  return githubToken;
 }
 
 /**
@@ -170,14 +167,130 @@ function extractPRNumbersFromDescription(description) {
   return new Set(prMatches.map((match) => parseInt(match.replace(/[^0-9]/g, ''))));
 }
 
+/**
+ * Fetch repositories the user has contributed to, including personal and organization repos
+ * @returns {Promise<Array>} List of repositories
+ */
+async function fetchUserRepositories() {
+  const spinner = ora('Fetching your repositories...').start();
+  try {
+    // Get authenticated user info
+    const { data: user } = await octokit.rest.users.getAuthenticated();
+    const username = user.login;
+
+    // Get user's repositories (both owned and contributed to)
+    const repos = [];
+
+    // Fetch user's own repositories
+    const userReposIterator = octokit.paginate.iterator(
+      octokit.rest.repos.listForAuthenticatedUser,
+      {
+        per_page: 100,
+        sort: 'updated',
+        direction: 'desc',
+      }
+    );
+
+    for await (const { data: userRepos } of userReposIterator) {
+      repos.push(
+        ...userRepos.map((repo) => ({
+          name: `${repo.owner.login}/${repo.name}`,
+          fullName: `${repo.owner.login}/${repo.name}`,
+          owner: repo.owner.login,
+          repoName: repo.name,
+          updatedAt: new Date(repo.updated_at),
+          pushedAt: new Date(repo.pushed_at || repo.updated_at),
+          isPersonal: repo.owner.login === username,
+          activityScore: 0, // Will be calculated based on user activity
+        }))
+      );
+
+      // Limit to 100 repositories to avoid excessive API calls
+      if (repos.length >= 100) break;
+    }
+
+    // Get recent user activity for each repository (limited to top 15 to avoid API rate limits)
+    const topRepos = repos.slice(0, 15);
+    spinner.text = 'Analyzing your recent activity...';
+
+    // Process repositories in parallel with rate limiting
+    await Promise.all(
+      topRepos.map(async (repo, index) => {
+        // Add delay to avoid hitting rate limits
+        await new Promise((resolve) => setTimeout(resolve, index * 100));
+
+        try {
+          // Check for user's recent commits
+          const { data: commits } = await octokit.rest.repos
+            .listCommits({
+              owner: repo.owner,
+              repo: repo.repoName,
+              author: username,
+              per_page: 100,
+            })
+            .catch(() => ({ data: [] }));
+
+          // Check for user's recent PRs
+          const { data: prs } = await octokit.rest.pulls
+            .list({
+              owner: repo.owner,
+              repo: repo.repoName,
+              state: 'all',
+              per_page: 100,
+            })
+            .catch(() => ({ data: [] }));
+
+          // Calculate activity score based on recency and count
+          const now = new Date();
+          let score = 0;
+
+          // Add points for recent commits
+          commits.forEach((commit) => {
+            const daysAgo = (now - new Date(commit.commit.author.date)) / (1000 * 60 * 60 * 24);
+            score += Math.max(30 - daysAgo, 0); // More points for more recent commits
+          });
+
+          // Add points for PRs authored or reviewed by user
+          prs.forEach((pr) => {
+            if (pr.user.login === username) {
+              const daysAgo = (now - new Date(pr.updated_at)) / (1000 * 60 * 60 * 24);
+              score += Math.max(20 - daysAgo, 0); // Points for authoring PRs
+            }
+          });
+
+          // Update the repository's activity score
+          repo.activityScore = score;
+        } catch (error) {
+          // Silently continue if we hit API limits or other issues
+        }
+      })
+    );
+
+    // Sort repositories by activity score first, then by pushed date
+    repos.sort((a, b) => {
+      if (a.activityScore !== b.activityScore) {
+        return b.activityScore - a.activityScore; // Higher score first
+      }
+      return b.pushedAt - a.pushedAt; // Then by most recent push
+    });
+
+    spinner.succeed(`Found ${repos.length} repositories, sorted by your recent activity`);
+    return repos;
+  } catch (error) {
+    spinner.fail('Failed to fetch repositories');
+    console.error(chalk.red(`Error: ${error.message}`));
+    return [];
+  }
+}
+
 /**
  * Fetch closed pull requests from the repository
  * @param {string} owner - Repository owner
  * @param {string} repo - Repository name
- * @param {string} targetBranch - Target branch name
+ * @param {string} baseBranch - Base branch name
  * @returns {Promise<Array>} List of pull requests
  */
-async function fetchPullRequests(owner, repo) {
+async function fetchPullRequests(owner, repo, baseBranch) {
   const spinner = ora('Fetching pull requests...').start();
   try {
     // Get the latest release PR first
@@ -195,10 +308,14 @@ async function fetchPullRequests(owner, repo) {
     });
 
     for await (const { data } of iterator) {
-      // Filter PRs that are merged after the last release and not included in it
+      // Filter PRs that are merged after the last release, not included in it, and merged to the target branch
       const relevantPRs = data.filter((pr) => {
+        // Skip PRs that aren't merged
         if (!pr.merged_at) return false;
 
+        // Skip PRs that aren't targeting the specified branch
+        if (pr.base && pr.base.ref !== baseBranch) return false;
+
         const isAfterLastRelease = latestReleasePR
           ? new Date(pr.merged_at) >= new Date(latestReleasePR.merged_at)
           : true;
@@ -229,9 +346,10 @@ async function fetchPullRequests(owner, repo) {
 /**
  * Generate an AI-powered release summary from selected pull requests
  * @param {Array} selectedPRs - List of selected pull requests
+ * @param {string} aiProvider - The AI provider to use ('openai' or 'gemini')
  * @returns {Promise<string>} Generated release summary
  */
-async function generateSummary(selectedPRs) {
+async function generateSummary(selectedPRs, aiProvider) {
   const spinner = ora('Generating release summary...').start();
   try {
     const prDetails = selectedPRs.map((pr) => ({
@@ -250,28 +368,46 @@ async function generateSummary(selectedPRs) {
   1.2 For each type, make each bullet point concise and easy to read and understand for non-tech people.
   1.3 Don't link the bullet points to a pull requests
 2. The last section should be a list of pull requests included in the release. Format: "#<number> - <title> by [@<author>](<authorUrl>) (<date>)".
+3. Don't add Release Summary title/heading.
 
 Pull Requests to summarize:
 ${JSON.stringify(prDetails, null, 2)}
 
 Keep the summary concise, clear, and focused on the user impact. Use professional but easy-to-understand language.`;
 
-    const model = program.opts().openaiModel || 'gpt-4o';
-    const response = await openai.chat.completions.create({
-      model,
-      messages: [{ role: 'user', content: prompt }],
-      temperature: 0.7,
-    });
+    let summaryText;
 
-    // Validate response structure
-    if (!response?.choices?.length || !response.choices[0]?.message?.content) {
-      throw new Error(
-        'Invalid API response structure. Expected response.choices[0].message.content'
-      );
+    if (aiProvider === 'openai') {
+      const model = program.opts().openaiModel || 'gpt-4o';
+      const response = await openai.chat.completions.create({
+        model,
+        messages: [{ role: 'user', content: prompt }],
+        temperature: 0.7,
+      });
+
+      if (!response?.choices?.length || !response.choices[0]?.message?.content) {
+        throw new Error('Invalid API response structure from OpenAI.');
+      }
+      summaryText = response.choices[0].message.content;
+    } else if (aiProvider === 'gemini') {
+      const modelName = program.opts().geminiModel || 'gemini-pro';
+      const model = gemini.getGenerativeModel({ model: modelName });
+      const result = await model.generateContent(prompt);
+      const response = await result.response;
+      summaryText = response.text();
+    } else if (aiProvider === 'gemini-cli') {
+      const tempFilePath = join(tmpdir(), `gemini-prompt-${Date.now()}.txt`);
+      try {
+        await writeFile(tempFilePath, prompt, 'utf-8');
+        const { stdout } = await exec(`gemini < ${tempFilePath}`);
+        summaryText = stdout;
+      } finally {
+        await unlink(tempFilePath);
+      }
     }
 
     spinner.succeed('Summary generated successfully');
-    return response.choices[0].message.content;
+    return summaryText;
   } catch (error) {
     spinner.fail('Failed to generate summary');
 
@@ -362,41 +498,152 @@ async function run() {
   const options = program.opts();
 
   // Initialize GitHub token
-  const { githubToken } = await initializeTokens();
+  const githubToken = await initializeGitHubToken();
+  octokit = new Octokit({ auth: githubToken });
 
-  // Get OpenAI token from command line or fallback to configuration
-  let openaiToken = options.openaiKey;
-  if (!openaiToken) {
-    const tokens = await initializeTokens();
-    openaiToken = tokens.openaiToken;
+  // AI Provider selection
+  let aiProvider = options.aiProvider;
+  if (!aiProvider) {
+    const { provider } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'provider',
+        message: 'Select an AI provider for generating summaries:',
+        choices: [
+          { name: 'OpenAI', value: 'openai' },
+          { name: 'Gemini (API Key)', value: 'gemini' },
+          { name: 'Gemini (CLI)', value: 'gemini-cli' },
+        ],
+        default: 'openai',
+      },
+    ]);
+    aiProvider = provider;
   }
 
-  // Initialize clients with tokens
-  octokit = new Octokit({
-    auth: githubToken,
-  });
+  // Initialize AI client
+  if (aiProvider === 'openai') {
+    const openaiToken =
+      options.openaiKey ||
+      (await configureToken({
+        envKey: 'OPENAI_API_KEY',
+        gitKey: 'openai.token',
+        name: 'OpenAI',
+        createUrl: 'https://platform.openai.com/api-keys',
+      }));
+    openai = new OpenAI({
+      apiKey: openaiToken,
+      baseURL: options.openaiBaseUrl,
+    });
+  } else if (aiProvider === 'gemini') {
+    const geminiToken =
+      options.geminiKey ||
+      (await configureToken({
+        envKey: 'GEMINI_API_KEY',
+        gitKey: 'gemini.token',
+        name: 'Gemini',
+        createUrl: 'https://makersuite.google.com/app/apikey',
+      }));
+    gemini = new GoogleGenerativeAI(geminiToken);
+  } else if (aiProvider === 'gemini-cli') {
+    // No initialization needed, but I can check if `gemini` command exists
+    try {
+      await exec('command -v gemini');
+    } catch (error) {
+      console.error(
+        chalk.red(
+          'Error: `gemini` command not found. Please install the gemini-cli tool and make sure it is in your PATH.'
+        )
+      );
+      process.exit(1);
+    }
+  }
 
-  openai = new OpenAI({
-    apiKey: openaiToken,
-    baseURL: options.openaiBaseUrl,
-  });
+  // Fetch repositories the user has contributed to
+  const userRepos = await fetchUserRepositories();
+
+  // Prepare repository choices
+  const repoChoices =
+    userRepos.length > 0
+      ? userRepos.map((repo) => ({
+          name: repo.fullName + (repo.isPersonal ? ' (personal)' : ''),
+          value: { owner: repo.owner, repo: repo.repoName },
+        }))
+      : [];
+
+  // Add option for manual entry
+  repoChoices.push({ name: '-- Enter repository manually --', value: 'manual' });
+
+  let repoInfo = { owner: '', repo: '' };
+  const { repoSelection } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'repoSelection',
+      message: 'Select a repository:',
+      choices: repoChoices,
+      pageSize: 5,
+    },
+  ]);
+
+  // Handle manual repository entry
+  if (repoSelection === 'manual') {
+    const manualEntry = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'owner',
+        message: 'Enter repository owner:',
+        validate: (input) => input.length > 0,
+      },
+      {
+        type: 'input',
+        name: 'repo',
+        message: 'Enter repository name:',
+        validate: (input) => input.length > 0,
+      },
+    ]);
+    repoInfo = manualEntry;
+  } else {
+    repoInfo = repoSelection;
+  }
 
-  const { owner, repo } = await inquirer.prompt([
+  const { owner, repo } = repoInfo;
+
+  const { sourceBranch, targetBranch } = await inquirer.prompt([
     {
       type: 'input',
-      name: 'owner',
-      message: 'Enter repository owner:',
+      name: 'sourceBranch',
+      message: 'Enter source branch name:',
+      default: 'staging',
       validate: (input) => input.length > 0,
     },
     {
       type: 'input',
-      name: 'repo',
-      message: 'Enter repository name:',
+      name: 'targetBranch',
+      message: 'Enter target branch name:',
+      default: 'main',
       validate: (input) => input.length > 0,
     },
   ]);
 
-  const pulls = await fetchPullRequests(owner, repo);
+  // Get the latest release version for the repository
+  let suggestedVersion = '1.0.0';
+  try {
+    const { data: releases } = await octokit.rest.repos.listReleases({
+      owner,
+      repo,
+      per_page: 100,
+    });
+
+    if (releases && releases.length > 0) {
+      // Extract version from tag_name (removing any 'v' prefix)
+      const latestTag = releases[0].tag_name.replace(/^v/, '');
+      const [major, minor, patch] = latestTag.split('.');
+      suggestedVersion = `${major}.${minor}.${parseInt(patch) + 1}`;
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`Could not fetch latest release version: ${error.message}`));
+  }
+
+  const pulls = await fetchPullRequests(owner, repo, sourceBranch);
 
   const { selectedPRs } = await inquirer.prompt([
     {
@@ -425,7 +672,7 @@ async function run() {
 
   let summary;
   if (summaryType === 'ai') {
-    summary = await generateSummary(selectedPRs);
+    summary = await generateSummary(selectedPRs, aiProvider);
   } else {
     summary = selectedPRs
       .map((pr) => {
@@ -438,11 +685,12 @@ async function run() {
   console.log(chalk.cyan('\nSummary:'));
   console.log(summary);
 
-  const { version, confirm, sourceBranch, targetBranch } = await inquirer.prompt([
+  const { version, confirm } = await inquirer.prompt([
     {
       type: 'input',
       name: 'version',
-      message: 'Enter the version number for this release (e.g., 1.2.3):',
+      message: `Enter the version number for this release (suggested: ${suggestedVersion}):`,
+      default: suggestedVersion,
       validate: (input) => {
         // Validate semantic versioning format (x.y.z)
         const semverRegex = /^\d+\.\d+\.\d+$/;
@@ -457,20 +705,6 @@ async function run() {
       name: 'confirm',
       message: 'Would you like to create a release PR with this summary?',
     },
-    {
-      type: 'input',
-      name: 'sourceBranch',
-      message: 'Enter source branch name:',
-      when: (answers) => answers.confirm,
-      validate: (input) => input.length > 0,
-    },
-    {
-      type: 'input',
-      name: 'targetBranch',
-      message: 'Enter target branch name:',
-      when: (answers) => answers.confirm,
-      validate: (input) => input.length > 0,
-    },
   ]);
 
   if (confirm) {
@@ -490,27 +724,36 @@ async function run() {
 const description = `AI-powered GitHub release automation tool
 
 Options:
-  --openai-key <key>        Set OpenAI API key directly (alternative to env/git config)
-  --openai-model <model>    Set OpenAI model to use (default: "gpt-4")
-                           Examples: gpt-4, gpt-3.5-turbo
+  --ai-provider <provider>  Set AI provider to use ('openai', 'gemini', or 'gemini-cli')
+  --openai-key <key>        Set OpenAI API key directly
+  --openai-model <model>    Set OpenAI model to use (default: "gpt-4o")
   --openai-base-url <url>   Set custom OpenAI API base URL
-                           Example: https://custom-openai-endpoint.com/v1
+  --gemini-key <key>        Set Gemini API key directly (for 'gemini' provider)
+  --gemini-model <model>    Set Gemini model to use (default: "gemini-pro")
 
 Environment Variables:
   GITHUB_TOKEN              GitHub personal access token
-  OPENAI_API_KEY            OpenAI API key (if not using --openai-key)
+  OPENAI_API_KEY            OpenAI API key
+  GEMINI_API_KEY            Gemini API key
 
 Git Config:
   github.token              GitHub token in git config
-  openai.token              OpenAI token in git config (if not using --openai-key)
+  openai.token              OpenAI token in git config
+  gemini.token              Gemini token in git config
 `;
 
 program
   .name('create-app-release')
   .description(description)
   .version(pkg.version)
+  .option(
+    '--ai-provider <provider>',
+    "Set AI provider to use ('openai', 'gemini', or 'gemini-cli')"
+  )
   .option('--openai-base-url <url>', 'Set custom OpenAI API base URL')
-  .option('--openai-model <model>', 'Set OpenAI model to use (default: "gpt-4")')
-  .option('--openai-key <key>', 'Set OpenAI API key directly (alternative to env/git config)')
+  .option('--openai-model <model>', 'Set OpenAI model to use (default: "gpt-4o")')
+  .option('--openai-key <key>', 'Set OpenAI API key directly')
+  .option('--gemini-model <model>', 'Set Gemini model to use (default: "gemini-pro")')
+  .option('--gemini-key <key>', "Set Gemini API key directly (for 'gemini' provider)")
   .action(run)
   .parse(process.argv);