@atcute/lex-cli 2.6.0 → 2.7.0

package/src/commands/pull.ts

@@ -187,40 +187,44 @@ export const runPull = async (args: PullCommand): Promise<void> => {
 	const outdir = path.resolve(config.root, pullConfig.outdir);
 	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 });
 
-	await Promise.all([
-		...collected.map((entry) => writeLexicon(outdir, entry.nsid, entry.doc, formatter)),
-		writeSourceReadme(outdir, sourceRevisions, formatter),
-	]);
+		await Promise.all([
+			...collected.map((entry) => writeLexicon(outdir, entry.nsid, entry.doc, formatter)),
+			writeSourceReadme(outdir, sourceRevisions, formatter),
+		]);
+	} finally {
+		await formatter.dispose();
+	}
 };

package/src/config.ts

@@ -1,5 +1,4 @@
 import * as fs from 'node:fs/promises';
-import { availableParallelism } from 'node:os';
 import * as path from 'node:path';
 import * as url from 'node:url';
 
@@ -72,7 +71,11 @@ const formatterConfigSchema = v.union(
 		concurrency: v
 			.number()
 			.assert((value) => Number.isInteger(value) && value > 0, `must be a positive integer`)
-			.optional(() => availableParallelism()),
+			.optional(() => 1),
+	}),
+	v.object({
+		type: v.literal('lsp'),
+		command: v.string().assert((value) => value.length > 0, `must not be empty`),
 	}),
 );
 

package/src/formatter.ts

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
-import { availableParallelism } from 'node:os';
 
 import type { FormatterConfig } from './config.ts';
+import { createLspClient } from './lsp-client.ts';
 
 /** formats source code */
 export interface Formatter {
@@ -12,6 +12,8 @@ export interface Formatter {
 	 * @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 => {
@@ -74,72 +76,82 @@ class Semaphore {
  * @returns a formatter instance
  */
 export const createFormatter = async (config: FormatterConfig, root: string): Promise<Formatter> => {
-	let inner: Formatter;
-	let concurrency: number;
-
-	if (config.type === 'prettier') {
-		const prettier = await import('prettier');
-		const prettierConfig = await prettier.resolveConfig(root, { editorconfig: true });
-
-		// prettier is in-process and CPU-bound, so concurrency only helps
-		// avoid buffering all files in memory at once
-		concurrency = availableParallelism();
-		inner = {
-			async format(code, filepath) {
-				return prettier.format(code, { ...prettierConfig, parser: inferPrettierParser(filepath) });
-			},
-		};
-	} else {
-		// 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"');
-
-		concurrency = config.concurrency;
-		inner = {
-			format(code, filepath) {
-				return 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);
-				});
-			},
-		};
+	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();
+				},
+			};
+		}
 	}
-
-	const semaphore = new Semaphore(concurrency);
-
-	return {
-		async format(code, filepath) {
-			const lock = await semaphore.acquire();
-			try {
-				return await inner.format(code, filepath);
-			} finally {
-				lock.release();
-			}
-		},
-	};
 };

package/src/lsp-client.ts

@@ -0,0 +1,292 @@
+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', () => {});
+
+	// drain stderr so a chatty server doesn't block on a full pipe buffer
+	child.stderr.resume();
+
+	// #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;
+			}
+
+			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);
+					}
+				} else if (message.method != null) {
+					// server-initiated request — reply with MethodNotFound so it doesn't hang
+					sendMessage({
+						jsonrpc: '2.0',
+						id: message.id,
+						error: { code: -32601, message: `method not found` },
+					});
+				}
+			}
+		}
+	};
+
+	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));
+			}
+		},
+	};
+};