gitpt 1.4.0 → 1.7.2

package/dist/commands/commit/index.js

@@ -1,183 +1,192 @@
-import chalk from "chalk";
-import inquirer from "inquirer";
+import { git } from "../../services/git/index.js";
 import { capabilitiesMiddleware } from "../middleware/capabilitiesMiddleware/index.js";
+import { isDebug } from "../../config.js";
 import { setupMiddleware } from "../middleware/setupMiddleware/index.js";
-import { git } from "../../services/git/index.js";
-import { hasCommitlintConfig, validateCommitMessage, } from "../../utils/commitlint.js";
+import { hasCommitlintConfig, validateCommitMessage } from "../../utils/commitlint.js";
 import { hasStagedChangesMiddleware } from "../middleware/hasStagedChangesMiddleware.js";
 import { generateCommitMessage } from "./generateCommitMessage.js";
-export const commitCommand = async (options) => {
-    capabilitiesMiddleware(["git"]);
-    await setupMiddleware();
-    hasStagedChangesMiddleware();
-    let commitMessage;
-    // If message is provided, use that
-    if (options.message) {
-        commitMessage = options.message;
-    }
-    else {
-        try {
-            // Get staged changes
-            const diff = git.getStagedChanges();
-            console.log(chalk.blue("Generating commit message..."));
-            // Check if commitlint is configured
-            let hasCommitlint = false;
-            try {
-                hasCommitlint = hasCommitlintConfig();
-                if (hasCommitlint) {
-                    console.log(chalk.blue("Commitlint configuration detected. Generating message according to rules..."));
-                }
-            }
-            catch (error) {
-                console.warn(chalk.yellow("Warning: Error detecting commitlint config, proceeding without commitlint validation."));
-            }
-            // Generate first commit message
-            commitMessage = await generateCommitMessage(diff);
-            // If commitlint is configured, try to validate and regenerate up to 3 times
-            if (hasCommitlint) {
-                try {
-                    console.log(chalk.blue("Validating commit message against commitlint rules..."));
-                    // Try up to 3 times to get a valid message
-                    let validMessage = false;
-                    let attempts = 0;
-                    const MAX_ATTEMPTS = 3;
-                    let validationErrors;
-                    while (!validMessage && attempts < MAX_ATTEMPTS) {
-                        const validation = await validateCommitMessage(commitMessage);
-                        if (validation.valid) {
-                            console.log(chalk.green("✓ Commit message passed validation"));
-                            validMessage = true;
-                            break;
-                        }
-                        else {
-                            attempts++;
-                            console.log(chalk.yellow(`Commit message failed validation. ${attempts < MAX_ATTEMPTS
-                                ? "Regenerating..."
-                                : "Max attempts reached."}`));
-                            if (validation.errors) {
-                                console.log(chalk.gray(validation.errors));
-                                validationErrors = validation.errors;
-                            }
-                            if (attempts < MAX_ATTEMPTS) {
-                                // Try regenerating with validation errors
-                                try {
-                                    commitMessage = await generateCommitMessage(diff, validationErrors);
-                                }
-                                catch (error) {
-                                    console.warn(chalk.yellow("Error regenerating message, breaking validation loop."));
-                                    break;
-                                }
-                            }
-                            else {
-                                // Ask user what to do after max attempts
-                                const { action } = await inquirer.prompt([
-                                    {
-                                        type: "list",
-                                        name: "action",
-                                        message: "Failed to generate a valid commit message after 3 attempts. What would you like to do?",
-                                        choices: [
-                                            {
-                                                name: "Proceed with invalid message",
-                                                value: "proceed",
-                                            },
-                                            { name: "Edit message manually", value: "edit" },
-                                            { name: "Abort commit", value: "abort" },
-                                        ],
-                                    },
-                                ]);
-                                if (action === "abort") {
-                                    console.log(chalk.red("Commit aborted due to validation failures."));
-                                    process.exit(1);
-                                }
-                                else if (action === "edit") {
-                                    options.edit = true; // Force editor to open
-                                }
-                                else {
-                                    console.log(chalk.yellow("Proceeding with invalid message..."));
-                                }
-                                break;
-                            }
-                        }
-                    }
-                }
-                catch (error) {
-                    // If there's an error with commitlint validation, continue without it
-                    console.warn(chalk.yellow("Warning: Error during commitlint validation, proceeding without validation."));
-                    console.warn(chalk.gray("This may be due to an ESM module cycle conflict or missing commitlint dependencies."));
-                }
-            }
-            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;
-        // Validate the edited message once
-        try {
-            const hasCommitlint = hasCommitlintConfig();
-            if (hasCommitlint) {
-                console.log(chalk.blue("Validating edited commit message..."));
-                const validation = await validateCommitMessage(commitMessage);
-                if (!validation.valid) {
-                    console.log(chalk.yellow("Warning: Edited message still has validation issues."));
-                    if (validation.errors) {
-                        console.log(chalk.gray(validation.errors));
-                    }
-                    // Ask if user wants to proceed anyway
-                    const { proceed } = await inquirer.prompt([
-                        {
-                            type: "confirm",
-                            name: "proceed",
-                            message: "Proceed with invalid commit message?",
-                            default: false,
-                        },
-                    ]);
-                    if (!proceed) {
-                        console.log(chalk.red("Commit aborted by user."));
-                        process.exit(1);
-                    }
-                }
-                else {
-                    console.log(chalk.green("✓ Edited message passed validation"));
-                }
-            }
-        }
-        catch (error) {
-            // If validation fails, just warn and continue
-            console.warn(chalk.yellow("Could not validate edited message, proceeding anyway."));
-        }
-    }
-    // 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 {
-        git.commit(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);
-    }
+import { prepareCommitContext } from "./summarizeDiff.js";
+import { isAmend, skipsStagedGuard } from "./commitFlags.js";
+import { passthroughArgs } from "../passthroughArgs.js";
+import chalk from "chalk";
+import inquirer from "inquirer";
+//#region src/commands/commit/index.ts
+var commitCommand = async (options, command) => {
+	if (options.debug) ({}).GITPT_DEBUG = "1";
+	capabilitiesMiddleware(["git"]);
+	await setupMiddleware();
+	const passthrough = passthroughArgs(command);
+	const amend = isAmend(passthrough);
+	const noEdit = options.edit === false;
+	if (!skipsStagedGuard(passthrough)) hasStagedChangesMiddleware();
+	if (amend && noEdit && !options.message) {
+		if (options.dryRun) {
+			console.log(chalk.yellow("[dry-run] Would amend the last commit (keeping its message). Nothing changed."));
+			return;
+		}
+		try {
+			git.commit(null, [...passthrough, "--no-edit"]);
+			console.log(chalk.green("✓ Amended (kept the original message)."));
+		} catch (error) {
+			console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		return;
+	}
+	let commitMessage;
+	let context;
+	if (options.message) commitMessage = options.message;
+	else try {
+		const diff = amend ? git.getAmendChanges() : git.getStagedChanges();
+		if (!diff.trim()) {
+			console.error(chalk.red("Error: nothing to summarise. Provide a message with -m \"...\"."));
+			process.exit(1);
+		}
+		context = await prepareCommitContext(diff);
+		console.log(chalk.blue("Generating commit message..."));
+		let hasCommitlint = false;
+		try {
+			hasCommitlint = hasCommitlintConfig();
+			if (hasCommitlint) console.log(chalk.blue("Commitlint configuration detected. Generating message according to rules..."));
+		} catch (error) {
+			console.warn(chalk.yellow("Warning: Error detecting commitlint config, proceeding without commitlint validation."));
+		}
+		const startedAt = Date.now();
+		commitMessage = await generateCommitMessage(context);
+		if (isDebug()) console.log(chalk.gray(`⚙ debug · ~${Math.ceil(context.length / 3)} context tokens · generated in ${Date.now() - startedAt}ms`));
+		if (hasCommitlint) try {
+			console.log(chalk.blue("Validating commit message against commitlint rules..."));
+			let validMessage = false;
+			let attempts = 0;
+			const MAX_ATTEMPTS = 3;
+			let validationErrors;
+			while (!validMessage && attempts < MAX_ATTEMPTS) {
+				const validation = await validateCommitMessage(commitMessage);
+				if (validation.valid) {
+					console.log(chalk.green("✓ Commit message passed validation"));
+					validMessage = true;
+					break;
+				} else {
+					attempts++;
+					console.log(chalk.yellow(`Commit message failed validation. ${attempts < MAX_ATTEMPTS ? "Regenerating..." : "Max attempts reached."}`));
+					if (validation.errors) {
+						console.log(chalk.gray(validation.errors));
+						validationErrors = validation.errors;
+					}
+					if (attempts < MAX_ATTEMPTS) try {
+						commitMessage = await generateCommitMessage(context, validationErrors);
+					} catch (error) {
+						console.warn(chalk.yellow("Error regenerating message, breaking validation loop."));
+						break;
+					}
+					else {
+						const { action } = await inquirer.prompt([{
+							type: "list",
+							name: "action",
+							message: "Failed to generate a valid commit message after 3 attempts. What would you like to do?",
+							choices: [
+								{
+									name: "Proceed with invalid message",
+									value: "proceed"
+								},
+								{
+									name: "Edit message manually",
+									value: "edit"
+								},
+								{
+									name: "Abort commit",
+									value: "abort"
+								}
+							]
+						}]);
+						if (action === "abort") {
+							console.log(chalk.red("Commit aborted due to validation failures."));
+							process.exit(1);
+						} else if (action === "edit") options.edit = true;
+						else console.log(chalk.yellow("Proceeding with invalid message..."));
+						break;
+					}
+				}
+			}
+		} catch (error) {
+			console.warn(chalk.yellow("Warning: Error during commitlint validation, proceeding without validation."));
+			console.warn(chalk.gray("This may be due to an ESM module cycle conflict or missing commitlint dependencies."));
+		}
+		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 (options.dryRun) return;
+	if (options.edit !== false && !options.message && context !== void 0) {
+		let confirmed = false;
+		while (!confirmed) {
+			const { action } = await inquirer.prompt([{
+				type: "list",
+				name: "action",
+				message: "Use this commit message?",
+				choices: [
+					{
+						name: "Confirm and commit",
+						value: "confirm"
+					},
+					{
+						name: "Generate another (different wording)",
+						value: "another"
+					},
+					{
+						name: "Edit manually",
+						value: "edit"
+					},
+					{
+						name: "Cancel",
+						value: "cancel"
+					}
+				]
+			}]);
+			if (action === "confirm") confirmed = true;
+			else if (action === "another") {
+				commitMessage = (await generateCommitMessage(`${context}\n\nWrite a noticeably different commit message — a fresh wording or angle, not the same as before.`)).trim();
+				console.log("");
+				console.log(chalk.cyan("Generated message:"));
+				console.log(commitMessage);
+				console.log("");
+			} else if (action === "edit") {
+				commitMessage = (await inquirer.prompt([{
+					type: "editor",
+					name: "message",
+					message: "Edit commit message:",
+					default: commitMessage
+				}])).message;
+				confirmed = true;
+			} else {
+				console.log(chalk.gray("Commit cancelled."));
+				process.exit(0);
+			}
+		}
+		try {
+			if (hasCommitlintConfig()) {
+				const validation = await validateCommitMessage(commitMessage);
+				if (!validation.valid) {
+					console.log(chalk.yellow("Warning: Edited message still has validation issues."));
+					if (validation.errors) console.log(chalk.gray(validation.errors));
+				}
+			}
+		} catch (error) {
+			console.warn(chalk.yellow("Could not validate edited message, proceeding anyway."));
+		}
+	}
+	try {
+		git.commit(commitMessage, passthrough);
+		console.log(chalk.green("✓ Changes committed successfully"));
+	} catch (error) {
+		console.error(chalk.red("Error:"), error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
 };
+//#endregion
+export { commitCommand };

package/dist/commands/commit/summarizeDiff.js

@@ -0,0 +1,193 @@
+import { getProvider } from "../../llm/registry.js";
+import { systemPrompt } from "./context/systemPrompt.js";
+import { userPrompt } from "./context/userPrompt.js";
+import { countTokens } from "../../llm/tokenCount.js";
+import { fitBudget } from "../../llm/budget.js";
+import { summarySystemPrompt, summaryUserPrompt } from "./context/summaryPrompt.js";
+import ora from "ora";
+//#region src/commands/commit/summarizeDiff.ts
+var MAX_REDUCE_PASSES = 3;
+var LOW_SIGNAL_PATTERNS = [
+	{
+		test: /(^|\/)package-lock\.json$/,
+		note: "dependency lockfile updated"
+	},
+	{
+		test: /(^|\/)npm-shrinkwrap\.json$/,
+		note: "dependency lockfile updated"
+	},
+	{
+		test: /(^|\/)yarn\.lock$/,
+		note: "dependency lockfile updated"
+	},
+	{
+		test: /(^|\/)pnpm-lock\.yaml$/,
+		note: "dependency lockfile updated"
+	},
+	{
+		test: /\.lock$/,
+		note: "dependency lockfile updated"
+	},
+	{
+		test: /(^|\/)(dist|build|out|coverage)\//,
+		note: "generated output updated"
+	},
+	{
+		test: /\.min\.(js|css)$/,
+		note: "minified asset updated"
+	},
+	{
+		test: /\.(snap)$/,
+		note: "test snapshot updated"
+	},
+	{
+		test: /(^|\/)snapshots?\//,
+		note: "test snapshot updated"
+	},
+	{
+		test: /\.(patch|diff)$/,
+		note: "patch file updated"
+	}
+];
+var lowSignalNote = (file) => LOW_SIGNAL_PATTERNS.find((p) => p.test.test(file))?.note ?? null;
+var finalPromptTokens = (context) => countTokens(`${systemPrompt}\n\n${userPrompt(context)}`);
+var splitIntoFileBlocks = (diff) => diff.split(/(?=^diff --git )/m).filter((part) => part.trim().length > 0);
+var fileNameOf = (block) => {
+	const match = block.match(/^diff --git a\/(.+?) b\//m);
+	return match ? match[1] : "changes";
+};
+var truncateToBudget = (file, content, budget) => {
+	if (countTokens(content) <= budget) return content;
+	const marker = `\n... [truncated ${file} to fit context] ...\n`;
+	let keep = content.length;
+	let truncated = content;
+	while (countTokens(truncated) > budget && keep > 200) {
+		keep = Math.floor(keep * .7);
+		truncated = content.slice(0, keep) + marker;
+	}
+	return truncated;
+};
+var splitBlockByHunks = (file, content, budget) => {
+	const firstHunk = content.search(/^@@ /m);
+	if (firstHunk < 0) return [{
+		files: [file],
+		content: truncateToBudget(file, content, budget)
+	}];
+	const header = content.slice(0, firstHunk);
+	const hunks = content.slice(firstHunk).split(/(?=^@@ )/m).filter((h) => h.length > 0);
+	const chunks = [];
+	let current = "";
+	const flush = () => {
+		if (current) {
+			chunks.push({
+				files: [file],
+				content: truncateToBudget(file, header + current, budget)
+			});
+			current = "";
+		}
+	};
+	for (const hunk of hunks) {
+		if (current && countTokens(header + current + hunk) > budget) flush();
+		current += hunk;
+	}
+	flush();
+	return chunks;
+};
+var packChunks = (blocks, budget) => {
+	const chunks = [];
+	let files = [];
+	let content = "";
+	let tokens = 0;
+	const flush = () => {
+		if (content) {
+			chunks.push({
+				files,
+				content
+			});
+			files = [];
+			content = "";
+			tokens = 0;
+		}
+	};
+	for (const block of blocks) {
+		if (block.tokens > budget) {
+			flush();
+			chunks.push(...splitBlockByHunks(block.file, block.content, budget));
+			continue;
+		}
+		if (content && tokens + block.tokens > budget) flush();
+		files.push(block.file);
+		content += block.content;
+		tokens += block.tokens;
+	}
+	flush();
+	return chunks;
+};
+var summarizeChunk = async (content) => {
+	const provider = getProvider();
+	return (await provider.complete({
+		system: summarySystemPrompt,
+		user: summaryUserPrompt(content),
+		maxTokens: provider.maxOutputTokens
+	})).trim();
+};
+var prepareCommitContext = async (diff) => {
+	const reserved = getProvider().maxOutputTokens;
+	const window = await getProvider().getContextWindow();
+	if (!Number.isFinite(window)) return diff;
+	const promptBudget = fitBudget(window, reserved);
+	if (finalPromptTokens(diff) <= promptBudget) return diff;
+	const spinner = ora({ text: "Analyzing diff size..." }).start();
+	try {
+		const blocks = splitIntoFileBlocks(diff).map((content) => ({
+			file: fileNameOf(content),
+			content,
+			tokens: countTokens(content)
+		}));
+		const totalTokens = blocks.reduce((sum, b) => sum + b.tokens, 0);
+		const sourceBlocks = blocks.filter((b) => !lowSignalNote(b.file));
+		const lowSignalLines = blocks.map((b) => {
+			const note = lowSignalNote(b.file);
+			return note ? `${b.file}: ${note}` : null;
+		}).filter((line) => line !== null);
+		const chunkBudget = fitBudget(window, reserved + countTokens(`${summarySystemPrompt}\n\n${summaryUserPrompt("")}`));
+		const chunks = packChunks(sourceBlocks, chunkBudget);
+		const condensedNote = lowSignalLines.length ? `, ${lowSignalLines.length} generated file(s) condensed` : "";
+		spinner.text = `Diff is large (~${totalTokens} tokens). Summarizing ${sourceBlocks.length} source file(s) in ${chunks.length} chunk(s)${condensedNote}...`;
+		const summaries = [];
+		for (let i = 0; i < chunks.length; i++) {
+			const chunk = chunks[i];
+			spinner.text = `Summarizing to fit the context window (~${window} tokens) — chunk ${i + 1}/${chunks.length}...`;
+			summaries.push(await summarizeChunk(chunk.content));
+		}
+		const header = `The lines below are per-file summaries of a single commit. Treat them as one related change and write a commit message describing the overall change (not just one file):`;
+		let combined = [...summaries.filter(Boolean), ...lowSignalLines].join("\n");
+		const framed = () => `${header}\n${combined}`;
+		let pass = 0;
+		while (finalPromptTokens(framed()) > promptBudget && pass < MAX_REDUCE_PASSES) {
+			pass++;
+			const reduceChunks = packChunks(combined.split("\n").filter((line) => line.trim().length > 0).map((line) => ({
+				file: "summary",
+				content: `${line}\n`,
+				tokens: countTokens(line)
+			})), chunkBudget);
+			const reduced = [];
+			for (let i = 0; i < reduceChunks.length; i++) {
+				spinner.text = `Condensing summary (pass ${pass}, ${i + 1}/${reduceChunks.length})...`;
+				reduced.push(await summarizeChunk(reduceChunks[i].content));
+			}
+			combined = reduced.filter(Boolean).join("\n");
+		}
+		if (finalPromptTokens(framed()) > promptBudget) {
+			const headerTokens = countTokens(`${systemPrompt}\n\n${userPrompt(`${header}\n`)}`);
+			combined = truncateToBudget("summary", combined, promptBudget - headerTokens);
+		}
+		spinner.succeed(`Summarized ${blocks.length} file(s) to fit the context window: ~${totalTokens} → ~${countTokens(framed())} tokens`);
+		return framed();
+	} catch (error) {
+		spinner.fail("Failed to summarize diff");
+		throw error;
+	}
+};
+//#endregion
+export { prepareCommitContext };

package/dist/commands/config.js

@@ -1,11 +1,26 @@
-import chalk from "chalk";
-import { getConfig } from "../config.js";
+import { getConfig, isDebug } from "../config.js";
 import { maskApiKey } from "../utils/maskApiKey.js";
-export const configCommand = async () => {
-    console.log(chalk.blue("GitPT Configuration"));
-    const { apiKey, ...config } = getConfig();
-    console.log({
-        apiKey: apiKey ? maskApiKey(apiKey) : undefined,
-        ...config,
-    });
+import chalk from "chalk";
+//#region src/commands/config.ts
+var DEBUG_ONLY = /* @__PURE__ */ new Set(["debug"]);
+var configCommand = async () => {
+	console.log(chalk.blue("GitPT Configuration"));
+	const { apiKey, ...config } = getConfig();
+	const entries = {
+		apiKey: apiKey ? maskApiKey(apiKey) : void 0,
+		...config
+	};
+	const debug = isDebug();
+	const labelWidth = Math.max(...Object.keys(entries).map((key) => key.length));
+	for (const [key, value] of Object.entries(entries)) {
+		if (!debug && DEBUG_ONLY.has(key)) continue;
+		let display;
+		if (key === "apiKeys" && value && typeof value === "object") {
+			const masked = Object.entries(value).map(([provider, k]) => `${provider}: ${maskApiKey(k)}`);
+			display = masked.length ? masked.join(", ") : chalk.gray("—");
+		} else display = value === void 0 || value === "" ? chalk.gray("—") : String(value);
+		console.log(`  ${chalk.cyan(key.padEnd(labelWidth))}  ${display}`);
+	}
 };
+//#endregion
+export { configCommand };