@intlayer/lsp 8.11.4 → 9.0.0-canary.12

package/dist/esm/index.mjs

@@ -1,14 +1,18 @@
 #!/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 { findContentFieldAtOffset, findKeyInContentFile } from "./findKeyInContentFile.mjs";
-import { findUsageFieldAtOffset } from "./findUsageFieldAtOffset.mjs";
-import { Location, Position, ProposedFeatures, Range, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node.js";
+import { CompletionItemKind, DiagnosticSeverity, Location, MarkupKind, Position, ProposedFeatures, Range, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver/node";
 import { existsSync } from "node:fs";
-import { readFile, readdir } from "node:fs/promises";
-import { extname, isAbsolute, join } from "node:path";
+import { readFile } from "node:fs/promises";
+import { dirname, isAbsolute, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { getConfiguration } from "@intlayer/config/node";
+import { buildComponentFilesList } from "@intlayer/engine/utils";
 import { getUnmergedDictionaries } from "@intlayer/unmerged-dictionaries-entry";
 import { TextDocument } from "vscode-languageserver-textdocument";
 
@@ -27,91 +31,49 @@ let workspaceRoot;
 * The LSP process cwd is not the project root, so we must resolve the config
 * from `workspaceRoot` to get the right `system`/`build`/`content` paths.
 */
-let cachedConfig = null;
-/**
-* Cached unmerged dictionaries with a short TTL so that running
-* `intlayer build` during a session picks up without a full re-init.
-*/
-let cachedDictionaries = null;
-let dictionariesCachedAt = 0;
+const projectConfigs = /* @__PURE__ */ new Map();
+const projectDictionaries = /* @__PURE__ */ new Map();
 const DICTIONARY_CACHE_TTL_MS = 5e3;
-let cachedSourceExtensions = null;
-let cachedExcludedDirs = null;
-let cachedFileExclusionRegexes = null;
-/**
-* Cached list of source file paths.
-* Walking the directory tree is the dominant cost on every Go-to-Definition
-* from a content file. We cache the result for 30 s and re-scan only when
-* the client reports a watched-file change or the config is invalidated.
-*/
-let cachedSourceFiles = null;
-let sourceFilesCachedAt = 0;
+const projectSourceFiles = /* @__PURE__ */ new Map();
 const SOURCE_FILES_CACHE_TTL_MS = 3e4;
 const invalidateConfigCaches = () => {
-	cachedConfig = null;
-	cachedDictionaries = null;
-	dictionariesCachedAt = 0;
-	cachedSourceExtensions = null;
-	cachedExcludedDirs = null;
-	cachedFileExclusionRegexes = null;
-	cachedSourceFiles = null;
-	sourceFilesCachedAt = 0;
+	projectConfigs.clear();
+	projectDictionaries.clear();
+	projectSourceFiles.clear();
 };
-const getWorkspaceConfig = () => {
-	if (cachedConfig) return cachedConfig;
-	if (!workspaceRoot) {
-		log("getWorkspaceConfig — no workspace root, skipping");
-		return null;
-	}
+const getProjectConfig = (absolutePath) => {
 	try {
-		log(`getWorkspaceConfig — loading config from: ${workspaceRoot}`);
-		const { system, build, content } = getConfiguration({ baseDir: workspaceRoot });
-		cachedConfig = {
-			system,
-			build,
-			content
-		};
-		log(`getWorkspaceConfig — OK  baseDir=${system.baseDir}  unmergedDictionariesDir=${system.unmergedDictionariesDir}`);
-		return cachedConfig;
+		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(`getWorkspaceConfig — FAILED: ${error}`);
+		log(`getProjectConfig — FAILED: ${error}`);
 		return null;
 	}
 };
-const getUnmergedDictionariesCached = () => {
+const getUnmergedDictionariesCached = (config) => {
+	const cacheKey = config.system.baseDir;
+	const cached = projectDictionaries.get(cacheKey);
 	const now = Date.now();
-	if (cachedDictionaries && now - dictionariesCachedAt < DICTIONARY_CACHE_TTL_MS) return cachedDictionaries;
-	const config = getWorkspaceConfig();
-	if (!config) return {};
-	cachedDictionaries = getUnmergedDictionaries(config);
-	dictionariesCachedAt = now;
-	return cachedDictionaries;
-};
-const getSourceExtensions = () => {
-	if (cachedSourceExtensions) return cachedSourceExtensions;
-	const traversePattern = getWorkspaceConfig()?.build.traversePattern ?? [];
-	cachedSourceExtensions = new Set(traversePattern.filter((pattern) => !pattern.startsWith("!")).flatMap((pattern) => {
-		const match = pattern.match(/\.\{([^}]+)\}/);
-		return match?.[1] ? match[1].split(",").map((extension) => `.${extension.trim()}`) : [];
-	}));
-	return cachedSourceExtensions;
-};
-const getExcludedDirs = () => {
-	if (cachedExcludedDirs) return cachedExcludedDirs;
-	const traversePattern = getWorkspaceConfig()?.build.traversePattern ?? [];
-	cachedExcludedDirs = new Set(traversePattern.filter((pattern) => /^!\*\*\/[^*/]+\/\*\*$/.test(pattern)).map((pattern) => pattern.replace(/^!\*\*\//, "").replace(/\/\*\*$/, "")));
-	return cachedExcludedDirs;
-};
-const getFileExclusionRegexes = () => {
-	if (cachedFileExclusionRegexes) return cachedFileExclusionRegexes;
-	cachedFileExclusionRegexes = (getWorkspaceConfig()?.build.traversePattern ?? []).filter((pattern) => pattern.startsWith("!") && !/^!\*\*\/[^*/]+\/\*\*$/.test(pattern)).map((pattern) => {
-		const inner = pattern.replace(/^!(\*\*\/)*/, "");
-		return new RegExp(`${inner.replace(/\./g, "\\.").replace(/\*/g, "[^\\/]*")}$`);
+	if (cached && now - cached.cachedAt < DICTIONARY_CACHE_TTL_MS) return cached.dictionaries;
+	const dictionaries = getUnmergedDictionaries(config);
+	projectDictionaries.set(cacheKey, {
+		dictionaries,
+		cachedAt: now
 	});
-	return cachedFileExclusionRegexes;
+	return dictionaries;
 };
-const isContentFile = (uri) => {
-	return (getWorkspaceConfig()?.content.fileExtensions ?? []).some((extension) => uri.endsWith(extension));
+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) => {
@@ -133,32 +95,6 @@ const runConcurrent = async (items, callback, limit = 50) => {
 	};
 	await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
 };
-/**
-* Recursively collect all source-file paths under `directory`.
-* Uses async readdir so it does not block the Node.js event loop.
-*/
-const collectSourceFiles = async (directory) => {
-	const results = [];
-	const sourceExtensions = getSourceExtensions();
-	const excludedDirs = getExcludedDirs();
-	const fileExclusionRegexes = getFileExclusionRegexes();
-	const contentExtensions = getWorkspaceConfig()?.content.fileExtensions ?? [];
-	const visit = async (dir) => {
-		let entries;
-		try {
-			entries = await readdir(dir, { withFileTypes: true });
-		} catch {
-			return;
-		}
-		await Promise.all(entries.map(async (entry) => {
-			if (entry.isDirectory()) {
-				if (!excludedDirs.has(entry.name)) await visit(join(dir, entry.name));
-			} else if (sourceExtensions.has(extname(entry.name)) && !contentExtensions.some((extension) => entry.name.endsWith(extension)) && !fileExclusionRegexes.some((regularExpression) => regularExpression.test(entry.name))) results.push(join(dir, entry.name));
-		}));
-	};
-	await visit(directory);
-	return results;
-};
 /** Find the `key: "<key>"` line inside a content file so the cursor lands on it. */
 const getKeyRange = async (absolutePath, key) => {
 	try {
@@ -176,10 +112,10 @@ const getKeyRange = async (absolutePath, 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 = async (key) => {
-	const config = getWorkspaceConfig();
+const getContentDeclarationLocations = async (key, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
 	if (!config) return [];
-	const unmergedDictionaries = getUnmergedDictionariesCached();
+	const unmergedDictionaries = getUnmergedDictionariesCached(config);
 	const dictionaries = Object.values(unmergedDictionaries).flat().filter((dictionary) => dictionary?.key === key && dictionary.filePath);
 	const locations = [];
 	await runConcurrent(dictionaries, async (dictionary) => {
@@ -194,30 +130,51 @@ const getContentDeclarationLocations = async (key) => {
 * 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) => {
-	if (cachedSourceFiles && Date.now() - sourceFilesCachedAt < SOURCE_FILES_CACHE_TTL_MS) return cachedSourceFiles;
+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();
-	cachedSourceFiles = await collectSourceFiles(directory);
-	sourceFilesCachedAt = Date.now();
-	log(`source files scanned: ${cachedSourceFiles.length} file(s) in ${Date.now() - startTime}ms`);
-	return cachedSourceFiles;
+	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) => {
-	const config = getWorkspaceConfig();
+const getKeyUsageLocations = async (key, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
 	if (!config) return [];
-	const usageRegularExpression = new RegExp(`\\b(?:useIntlayer|getIntlayer)\\b\\s*(?:<[^<>()]*>)?\\s*\\(\\s*(['"\`])${escapeRegularExpression(key)}\\1`, "g");
-	const filePaths = await getSourceFiles(config.system.baseDir);
+	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;
-		for (const match of text.matchAll(usageRegularExpression)) {
+		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)));
 		}
@@ -234,14 +191,14 @@ const getKeyUsageLocations = async (key) => {
 * Single-element paths (e.g. `['greet']`) behave like the previous
 * single-`fieldName` API.
 */
-const getFieldUsageLocations = async (dictionaryKey, fieldPath) => {
-	const config = getWorkspaceConfig();
+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 = new RegExp(`\\b(?:useIntlayer|getIntlayer)\\b(?:<[^<>()]*>)?\\s*\\(\\s*['"\`]${escapedKey}['"\`]`);
-	const filePaths = await getSourceFiles(config.system.baseDir);
+	const useCallRegularExpression = buildCallerWithKeyPattern(dictionaryKey);
+	const filePaths = await getSourceFiles(config.system.baseDir, config);
 	const locations = [];
 	const startTime = Date.now();
 	await runConcurrent(filePaths, async (filePath) => {
@@ -256,15 +213,17 @@ const getFieldUsageLocations = async (dictionaryKey, fieldPath) => {
 	return locations;
 };
 /**
-* Find the line/column of `fieldName` as a property key inside a content file.
-* Looks for `fieldName:` (the field definition), not just any occurrence.
-* Falls back to the top of the file if the field cannot be located.
+* 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, fieldName) => {
+const getFieldRangeInContentFile = async (absolutePath, fieldPath) => {
 	const content = await tryReadFile(absolutePath);
-	if (!content) return Range.create(Position.create(0, 0), Position.create(0, 0));
+	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/);
-	const fieldRegularExpression = new RegExp(`(?<![.\\w])${escapeRegularExpression(fieldName)}(?![\\w])\\s*:`);
 	for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
 		const line = lines[lineIndex];
 		const matchPosition = line.search(fieldRegularExpression);
@@ -276,23 +235,105 @@ const getFieldRangeInContentFile = async (absolutePath, fieldName) => {
 	return Range.create(Position.create(0, 0), Position.create(0, 0));
 };
 /**
-* Return every content-file location where `fieldName` is defined as a
-* property of the dictionary with the given `dictionaryKey`.
+* 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, fieldName) => {
-	const config = getWorkspaceConfig();
+const getContentFieldLocations = async (dictionaryKey, fieldPath, absolutePath) => {
+	const config = getProjectConfig(absolutePath);
 	if (!config) return [];
-	const unmergedDictionaries = getUnmergedDictionariesCached();
+	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, fieldName)));
+		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();
@@ -301,11 +342,22 @@ connection.onInitialize((parameters) => {
 	return { capabilities: {
 		textDocumentSync: TextDocumentSyncKind.Incremental,
 		definitionProvider: true,
-		referencesProvider: true
+		referencesProvider: true,
+		hoverProvider: true,
+		completionProvider: {
+			triggerCharacters: [
+				"\"",
+				"'",
+				"`",
+				"."
+			],
+			resolveProvider: false
+		}
 	} };
 });
 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) {
@@ -315,37 +367,27 @@ connection.onDefinition(async (parameters) => {
 	const text = document.getText();
 	const offset = document.offsetAt(position);
 	log(`onDefinition — ${uri.replace(/^file:\/\//, "").split("/").slice(-2).join("/")} ${position.line}:${position.character}`);
-	if (isContentFile(uri)) {
-		log("onDefinition — detected content file");
-		const key = findKeyInContentFile(text, offset);
-		if (key) {
-			log(`onDefinition — key declaration: "${key}" → searching call sites`);
-			const locations = await getKeyUsageLocations(key);
-			log(`onDefinition — found ${locations.length} call site(s) for key "${key}"`);
-			return locations.length ? locations : null;
-		}
-		const fieldInfo = findContentFieldAtOffset(text, offset);
-		if (fieldInfo) {
-			log(`onDefinition — field: "${fieldInfo.dictionaryKey}.${fieldInfo.fieldPath.join(".")}" → searching usages`);
-			const locations = await getFieldUsageLocations(fieldInfo.dictionaryKey, fieldInfo.fieldPath);
-			log(`onDefinition — found ${locations.length} usage(s) for field path "${fieldInfo.fieldPath.join(".")}"`);
-			return locations.length ? locations : null;
-		}
-		log("onDefinition — cursor not on a key or field declaration, no result");
+	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);
+		const locations = await getContentDeclarationLocations(key, absolutePath);
 		log(`onDefinition — found ${locations.length} content declaration(s) for key "${key}"`);
 		return locations.length ? locations : null;
 	}
-	const usageField = findUsageFieldAtOffset(text, offset);
-	if (usageField) {
-		log(`onDefinition — usage field: "${usageField.dictionaryKey}.${usageField.fieldName}" → searching content field`);
-		const locations = await getContentFieldLocations(usageField.dictionaryKey, usageField.fieldName);
-		log(`onDefinition — found ${locations.length} content file(s) with field "${usageField.fieldName}"`);
+	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");
@@ -362,22 +404,25 @@ connection.onDefinition(async (parameters) => {
 */
 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 text = document.getText();
 	const offset = document.offsetAt(position);
 	log(`onReferences — ${uri.replace(/^file:\/\//, "").split("/").slice(-2).join("/")} ${position.line}:${position.character}`);
-	if (isContentFile(uri)) {
+	const config = getProjectConfig(absolutePath);
+	if (config && isContentFile(uri, config)) {
 		const key = findKeyInContentFile(text, offset);
 		if (key) {
-			const locations = await getKeyUsageLocations(key);
+			const locations = await getKeyUsageLocations(key, absolutePath);
 			log(`onReferences — key "${key}" → ${locations.length} call site(s)`);
 			return locations.length ? locations : null;
 		}
-		const fieldInfo = findContentFieldAtOffset(text, offset);
+		const extMatch = uri.match(/\.[^.]+$/);
+		const fieldInfo = findContentFieldAtOffset(text, offset, extMatch ? extMatch[0] : "");
 		if (fieldInfo) {
-			const locations = await getFieldUsageLocations(fieldInfo.dictionaryKey, fieldInfo.fieldPath);
+			const locations = await getFieldUsageLocations(fieldInfo.dictionaryKey, fieldInfo.fieldPath, absolutePath);
 			log(`onReferences — field "${fieldInfo.fieldPath.join(".")}" → ${locations.length} usage(s)`);
 			return locations.length ? locations : null;
 		}
@@ -385,23 +430,146 @@ connection.onReferences(async (parameters) => {
 	}
 	const key = findKeyAtOffset(text, offset);
 	if (key) {
-		const locations = await getContentDeclarationLocations(key);
+		const locations = await getContentDeclarationLocations(key, absolutePath);
 		log(`onReferences — key "${key}" → ${locations.length} declaration(s)`);
 		return locations.length ? locations : null;
 	}
-	const usageField = findUsageFieldAtOffset(text, offset);
-	if (usageField) {
-		const locations = await getContentFieldLocations(usageField.dictionaryKey, usageField.fieldName);
-		log(`onReferences — field "${usageField.fieldName}" → ${locations.length} content definition(s)`);
+	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(() => {
-	cachedSourceFiles = null;
-	sourceFilesCachedAt = 0;
-	cachedDictionaries = null;
-	dictionariesCachedAt = 0;
+	invalidateConfigCaches();
 	log("watched files changed — source file list and dictionary cache invalidated");
 });
 documents.listen(connection);