create-app-release 1.2.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,15 @@ 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
@@ -72,6 +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.2.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;
 }
 
 /**
@@ -349,9 +346,10 @@ async function fetchPullRequests(owner, repo, baseBranch) {
 /**
  * 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) => ({
@@ -377,22 +375,39 @@ ${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');
 
@@ -483,24 +498,65 @@ 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,
-  });
-
-  openai = new OpenAI({
-    apiKey: openaiToken,
-    baseURL: options.openaiBaseUrl,
-  });
+  // 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);
+    }
+  }
 
   // Fetch repositories the user has contributed to
   const userRepos = await fetchUserRepositories();
@@ -616,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) => {
@@ -668,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);