gitpt 1.1.0 → 1.2.0

package/README.md

@@ -6,10 +6,15 @@ Git Prompt Tool is a CLI tool that helps you write commit messages using AI thro
 
 - Acts as a complete git replacement - all git commands are supported
 - Generate commit messages with AI based on your code changes
+
+  `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
 
@@ -59,14 +64,8 @@ gitpt merge --no-ff feature-branch
 Add files to the staging area just like you would with git:
 
 ```bash
-# Same as git add .
+# Same as git add . (supports all the regular git add options)
 gitpt add .
-
-# Same as git add -p
-gitpt add -p
-
-# Same as git add src/*.ts
-gitpt add src/*.ts
 ```
 
 ### Creating Commits
@@ -75,14 +74,22 @@ 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
 
 ### Changing Models
 
@@ -99,20 +106,9 @@ gitpt model openai/gpt-4o
 gitpt model anthropic/claude-3-haiku
 ```
 
-### Commit Options
-
-You can use any standard git commit options with the `gitpt commit` command:
-
-```bash
-# Skip editing the message
-gitpt commit --no-edit
-
-# Provide your own message instead of generating one
-gitpt commit -m "Your message here"
+## GitHub Usage
 
-# Pass any other git commit options
-gitpt commit --amend
-```
+If you have GitHub CLI (`gh`) installed, you can use GitPT to interact with GitHub (e.g. generate full pull requests).
 
 ### Creating Pull Requests
 
@@ -145,8 +141,6 @@ gitpt pr create --no-edit
 gitpt pr create --title "Your PR title here"
 ```
 
-> **Note:** This command requires GitHub CLI (`gh`) to be installed and authenticated.
-
 ## How It Works
 
 GitPT leverages AI via OpenRouter to enhance your Git workflow while acting as a complete git wrapper:
@@ -155,6 +149,8 @@ GitPT leverages AI via OpenRouter to enhance your Git workflow while acting as a
 
 - **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.
@@ -176,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/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";
+import { hasCommitlintConfig, getCommitlintRules } from "./commitlint.js";
 const OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions";
-export async function generateCommitMessage(diff) {
+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.');
@@ -12,7 +15,7 @@ export async function generateCommitMessage(diff) {
             role: "system",
             content: `You are a helpful assistant that generates concise, informative Git commit messages.
       Follow these strict rules:
-      1. Use conventional commit format: type: description
+      ${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
@@ -23,7 +26,7 @@ export async function generateCommitMessage(diff) {
          - feat: add user authentication
          - fix: resolve null pointer in login
          - chore: update dependencies
-         - style: format css files`,
+         - 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",

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.1.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"
   }
 }