prettier-plugin-wolfram 0.7.3 → 0.7.5

package/README.md

@@ -210,6 +210,8 @@ The package also exposes a small rule runner:
 npx prettier-wolfram lint "src/**/*.wl"
 ```
 
+Matched directories and non-Wolfram file extensions are skipped.
+
 It prints diagnostics as:
 
 ```text
@@ -263,12 +265,12 @@ npm run publish:vscode:pre-release
 The extension README with editor setup, settings, diagnostics, and file
 association behavior lives at `vscode-extension/README.md`.
 
-## Publishing To Verdaccio
+## Publishing To npm
 
 Log in:
 
 ```bash
-npm login --registry http://localhost:4873
+npm login
 ```
 
 Preview package contents:
@@ -280,11 +282,11 @@ npm pack --dry-run
 Publish:
 
 ```bash
-npm publish --registry http://localhost:4873
+npm publish
 ```
 
 Verify:
 
 ```bash
-npm view prettier-plugin-wolfram --registry http://localhost:4873
+npm view prettier-plugin-wolfram
 ```

package/bin/prettier-wolfram-lsp.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// bin/prettier-wolfram-lsp.js
+// Minimal LSP server that publishes prettier-wolfram lint diagnostics over stdio.
+
+import { WolframParser } from "../src/parser/index.js";
+import { runRules } from "../src/rules/index.js";
+import { buildOffsetTable, addOffsets } from "../src/utils/offsets.js";
+
+const parser = new WolframParser();
+
+// ── LSP framing ──────────────────────────────────────────────────────────────
+
+let inputBuf = "";
+
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+	inputBuf += chunk;
+	drainBuffer();
+});
+
+function drainBuffer() {
+	while (true) {
+		const sep = inputBuf.indexOf("\r\n\r\n");
+		if (sep === -1) break;
+		const header = inputBuf.slice(0, sep);
+		const m = header.match(/Content-Length:\s*(\d+)/i);
+		if (!m) { inputBuf = inputBuf.slice(sep + 4); continue; }
+		const len = parseInt(m[1], 10);
+		const bodyStart = sep + 4;
+		if (inputBuf.length < bodyStart + len) break;
+		const body = inputBuf.slice(bodyStart, bodyStart + len);
+		inputBuf = inputBuf.slice(bodyStart + len);
+		try { dispatch(JSON.parse(body)); } catch {}
+	}
+}
+
+function send(obj) {
+	const body = JSON.stringify(obj);
+	process.stdout.write(`Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`);
+}
+
+const reply  = (id, result) => send({ jsonrpc: "2.0", id, result });
+const notify = (method, params) => send({ jsonrpc: "2.0", method, params });
+
+// ── Lint ─────────────────────────────────────────────────────────────────────
+
+const docs   = new Map(); // uri → text
+const timers = new Map(); // uri → debounce timer
+
+function scheduleLint(uri) {
+	if (timers.has(uri)) clearTimeout(timers.get(uri));
+	timers.set(uri, setTimeout(async () => {
+		timers.delete(uri);
+		const source = docs.get(uri);
+		if (source == null) return;
+		try {
+			const cst  = await parser.getCST(source);
+			const table = buildOffsetTable(source);
+			addOffsets(cst, table);
+			const issues = await runRules(cst, {});
+
+			const diagnostics = issues.map((d) => {
+				const [start, end] = d.node?.source ?? [[1, 1], [1, 1]];
+				return {
+					range: {
+						start: { line: start[0] - 1, character: start[1] - 1 },
+						end:   { line: end[0]   - 1, character: end[1]   - 1 },
+					},
+					severity: d.level === "error" ? 1 : 2,
+					source:   "prettier-wolfram",
+					code:     d.rule,
+					message:  d.message,
+				};
+			});
+
+			notify("textDocument/publishDiagnostics", { uri, diagnostics });
+		} catch {
+			notify("textDocument/publishDiagnostics", { uri, diagnostics: [] });
+		}
+	}, 200));
+}
+
+// ── Dispatch ─────────────────────────────────────────────────────────────────
+
+function dispatch(msg) {
+	const { method, id, params } = msg;
+
+	switch (method) {
+		case "initialize":
+			reply(id, {
+				capabilities: {
+					textDocumentSync: { openClose: true, change: 1 },
+				},
+				serverInfo: { name: "prettier-wolfram-ls", version: "0.1.0" },
+			});
+			break;
+
+		case "initialized":
+			break;
+
+		case "textDocument/didOpen":
+			docs.set(params.textDocument.uri, params.textDocument.text);
+			scheduleLint(params.textDocument.uri);
+			break;
+
+		case "textDocument/didChange":
+			docs.set(params.textDocument.uri, params.contentChanges[0].text);
+			scheduleLint(params.textDocument.uri);
+			break;
+
+		case "textDocument/didClose":
+			docs.delete(params.textDocument.uri);
+			notify("textDocument/publishDiagnostics", { uri: params.textDocument.uri, diagnostics: [] });
+			break;
+
+		case "shutdown":
+			reply(id, null);
+			break;
+
+		case "exit":
+			process.exit(0);
+			break;
+
+		default:
+			if (id != null)
+				send({ jsonrpc: "2.0", id, error: { code: -32601, message: "Method not found" } });
+	}
+}

package/bin/prettier-wolfram.js

@@ -2,12 +2,23 @@
 // bin/prettier-wolfram.js
 // Usage: prettier-wolfram lint [options] <glob...>
 
-import { readFileSync } from "fs";
+import { readFileSync, statSync } from "fs";
 import { globSync } from "fs";
+import { extname } from "path";
 import { WolframParser } from "../src/parser/index.js";
 import { runRules } from "../src/rules/index.js";
 import { buildOffsetTable, addOffsets } from "../src/utils/offsets.js";
 
+const WOLFRAM_EXTENSIONS = new Set([
+	".wl",
+	".wls",
+	".wlt",
+	".mt",
+	".m",
+	".vsnb",
+	".nb",
+]);
+
 const [, , command, ...args] = process.argv;
 
 if (command !== "lint") {
@@ -31,8 +42,14 @@ let totalDiagnostics = 0;
 for (const pattern of args) {
 	const files = globSync(pattern, { absolute: true });
 	for (const file of files) {
-		const source = readFileSync(file, "utf8");
 		try {
+			if (
+				!statSync(file).isFile() ||
+				!WOLFRAM_EXTENSIONS.has(extname(file).toLowerCase())
+			) {
+				continue;
+			}
+			const source = readFileSync(file, "utf8");
 			const cst = await parser.getCST(source);
 			const table = buildOffsetTable(source);
 			addOffsets(cst, table);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "prettier-plugin-wolfram",
-	"version": "0.7.3",
+	"version": "0.7.5",
 	"description": "Prettier plugin for Wolfram Language using tree-sitter",
 	"license": "MIT",
 	"repository": {
@@ -21,7 +21,8 @@
 		".": "./src/index.js"
 	},
 	"bin": {
-		"prettier-wolfram": "bin/prettier-wolfram.js"
+		"prettier-wolfram": "bin/prettier-wolfram.js",
+		"prettier-wolfram-lsp": "bin/prettier-wolfram-lsp.js"
 	},
 	"files": [
 		"bin/",

package/src/parser/adapter.js

@@ -9,9 +9,12 @@ const GROUP_CLOSE_LEAF = { "}": "Token`CloseCurly", ")": "Token`CloseParen", "]"
 
 // preprocessedSource is the version passed to tree-sitter (may have ⁢ for InvisibleTimes);
 // source is the original — used only for the unformattable fallback.
-export function adapt(tree, source, preprocessedSource) {
+// map (optional) translates preprocessed char offsets back to original offsets;
+// it is attached to lineIndex so nodeSource can record exact original positions.
+export function adapt(tree, source, preprocessedSource, map) {
 	const ps = preprocessedSource ?? source;
 	const lineIndex = makeLineIndex(ps);
+	lineIndex.map = map;
 	const ctx = { source: ps, lineIndex };
 	const root = tree.rootNode;
 	if (subtreeHasError(root)) {

package/src/parser/index.js

@@ -20,10 +20,24 @@ async function getLanguage() {
 
 // Replace space-based implicit multiplication (a  b) with U+2062 (InvisibleTimes)
 // so the grammar can parse it. Skip content inside strings and nested comments.
-export function preprocessInvisibleTimes(src) {
+//
+// Returns { text, map } where `text` is the preprocessed source and `map` is an
+// index translation table: map[i] is the original-source character offset that
+// corresponds to preprocessed-text offset i (map[text.length] === src.length).
+// Because the only length-changing transform collapses a run of spaces into a
+// single InvisibleTimes char, this map lets callers translate tree-sitter node
+// positions (computed on the preprocessed text) back to exact offsets in the
+// original source, without lossy line/col round-trips.
+export function preprocess(src) {
 	let result = "";
-	let i = 0;
+	const map = [];
 	const n = src.length;
+	// Copy src[start..end) verbatim, recording the source offset of each char.
+	const copyVerbatim = (start, end) => {
+		for (let k = start; k < end; k++) map.push(k);
+		result += src.slice(start, end);
+	};
+	let i = 0;
 	while (i < n) {
 		// Skip quoted string
 		if (src[i] === '"') {
@@ -33,7 +47,7 @@ export function preprocessInvisibleTimes(src) {
 				i++;
 			}
 			if (i < n) i++;
-			result += src.slice(start, i);
+			copyVerbatim(start, i);
 			continue;
 		}
 		// Skip nested WL comment (* ... *)
@@ -46,7 +60,7 @@ export function preprocessInvisibleTimes(src) {
 				else if (src[i] === "*" && src[i + 1] === ")") { depth--; i += 2; }
 				else i++;
 			}
-			result += src.slice(start, i);
+			copyVerbatim(start, i);
 			continue;
 		}
 		// Two or more spaces between word chars on same line → InvisibleTimes
@@ -59,14 +73,22 @@ export function preprocessInvisibleTimes(src) {
 				while (j < n && src[j] === " ") j++;
 				if (j < n && /\w/.test(src[j])) {
 					result += "⁢"; // InvisibleTimes, spaces stripped (they're extras)
+					map.push(i); // the single char maps to the start of the run
 					i = j;
 					continue;
 				}
 			}
 		}
+		map.push(i);
 		result += src[i++];
 	}
-	return result;
+	map.push(n); // sentinel for end offsets (node endIndex === text.length)
+	return { text: result, map };
+}
+
+// Backward-compatible wrapper returning only the preprocessed text.
+export function preprocessInvisibleTimes(src) {
+	return preprocess(src).text;
 }
 
 export class WolframParser {
@@ -74,8 +96,8 @@ export class WolframParser {
 		const lang = await getLanguage();
 		const parser = new Parser();
 		parser.setLanguage(lang);
-		const preprocessed = preprocessInvisibleTimes(sourceText);
+		const { text: preprocessed, map } = preprocess(sourceText);
 		const tree = parser.parse(preprocessed);
-		return adapt(tree, sourceText, preprocessed);
+		return adapt(tree, sourceText, preprocessed, map);
 	}
 }

package/src/parser/position.js

@@ -55,8 +55,26 @@ export function offsetToLineCol(lineIndex, charOffset) {
 }
 
 export function nodeSource(tsNode, lineIndex) {
-	return [
+	const source = [
 		offsetToLineCol(lineIndex, tsNode.startIndex),
 		offsetToLineCol(lineIndex, tsNode.endIndex),
 	];
+	// When a preprocessing offset map is available, record the exact original
+	// character offsets (non-enumerably, so node.source stays a [[l,c],[l,c]]
+	// pair for lint rules). These bypass the lossy WL-byte/visual-column line/col
+	// round-trip in addOffsets, which otherwise mismaps offsets whenever the
+	// preprocessed text differs from the original (collapsed spaces, tabs, or
+	// non-ASCII characters earlier on the line).
+	const map = lineIndex?.map;
+	if (map) {
+		const charStart = map[tsNode.startIndex];
+		const charEnd = map[tsNode.endIndex];
+		if (typeof charStart === "number" && typeof charEnd === "number") {
+			Object.defineProperties(source, {
+				charStart: { value: charStart, enumerable: false },
+				charEnd: { value: charEnd, enumerable: false },
+			});
+		}
+	}
+	return source;
 }

package/src/translator/nodes/binary.js

@@ -163,7 +163,7 @@ export function printBinary(node, options, print) {
 	const rhsWillBreak =
 		isMultilineStringLeaf(rhs, rhsDoc) || isMultilineStringJoin(rhs);
 
-	if (node.op === "BinaryAt" || node.op === "BinarySlashSlash") {
+	if (node.op === "BinaryAt") {
 		return group([
 			lhsDoc,
 			`${gap}${opStr}`,
@@ -172,6 +172,14 @@ export function printBinary(node, options, print) {
 		]);
 	}
 
+	if (node.op === "BinarySlashSlash") {
+		return group([
+			lhsDoc,
+			`${gap}${opStr}`,
+			indent([space ? line : softline, rhsDoc]),
+		]);
+	}
+
 	if (!space) {
 		if (rhsWillBreak) {
 			return group([lhsDoc, opStr, indent([line, rhsDoc])]);

package/src/utils/offsets.js

@@ -57,6 +57,14 @@ export function lineColToOffset(table, line, col) {
 
 function sourceToOffsets(source, table) {
 	if (!Array.isArray(source) || source.length !== 2) return null;
+	// Exact original char offsets recorded by the parser (see nodeSource) are
+	// authoritative when present — they avoid the lossy line/col conversion below.
+	if (
+		typeof source.charStart === "number" &&
+		typeof source.charEnd === "number"
+	) {
+		return { locStart: source.charStart, locEnd: source.charEnd };
+	}
 	const [start, end] = source;
 	if (!Array.isArray(start) || !Array.isArray(end)) return null;
 	const [startLine, startCol] = start;