@intlayer/lsp 8.11.3 → 9.0.0-canary.12

package/dist/esm/index.mjs

@@ -1,82 +1,577 @@
 #!/usr/bin/env node
+import { parseText, walkAst } from "./oxcUtils.mjs";
+import { collectNamespaceReferences, findMessageUsageAtOffset, matchCallNamespace } from "./usageAnalyzer.mjs";
+import { escapeRegularExpression, findFieldRangesInFile, offsetToRange } from "./findFieldInFile.mjs";
+import { formatDictionaryHover, formatFieldHover, formatFieldValue, getFieldByPath, getFieldsAtPath } from "./dictionaryUtils.mjs";
+import { buildCallerWithKeyPattern, buildKeyUsagePatterns, getCallerNamesAlternation } from "./callers/patterns.mjs";
 import { findKeyAtOffset } from "./findKeyAtOffset.mjs";
-import { existsSync, readFileSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { findContentFieldAtOffset, findKeyInContentFile } from "./findKeyInContentFile.mjs";
+import { CompletionItemKind, DiagnosticSeverity, Location, MarkupKind, Position, ProposedFeatures, Range, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
-import { getConfiguration } from "@intlayer/config";
+import { getConfiguration } from "@intlayer/config/node";
+import { buildComponentFilesList } from "@intlayer/engine/utils";
 import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
-import { Location, Position, ProposedFeatures, Range, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node.js";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
 //#region src/index.ts
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
+/**
+* Send a log line to the client's Output panel (View → Output → "Intlayer LSP").
+* Uses connection.console.log so it travels over the JSON-RPC channel and never
+* touches stdout (which is reserved for the LSP protocol).
+*/
+const log = (message) => connection.console.log(`[Intlayer LSP] ${message}`);
 let workspaceRoot;
 /**
 * Resolve (and cache) the Intlayer configuration for the current workspace.
 * The LSP process cwd is not the project root, so we must resolve the config
-* from `workspaceRoot` to get the right `system`/`build` paths.
+* from `workspaceRoot` to get the right `system`/`build`/`content` paths.
 */
-let cachedConfig = null;
-const getWorkspaceConfig = () => {
-	if (cachedConfig) return cachedConfig;
-	if (!workspaceRoot) return null;
-	const { system, build } = getConfiguration({ baseDir: workspaceRoot });
-	cachedConfig = {
-		system,
-		build
+const projectConfigs = /* @__PURE__ */ new Map();
+const projectDictionaries = /* @__PURE__ */ new Map();
+const DICTIONARY_CACHE_TTL_MS = 5e3;
+const projectSourceFiles = /* @__PURE__ */ new Map();
+const SOURCE_FILES_CACHE_TTL_MS = 3e4;
+const invalidateConfigCaches = () => {
+	projectConfigs.clear();
+	projectDictionaries.clear();
+	projectSourceFiles.clear();
+};
+const getProjectConfig = (absolutePath) => {
+	try {
+		const { system, build, content, compiler } = getConfiguration({ baseDir: dirname(absolutePath) });
+		const cacheKey = system.baseDir;
+		if (!projectConfigs.has(cacheKey)) {
+			projectConfigs.set(cacheKey, {
+				system,
+				build,
+				content,
+				compiler
+			});
+			log(`getProjectConfig — OK baseDir=${system.baseDir} unmergedDictionariesDir=${system.unmergedDictionariesDir}`);
+		}
+		return projectConfigs.get(cacheKey);
+	} catch (error) {
+		log(`getProjectConfig — FAILED: ${error}`);
+		return null;
+	}
+};
+const getUnmergedDictionariesCached = (config) => {
+	const cacheKey = config.system.baseDir;
+	const cached = projectDictionaries.get(cacheKey);
+	const now = Date.now();
+	if (cached && now - cached.cachedAt < DICTIONARY_CACHE_TTL_MS) return cached.dictionaries;
+	const dictionaries = getUnmergedDictionaries(config);
+	projectDictionaries.set(cacheKey, {
+		dictionaries,
+		cachedAt: now
+	});
+	return dictionaries;
+};
+const isContentFile = (uri, config) => {
+	return (config.content.fileExtensions ?? []).some((extension) => uri.endsWith(extension));
+};
+/** Read a file as UTF-8, returning null on any error. */
+const tryReadFile = async (filePath) => {
+	try {
+		return await readFile(filePath, "utf-8");
+	} catch {
+		return null;
+	}
+};
+/**
+* Run `callback` over every item with at most `limit` tasks in-flight at once.
+* JS is single-threaded so `results.push` inside callback is race-free.
+*/
+const runConcurrent = async (items, callback, limit = 50) => {
+	if (items.length === 0) return;
+	let index = 0;
+	const worker = async () => {
+		while (index < items.length) await callback(items[index++]);
 	};
-	return cachedConfig;
+	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+};
+/** Find the `key: "<key>"` line inside a content file so the cursor lands on it. */
+const getKeyRange = async (absolutePath, key) => {
+	try {
+		const lines = (await readFile(absolutePath, "utf-8")).split(/\r?\n/);
+		const keyRegularExpression = new RegExp(`key\\s*:\\s*['"\`]${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"\`]`);
+		for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+			const column = lines[lineIndex]?.search(keyRegularExpression);
+			if (column !== void 0 && column !== -1) return Range.create(Position.create(lineIndex, column), Position.create(lineIndex, lines[lineIndex].length));
+		}
+	} catch {}
+	return Range.create(Position.create(0, 0), Position.create(0, 0));
 };
 /**
 * Return every `.content` file location that declares the given key.
 * A key can be split across several content files (merged dictionaries), so we
 * return one `Location` per source file, pointing at the `key:` declaration.
 */
-const getContentDeclarationLocations = (key) => {
-	const config = getWorkspaceConfig();
+const getContentDeclarationLocations = async (key, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
 	if (!config) return [];
-	const unmergedDictionaries = getUnmergedDictionaries(config);
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
 	const dictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary?.key === key && dictionary.filePath);
 	const locations = [];
-	for (const dictionary of dictionaries) {
+	await runConcurrent(dictionaries, async (dictionary) => {
 		const filePath = dictionary.filePath;
 		const absolutePath = isAbsolute(filePath) ? filePath : join(config.system.baseDir, filePath);
-		if (!existsSync(absolutePath)) continue;
-		locations.push(Location.create(pathToFileURL(absolutePath).href, getKeyRange(absolutePath, key)));
-	}
+		if (!existsSync(absolutePath)) return;
+		locations.push(Location.create(pathToFileURL(absolutePath).href, await getKeyRange(absolutePath, key)));
+	});
 	return locations;
 };
-/** Find the `key: "<key>"` line inside a content file so the cursor lands on it. */
-const getKeyRange = (absolutePath, key) => {
-	try {
-		const lines = readFileSync(absolutePath, "utf-8").split(/\r?\n/);
-		const keyRegex = new RegExp(`key\\s*:\\s*['"\`]${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}['"\`]`);
-		for (let line = 0; line < lines.length; line++) {
-			const column = lines[line].search(keyRegex);
-			if (column !== -1) return Range.create(Position.create(line, column), Position.create(line, lines[line].length));
+/**
+* Return the cached source-file list, re-scanning only when the cache has
+* expired or been explicitly invalidated (config change, watched-file event).
+*/
+const getSourceFiles = async (directory, config) => {
+	const now = Date.now();
+	const cached = projectSourceFiles.get(directory);
+	if (cached && now - cached.cachedAt < SOURCE_FILES_CACHE_TTL_MS) return cached.files;
+	const startTime = Date.now();
+	const files = buildComponentFilesList(config, [
+		"**/.output/**",
+		"**/.svelte-kit/**",
+		"**/src-tauri/**",
+		"**/.next/**",
+		"**/.nuxt/**",
+		"**/.expo/**",
+		"**/.vercel/**",
+		"**/.turbo/**",
+		"**/.tanstack/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/node_modules/**"
+	]);
+	projectSourceFiles.set(directory, {
+		files,
+		cachedAt: Date.now()
+	});
+	log(`source files scanned: ${files.length} file(s) in ${Date.now() - startTime}ms`);
+	return files;
+};
+/**
+* Return every source-file location that calls useIntlayer / getIntlayer with
+* the given key.
+*/
+const getKeyUsageLocations = async (key, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
+	if (!config) return [];
+	const usagePatterns = buildKeyUsagePatterns(key);
+	const filePaths = await getSourceFiles(config.system.baseDir, config);
+	const locations = [];
+	const startTime = Date.now();
+	await runConcurrent(filePaths, async (filePath) => {
+		const text = await tryReadFile(filePath);
+		if (!text?.includes(key)) return;
+		const seenStarts = /* @__PURE__ */ new Set();
+		for (const usagePattern of usagePatterns) for (const match of text.matchAll(usagePattern)) {
+			const matchStart = match.index;
+			if (seenStarts.has(matchStart)) continue;
+			seenStarts.add(matchStart);
+			const matchEnd = matchStart + match[0].length;
+			locations.push(Location.create(pathToFileURL(filePath).href, offsetToRange(text, matchStart, matchEnd)));
 		}
-	} catch {}
+	});
+	log(`getKeyUsageLocations("${key}") — ${filePaths.length} file(s) searched in ${Date.now() - startTime}ms → ${locations.length} hit(s)`);
+	return locations;
+};
+/**
+* Return every source-file location that accesses the field at `fieldPath` on
+* the result of `useIntlayer(dictionaryKey)` / `getIntlayer(dictionaryKey)`.
+*
+* `fieldPath` is an array of property names from the content root to the
+* target field (e.g. `['searchInput', 'text']` for a nested field).
+* Single-element paths (e.g. `['greet']`) behave like the previous
+* single-`fieldName` API.
+*/
+const getFieldUsageLocations = async (dictionaryKey, fieldPath, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
+	if (!config || fieldPath.length === 0) return [];
+	const leafFieldName = fieldPath[fieldPath.length - 1];
+	const escapedKey = escapeRegularExpression(dictionaryKey);
+	const escapedLeaf = escapeRegularExpression(leafFieldName);
+	const useCallRegularExpression = buildCallerWithKeyPattern(dictionaryKey);
+	const filePaths = await getSourceFiles(config.system.baseDir, config);
+	const locations = [];
+	const startTime = Date.now();
+	await runConcurrent(filePaths, async (filePath) => {
+		const text = await tryReadFile(filePath);
+		if (!text) return;
+		if (!text.includes(dictionaryKey)) return;
+		if (fieldPath.some((segment) => !text.includes(segment))) return;
+		if (!useCallRegularExpression.test(text)) return;
+		for (const range of findFieldRangesInFile(text, escapedKey, leafFieldName, escapedLeaf, fieldPath)) locations.push(Location.create(pathToFileURL(filePath).href, range));
+	});
+	log(`getFieldUsageLocations("${dictionaryKey}.${fieldPath.join(".")}") — ${filePaths.length} file(s) searched in ${Date.now() - startTime}ms → ${locations.length} hit(s)`);
+	return locations;
+};
+/**
+* Find the line/column of the field's leaf name as a property key inside a
+* content file. Looks for `fieldName:` or `'field.name':` (flat keys with
+* dots, as used by lingui catalogs), not just any occurrence. Falls back to
+* the top of the file if the field cannot be located.
+*/
+const getFieldRangeInContentFile = async (absolutePath, fieldPath) => {
+	const content = await tryReadFile(absolutePath);
+	const fieldName = fieldPath[fieldPath.length - 1];
+	if (!content || !fieldName) return Range.create(Position.create(0, 0), Position.create(0, 0));
+	const fieldRegularExpression = new RegExp(`(?<![.\\w])(['"\`]?)${escapeRegularExpression(fieldName)}\\1\\s*:`);
+	const lines = content.split(/\r?\n/);
+	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+		const line = lines[lineIndex];
+		const matchPosition = line.search(fieldRegularExpression);
+		if (matchPosition === -1) continue;
+		const column = line.indexOf(fieldName, matchPosition);
+		if (column === -1) continue;
+		return Range.create(Position.create(lineIndex, column), Position.create(lineIndex, column + fieldName.length));
+	}
 	return Range.create(Position.create(0, 0), Position.create(0, 0));
 };
-connection.onInitialize((params) => {
-	workspaceRoot = params.rootPath || (params.workspaceFolders?.[0]?.uri ? decodeURIComponent(new URL(params.workspaceFolders[0].uri).pathname) : void 0);
-	cachedConfig = null;
+/**
+* Return every content-file location where the field at `fieldPath` is
+* defined as a property of the dictionary with the given `dictionaryKey`.
+*/
+const getContentFieldLocations = async (dictionaryKey, fieldPath, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
+	if (!config) return [];
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
+	const dictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary?.key === dictionaryKey && dictionary.filePath);
+	const locations = [];
+	await runConcurrent(dictionaries, async (dictionary) => {
+		const filePath = dictionary.filePath;
+		const absolutePath = isAbsolute(filePath) ? filePath : join(config.system.baseDir, filePath);
+		if (!existsSync(absolutePath)) return;
+		locations.push(Location.create(pathToFileURL(absolutePath).href, await getFieldRangeInContentFile(absolutePath, fieldPath)));
+	});
+	return locations;
+};
+const DIAGNOSTIC_DEBOUNCE_MS = 300;
+const diagnosticTimers = /* @__PURE__ */ new Map();
+const computeDiagnostics = (text, config) => {
+	const namespaceReferences = collectNamespaceReferences(text);
+	if (namespaceReferences.length === 0) return [];
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
+	const knownKeys = new Set(Object.values(unmergedDictionaries).flat().map((dictionary) => dictionary?.key).filter((key) => typeof key === "string"));
+	const diagnostics = [];
+	for (const reference of namespaceReferences) {
+		if (knownKeys.has(reference.dictionaryKey)) continue;
+		diagnostics.push({
+			range: offsetToRange(text, reference.namespaceStart, reference.namespaceEnd),
+			severity: DiagnosticSeverity.Warning,
+			source: "intlayer",
+			message: `Dictionary key "${reference.dictionaryKey}" is not declared in any content file`
+		});
+	}
+	return diagnostics;
+};
+const sendDiagnosticsForDocument = (uri, text, version) => {
+	const config = getProjectConfig(decodeURIComponent(new URL(uri).pathname));
+	const diagnostics = config && !isContentFile(uri, config) ? computeDiagnostics(text, config) : [];
+	connection.sendDiagnostics({
+		uri,
+		version: version ?? void 0,
+		diagnostics
+	});
+};
+const scheduleDiagnostics = (uri, text, version) => {
+	const existing = diagnosticTimers.get(uri);
+	if (existing !== void 0) clearTimeout(existing);
+	diagnosticTimers.set(uri, setTimeout(() => {
+		diagnosticTimers.delete(uri);
+		sendDiagnosticsForDocument(uri, text, version);
+	}, DIAGNOSTIC_DEBOUNCE_MS));
+};
+/** Find the dictionary key for a simple variable assigned from any registered caller. */
+const resolveVariableToDictionaryKey = (program, varName) => {
+	let result = null;
+	walkAst(program, (node) => {
+		if (result) return true;
+		if (node["type"] !== "VariableDeclarator") return;
+		const id = node["id"];
+		if (id?.["type"] !== "Identifier" || id["name"] !== varName) return;
+		const init = node["init"];
+		if (!init) return;
+		result = matchCallNamespace(init);
+		return true;
+	});
+	return result;
+};
+/**
+* Detect what kind of completion is appropriate at the given offset.
+*
+* Handles:
+*   - key completion: cursor inside first string arg of useIntlayer/getIntlayer
+*   - field (member): cursor after `variable.` where variable came from useIntlayer
+*   - field (destructure): cursor inside `const { | } = useIntlayer("key")`
+*/
+const getCompletionContext = (textBefore, textAfter, program) => {
+	if (new RegExp(`\\b(?:${getCallerNamesAlternation()})\\b(?:<[^<>]*>)?\\s*\\(\\s*['"\`][^'"\`\\n]*$`).test(textBefore)) return { kind: "key" };
+	const memberMatch = /\b(\w+)((?:\.\w+)*)\.$/.exec(textBefore);
+	if (memberMatch && program) {
+		const rootVar = memberMatch[1];
+		const chainStr = memberMatch[2];
+		const dictKey = resolveVariableToDictionaryKey(program, rootVar);
+		if (dictKey) return {
+			kind: "field",
+			dictionaryKey: dictKey,
+			fieldPath: chainStr ? chainStr.slice(1).split(".") : []
+		};
+	}
+	if (/(?:const|let|var)\s*\{[^}]*$/.test(textBefore)) {
+		const destructMatch = new RegExp(`^[^}]*\\}\\s*=\\s*(?:${getCallerNamesAlternation()})(?:<[^<>]*>)?\\s*\\(\\s*['"\`]([^'"\`\\n]+)['"\`]`).exec(textAfter);
+		if (destructMatch) return {
+			kind: "field",
+			dictionaryKey: destructMatch[1],
+			fieldPath: []
+		};
+	}
+	return null;
+};
+connection.onInitialize((parameters) => {
+	workspaceRoot = parameters.rootPath || (parameters.workspaceFolders?.[0]?.uri ? decodeURIComponent(new URL(parameters.workspaceFolders[0].uri).pathname) : void 0);
+	invalidateConfigCaches();
+	log(`initialized — workspaceRoot: ${workspaceRoot ?? "(none)"}`);
+	if (parameters.workspaceFolders?.length) log(`workspaceFolders: ${parameters.workspaceFolders.map((folder) => folder.name).join(", ")}`);
 	return { capabilities: {
 		textDocumentSync: TextDocumentSyncKind.Incremental,
-		definitionProvider: true
+		definitionProvider: true,
+		referencesProvider: true,
+		hoverProvider: true,
+		completionProvider: {
+			triggerCharacters: [
+				"\"",
+				"'",
+				"`",
+				"."
+			],
+			resolveProvider: false
+		}
 	} };
 });
-connection.onDefinition((params) => {
-	const document = documents.get(params.textDocument.uri);
+connection.onDefinition(async (parameters) => {
+	const uri = parameters.textDocument.uri;
+	const absolutePath = decodeURIComponent(new URL(uri).pathname);
+	const position = parameters.position;
+	const document = documents.get(uri);
+	if (!document) {
+		log(`onDefinition — document not found in cache: ${uri}`);
+		return null;
+	}
+	const text = document.getText();
+	const offset = document.offsetAt(position);
+	log(`onDefinition — ${uri.replace(/^file:\/\//, "").split("/").slice(-2).join("/")} ${position.line}:${position.character}`);
+	const config = getProjectConfig(absolutePath);
+	if (config && isContentFile(uri, config)) {
+		log("onDefinition — content file: delegating to extension provider");
+		return null;
+	}
+	const key = findKeyAtOffset(text, offset);
+	if (key) {
+		log(`onDefinition — useIntlayer key: "${key}" → searching content declarations`);
+		const locations = await getContentDeclarationLocations(key, absolutePath);
+		log(`onDefinition — found ${locations.length} content declaration(s) for key "${key}"`);
+		return locations.length ? locations : null;
+	}
+	const usage = findMessageUsageAtOffset(text, offset);
+	if (usage && usage.fieldPath.length > 0) {
+		log(`onDefinition — usage field: "${usage.dictionaryKey}.${usage.fieldPath.join(".")}" (${usage.callerName}) → searching content field`);
+		const locations = await getContentFieldLocations(usage.dictionaryKey, usage.fieldPath, absolutePath);
+		log(`onDefinition — found ${locations.length} content file(s) with field "${usage.fieldPath.join(".")}"`);
+		return locations.length ? locations : null;
+	}
+	if (usage) {
+		const locations = await getContentDeclarationLocations(usage.dictionaryKey, absolutePath);
+		return locations.length ? locations : null;
+	}
+	log("onDefinition — no Intlayer key at cursor, no result");
+	return null;
+});
+/**
+* "Find All References" handler (Shift+F12).
+*
+* From a content file, returns every source-file location that uses the key or
+* field at the cursor — the reverse direction of Go-to-Definition.
+*
+* From a source file, returns all content-file declarations for the key or
+* field at the cursor — complementing what Go-to-Definition already handles.
+*/
+connection.onReferences(async (parameters) => {
+	const uri = parameters.textDocument.uri;
+	const absolutePath = decodeURIComponent(new URL(uri).pathname);
+	const position = parameters.position;
+	const document = documents.get(uri);
 	if (!document) return null;
-	const key = findKeyAtOffset(document.getText(), document.offsetAt(params.position));
+	const text = document.getText();
+	const offset = document.offsetAt(position);
+	log(`onReferences — ${uri.replace(/^file:\/\//, "").split("/").slice(-2).join("/")} ${position.line}:${position.character}`);
+	const config = getProjectConfig(absolutePath);
+	if (config && isContentFile(uri, config)) {
+		const key = findKeyInContentFile(text, offset);
+		if (key) {
+			const locations = await getKeyUsageLocations(key, absolutePath);
+			log(`onReferences — key "${key}" → ${locations.length} call site(s)`);
+			return locations.length ? locations : null;
+		}
+		const extMatch = uri.match(/\.[^.]+$/);
+		const fieldInfo = findContentFieldAtOffset(text, offset, extMatch ? extMatch[0] : "");
+		if (fieldInfo) {
+			const locations = await getFieldUsageLocations(fieldInfo.dictionaryKey, fieldInfo.fieldPath, absolutePath);
+			log(`onReferences — field "${fieldInfo.fieldPath.join(".")}" → ${locations.length} usage(s)`);
+			return locations.length ? locations : null;
+		}
+		return null;
+	}
+	const key = findKeyAtOffset(text, offset);
 	if (key) {
-		const locations = getContentDeclarationLocations(key);
+		const locations = await getContentDeclarationLocations(key, absolutePath);
+		log(`onReferences — key "${key}" → ${locations.length} declaration(s)`);
+		return locations.length ? locations : null;
+	}
+	const usage = findMessageUsageAtOffset(text, offset);
+	if (usage && usage.fieldPath.length > 0) {
+		const locations = await getContentFieldLocations(usage.dictionaryKey, usage.fieldPath, absolutePath);
+		log(`onReferences — field "${usage.fieldPath.join(".")}" → ${locations.length} content definition(s)`);
 		return locations.length ? locations : null;
 	}
 	return null;
 });
+connection.onHover(async (parameters) => {
+	const uri = parameters.textDocument.uri;
+	const absolutePath = decodeURIComponent(new URL(uri).pathname);
+	const document = documents.get(uri);
+	if (!document) return null;
+	const text = document.getText();
+	const offset = document.offsetAt(parameters.position);
+	const config = getProjectConfig(absolutePath);
+	if (!config) return null;
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
+	const getDicts = (key) => Object.values(unmergedDictionaries).flat().filter((d) => d?.key === key);
+	if (isContentFile(uri, config)) {
+		const key = findKeyInContentFile(text, offset);
+		if (key) {
+			const dicts = getDicts(key);
+			if (dicts.length > 0) return { contents: {
+				kind: MarkupKind.Markdown,
+				value: formatDictionaryHover(dicts, key)
+			} };
+		}
+		const fieldInfo = findContentFieldAtOffset(text, offset, uri.match(/\.[^.]+$/)?.[0] ?? "");
+		if (fieldInfo) {
+			const dicts = getDicts(fieldInfo.dictionaryKey);
+			if (dicts.length > 0) {
+				const hoverText = formatFieldHover(dicts, fieldInfo.dictionaryKey, fieldInfo.fieldPath);
+				if (hoverText) return { contents: {
+					kind: MarkupKind.Markdown,
+					value: hoverText
+				} };
+			}
+		}
+		return null;
+	}
+	const key = findKeyAtOffset(text, offset);
+	if (key) {
+		const dicts = getDicts(key);
+		if (dicts.length > 0) return { contents: {
+			kind: MarkupKind.Markdown,
+			value: formatDictionaryHover(dicts, key)
+		} };
+		return null;
+	}
+	const usage = findMessageUsageAtOffset(text, offset);
+	if (usage) {
+		const dicts = getDicts(usage.dictionaryKey);
+		if (dicts.length > 0) {
+			if (usage.fieldPath.length === 0) return { contents: {
+				kind: MarkupKind.Markdown,
+				value: formatDictionaryHover(dicts, usage.dictionaryKey)
+			} };
+			const hoverText = formatFieldHover(dicts, usage.dictionaryKey, usage.fieldPath);
+			if (hoverText) return { contents: {
+				kind: MarkupKind.Markdown,
+				value: hoverText
+			} };
+		}
+	}
+	return null;
+});
+connection.onCompletion(async (parameters) => {
+	const uri = parameters.textDocument.uri;
+	const absolutePath = decodeURIComponent(new URL(uri).pathname);
+	const document = documents.get(uri);
+	if (!document) return null;
+	const text = document.getText();
+	const offset = document.offsetAt(parameters.position);
+	const config = getProjectConfig(absolutePath);
+	if (!config) return null;
+	const program = parseText(text);
+	const context = getCompletionContext(text.slice(0, offset), text.slice(offset), program);
+	if (!context) return null;
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
+	if (context.kind === "key") {
+		const seen = /* @__PURE__ */ new Set();
+		const items = [];
+		for (const dictionary of Object.values(unmergedDictionaries).flat()) {
+			if (!dictionary?.key || seen.has(dictionary.key)) continue;
+			seen.add(dictionary.key);
+			items.push({
+				label: dictionary.key,
+				kind: CompletionItemKind.Value,
+				detail: dictionary.title ?? void 0,
+				documentation: dictionary.description ? {
+					kind: MarkupKind.Markdown,
+					value: dictionary.description
+				} : void 0
+			});
+		}
+		log(`onCompletion — key: ${items.length} dictionary keys`);
+		return items.length > 0 ? items : null;
+	}
+	if (context.kind === "field") {
+		const dictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary?.key === context.dictionaryKey);
+		if (dictionaries.length === 0) return null;
+		const primary = dictionaries[0];
+		const items = getFieldsAtPath(primary.content, context.fieldPath).map((fieldName) => {
+			const value = getFieldByPath(primary.content, [...context.fieldPath, fieldName]);
+			return {
+				label: fieldName,
+				kind: CompletionItemKind.Field,
+				detail: formatFieldValue(value)
+			};
+		});
+		log(`onCompletion — field "${context.dictionaryKey}.${context.fieldPath.join(".")}": ${items.length} field(s)`);
+		return items.length > 0 ? items : null;
+	}
+	return null;
+});
+documents.onDidOpen((event) => {
+	sendDiagnosticsForDocument(event.document.uri, event.document.getText(), event.document.version);
+});
+documents.onDidChangeContent((event) => {
+	scheduleDiagnostics(event.document.uri, event.document.getText(), event.document.version);
+});
+documents.onDidClose((event) => {
+	const uri = event.document.uri;
+	const timer = diagnosticTimers.get(uri);
+	if (timer !== void 0) {
+		clearTimeout(timer);
+		diagnosticTimers.delete(uri);
+	}
+	connection.sendDiagnostics({
+		uri,
+		diagnostics: []
+	});
+});
+connection.onDidChangeWatchedFiles(() => {
+	invalidateConfigCaches();
+	log("watched files changed — source file list and dictionary cache invalidated");
+});
 documents.listen(connection);
 connection.listen();