@sheplu/editorconfig 0.8.6 → 0.9.0

package/README.md

@@ -4,8 +4,8 @@ A small CLI to manage a **consistent `.editorconfig`** across your projects.
 
 - ✅ Generate a sane default `.editorconfig` in seconds
 - ✅ Check if your existing file matches the target setup
-- 🔜 Propose updates (with confirmation) instead of blindly overwriting
-- 🔜 Compare your file against the recommended template
+- ✅ Confirm before overwriting an existing `.editorconfig` (or pass `--overwrite` to skip the prompt)
+- ✅ Override the built-in template with a team-shared file via `--template` (local path or `https://` URL)
 
 ## Why?
 
@@ -49,8 +49,8 @@ npx @sheplu/editorconfig --mode=write
 This will:
 
 - Create a `.editorconfig` file if it doesn’t exist
-- (Current behavior) Write the default template
-- (Future behavior) Ask before overwriting an existing file
+- Write the default template
+- Ask before overwriting an existing file (or fail in non-interactive contexts unless `--overwrite` is passed)
 
 ## Current Features
 
@@ -62,6 +62,23 @@ npx @sheplu/editorconfig --mode=write
 
 Creates a base `.editorconfig` file in the current directory.
 
+If a `.editorconfig` already exists at the target path, the CLI will:
+
+- Prompt for confirmation in an interactive terminal (`y` / `yes` to overwrite, anything else keeps the file).
+- Exit non-zero in non-interactive contexts (CI, redirected stdin) so a script never silently destroys an existing config.
+
+Pass `--overwrite` (or `-o`) to bypass the prompt and force a rewrite:
+
+```bash
+npx @sheplu/editorconfig --mode=write --overwrite
+```
+
+You can also point at a custom path:
+
+```bash
+npx @sheplu/editorconfig --mode=write --path=path/to/.editorconfig
+```
+
 Typical content (example):
 
 ```ini
@@ -96,6 +113,36 @@ This command will:
   - `0` if everything matches
   - `1` if differences are found
 
+### `--template` (custom team template)
+
+Both `write` and `check` accept a `--template` (or `-t`) flag pointing at a custom `.editorconfig`-syntax file. Sections in that file override the built-in defaults; languages it doesn't redefine still come from the built-ins. This lets a team host a single source of truth and reference it from every repo.
+
+The flag accepts either a local path or an `https://` URL:
+
+```bash
+# local file
+npx @sheplu/editorconfig --mode=write --template=./team.editorconfig
+
+# remote URL
+npx @sheplu/editorconfig --mode=check --template=https://raw.githubusercontent.com/example/team-config/main/.editorconfig
+```
+
+The custom template must follow the same semantics as the built-ins:
+
+- Use only known section headers (`[*]`, `[*.md]`, `[*.{js,jsx,...}]`, etc.). Unknown headers (like `[*.proto]`) are rejected.
+- Include `root = true` in the preamble whenever the template redefines `[*]`.
+- Each header may appear at most once.
+
+URL fetching is constrained for safety: `https://` only (`http://` is rejected before any network call), redirects must stay on https (max 5 hops), 10-second timeout, 1 MB response cap. Templates are fetched on every invocation — there is no local cache.
+
+### `--help`
+
+```bash
+npx @sheplu/editorconfig --help
+```
+
+Prints the full usage, the available commands, and every supported option.
+
 ## Planned / Upcoming Features
 
 ### 1. Interactive update / replace
@@ -115,10 +162,27 @@ npx @sheplu/editorconfig --mode=diff
 - [ ] Add diff logic and `diff` command
 - [ ] Add interactive `fix` / `update` command
 - [ ] Expose presets or configuration options
-- [ ] Add tests and CI examples
 
 Additional properties can be found on the [editorconfig wiki](https://github.com/editorconfig/editorconfig/wiki/editorconfig-properties).
 
+## Tests
+
+Tests live under `test/` and are split by scope:
+
+- `test/unit/` — fast, in-process tests of exported functions (no spawning, no I/O beyond a tmp dir).
+- `test/integration/` — full CLI runs. The interactive prompt path is exercised in a real pseudoterminal via [`node-pty`](https://github.com/microsoft/node-pty); the rest go through `child_process.spawnSync` with a closed stdin.
+
+Run them with:
+
+```bash
+npm test                  # everything
+npm run test:unit         # unit only — runs in ~50ms
+npm run test:integration  # integration only — spawns the CLI
+npm run lint              # oxlint
+```
+
+CI runs lint, audit, and the full suite on every PR across Node 24 / 26.
+
 ## Documentation
 
 [Editorconfig documentation](https://github.com/editorconfig/editorconfig/wiki/editorconfig-properties)

package/index.js

@@ -1,60 +1,285 @@
 #!/usr/bin/env node
 
-import { readFileSync, writeFileSync } from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
+import { createInterface } from 'node:readline';
 import { parseArgs } from 'node:util';
+import {
+	ALIASES,
+	AVAILABLE_LANGUAGES,
+	composeEditorConfig,
+	EMPTY_OVERRIDES,
+} from './src/templates/index.js';
+import { loadCustomTemplate } from './src/templates/custom-template.js';
+import { compareEditorConfig, NO_LANGUAGE_FILTER, runCheck } from './src/check.js';
 
-const editorconfigContent = `root = true
-
-[*]
-indent_style = tab
-indent_size = 4
-tab_width = 4
-end_of_line = lf
-charset = utf-8
-spelling_language = en
-trim_trailing_whitespace = true
-insert_final_newline = true
-quote_type = single
-spaces_around_operators = true
-`;
-
-export function createEditorConfig(path = '.editorconfig') {
-	writeFileSync(path, editorconfigContent, 'utf8');
+export { compareEditorConfig };
+
+export function createEditorConfig(path = '.editorconfig', languages = [], overrides = EMPTY_OVERRIDES) {
+	writeFileSync(path, composeEditorConfig(languages, overrides), 'utf8');
+};
+
+export const options = {
+	mode: {
+		type: 'string',
+		short: 'm',
+	},
+	path: {
+		type: 'string',
+		short: 'p',
+	},
+	languages: {
+		type: 'string',
+		short: 'l',
+	},
+	help: {
+		type: 'boolean',
+		short: 'h',
+	},
+	overwrite: {
+		type: 'boolean',
+		short: 'o',
+	},
+	strict: {
+		type: 'boolean',
+		short: 's',
+	},
+	template: {
+		type: 'string',
+		short: 't',
+	},
 };
 
-export function compareEditorConfig(path = '.editorconfig') {
-	const file = readFileSync(path).toString();
-	if (editorconfigContent === file) {
-		console.log('✅ Editorconfig is matching the expected configuration')
+export const NOT_PROVIDED = Symbol('languages-not-provided');
+
+export function parseLanguages(raw) {
+	if (typeof raw !== 'string') {
+		return NOT_PROVIDED;
 	}
-	else {
-		console.log('❌ Editorconfig is not matching the expected configuration');
+	return raw
+		.split(',')
+		.map((token) => token.trim().toLowerCase())
+		.filter((token) => token.length > 0);
+}
+
+function formatAliasList() {
+	const grouped = new Map();
+	for (const [alias, target] of Object.entries(ALIASES)) {
+		const list = grouped.get(target) ?? [];
+		list.push(alias);
+		grouped.set(target, list);
 	}
+	return [...grouped.entries()]
+		.map(([target, aliases]) => `${aliases.join(', ')} -> ${target}`)
+		.join('; ');
+}
+
+export function printHelp() {
+	console.log(`Usage: editorconfig --mode=<command> [--path=<path>] [--languages=<list>] [--template=<path|url>]
+
+Commands:
+  write    Create a .editorconfig file with the selected language sections
+  check    Validate per-section against the canonical templates
+
+Options:
+  -m, --mode       Command to run (write | check)
+  -p, --path       Path to the .editorconfig file (default: .editorconfig)
+  -l, --languages  Comma-separated language sections (write: which to emit; check: required set)
+  -o, --overwrite  Overwrite an existing .editorconfig without confirmation
+  -s, --strict     Treat unknown section headers as failures (check only)
+  -t, --template   Path or https URL to a custom .editorconfig-syntax file whose sections override the built-in ones
+  -h, --help       Show this help message
+
+Languages: ${AVAILABLE_LANGUAGES.join(', ')}
+Aliases:   ${formatAliasList()}
+
+Examples:
+  editorconfig --mode=write --languages=js,md
+  editorconfig --mode=write --languages=         # base only
+  editorconfig --mode=write                       # interactive in TTY, base only otherwise
+  editorconfig --mode=check                       # validate sections present in the file
+  editorconfig --mode=check --languages=js,md    # require exactly base + js + md
+  editorconfig --mode=check --strict             # fail on any unknown section header
+  editorconfig --mode=write --template=./team.editorconfig
+  editorconfig --mode=check --template=./team.editorconfig
+  editorconfig --mode=check --template=https://team.example.com/.editorconfig`);
 };
 
-function main() {
-	const args = process.argv.slice(2);
-	const options = {
-		mode: {
-			type: 'string',
-			short: 'm',
-		},
-		path: {
-			type: 'string',
-			short: 'p',
-		},
-	};
-	const { values } = parseArgs({ args, options });
-	const path = values.path || '.editorconfig'
-	if (values.mode === 'write') {
-		createEditorConfig(path);
-	}
-	else if (values.mode === 'check') {
-		compareEditorConfig(path);
+function resolvePromptAnswer(answer) {
+	const tokens = answer
+		.split(',')
+		.map((token) => token.trim().toLowerCase())
+		.filter((token) => token.length > 0);
+	return tokens.map((token) => {
+		const asNumber = Number.parseInt(token, 10);
+		if (Number.isInteger(asNumber) && asNumber >= 1 && asNumber <= AVAILABLE_LANGUAGES.length) {
+			return AVAILABLE_LANGUAGES[asNumber - 1];
+		}
+		return token;
+	});
+}
+
+function promptLanguages() {
+	return new Promise((resolve) => {
+		const rl = createInterface({ input: process.stdin, output: process.stdout });
+		const numbered = AVAILABLE_LANGUAGES
+			.map((name, index) => `  ${index + 1}. ${name}`)
+			.join('\n');
+		console.log(`Available language sections:\n${numbered}`);
+		rl.question('Languages? [comma-separated names or indices, blank=base only] ', (answer) => {
+			rl.close();
+			resolve(resolvePromptAnswer(answer));
+		});
+	});
+}
+
+function resolveLanguages(parsedLanguages) {
+	if (parsedLanguages !== NOT_PROVIDED) {
+		return Promise.resolve(parsedLanguages);
+	}
+	if (process.stdin.isTTY) {
+		return promptLanguages();
+	}
+	return Promise.resolve([]);
+}
+
+function confirmOverwrite(path) {
+	return new Promise((resolve) => {
+		const rl = createInterface({ input: process.stdin, output: process.stdout });
+		rl.question(`\`${path}\` already exists. Overwrite? [y/N] `, (answer) => {
+			rl.close();
+			resolve(/^y(es)?$/iu.test(answer.trim()));
+		});
+	});
+}
+
+async function handleExistingTarget(path, languages, overrides) {
+	if (!process.stdin.isTTY) {
+		console.error(`\`${path}\` already exists. Use --overwrite to replace it.`);
+		process.exitCode = 1;
+		return;
+	}
+	const confirmed = await confirmOverwrite(path);
+	if (confirmed) {
+		createEditorConfig(path, languages, overrides);
 	}
 	else {
-		console.error('invalide commande');
+		console.log(`Skipped: \`${path}\` was not modified.`);
+	}
+}
+
+async function runWrite({ path, overwrite, parsedLanguages, overrides }) {
+	const languages = await resolveLanguages(parsedLanguages);
+	if (!existsSync(path) || overwrite) {
+		createEditorConfig(path, languages, overrides);
+		return;
+	}
+	await handleExistingTarget(path, languages, overrides);
+}
+
+function dispatchCheck({ path, languages, strict, overrides }) {
+	let filter = languages;
+	if (filter === NOT_PROVIDED) {
+		filter = NO_LANGUAGE_FILTER;
+	}
+	try {
+		runCheck({ path, parsedLanguages: filter, strict, overrides });
+	}
+	catch (error) {
+		console.error(error.message);
+		process.exitCode = 1;
 	}
+}
+
+async function dispatchWrite({ path, overwrite, languages, overrides }) {
+	try {
+		await runWrite({ path, overwrite, parsedLanguages: languages, overrides });
+	}
+	catch (error) {
+		console.error(error.message);
+		process.exitCode = 1;
+	}
+}
+
+async function runCommand({ mode, path, overwrite, languages, strict, overrides }) {
+	if (mode === 'write') {
+		await dispatchWrite({ path, overwrite, languages, overrides });
+		return;
+	}
+	if (mode === 'check') {
+		dispatchCheck({ path, languages, strict, overrides });
+		return;
+	}
+	console.error('invalid command');
+	process.exitCode = 1;
+}
+
+function formatCliError(error) {
+	if (error.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION') {
+		return `${error.message.split('.')[0]}. See --help.`;
+	}
+	return error.message;
+}
+
+function parseCliArgs(args) {
+	try {
+		return parseArgs({ args, options });
+	}
+	catch (error) {
+		console.error(formatCliError(error));
+		process.exitCode = 1;
+		return false;
+	}
+}
+
+const OVERRIDES_FAILED = Symbol('overrides-failed');
+
+async function resolveOverrides(templateValue) {
+	if (typeof templateValue !== 'string') {
+		return EMPTY_OVERRIDES;
+	}
+	try {
+		return await loadCustomTemplate(templateValue);
+	}
+	catch (error) {
+		console.error(error.message);
+		process.exitCode = 1;
+		return OVERRIDES_FAILED;
+	}
+}
+
+async function dispatchValues(values) {
+	const overrides = await resolveOverrides(values.template);
+	if (overrides === OVERRIDES_FAILED) {
+		return;
+	}
+	await runCommand({
+		mode: values.mode,
+		path: values.path || '.editorconfig',
+		overwrite: values.overwrite,
+		languages: parseLanguages(values.languages),
+		strict: values.strict,
+		overrides,
+	});
+}
+
+async function main() {
+	const parsed = parseCliArgs(process.argv.slice(2));
+	if (!parsed) {
+		return;
+	}
+	if (parsed.values.help) {
+		printHelp();
+		return;
+	}
+	await dispatchValues(parsed.values);
 };
 
-main();
+if (process.argv[1] === import.meta.filename) {
+	try {
+		await main();
+	}
+	catch (error) {
+		console.error(error.message);
+		process.exitCode = 1;
+	}
+}

package/package.json

@@ -1,10 +1,17 @@
 {
 	"name": "@sheplu/editorconfig",
-	"version": "0.8.6",
+	"version": "0.9.0",
 	"description": "",
 	"main": "index.js",
+	"files": [
+		"index.js",
+		"src/"
+	],
 	"scripts": {
-		"test": "echo \"Error: no test specified\" && exit 1"
+		"lint": "oxlint",
+		"test": "node --test",
+		"test:unit": "node --test 'test/unit/*.test.js'",
+		"test:integration": "node --test 'test/integration/*.test.js'"
 	},
 	"bin": {
 		"@sheplu/editorconfig": "index.js"
@@ -24,8 +31,15 @@
 	"author": "Jean Burellier",
 	"license": "MIT",
 	"type": "module",
+	"engines": {
+		"node": ">=24"
+	},
 	"bugs": {
 		"url": "https://github.com/sheplu/editorconfig/issues"
 	},
-	"homepage": "https://github.com/sheplu/editorconfig#readme"
+	"homepage": "https://github.com/sheplu/editorconfig#readme",
+	"devDependencies": {
+		"node-pty": "1.0.0",
+		"oxlint": "^1.64.0"
+	}
 }

package/src/check.js

@@ -0,0 +1,175 @@
+import { existsSync, readFileSync } from 'node:fs';
+import {
+	BASE_SECTION_HEADER,
+	compareSection,
+	EMPTY_OVERRIDES,
+	expectedBodyForLanguage,
+	headerToLanguage,
+	languageToHeader,
+	parseSections,
+	resolveLanguageNames,
+} from './templates/index.js';
+
+export const NO_LANGUAGE_FILTER = Symbol('check-no-language-filter');
+
+const STATUS_GLYPH = {
+	match: '✅',
+	mismatch: '❌',
+	missing: '❌',
+	'no-root': '❌',
+	unknown: '⚠️ ',
+};
+
+const STATUS_DETAIL = {
+	match: '',
+	mismatch: 'section body does not match',
+	missing: 'missing',
+	'no-root': "missing 'root = true' before sections",
+	unknown: 'unknown header (not validated)',
+};
+
+function languageForHeader(header) {
+	if (header === BASE_SECTION_HEADER) {
+		return 'base';
+	}
+	return headerToLanguage(header);
+}
+
+function checkSection(section, overrides) {
+	const language = languageForHeader(section.header);
+	if (!language) {
+		return { header: section.header, status: 'unknown' };
+	}
+	const expected = expectedBodyForLanguage(language, overrides);
+	const { ok } = compareSection(section.body, expected);
+	if (ok) {
+		return { header: section.header, status: 'match' };
+	}
+	return { header: section.header, status: 'mismatch' };
+}
+
+function buildExpectedHeaders(parsedLanguages) {
+	const resolved = resolveLanguageNames(parsedLanguages);
+	return [BASE_SECTION_HEADER, ...resolved.map((name) => languageToHeader(name))];
+}
+
+function buildResults({ parsedLanguages, parsed, overrides }) {
+	const results = parsed.sections.map((section) => checkSection(section, overrides));
+	if (parsedLanguages !== NO_LANGUAGE_FILTER) {
+		const present = new Set(parsed.sections.map((section) => section.header));
+		const expectedHeaders = buildExpectedHeaders(parsedLanguages);
+		for (const header of expectedHeaders) {
+			if (!present.has(header)) {
+				results.push({ header, status: 'missing' });
+			}
+		}
+	}
+	return results;
+}
+
+function buildBaseIssues(parsed) {
+	const issues = [];
+	const hasBase = parsed.sections.some((section) => section.header === BASE_SECTION_HEADER);
+	if (!hasBase) {
+		issues.push({ header: BASE_SECTION_HEADER, status: 'missing' });
+	}
+	else if (!parsed.hasRoot) {
+		issues.push({ header: BASE_SECTION_HEADER, status: 'no-root' });
+	}
+	return issues;
+}
+
+export function compareEditorConfig(path = '.editorconfig', parsedLanguages = NO_LANGUAGE_FILTER, overrides = EMPTY_OVERRIDES) {
+	if (!existsSync(path)) {
+		throw new Error(`'${path}' does not exist`);
+	}
+	const text = readFileSync(path, 'utf8');
+	const parsed = parseSections(text);
+	const baseIssues = buildBaseIssues(parsed);
+	const results = buildResults({ parsedLanguages, parsed, overrides });
+	return { baseIssues, results };
+}
+
+function formatLine({ header, status }) {
+	const glyph = STATUS_GLYPH[status];
+	const detail = STATUS_DETAIL[status];
+	if (detail) {
+		return `  ${glyph} ${header} ${detail}`;
+	}
+	return `  ${glyph} ${header}`;
+}
+
+export function reportIsFailing({ baseIssues, results }, strict) {
+	const failing = [...baseIssues, ...results].some((entry) =>
+		entry.status === 'mismatch' || entry.status === 'missing' || entry.status === 'no-root',
+	);
+	const hasUnknown = results.some((entry) => entry.status === 'unknown');
+	return failing || (strict && hasUnknown);
+}
+
+function printReport(path, report) {
+	console.log(`Checking ${path}`);
+	console.log('');
+	for (const issue of report.baseIssues) {
+		console.log(formatLine(issue));
+	}
+	for (const entry of report.results) {
+		console.log(formatLine(entry));
+	}
+	console.log('');
+}
+
+function summarize(report) {
+	const lines = [...report.baseIssues, ...report.results];
+	const total = lines.length;
+	const matched = lines.filter((entry) => entry.status === 'match').length;
+	const failed = lines.filter((entry) =>
+		entry.status === 'mismatch' || entry.status === 'missing' || entry.status === 'no-root',
+	).length;
+	const unknown = lines.filter((entry) => entry.status === 'unknown').length;
+	return { total, matched, failed, unknown };
+}
+
+function pluralize(count, singular) {
+	if (count === 1) {
+		return singular;
+	}
+	return `${singular}s`;
+}
+
+function formatFailureSummary({ total, failed, unknown }) {
+	const reasons = [];
+	if (failed > 0) {
+		reasons.push(`${failed} of ${total} ${pluralize(total, 'section')} did not match`);
+	}
+	if (unknown > 0) {
+		reasons.push(`${unknown} unknown ${pluralize(unknown, 'header')}`);
+	}
+	return `❌ FAIL — ${reasons.join('; ')}`;
+}
+
+function formatPassSummary({ matched, unknown }) {
+	const matchedLabel = `${matched} ${pluralize(matched, 'section')} matched`;
+	if (unknown > 0) {
+		return `✅ PASS — ${matchedLabel} (${unknown} unknown ${pluralize(unknown, 'header')} ignored)`;
+	}
+	return `✅ PASS — ${matchedLabel}`;
+}
+
+function formatSummary(report, isFailure) {
+	const counts = summarize(report);
+	if (isFailure) {
+		return formatFailureSummary(counts);
+	}
+	return formatPassSummary(counts);
+}
+
+export function runCheck({ path, parsedLanguages, strict, overrides }) {
+	const report = compareEditorConfig(path, parsedLanguages, overrides);
+	printReport(path, report);
+	const failed = reportIsFailing(report, strict);
+	console.log(formatSummary(report, failed));
+	if (failed) {
+		process.exitCode = 1;
+	}
+}

package/{.editorconfig → src/templates/base.js}

@@ -1,4 +1,4 @@
-root = true
+export const base = `root = true
 
 [*]
 indent_style = tab
@@ -11,3 +11,4 @@ trim_trailing_whitespace = true
 insert_final_newline = true
 quote_type = single
 spaces_around_operators = true
+`;

package/src/templates/css.js

@@ -0,0 +1,4 @@
+export const css = `[*.{css,scss,sass,less}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/custom-template.js

@@ -0,0 +1,123 @@
+import {
+	AVAILABLE_LANGUAGES,
+	BASE_SECTION_HEADER,
+	headerToLanguage,
+	languageToHeader,
+	parseSections,
+} from './index.js';
+import { readTemplateText } from './template-source.js';
+
+const HEADER_LINE = /^\[.*\]$/u;
+const NO_HEADER = '';
+
+function knownHeaders() {
+	return [BASE_SECTION_HEADER, ...AVAILABLE_LANGUAGES.map((name) => languageToHeader(name))];
+}
+
+function languageForHeader(header) {
+	if (header === BASE_SECTION_HEADER) {
+		return 'base';
+	}
+	return headerToLanguage(header);
+}
+
+function trimTrailingBlankLines(lines) {
+	while (lines.length > 0 && lines.at(-1).trim() === '') {
+		lines.pop();
+	}
+}
+
+function flushBlock(state, blocks) {
+	if (state.header === NO_HEADER) {
+		return;
+	}
+	trimTrailingBlankLines(state.lines);
+	blocks.set(state.header, [state.header, ...state.lines].join('\n'));
+}
+
+function processLine(state, blocks, line) {
+	const trimmed = line.trim();
+	if (HEADER_LINE.test(trimmed)) {
+		flushBlock(state, blocks);
+		state.header = trimmed;
+		state.lines = [];
+		return;
+	}
+	if (state.header !== NO_HEADER) {
+		state.lines.push(line);
+	}
+}
+
+function extractRawSections(text) {
+	const normalized = text.replaceAll(/\r\n?/gu, '\n');
+	const blocks = new Map();
+	const state = { header: NO_HEADER, lines: [] };
+	for (const line of normalized.split('\n')) {
+		processLine(state, blocks, line);
+	}
+	flushBlock(state, blocks);
+	return blocks;
+}
+
+function rejectUnknownHeader(path, header) {
+	throw new Error(
+		`custom template '${path}' has unknown header '${header}'. Allowed: ${knownHeaders().join(', ')}`,
+	);
+}
+
+function rejectDuplicate(path, header) {
+	throw new Error(
+		`custom template '${path}' declares header '${header}' more than once`,
+	);
+}
+
+function ingestSection({ path, section, accumulator }) {
+	const language = languageForHeader(section.header);
+	if (!language) {
+		rejectUnknownHeader(path, section.header);
+		return;
+	}
+	if (accumulator.seen.has(language)) {
+		rejectDuplicate(path, section.header);
+		return;
+	}
+	accumulator.seen.add(language);
+	accumulator.bodies.set(language, section.body);
+}
+
+function buildBodies(path, sections) {
+	const accumulator = { bodies: new Map(), seen: new Set() };
+	for (const section of sections) {
+		ingestSection({ path, section, accumulator });
+	}
+	return accumulator.bodies;
+}
+
+function rawSectionFor(language, rawBlocks) {
+	if (language === 'base') {
+		return `root = true\n\n${rawBlocks.get(BASE_SECTION_HEADER)}`;
+	}
+	return rawBlocks.get(languageToHeader(language));
+}
+
+function buildRawSections(bodies, text) {
+	const rawBlocks = extractRawSections(text);
+	const rawSections = new Map();
+	for (const language of bodies.keys()) {
+		rawSections.set(language, rawSectionFor(language, rawBlocks));
+	}
+	return rawSections;
+}
+
+export async function loadCustomTemplate(input) {
+	const text = await readTemplateText(input);
+	const parsed = parseSections(text);
+	const bodies = buildBodies(input, parsed.sections);
+	if (bodies.has('base') && !parsed.hasRoot) {
+		throw new Error(
+			`custom template '${input}' redefines [*] but is missing 'root = true' in the preamble`,
+		);
+	}
+	const rawSections = buildRawSections(bodies, text);
+	return { bodies, rawSections, hasRoot: parsed.hasRoot };
+}

package/src/templates/dockerfile.js

@@ -0,0 +1,4 @@
+export const dockerfile = `[{Dockerfile,Dockerfile.*,*.dockerfile}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/go.js

@@ -0,0 +1,5 @@
+export const go = `[*.go]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+`;

package/src/templates/html.js

@@ -0,0 +1,4 @@
+export const html = `[*.{html,htm}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/index.js

@@ -0,0 +1,277 @@
+import { base } from './base.js';
+import { javascript } from './javascript.js';
+import { yaml } from './yaml.js';
+import { markdown } from './markdown.js';
+import { python } from './python.js';
+import { go } from './go.js';
+import { rust } from './rust.js';
+import { terraform } from './terraform.js';
+import { json } from './json.js';
+import { toml } from './toml.js';
+import { shell } from './shell.js';
+import { makefile } from './makefile.js';
+import { dockerfile } from './dockerfile.js';
+import { html } from './html.js';
+import { css } from './css.js';
+
+export {
+	base,
+	javascript,
+	yaml,
+	markdown,
+	python,
+	go,
+	rust,
+	terraform,
+	json,
+	toml,
+	shell,
+	makefile,
+	dockerfile,
+	html,
+	css,
+};
+
+export const AVAILABLE_LANGUAGES = [
+	'javascript',
+	'yaml',
+	'markdown',
+	'python',
+	'go',
+	'rust',
+	'terraform',
+	'json',
+	'toml',
+	'shell',
+	'makefile',
+	'dockerfile',
+	'html',
+	'css',
+];
+
+export const ALIASES = {
+	js: 'javascript',
+	jsx: 'javascript',
+	ts: 'javascript',
+	tsx: 'javascript',
+	mjs: 'javascript',
+	cjs: 'javascript',
+	yml: 'yaml',
+	md: 'markdown',
+	py: 'python',
+	rs: 'rust',
+	tf: 'terraform',
+	tfvars: 'terraform',
+	sh: 'shell',
+	bash: 'shell',
+	zsh: 'shell',
+	mk: 'makefile',
+	htm: 'html',
+	scss: 'css',
+	sass: 'css',
+	less: 'css',
+};
+
+const LANGUAGE_TEMPLATES = {
+	javascript,
+	yaml,
+	markdown,
+	python,
+	go,
+	rust,
+	terraform,
+	json,
+	toml,
+	shell,
+	makefile,
+	dockerfile,
+	html,
+	css,
+};
+
+function joinSections(sections) {
+	return `${sections
+		.map((section) => section.replace(/\n+$/u, ''))
+		.join('\n\n')}\n`;
+}
+
+export const EMPTY_OVERRIDES = Object.freeze({
+	bodies: new Map(),
+	rawSections: new Map(),
+	hasRoot: false,
+});
+
+function pickSection(name, builtin, overrides) {
+	if (overrides.rawSections.has(name)) {
+		return overrides.rawSections.get(name);
+	}
+	return builtin;
+}
+
+export function composeEditorConfig(languageNames = [], overrides = EMPTY_OVERRIDES) {
+	const resolved = new Set();
+	for (const raw of languageNames) {
+		const name = ALIASES[raw] ?? raw;
+		if (!Object.hasOwn(LANGUAGE_TEMPLATES, name)) {
+			throw new Error(
+				`unknown language: '${raw}'. Available: ${AVAILABLE_LANGUAGES.join(', ')}`,
+			);
+		}
+		resolved.add(name);
+	}
+	const ordered = AVAILABLE_LANGUAGES.filter((name) => resolved.has(name));
+	const sections = [
+		pickSection('base', base, overrides),
+		...ordered.map((name) => pickSection(name, LANGUAGE_TEMPLATES[name], overrides)),
+	];
+	return joinSections(sections);
+}
+
+export const editorconfigContent = composeEditorConfig(AVAILABLE_LANGUAGES);
+
+const BASE_HEADER = '[*]';
+
+function extractHeader(template) {
+	return template.split('\n', 1)[0];
+}
+
+const HEADER_TO_LANGUAGE = new Map(
+	AVAILABLE_LANGUAGES.map((name) => [extractHeader(LANGUAGE_TEMPLATES[name]), name]),
+);
+
+export function headerToLanguage(header) {
+	return HEADER_TO_LANGUAGE.get(header);
+}
+
+function isIgnoredLine(line) {
+	if (line === '' || line.startsWith('#') || line.startsWith(';')) {
+		return true;
+	}
+	if (line.startsWith('[') && line.endsWith(']')) {
+		return true;
+	}
+	return false;
+}
+
+function applyKeyValue(body, line) {
+	const equalsAt = line.indexOf('=');
+	if (equalsAt === -1) {
+		return;
+	}
+	const key = line.slice(0, equalsAt).trim().toLowerCase();
+	if (key.length === 0) {
+		return;
+	}
+	body.set(key, line.slice(equalsAt + 1).trim());
+}
+
+export function parseSection(block) {
+	const body = new Map();
+	for (const rawLine of block.split('\n')) {
+		const line = rawLine.trim();
+		if (!isIgnoredLine(line)) {
+			applyKeyValue(body, line);
+		}
+	}
+	return body;
+}
+
+function finishSection({ header, lines }) {
+	return {
+		header,
+		body: parseSection(lines.join('\n')),
+	};
+}
+
+function processLine(state, line) {
+	const trimmed = line.trim();
+	if (/^\[.*\]$/u.test(trimmed)) {
+		if (state.current) {
+			state.sections.push(finishSection(state.current));
+		}
+		state.current = { header: trimmed, lines: [] };
+	}
+	else if (state.current) {
+		state.current.lines.push(line);
+	}
+	else {
+		state.preamble.push(line);
+	}
+}
+
+function splitSections(lines) {
+	const state = { sections: [], preamble: [], current: false };
+	for (const line of lines) {
+		processLine(state, line);
+	}
+	if (state.current) {
+		state.sections.push(finishSection(state.current));
+	}
+	return { sections: state.sections, preamble: state.preamble };
+}
+
+export function parseSections(text) {
+	const normalized = text.replaceAll(/\r\n?/gu, '\n');
+	const { sections, preamble } = splitSections(normalized.split('\n'));
+	const hasRoot = preamble.some((line) => /^\s*root\s*=\s*true\s*$/iu.test(line));
+	return { hasRoot, sections };
+}
+
+export function compareSection(actualBody, expectedBody) {
+	if (actualBody.size !== expectedBody.size) {
+		return { ok: false };
+	}
+	for (const [key, value] of expectedBody) {
+		if (!actualBody.has(key) || actualBody.get(key) !== value) {
+			return { ok: false };
+		}
+	}
+	return { ok: true };
+}
+
+function bodyAfterHeader(template) {
+	const headerEnd = template.indexOf('\n');
+	return template.slice(headerEnd + 1);
+}
+
+function bodyAfterFirstHeader(template) {
+	const lines = template.split('\n');
+	const headerIndex = lines.findIndex((line) => /^\[.*\]$/u.test(line.trim()));
+	if (headerIndex === -1) {
+		return template;
+	}
+	return lines.slice(headerIndex + 1).join('\n');
+}
+
+export function expectedBodyForLanguage(language, overrides = EMPTY_OVERRIDES) {
+	if (overrides.bodies.has(language)) {
+		return overrides.bodies.get(language);
+	}
+	if (language === 'base') {
+		return parseSection(bodyAfterFirstHeader(base));
+	}
+	return parseSection(bodyAfterHeader(LANGUAGE_TEMPLATES[language]));
+}
+
+export function resolveLanguageNames(languageNames) {
+	const resolved = new Set();
+	for (const raw of languageNames) {
+		const name = ALIASES[raw] ?? raw;
+		if (!Object.hasOwn(LANGUAGE_TEMPLATES, name)) {
+			throw new Error(
+				`unknown language: '${raw}'. Available: ${AVAILABLE_LANGUAGES.join(', ')}`,
+			);
+		}
+		resolved.add(name);
+	}
+	return AVAILABLE_LANGUAGES.filter((name) => resolved.has(name));
+}
+
+export function languageToHeader(language) {
+	if (language === 'base') {
+		return BASE_HEADER;
+	}
+	return extractHeader(LANGUAGE_TEMPLATES[language]);
+}
+
+export const BASE_SECTION_HEADER = BASE_HEADER;

package/src/templates/javascript.js

@@ -0,0 +1,6 @@
+export const javascript = `[*.{js,jsx,ts,tsx,mjs,cjs}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+quote_type = single
+`;

package/src/templates/json.js

@@ -0,0 +1,4 @@
+export const json = `[*.json]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/makefile.js

@@ -0,0 +1,5 @@
+export const makefile = `[{Makefile,GNUmakefile,makefile,*.mk}]
+indent_style = tab
+indent_size = 4
+tab_width = 4
+`;

package/src/templates/markdown.js

@@ -0,0 +1,5 @@
+export const markdown = `[*.md]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = false
+`;

package/src/templates/python.js

@@ -0,0 +1,5 @@
+export const python = `[*.py]
+indent_style = space
+indent_size = 4
+max_line_length = 88
+`;

package/src/templates/rust.js

@@ -0,0 +1,5 @@
+export const rust = `[*.rs]
+indent_style = space
+indent_size = 4
+max_line_length = 100
+`;

package/src/templates/shell.js

@@ -0,0 +1,4 @@
+export const shell = `[*.{sh,bash,zsh}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/template-source.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { fetchTemplate } from '../utils/fetch.js';
+import { isHttpScheme, tryParseUrl } from '../utils/url.js';
+
+function readLocalFile(path) {
+	if (!existsSync(path)) {
+		throw new Error(`custom template '${path}' does not exist`);
+	}
+	return readFileSync(path, 'utf8');
+}
+
+export async function readTemplateText(input) {
+	if (typeof input !== 'string' || input.trim() === '') {
+		throw new Error('--template requires a path or URL to a custom template');
+	}
+	const url = tryParseUrl(input);
+	if (url && isHttpScheme(url)) {
+		if (url.protocol !== 'https:') {
+			throw new Error(`--template URL must use https (got '${url.protocol.replace(':', '')}')`);
+		}
+		return await fetchTemplate(url.href);
+	}
+	return readLocalFile(input);
+}

package/src/templates/terraform.js

@@ -0,0 +1,4 @@
+export const terraform = `[*.{tf,tfvars}]
+indent_style = space
+indent_size = 2
+`;

package/src/templates/toml.js

@@ -0,0 +1,4 @@
+export const toml = `[*.toml]
+indent_style = space
+indent_size = 4
+`;

package/src/templates/yaml.js

@@ -0,0 +1,4 @@
+export const yaml = `[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+`;

package/src/utils/fetch.js

@@ -0,0 +1,104 @@
+import { parseRedirectLocation } from './url.js';
+
+const TIMEOUT_MS = 10_000;
+const MAX_BYTES = 1_048_576;
+const MAX_REDIRECTS = 5;
+
+function ignoreCancelError() {
+	return false;
+}
+
+export function isRedirect(status) {
+	return status >= 300 && status < 400;
+}
+
+export function rejectOversized(url) {
+	throw new Error(`template body for '${url}' exceeds 1 MB limit`);
+}
+
+export function checkContentLength(response, url) {
+	const header = response.headers.get('content-length');
+	if (header === null) {
+		return;
+	}
+	const bytes = Number.parseInt(header, 10);
+	if (Number.isFinite(bytes) && bytes > MAX_BYTES) {
+		rejectOversized(url);
+	}
+}
+
+export function decodeChunks(chunks) {
+	return new TextDecoder('utf-8').decode(Buffer.concat(chunks));
+}
+
+export function appendChunk({ state, value, reader, url }) {
+	state.total += value.byteLength;
+	if (state.total > MAX_BYTES) {
+		// We're about to throw rejectOversized; swallow any cancel() rejection.
+		reader.cancel().catch(ignoreCancelError);
+		rejectOversized(url);
+	}
+	state.chunks.push(value);
+}
+
+export async function consumeStream(reader, url) {
+	const state = { chunks: [], total: 0 };
+	for (;;) {
+		// eslint-disable-next-line no-await-in-loop
+		const { value, done } = await reader.read();
+		if (done) {
+			return decodeChunks(state.chunks);
+		}
+		appendChunk({ state, value, reader, url });
+	}
+}
+
+export async function readBoundedBody(response, url) {
+	checkContentLength(response, url);
+	return await consumeStream(response.body.getReader(), url);
+}
+
+export function resolveRedirect(response, currentUrl) {
+	const location = response.headers.get('location');
+	return parseRedirectLocation(location, currentUrl);
+}
+
+export async function performFetch(initialUrl, signal) {
+	let url = initialUrl;
+	for (let hop = 0; hop <= MAX_REDIRECTS; hop += 1) {
+		// eslint-disable-next-line no-await-in-loop
+		const response = await fetch(url, { signal, redirect: 'manual' });
+		if (response.ok) {
+			return readBoundedBody(response, url);
+		}
+		if (!isRedirect(response.status)) {
+			throw new Error(`failed to fetch '${url}': HTTP ${response.status}`);
+		}
+		url = resolveRedirect(response, url);
+	}
+	throw new Error(`failed to fetch '${initialUrl}': too many redirects (max ${MAX_REDIRECTS})`);
+}
+
+export function describeFetchError(url, error) {
+	if (error.name === 'AbortError') {
+		return new Error(`failed to fetch '${url}': request timed out after ${TIMEOUT_MS / 1000}s`);
+	}
+	if (/^failed to fetch |^template body /u.test(error.message)) {
+		return error;
+	}
+	return new Error(`failed to fetch '${url}': ${error.message}`);
+}
+
+export async function fetchTemplate(url) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+	try {
+		return await performFetch(url, controller.signal);
+	}
+	catch (error) {
+		throw describeFetchError(url, error);
+	}
+	finally {
+		clearTimeout(timer);
+	}
+}

package/src/utils/url.js

@@ -0,0 +1,23 @@
+export function tryParseUrl(input) {
+	try {
+		return new URL(input);
+	}
+	catch {
+		return false;
+	}
+}
+
+export function isHttpScheme(url) {
+	return url.protocol === 'http:' || url.protocol === 'https:';
+}
+
+export function parseRedirectLocation(location, currentUrl) {
+	if (typeof location !== 'string' || location.length === 0) {
+		throw new Error(`failed to fetch '${currentUrl}': redirect missing Location header`);
+	}
+	const next = new URL(location, currentUrl);
+	if (next.protocol !== 'https:') {
+		throw new Error(`failed to fetch '${currentUrl}': refused redirect to non-https '${next.href}'`);
+	}
+	return next.href;
+}

package/.github/workflows/npm-release.yaml

@@ -1,42 +0,0 @@
-name: Publish package
-on:
-  release:
-    types: [created]
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    environment: prod
-    permissions:
-      contents: read
-      id-token: write
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v5
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v6
-        with:
-          node-version: 24
-          registry-url: https://registry.npmjs.org
-
-      - name: NPM install
-        run: |
-          npm install
-
-      - name: Version
-        if: github.event_name == 'release' && github.event.action == 'created'
-        run: |
-          VERSION=${{ github.event.release.tag_name }}
-          VERSION=${VERSION:1}
-          CURRENT_VERSION=$(npm pkg get version | tr -d '"')
-          if [ "$CURRENT_VERSION" != "$VERSION" ]; then
-            npm version $VERSION --no-git-tag-version
-          else
-            echo "Version already set to $VERSION, skipping npm version command"
-          fi
-
-      - name: publish
-        run: |
-          npm publish --access public