Annotation of /trunk/git/genchangelog

#!/usr/bin/env node

/**
 *  Copyright (C) 2024  OSN, Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

"use strict";

const path = require("path");
const { existsSync } = require("fs");
const { exit } = require("process");
const { execSync } = require("child_process");
const { writeFile } = require("fs/promises");
const { parseArgs } = require("util");
const crypto = require("crypto");

const ME = path.basename(process.argv[1]);
const GIT_COMMIT_BOUNDARY = crypto.randomBytes(64).toString("hex");
const GIT_SPACE_BOUNDARY = crypto.randomBytes(64).toString("hex");

function print(...args) {
    console.log(`${ME}: ${args.join(" ")}`);
}

function perror(...args) {
    console.error(`\x1b[0m${ME}: error: ${args.join(" ")}`);
}

function findInPath(executable) {
    for (const segment of process.env.PATH?.split(
        process.platform === "win32" ? ";" : ":",
    ) ?? []) {
        const executablePath = path.join(
            segment,
            executable + (process.platform === "win32" ? ".exe" : ""),
        );

        if (existsSync(executablePath)) {
            return executablePath;
        }
    }

    return null;
}

function checkForGit() {
    const gitPath = findInPath("git");

    if (!gitPath) {
        perror("could not find git in $PATH");
        perror("please make sure git is installed and available in $PATH");
        exit(1);
    }

    return gitPath;
}

function getGitLog(gitPath) {
    try {
        return execSync(
            gitPath +
                ` --no-pager log --pretty=format:"%h %H %an${GIT_SPACE_BOUNDARY} %ae %ad${GIT_SPACE_BOUNDARY} %B${GIT_COMMIT_BOUNDARY}"`,
            { encoding: "utf8" },
        );
    } catch {
        perror("command `git log' failed");
        exit(1);
    }
}

function strUntil(str, boundary) {
    let output = "";
    let i = 0;

    for (i = 0; i < str.length; i++) {
        if (str[i] === boundary[0]) {
            let boundaryIndex = 0;
            let previousI = i;

            while (
                boundaryIndex < boundary.length &&
                i < str.length &&
                str[i] === boundary[boundaryIndex]
            ) {
                i++;
                boundaryIndex++;
            }

            if (boundaryIndex === boundary.length) {
                return { output, size: i };
            }

            i = previousI;
        }

        output += str[i];
    }

    return { output, size: i };
}

function parseGitLog(gitLog) {
    const commits = [];

    let i = 0;

    while (i < gitLog.length) {
        const { output, size } = strUntil(gitLog.slice(i), GIT_COMMIT_BOUNDARY);
        i += size;

        let outputIndex = 0;

        const shortIdSpaceIndex = output.indexOf(" ");
        const idSpaceIndex = output.indexOf(" ", shortIdSpaceIndex + 1);
        const shortId = output.slice(outputIndex, shortIdSpaceIndex);
        const id = output.slice(shortIdSpaceIndex + 1, idSpaceIndex);

        outputIndex += shortId.length + id.length + 2;

        const { output: authorName, size: authorNameSize } = strUntil(
            output.slice(outputIndex),
            GIT_SPACE_BOUNDARY,
        );

        outputIndex += authorNameSize + 1;

        const authorEmailSpaceIndex = output.indexOf(" ", outputIndex + 1);
        const authorEmail = output.slice(outputIndex, authorEmailSpaceIndex);

        outputIndex += authorEmail.length + 1;

        const { output: date, size: dateSize } = strUntil(
            output.slice(outputIndex),
            GIT_SPACE_BOUNDARY,
        );

        outputIndex += dateSize + 1;

        const message = output.slice(outputIndex);
        const newlineIndex = message.indexOf("\n");
        const subject = message.slice(
            0,
            newlineIndex === -1 ? undefined : newlineIndex,
        );
        const body = newlineIndex === -1 ? "" : message.slice(newlineIndex + 1);

        const validFooterProps = [
            "signed-off-by",
            "co-authored-by",
            "on-behalf-of",
        ];
        const footerProps = {};
        const coAuthors = [];

        for (const line of body.split("\n")) {
            const colonIndex = line.indexOf(":");
            const key = line.slice(0, colonIndex).trim().toLowerCase();
            const value = line.slice(colonIndex + 1).trim();

            if (validFooterProps.includes(key)) {
                footerProps[key] = value;
            }

            if (key === "co-authored-by") {
                const name = value.slice(0, value.lastIndexOf(" ")).trim();

                coAuthors.push({
                    name,
                    email: value
                        .slice(name.length)
                        .trim()
                        .replace(/^<|>$/g, ""),
                });
            }
        }

        commits.push({
            shortId,
            id,
            author: {
                name: authorName,
                email: authorEmail,
            },
            date: new Date(date),
            subject,
            body,
            footerProps,
            message,
            coAuthors,
            authors: [
                {
                    name: authorName,
                    email: authorEmail,
                },
                ...coAuthors,
            ],
        });
    }

    return commits;
}

function escapeMarkdown(str) {
    return str.replace(/([_*~`])/g, "\\$1");
}

function generateMarkdownChangelog(commits) {
    let output = "# Changelog\n\n";

    const grouppedCommitsByDate = {};

    for (const commit of commits) {
        const key = `${commit.date.getUTCDate().toString().padStart(2, 0)}-${(
            commit.date.getUTCMonth() + 1
        )
            .toString()
            .padStart(2, "0")}-${commit.date.getUTCFullYear()}::${commit.authors
            .map((a) => `[${escapeMarkdown(a.name)}](mailto:${a.email})`)
            .join(":")}`;
        grouppedCommitsByDate[key] ??= [];
        grouppedCommitsByDate[key].push(commit);
    }

    for (const key in grouppedCommitsByDate) {
        const [date, author] = key.split("::");
        output += `### ${date} - [${author}]\n\n`;

        for (const commit of grouppedCommitsByDate[key]) {
            const conventionalCommitType = commit.subject.match(
                /^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test|release|deps)(\(.+\))?:/,
            );
            let needsBreakingChangeWarning = conventionalCommitType?.[0]
                ?.trim()
                ?.endsWith("!:");

            if (conventionalCommitType) {
                output += `  * **${conventionalCommitType[0]}**${commit.subject.slice(conventionalCommitType[0].length)}`;
            } else {
                output += `  * ${commit.subject}`;
            }

            if (commit.body) {
                output += "    \n";

                for (const line of commit.body.split("\n")) {
                    const colonIndex = line.indexOf(":");

                    if (colonIndex !== -1) {
                        const name = line.slice(0, colonIndex);
                        const value = line.slice(colonIndex + 1);
                        output += `    **${name}:** ${value}  \n`;

                        if (name === "BREAKING CHANGE") {
                            needsBreakingChangeWarning = false;
                        }
                    } else {
                        output += `    ${line}  \n`;
                    }
                }
            }

            if (needsBreakingChangeWarning) {
                output += "    **This is a breaking change.**  \n";
                output += "    \n";
            }

            if (!commit.body && !needsBreakingChangeWarning) {
                output += "\n";
            }
        }

        output += "\n";
    }

    return output.trimEnd();
}

function generateChangelog(commits) {
    let output = "";

    const grouppedCommitsByDate = {};

    for (const commit of commits) {
        const key = `${commit.date.getUTCDate().toString().padStart(2, 0)}-${(
            commit.date.getUTCMonth() + 1
        )
            .toString()
            .padStart(
                2,
                "0",
            )}-${commit.date.getUTCFullYear()}::${commit.authors.map((a) => `${a.name} <${a.email}>`).join(":")}`;
        grouppedCommitsByDate[key] ??= [];
        grouppedCommitsByDate[key].push(commit);
    }

    for (const key in grouppedCommitsByDate) {
        const separatorPosition = key.indexOf("::");
        const date = key.slice(0, separatorPosition);
        const commits = grouppedCommitsByDate[key];

        output += `${date}  ${commits[0].authors
            .map((a) => `${a.name} <${a.email}>`)
            .join(", ")}\n\n`;

        for (const commit of commits) {
            output += `     [*] ${commit.subject}\n${commit.body
                .split("\n")
                .map((part) => `         ${part}`)
                .join("\n")}\n\n`;
        }
    }

    return output.trim();
}

function printHelp() {
    console.log("Usage:");
    console.log(`  ${ME} [OPTION]...`);
    console.log("Generate a formatted ChangeLog from Git commit logs.");
    console.log();
    console.log("Options:");
    console.log("  -h, --help           Show this help and exit.");
    console.log("  -v, --version        Show this script's version.");
    console.log("  -f, --format         Set the changelog format.");
    console.log("                       Supported formats are: plain,");
    console.log("                       markdown.");
    console.log("  -o, --output=<FILE>  Write the generated changelog to");
    console.log("                       a file instead of standard output.");
    console.log("      --no-overwrite   Disallow overwriting of the output");
    console.log("                       file if it exists already.");
    console.log();
    console.log("Send general inquiries, questions and bug reports");
    console.log("to <[email protected]>.");
}

function printVersion() {
    console.log("Copyright (C) 2024 OSN, Inc.");
    console.log(
        "License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.",
    );
    console.log(
        "This is free software: you are free to change and redistribute it.",
    );
    console.log("There is NO WARRANTY, to the extent permitted by law.");
    console.log();
    console.log("Written by Ar Rakin.");
}

async function main() {
    let options;

    try {
        options = parseArgs({
            argv: process.argv.slice(1),
            strict: true,
            allowPositionals: false,
            options: {
                help: {
                    type: "boolean",
                    alias: "h",
                },
                version: {
                    type: "boolean",
                    alias: "v",
                },
                output: {
                    type: "string",
                    short: "o",
                },
                "no-overwrite": {
                    type: "boolean",
                },
                format: {
                    type: "string",
                    short: "f",
                },
            },
        }).values;
    } catch (error) {
        perror(`${error?.message ?? error}`);
        exit(1);
    }

    if (options.help) {
        printHelp();
        exit(0);
    }

    if (options.version) {
        printVersion();
        exit(0);
    }

    if (options.format && !["markdown", "plain"].includes(options.format)) {
        perror(
            "option `--format` or `-f` only accepts one of the following: markdown, plain",
        );
        exit(1);
    }

    if (!options.output && options["no-overwrite"]) {
        perror(
            "option `--no-overwrite' without `--output` does not make sense",
        );
        exit(1);
    }

    if (
        options.output &&
        options["no-overwrite"] &&
        existsSync(options.output)
    ) {
        perror(`${options.output}: cannot write changelog: File exists`);
        exit(1);
    }

    const gitPath = checkForGit();
    const gitLog = getGitLog(gitPath);
    const commits = parseGitLog(gitLog);
    const filteredCommits = commits.filter(
        (commit) =>
            !/Merge pull request #\d+ from|Merge branch '\S+' of/.test(
                commit.message,
            ),
    );
    const changelog =
        options.format === "markdown"
            ? generateMarkdownChangelog(filteredCommits)
            : generateChangelog(filteredCommits);

    if (options.output) {
        try {
            await writeFile(options.output, changelog);
        } catch (error) {
            perror(
                `${options.output}: failed to write changelog: ${
                    error?.message ?? error
                }`,
            );
            exit(1);
        }

        print(`wrote generated changelog to ${options.output}`);
    } else {
        console.log(changelog);
    }
}

main();
1	rakinar2	11	#!/usr/bin/env node
2
3			/**
4			* Copyright (C) 2024 OSN, Inc.
5			*
6			* This program is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			"use strict";
21
22			const path = require("path");
23			const { existsSync } = require("fs");
24			const { exit } = require("process");
25			const { execSync } = require("child_process");
26			const { writeFile } = require("fs/promises");
27			const { parseArgs } = require("util");
28	rakinar2	55	const crypto = require("crypto");
29	rakinar2	11
30			const ME = path.basename(process.argv[1]);
31	rakinar2	55	const GIT_COMMIT_BOUNDARY = crypto.randomBytes(64).toString("hex");
32			const GIT_SPACE_BOUNDARY = crypto.randomBytes(64).toString("hex");
33	rakinar2	11
34			function print(...args) {
35			console.log(`${ME}: ${args.join(" ")}`);
36			}
37
38			function perror(...args) {
39			console.error(`\x1b[0m${ME}: error: ${args.join(" ")}`);
40			}
41
42			function findInPath(executable) {
43	rakinar2	15	for (const segment of process.env.PATH?.split(
44	rakinar2	55	process.platform === "win32" ? ";" : ":",
45	rakinar2	15	) ?? []) {
46			const executablePath = path.join(
47			segment,
48	rakinar2	55	executable + (process.platform === "win32" ? ".exe" : ""),
49	rakinar2	15	);
50
51	rakinar2	11	if (existsSync(executablePath)) {
52			return executablePath;
53			}
54			}
55
56			return null;
57			}
58
59			function checkForGit() {
60			const gitPath = findInPath("git");
61
62			if (!gitPath) {
63			perror("could not find git in $PATH");
64			perror("please make sure git is installed and available in $PATH");
65			exit(1);
66			}
67
68			return gitPath;
69			}
70
71			function getGitLog(gitPath) {
72			try {
73	rakinar2	55	return execSync(
74			gitPath +
75			` --no-pager log --pretty=format:"%h %H %an${GIT_SPACE_BOUNDARY} %ae %ad${GIT_SPACE_BOUNDARY} %B${GIT_COMMIT_BOUNDARY}"`,
76			{ encoding: "utf8" },
77			);
78	rakinar2	15	} catch {
79	rakinar2	55	perror("command `git log' failed");
80	rakinar2	11	exit(1);
81			}
82			}
83
84	rakinar2	55	function strUntil(str, boundary) {
85			let output = "";
86			let i = 0;
87
88			for (i = 0; i < str.length; i++) {
89			if (str[i] === boundary[0]) {
90			let boundaryIndex = 0;
91			let previousI = i;
92
93			while (
94			boundaryIndex < boundary.length &&
95			i < str.length &&
96			str[i] === boundary[boundaryIndex]
97			) {
98			i++;
99			boundaryIndex++;
100			}
101
102			if (boundaryIndex === boundary.length) {
103			return { output, size: i };
104			}
105
106			i = previousI;
107			}
108
109			output += str[i];
110			}
111
112			return { output, size: i };
113			}
114
115	rakinar2	11	function parseGitLog(gitLog) {
116			const commits = [];
117
118	rakinar2	55	let i = 0;
119	rakinar2	11
120	rakinar2	55	while (i < gitLog.length) {
121			const { output, size } = strUntil(gitLog.slice(i), GIT_COMMIT_BOUNDARY);
122			i += size;
123	rakinar2	11
124	rakinar2	55	let outputIndex = 0;
125	rakinar2	11
126	rakinar2	55	const shortIdSpaceIndex = output.indexOf(" ");
127			const idSpaceIndex = output.indexOf(" ", shortIdSpaceIndex + 1);
128			const shortId = output.slice(outputIndex, shortIdSpaceIndex);
129			const id = output.slice(shortIdSpaceIndex + 1, idSpaceIndex);
130	rakinar2	11
131	rakinar2	55	outputIndex += shortId.length + id.length + 2;
132	rakinar2	11
133	rakinar2	55	const { output: authorName, size: authorNameSize } = strUntil(
134			output.slice(outputIndex),
135			GIT_SPACE_BOUNDARY,
136			);
137	rakinar2	15
138	rakinar2	55	outputIndex += authorNameSize + 1;
139	rakinar2	11
140	rakinar2	55	const authorEmailSpaceIndex = output.indexOf(" ", outputIndex + 1);
141			const authorEmail = output.slice(outputIndex, authorEmailSpaceIndex);
142
143			outputIndex += authorEmail.length + 1;
144
145			const { output: date, size: dateSize } = strUntil(
146			output.slice(outputIndex),
147			GIT_SPACE_BOUNDARY,
148			);
149
150			outputIndex += dateSize + 1;
151
152			const message = output.slice(outputIndex);
153			const newlineIndex = message.indexOf("\n");
154			const subject = message.slice(
155			0,
156			newlineIndex === -1 ? undefined : newlineIndex,
157			);
158			const body = newlineIndex === -1 ? "" : message.slice(newlineIndex + 1);
159
160	rakinar2	15	const validFooterProps = [
161			"signed-off-by",
162			"co-authored-by",
163			"on-behalf-of",
164			];
165	rakinar2	55	const footerProps = {};
166			const coAuthors = [];
167	rakinar2	15
168	rakinar2	55	for (const line of body.split("\n")) {
169			const colonIndex = line.indexOf(":");
170			const key = line.slice(0, colonIndex).trim().toLowerCase();
171			const value = line.slice(colonIndex + 1).trim();
172	rakinar2	11
173	rakinar2	55	if (validFooterProps.includes(key)) {
174			footerProps[key] = value;
175	rakinar2	11	}
176	rakinar2	15
177	rakinar2	55	if (key === "co-authored-by") {
178			const name = value.slice(0, value.lastIndexOf(" ")).trim();
179	rakinar2	11
180	rakinar2	55	coAuthors.push({
181			name,
182			email: value
183			.slice(name.length)
184			.trim()
185			.replace(/^<\|>$/g, ""),
186			});
187	rakinar2	11	}
188			}
189
190			commits.push({
191	rakinar2	55	shortId,
192			id,
193			author: {
194			name: authorName,
195			email: authorEmail,
196			},
197			date: new Date(date),
198			subject,
199			body,
200			footerProps,
201	rakinar2	11	message,
202	rakinar2	55	coAuthors,
203			authors: [
204			{
205			name: authorName,
206			email: authorEmail,
207			},
208			...coAuthors,
209			],
210	rakinar2	11	});
211			}
212
213			return commits;
214			}
215
216	rakinar2	55	function escapeMarkdown(str) {
217			return str.replace(/([_*~`])/g, "\\$1");
218			}
219
220	rakinar2	54	function generateMarkdownChangelog(commits) {
221			let output = "# Changelog\n\n";
222
223			const grouppedCommitsByDate = {};
224
225			for (const commit of commits) {
226	rakinar2	55	const key = `${commit.date.getUTCDate().toString().padStart(2, 0)}-${(
227			commit.date.getUTCMonth() + 1
228			)
229	rakinar2	54	.toString()
230	rakinar2	55	.padStart(2, "0")}-${commit.date.getUTCFullYear()}::${commit.authors
231			.map((a) => `[${escapeMarkdown(a.name)}](mailto:${a.email})`)
232			.join(":")}`;
233	rakinar2	54	grouppedCommitsByDate[key] ??= [];
234			grouppedCommitsByDate[key].push(commit);
235			}
236
237			for (const key in grouppedCommitsByDate) {
238			const [date, author] = key.split("::");
239	rakinar2	55	output += `### ${date} - [${author}]\n\n`;
240	rakinar2	54
241			for (const commit of grouppedCommitsByDate[key]) {
242	rakinar2	55	const conventionalCommitType = commit.subject.match(
243			/^(build\|chore\|ci\|docs\|feat\|fix\|perf\|refactor\|revert\|style\|test\|release\|deps)(\(.+\))?:/,
244			);
245			let needsBreakingChangeWarning = conventionalCommitType?.[0]
246			?.trim()
247			?.endsWith("!:");
248
249			if (conventionalCommitType) {
250			output += ` * ${conventionalCommitType[0]}${commit.subject.slice(conventionalCommitType[0].length)}`;
251			} else {
252			output += ` * ${commit.subject}`;
253			}
254
255			if (commit.body) {
256			output += " \n";
257
258			for (const line of commit.body.split("\n")) {
259			const colonIndex = line.indexOf(":");
260
261			if (colonIndex !== -1) {
262			const name = line.slice(0, colonIndex);
263			const value = line.slice(colonIndex + 1);
264			output += ` ${name}: ${value} \n`;
265
266			if (name === "BREAKING CHANGE") {
267			needsBreakingChangeWarning = false;
268			}
269			} else {
270			output += ` ${line} \n`;
271			}
272			}
273			}
274
275			if (needsBreakingChangeWarning) {
276			output += " This is a breaking change. \n";
277			output += " \n";
278			}
279
280			if (!commit.body && !needsBreakingChangeWarning) {
281			output += "\n";
282			}
283	rakinar2	54	}
284
285			output += "\n";
286			}
287
288	rakinar2	55	return output.trimEnd();
289	rakinar2	54	}
290
291	rakinar2	11	function generateChangelog(commits) {
292			let output = "";
293	rakinar2	15
294	rakinar2	11	const grouppedCommitsByDate = {};
295	rakinar2	15
296	rakinar2	11	for (const commit of commits) {
297	rakinar2	55	const key = `${commit.date.getUTCDate().toString().padStart(2, 0)}-${(
298			commit.date.getUTCMonth() + 1
299			)
300	rakinar2	15	.toString()
301	rakinar2	55	.padStart(
302			2,
303			"0",
304			)}-${commit.date.getUTCFullYear()}::${commit.authors.map((a) => `${a.name} <${a.email}>`).join(":")}`;
305	rakinar2	11	grouppedCommitsByDate[key] ??= [];
306			grouppedCommitsByDate[key].push(commit);
307			}
308
309			for (const key in grouppedCommitsByDate) {
310			const separatorPosition = key.indexOf("::");
311			const date = key.slice(0, separatorPosition);
312			const commits = grouppedCommitsByDate[key];
313
314	rakinar2	55	output += `${date} ${commits[0].authors
315			.map((a) => `${a.name} <${a.email}>`)
316			.join(", ")}\n\n`;
317	rakinar2	11
318			for (const commit of commits) {
319	rakinar2	55	output += ` [*] ${commit.subject}\n${commit.body
320			.split("\n")
321			.map((part) => ` ${part}`)
322			.join("\n")}\n\n`;
323	rakinar2	11	}
324			}
325	rakinar2	15
326	rakinar2	11	return output.trim();
327			}
328
329			function printHelp() {
330			console.log("Usage:");
331			console.log(` ${ME} [OPTION]...`);
332			console.log("Generate a formatted ChangeLog from Git commit logs.");
333			console.log();
334			console.log("Options:");
335			console.log(" -h, --help Show this help and exit.");
336			console.log(" -v, --version Show this script's version.");
337	rakinar2	55	console.log(" -f, --format Set the changelog format.");
338	rakinar2	54	console.log(" Supported formats are: plain,");
339			console.log(" markdown.");
340			console.log(" -o, --output=<FILE> Write the generated changelog to");
341	rakinar2	11	console.log(" a file instead of standard output.");
342			console.log(" --no-overwrite Disallow overwriting of the output");
343			console.log(" file if it exists already.");
344			console.log();
345			console.log("Send general inquiries, questions and bug reports");
346	rakinar2	20	console.log("to <[email protected]>.");
347	rakinar2	11	}
348
349			function printVersion() {
350			console.log("Copyright (C) 2024 OSN, Inc.");
351	rakinar2	15	console.log(
352	rakinar2	55	"License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.",
353	rakinar2	15	);
354			console.log(
355	rakinar2	55	"This is free software: you are free to change and redistribute it.",
356	rakinar2	15	);
357	rakinar2	11	console.log("There is NO WARRANTY, to the extent permitted by law.");
358			console.log();
359			console.log("Written by Ar Rakin.");
360			}
361
362			async function main() {
363			let options;
364
365			try {
366			options = parseArgs({
367			argv: process.argv.slice(1),
368			strict: true,
369			allowPositionals: false,
370			options: {
371			help: {
372			type: "boolean",
373	rakinar2	15	alias: "h",
374	rakinar2	11	},
375			version: {
376			type: "boolean",
377	rakinar2	15	alias: "v",
378	rakinar2	11	},
379			output: {
380			type: "string",
381	rakinar2	15	short: "o",
382	rakinar2	11	},
383			"no-overwrite": {
384	rakinar2	15	type: "boolean",
385			},
386	rakinar2	54	format: {
387			type: "string",
388	rakinar2	55	short: "f",
389			},
390	rakinar2	15	},
391	rakinar2	11	}).values;
392	rakinar2	15	} catch (error) {
393	rakinar2	11	perror(`${error?.message ?? error}`);
394			exit(1);
395			}
396
397			if (options.help) {
398			printHelp();
399			exit(0);
400			}
401
402			if (options.version) {
403			printVersion();
404			exit(0);
405			}
406
407	rakinar2	54	if (options.format && !["markdown", "plain"].includes(options.format)) {
408	rakinar2	55	perror(
409			"option `--format` or `-f` only accepts one of the following: markdown, plain",
410			);
411	rakinar2	54	exit(1);
412			}
413
414	rakinar2	11	if (!options.output && options["no-overwrite"]) {
415	rakinar2	15	perror(
416	rakinar2	55	"option `--no-overwrite' without `--output` does not make sense",
417	rakinar2	15	);
418	rakinar2	11	exit(1);
419			}
420	rakinar2	15
421			if (
422			options.output &&
423			options["no-overwrite"] &&
424			existsSync(options.output)
425			) {
426	rakinar2	11	perror(`${options.output}: cannot write changelog: File exists`);
427			exit(1);
428			}
429	rakinar2	15
430	rakinar2	11	const gitPath = checkForGit();
431			const gitLog = getGitLog(gitPath);
432			const commits = parseGitLog(gitLog);
433	rakinar2	15	const filteredCommits = commits.filter(
434			(commit) =>
435			!/Merge pull request #\d+ from\|Merge branch '\S+' of/.test(
436	rakinar2	55	commit.message,
437			),
438	rakinar2	15	);
439	rakinar2	55	const changelog =
440			options.format === "markdown"
441			? generateMarkdownChangelog(filteredCommits)
442			: generateChangelog(filteredCommits);
443	rakinar2	11
444	rakinar2	15	if (options.output) {
445	rakinar2	11	try {
446			await writeFile(options.output, changelog);
447	rakinar2	15	} catch (error) {
448			perror(
449			`${options.output}: failed to write changelog: ${
450			error?.message ?? error
451	rakinar2	55	}`,
452	rakinar2	15	);
453	rakinar2	11	exit(1);
454			}
455
456			print(`wrote generated changelog to ${options.output}`);
457	rakinar2	15	} else {
458	rakinar2	11	console.log(changelog);
459			}
460			}
461
462			main();