gitpt 1.0.0 → 1.2.0

package/README.md

@@ -1,13 +1,20 @@
 # GitPT
 
-Git Prompt Tool is a CLI tool that helps you write commit messages using AI through [OpenRouter](https://openrouter.ai/).
+Git Prompt Tool is a CLI tool that helps you write commit messages using AI through [OpenRouter](https://openrouter.ai/). It acts as a complete git wrapper, enhancing specific commands with AI while passing through all other git commands directly.
 
 ## Features
 
+- Acts as a complete git replacement - all git commands are supported
 - Generate commit messages with AI based on your code changes
-- Compatible with all regular git commit options (you can treat it as an alias)
+
+  `gitpt commit`
+- Create pull requests with AI-generated titles and descriptions
+
+  `gitpt pr create`
+- Compatible with all regular git options (flags, arguments, etc.)
 - Edit suggested messages before committing
 - Works with various AI models via OpenRouter
+- [Commitlint](https://commitlint.js.org/) support - read directly from your repository
 
 ## Installation
 
@@ -35,15 +42,29 @@ You'll need an [OpenRouter](https://openrouter.ai/) account to get an API key.
 
 ## Usage
 
-### Adding Files
+### Using GitPT as a Complete Git Replacement
 
-Add files to the staging area using either git directly or the GitPT wrapper:
+GitPT can be used as a direct replacement for git - any git command can be run through GitPT:
 
 ```bash
-# Standard git command
-git add .
+# Standard git commands work exactly the same
+gitpt status
+gitpt log
+gitpt branch
+gitpt checkout -b new-feature
+gitpt push origin main
+
+# GitPT passes all arguments and options to git
+gitpt log --oneline --graph
+gitpt merge --no-ff feature-branch
+```
+
+### Adding Files
 
-# Or using GitPT wrapper
+Add files to the staging area just like you would with git:
+
+```bash
+# Same as git add . (supports all the regular git add options)
 gitpt add .
 ```
 
@@ -53,33 +74,86 @@ Generate an AI-powered commit message based on your staged changes:
 
 ```bash
 gitpt commit
+
+# Or supply -m argument, if you want to avoid gitpt generating the message
+gitpt commit -m "feat: file hash validation"
+
+# Pass any other git commit options
+gitpt commit --amend
 ```
 
 The tool will:
 1. Analyze your staged changes
 2. Generate a commit message using the configured AI model
-3. Show you the suggested message
-4. Let you edit the message before committing
-5. Create the commit with your approved message
+3. Validate against commitlint rules (if configured)
+4. Regenerate the message if it fails validation
+5. Show you the suggested message
+6. Let you edit the message before committing
+7. Create the commit with your approved message
 
-### Options
+### Changing Models
 
-You can use any standard git commit options with the `gitpt commit` command:
+You can change the AI model at any time without re-entering your API key:
 
 ```bash
-# Skip editing the message
-gitpt commit --no-edit
+# Select model interactively (fetches available models from OpenRouter)
+gitpt model
 
-# Provide your own message instead of generating one
-gitpt commit -m "Your message here"
+# Specify model directly
+gitpt model openai/gpt-4o
 
-# Pass any other git commit options
-gitpt commit --amend
+# Switch to a different Claude model
+gitpt model anthropic/claude-3-haiku
+```
+
+## GitHub Usage
+
+If you have GitHub CLI (`gh`) installed, you can use GitPT to interact with GitHub (e.g. generate full pull requests).
+
+### Creating Pull Requests
+
+Generate AI-powered pull request titles and descriptions based on your changes:
+
+```bash
+gitpt pr create
+```
+
+The tool will:
+1. Analyze the commits and files changed since branching from the base branch
+2. Generate a suitable PR title and detailed description
+3. Show you the suggested content
+4. Let you edit the title and description before submission
+5. Create the pull request with your approved content
+
+#### Pull Request Options
+
+```bash
+# Create a draft PR
+gitpt pr create --draft
+
+# Specify a custom base branch
+gitpt pr create --base develop
+
+# Skip editing the PR details
+gitpt pr create --no-edit
+
+# Provide your own title instead of generating one
+gitpt pr create --title "Your PR title here"
 ```
 
 ## How It Works
 
-GitPT sends a diff of your staged changes to the configured AI model via OpenRouter, which generates a contextual commit message following best practices.
+GitPT leverages AI via OpenRouter to enhance your Git workflow while acting as a complete git wrapper:
+
+- **Command Handling:** GitPT intelligently routes commands - enhanced commands (commit, pr) use AI capabilities while all other git commands are passed directly to git.
+
+- **For commits:** Sends a diff of your staged changes to the AI, which generates a contextual commit message following best practices.
+
+- **Commitlint Integration:** Automatically detects commitlint configuration files and validates generated commit messages against your project's commit conventions. If validation fails, it regenerates a compliant message.
+
+- **For pull requests:** Analyzes the commits and file changes between your branch and the base branch, then generates a suitable title and detailed description for your PR.
+
+- **For other git commands:** Passes them through directly to git with all arguments and options preserved, ensuring complete compatibility with your existing git workflow.
 
 ## Development
 
@@ -98,6 +172,20 @@ npm run build
 npm link
 ```
 
+## Commitlint Integration
+
+GitPT automatically detects and integrates with [commitlint](https://commitlint.js.org/) if it's configured in your repository:
+
+- **Automatic Detection:** GitPT checks for common commitlint configuration files (commitlint.config.js, .commitlintrc.*, etc.)
+
+- **Rule-Aware Generation:** When commitlint is detected, GitPT instructs the AI to generate messages that follow your specific commit conventions
+
+- **Validation & Regeneration:** Generated messages are validated against your commitlint rules before committing. If validation fails, GitPT automatically regenerates a compliant message
+
+- **Error Feedback:** Validation errors are sent to the AI to help it understand how to fix the message
+
+This integration ensures that all AI-generated commit messages follow your team's established commit conventions without requiring manual corrections.
+
 ## License
 
-MIT
+MIT

package/dist/commands/commit.js

@@ -3,6 +3,7 @@ import chalk from 'chalk';
 import { isGitRepository, hasStagedChanges, getStagedChanges, executeGitCommit } from '../utils/git.js';
 import { generateCommitMessage } from '../utils/api.js';
 import { getConfig } from '../utils/config.js';
+import { hasCommitlintConfig, validateCommitMessage } from '../utils/commitlint.js';
 export async function commitCommand(options) {
     if (!isGitRepository()) {
         console.error(chalk.red('Error: Not a git repository'));
@@ -29,8 +30,32 @@ export async function commitCommand(options) {
             // Get staged changes
             const diff = getStagedChanges();
             console.log(chalk.blue('Generating commit message...'));
+            // Check if commitlint is configured
+            if (hasCommitlintConfig()) {
+                console.log(chalk.blue('Commitlint configuration detected. Generating message according to rules...'));
+            }
             // Generate commit message
             commitMessage = await generateCommitMessage(diff);
+            // If commitlint is configured, validate the message
+            if (hasCommitlintConfig()) {
+                console.log(chalk.blue('Validating commit message against commitlint rules...'));
+                const validation = await validateCommitMessage(commitMessage);
+                if (!validation.valid && validation.errors) {
+                    console.log(chalk.yellow('Commit message failed validation. Regenerating...'));
+                    console.log(chalk.gray(validation.errors));
+                    // Regenerate with validation errors
+                    commitMessage = await generateCommitMessage(diff, validation.errors);
+                    // Validate again
+                    const revalidation = await validateCommitMessage(commitMessage);
+                    if (!revalidation.valid) {
+                        console.log(chalk.yellow('Warning: Regenerated message still has validation issues.'));
+                        console.log(chalk.gray(revalidation.errors));
+                    }
+                }
+                else {
+                    console.log(chalk.green('✓ Commit message passed validation'));
+                }
+            }
             console.log(chalk.green('✓ Commit message generated'));
             console.log('');
             console.log(chalk.cyan('Generated message:'));

package/dist/commands/model.d.ts

@@ -0,0 +1 @@
+export declare function modelCommand(modelId?: string): Promise<void>;

package/dist/commands/model.js

@@ -0,0 +1,114 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import fetch from 'node-fetch';
+import { getConfig, saveConfig } from '../utils/config.js';
+// List of popular models available on OpenRouter
+const POPULAR_MODELS = [
+    { name: 'Claude 3 Opus - Anthropic', value: 'anthropic/claude-3-opus:beta' },
+    { name: 'Claude 3 Sonnet - Anthropic', value: 'anthropic/claude-3-sonnet:beta' },
+    { name: 'Claude 3 Haiku - Anthropic', value: 'anthropic/claude-3-haiku:beta' },
+    { name: 'GPT-4o - OpenAI', value: 'openai/gpt-4o' },
+    { name: 'GPT-4 Turbo - OpenAI', value: 'openai/gpt-4-turbo' },
+    { name: 'GPT-3.5 Turbo - OpenAI', value: 'openai/gpt-3.5-turbo' },
+    { name: 'Other (specify model identifier)', value: 'custom' }
+];
+async function fetchAvailableModels(apiKey) {
+    try {
+        const response = await fetch('https://openrouter.ai/api/v1/models', {
+            headers: {
+                'Authorization': `Bearer ${apiKey}`,
+                'HTTP-Referer': 'https://github.com/bartaxyz/GitPT',
+            }
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.data;
+    }
+    catch (error) {
+        console.error(chalk.red('Error fetching models:'), error);
+        return [];
+    }
+}
+export async function modelCommand(modelId) {
+    console.log(chalk.blue('GitPT Model Selection'));
+    // Check if config exists
+    const existingConfig = getConfig();
+    if (!existingConfig) {
+        console.error(chalk.red('GitPT is not configured. Please run "gitpt setup" first.'));
+        process.exit(1);
+    }
+    let selectedModel;
+    // If a model ID is provided directly, use it
+    if (modelId) {
+        selectedModel = modelId;
+        // Update config with the new model while keeping the existing API key
+        saveConfig({
+            apiKey: existingConfig.apiKey,
+            model: selectedModel
+        });
+        console.log(chalk.green(`✓ Model set to: ${chalk.yellow(selectedModel)}`));
+        return;
+    }
+    // Otherwise, show interactive selection
+    console.log('Current model:', chalk.yellow(existingConfig.model));
+    console.log('');
+    try {
+        // Try to fetch available models from OpenRouter
+        console.log(chalk.gray('Fetching available models from OpenRouter...'));
+        const availableModels = await fetchAvailableModels(existingConfig.apiKey);
+        let modelChoices;
+        if (availableModels.length > 0) {
+            // Convert available models to choices format
+            modelChoices = availableModels.map(model => ({
+                name: `${model.name} (Context: ${model.context_length})`,
+                value: model.id
+            }));
+            // Add custom option at the end
+            modelChoices.push({ name: 'Other (specify model identifier)', value: 'custom' });
+            console.log(chalk.green(`✓ Found ${availableModels.length} models available with your API key`));
+        }
+        else {
+            // Fallback to predefined list if API call fails
+            console.log(chalk.yellow('Could not fetch models from OpenRouter, using predefined list'));
+            modelChoices = POPULAR_MODELS;
+        }
+        const answers = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'modelChoice',
+                message: 'Select an AI model:',
+                choices: modelChoices,
+                default: () => {
+                    // Try to find current model in the list to set as default
+                    const currentIndex = modelChoices.findIndex(choice => choice.value === existingConfig.model);
+                    return currentIndex >= 0 ? currentIndex : 0;
+                }
+            },
+            {
+                type: 'input',
+                name: 'customModel',
+                message: 'Enter model identifier:',
+                when: (answers) => answers.modelChoice === 'custom',
+                validate: (input) => {
+                    if (!input)
+                        return 'Model identifier is required';
+                    return true;
+                }
+            }
+        ]);
+        // Get the selected model
+        selectedModel = answers.modelChoice === 'custom' ? answers.customModel : answers.modelChoice;
+        // Save the updated configuration
+        saveConfig({
+            apiKey: existingConfig.apiKey,
+            model: selectedModel
+        });
+        console.log(chalk.green(`✓ Model updated to: ${chalk.yellow(selectedModel)}`));
+    }
+    catch (error) {
+        console.error(chalk.red('Error updating model:'), error);
+        process.exit(1);
+    }
+}

package/dist/commands/pr.d.ts

@@ -0,0 +1,10 @@
+interface PullRequestOptions {
+    title?: string;
+    body?: string;
+    draft?: boolean;
+    base?: string;
+    edit?: boolean;
+    [key: string]: any;
+}
+export declare function prCreateCommand(options?: PullRequestOptions): Promise<void>;
+export {};

package/dist/commands/pr.js

@@ -0,0 +1,458 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import { isGitRepository } from '../utils/git.js';
+import { getConfig } from '../utils/config.js';
+import fetch from 'node-fetch';
+function getCurrentBranch() {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD').toString().trim();
+    }
+    catch (error) {
+        console.error(chalk.red('Error getting current branch:'), error);
+        throw new Error('Failed to get current branch');
+    }
+}
+function getDefaultBaseBranch() {
+    try {
+        // First check for a default branch set in git config
+        try {
+            const defaultBranch = execSync('git config init.defaultBranch').toString().trim();
+            if (defaultBranch) {
+                return defaultBranch;
+            }
+        }
+        catch (error) {
+            // Continue if git config doesn't have default branch
+        }
+        // Next, check if GitHub CLI can tell us the default branch
+        try {
+            const repoInfo = execSync('gh repo view --json defaultBranchRef --jq .defaultBranchRef.name').toString().trim();
+            if (repoInfo) {
+                return repoInfo;
+            }
+        }
+        catch (error) {
+            // Continue if gh command fails
+        }
+        // Try to find default branch in remote branches list
+        const branches = execSync('git branch -r').toString().trim().split('\n');
+        // Common default branch names, in order of likelihood
+        const mainPatterns = [
+            /origin\/main$/,
+            /origin\/master$/,
+            /origin\/develop$/,
+            /origin\/dev$/,
+            /origin\/trunk$/
+        ];
+        // Try each pattern in order
+        for (const pattern of mainPatterns) {
+            const defaultBranch = branches.find(b => pattern.test(b.trim()));
+            if (defaultBranch) {
+                return defaultBranch.trim().replace(/^origin\//, '');
+            }
+        }
+        // Check for a branch that has 'HEAD -> origin/' in it, indicating the default branch
+        const headBranch = branches.find(b => b.includes('HEAD -> origin/'));
+        if (headBranch) {
+            const match = headBranch.match(/HEAD -> origin\/([^,\s]+)/);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        // Fallback to 'main' as most GitHub repos use this now
+        console.log(chalk.yellow('Could not determine default branch, using "main"'));
+        return 'main';
+    }
+    catch (error) {
+        // If we can't determine, default to main
+        console.log(chalk.yellow('Error detecting default branch, using "main"'));
+        return 'main';
+    }
+}
+function getCommitsSinceBaseBranch(baseBranch) {
+    try {
+        // Try first with origin/baseBranch
+        try {
+            const mergeBase = execSync(`git merge-base HEAD origin/${baseBranch}`).toString().trim();
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${mergeBase}..HEAD`).toString().trim();
+            if (commitMessages) {
+                return commitMessages.split('\n').filter(Boolean);
+            }
+        }
+        catch (error) {
+            // If origin/baseBranch doesn't exist, try with just baseBranch
+            console.log(chalk.yellow(`No origin/${baseBranch} found, trying with local ${baseBranch} branch...`));
+        }
+        // Try with local branch
+        try {
+            const mergeBase = execSync(`git merge-base HEAD ${baseBranch}`).toString().trim();
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${mergeBase}..HEAD`).toString().trim();
+            if (commitMessages) {
+                return commitMessages.split('\n').filter(Boolean);
+            }
+        }
+        catch (error) {
+            // If that fails too, fallback to simple branch comparison
+            console.log(chalk.yellow(`Merge base with ${baseBranch} not found, comparing branches directly...`));
+        }
+        // Direct branch comparison
+        try {
+            const commitMessages = execSync(`git log --pretty=format:"%s" ${baseBranch}..HEAD`).toString().trim();
+            if (commitMessages) {
+                return commitMessages.split('\n').filter(Boolean);
+            }
+        }
+        catch (error) {
+            console.log(chalk.yellow(`Could not compare with ${baseBranch}, using recent commits...`));
+        }
+        // Last resort: get most recent commits
+        const commitMessages = execSync('git log --pretty=format:"%s" -n 10').toString().trim();
+        return commitMessages.split('\n').filter(Boolean);
+    }
+    catch (error) {
+        console.error(chalk.yellow('Could not get commits. Using empty list.'));
+        return [];
+    }
+}
+function getChangedFiles(baseBranch) {
+    // Try several methods to get changed files
+    // Method 1: Compare with origin/baseBranch using three dots
+    try {
+        const changedFiles = execSync(`git diff --name-only origin/${baseBranch}...HEAD`).toString().trim();
+        if (changedFiles) {
+            return changedFiles.split('\n').filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 2: Compare with local baseBranch using three dots
+    try {
+        const changedFiles = execSync(`git diff --name-only ${baseBranch}...HEAD`).toString().trim();
+        if (changedFiles) {
+            return changedFiles.split('\n').filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 3: Direct comparison with two dots
+    try {
+        const changedFiles = execSync(`git diff --name-only ${baseBranch}..HEAD`).toString().trim();
+        if (changedFiles) {
+            return changedFiles.split('\n').filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Continue to next method
+    }
+    // Method 4: Get recently modified files
+    try {
+        console.log(chalk.yellow(`Could not determine changed files relative to ${baseBranch}, using recently modified files...`));
+        const changedFiles = execSync('git ls-files --modified --others --exclude-standard').toString().trim();
+        if (changedFiles) {
+            return changedFiles.split('\n').filter(Boolean);
+        }
+    }
+    catch (error) {
+        // Last resort
+    }
+    // Method 5: List all files in the repo as a last resort
+    try {
+        console.log(chalk.yellow('Using all tracked files as fallback...'));
+        const allFiles = execSync('git ls-files').toString().trim();
+        return allFiles.split('\n').filter(Boolean).slice(0, 50); // Limit to first 50 files
+    }
+    catch (error) {
+        console.error(chalk.red('Could not determine changed files.'));
+        return [];
+    }
+}
+async function generatePRDetails(baseBranch, currentBranch) {
+    const config = getConfig();
+    if (!config) {
+        throw new Error('GitPT is not configured. Please run "gitpt setup" first.');
+    }
+    const { apiKey, model } = config;
+    // Get context for PR
+    const commitMessages = getCommitsSinceBaseBranch(baseBranch);
+    const changedFiles = getChangedFiles(baseBranch);
+    // Check if we have any content to work with
+    if (commitMessages.length === 0 && changedFiles.length === 0) {
+        console.log(chalk.yellow('No commits or changed files detected.'));
+        console.log(chalk.yellow('Will attempt to generate PR details using branch name and repository context.'));
+    }
+    // Get additional context from repository
+    let repoName = "";
+    let repoDescription = "";
+    try {
+        // Try to get repo information from GitHub CLI
+        const repoInfo = JSON.parse(execSync('gh repo view --json name,description').toString().trim());
+        repoName = repoInfo.name || "";
+        repoDescription = repoInfo.description || "";
+    }
+    catch (error) {
+        // Continue without this info
+    }
+    console.log(chalk.blue('Generating PR title and description...'));
+    // Build a rich context for the AI
+    let contextSections = [
+        `Branch: ${currentBranch}`,
+        `Base branch: ${baseBranch}`
+    ];
+    // Add repository info if available
+    if (repoName) {
+        contextSections.push(`Repository: ${repoName}`);
+    }
+    if (repoDescription) {
+        contextSections.push(`Repository description: ${repoDescription}`);
+    }
+    // Add commit messages if available
+    if (commitMessages.length > 0) {
+        contextSections.push('Commit messages in this branch:', commitMessages.map(msg => `- ${msg}`).join('\n'));
+    }
+    else {
+        contextSections.push('No commit messages available.');
+        // Try to extract intent from branch name if no commits
+        if (currentBranch.includes('/')) {
+            const branchParts = currentBranch.split('/');
+            const branchType = branchParts[0]; // e.g., "feature", "fix", "chore"
+            const branchDescription = branchParts.slice(1).join('/').replace(/-/g, ' ');
+            contextSections.push('Branch name analysis:', `Type: ${branchType}`, `Description: ${branchDescription}`);
+        }
+    }
+    // Add changed files if available
+    if (changedFiles.length > 0) {
+        contextSections.push('Files changed in this branch:', changedFiles.map(file => `- ${file}`).join('\n'));
+    }
+    else {
+        contextSections.push('No file changes detected.');
+    }
+    // Create the final context
+    const context = contextSections.join('\n\n');
+    const systemPrompt = `You are a helpful assistant that generates clear, informative GitHub pull request titles and descriptions.
+For the title:
+- Keep it concise (under 80 characters)
+- Start with a verb in present tense (e.g., "Add", "Fix", "Update")
+- Clearly summarize the main purpose of the changes
+
+For the description:
+- Start with a brief summary (1-2 sentences) of what the PR accomplishes
+- Include a more detailed explanation of changes if needed
+- List key changes as bullet points if there are multiple components
+- Include any relevant context that reviewers should know
+- End with any testing instructions if applicable
+
+Format the description in Markdown with sections.
+Do not include "PR" or "Pull Request" in the title.`;
+    const userPrompt = `Generate a pull request title and description for the following changes:
+
+${context}
+
+Format your response exactly like this example:
+Title: Add user authentication with JWT
+Description: 
+## Summary
+This PR adds user authentication using JWT tokens.
+
+## Changes
+- Implement login and registration endpoints
+- Add JWT generation and validation
+- Update user model with password hashing
+- Add authorization middleware
+
+## How to test
+1. Register a new user with \`/api/register\`
+2. Login with the new user credentials
+3. Use the returned token to access protected endpoints`;
+    try {
+        const response = await fetch('https://openrouter.ai/api/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+                'HTTP-Referer': 'https://github.com/bartaxyz/GitPT',
+            },
+            body: JSON.stringify({
+                model: model,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: userPrompt }
+                ],
+                max_tokens: 1000,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`API request failed: ${response.status} ${response.statusText}\n${errorText}`);
+        }
+        const data = await response.json();
+        const result = data.choices[0].message.content.trim();
+        // Parse title and description from AI response
+        const titleMatch = result.match(/Title:\s*(.+?)(?:\n|$)/);
+        const descMatch = result.match(/Description:\s*\n([\s\S]+)$/);
+        const title = titleMatch ? titleMatch[1].trim() : '';
+        const body = descMatch ? descMatch[1].trim() : result; // Fallback to full response if parsing fails
+        return { title, body };
+    }
+    catch (error) {
+        console.error(chalk.red('Error generating PR details:'), error);
+        throw new Error('Failed to generate PR details');
+    }
+}
+function checkGitHubCLIAvailability() {
+    try {
+        execSync('gh --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+function createPullRequest(title, body, baseBranch, draft) {
+    const draftFlag = draft ? '--draft' : '';
+    try {
+        console.log(chalk.blue(`Creating pull request to ${baseBranch}...`));
+        // Create a temporary file for the PR body to avoid issues with escaping
+        const tempFilePath = `/tmp/gitpt-pr-body-${Date.now()}.md`;
+        try {
+            // Write the body to a temporary file
+            execSync(`cat > "${tempFilePath}" << 'GITPT_EOF'
+${body}
+GITPT_EOF`);
+            // Try to get the remote repo URL if available
+            let repoUrlArg = '';
+            try {
+                const repoUrl = execSync('git config --get remote.origin.url').toString().trim();
+                if (repoUrl) {
+                    repoUrlArg = `--repo "${repoUrl}"`;
+                }
+            }
+            catch (e) {
+                // Proceed without repo URL
+            }
+            // Use the file for the body
+            const command = `gh pr create --title "${title.replace(/"/g, '\\"')}" --body-file "${tempFilePath}" --base "${baseBranch}" ${draftFlag} ${repoUrlArg}`;
+            // Set a timeout to avoid hanging indefinitely
+            console.log(chalk.gray('Running GitHub PR creation command...'));
+            console.log(chalk.gray(`Using base branch: ${baseBranch}`));
+            // Add debugging output
+            console.log(chalk.gray('Executing command with 60s timeout:'));
+            // Execute the command with a timeout
+            const result = execSync(command, {
+                stdio: 'pipe',
+                timeout: 60000 // 60-second timeout 
+            }).toString();
+            console.log(result);
+            console.log(chalk.green('✓ Pull request created successfully'));
+        }
+        finally {
+            // Clean up temporary file
+            try {
+                execSync(`rm -f "${tempFilePath}"`);
+            }
+            catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes('timeout')) {
+            console.error(chalk.red('Error: GitHub CLI command timed out after 60 seconds.'));
+            console.log(chalk.yellow('You may need to create the PR manually using:'));
+            console.log(chalk.yellow(`gh pr create --title "${title}" --base "${baseBranch}" ${draftFlag}`));
+        }
+        else {
+            console.error(chalk.red('Error creating pull request:'), error);
+        }
+        throw new Error('Failed to create pull request');
+    }
+}
+export async function prCreateCommand(options = {}) {
+    if (!isGitRepository()) {
+        console.error(chalk.red('Error: Not a git repository'));
+        process.exit(1);
+    }
+    // Check if GitHub CLI is available
+    if (!checkGitHubCLIAvailability()) {
+        console.error(chalk.red('Error: GitHub CLI (gh) is not installed or not available in PATH.'));
+        console.log(chalk.yellow('Please install GitHub CLI from https://cli.github.com/'));
+        process.exit(1);
+    }
+    // Check if user is authenticated with GitHub CLI
+    try {
+        const authStatus = execSync('gh auth status -h github.com 2>&1 || true').toString();
+        if (authStatus.includes('not logged')) {
+            console.error(chalk.red('Error: You are not authenticated with GitHub CLI.'));
+            console.log(chalk.yellow('Please run `gh auth login` to authenticate.'));
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.log(chalk.yellow('Warning: Could not verify GitHub CLI authentication.'));
+        console.log(chalk.yellow('If PR creation fails, please run `gh auth login` first.'));
+    }
+    // Get configuration
+    const config = getConfig();
+    if (!config) {
+        console.error(chalk.red('GitPT is not configured. Please run "gitpt setup" first.'));
+        process.exit(1);
+    }
+    try {
+        const currentBranch = getCurrentBranch();
+        const baseBranch = options.base || getDefaultBaseBranch();
+        let title = options.title || '';
+        let body = options.body || '';
+        // Generate PR details if not provided
+        if (!title || !body) {
+            const generatedDetails = await generatePRDetails(baseBranch, currentBranch);
+            title = title || generatedDetails.title;
+            body = body || generatedDetails.body;
+            console.log(chalk.green('✓ PR details generated'));
+            console.log('');
+            console.log(chalk.cyan('Generated title:'));
+            console.log(title);
+            console.log('');
+            console.log(chalk.cyan('Generated description:'));
+            console.log(body);
+            console.log('');
+        }
+        // Allow editing PR details
+        if (options.edit !== false) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'title',
+                    message: 'Edit PR title:',
+                    default: title
+                },
+                {
+                    type: 'editor',
+                    name: 'body',
+                    message: 'Edit PR description:',
+                    default: body
+                },
+                {
+                    type: 'confirm',
+                    name: 'draft',
+                    message: 'Create as draft PR?',
+                    default: options.draft || false
+                }
+            ]);
+            title = answers.title;
+            body = answers.body;
+            const isDraft = answers.draft;
+            // Create the PR
+            createPullRequest(title, body, baseBranch, isDraft);
+        }
+        else {
+            // Create the PR without editing
+            createPullRequest(title, body, baseBranch, options.draft || false);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import chalk from 'chalk';
+import { execSync } from 'child_process';
 import { setupCommand } from './commands/setup.js';
 import { commitCommand } from './commands/commit.js';
 import { addCommand } from './commands/add.js';
+import { modelCommand } from './commands/model.js';
+import { prCreateCommand } from './commands/pr.js';
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
+import { isGitRepository } from './utils/git.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../package.json'), 'utf8'));
@@ -16,17 +20,21 @@ program
     .name('gitpt')
     .description('Git Prompt Tool helps you write commit messages using AI')
     .version(version);
-// Setup command
+// GitPT-specific commands
 program
     .command('setup')
     .description('Configure GitPT with your OpenRouter API key and model selection')
     .action(setupCommand);
-// Add command (pass-through to git add)
+program
+    .command('model [model-id]')
+    .description('Change the AI model used for generating commit messages')
+    .action(modelCommand);
+// Enhanced git commands
 program
     .command('add [files...]')
     .description('Add files to git staging area (pass-through to git add)')
+    .allowUnknownOption(true) // Pass through other git add options
     .action(addCommand);
-// Commit command
 program
     .command('commit')
     .description('Generate AI-powered commit message based on staged changes')
@@ -35,6 +43,34 @@ program
     .option('--no-edit', 'do not edit the message after generation')
     .allowUnknownOption(true) // Pass through other git commit options
     .action(commitCommand);
+program
+    .command('pr create')
+    .description('Create a pull request with AI-generated title and description')
+    .option('-t, --title <title>', 'Custom pull request title')
+    .option('-b, --body <body>', 'Custom pull request description')
+    .option('-d, --draft', 'Create as draft pull request')
+    .option('-B, --base <branch>', 'Base branch to create PR against')
+    .option('-e, --edit', 'Edit PR details before submission', true)
+    .option('--no-edit', 'Skip editing PR details')
+    .allowUnknownOption(true)
+    .action(prCreateCommand);
+// Handle unknown commands by passing them to git
+program.on('command:*', (operands) => {
+    if (!isGitRepository()) {
+        console.error(chalk.red('Error: Not a git repository'));
+        process.exit(1);
+    }
+    try {
+        // Get all arguments passed to the original command
+        const args = process.argv.slice(2);
+        // Execute git with all arguments
+        execSync(`git ${args.join(' ')}`, { stdio: 'inherit' });
+    }
+    catch (error) {
+        // Git will handle its own error output through stdio: 'inherit'
+        process.exit(1);
+    }
+});
 // Main logic
 async function main() {
     try {

package/dist/utils/api.d.ts

@@ -1 +1 @@
-export declare function generateCommitMessage(diff: string): Promise<string>;
+export declare function generateCommitMessage(diff: string, validationErrors?: string): Promise<string>;

package/dist/utils/api.js

@@ -1,7 +1,10 @@
-import fetch from 'node-fetch';
-import { getConfig } from './config.js';
-const OPENROUTER_API_URL = 'https://openrouter.ai/api/v1/chat/completions';
-export async function generateCommitMessage(diff) {
+import fetch from "node-fetch";
+import { getConfig } from "./config.js";
+import { hasCommitlintConfig, getCommitlintRules } from "./commitlint.js";
+const OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
+export async function generateCommitMessage(diff, validationErrors) {
+    // Check if commitlint is configured
+    const hasCommitlint = hasCommitlintConfig();
     const config = getConfig();
     if (!config) {
         throw new Error('GitPT is not configured. Please run "gitpt setup" first.');
@@ -9,31 +12,34 @@ export async function generateCommitMessage(diff) {
     const { apiKey, model } = config;
     const messages = [
         {
-            role: 'system',
-            content: `You are a helpful assistant that generates concise, informative Git commit messages. 
-      Follow conventional commit style. Be brief but descriptive. 
-      Focus on WHAT changes were made, WHY they were made, and their IMPACT.
-      Use present tense (e.g., "add feature" not "added feature").
-      Split the message like this if needed:
-      
-      feat(scope): short description
-      
-      More detailed explanation if necessary
-      
-      Only include a detailed explanation for complex changes.`
+            role: "system",
+            content: `You are a helpful assistant that generates concise, informative Git commit messages.
+      Follow these strict rules:
+      ${hasCommitlint ? getCommitlintRules() : `1. Use conventional commit format: type: description
+      2. Types are: feat, fix, docs, style, refactor, test, chore
+      3. NO scopes in parentheses - do not use feat(scope)
+      4. Keep the entire message under 100 characters
+      5. Use present tense (e.g., "add feature" not "added feature")
+      6. Be brief but descriptive about WHAT changed
+      7. Do not include detailed explanations
+      8. Examples:
+         - feat: add user authentication
+         - fix: resolve null pointer in login
+         - chore: update dependencies
+         - style: format css files`}${validationErrors ? `\n\nYOUR PREVIOUS MESSAGE FAILED VALIDATION WITH THESE ERRORS:\n${validationErrors}\n\nFIX THESE ISSUES IN YOUR NEW MESSAGE.` : ''}`,
         },
         {
-            role: 'user',
-            content: `Generate a commit message for the following git diff:\n\n${diff}`
-        }
+            role: "user",
+            content: `Generate a commit message for the following git diff:\n\n${diff}`,
+        },
     ];
     try {
         const response = await fetch(OPENROUTER_API_URL, {
-            method: 'POST',
+            method: "POST",
             headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-                'HTTP-Referer': 'https://github.com/bartaxyz/GitPT',
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${apiKey}`,
+                "HTTP-Referer": "https://github.com/bartaxyz/GitPT",
             },
             body: JSON.stringify({
                 model: model,
@@ -45,11 +51,11 @@ export async function generateCommitMessage(diff) {
             const errorText = await response.text();
             throw new Error(`API request failed: ${response.status} ${response.statusText}\n${errorText}`);
         }
-        const data = await response.json();
+        const data = (await response.json());
         return data.choices[0].message.content.trim();
     }
     catch (error) {
-        console.error('Error generating commit message:', error);
-        throw new Error('Failed to generate commit message');
+        console.error("Error generating commit message:", error);
+        throw new Error("Failed to generate commit message");
     }
 }

package/dist/utils/commitlint.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Represents a parsed commitlint configuration
+ */
+export interface CommitlintConfig {
+    rules?: Record<string, any>;
+    extends?: string | string[];
+}
+/**
+ * Check if a commitlint configuration exists in the repository
+ */
+export declare function hasCommitlintConfig(): boolean;
+/**
+ * Get the commitlint configuration format rules as a string
+ */
+export declare function getCommitlintRules(): string;
+/**
+ * Validate a commit message against commitlint rules
+ * @param message The commit message to validate
+ * @returns An object with success status and error message if applicable
+ */
+export declare function validateCommitMessage(message: string): Promise<{
+    valid: boolean;
+    errors?: string;
+}>;

package/dist/utils/commitlint.js

@@ -0,0 +1,124 @@
+import fs from 'fs';
+import { execSync } from 'child_process';
+/**
+ * Check if a commitlint configuration exists in the repository
+ */
+export function hasCommitlintConfig() {
+    const possibleConfigFiles = [
+        '.commitlintrc',
+        '.commitlintrc.json',
+        '.commitlintrc.yaml',
+        '.commitlintrc.yml',
+        '.commitlintrc.js',
+        'commitlint.config.js',
+        'package.json'
+    ];
+    // Check if any of the possible config files exist
+    return possibleConfigFiles.some(file => {
+        try {
+            if (file === 'package.json') {
+                const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+                return packageJson.commitlint !== undefined;
+            }
+            return fs.existsSync(file);
+        }
+        catch (error) {
+            return false;
+        }
+    });
+}
+/**
+ * Get the commitlint configuration format rules as a string
+ */
+export function getCommitlintRules() {
+    try {
+        // Try to get the rules using commitlint CLI if available
+        try {
+            const rulesOutput = execSync('npx commitlint --print-config', { stdio: ['ignore', 'pipe', 'ignore'] }).toString();
+            const config = JSON.parse(rulesOutput);
+            return formatCommitlintRules(config);
+        }
+        catch (error) {
+            // If CLI approach fails, try to find and parse config files manually
+            // This is a simplified approach - in a real implementation, you'd want to handle
+            // all possible config files and formats
+            if (fs.existsSync('commitlint.config.js')) {
+                // We can't directly require the JS file in ESM, so we'll return a generic message
+                return "Follow the conventional commit format (type(scope): message)";
+            }
+            if (fs.existsSync('.commitlintrc.json')) {
+                const config = JSON.parse(fs.readFileSync('.commitlintrc.json', 'utf8'));
+                return formatCommitlintRules(config);
+            }
+            // Default to conventional commits format if we can't parse the config
+            return "Follow the conventional commit format (type(scope): message)";
+        }
+    }
+    catch (error) {
+        // If all else fails, return a generic message
+        return "Follow the conventional commit format (type(scope): message)";
+    }
+}
+/**
+ * Format commitlint rules into a human-readable string
+ */
+function formatCommitlintRules(config) {
+    let rulesDescription = "Follow these commit message rules:\n";
+    if (!config.rules) {
+        return "Follow the conventional commit format (type(scope): message)";
+    }
+    // Extract type-enum rule if it exists
+    if (config.rules['type-enum'] && Array.isArray(config.rules['type-enum'][2])) {
+        const allowedTypes = config.rules['type-enum'][2];
+        rulesDescription += `- Commit type must be one of: ${allowedTypes.join(', ')}\n`;
+    }
+    // Extract other common rules
+    if (config.rules['scope-enum'] && Array.isArray(config.rules['scope-enum'][2])) {
+        const allowedScopes = config.rules['scope-enum'][2];
+        rulesDescription += `- Scope must be one of: ${allowedScopes.join(', ')}\n`;
+    }
+    if (config.rules['subject-case']) {
+        rulesDescription += `- Subject must follow case rules\n`;
+    }
+    if (config.rules['subject-max-length']) {
+        const maxLength = config.rules['subject-max-length'][2];
+        rulesDescription += `- Subject must be no longer than ${maxLength} characters\n`;
+    }
+    return rulesDescription;
+}
+/**
+ * Validate a commit message against commitlint rules
+ * @param message The commit message to validate
+ * @returns An object with success status and error message if applicable
+ */
+export async function validateCommitMessage(message) {
+    if (!hasCommitlintConfig()) {
+        // If no commitlint config, consider it valid
+        return { valid: true };
+    }
+    try {
+        // Create a temporary file with the message
+        const tempFile = `/tmp/gitpt-commit-msg-${Date.now()}`;
+        fs.writeFileSync(tempFile, message);
+        try {
+            // Run commitlint against the file
+            execSync(`npx commitlint --config commitlint.config.js < ${tempFile}`, { stdio: 'ignore' });
+            // If we get here, validation passed
+            fs.unlinkSync(tempFile); // Clean up temp file
+            return { valid: true };
+        }
+        catch (error) {
+            // Capture the error output for feedback
+            const errorOutput = execSync(`npx commitlint --config commitlint.config.js < ${tempFile} 2>&1 || true`).toString();
+            fs.unlinkSync(tempFile); // Clean up temp file
+            return {
+                valid: false,
+                errors: errorOutput
+            };
+        }
+    }
+    catch (error) {
+        // If we can't run commitlint, consider it valid to avoid blocking
+        return { valid: true };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitpt",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "CLI tool that helps you write commit messages & pull request descriptions using AI",
   "main": "dist/index.js",
   "type": "module",
@@ -48,5 +48,9 @@
     "configstore": "^7.0.0",
     "inquirer": "^12.5.2",
     "node-fetch": "^3.3.2"
+  },
+  "optionalDependencies": {
+    "@commitlint/cli": "^18.4.3",
+    "@commitlint/config-conventional": "^18.4.3"
   }
 }