mcp-udacity-commit - npm Package Compare versions

Comparing version

1.0.1

1.0.2

+211

build/lint.js

		/**
		* Pure, side-effect-free linting logic for the Udacity Git Commit Message
		* Style Guide. Kept separate from the MCP server (index.ts) so it can be
		* unit-tested in isolation.
		*
		* Length semantics: all limits are measured in Unicode code points
		* (`width()`), not UTF-16 code units, so emoji / CJK / combining marks are
		* counted the way a human reads them. The 50-char subject limit applies to
		* the WHOLE `type: Subject` line, including the `type: ` prefix.
		*/
		export const SUBJECT_MAX = 50;
		export const BODY_WRAP = 72;
		export const TYPES = {
		feat: "A new feature",
		fix: "A bug fix",
		docs: "Changes to documentation",
		style: "Formatting, missing semicolons, etc; no code change",
		refactor: "Refactoring production code",
		test: "Adding tests, refactoring tests; no production code change",
		chore: "Updating build tasks, package configs, etc; no production code change",
		};
		/** Footer keywords recognized for issue-reference validation. */
		export const FOOTER_KEYS = ["Resolves", "Closes", "Fixes", "Fix", "See also", "Refs", "Ref"];
		/**
		* Common non-imperative first words (past tense / gerund). We match against
		* this allow-known-bad list rather than a broad `/(ed\|ing)$/` regex so that
		* legitimate imperatives like "Bring", "Embed", "Ring" are never flagged.
		* This favors precision (no false positives) over recall.
		*/
		const NON_IMPERATIVE = new Set([
		// past tense
		"added", "fixed", "updated", "changed", "removed", "deleted", "created",
		"refactored", "implemented", "improved", "renamed", "moved", "merged",
		"reverted", "bumped", "cleaned", "corrected", "adjusted", "enabled",
		"disabled", "introduced", "resolved", "replaced", "converted", "migrated",
		"dropped", "extracted", "wrapped", "tweaked", "optimized", "simplified",
		"formatted", "documented", "tested", "released", "handled", "allowed",
		"prevented", "ensured", "avoided", "unified", "applied", "upgraded",
		"downgraded", "patched", "hardened", "restructured", "reorganized",
		"deprecated", "exposed", "integrated", "validated", "normalized", "cached",
		"supported", "added", "wired", "hooked",
		// gerund
		"adding", "fixing", "updating", "changing", "removing", "deleting",
		"creating", "refactoring", "implementing", "improving", "renaming",
		"moving", "merging", "reverting", "bumping", "cleaning", "correcting",
		"adjusting", "enabling", "disabling", "introducing", "resolving",
		"replacing", "converting", "migrating", "dropping", "extracting",
		"wrapping", "tweaking", "optimizing", "simplifying", "formatting",
		"documenting", "testing", "releasing", "handling", "allowing",
		"preventing", "ensuring", "avoiding", "unifying", "applying", "upgrading",
		"patching", "hardening", "restructuring", "reorganizing", "deprecating",
		"exposing", "integrating", "validating", "normalizing", "caching",
		"supporting",
		]);
		export const STYLE_GUIDE = `# Udacity Git Commit Message Style Guide

		A commit message has three parts separated by blank lines: subject, optional body, optional footer.

		type: Subject

		Body — the what and why, not the how.

		Resolves: #123
		See also: #456, #789

		## Types
		${Object.entries(TYPES)
		.map(([t, d]) => `- ${t}: ${d}`)
		.join("\n")}

		## Subject
		- \`type: Subject\` format
		- The whole line (including the \`type: \` prefix) is no more than ${SUBJECT_MAX} characters
		- Begins with a capital letter
		- Imperative mood ("Add", not "Added")
		- No trailing period
		- Blank line separates it from the body

		## Body (optional)
		- Only when the commit needs explanation
		- Explains the what and why, not the how
		- Wrap each line at ${BODY_WRAP} characters

		## Footer (optional)
		- References issue-tracker IDs: \`Resolves: #123\`, \`See also: #456, #789\`

		_Lengths are counted in Unicode code points._
		`;
		/** Length in Unicode code points (not UTF-16 code units). */
		export function width(s) {
		return [...s].length;
		}
		/** Uppercase the first code point of a string (astral-safe). */
		function capitalizeFirst(s) {
		const chars = [...s];
		if (chars.length === 0)
		return s;
		return chars[0].toUpperCase() + chars.slice(1).join("");
		}
		/**
		* Greedy word-wrap that preserves paragraph breaks AND hard-breaks any single
		* token longer than `max` (URLs, long paths), so no output line ever exceeds
		* the limit. This guarantees `format`'s output always passes `validate`.
		*/
		export function wrap(text, max = BODY_WRAP) {
		return text
		.split("\n")
		.map((para) => {
		const lines = [];
		let line = "";
		const flush = () => {
		if (line) {
		lines.push(line);
		line = "";
		}
		};
		for (let word of para.split(/\s+/).filter(Boolean)) {
		// hard-break an over-long token across multiple lines
		while (width(word) > max) {
		flush();
		const chars = [...word];
		lines.push(chars.slice(0, max).join(""));
		word = chars.slice(max).join("");
		}
		if (!line)
		line = word;
		else if (width(line) + 1 + width(word) <= max)
		line += " " + word;
		else {
		flush();
		line = word;
		}
		}
		flush();
		return lines.join("\n");
		})
		.join("\n");
		}
		/** Validate a full commit message against the Udacity style guide. */
		export function validate(message) {
		const problems = [];
		const warnings = [];
		// Normalize CRLF / lone CR so line-based checks are reliable.
		const normalized = message.replace(/\r\n?/g, "\n");
		const lines = normalized.split("\n");
		// Drop trailing blank lines (a trailing newline shouldn't count as a body).
		while (lines.length > 1 && lines[lines.length - 1].trim() === "")
		lines.pop();
		const rawSubject = lines[0] ?? "";
		const subject = rawSubject.replace(/\s+$/, "");
		const m = subject.match(/^(\w+): (.*)$/);
		if (!m) {
		problems.push(`Subject must follow "type: Subject". Got: "${subject}".`);
		}
		else {
		const [, type, rest] = m;
		if (!TYPES[type]) {
		problems.push(`Unknown type "${type}". Use one of: ${Object.keys(TYPES).join(", ")}.`);
		}
		if (!rest) {
		problems.push("Subject text is empty after the type.");
		}
		else {
		if (/^\p{Ll}/u.test(rest)) {
		problems.push(`Subject should begin with a capital letter (got "${[...rest][0]}").`);
		}
		const firstWord = rest.split(/\s+/)[0];
		if (NON_IMPERATIVE.has(firstWord.toLowerCase())) {
		warnings.push(`"${firstWord}" looks past-tense/gerund — use the imperative mood ("Add", not "Added").`);
		}
		}
		}
		if (rawSubject !== subject)
		problems.push("Subject has trailing whitespace.");
		if (/\.$/.test(subject))
		problems.push("Subject must not end with a period.");
		if (width(subject) > SUBJECT_MAX) {
		problems.push(`Subject line is ${width(subject)} chars (incl. the "type: " prefix); max is ${SUBJECT_MAX}.`);
		}
		if (lines.length > 1 && lines[1].trim() !== "") {
		problems.push("Leave a blank line between the subject and the body.");
		}
		for (let i = 2; i < lines.length; i++) {
		const line = lines[i];
		if (width(line) > BODY_WRAP) {
		problems.push(`Line ${i + 1} is ${width(line)} chars; wrap body/footer at ${BODY_WRAP}.`);
		}
		const fm = line.match(/^([A-Za-z][A-Za-z ]?):\s(.*)$/);
		if (fm && FOOTER_KEYS.some((k) => k.toLowerCase() === fm[1].toLowerCase())) {
		if (!/#\d+/.test(fm[2])) {
		warnings.push(`Footer "${fm[1]}" should reference an issue, e.g. "${fm[1]}: #123".`);
		}
		}
		}
		return { valid: problems.length === 0, problems, warnings };
		}
		/**
		* Compose a compliant commit message from parts. Capitalizes the subject,
		* strips a trailing period, and hard-wraps the body so the result always
		* passes `validate`.
		*/
		export function formatMessage(input) {
		const subject = capitalizeFirst(input.subject.trim().replace(/\.+$/, ""));
		const parts = [`${input.type}: ${subject}`];
		if (input.body?.trim())
		parts.push("", wrap(input.body.trim(), BODY_WRAP));
		if (input.footer?.trim())
		parts.push("", input.footer.trim());
		const message = parts.join("\n");
		return { message, report: validate(message) };
		}

+74

-152

build/index.js

		@@ -5,156 +5,78 @@ #!/usr/bin/env node
		import { z } from "zod";
		const SUBJECT_MAX = 50;
		const BODY_WRAP = 72;
		const TYPES = {
		feat: "A new feature",
		fix: "A bug fix",
		docs: "Changes to documentation",
		style: "Formatting, missing semicolons, etc; no code change",
		refactor: "Refactoring production code",
		test: "Adding tests, refactoring tests; no production code change",
		chore: "Updating build tasks, package configs, etc; no production code change",
		};
		const STYLE_GUIDE = `# Udacity Git Commit Message Style Guide

		A commit message has three parts separated by blank lines: subject, optional body, optional footer.

		type: Subject

		Body — the what and why, not the how.

		Resolves: #123
		See also: #456, #789

		## Types
		${Object.entries(TYPES)
		.map(([t, d]) => `- ${t}: ${d}`)
		.join("\n")}

		## Subject
		- \`type: Subject\` format
		- No more than ${SUBJECT_MAX} characters
		- Begins with a capital letter
		- Imperative mood ("Add", not "Added")
		- No trailing period
		- Blank line separates it from the body

		## Body (optional)
		- Only when the commit needs explanation
		- Explains the what and why, not the how
		- Wrap each line at ${BODY_WRAP} characters

		## Footer (optional)
		- References issue-tracker IDs: \`Resolves: #123\`, \`See also: #456, #789\`
		`;
		/** Greedy word-wrap that preserves existing paragraph breaks. */
		function wrap(text, width) {
		return text
		.split("\n")
		.map((para) => {
		const words = para.split(/\s+/).filter(Boolean);
		const lines = [];
		let line = "";
		for (const w of words) {
		if (!line)
		line = w;
		else if ((line + " " + w).length <= width)
		line += " " + w;
		else {
		lines.push(line);
		line = w;
		}
		}
		if (line)
		lines.push(line);
		return lines.join("\n");
		})
		.join("\n");
		import { STYLE_GUIDE, validate, formatMessage } from "./lint.js";
		const VERSION = "1.0.2";
		export function createServer() {
		const server = new McpServer({ name: "udacity-commit", version: VERSION });
		server.registerResource("styleguide", "udacity://commit-styleguide", {
		title: "Udacity Git Commit Style Guide",
		description: "The commit-message rules (types, subject, body, footer).",
		mimeType: "text/markdown",
		}, async (uri) => ({ contents: [{ uri: uri.href, text: STYLE_GUIDE }] }));
		server.registerTool("validate_commit_message", {
		title: "Validate a commit message",
		description: "Check a commit message against the Udacity Git Commit Message Style Guide. " +
		"Returns whether it is compliant plus any problems (violations) and warnings (hints).",
		inputSchema: { message: z.string().describe("The full commit message to check") },
		outputSchema: {
		valid: z.boolean(),
		problems: z.array(z.string()),
		warnings: z.array(z.string()),
		},
		}, async ({ message }) => {
		const r = validate(message);
		const text = [
		r.valid ? "✅ Compliant with the Udacity style guide." : "❌ Not compliant.",
		...r.problems.map((p) => ` • ${p}`),
		...r.warnings.map((w) => ` ⚠ ${w}`),
		].join("\n");
		const structuredContent = {
		valid: r.valid,
		problems: r.problems,
		warnings: r.warnings,
		};
		return { content: [{ type: "text", text }], structuredContent };
		});
		server.registerTool("format_commit_message", {
		title: "Format a Udacity-style commit message",
		description: "Compose a compliant commit message from its parts. The subject is capitalized, " +
		"a trailing period is removed, and the body is wrapped at 72 characters.",
		inputSchema: {
		type: z.enum(["feat", "fix", "docs", "style", "refactor", "test", "chore"]),
		subject: z.string().describe("Imperative subject; auto-capitalized, trailing period removed"),
		body: z.string().optional().describe("What & why; auto-wrapped at 72 chars"),
		footer: z.string().optional().describe('Issue refs, e.g. "Resolves: #123"'),
		},
		outputSchema: {
		message: z.string(),
		valid: z.boolean(),
		problems: z.array(z.string()),
		warnings: z.array(z.string()),
		},
		}, async (input) => {
		const { message, report } = formatMessage(input);
		const note = !report.valid
		? "❌ " + [...report.problems, ...report.warnings].join("; ")
		: report.warnings.length
		? "✅ compliant (hint: " + report.warnings.join("; ") + ")"
		: "✅ compliant";
		const structuredContent = {
		message,
		valid: report.valid,
		problems: report.problems,
		warnings: report.warnings,
		};
		return {
		content: [{ type: "text", text: `${message}\n\n--- ${note}` }],
		structuredContent,
		};
		});
		return server;
		}
		function validate(message) {
		const problems = [];
		const warnings = [];
		const lines = message.replace(/\s+$/, "").split("\n");
		const subject = lines[0] ?? "";
		const m = subject.match(/^(\w+): (.*)$/);
		if (!m) {
		problems.push(`Subject must follow "type: Subject". Got: "${subject}".`);
		}
		else {
		const [, type, rest] = m;
		if (!TYPES[type]) {
		problems.push(`Unknown type "${type}". Use one of: ${Object.keys(TYPES).join(", ")}.`);
		}
		if (!rest) {
		problems.push("Subject text is empty after the type.");
		}
		else {
		if (!/^[A-Z]/.test(rest)) {
		problems.push(`Subject should begin with a capital letter (got "${rest[0]}").`);
		}
		const first = rest.split(/\s+/)[0];
		if (/(ed\|ing)$/i.test(first)) {
		warnings.push(`"${first}" looks past-tense/gerund — use imperative mood ("Add", not "Added").`);
		}
		}
		}
		if (/\.$/.test(subject))
		problems.push("Subject must not end with a period.");
		if (subject.length > SUBJECT_MAX) {
		problems.push(`Subject is ${subject.length} chars; max is ${SUBJECT_MAX}.`);
		}
		if (lines.length > 1 && lines[1].trim() !== "") {
		problems.push("Leave a blank line between the subject and the body.");
		}
		for (let i = 2; i < lines.length; i++) {
		if (lines[i].length > BODY_WRAP) {
		problems.push(`Line ${i + 1} is ${lines[i].length} chars; wrap body/footer at ${BODY_WRAP}.`);
		}
		}
		return { valid: problems.length === 0, problems, warnings };
		async function main() {
		const server = createServer();
		await server.connect(new StdioServerTransport());
		}
		const server = new McpServer({ name: "udacity-commit", version: "1.0.1" });
		server.registerResource("styleguide", "udacity://commit-styleguide", {
		title: "Udacity Git Commit Style Guide",
		description: "The commit-message rules (types, subject, body, footer).",
		mimeType: "text/markdown",
		}, async (uri) => ({ contents: [{ uri: uri.href, text: STYLE_GUIDE }] }));
		server.registerTool("validate_commit_message", {
		title: "Validate a commit message",
		description: "Check a commit message against the Udacity Git Commit Message Style Guide.",
		inputSchema: { message: z.string().describe("The full commit message to check") },
		}, async ({ message }) => {
		const r = validate(message);
		const out = [
		r.valid ? "✅ Compliant with the Udacity style guide." : "❌ Not compliant.",
		...r.problems.map((p) => ` • ${p}`),
		...r.warnings.map((w) => ` ⚠ ${w}`),
		].join("\n");
		return { content: [{ type: "text", text: out }] };
		main().catch((err) => {
		console.error(err);
		process.exit(1);
		});
		server.registerTool("format_commit_message", {
		title: "Format a Udacity-style commit message",
		description: "Compose a compliant commit message from its parts.",
		inputSchema: {
		type: z.enum(["feat", "fix", "docs", "style", "refactor", "test", "chore"]),
		subject: z
		.string()
		.describe("Imperative subject; auto-capitalized, trailing period removed"),
		body: z.string().optional().describe("What & why; auto-wrapped at 72 chars"),
		footer: z.string().optional().describe('Issue refs, e.g. "Resolves: #123"'),
		},
		}, async ({ type, subject, body, footer }) => {
		let s = subject.trim().replace(/\.+$/, "");
		s = s.charAt(0).toUpperCase() + s.slice(1);
		const parts = [`${type}: ${s}`];
		if (body?.trim())
		parts.push("", wrap(body.trim(), BODY_WRAP));
		if (footer?.trim())
		parts.push("", footer.trim());
		const msg = parts.join("\n");
		const v = validate(msg);
		const note = v.valid ? "✅ compliant" : "❌ " + v.problems.join("; ");
		return { content: [{ type: "text", text: `${msg}\n\n--- ${note}` }] };
		});
		const transport = new StdioServerTransport();
		await server.connect(transport);
		//# sourceMappingURL=index.js.map

+5

-3

package.json

		{
		"name": "mcp-udacity-commit",
		"version": "1.0.1",
		"version": "1.0.2",
		"description": "MCP server that validates and formats git commit messages per the Udacity Git Commit Message Style Guide.",
		@@ -32,5 +32,7 @@ "type": "module",
		"scripts": {
		"build": "tsc && chmod 755 build/index.js",
		"build": "rm -rf build && tsc && chmod 755 build/index.js",
		"start": "node build/index.js",
		"prepublishOnly": "npm run build",
		"pretest": "npm run build",
		"test": "node --test test/*.test.mjs",
		"prepublishOnly": "npm test",
		"test:client": "node test-client.mjs"
		@@ -37,0 +39,0 @@ },

-2

build/index.d.ts

		#!/usr/bin/env node
		export {};

-1

build/index.js.map

mcp-udacity-commit - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics