Merge pull request #31 from imcquee/add-pull-request-suggestions

Add command to generate pr titles

Author: m7medVision

README.md

@@ -5,6 +5,7 @@ AI-powered Git commit message generator that analyzes your staged changes and ou
 ## Features
 
 - Generates configurable number of commit message suggestions from your staged diff
+-  Generates 10 pull request titles based on the diff between the current branch and a target branch
 - Providers: GitHub Copilot (default), OpenAI, Anthropic (Claude Code CLI)
 - Multi-language support: English and Spanish
 - Interactive config to pick provider/model/language and set keys
@@ -28,9 +29,10 @@ go build -o lazycommit main.go
 
 - Root command: `lazycommit`
 - Subcommands:
-  - `lazycommit commit` — prints suggested commit messages to stdout, one per line, based on `git diff --cached`.
-  - `lazycommit config get` — prints the active provider, model, and language.
-  - `lazycommit config set` — interactive setup for provider, API key, model, and language.
+  - `lazycommit commit` — prints 10 suggested commit messages to stdout, one per line, based on `git diff --cached`.
+  - `lazycommit pr <target-branch>` — prints 10 suggested pull request titles to stdout, one per line, based on diff between current branch and `<target-branch>`.
+  - `lazycommit config get` — prints the active provider, model and language.
+  - `lazycommit config set` — interactive setup for provider, API key,  model, and language.
 
 Exit behaviors:
 - If no staged changes: prints "No staged changes to commit." and exits 0.
@@ -59,6 +61,12 @@ git add .
 lazycommit commit | fzf --prompt='Pick commit> ' | xargs -r -I {} git commit -m "{}"
 ```
 
+Generate PR titles against `main` branch:
+
+```bash
+lazycommit pr main
+```
+
 ## Configuration
 
 lazycommit uses a two-file configuration system to separate sensitive provider settings from shareable prompt configurations:
@@ -106,8 +114,9 @@ Contains prompt templates and message configurations. **Safe to share in dotfile
 This file is automatically created on first run with sensible defaults:
 
 ```yaml
-system_message: "You are a helpful assistant that generates git commit messages."
+system_message: "You are a helpful assistant that generates git commit messages, and pull request titles."
 commit_message_template: "Based on the following git diff, generate 10 conventional commit messages. Each message should be on a new line, without any numbering or bullet points:\n\n%s"
+pr_title_template: "Based on the following git diff, generate 10 pull request title suggestions. Each title should be on a new line, without any numbering or bullet points:\n\n%s"
 ```
 
 

cmd/pr.go

@@ -0,0 +1,115 @@
+package cmd
+
+import (
+	"context"
+	"fmt"
+	"os"
+
+	"github.com/m7medvision/lazycommit/internal/config"
+	"github.com/m7medvision/lazycommit/internal/git"
+	"github.com/m7medvision/lazycommit/internal/provider"
+	"github.com/spf13/cobra"
+)
+
+// PrProvider defines the interface for generating pull request titles
+type PrProvider interface {
+	GeneratePRTitle(ctx context.Context, diff string) (string, error)
+	GeneratePRTitles(ctx context.Context, diff string) ([]string, error)
+}
+
+// prCmd represents the pr command
+var prCmd = &cobra.Command{
+	Use:   "pr",
+	Short: "Generate pull request title suggestions",
+	Long: `Analyzes the diff of the current branch compared to a target branch, and generates a list of 10 suggested pull request titles.
+
+	Arguments:
+  <target-branch>    The branch to compare against (e.g., main, develop)`,
+	Args: func(cmd *cobra.Command, args []string) error {
+		if len(args) < 1 {
+			return fmt.Errorf("missing required argument: <target-branch>")
+		}
+		if len(args) > 1 {
+			return fmt.Errorf("too many arguments, expected 1 but got %d", len(args))
+		}
+		return nil
+	},
+	Example: "lazycommit pr main\n  lazycommit pr develop",
+	Run: func(cmd *cobra.Command, args []string) {
+		diff, err := git.GetDiffAgainstBranch(args[0])
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error getting branch comparison diff: %v\n", err)
+			os.Exit(1)
+		}
+
+		if diff == "" {
+			fmt.Println("No changes compared to base branch.")
+			return
+		}
+
+		var aiProvider PrProvider
+
+		providerName := config.GetProvider()
+
+		// API key is not needed for anthropic provider (uses CLI)
+		var apiKey string
+		if providerName != "anthropic" {
+			var err error
+			apiKey, err = config.GetAPIKey()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error getting API key: %v\n", err)
+				os.Exit(1)
+			}
+		}
+
+		var model string
+		if providerName == "copilot" || providerName == "openai" || providerName == "anthropic" {
+			var err error
+			model, err = config.GetModel()
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Error getting model: %v\n", err)
+				os.Exit(1)
+			}
+		}
+
+		endpoint, err := config.GetEndpoint()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error getting endpoint: %v\n", err)
+			os.Exit(1)
+		}
+
+		switch providerName {
+		case "copilot":
+			aiProvider = provider.NewCopilotProviderWithModel(apiKey, model, endpoint)
+		case "openai":
+			aiProvider = provider.NewOpenAIProvider(apiKey, model, endpoint)
+		case "anthropic":
+			// Get num_suggestions from config
+			numSuggestions := config.GetNumSuggestions()
+			aiProvider = provider.NewAnthropicProvider(model, numSuggestions)
+		default:
+			// Default to copilot if provider is not set or unknown
+			aiProvider = provider.NewCopilotProvider(apiKey, endpoint)
+		}
+
+		prTitles, err := aiProvider.GeneratePRTitles(context.Background(), diff)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Error generating pull request titles %v\n", err)
+			os.Exit(1)
+		}
+
+		if len(prTitles) == 0 {
+			fmt.Println("No PR titles generated.")
+			return
+		}
+
+		for _, title := range prTitles {
+			fmt.Println(title)
+		}
+
+	},
+}
+
+func init() {
+	RootCmd.AddCommand(prCmd)
+}

internal/config/prompts.go

@@ -11,6 +11,7 @@ import (
 type PromptConfig struct {
 	SystemMessage         string `yaml:"system_message"`
 	CommitMessageTemplate string `yaml:"commit_message_template"`
+	PRTitleTemplate       string `yaml:"pr_title_template"`
 }
 
 var promptsCfg *PromptConfig
@@ -60,8 +61,9 @@ func InitPromptConfig() {
 // getDefaultPromptConfig returns the default prompt configuration
 func getDefaultPromptConfig() *PromptConfig {
 	return &PromptConfig{
-		SystemMessage:         "You are a helpful assistant that generates git commit messages.",
+		SystemMessage:         "You are a helpful assistant that generates git commit messages, and pull request titles.",
 		CommitMessageTemplate: "Based on the following git diff, generate 10 conventional commit messages. Each message should be on a new line, without any numbering or bullet points:\n\n%s",
+		PRTitleTemplate:       "Based on the following git diff, generate 10 pull request title suggestions. Each title should be on a new line, without any numbering or bullet points:\n\n%s",
 	}
 }
 
@@ -118,3 +120,13 @@ func GetCommitMessagePromptFromConfig(diff string) string {
 
 	return basePrompt
 }
+
+// GetPRTitlePromptFromConfig returns the pull request title prompt from configuration
+func GetPRTitlePromptFromConfig(diff string) string {
+	config := GetPromptConfig()
+	if config.PRTitleTemplate != "" {
+		return fmt.Sprintf(config.PRTitleTemplate, diff)
+	}
+	// Fallback to hardcoded default
+	return fmt.Sprintf("Based on the following git diff, generate 10 pull request title suggestions. Each title should be on a new line, without any numbering or bullet points:\n\n%s", diff)
+}

internal/git/git.go

@@ -19,6 +19,24 @@ func GetStagedDiff() (string, error) {
 	return out.String(), nil
 }
 
+// GetDiffAgainstBranch returns the diff against the specified branch. For example "main" when creating a PR.
+func GetDiffAgainstBranch(branch string) (string, error) {
+	// Check if the branch exists
+	checkCmd := exec.Command("git", "rev-parse", "--verify", branch)
+	if err := checkCmd.Run(); err != nil {
+		return "", fmt.Errorf("branch '%s' does not exist", branch)
+	}
+
+	cmd := exec.Command("git", "diff", branch)
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	err := cmd.Run()
+	if err != nil {
+		return "", fmt.Errorf("error running git diff %s: %w", branch, err)
+	}
+	return out.String(), nil
+}
+
 // GetWorkingTreeDiff returns the diff of the working tree.
 func GetWorkingTreeDiff() (string, error) {
 	cmd := exec.Command("git", "diff")

internal/provider/anthropic.go

@@ -109,3 +109,84 @@ func (a *AnthropicProvider) GenerateCommitMessages(ctx context.Context, diff str
 
 	return commitMessages, nil
 }
+
+func (a *AnthropicProvider) GeneratePRTitle(ctx context.Context, diff string) (string, error) {
+	titles, err := a.GeneratePRTitles(ctx, diff)
+	if err != nil {
+		return "", err
+	}
+	if len(titles) == 0 {
+		return "", fmt.Errorf("no PR titles generated")
+	}
+	return titles[0], nil
+}
+
+func (a *AnthropicProvider) GeneratePRTitles(ctx context.Context, diff string) ([]string, error) {
+	if strings.TrimSpace(diff) == "" {
+		return nil, fmt.Errorf("no diff provided")
+	}
+
+	// Check if claude CLI is available
+	if _, err := exec.LookPath("claude"); err != nil {
+		return nil, fmt.Errorf("claude CLI not found in PATH. Please install Claude Code CLI: %w", err)
+	}
+
+	// Build the prompt using PR title template
+	systemMsg := GetSystemMessage()
+	userPrompt := GetPRTitlePrompt(diff)
+
+	// Modify the prompt to request specific number of suggestions
+	fullPrompt := fmt.Sprintf("%s\n\nUser request: %s\n\nIMPORTANT: Generate exactly %d pull request titles, one per line. Do not include any other text, explanations, or formatting - just the PR titles.",
+		systemMsg, userPrompt, a.numSuggestions)
+
+	// Execute claude CLI with the specified model
+	cmd := exec.CommandContext(ctx, "claude", "--model", a.model, "-p", fullPrompt)
+
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		return nil, fmt.Errorf("error executing claude CLI: %w\nOutput: %s", err, string(output))
+	}
+
+	// Parse the output - same logic as commit message generation
+	content := string(output)
+	lines := strings.Split(content, "\n")
+
+	var prTitles []string
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			continue
+		}
+		if len(trimmed) > 200 {
+			continue
+		}
+		// Skip markdown formatting or numbered lists
+		if strings.HasPrefix(trimmed, "#") || strings.HasPrefix(trimmed, "-") || strings.HasPrefix(trimmed, "*") {
+			parts := strings.SplitN(trimmed, " ", 2)
+			if len(parts) == 2 {
+				trimmed = strings.TrimSpace(parts[1])
+			}
+		}
+		// Remove numbered list formatting like "1. " or "1) "
+		if len(trimmed) > 3 {
+			if (trimmed[0] >= '0' && trimmed[0] <= '9') && (trimmed[1] == '.' || trimmed[1] == ')') {
+				trimmed = strings.TrimSpace(trimmed[2:])
+			}
+		}
+
+		if trimmed != "" {
+			prTitles = append(prTitles, trimmed)
+		}
+
+		// Stop once we have enough titles
+		if len(prTitles) >= a.numSuggestions {
+			break
+		}
+	}
+
+	if len(prTitles) == 0 {
+		return nil, fmt.Errorf("no valid PR titles generated from Claude output")
+	}
+
+	return prTitles, nil
+}

internal/provider/common.go

@@ -47,3 +47,37 @@ func (c *commonProvider) generateCommitMessages(ctx context.Context, diff string
 	}
 	return cleanMessages, nil
 }
+
+// generatePRTitles is a helper function to generate pull request titles using the OpenAI API.
+func (c *commonProvider) generatePRTitles(ctx context.Context, diff string) ([]string, error) {
+	if diff == "" {
+		return nil, fmt.Errorf("no diff provided")
+	}
+
+	params := openai.ChatCompletionNewParams{
+		Model: openai.ChatModel(c.model),
+		Messages: []openai.ChatCompletionMessageParamUnion{
+			{OfSystem: &openai.ChatCompletionSystemMessageParam{Content: openai.ChatCompletionSystemMessageParamContentUnion{OfString: openai.String(GetSystemMessage())}}},
+			{OfUser: &openai.ChatCompletionUserMessageParam{Content: openai.ChatCompletionUserMessageParamContentUnion{OfString: openai.String(GetPRTitlePrompt(diff))}}},
+		},
+	}
+
+	resp, err := c.client.Chat.Completions.New(ctx, params)
+	if err != nil {
+		return nil, fmt.Errorf("error making request to OpenAI compatible API: %w", err)
+	}
+
+	if len(resp.Choices) == 0 {
+		return nil, fmt.Errorf("no pr titles generated")
+	}
+
+	content := resp.Choices[0].Message.Content
+	messages := strings.Split(content, "\n")
+	var cleanMessages []string
+	for _, msg := range messages {
+		if strings.TrimSpace(msg) != "" {
+			cleanMessages = append(cleanMessages, strings.TrimSpace(msg))
+		}
+	}
+	return cleanMessages, nil
+}