correctly 0.0.0

package/src/lsp/server.ts

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import { fileURLToPath, pathToFileURL } from "node:url"
+import path from "node:path"
+import {
+	createConnection,
+	TextDocuments,
+	TextDocumentSyncKind,
+	DidChangeWatchedFilesNotification,
+	ResponseError,
+	LSPErrorCodes,
+	type CancellationToken,
+} from "vscode-languageserver/node"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { Workspace } from "./workspace.ts"
+import { Hints } from "./hints.ts"
+import type { FileResult } from "../core/types.ts"
+import { diagnostic } from "../core/parse.ts"
+import { diagnosticViews, diagnosticDetails } from "../core/diagnostics.ts"
+
+export function lspDiagnostics(result: FileResult, text: string) {
+	return diagnosticViews([
+		...result.diagnostics,
+		...result.failures
+			.filter(
+				(f) =>
+					!result.diagnostics.some(
+						(d) => d.code === f.code && d.message === f.message,
+					),
+			)
+			.map((f) => diagnostic(text, f.code, f.message)),
+	]).map((d) => ({
+		range: d.range,
+		message: d.message,
+		code: d.code,
+		severity: 1 as const,
+		source: "correctly",
+		data: { pointer: d.pointer },
+		...(d.branches.length
+			? {
+					relatedInformation: diagnosticDetails(d).map(
+						({ label, diagnostic }) => ({
+							location: {
+								uri: pathToFileURL(result.file).href,
+								range: diagnostic.range,
+							},
+							message: `${label}: ${diagnostic.message}`,
+						}),
+					),
+				}
+			: {}),
+	}))
+}
+
+export function startServer() {
+	const connection = createConnection()
+	const documents = new TextDocuments(TextDocument)
+	const workspace = new Workspace([])
+	const hints = new Hints()
+	const jobs = new Map<
+		string,
+		{ controller: AbortController; timer: ReturnType<typeof setTimeout> }
+	>()
+	let dynamicWatch = false
+	const watchedSchemas = new Set<string>()
+	workspace.onSchema = (uri) => {
+		if (!dynamicWatch || !uri.startsWith("file:") || watchedSchemas.has(uri))
+			return
+		watchedSchemas.add(uri)
+		const file = fileURLToPath(uri)
+		void connection.client
+			.register(DidChangeWatchedFilesNotification.type, {
+				watchers: [
+					{
+						globPattern: {
+							baseUri: pathToFileURL(path.dirname(file)).href,
+							pattern: path.basename(file),
+						},
+					},
+				],
+			})
+			.catch((error: unknown) => connection.console.error(String(error)))
+	}
+	connection.onInitialize((params) => {
+		workspace.roots = (
+			params.workspaceFolders?.map((f) => f.uri) ??
+			(params.rootUri ? [params.rootUri] : [])
+		)
+			.filter((uri) => uri.startsWith("file:"))
+			.map((uri) => fileURLToPath(uri))
+		dynamicWatch =
+			params.capabilities.workspace?.didChangeWatchedFiles
+				?.dynamicRegistration ?? false
+		return {
+			capabilities: {
+				textDocumentSync: TextDocumentSyncKind.Incremental,
+				completionProvider: { triggerCharacters: ['"', ":"] },
+				hoverProvider: true,
+				workspace: {
+					workspaceFolders: { supported: true, changeNotifications: true },
+				},
+			},
+			serverInfo: { name: "correctly", version: "0.0.0" },
+		}
+	})
+	connection.onInitialized(() => {
+		if (dynamicWatch)
+			void connection.client
+				.register(DidChangeWatchedFilesNotification.type, {
+					watchers: [{ globPattern: "**/*.{json,jsonc}" }],
+				})
+				.catch((error: unknown) => connection.console.error(String(error)))
+		connection.workspace.onDidChangeWorkspaceFolders((event) => {
+			const removed = new Set(event.removed.map((f) => fileURLToPath(f.uri)))
+			workspace.roots = [
+				...workspace.roots.filter((r) => !removed.has(r)),
+				...event.added.map((f) => fileURLToPath(f.uri)),
+			]
+			refresh()
+		})
+	})
+	function schedule(document: TextDocument) {
+		if (!document.uri.startsWith("file:")) return
+		const previous = jobs.get(document.uri)
+		if (previous) {
+			clearTimeout(previous.timer)
+			previous.controller.abort()
+		}
+		const controller = new AbortController()
+		const generation = workspace.generation
+		const timer = setTimeout(() => {
+			void workspace
+				.validate(document)
+				.then((result) => {
+					if (
+						controller.signal.aborted ||
+						workspace.generation !== generation ||
+						documents.get(document.uri)?.version !== document.version
+					)
+						return
+					return connection.sendDiagnostics({
+						uri: document.uri,
+						version: document.version,
+						diagnostics: lspDiagnostics(result, document.getText()),
+					})
+				})
+				.catch((error: unknown) => connection.console.error(String(error)))
+		}, 40)
+		jobs.set(document.uri, { controller, timer })
+	}
+	function scheduleAll() {
+		for (const document of documents.all()) schedule(document)
+	}
+	function refresh() {
+		workspace.invalidate()
+		scheduleAll()
+	}
+	documents.onDidChangeContent(({ document }) => {
+		if (!document.uri.startsWith("file:")) return
+		const resourceChanged = workspace.open(document)
+		if (resourceChanged) scheduleAll()
+		else schedule(document)
+	})
+	documents.onDidClose(async ({ document }) => {
+		const job = jobs.get(document.uri)
+		if (job) {
+			clearTimeout(job.timer)
+			job.controller.abort()
+			jobs.delete(document.uri)
+		}
+		await connection.sendDiagnostics({ uri: document.uri, diagnostics: [] })
+		if (document.uri.startsWith("file:") && workspace.close(document.uri))
+			scheduleAll()
+	})
+	connection.onDidChangeWatchedFiles((params) => {
+		// Cache writes and unrelated JSON files must not trigger schema reloads.
+		if (params.changes.some((change) => workspace.resourceChanged(change.uri)))
+			refresh()
+	})
+	connection.onDidChangeConfiguration(refresh)
+	async function request<T>(
+		uri: string,
+		token: CancellationToken,
+		action: (
+			engine: Awaited<ReturnType<Workspace["engineFor"]>>,
+			document: TextDocument,
+		) => Promise<T>,
+	): Promise<T | null> {
+		const document = documents.get(uri)
+		if (!document || !uri.startsWith("file:")) return null
+		const generation = workspace.generation
+		const cancelled = () =>
+			token.isCancellationRequested ||
+			workspace.generation !== generation ||
+			documents.get(uri)?.version !== document.version
+		if (cancelled())
+			throw new ResponseError(
+				LSPErrorCodes.RequestCancelled,
+				"Request cancelled",
+			)
+		const operation = (async () => {
+			try {
+				const engine = await workspace.engineFor(uri)
+				if (cancelled())
+					throw new ResponseError(
+						LSPErrorCodes.RequestCancelled,
+						"Request cancelled",
+					)
+				const result = await action(engine, document)
+				if (cancelled())
+					throw new ResponseError(
+						LSPErrorCodes.RequestCancelled,
+						"Request cancelled",
+					)
+				return result
+			} catch (error) {
+				if (error instanceof ResponseError) throw error
+				if (cancelled())
+					throw new ResponseError(
+						LSPErrorCodes.RequestCancelled,
+						"Request cancelled",
+					)
+				connection.console.error(String(error))
+				return null
+			}
+		})()
+		let listener: { dispose(): void } | undefined
+		const cancellation = new Promise<never>((_resolve, reject) => {
+			listener = token.onCancellationRequested(() =>
+				reject(
+					new ResponseError(
+						LSPErrorCodes.RequestCancelled,
+						"Request cancelled",
+					),
+				),
+			)
+		})
+		try {
+			return await Promise.race([operation, cancellation])
+		} finally {
+			listener?.dispose()
+		}
+	}
+	connection.onCompletion((params, token) =>
+		request(params.textDocument.uri, token, (engine, document) =>
+			hints.complete(engine, document, params.position),
+		),
+	)
+	connection.onHover((params, token) =>
+		request(params.textDocument.uri, token, (engine, document) =>
+			hints.hover(engine, document, params.position),
+		),
+	)
+	connection.onShutdown(() => {
+		workspace.invalidate()
+		for (const job of jobs.values()) {
+			clearTimeout(job.timer)
+			job.controller.abort()
+		}
+		jobs.clear()
+	})
+	documents.listen(connection)
+	connection.listen()
+}
+
+startServer()

package/src/lsp/workspace.ts

@@ -0,0 +1,132 @@
+import path from "node:path"
+import { fileURLToPath, pathToFileURL } from "node:url"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import {
+	contains,
+	discoverConfig,
+	loadProject,
+	readText,
+	type ReadText,
+} from "../core/config.ts"
+import { Engine } from "../core/engine.ts"
+import { CorrectlyError, failure, type FileResult } from "../core/types.ts"
+import { diagnostic } from "../core/parse.ts"
+
+export class Workspace {
+	onSchema: ((uri: string) => void) | undefined
+	roots: string[]
+	private readonly read: ReadText
+	readonly documents = new Map<string, TextDocument>()
+	private readonly engines = new Map<string, Promise<Engine>>()
+	private controller = new AbortController()
+	generation = 0
+	constructor(roots: string[], read: ReadText = readText) {
+		this.roots = roots
+		this.read = read
+	}
+
+	invalidate() {
+		this.generation++
+		this.controller.abort()
+		this.controller = new AbortController()
+		this.engines.clear()
+	}
+
+	open(document: TextDocument): boolean {
+		this.documents.set(document.uri, document)
+		const resource =
+			path.basename(fileURLToPath(document.uri)) === "correctly.config.json" ||
+			this.isSchema(document.uri)
+		if (resource) this.invalidate()
+		return resource
+	}
+	close(uri: string): boolean {
+		const resource =
+			uri.endsWith("/correctly.config.json") || this.isSchema(uri)
+		this.documents.delete(uri)
+		if (resource) this.invalidate()
+		return resource
+	}
+	private readonly schemaUris = new Set<string>()
+	private isSchema(uri: string): boolean {
+		return this.schemaUris.has(uri)
+	}
+	resourceChanged(uri: string): boolean {
+		return uri.endsWith("/correctly.config.json") || this.isSchema(uri)
+	}
+	private readonly readBuffer: ReadText = (uri) => {
+		const document = this.documents.get(uri)
+		return document ? Promise.resolve(document.getText()) : this.read(uri)
+	}
+
+	async engineFor(uri: string): Promise<Engine> {
+		const file = fileURLToPath(uri)
+		const root = this.roots
+			.filter((r) => contains(r, file))
+			.sort((a, b) => b.length - a.length)[0]
+		if (this.roots.length && !root)
+			throw new CorrectlyError(
+				"config",
+				`Document is outside the editor workspace: ${file}`,
+			)
+		const virtualConfigs = new Set(
+			[...this.documents.keys()]
+				.filter((key) => key.endsWith("/correctly.config.json"))
+				.map((key) => fileURLToPath(key)),
+		)
+		const configPath = await discoverConfig(
+			path.dirname(file),
+			root,
+			virtualConfigs,
+		)
+		let promise = this.engines.get(configPath)
+		if (!promise) {
+			const signal = this.controller.signal
+			promise = (async () => {
+				const project = await loadProject(configPath, this.readBuffer)
+				const readSchema: ReadText = async (schema) => {
+					this.schemaUris.add(schema)
+					this.onSchema?.(schema)
+					return this.readBuffer(schema)
+				}
+				const engine = new Engine(project, { read: readSchema, signal })
+				await engine.prepare()
+				for (const resource of engine.store.resources.values())
+					this.schemaUris.add(resource.uri)
+				signal.throwIfAborted()
+				return engine
+			})()
+			this.engines.set(configPath, promise)
+		}
+		return promise
+	}
+
+	async validate(document: TextDocument): Promise<FileResult> {
+		try {
+			const engine = await this.engineFor(document.uri)
+			return await engine.validate(
+				fileURLToPath(document.uri),
+				document.getText(),
+			)
+		} catch (error) {
+			const problem = failure(error, fileURLToPath(document.uri))
+			return {
+				file: fileURLToPath(document.uri),
+				mode: document.languageId === "jsonc" ? "jsonc" : "json",
+				association: null,
+				coverage: "syntax-only",
+				diagnostics: [
+					diagnostic(document.getText(), problem.code, problem.message),
+				],
+				failures: [problem],
+			}
+		}
+	}
+
+	documentPath(uri: string): string {
+		return fileURLToPath(uri)
+	}
+	rootUris(): string[] {
+		return this.roots.map((root) => pathToFileURL(root).href)
+	}
+}

package/src/vscode/README.md

@@ -0,0 +1,7 @@
+# Correctly for VS Code
+
+Install the VSIX, add `correctly.config.json` to each workspace root, and open JSON or JSONC files. Correctly uses that same external configuration for validation, completion, and hover. It reads unsaved buffers and refreshes when configurations and schemas change.
+
+The client and server are bundled; no npm install or separate schema map is needed. Run **Correctly: Restart Server** to restart the language server. JSON formatting remains the responsibility of your formatter.
+
+VS Code's built-in JSON features can also provide their own diagnostics or suggestions. Correctly diagnostics have source `correctly`. For an editor experience using only Correctly validation, set `json.validate.enable` to `false`; this does not affect Correctly or require another schema association map.

package/src/vscode/extension.ts

@@ -0,0 +1,33 @@
+import * as vscode from "vscode"
+import { LanguageClient, TransportKind } from "vscode-languageclient/node"
+
+let client: LanguageClient | undefined
+export async function activate(context: vscode.ExtensionContext) {
+	const watcher = vscode.workspace.createFileSystemWatcher("**/*")
+	context.subscriptions.push(watcher)
+	client = new LanguageClient(
+		"correctly",
+		"Correctly",
+		{
+			module: context.asAbsolutePath("dist/server.mjs"),
+			transport: TransportKind.stdio,
+		},
+		{
+			documentSelector: [
+				{ scheme: "file", language: "json" },
+				{ scheme: "file", language: "jsonc" },
+			],
+			synchronize: { fileEvents: watcher },
+		},
+	)
+	context.subscriptions.push(
+		vscode.commands.registerCommand("correctly.restartServer", async () => {
+			await client?.restart()
+		}),
+	)
+	await client.start()
+}
+export async function deactivate() {
+	await client?.stop()
+	client = undefined
+}

package/src/vscode/package.json

@@ -0,0 +1,43 @@
+{
+	"name": "correctly-vscode",
+	"displayName": "Correctly",
+	"version": "0.0.0",
+	"private": true,
+	"description": "JSON Schema validation and editor hints from one external configuration",
+	"categories": [
+		"Linters",
+		"Programming Languages"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/jeremybanka/correctly.git",
+		"directory": "packages/correctly/src/vscode"
+	},
+	"license": "MPL-2.0",
+	"publisher": "jeremybanka",
+	"type": "module",
+	"main": "./dist/extension.mjs",
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"contributes": {
+		"commands": [
+			{
+				"command": "correctly.restartServer",
+				"title": "Correctly: Restart Server"
+			}
+		]
+	},
+	"activationEvents": [
+		"onLanguage:json",
+		"onLanguage:jsonc"
+	],
+	"engines": {
+		"vscode": "^1.100.0"
+	},
+	"extensionKind": [
+		"workspace"
+	]
+}