@hatchingpoint/point 0.0.10 → 0.0.11

package/package.json

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

package/src/lsp/analyze.ts

@@ -31,6 +31,61 @@ 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[];
@@ -128,6 +183,79 @@ export function formatPointDocument(source: string): string {
 	}
 }
 
+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)

package/src/lsp/server.ts

@@ -1,18 +1,32 @@
 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()) {
@@ -29,8 +43,10 @@ async function handleMessage(message: JsonRpcMessage): Promise<void> {
 				definitionProvider: true,
 				hoverProvider: true,
 				documentFormattingProvider: true,
+				completionProvider: { triggerCharacters: [".", " "] },
+				renameProvider: { prepareProvider: true },
 			},
-			serverInfo: { name: "point-lsp", version: "0.0.9" },
+			serverInfo: { name: "point-lsp", version: lspVersion() },
 		});
 		return;
 	}
@@ -130,6 +146,65 @@ async function handleMessage(message: JsonRpcMessage): Promise<void> {
 		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);
 	}