correctly 0.0.0 → 0.1.0

package/src/runtime/worker.ts

@@ -0,0 +1,99 @@
+import { parentPort } from "node:worker_threads"
+import { registerHooks } from "node:module"
+import { TextDocument } from "vscode-languageserver-textdocument"
+import { loadProject, readText } from "../core/config.ts"
+import { Engine } from "../core/engine.ts"
+import { failure, type Position } from "../core/types.ts"
+import { Hints } from "../lsp/hints.ts"
+import { checkProject } from "../cli/check.ts"
+
+if (!parentPort) throw new Error("Correctly project runtime requires a worker")
+const port = parentPort
+let engine: Engine | undefined
+const hints = new Hints()
+const controller = new AbortController()
+const dependencies = new Set<string>()
+function dependency(uri: string, kind: "module" | "resource") {
+	const key = `${kind}:${uri}`
+	if (!uri.startsWith("file:") || dependencies.has(key)) return
+	dependencies.add(key)
+	port.postMessage({ dependency: { uri, kind } })
+}
+// Comline owns loading; hooks only observe dependencies, including failed relative imports.
+registerHooks({
+	resolve(specifier, context, next) {
+		if (
+			context.parentURL &&
+			(specifier.startsWith(".") || specifier.startsWith("file:"))
+		)
+			dependency(new URL(specifier, context.parentURL).href, "module")
+		const result = next(specifier, context)
+		dependency(result.url, "module")
+		return result
+	},
+})
+port.on(
+	"message",
+	(message: {
+		id: number
+		method: string
+		params: Record<string, unknown>
+	}) => {
+		void (async () => {
+			const p = message.params
+			if (message.method === "dispose") {
+				controller.abort()
+				await engine?.dispose()
+				return
+			}
+			if (message.method === "init") {
+				const buffers = new Map(p.buffers as [string, string][])
+				const project = await loadProject(p.configPath as string)
+				engine = new Engine(project, {
+					signal: controller.signal,
+					read: (uri) =>
+						buffers.has(uri)
+							? Promise.resolve(buffers.get(uri)!)
+							: readText(uri),
+					...(p.offline === undefined ? {} : { offline: p.offline as boolean }),
+					onDependency: (uri) => dependency(uri, "resource"),
+				})
+				await engine.prepare()
+				return
+			}
+			if (!engine) throw new Error("Project is not initialized")
+			if (message.method === "validate")
+				return engine.validate(p.file as string, p.text as string)
+			if (message.method === "check") {
+				const sources: [string, string][] = []
+				const report = await checkProject(engine, {
+					cwd: p.cwd as string,
+					...(p.files ? { files: p.files as string[] } : {}),
+					...(p.sources
+						? {
+								onRead: (file: string, text: string) => {
+									sources.push([file, text])
+								},
+							}
+						: {}),
+				})
+				return { report, sources }
+			}
+			const document = TextDocument.create(
+				p.uri as string,
+				p.language as string,
+				p.version as number,
+				p.text as string,
+			)
+			if (message.method === "complete")
+				return hints.complete(engine, document, p.position as Position)
+			if (message.method === "hover")
+				return hints.hover(engine, document, p.position as Position)
+			throw new Error(`Unknown project operation: ${message.method}`)
+		})().then(
+			(value) => port.postMessage({ id: message.id, value }),
+			(error: unknown) =>
+				port.postMessage({ id: message.id, error: failure(error) }),
+		)
+	},
+)

package/src/validators/ajv.ts

@@ -0,0 +1,257 @@
+import {
+	Ajv,
+	type ErrorObject,
+	type ValidateFunction,
+	type SchemaObject,
+} from "ajv"
+import { Ajv2020 } from "ajv/dist/2020.js"
+import addFormats from "ajv-formats"
+import { schemaUri } from "../core/config.ts"
+import { diagnostic, pointer, type ParsedDocument } from "../core/parse.ts"
+import { DIALECTS, SchemaStore } from "../core/schemas.ts"
+import { validationContexts } from "../core/diagnostics.ts"
+import {
+	knownExtensions,
+	installExtensions,
+	assertFormats,
+	type AjvExtension,
+} from "../core/extensions.ts"
+import {
+	CorrectlyError,
+	isCorrectlyError,
+	type Diagnostic,
+} from "../core/types.ts"
+import type { Validator, ValidationContext } from "../core/adapters.ts"
+
+const ANNOTATIONS = [
+	"markdownDescription",
+	"enumDescriptions",
+	"markdownEnumDescriptions",
+	"defaultSnippets",
+	"errorMessage",
+	"patternErrorMessage",
+	"deprecationMessage",
+	"suggestSortText",
+	"doNotSuggest",
+	"allowComments",
+	"allowTrailingCommas",
+	"deprecated",
+	"$vocabulary",
+]
+
+function registerRootAnchors(ajv: Ajv, schema: unknown, uri: string) {
+	if (typeof schema !== "object" || schema === null) return
+	const object = schema as SchemaObject
+	for (const anchor of [object.$anchor, object.$dynamicAnchor]) {
+		if (typeof anchor === "string")
+			ajv.refs[new URL(`#${anchor}`, object.$id ?? uri).href] =
+				object.$id ?? uri
+	}
+}
+
+function validationMessage(error: ErrorObject): string {
+	if (error.keyword === "anyOf")
+		return "must match at least one alternative; none matched"
+	if (
+		error.keyword === "if" &&
+		["then", "else"].includes(error.params.failingKeyword as string)
+	)
+		return `must satisfy the ${error.params.failingKeyword} branch of the conditional schema`
+	if (error.keyword === "uniqueItems") {
+		const { i, j } = error.params
+		if (Number.isInteger(i) && Number.isInteger(j))
+			return `duplicates item at ${error.instancePath}${pointer([Math.min(i, j)])}; array items must be unique`
+	}
+	if (error.keyword === "enum" && Array.isArray(error.params.allowedValues))
+		return `must be one of: ${error.params.allowedValues.map((value: unknown) => JSON.stringify(value)).join(", ")}`
+	if (error.keyword === "const" && Object.hasOwn(error.params, "allowedValue"))
+		return `must equal ${JSON.stringify(error.params.allowedValue)}`
+	if (error.keyword === "oneOf") {
+		if (error.params.passingSchemas === null)
+			return "must match exactly one alternative; none matched"
+		if (Array.isArray(error.params.passingSchemas))
+			return `must match exactly one alternative; multiple matched (alternatives ${error.params.passingSchemas.map((index: number) => index + 1).join(", ")})`
+	}
+	return error.message ?? "Schema violation"
+}
+
+function validationDiagnostic(
+	text: string,
+	parsed: ParsedDocument,
+	error: ErrorObject,
+): Diagnostic {
+	let jsonPointer = error.instancePath
+	if (
+		error.keyword === "uniqueItems" &&
+		Number.isInteger(error.params.i) &&
+		Number.isInteger(error.params.j)
+	)
+		jsonPointer += pointer([Math.max(error.params.i, error.params.j)])
+	const property: unknown =
+		error.params.additionalProperty ??
+		error.params.unevaluatedProperty ??
+		error.params.missingProperty ??
+		error.params.propertyName ??
+		error.propertyName
+	if (typeof property === "string") jsonPointer += pointer([property])
+	const node = parsed.locate(
+		jsonPointer,
+		error.keyword === "additionalProperties" ||
+			error.keyword === "unevaluatedProperties" ||
+			error.keyword === "propertyNames" ||
+			typeof error.propertyName === "string",
+	)
+	const rangeNode =
+		error.keyword === "required" && error.propertyName === undefined
+			? parsed.locate(error.instancePath)
+			: node
+	const length =
+		error.keyword === "required" && error.propertyName === undefined
+			? 1
+			: rangeNode?.length
+	return diagnostic(
+		text,
+		`schema/${error.keyword}`,
+		`${jsonPointer || "/"}: ${validationMessage(error)}`,
+		jsonPointer,
+		rangeNode?.offset ?? 0,
+		length ?? 1,
+	)
+}
+
+async function compile(
+	store: SchemaStore,
+	uri: string,
+	extensions: readonly AjvExtension[],
+): Promise<ValidateFunction> {
+	try {
+		const resource = await store.load(uri)
+		const options = {
+			allErrors: true,
+			strictSchema: true,
+			strictTypes: false,
+			strictTuples: false,
+			strictRequired: false,
+			coerceTypes: false,
+			useDefaults: false,
+			removeAdditional: false,
+			validateSchema: true,
+			loadSchema: async (ref: string) => {
+				const loaded = await store.load(ref, resource.dialect)
+				if (loaded.dialect !== resource.dialect)
+					throw new CorrectlyError(
+						"unsupported-dialect",
+						`Mixed schema dialects: ${uri} references ${ref}`,
+					)
+				assertFormats(
+					ajv,
+					loaded.schema,
+					loaded.uri,
+					knownExtensions,
+					loaded.pointer,
+				)
+				registerRootAnchors(ajv, loaded.schema, loaded.uri)
+				return loaded.schema as SchemaObject
+			},
+		}
+		const ajv =
+			resource.dialect === "2020-12" ? new Ajv2020(options) : new Ajv(options)
+		// CommonJS package exports retain a callable default at runtime.
+		const formats = addFormats as unknown as (instance: Ajv) => void
+		formats(ajv)
+		// ajv-formats also ships OpenAPI numeric names. Their width semantics
+		// belong to an explicitly selected extension, not the baseline.
+		for (const name of ["int32", "int64", "float", "double"])
+			delete ajv.formats[name]
+		for (const keyword of ANNOTATIONS)
+			if (!ajv.RULES.keywords[keyword]) ajv.addKeyword({ keyword, valid: true })
+		// Ajv indexes plain anchors during reference resolution, but does not
+		// register the annotation keyword in its strict vocabulary.
+		if (resource.dialect === "2020-12")
+			ajv.addKeyword({
+				keyword: "$anchor",
+				schemaType: "string",
+				valid: true,
+			})
+		installExtensions(ajv, extensions)
+		assertFormats(
+			ajv,
+			resource.schema,
+			resource.uri,
+			knownExtensions,
+			resource.pointer,
+		)
+		ajv.addSchema(resource.schema, resource.uri)
+		registerRootAnchors(ajv, resource.schema, resource.uri)
+		const validate = await ajv.compileAsync({
+			$schema: DIALECTS[resource.dialect],
+			$ref: uri,
+		})
+		return validate as ValidateFunction
+	} catch (error) {
+		if (isCorrectlyError(error)) throw error
+		throw new CorrectlyError(
+			"schema",
+			`Cannot compile schema ${uri}: ${error instanceof Error ? error.message : String(error)}`,
+		)
+	}
+}
+
+const storeKey = Symbol.for("correctly/ajv/schema-store@1")
+function schemaStore(context: ValidationContext): SchemaStore {
+	let store = context.services.get(storeKey) as SchemaStore | undefined
+	if (!store) {
+		store = new SchemaStore(
+			{
+				root: context.root,
+				config: context.remote ? { remote: context.remote } : {},
+			},
+			{
+				read: context.read,
+				...(context.fetch ? { fetch: context.fetch } : {}),
+				...(context.signal ? { signal: context.signal } : {}),
+			},
+		)
+		context.services.set(storeKey, store)
+	}
+	return store
+}
+export type AjvOptions = {
+	schema: string
+	extensions?: readonly AjvExtension[]
+}
+export function ajv(options: AjvOptions): Validator {
+	const extensions = [...(options.extensions ?? [])]
+	return {
+		id: "ajv",
+		accepts: ["json"],
+		schema: options.schema,
+		extensions,
+		register: async (context) => {
+			await schemaStore(context).load(schemaUri(options.schema, context.root))
+		},
+		prepare: async (context) => {
+			const store = schemaStore(context)
+			const uri = schemaUri(options.schema, context.root)
+			const validate = await compile(store, uri, extensions)
+			return {
+				validate: ({ text, parsed }) =>
+					validate(parsed.value)
+						? []
+						: validationContexts(
+								validate.errors ?? [],
+								(validate.errors ?? []).map((error) =>
+									validationDiagnostic(text, parsed, error),
+								),
+							),
+				editor: {
+					kind: "json-schema",
+					uri,
+					readSchema: async (uri) =>
+						JSON.stringify((await store.load(uri)).schema),
+				},
+			}
+		},
+	}
+}
+export type { AjvExtension } from "../core/extensions.ts"

package/src/vscode/README.md

@@ -1,6 +1,6 @@
 # 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.
+Install Correctly and any imported adapters in the project, trust the workspace, install the VSIX, add `correctly.config.ts` to each workspace root, and open JSON or JSONC files. Correctly uses that same external configuration for validation, completion, and hover. It reads unsaved data and schema buffers. Executable configuration and imported modules reload only after saving. The extension is disabled in untrusted workspaces.
 
 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.
 

package/src/vscode/extension.ts

@@ -3,6 +3,7 @@ import { LanguageClient, TransportKind } from "vscode-languageclient/node"
 
 let client: LanguageClient | undefined
 export async function activate(context: vscode.ExtensionContext) {
+	if (!vscode.workspace.isTrusted) return
 	const watcher = vscode.workspace.createFileSystemWatcher("**/*")
 	context.subscriptions.push(watcher)
 	client = new LanguageClient(
@@ -13,10 +14,7 @@ export async function activate(context: vscode.ExtensionContext) {
 			transport: TransportKind.stdio,
 		},
 		{
-			documentSelector: [
-				{ scheme: "file", language: "json" },
-				{ scheme: "file", language: "jsonc" },
-			],
+			documentSelector: [{ scheme: "file" }],
 			synchronize: { fileEvents: watcher },
 		},
 	)

package/src/vscode/package.json

@@ -32,10 +32,17 @@
 	},
 	"activationEvents": [
 		"onLanguage:json",
-		"onLanguage:jsonc"
+		"onLanguage:jsonc",
+		"workspaceContains:**/correctly.config.ts"
 	],
 	"engines": {
-		"vscode": "^1.100.0"
+		"vscode": "^1.105.0"
+	},
+	"capabilities": {
+		"untrustedWorkspaces": {
+			"supported": false,
+			"description": "Correctly evaluates the project TypeScript configuration and its imported parser, validator, and extension code."
+		}
 	},
 	"extensionKind": [
 		"workspace"