@atcute/lex-cli 2.5.3 → 2.6.1

package/src/commands/pull.ts

@@ -8,13 +8,13 @@ import { message } from '@optique/core/message';
 import { type InferValue } from '@optique/core/parser';
 import { command, constant } from '@optique/core/primitives';
 import pc from 'picocolors';
-import prettier from 'prettier';
 
-import { loadConfig, type NormalizedConfig, type PullConfig, type SourceConfig } from '../config.js';
-import { pullAtprotoSource } from '../pull-sources/atproto.js';
-import { pullGitSource } from '../pull-sources/git.js';
-import type { PullResult, PulledLexicon, SourceLocation } from '../pull-sources/types.js';
-import { sharedOptions } from '../shared-options.js';
+import { loadConfig, type NormalizedConfig, type PullConfig, type SourceConfig } from '../config.ts';
+import { createFormatter, type Formatter } from '../formatter.ts';
+import { pullAtprotoSource } from '../pull-sources/atproto.ts';
+import { pullGitSource } from '../pull-sources/git.ts';
+import type { PullResult, PulledLexicon, SourceLocation } from '../pull-sources/types.ts';
+import { sharedOptions } from '../shared-options.ts';
 
 export const pullCommandSchema = command(
 	'pull',
@@ -110,16 +110,13 @@ const writeLexicon = async (
 	outdir: string,
 	nsid: string,
 	doc: LexiconDoc,
-	prettierConfig: prettier.Options | null,
+	formatter: Formatter,
 ): Promise<void> => {
 	const nsidPath = nsid.replaceAll('.', '/');
 	const target = path.join(outdir, `${nsidPath}.json`);
 	const dirname = path.dirname(target);
 
-	const code = await prettier.format(JSON.stringify(doc, null, 2), {
-		...prettierConfig,
-		parser: 'json',
-	});
+	const code = await formatter.format(JSON.stringify(doc, null, 2), target);
 
 	await fs.mkdir(dirname, { recursive: true });
 	await fs.writeFile(target, code);
@@ -139,7 +136,7 @@ const pullSource = async (source: SourceConfig): Promise<PullResult> => {
 const writeSourceReadme = async (
 	outdir: string,
 	revisions: SourceRevision[],
-	prettierConfig: prettier.Options | null,
+	formatter: Formatter,
 ): Promise<void> => {
 	const lines = [
 		'# lexicon sources',
@@ -173,12 +170,10 @@ const writeSourceReadme = async (
 	lines.push('');
 
 	const content = lines.join('\n');
-	const formatted = await prettier.format(content, {
-		...prettierConfig,
-		parser: 'markdown',
-	});
+	const target = path.join(outdir, 'README.md');
+	const formatted = await formatter.format(content, target);
 
-	await fs.writeFile(path.join(outdir, 'README.md'), formatted);
+	await fs.writeFile(target, formatted);
 };
 
 /**
@@ -190,43 +185,46 @@ export const runPull = async (args: PullCommand): Promise<void> => {
 	const pullConfig = ensurePullConfig(config);
 
 	const outdir = path.resolve(config.root, pullConfig.outdir);
-	const prettierConfig = await prettier.resolveConfig(config.root, { editorconfig: true });
+	const formatter = await createFormatter(config.formatter, config.root);
 
-	const seen = new Map<string, SourceLocation>();
-	const collected: PulledLexicon[] = [];
-	const sourceRevisions: SourceRevision[] = [];
+	try {
+		const seen = new Map<string, SourceLocation>();
+		const collected: PulledLexicon[] = [];
+		const sourceRevisions: SourceRevision[] = [];
 
-	for (const source of pullConfig.sources) {
-		const result = await pullSource(source);
+		for (const source of pullConfig.sources) {
+			const result = await pullSource(source);
 
-		sourceRevisions.push({ source, rev: result.rev });
+			sourceRevisions.push({ source, rev: result.rev });
 
-		for (const [nsid, entry] of result.pulled) {
-			const existing = seen.get(nsid);
+			for (const [nsid, entry] of result.pulled) {
+				const existing = seen.get(nsid);
 
-			if (existing) {
-				console.error(pc.bold(pc.red(`duplicate lexicon "${nsid}"`)));
-				console.error(`- found ${entry.location.relativePath} from ${entry.location.sourceDescription}`);
-				console.error(`  at ${entry.location.absolutePath}`);
-				console.error(`- already found ${existing.relativePath} from ${existing.sourceDescription}`);
-				console.error(`  at ${existing.absolutePath}`);
-				process.exit(1);
-			}
+				if (existing) {
+					console.error(pc.bold(pc.red(`duplicate lexicon "${nsid}"`)));
+					console.error(`- found ${entry.location.relativePath} from ${entry.location.sourceDescription}`);
+					console.error(`  at ${entry.location.absolutePath}`);
+					console.error(`- already found ${existing.relativePath} from ${existing.sourceDescription}`);
+					console.error(`  at ${existing.absolutePath}`);
+					process.exit(1);
+				}
 
-			seen.set(nsid, entry.location);
-			collected.push(entry);
+				seen.set(nsid, entry.location);
+				collected.push(entry);
+			}
 		}
-	}
 
-	if (pullConfig.clean) {
-		await fs.rm(outdir, { recursive: true, force: true });
-	}
+		if (pullConfig.clean) {
+			await fs.rm(outdir, { recursive: true, force: true });
+		}
 
-	await fs.mkdir(outdir, { recursive: true });
+		await fs.mkdir(outdir, { recursive: true });
 
-	for (const entry of collected) {
-		await writeLexicon(outdir, entry.nsid, entry.doc, prettierConfig);
+		await Promise.all([
+			...collected.map((entry) => writeLexicon(outdir, entry.nsid, entry.doc, formatter)),
+			writeSourceReadme(outdir, sourceRevisions, formatter),
+		]);
+	} finally {
+		await formatter.dispose();
 	}
-
-	await writeSourceReadme(outdir, sourceRevisions, prettierConfig);
 };

package/src/config.ts

@@ -8,7 +8,7 @@ import { isHandle, isNsid } from '@atcute/lexicons/syntax';
 import * as v from '@badrap/valita';
 import pc from 'picocolors';
 
-import type { ImportMapping } from './codegen.js';
+import type { ImportMapping } from './codegen.ts';
 
 const gitSourceConfigSchema = v.object({
 	type: v.literal('git'),
@@ -63,6 +63,22 @@ const exportConfigSchema = v.object({
 	clean: v.boolean().optional(),
 });
 
+const formatterConfigSchema = v.union(
+	v.object({ type: v.literal('prettier') }),
+	v.object({
+		type: v.literal('command'),
+		command: v.string().assert((value) => value.length > 0, `must not be empty`),
+		concurrency: v
+			.number()
+			.assert((value) => Number.isInteger(value) && value > 0, `must be a positive integer`)
+			.optional(() => 1),
+	}),
+	v.object({
+		type: v.literal('lsp'),
+		command: v.string().assert((value) => value.length > 0, `must not be empty`),
+	}),
+);
+
 export type GitSourceConfig = v.Infer<typeof gitSourceConfigSchema>;
 export type AtprotoNsidsSourceConfig = v.Infer<typeof atprotoNsidsSourceConfigSchema>;
 export type AtprotoAuthoritySourceConfig = v.Infer<typeof atprotoAuthoritySourceConfigSchema>;
@@ -70,6 +86,7 @@ export type AtprotoSourceConfig = v.Infer<typeof atprotoSourceConfigSchema>;
 export type SourceConfig = v.Infer<typeof sourceConfigSchema>;
 export type PullConfig = v.Infer<typeof pullConfigSchema>;
 export type ExportConfig = v.Infer<typeof exportConfigSchema>;
+export type FormatterConfig = v.Infer<typeof formatterConfigSchema>;
 
 const isValidLexiconPattern = (pattern: string): boolean => {
 	if (pattern.endsWith('.*')) {
@@ -126,6 +143,7 @@ export const lexiconConfigSchema = v.object({
 		})
 		.partial()
 		.optional(),
+	formatter: formatterConfigSchema.optional((): FormatterConfig => ({ type: 'prettier' })),
 	pull: pullConfigSchema.optional(),
 	export: exportConfigSchema.optional(),
 });

package/src/formatter.ts

@@ -0,0 +1,157 @@
+import { spawn } from 'node:child_process';
+
+import type { FormatterConfig } from './config.ts';
+import { createLspClient } from './lsp-client.ts';
+
+/** formats source code */
+export interface Formatter {
+	/**
+	 * formats the given code
+	 * @param code source code to format
+	 * @param filepath filepath hint for language detection and config resolution
+	 * @returns formatted code
+	 */
+	format(code: string, filepath: string): Promise<string>;
+	/** releases any resources held by the formatter */
+	dispose(): Promise<void>;
+}
+
+const inferPrettierParser = (filepath: string): string => {
+	if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
+		return 'typescript';
+	}
+	if (filepath.endsWith('.json')) {
+		return 'json';
+	}
+	if (filepath.endsWith('.md') || filepath.endsWith('.markdown')) {
+		return 'markdown';
+	}
+	return 'typescript';
+};
+
+// #region semaphore
+
+interface Lock {
+	release(): void;
+}
+
+class Semaphore {
+	private waiting: (() => void)[] = [];
+	private active = 0;
+	private max: number;
+
+	constructor(max: number) {
+		this.max = max;
+	}
+
+	acquire(): Promise<Lock> {
+		const lock: Lock = {
+			release: () => {
+				this.active--;
+				const next = this.waiting.shift();
+				if (next) {
+					this.active++;
+					next();
+				}
+			},
+		};
+
+		if (this.active < this.max) {
+			this.active++;
+			return Promise.resolve(lock);
+		}
+
+		const { promise, resolve } = Promise.withResolvers<Lock>();
+		this.waiting.push(() => resolve(lock));
+		return promise;
+	}
+}
+
+// #endregion
+
+/**
+ * creates a formatter from the given configuration
+ * @param config formatter configuration
+ * @param root project root for config resolution
+ * @returns a formatter instance
+ */
+export const createFormatter = async (config: FormatterConfig, root: string): Promise<Formatter> => {
+	switch (config.type) {
+		case 'prettier': {
+			const prettier = await import('prettier');
+			const prettierConfig = await prettier.resolveConfig(root, { editorconfig: true });
+
+			return {
+				async format(code, filepath) {
+					return prettier.format(code, { ...prettierConfig, parser: inferPrettierParser(filepath) });
+				},
+				async dispose() {},
+			};
+		}
+		case 'command': {
+			// the template uses {filepath} as a placeholder, which is passed as a
+			// positional argument to sh to avoid shell injection via filenames
+			const shellCmd = config.command.replaceAll('{filepath}', '"$1"');
+			const semaphore = new Semaphore(config.concurrency);
+
+			return {
+				async format(code, filepath) {
+					const lock = await semaphore.acquire();
+
+					try {
+						return await new Promise<string>((resolve, reject) => {
+							const child = spawn('sh', ['-c', shellCmd, 'sh', filepath], {
+								stdio: ['pipe', 'pipe', 'pipe'],
+							});
+
+							const stdoutChunks: Buffer[] = [];
+							const stderrChunks: Buffer[] = [];
+
+							child.stdout.on('data', (chunk: Buffer) => {
+								stdoutChunks.push(chunk);
+							});
+
+							child.stderr.on('data', (chunk: Buffer) => {
+								stderrChunks.push(chunk);
+							});
+
+							child.on('error', reject);
+
+							child.on('close', (exitCode: number | null) => {
+								if (exitCode !== 0) {
+									const stderr = Buffer.concat(stderrChunks).toString();
+									reject(new Error(`formatter exited with code ${exitCode}:\n${stderr}`));
+								} else {
+									resolve(Buffer.concat(stdoutChunks).toString());
+								}
+							});
+
+							child.stdin.end(code);
+						});
+					} finally {
+						lock.release();
+					}
+				},
+				async dispose() {},
+			};
+		}
+		case 'lsp': {
+			const client = await createLspClient(config.command, root);
+			const semaphore = new Semaphore(1);
+
+			return {
+				async format(code, filepath) {
+					const lock = await semaphore.acquire();
+					try {
+						return await client.formatDocument(code, filepath);
+					} finally {
+						lock.release();
+					}
+				},
+				async dispose() {
+					await client.dispose();
+				},
+			};
+		}
+	}
+};

package/src/index.ts

@@ -1,4 +1,4 @@
-import { lexiconConfigSchema, type LexiconConfig } from './config.js';
+import { lexiconConfigSchema, type LexiconConfig } from './config.ts';
 
 export type { LexiconConfig };
 

package/src/lsp-client.ts

@@ -0,0 +1,283 @@
+import { spawn } from 'node:child_process';
+import * as url from 'node:url';
+
+import { getUtf8Length } from '@atcute/uint8array';
+
+// #region types
+
+interface Position {
+	line: number;
+	character: number;
+}
+
+interface Range {
+	start: Position;
+	end: Position;
+}
+
+interface TextEdit {
+	range: Range;
+	newText: string;
+}
+
+interface JsonRpcMessage {
+	jsonrpc: '2.0';
+	id?: number;
+	method?: string;
+	params?: unknown;
+	result?: unknown;
+	error?: { code: number; message: string; data?: unknown };
+}
+
+// #endregion
+
+// #region text edits
+
+const applyTextEdits = (code: string, edits: TextEdit[]): string => {
+	if (edits.length === 0) {
+		return code;
+	}
+
+	// build line start offsets
+	const lineStarts = [0];
+	for (let i = 0; i < code.length; i++) {
+		if (code[i] === '\n') {
+			lineStarts.push(i + 1);
+		}
+	}
+
+	const positionToOffset = (pos: Position): number => {
+		return (lineStarts[pos.line] ?? code.length) + pos.character;
+	};
+
+	// sort edits in reverse document order so earlier positions stay valid
+	const sorted = edits.toSorted((a, b) => {
+		const lineDiff = b.range.start.line - a.range.start.line;
+		if (lineDiff !== 0) {
+			return lineDiff;
+		}
+		return b.range.start.character - a.range.start.character;
+	});
+
+	let result = code;
+	for (const edit of sorted) {
+		const start = positionToOffset(edit.range.start);
+		const end = positionToOffset(edit.range.end);
+		result = result.slice(0, start) + edit.newText + result.slice(end);
+	}
+
+	return result;
+};
+
+// #endregion
+
+const inferLanguageId = (filepath: string): string => {
+	if (filepath.endsWith('.ts') || filepath.endsWith('.tsx')) {
+		return 'typescript';
+	}
+	if (filepath.endsWith('.json')) {
+		return 'json';
+	}
+	if (filepath.endsWith('.md') || filepath.endsWith('.markdown')) {
+		return 'markdown';
+	}
+	return 'typescript';
+};
+
+/** LSP client for formatting documents */
+export interface LspClient {
+	/**
+	 * formats a document via LSP textDocument/formatting
+	 * @param code source code to format
+	 * @param filepath filepath for language detection and URI
+	 * @returns formatted code
+	 */
+	formatDocument(code: string, filepath: string): Promise<string>;
+	/** shuts down the LSP server */
+	dispose(): Promise<void>;
+}
+
+/**
+ * creates an LSP client that communicates with a formatter over stdio
+ * @param command shell command to spawn the LSP server
+ * @param root project root for LSP rootUri
+ * @returns an initialized LSP client ready for formatting
+ */
+export const createLspClient = async (command: string, root: string): Promise<LspClient> => {
+	const child = spawn('sh', ['-c', command], {
+		stdio: ['pipe', 'pipe', 'pipe'],
+	});
+
+	// prevent EPIPE crash when child exits mid-write; actual errors
+	// are handled by the close/error handlers below
+	child.stdin.on('error', () => {});
+
+	// #region JSON-RPC framing
+
+	const pending = new Map<number, PromiseWithResolvers<unknown>>();
+	let nextId = 1;
+	let exited = false;
+
+	const sendMessage = (message: Record<string, unknown>): void => {
+		if (exited) {
+			return;
+		}
+
+		const json = JSON.stringify(message);
+		const byteLength = getUtf8Length(json);
+
+		child.stdin.write(`Content-Length: ${byteLength}\r\n\r\n${json}`);
+	};
+
+	const sendRequest = (method: string, params?: unknown): Promise<unknown> => {
+		if (exited) {
+			return Promise.reject(new Error(`LSP server has already exited`));
+		}
+
+		const id = nextId++;
+		const deferred = Promise.withResolvers<unknown>();
+
+		pending.set(id, deferred);
+		sendMessage({ jsonrpc: '2.0', id, method, params });
+
+		return deferred.promise;
+	};
+
+	const sendNotification = (method: string, params?: unknown): void => {
+		sendMessage({ jsonrpc: '2.0', method, params });
+	};
+
+	// incremental message parser
+	const HEADER_SEPARATOR = Buffer.from('\r\n\r\n');
+
+	let buffer: Buffer = Buffer.alloc(0);
+	let contentLength = -1;
+
+	const processBuffer = (): void => {
+		while (true) {
+			if (contentLength === -1) {
+				const separatorIndex = buffer.indexOf(HEADER_SEPARATOR);
+				if (separatorIndex === -1) {
+					break;
+				}
+
+				const header = buffer.toString('utf8', 0, separatorIndex);
+				const match = header.match(/Content-Length:\s*(\d+)/i);
+
+				buffer = buffer.subarray(separatorIndex + 4);
+
+				if (!match) {
+					continue;
+				}
+
+				contentLength = parseInt(match[1], 10);
+			}
+
+			if (buffer.length < contentLength) {
+				break;
+			}
+
+			const body = buffer.toString('utf8', 0, contentLength);
+			buffer = buffer.subarray(contentLength);
+			contentLength = -1;
+
+			let message: JsonRpcMessage;
+			try {
+				message = JSON.parse(body);
+			} catch {
+				continue;
+			}
+
+			// dispatch responses to pending requests, ignore everything else
+			if (message.id != null) {
+				const entry = pending.get(message.id);
+				if (entry) {
+					pending.delete(message.id);
+
+					if (message.error) {
+						entry.reject(new Error(`LSP error ${message.error.code}: ${message.error.message}`));
+					} else {
+						entry.resolve(message.result);
+					}
+				}
+			}
+		}
+	};
+
+	child.stdout.on('data', (chunk: Buffer) => {
+		buffer = buffer.length > 0 ? Buffer.concat([buffer, chunk]) : chunk;
+		processBuffer();
+	});
+
+	const rejectPending = (error: Error): void => {
+		for (const [, entry] of pending) {
+			entry.reject(error);
+		}
+		pending.clear();
+	};
+
+	child.on('error', (err) => {
+		exited = true;
+		rejectPending(err);
+	});
+
+	child.on('close', (exitCode) => {
+		exited = true;
+		rejectPending(new Error(`LSP server exited unexpectedly with code ${exitCode}`));
+	});
+
+	// #endregion
+
+	// #region initialize handshake
+
+	const rootUri = url.pathToFileURL(root).href;
+
+	await sendRequest('initialize', {
+		processId: process.pid,
+		clientInfo: { name: 'lex-cli' },
+		rootUri,
+		capabilities: {},
+	});
+
+	sendNotification('initialized');
+
+	// #endregion
+
+	return {
+		async formatDocument(code, filepath) {
+			const uri = url.pathToFileURL(filepath).href;
+			const languageId = inferLanguageId(filepath);
+
+			sendNotification('textDocument/didOpen', {
+				textDocument: { uri, languageId, version: 1, text: code },
+			});
+
+			const edits = (await sendRequest('textDocument/formatting', {
+				textDocument: { uri },
+				options: { tabSize: 2, insertSpaces: false },
+			})) as TextEdit[] | null;
+
+			sendNotification('textDocument/didClose', {
+				textDocument: { uri },
+			});
+
+			if (!edits || edits.length === 0) {
+				return code;
+			}
+
+			return applyTextEdits(code, edits);
+		},
+
+		async dispose() {
+			if (!exited) {
+				await sendRequest('shutdown', null);
+				sendNotification('exit');
+			}
+
+			if (!exited) {
+				child.kill();
+				await new Promise<void>((resolve) => child.on('close', resolve));
+			}
+		},
+	};
+};

package/src/pull-sources/atproto.ts

@@ -20,9 +20,9 @@ import {
 
 import pc from 'picocolors';
 
-import type { AtprotoSourceConfig } from '../config.js';
+import type { AtprotoSourceConfig } from '../config.ts';
 
-import type { PullResult, SourceLocation } from './types.js';
+import type { PullResult, SourceLocation } from './types.ts';
 
 /**
  * discovers all published lexicons for an authority by listing records in the

package/src/pull-sources/git.ts

@@ -6,10 +6,10 @@ import type { LexiconDoc } from '@atcute/lexicon-doc';
 
 import pc from 'picocolors';
 
-import type { GitSourceConfig } from '../config.js';
-import { runGit, GitError } from '../git.js';
+import type { GitSourceConfig } from '../config.ts';
+import { runGit, GitError } from '../git.ts';
 
-import type { PullResult, PulledLexicon, SourceLocation } from './types.js';
+import type { PullResult, PulledLexicon, SourceLocation } from './types.ts';
 
 /**
  * pulls lexicon documents from a git repository source