gitpt 1.1.0 → 1.3.0

package/dist/services/git/index.js

@@ -0,0 +1,24 @@
+import { executeGitAdd } from "./executeGitAdd.js";
+import { executeGitCommit } from "./executeGitCommit.js";
+import { getChangedFiles } from "./getChangedFiles.js";
+import { getCommitsSinceBaseBranch } from "./getCommitsSinceBaseBranch.js";
+import { getCurrentBranch } from "./getCurrentBranch.js";
+import { getDefaultBranch } from "./getDefaultBranch.js";
+import { getStagedChanges } from "./getStagedChanges.js";
+import { getStagedFiles } from "./getStagedFiles.js";
+import { hasStagedChanges } from "./hasStagedChanges.js";
+import { isAvailable } from "./isAvailable.js";
+import { isGitRepository } from "./isGitRepository.js";
+export const git = {
+    add: executeGitAdd,
+    commit: executeGitCommit,
+    getChangedFiles,
+    getCommitsSinceBaseBranch,
+    getCurrentBranch,
+    getDefaultBranch,
+    hasStagedChanges,
+    getStagedChanges,
+    getStagedFiles,
+    isAvailable,
+    isGitRepository,
+};

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

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

package/dist/services/git/isAvailable.js

@@ -0,0 +1,10 @@
+import { execSync } from "child_process";
+export const isAvailable = () => {
+    try {
+        execSync("git --version", { stdio: "ignore" });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+};

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

@@ -0,0 +1,25 @@
+export interface CommitlintConfig {
+    rules?: Record<string, any>;
+    extends?: string | string[];
+}
+/**
+ * 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
+ */
+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,148 @@
+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",
+    ];
+    // Temporary
+    readCommitlintConfig();
+    // 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;
+        }
+    });
+}
+/**
+ * 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
+ */
+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`;
+    }
+    rulesDescription +=
+        "- Use a single commit message, not multiple messages separated by blank lines or markdown formatting";
+    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 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 {
+            execSync(`npx commitlint < ${tempFile}`, { stdio: "ignore" });
+            fs.unlinkSync(tempFile);
+            return { valid: true };
+        }
+        catch (error) {
+            // 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 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.1.0",
+  "version": "1.3.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,14 +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"
+    "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,74 +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';
-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...'));
-            // Generate commit message
-            commitMessage = await generateCommitMessage(diff);
-            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);
-    }
-}