gitpt 1.6.1 → 1.7.2

package/dist/services/git/getCommitsSinceBaseBranch.js

@@ -1,59 +1,31 @@
 import chalk from "chalk";
 import { execSync } from "child_process";
-export const 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 [];
-    }
+//#region src/services/git/getCommitsSinceBaseBranch.ts
+var getCommitsSinceBaseBranch = (baseBranch) => {
+	try {
+		try {
+			const commitMessages = execSync(`git log --pretty=format:"%s" ${execSync(`git merge-base HEAD origin/${baseBranch}`).toString().trim()}..HEAD`).toString().trim();
+			if (commitMessages) return commitMessages.split("\n").filter(Boolean);
+		} catch (error) {
+			console.log(chalk.yellow(`No origin/${baseBranch} found, trying with local ${baseBranch} branch...`));
+		}
+		try {
+			const commitMessages = execSync(`git log --pretty=format:"%s" ${execSync(`git merge-base HEAD ${baseBranch}`).toString().trim()}..HEAD`).toString().trim();
+			if (commitMessages) return commitMessages.split("\n").filter(Boolean);
+		} catch (error) {
+			console.log(chalk.yellow(`Merge base with ${baseBranch} not found, comparing branches directly...`));
+		}
+		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...`));
+		}
+		return execSync("git log --pretty=format:\"%s\" -n 10").toString().trim().split("\n").filter(Boolean);
+	} catch (error) {
+		console.error(chalk.yellow("Could not get commits. Using empty list."));
+		return [];
+	}
 };
+//#endregion
+export { getCommitsSinceBaseBranch };

package/dist/services/git/getCurrentBranch.js

@@ -1,11 +1,13 @@
 import chalk from "chalk";
 import { execSync } from "child_process";
-export const 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");
-    }
+//#region src/services/git/getCurrentBranch.ts
+var 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");
+	}
 };
+//#endregion
+export { getCurrentBranch };

package/dist/services/git/getDefaultBranch.js

@@ -1,63 +1,38 @@
 import chalk from "chalk";
 import { execSync } from "child_process";
-export const getDefaultBranch = () => {
-    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";
-    }
+//#region src/services/git/getDefaultBranch.ts
+var getDefaultBranch = () => {
+	try {
+		try {
+			const defaultBranch = execSync("git config init.defaultBranch").toString().trim();
+			if (defaultBranch) return defaultBranch;
+		} catch (error) {}
+		try {
+			const repoInfo = execSync("gh repo view --json defaultBranchRef --jq .defaultBranchRef.name").toString().trim();
+			if (repoInfo) return repoInfo;
+		} catch (error) {}
+		const branches = execSync("git branch -r").toString().trim().split("\n");
+		for (const pattern of [
+			/origin\/main$/,
+			/origin\/master$/,
+			/origin\/develop$/,
+			/origin\/dev$/,
+			/origin\/trunk$/
+		]) {
+			const defaultBranch = branches.find((b) => pattern.test(b.trim()));
+			if (defaultBranch) return defaultBranch.trim().replace(/^origin\//, "");
+		}
+		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];
+		}
+		console.log(chalk.yellow("Could not determine default branch, using \"main\""));
+		return "main";
+	} catch (error) {
+		console.log(chalk.yellow("Error detecting default branch, using \"main\""));
+		return "main";
+	}
 };
+//#endregion
+export { getDefaultBranch };

package/dist/services/git/getStagedChanges.js

@@ -1,11 +1,13 @@
 import chalk from "chalk";
 import { execSync } from "child_process";
-export const getStagedChanges = () => {
-    try {
-        return execSync("git diff --staged --function-context").toString();
-    }
-    catch (error) {
-        console.error(chalk.red("Error getting staged changes:"), error);
-        throw new Error("Failed to get staged changes");
-    }
+//#region src/services/git/getStagedChanges.ts
+var getStagedChanges = () => {
+	try {
+		return execSync("git diff --staged --function-context").toString();
+	} catch (error) {
+		console.error(chalk.red("Error getting staged changes:"), error);
+		throw new Error("Failed to get staged changes");
+	}
 };
+//#endregion
+export { getStagedChanges };

package/dist/services/git/getStagedFiles.js

@@ -1,12 +1,13 @@
 import chalk from "chalk";
 import { execSync } from "child_process";
-export const getStagedFiles = () => {
-    try {
-        const result = execSync("git diff --staged --name-only").toString();
-        return result.split("\n").filter(Boolean);
-    }
-    catch (error) {
-        console.error(chalk.red("Error getting staged files:"), error);
-        throw new Error("Failed to get staged files");
-    }
+//#region src/services/git/getStagedFiles.ts
+var getStagedFiles = () => {
+	try {
+		return execSync("git diff --staged --name-only").toString().split("\n").filter(Boolean);
+	} catch (error) {
+		console.error(chalk.red("Error getting staged files:"), error);
+		throw new Error("Failed to get staged files");
+	}
 };
+//#endregion
+export { getStagedFiles };

package/dist/services/git/hasStagedChanges.js

@@ -1,10 +1,11 @@
 import { execSync } from "child_process";
-export const hasStagedChanges = () => {
-    try {
-        const output = execSync('git diff --staged --quiet || echo "has-changes"').toString();
-        return output.includes("has-changes");
-    }
-    catch (error) {
-        return true; // Assume there are changes if we can't check
-    }
+//#region src/services/git/hasStagedChanges.ts
+var hasStagedChanges = () => {
+	try {
+		return execSync("git diff --staged --quiet || echo \"has-changes\"").toString().includes("has-changes");
+	} catch (error) {
+		return true;
+	}
 };
+//#endregion
+export { hasStagedChanges };

package/dist/services/git/index.js

@@ -1,6 +1,7 @@
 import { executeGitAdd } from "./executeGitAdd.js";
 import { executeGitCommit } from "./executeGitCommit.js";
 import { getChangedFiles } from "./getChangedFiles.js";
+import { getAmendChanges } from "./getAmendChanges.js";
 import { getCommitsSinceBaseBranch } from "./getCommitsSinceBaseBranch.js";
 import { getCurrentBranch } from "./getCurrentBranch.js";
 import { getDefaultBranch } from "./getDefaultBranch.js";
@@ -9,16 +10,20 @@ 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,
+//#region src/services/git/index.ts
+var git = {
+	add: executeGitAdd,
+	commit: executeGitCommit,
+	getAmendChanges,
+	getChangedFiles,
+	getCommitsSinceBaseBranch,
+	getCurrentBranch,
+	getDefaultBranch,
+	hasStagedChanges,
+	getStagedChanges,
+	getStagedFiles,
+	isAvailable,
+	isGitRepository
 };
+//#endregion
+export { git };

package/dist/services/git/isAvailable.js

@@ -1,10 +1,12 @@
 import { execSync } from "child_process";
-export const isAvailable = () => {
-    try {
-        execSync("git --version", { stdio: "ignore" });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
+//#region src/services/git/isAvailable.ts
+var isAvailable = () => {
+	try {
+		execSync("git --version", { stdio: "ignore" });
+		return true;
+	} catch (error) {
+		return false;
+	}
 };
+//#endregion
+export { isAvailable };

package/dist/services/git/isGitRepository.js

@@ -1,10 +1,12 @@
 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;
-    }
+//#region src/services/git/isGitRepository.ts
+var isGitRepository = () => {
+	try {
+		execSync("git rev-parse --is-inside-work-tree", { stdio: "ignore" });
+		return true;
+	} catch (error) {
+		return false;
+	}
 };
+//#endregion
+export { isGitRepository };

package/dist/utils/commitlint.js

@@ -1,148 +1,110 @@
-import loadConfig from "@commitlint/load";
 import { execSync } from "child_process";
+import loadConfig from "@commitlint/load";
 import fs from "fs";
+//#region src/utils/commitlint.ts
 /**
- * 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;
-        }
-    });
+* Check if a commitlint configuration exists in the repository
+*/
+function hasCommitlintConfig() {
+	const possibleConfigFiles = [
+		".commitlintrc",
+		".commitlintrc.json",
+		".commitlintrc.yaml",
+		".commitlintrc.yml",
+		".commitlintrc.js",
+		"commitlint.config.js",
+		"package.json"
+	];
+	readCommitlintConfig();
+	return possibleConfigFiles.some((file) => {
+		try {
+			if (file === "package.json") return JSON.parse(fs.readFileSync("package.json", "utf8")).commitlint !== void 0;
+			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;
+* Read commitlint config file (using @commitlint/load) and print it out
+*/
+async function readCommitlintConfig() {
+	return (await loadConfig()).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)";
-    }
+* Get the commitlint configuration format rules as a string
+*/
+function getCommitlintRules() {
+	try {
+		try {
+			const rulesOutput = execSync("npx commitlint --print-config", { stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			] }).toString();
+			return formatCommitlintRules(JSON.parse(rulesOutput));
+		} catch (error) {
+			if (fs.existsSync("commitlint.config.js")) return "Follow the conventional commit format (type(scope): message)";
+			if (fs.existsSync(".commitlintrc.json")) return formatCommitlintRules(JSON.parse(fs.readFileSync(".commitlintrc.json", "utf8")));
+			return "Follow the conventional commit format (type(scope): message)";
+		}
+	} catch (error) {
+		return "Follow the conventional commit format (type(scope): message)";
+	}
 }
 /**
- * Format commitlint rules into a human-readable string
- */
+* 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;
+	let rulesDescription = "Follow these commit message rules:\n";
+	if (!config.rules) return "Follow the conventional commit format (type(scope): message)";
+	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["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 };
-    }
+* 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
+*/
+async function validateCommitMessage(message) {
+	if (!hasCommitlintConfig()) return { valid: true };
+	try {
+		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) {
+			try {
+				const errorOutput = execSync(`npx commitlint < ${tempFile} 2>&1 || true`).toString();
+				fs.unlinkSync(tempFile);
+				return {
+					valid: false,
+					errors: errorOutput
+				};
+			} catch (e) {
+				fs.unlinkSync(tempFile);
+				return { valid: true };
+			}
+		}
+	} catch (error) {
+		console.warn("Warning: Could not validate with commitlint, performing basic validation");
+		return { valid: true };
+	}
 }
+//#endregion
+export { getCommitlintRules, hasCommitlintConfig, validateCommitMessage };

package/dist/utils/formatBaseURL.js

@@ -1,7 +1,8 @@
-export const formatBaseURL = (baseURL) => {
-    // If it doesn't end with /v1, add it
-    if (!baseURL.endsWith("/v1")) {
-        return `${baseURL}/v1`;
-    }
-    return baseURL;
+//#region src/utils/formatBaseURL.ts
+var formatBaseURL = (baseURL) => {
+	const trimmed = baseURL.replace(/\/+$/, "");
+	if (!trimmed.endsWith("/v1")) return `${trimmed}/v1`;
+	return trimmed;
 };
+//#endregion
+export { formatBaseURL };

package/dist/utils/maskApiKey.js

@@ -1,8 +1,7 @@
-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}`;
+//#region src/utils/maskApiKey.ts
+var maskApiKey = (apiKey) => {
+	if (apiKey.length <= 10) return "*".repeat(apiKey.length);
+	return `${apiKey.substring(0, 4)}...${apiKey.substring(apiKey.length - 4)}`;
 };
+//#endregion
+export { maskApiKey };