gitpt 1.2.0 → 1.4.0

package/dist/services/git/isGitRepository.d.ts

@@ -0,0 +1 @@
+export declare const isGitRepository: () => boolean;

package/dist/services/git/isGitRepository.js

@@ -0,0 +1,10 @@
+import { execSync } from "child_process";
+export const isGitRepository = () => {
+    try {
+        execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};

package/dist/utils/commitlint.d.ts

@@ -1,6 +1,3 @@
-/**
- * Represents a parsed commitlint configuration
- */
 export interface CommitlintConfig {
     rules?: Record<string, any>;
     extends?: string | string[];
@@ -9,6 +6,10 @@ export interface CommitlintConfig {
  * Check if a commitlint configuration exists in the repository
  */
 export declare function hasCommitlintConfig(): boolean;
+/**
+ * Read commitlint config file (using @commitlint/load) and print it out
+ */
+export declare function readCommitlintConfig(): Promise<any>;
 /**
  * Get the commitlint configuration format rules as a string
  */

package/dist/utils/commitlint.js

@@ -1,23 +1,26 @@
-import fs from 'fs';
-import { execSync } from 'child_process';
+import loadConfig from "@commitlint/load";
+import { execSync } from "child_process";
+import fs from "fs";
 /**
  * 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'
+        ".commitlintrc",
+        ".commitlintrc.json",
+        ".commitlintrc.yaml",
+        ".commitlintrc.yml",
+        ".commitlintrc.js",
+        "commitlint.config.js",
+        "package.json",
     ];
+    // Temporary
+    readCommitlintConfig();
     // Check if any of the possible config files exist
-    return possibleConfigFiles.some(file => {
+    return possibleConfigFiles.some((file) => {
         try {
-            if (file === 'package.json') {
-                const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+            if (file === "package.json") {
+                const packageJson = JSON.parse(fs.readFileSync("package.json", "utf8"));
                 return packageJson.commitlint !== undefined;
             }
             return fs.existsSync(file);
@@ -27,6 +30,14 @@ export function hasCommitlintConfig() {
         }
     });
 }
+/**
+ * Read commitlint config file (using @commitlint/load) and print it out
+ */
+export async function readCommitlintConfig() {
+    const config = await loadConfig();
+    // console.log(config);
+    return config.rules;
+}
 /**
  * Get the commitlint configuration format rules as a string
  */
@@ -34,7 +45,9 @@ 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 rulesOutput = execSync("npx commitlint --print-config", {
+                stdio: ["ignore", "pipe", "ignore"],
+            }).toString();
             const config = JSON.parse(rulesOutput);
             return formatCommitlintRules(config);
         }
@@ -42,12 +55,12 @@ export function getCommitlintRules() {
             // 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')) {
+            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'));
+            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
@@ -68,22 +81,26 @@ function formatCommitlintRules(config) {
         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`;
+    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["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']) {
+    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];
+    if (config.rules["subject-max-length"]) {
+        const maxLength = config.rules["subject-max-length"][2];
         rulesDescription += `- Subject must be no longer than ${maxLength} characters\n`;
     }
+    rulesDescription +=
+        "- Use a single commit message, not multiple messages separated by blank lines or markdown formatting";
     return rulesDescription;
 }
 /**
@@ -93,32 +110,39 @@ function formatCommitlintRules(config) {
  */
 export async function validateCommitMessage(message) {
     if (!hasCommitlintConfig()) {
-        // If no commitlint config, consider it valid
+        // If no commitlint config exists, consider it valid
         return { valid: true };
     }
+    // Using CLI approach
     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
+            execSync(`npx commitlint < ${tempFile}`, { stdio: "ignore" });
+            fs.unlinkSync(tempFile);
             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
-            };
+            // It's likely a validation error, capture the output
+            try {
+                const errorOutput = execSync(`npx commitlint < ${tempFile} 2>&1 || true`).toString();
+                fs.unlinkSync(tempFile);
+                return {
+                    valid: false,
+                    errors: errorOutput,
+                };
+            }
+            catch (e) {
+                // If we still can't get error output, fall back to basic pattern check
+                fs.unlinkSync(tempFile);
+                return { valid: true };
+            }
         }
     }
     catch (error) {
-        // If we can't run commitlint, consider it valid to avoid blocking
+        // If all else fails, just do a basic regex check
+        console.warn("Warning: Could not validate with commitlint, performing basic validation");
         return { valid: true };
     }
 }

package/dist/utils/formatBaseURL.d.ts

@@ -0,0 +1 @@
+export declare const formatBaseURL: (baseURL: string) => string;

package/dist/utils/formatBaseURL.js

@@ -0,0 +1,7 @@
+export const formatBaseURL = (baseURL) => {
+    // If it doesn't end with /v1, add it
+    if (!baseURL.endsWith("/v1")) {
+        return `${baseURL}/v1`;
+    }
+    return baseURL;
+};

package/dist/utils/maskApiKey.d.ts

@@ -0,0 +1 @@
+export declare const maskApiKey: (apiKey: string) => string;

package/dist/utils/maskApiKey.js

@@ -0,0 +1,8 @@
+export const maskApiKey = (apiKey) => {
+    if (apiKey.length <= 10) {
+        return "*".repeat(apiKey.length);
+    }
+    const firstFour = apiKey.substring(0, 4);
+    const lastFour = apiKey.substring(apiKey.length - 4);
+    return `${firstFour}...${lastFour}`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitpt",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "CLI tool that helps you write commit messages & pull request descriptions using AI",
   "main": "dist/index.js",
   "type": "module",
@@ -13,10 +13,9 @@
     "LICENSE"
   ],
   "scripts": {
+    "typecheck": "tsc --noEmit",
     "build": "tsc",
-    "dev": "ts-node --esm src/index.ts",
-    "start": "node dist/index.js",
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "npm run typecheck",
     "prepublishOnly": "npm run build"
   },
   "repository": {
@@ -39,18 +38,18 @@
     "@types/inquirer": "^9.0.7",
     "@types/node": "^22.14.1",
     "@types/node-fetch": "^2.6.12",
-    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@commitlint/load": "^19.8.1",
     "chalk": "^5.4.1",
     "commander": "^13.1.0",
     "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"
+    "node-fetch": "^3.3.2",
+    "openai": "^4.100.0"
   }
 }

package/dist/commands/add.d.ts

@@ -1 +0,0 @@
-export declare function addCommand(files: string[]): void;

package/dist/commands/add.js

@@ -1,16 +0,0 @@
-import chalk from 'chalk';
-import { isGitRepository, executeGitAdd } from '../utils/git.js';
-export function addCommand(files) {
-    if (!isGitRepository()) {
-        console.error(chalk.red('Error: Not a git repository'));
-        process.exit(1);
-    }
-    try {
-        executeGitAdd(files);
-        console.log(chalk.green('Files added to staging area'));
-    }
-    catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}

package/dist/commands/commit.js

@@ -1,99 +0,0 @@
-import inquirer from 'inquirer';
-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'));
-        process.exit(1);
-    }
-    // Check if config exists
-    const config = getConfig();
-    if (!config) {
-        console.error(chalk.red('GitPT is not configured. Please run "gitpt setup" first.'));
-        process.exit(1);
-    }
-    // Check if there are staged changes
-    if (!hasStagedChanges()) {
-        console.error(chalk.yellow('No staged changes. Use "git add" or "gitpt add" to stage changes first.'));
-        process.exit(1);
-    }
-    let commitMessage;
-    // If message is provided, use that
-    if (options.message) {
-        commitMessage = options.message;
-    }
-    else {
-        try {
-            // 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:'));
-            console.log(commitMessage);
-            console.log('');
-        }
-        catch (error) {
-            console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
-            process.exit(1);
-        }
-    }
-    // If edit is true or not specified, prompt user to edit the message
-    if (options.edit !== false) {
-        const answer = await inquirer.prompt([
-            {
-                type: 'editor',
-                name: 'message',
-                message: 'Edit commit message:',
-                default: commitMessage
-            }
-        ]);
-        commitMessage = answer.message;
-    }
-    // Extract other git options to pass through
-    const gitOptions = Object.keys(options)
-        .filter(key => !['message', 'edit'].includes(key))
-        .map(key => {
-        if (typeof options[key] === 'boolean') {
-            return options[key] ? `--${key}` : `--no-${key}`;
-        }
-        return `--${key}=${options[key]}`;
-    });
-    try {
-        executeGitCommit(commitMessage, gitOptions);
-        console.log(chalk.green('✓ Changes committed successfully'));
-    }
-    catch (error) {
-        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
-        process.exit(1);
-    }
-}