@hatchingpoint/point 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchingpoint/point",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "private": false,
   "type": "module",
   "description": "Point language compiler and CLI.",

package/src/core/cli.ts

@@ -9,6 +9,7 @@ import { emitPointCoreJavaScript } from "./emit-javascript.ts";
 import { formatPointSource } from "./format.ts";
 import { isCacheHit, isIncrementalEnabled, readBuildCache, recordCacheEntry, writeBuildCache } from "./incremental.ts";
 import { parsePointSource } from "./parser.ts";
+import { runPointLspServer } from "../lsp/server.ts";
 
 const DEFAULT_INPUT = "examples/math.point";
 const DEFAULT_OUTPUT = "generated/math.ast.json";
@@ -28,6 +29,11 @@ export async function main() {
 		return;
 	}
 
+	if (command === "lsp") {
+		await runPointLspServer();
+		return;
+	}
+
 	const inputPath = resolve(process.cwd(), input);
 	const source = await Bun.file(inputPath).text();
 	const program = parsePointSource(source);

package/src/lsp/analyze.ts

@@ -0,0 +1,326 @@
+import type { PointSourceSpan } from "../core/ast.ts";
+import { checkPointCore } from "../core/check.ts";
+import type { PointCoreDiagnostic } from "../core/check.ts";
+import { formatPointSource } from "../core/format.ts";
+import { parsePointSource } from "../core/parser.ts";
+import type { PointSemanticSymbol, PointSemanticSymbolKind } from "../semantic/context.ts";
+import { createSemanticIndex, explainSemanticRef, mapPublicDiagnostics } from "../semantic/context.ts";
+
+export interface LspRange {
+	start: { line: number; character: number };
+	end: { line: number; character: number };
+}
+
+export interface LspDiagnostic {
+	range: LspRange;
+	severity: 1;
+	code: string;
+	source: string;
+	message: string;
+}
+
+export interface LspDocumentSymbol {
+	name: string;
+	detail?: string;
+	kind: number;
+	range: LspRange;
+	selectionRange: LspRange;
+}
+
+export interface LspHover {
+	contents: string;
+}
+
+export interface LspCompletionItem {
+	label: string;
+	kind: number;
+	detail?: string;
+}
+
+const BLOCK_KEYWORDS = [
+	"module",
+	"use",
+	"record",
+	"calculation",
+	"rule",
+	"label",
+	"external",
+	"action",
+	"policy",
+	"view",
+	"route",
+	"workflow",
+	"command",
+];
+
+const STATEMENT_KEYWORDS = [
+	"input",
+	"output",
+	"return",
+	"when",
+	"otherwise",
+	"add",
+	"subtract",
+	"set",
+	"for",
+	"each",
+	"in",
+	"starts",
+	"at",
+	"as",
+	"to",
+	"from",
+	"is",
+	"render",
+	"method",
+	"path",
+	"step",
+	"await",
+	"touches",
+	"and",
+	"or",
+	"none",
+	"true",
+	"false",
+];
+
+const TYPE_KEYWORDS = ["Text", "Int", "Float", "Bool", "Void", "List", "Maybe"];
+
+export interface PointDocumentAnalysis {
+	diagnostics: LspDiagnostic[];
+	symbols: PointSemanticSymbol[];
+}
+
+const OUTLINE_KINDS = new Set<PointSemanticSymbolKind>([
+	"record",
+	"calculation",
+	"rule",
+	"label",
+	"action",
+	"policy",
+	"external",
+	"view",
+	"route",
+	"workflow",
+	"command",
+]);
+
+export function pointSpanToLspRange(span: PointSourceSpan): LspRange {
+	return {
+		start: { line: Math.max(0, span.start.line - 1), character: Math.max(0, span.start.column - 1) },
+		end: { line: Math.max(0, span.end.line - 1), character: Math.max(0, span.end.column - 1) },
+	};
+}
+
+export function lspPositionToPoint(line: number, character: number): { line: number; column: number } {
+	return { line: line + 1, column: character + 1 };
+}
+
+export function analyzePointSource(source: string): PointDocumentAnalysis {
+	try {
+		const program = parsePointSource(source);
+		const diagnostics = mapPublicDiagnostics(program, checkPointCore(program)).map(toLspDiagnostic);
+		const symbols = program.semanticSource ? createSemanticIndex(program.semanticSource).refs : [];
+		return { diagnostics, symbols };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return {
+			diagnostics: [parseErrorDiagnostic(message)],
+			symbols: [],
+		};
+	}
+}
+
+export function outlineSymbols(symbols: PointSemanticSymbol[]): LspDocumentSymbol[] {
+	return symbols
+		.filter((symbol) => OUTLINE_KINDS.has(symbol.kind) && symbol.span)
+		.map((symbol) => {
+			const range = pointSpanToLspRange(symbol.span!);
+			return {
+				name: symbol.name,
+				detail: symbol.ref,
+				kind: symbolKindToLsp(symbol.kind),
+				range,
+				selectionRange: range,
+			};
+		});
+}
+
+export function symbolAtPoint(symbols: PointSemanticSymbol[], line: number, column: number): PointSemanticSymbol | undefined {
+	const matches = symbols.filter((symbol) => symbolContainsPoint(symbol, line, column));
+	return matches.sort((left, right) => spanSize(left.span) - spanSize(right.span))[0];
+}
+
+export function hoverForPosition(source: string, line: number, column: number): LspHover | null {
+	const analysis = analyzePointSource(source);
+	const symbol = symbolAtPoint(analysis.symbols, line, column);
+	if (!symbol?.span) return null;
+	try {
+		const program = parsePointSource(source);
+		if (!program.semanticSource) return { contents: symbol.ref };
+		const explanation = explainSemanticRef(program.semanticSource, symbol.ref);
+		return { contents: explanation.summary };
+	} catch {
+		return { contents: symbol.ref };
+	}
+}
+
+export function definitionForPosition(
+	symbols: PointSemanticSymbol[],
+	line: number,
+	column: number,
+): LspRange | null {
+	const symbol = symbolAtPoint(symbols, line, column);
+	if (!symbol?.span) return null;
+	return pointSpanToLspRange(symbol.span);
+}
+
+export function formatPointDocument(source: string): string {
+	try {
+		return formatPointSource(source);
+	} catch {
+		return source;
+	}
+}
+
+export function completionsForPosition(source: string, line: number, column: number): LspCompletionItem[] {
+	const analysis = analyzePointSource(source);
+	const lines = source.split(/\r?\n/);
+	const lineText = lines[line - 1] ?? "";
+	const before = lineText.slice(0, Math.max(0, column - 1));
+	const items: LspCompletionItem[] = [];
+	const seen = new Set<string>();
+	const add = (label: string, kind: number, detail?: string) => {
+		if (seen.has(label)) return;
+		seen.add(label);
+		items.push({ label, kind, detail });
+	};
+
+	if (/^\s*$/.test(before)) {
+		for (const keyword of BLOCK_KEYWORDS) add(keyword, 14);
+	}
+
+	for (const keyword of [...STATEMENT_KEYWORDS, ...TYPE_KEYWORDS]) add(keyword, 14);
+	for (const symbol of analysis.symbols) {
+		const kind =
+			symbol.kind === "field" ? 5 : symbol.kind === "record" ? 7 : symbol.kind === "param" ? 6 : 3;
+		add(symbol.name, kind, symbol.kind);
+	}
+
+	return items;
+}
+
+export function renameSymbolInDocument(
+	source: string,
+	line: number,
+	column: number,
+	newName: string,
+): { range: LspRange; newText: string } | null {
+	const analysis = analyzePointSource(source);
+	const symbol = symbolAtPoint(analysis.symbols, line, column);
+	if (!symbol?.span || !newName.trim()) return null;
+	const oldName = symbol.name;
+	if (oldName === newName) {
+		return { range: pointSpanToLspRange(symbol.span), newText: oldName };
+	}
+	const escaped = oldName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const updated = source.replace(new RegExp(escaped, "g"), newName);
+	if (updated === source) return null;
+	return {
+		range: fullDocumentRange(source),
+		newText: updated,
+	};
+}
+
+export function prepareRenameAtPosition(
+	source: string,
+	line: number,
+	column: number,
+): { range: LspRange; placeholder: string } | null {
+	const analysis = analyzePointSource(source);
+	const symbol = symbolAtPoint(analysis.symbols, line, column);
+	if (!symbol?.span) return null;
+	return {
+		range: pointSpanToLspRange(symbol.span),
+		placeholder: symbol.name,
+	};
+}
+
+function fullDocumentRange(text: string): LspRange {
+	const lines = text.split(/\r?\n/);
+	const lastLine = Math.max(0, lines.length - 1);
+	const lastCharacter = lines[lastLine]?.length ?? 0;
+	return {
+		start: { line: 0, character: 0 },
+		end: { line: lastLine, character: lastCharacter },
+	};
+}
+
+function toLspDiagnostic(diagnostic: PointCoreDiagnostic): LspDiagnostic {
+	const range = diagnostic.span
+		? pointSpanToLspRange(diagnostic.span)
+		: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } };
+	return {
+		range,
+		severity: 1,
+		code: diagnostic.code,
+		source: diagnostic.ref,
+		message: diagnostic.message,
+	};
+}
+
+function parseErrorDiagnostic(message: string): LspDiagnostic {
+	const match = message.match(/\bat (\d+)\b/);
+	const line = match ? Math.max(0, Number(match[1]) - 1) : 0;
+	return {
+		range: { start: { line, character: 0 }, end: { line, character: 1 } },
+		severity: 1,
+		code: "parse-error",
+		source: "point",
+		message,
+	};
+}
+
+function symbolContainsPoint(symbol: PointSemanticSymbol, line: number, column: number): boolean {
+	if (!symbol.span) return false;
+	const { start, end } = symbol.span;
+	if (line < start.line || line > end.line) return false;
+	if (line === start.line && column < start.column) return false;
+	if (line === end.line && column > end.column) return false;
+	return true;
+}
+
+function spanSize(span: PointSourceSpan | null | undefined): number {
+	if (!span) return Number.MAX_SAFE_INTEGER;
+	const lines = span.end.line - span.start.line;
+	const columns = span.end.column - span.start.column;
+	return lines * 10_000 + columns;
+}
+
+function symbolKindToLsp(kind: PointSemanticSymbolKind): number {
+	switch (kind) {
+		case "record":
+			return 23;
+		case "field":
+			return 8;
+		case "calculation":
+		case "rule":
+		case "label":
+		case "action":
+		case "policy":
+		case "external":
+		case "view":
+		case "route":
+		case "workflow":
+		case "command":
+			return 12;
+		case "module":
+			return 2;
+		case "use":
+			return 3;
+		case "param":
+			return 6;
+		default:
+			return 13;
+	}
+}

package/src/lsp/protocol.ts

@@ -0,0 +1,79 @@
+import { stdin, stdout } from "node:process";
+
+export interface JsonRpcMessage {
+	jsonrpc: "2.0";
+	id?: number | string | null;
+	method?: string;
+	params?: unknown;
+	result?: unknown;
+	error?: { code: number; message: string; data?: unknown };
+}
+
+export class LspReader {
+	private buffer = Buffer.alloc(0);
+
+	async *messages(): AsyncGenerator<JsonRpcMessage> {
+		for (;;) {
+			const message = this.tryReadMessage();
+			if (message) {
+				yield message;
+				continue;
+			}
+			const chunk = await readStdinChunk();
+			if (chunk.length === 0) return;
+			this.buffer = Buffer.concat([this.buffer, chunk]);
+		}
+	}
+
+	private tryReadMessage(): JsonRpcMessage | null {
+		const headerEnd = this.buffer.indexOf("\r\n\r\n");
+		if (headerEnd === -1) return null;
+		const header = this.buffer.subarray(0, headerEnd).toString("utf8");
+		const lengthMatch = header.match(/Content-Length:\s*(\d+)/i);
+		if (!lengthMatch) {
+			this.buffer = this.buffer.subarray(headerEnd + 4);
+			return null;
+		}
+		const contentLength = Number(lengthMatch[1]);
+		const bodyStart = headerEnd + 4;
+		if (this.buffer.length < bodyStart + contentLength) return null;
+		const body = this.buffer.subarray(bodyStart, bodyStart + contentLength).toString("utf8");
+		this.buffer = this.buffer.subarray(bodyStart + contentLength);
+		return JSON.parse(body) as JsonRpcMessage;
+	}
+}
+
+export function writeMessage(message: JsonRpcMessage): void {
+	const body = JSON.stringify(message);
+	const header = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n`;
+	stdout.write(header + body);
+}
+
+function readStdinChunk(): Promise<Buffer> {
+	return new Promise((resolve, reject) => {
+		const onReadable = () => {
+			const chunk = stdin.read() as Buffer | null;
+			if (chunk) {
+				cleanup();
+				resolve(chunk);
+			}
+		};
+		const onEnd = () => {
+			cleanup();
+			resolve(Buffer.alloc(0));
+		};
+		const onError = (error: Error) => {
+			cleanup();
+			reject(error);
+		};
+		const cleanup = () => {
+			stdin.off("readable", onReadable);
+			stdin.off("end", onEnd);
+			stdin.off("error", onError);
+		};
+		stdin.on("readable", onReadable);
+		stdin.on("end", onEnd);
+		stdin.on("error", onError);
+		if (stdin.isPaused()) stdin.resume();
+	});
+}

package/src/lsp/server.ts

@@ -0,0 +1,237 @@
+import {
+	analyzePointSource,
+	completionsForPosition,
+	definitionForPosition,
+	formatPointDocument,
+	hoverForPosition,
+	lspPositionToPoint,
+	outlineSymbols,
+	prepareRenameAtPosition,
+	renameSymbolInDocument,
+	type LspRange,
+} from "./analyze.ts";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { LspReader, writeMessage, type JsonRpcMessage } from "./protocol.ts";
+
+type DocumentState = { version: number; text: string };
+
+const documents = new Map<string, DocumentState>();
+
+function lspVersion(): string {
+	try {
+		const pkgPath = join(import.meta.dir, "../../package.json");
+		return (JSON.parse(readFileSync(pkgPath, "utf8")) as { version: string }).version;
+	} catch {
+		return "0.0.0";
+	}
+}
+
+export async function runPointLspServer(): Promise<void> {
+	const reader = new LspReader();
+	for await (const message of reader.messages()) {
+		await handleMessage(message);
+	}
+}
+
+async function handleMessage(message: JsonRpcMessage): Promise<void> {
+	if (message.method === "initialize") {
+		respond(message.id, {
+			capabilities: {
+				textDocumentSync: 1,
+				documentSymbolProvider: true,
+				definitionProvider: true,
+				hoverProvider: true,
+				documentFormattingProvider: true,
+				completionProvider: { triggerCharacters: [".", " "] },
+				renameProvider: { prepareProvider: true },
+			},
+			serverInfo: { name: "point-lsp", version: lspVersion() },
+		});
+		return;
+	}
+
+	if (message.method === "initialized" || message.method === "exit") {
+		return;
+	}
+
+	if (message.method === "shutdown") {
+		respond(message.id, null);
+		return;
+	}
+
+	if (message.method === "textDocument/didOpen") {
+		const params = message.params as { textDocument: { uri: string; version: number; text: string } };
+		documents.set(params.textDocument.uri, { version: params.textDocument.version, text: params.textDocument.text });
+		publishDiagnostics(params.textDocument.uri);
+		return;
+	}
+
+	if (message.method === "textDocument/didChange") {
+		const params = message.params as {
+			textDocument: { uri: string; version: number };
+			contentChanges: Array<{ text: string }>;
+		};
+		const change = params.contentChanges[0];
+		if (!change) return;
+		documents.set(params.textDocument.uri, { version: params.textDocument.version, text: change.text });
+		publishDiagnostics(params.textDocument.uri);
+		return;
+	}
+
+	if (message.method === "textDocument/didClose") {
+		const params = message.params as { textDocument: { uri: string } };
+		documents.delete(params.textDocument.uri);
+		notify("textDocument/publishDiagnostics", { uri: params.textDocument.uri, diagnostics: [] });
+		return;
+	}
+
+	if (message.method === "textDocument/documentSymbol") {
+		const params = message.params as { textDocument: { uri: string } };
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, []);
+			return;
+		}
+		const analysis = analyzePointSource(document.text);
+		respond(message.id, outlineSymbols(analysis.symbols));
+		return;
+	}
+
+	if (message.method === "textDocument/definition") {
+		const params = message.params as { textDocument: { uri: string }; position: { line: number; character: number } };
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const analysis = analyzePointSource(document.text);
+		const range = definitionForPosition(analysis.symbols, point.line, point.column);
+		respond(message.id, range ? { uri: params.textDocument.uri, range } : null);
+		return;
+	}
+
+	if (message.method === "textDocument/hover") {
+		const params = message.params as { textDocument: { uri: string }; position: { line: number; character: number } };
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const hover = hoverForPosition(document.text, point.line, point.column);
+		respond(message.id, hover ? { contents: { kind: "markdown", value: hover.contents } } : null);
+		return;
+	}
+
+	if (message.method === "textDocument/formatting") {
+		const params = message.params as { textDocument: { uri: string } };
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, []);
+			return;
+		}
+		const formatted = formatPointDocument(document.text);
+		if (formatted === document.text) {
+			respond(message.id, []);
+			return;
+		}
+		respond(message.id, [
+			{
+				range: fullDocumentRange(document.text),
+				newText: formatted,
+			},
+		]);
+		return;
+	}
+
+	if (message.method === "textDocument/completion") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, { isIncomplete: false, items: [] });
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const items = completionsForPosition(document.text, point.line, point.column);
+		respond(message.id, { isIncomplete: false, items });
+		return;
+	}
+
+	if (message.method === "textDocument/prepareRename") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const prepared = prepareRenameAtPosition(document.text, point.line, point.column);
+		respond(message.id, prepared);
+		return;
+	}
+
+	if (message.method === "textDocument/rename") {
+		const params = message.params as {
+			textDocument: { uri: string };
+			position: { line: number; character: number };
+			newName: string;
+		};
+		const document = documents.get(params.textDocument.uri);
+		if (!document) {
+			respond(message.id, null);
+			return;
+		}
+		const point = lspPositionToPoint(params.position.line, params.position.character);
+		const edit = renameSymbolInDocument(document.text, point.line, point.column, params.newName);
+		if (!edit) {
+			respond(message.id, null);
+			return;
+		}
+		documents.set(params.textDocument.uri, { version: document.version, text: edit.newText });
+		publishDiagnostics(params.textDocument.uri);
+		respond(message.id, {
+			changes: {
+				[params.textDocument.uri]: [edit],
+			},
+		});
+		return;
+	}
+
+	if (message.id !== undefined) {
+		respond(message.id, null);
+	}
+}
+
+function publishDiagnostics(uri: string): void {
+	const document = documents.get(uri);
+	if (!document) return;
+	const analysis = analyzePointSource(document.text);
+	notify("textDocument/publishDiagnostics", { uri, diagnostics: analysis.diagnostics });
+}
+
+function fullDocumentRange(text: string): LspRange {
+	const lines = text.split(/\r?\n/);
+	const lastLine = Math.max(0, lines.length - 1);
+	const lastCharacter = lines[lastLine]?.length ?? 0;
+	return {
+		start: { line: 0, character: 0 },
+		end: { line: lastLine, character: lastCharacter },
+	};
+}
+
+function respond(id: number | string | null | undefined, result: unknown): void {
+	if (id === undefined) return;
+	writeMessage({ jsonrpc: "2.0", id, result });
+}
+
+function notify(method: string, params: unknown): void {
+	writeMessage({ jsonrpc: "2.0", method, params });
+}