i18n-lens-language-server 0.8.2 → 0.11.0

package/README.md

@@ -7,9 +7,36 @@ Zed extension plus Language Server for Vue, TypeScript, TSX, JavaScript and JSX.
 - Inline translation display via LSP inlay hints
 - Detect `$t`/`t`/`tc`/`$tc`/`i18n.t` calls, `v-t="'key'"`, `v-t="{ path: 'key' }"`, `<i18n-t keypath="key">` (Vue I18n), `<Trans i18nKey="key">` (react-i18next), and `formatMessage({ id: "key" })` (react-intl)
 - Hover: show all locale values for a key
-- Diagnostics: report missing keys, missing locale entries, and mismatched interpolation params
+- Diagnostics: report missing keys, missing locale entries, mismatched interpolation params, and (on locale files) keys whose params differ across languages
+- Quick fixes: add missing / remove unused interpolation params on supported i18n calls, and create a missing key in every locale file that lacks it
 - Completion: suggest existing i18n keys with default locale text
 - Definition: jump from a source key to its locale definition; when several locales define the key, pick which language file to open
+- References: from a key in a locale file (or a source usage), find every place the key is used across the project's source code
+
+## Installation
+
+Install **I18n Lens** from Zed's extension catalog. The extension downloads its companion language server package, [`i18n-lens-language-server`](https://www.npmjs.com/package/i18n-lens-language-server), into Zed's extension work directory at runtime.
+
+After installation, open a Vue, TypeScript, TSX, JavaScript, or JSX file in a project that contains locale files. If your locale files are not in one of the default directories, configure `localeDirs` as shown below.
+
+## Quick start
+
+For most projects, add this to your project `.zed/settings.json` or user-level Zed settings:
+
+```json
+{
+  "lsp": {
+    "i18n-lens": {
+      "settings": {
+        "defaultLocale": "en-US",
+        "localeDirs": ["src/locales", "src/i18n"]
+      }
+    }
+  }
+}
+```
+
+If you prefer a project-owned config file that can be committed with the repository, create `.zed/i18nlensrc.json` instead. When both are present, `.zed/i18nlensrc.json` takes precedence over Zed settings.
 
 ## Inline translations
 
@@ -27,7 +54,7 @@ will show the default locale translation inline after the key string, for exampl
 t("order.pay_now")  立即支付
 ```
 
-The inline hint uses `defaultLocale` from `.zed/i18nlensrc.json`, falling back to `zh-CN`. Missing keys are not shown inline because diagnostics already report them.
+The inline hint uses `defaultLocale` from your Zed settings or `.zed/i18nlensrc.json`, falling back to `zh-CN`. Missing keys are not shown inline because diagnostics already report them.
 
 Long translations are truncated inline to keep the editor readable. Hover still shows the full locale table.
 
@@ -47,6 +74,7 @@ Diagnostics distinguish between these cases:
 - If a key exists in at least one locale but is missing from other locales, it is reported as a warning listing the missing locale names.
 - If a translation contains named placeholders such as `{count}` but the source call does not pass them, it reports missing params.
 - If the source call passes params that no loaded translation uses, it reports unused params.
+- Quick fixes can add missing params to supported i18n calls.
 
 For example, if `order.pay_now` exists in `zh-CN` but is missing from `en-US`, the warning message is:
 
@@ -56,25 +84,57 @@ Missing i18n key "order.pay_now" in locales: en-US
 
 ## Project configuration
 
-You can add `.zed/i18nlensrc.json` under your project root to override the defaults:
+I18n Lens supports two configuration sources:
+
+1. Zed settings, under `lsp.i18n-lens.settings`.
+2. A project file, `.zed/i18nlensrc.json`.
+
+The project file is merged on top of Zed settings, so repository-specific configuration can override personal or team-wide editor settings.
+
+### Configure from Zed settings
+
+Use this when you want configuration to live in Zed's normal settings system:
 
 ```json
 {
-  "defaultLocale": "zh-CN",
-  "localeDirs": ["src/locales", "src/i18n", "locales", "i18n"],
+  "lsp": {
+    "i18n-lens": {
+      "settings": {
+        "defaultLocale": "en-US",
+        "localeDirs": ["src/locales", "src/i18n"],
+        "inlayHints": {
+          "enabled": true,
+          "maxLength": 32
+        }
+      }
+    }
+  }
+}
+```
+
+Zed settings can be user-level or project-level. For project-level Zed settings, put the snippet in `.zed/settings.json`.
+
+### Configure from `.zed/i18nlensrc.json`
+
+Use this when the i18n layout should be part of the repository and shared by everyone who opens it:
+
+```json
+{
+  "defaultLocale": "en-US",
+  "localeDirs": ["src/locales", "src/i18n"],
   "inlayHints": {
     "enabled": true,
-    "maxLength": 24
+    "maxLength": 32
   },
   "packages": [
     {
       "root": "apps/web",
-      "defaultLocale": "zh-CN",
+      "defaultLocale": "en-US",
       "localeDirs": ["src/locales"]
     },
     {
       "root": "packages/admin",
-      "defaultLocale": "en-US",
+      "defaultLocale": "ja-JP",
       "localeDirs": ["src/i18n"]
     }
   ]
@@ -92,31 +152,31 @@ Supported options:
 | Option | Type | Default | Description |
 |---|---|---|---|
 | `defaultLocale` | string | `zh-CN` | Locale used for completion details and inline translation hints. Supports exact names such as `en-US`, case-insensitive matching, `_`/`-` normalization, and language aliases such as `en` matching `en-US`. |
-| `localeDirs` | string[] | `src/locales`, `src/i18n`, `locales`, `i18n` | Workspace-relative directories to scan for locale files. |
-| `inlayHints.enabled` | boolean | `true` | Enables or disables inline translation hints from this language server. |
-| `inlayHints.maxLength` | number | `24` | Maximum inline hint label length before truncation. |
+| `localeDirs` | string[] | `src/locales`, `src/i18n`, `locales`, `i18n` | Workspace-relative directories to scan for locale files. In package configs, paths are relative to that package root. |
+| `inlayHints.enabled` | boolean | `true` | Enables or disables inline translation hints from this language server. Hover, completion, definition, diagnostics, and quick fixes can still work when inline hints are disabled. |
+| `inlayHints.maxLength` | number | `24` | Maximum inline hint label length before truncation. Hover still shows the full text. |
 | `packages` | array | `[]` | Optional monorepo package contexts. Each item needs a workspace-relative `root` and can override `defaultLocale`, `localeDirs`, and `inlayHints`. The language server picks the longest package root matching the currently edited file. |
 
-Invalid or missing config values fall back to defaults. If `.zed/i18nlensrc.json` contains invalid JSON, the language server logs a warning and continues with default config.
+Invalid or missing config values fall back to defaults. If `.zed/i18nlensrc.json` contains invalid JSON, the language server logs a warning and continues with the Zed settings or default config.
 
-Configuration changes are watched automatically. After saving `.zed/i18nlensrc.json`, the language server reloads config, rebuilds the locale cache, refreshes diagnostics, and asks the editor to refresh inlay hints. You should not need to rebuild or reload the Zed extension just to apply config changes.
+Configuration changes are watched automatically. After saving `.zed/i18nlensrc.json`, the language server reloads config, rebuilds the locale cache, refreshes diagnostics, and asks the editor to refresh inlay hints. Changes made through Zed settings are also handled through the language server configuration update path.
 
 ## Locale discovery
 
-In a single-project workspace, `localeDirs` are resolved relative to the workspace root. The language server currently reads JSON files from:
+In a single-project workspace, `localeDirs` are resolved relative to the workspace root. By default, the language server reads JSON files from these directories if they exist:
 
 - `src/locales/*.json`
 - `src/i18n/*.json`
 - `locales/*.json`
 - `i18n/*.json`
 
-Locale name comes from filename, for example `zh-CN.json` or `en-US.json`.
+Locale names come from filenames, for example `en-US.json`, `ja-JP.json`, or `zh-CN.json`. If your files are under a nested directory such as `src/i18n/locales/en-US.json`, set `localeDirs` to `["src/i18n/locales"]`.
 
 It also supports locale directories such as:
 
 ```text
-src/locales/zh-CN/common.json
 src/locales/en-US/common.json
+src/locales/ja-JP/common.json
 ```
 
 A file named `common.json` contributes keys with the `common.` prefix. A file named `index.json` contributes keys without an `index.` prefix.
@@ -127,7 +187,7 @@ For pnpm/turborepo and other monorepos, put `.zed/i18nlensrc.json` under the wor
 
 ```json
 {
-  "defaultLocale": "zh-CN",
+  "defaultLocale": "en-US",
   "packages": [
     {
       "root": "apps/web",

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "i18n-lens-language-server",
-  "version": "0.8.2",
+  "version": "0.11.0",
   "type": "module",
-  "description": "Language server for configurable i18n inlay hints, hover, completion, diagnostics, and definition in Vue/TS/TSX/JS.",
+  "description": "Language server for configurable i18n inlay hints, hover, completion, diagnostics, definition, and references in Vue/TS/TSX/JS.",
   "license": "MIT",
   "repository": {
     "type": "git",

package/server/core.js

@@ -22,6 +22,18 @@ export function normalizeI18nLensConfig(raw = {}) {
   return { ...base, packages };
 }
 
+export function mergeI18nLensConfig(base = {}, override = {}) {
+  return {
+    ...base,
+    ...override,
+    inlayHints: {
+      ...((base && typeof base.inlayHints === 'object') ? base.inlayHints : {}),
+      ...((override && typeof override.inlayHints === 'object') ? override.inlayHints : {}),
+    },
+    packages: Array.isArray(override?.packages) ? override.packages : base?.packages,
+  };
+}
+
 function normalizeProjectConfig(raw = {}, defaults = DEFAULT_CONFIG) {
   const defaultLocale = typeof raw.defaultLocale === 'string' && raw.defaultLocale.trim()
     ? raw.defaultLocale.trim()
@@ -157,8 +169,10 @@ function collectFunctionCallKeys(text, found) {
     const key = keyMatch[2];
     const start = parenOffset + keyMatch[0].indexOf(key);
     const end = start + key.length;
-    const args = splitArgs(callText.slice(1, -1));
-    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)) });
+    const args = splitArgsWithOffsets(callText.slice(1, -1));
+    const paramsEdit = getParamsEdit(args.slice(1), parenOffset + 1, parenOffset + callText.length - 1);
+    const paramsObject = extractParamsObject(args.slice(1), parenOffset + 1);
+    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit, paramsObject });
   }
 }
 
@@ -169,14 +183,16 @@ function collectFormatMessageKeys(text, found) {
     const parenOffset = re.lastIndex - 1;
     const callText = readParens(text, parenOffset);
     if (!callText) continue;
-    const args = splitArgs(callText.slice(1, -1));
-    const idArg = args[0] || '';
+    const args = splitArgsWithOffsets(callText.slice(1, -1));
+    const idArg = args[0]?.text || '';
     const keyMatch = idArg.match(/\bid\s*:\s*(['"])([A-Za-z0-9_.:-]+)\1/);
     if (!keyMatch) continue;
     const key = keyMatch[2];
     const start = parenOffset + 1 + idArg.indexOf(key);
     const end = start + key.length;
-    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)) });
+    const paramsEdit = getParamsEdit(args.slice(1), parenOffset + 1, parenOffset + callText.length - 1);
+    const paramsObject = extractParamsObject(args.slice(1), parenOffset + 1);
+    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit, paramsObject });
   }
 }
 
@@ -225,26 +241,87 @@ function splitArgs(text) {
   return args;
 }
 
+function splitArgsWithOffsets(text) {
+  const args = [];
+  let start = 0, depth = 0, quote = '', escaped = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === quote) quote = '';
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === '`') { quote = ch; continue; }
+    if (ch === '{' || ch === '[' || ch === '(') depth++;
+    else if (ch === '}' || ch === ']' || ch === ')') depth--;
+    else if (ch === ',' && depth === 0) { args.push(trimArg(text, start, i)); start = i + 1; }
+  }
+  const last = trimArg(text, start, text.length);
+  if (last.text) args.push(last);
+  return args;
+}
+
+function trimArg(text, start, end) {
+  while (start < end && /\s/.test(text[start])) start++;
+  while (end > start && /\s/.test(text[end - 1])) end--;
+  return { text: text.slice(start, end), start, end };
+}
+
+function getParamsEdit(args, argsStartOffset, closingParenOffset) {
+  const objectArg = args.find((arg) => arg.text.startsWith('{') && arg.text.lastIndexOf('}') > 0);
+  if (objectArg) {
+    const closeBrace = objectArg.text.lastIndexOf('}');
+    let insertAt = closeBrace;
+    while (insertAt > 1 && /\s/.test(objectArg.text[insertAt - 1])) insertAt--;
+    const body = objectArg.text.slice(1, insertAt);
+    return { insertOffset: argsStartOffset + objectArg.start + insertAt, prefix: body.trim() ? ', ' : ' ' };
+  }
+  return { insertOffset: closingParenOffset, prefix: ', { ', suffix: ' }' };
+}
+
 function collectParamNames(args) {
   const params = new Set();
   for (const arg of args) {
-    const trimmed = arg.trim();
+    const trimmed = (typeof arg === 'string' ? arg : arg.text).trim();
     if (!trimmed.startsWith('{')) continue;
     const body = trimmed.slice(1, trimmed.lastIndexOf('}'));
     for (const part of splitArgs(body)) {
-      const m = part.trim().match(/^(?:['"]([^'"]+)['"]|([A-Za-z_$][\w$]*))\s*(?::|$)/);
-      const name = m && (m[1] || m[2]);
-      if (name && !part.trim().startsWith('...')) params.add(name);
+      const name = paramNameOf(part);
+      if (name) params.add(name);
     }
   }
   return [...params].sort();
 }
 
+function paramNameOf(part) {
+  const trimmed = String(part).trim();
+  if (trimmed.startsWith('...')) return undefined;
+  const m = trimmed.match(/^(?:['"]([^'"]+)['"]|([A-Za-z_$][\w$]*))\s*(?::|$)/);
+  return (m && (m[1] || m[2])) || undefined;
+}
+
+// Absolute span of the params object literal plus each top-level property's raw
+// text, so a code action can rebuild the object with unused params removed.
+function extractParamsObject(args, argsStartOffset) {
+  const objectArg = args.find((arg) => arg.text.startsWith('{') && arg.text.lastIndexOf('}') > 0);
+  if (!objectArg) return undefined;
+  const start = argsStartOffset + objectArg.start;
+  const body = objectArg.text.slice(1, objectArg.text.lastIndexOf('}'));
+  const props = splitArgsWithOffsets(body).map((part) => ({ name: paramNameOf(part.text), text: part.text }));
+  return { start, end: start + objectArg.text.length, props };
+}
+
 export function keyAtPosition(text, position) {
   const offset = positionToOffset(text, position);
   return extractI18nKeys(text).find((item) => item.startOffset <= offset && offset <= item.endOffset);
 }
 
+// Reverse of Go to Definition: every range in `text` (source code) that uses `key`.
+export function findCodeKeyRanges(text, key) {
+  return extractI18nKeys(text).filter((item) => item.key === key).map((item) => item.range);
+}
+
 export function positionToOffset(text, position) {
   const lines = text.split('\n');
   let offset = 0;
@@ -334,7 +411,11 @@ export function getDiagnostics(text, locales) {
         data: { key: item.key, missingLocales, missingInAllLocales },
       });
     }
-    if (missingLocales.length !== localeEntries.length) diagnostics.push(...getParamDiagnostics(item, localeEntries));
+    if (missingLocales.length !== localeEntries.length) {
+      diagnostics.push(...getParamDiagnostics(item, localeEntries));
+      const consistency = getLocaleParamConsistency(item.key, locales);
+      if (!consistency.consistent) diagnostics.push(paramInconsistencyDiagnostic(item.key, item.range, consistency.perLocale));
+    }
     return diagnostics;
   });
 }
@@ -363,6 +444,97 @@ function collectRequiredParams(key, localeEntries) {
   return [...params].sort();
 }
 
+// Compare the interpolation placeholders a key uses across every locale that
+// defines it. `consistent` is false when two locales that both define the key
+// carry different param sets (a translation forgot or renamed a placeholder).
+// Locales that do not define the key are ignored — that is a missing-key concern.
+export function getLocaleParamConsistency(key, locales) {
+  const perLocale = [];
+  for (const [name, locale] of Object.entries(locales || {})) {
+    const value = locale.flat?.[key];
+    if (value === undefined) continue;
+    perLocale.push({ name, params: extractPlaceholders(value) });
+  }
+  const union = [...new Set(perLocale.flatMap((entry) => entry.params))].sort();
+  const consistent = perLocale.length < 2
+    || perLocale.every((entry) => entry.params.length === union.length && union.every((param) => entry.params.includes(param)));
+  return { consistent, perLocale, union };
+}
+
+// Warnings for keys defined in `locale`'s file whose params disagree with the
+// same key in other locales, anchored at each key's position in the file text.
+export function getLocaleParamDiagnostics(locale, filePath, text, locales) {
+  if (!locale?.flat) return [];
+  const isJson = /\.json$/i.test(filePath);
+  const diagnostics = [];
+  for (const key of Object.keys(locale.flat)) {
+    const consistency = getLocaleParamConsistency(key, locales);
+    if (consistency.consistent) continue;
+    const lookupKey = lookupKeyForLocaleFile(locale, filePath, key);
+    const position = isJson ? findJsonKeyLocation(text, lookupKey) : findLocaleKeyLocation(text, lookupKey);
+    if (!position) continue;
+    const leaf = lookupKey.split('.').at(-1);
+    const end = { line: position.line, character: position.character + leaf.length + (isJson ? 2 : 0) };
+    diagnostics.push(paramInconsistencyDiagnostic(key, { start: position, end }, consistency.perLocale));
+  }
+  return diagnostics;
+}
+
+function paramInconsistencyDiagnostic(key, range, perLocale) {
+  return {
+    severity: 2,
+    range,
+    message: 'i18n params for "' + key + '" differ across locales — ' + formatPerLocaleParams(perLocale),
+    source: 'i18n-lens',
+    data: { key, paramInconsistency: perLocale },
+  };
+}
+
+function formatPerLocaleParams(perLocale) {
+  return perLocale
+    .map((entry) => entry.name + ': ' + (entry.params.length ? entry.params.map((p) => '{' + p + '}').join(', ') : '(none)'))
+    .join('; ');
+}
+
+export function getParamCodeActions(text, diagnostics = []) {
+  const items = extractI18nKeys(text);
+  return diagnostics.flatMap((diagnostic) => {
+    const item = items.find((candidate) => candidate.key === diagnostic.data?.key && sameRange(candidate.range, diagnostic.range));
+
+    const missingParams = diagnostic.data?.missingParams;
+    if (Array.isArray(missingParams) && missingParams.length > 0) {
+      if (!item?.paramsEdit) return [];
+      const newText = item.paramsEdit.prefix + missingParams.join(', ') + (item.paramsEdit.suffix || '');
+      return [{
+        title: 'Add missing i18n params: ' + missingParams.join(', '),
+        diagnostic,
+        edit: { range: makeRange(text, item.paramsEdit.insertOffset, item.paramsEdit.insertOffset), newText },
+      }];
+    }
+
+    const unusedParams = diagnostic.data?.unusedParams;
+    if (Array.isArray(unusedParams) && unusedParams.length > 0) {
+      if (!item?.paramsObject) return [];
+      const kept = item.paramsObject.props.filter((prop) => !unusedParams.includes(prop.name));
+      const rebuilt = kept.length ? '{ ' + kept.map((prop) => prop.text).join(', ') + ' }' : '{}';
+      return [{
+        title: 'Remove unused i18n params: ' + unusedParams.join(', '),
+        diagnostic,
+        edit: { range: makeRange(text, item.paramsObject.start, item.paramsObject.end), newText: rebuilt },
+      }];
+    }
+
+    return [];
+  });
+}
+
+function sameRange(a, b) {
+  return a?.start?.line === b?.start?.line
+    && a?.start?.character === b?.start?.character
+    && a?.end?.line === b?.end?.line
+    && a?.end?.character === b?.end?.character;
+}
+
 export function extractPlaceholders(value) {
   const params = new Set();
   // ICU-style: {name, plural, ...} — extract top-level name, skip nested content
@@ -440,6 +612,29 @@ export function collectLocaleKeyTargets(locales, key, localeTexts = {}, defaultL
     .filter((target) => target?.position);
 }
 
+// Inverse of findLocaleKeyTarget: given a caret position inside a locale file,
+// return the full flattened key it points at (so Find References can jump back
+// to the code). Reuses the same key->location logic as Go to Definition to stay
+// consistent; precise for JSON, best-effort (line-based) for TS/JS locale modules.
+export function localeKeyAtPosition(locale, filePath, text, position) {
+  if (!locale || !locale.flat || !text || !position) return undefined;
+  const isJson = /\.json$/i.test(filePath);
+  let lineFallback;
+  let lineFallbackCount = 0;
+  for (const fullKey of Object.keys(locale.flat)) {
+    const lookupKey = lookupKeyForLocaleFile(locale, filePath, fullKey);
+    const loc = isJson ? findJsonKeyLocation(text, lookupKey) : findLocaleKeyLocation(text, lookupKey);
+    if (!loc || loc.line !== position.line) continue;
+    const leaf = lookupKey.split('.').at(-1);
+    const tokenStart = loc.character;
+    const tokenEnd = tokenStart + leaf.length + (isJson ? 2 : 0);
+    if (position.character >= tokenStart && position.character <= tokenEnd) return fullKey;
+    lineFallback = fullKey;
+    lineFallbackCount++;
+  }
+  return lineFallbackCount === 1 ? lineFallback : undefined;
+}
+
 export function getCompletionPrefix(text, position) {
   const offset = positionToOffset(text, position);
   const before = text.slice(0, offset);
@@ -470,6 +665,85 @@ export function findJsonKeyLocation(jsonText, key) {
   return undefined;
 }
 
+// Surgically insert a dotted `key` into a JSON document, creating intermediate
+// objects as needed and preserving the rest of the file's formatting. Returns
+// the new text, or undefined if the JSON is unparseable or the key already exists.
+export function insertNestedJsonKey(jsonText, key, value = '') {
+  let root;
+  try { root = JSON.parse(jsonText); } catch { return undefined; }
+  if (!root || typeof root !== 'object' || Array.isArray(root)) return undefined;
+  if (getValueByKey(root, key) !== undefined) return undefined;
+
+  const parts = key.split('.');
+  let node = root;
+  let existingDepth = 0;
+  for (; existingDepth < parts.length - 1; existingDepth++) {
+    const next = node[parts[existingDepth]];
+    if (next && typeof next === 'object' && !Array.isArray(next)) node = next;
+    else break;
+  }
+
+  const span = findJsonObjectSpan(jsonText, parts.slice(0, existingDepth));
+  if (!span) return undefined;
+
+  const unit = detectIndentUnit(jsonText);
+  const snippet = buildNestedProperty(parts.slice(existingDepth), value, unit.repeat(existingDepth + 1), unit);
+  const inner = jsonText.slice(span.openBrace + 1, span.contentEnd).trim();
+  if (inner.length === 0) {
+    return jsonText.slice(0, span.openBrace + 1) + '\n' + snippet + '\n' + unit.repeat(existingDepth) + jsonText.slice(span.closeBrace);
+  }
+  const needsComma = jsonText[span.contentEnd - 1] !== ',';
+  return jsonText.slice(0, span.contentEnd) + (needsComma ? ',' : '') + '\n' + snippet + jsonText.slice(span.contentEnd);
+}
+
+function findJsonObjectSpan(jsonText, pathParts) {
+  let searchFrom = 0;
+  if (pathParts.length) {
+    const pos = findJsonKeyLocation(jsonText, pathParts.join('.'));
+    if (!pos) return undefined;
+    const colon = jsonText.indexOf(':', positionToOffset(jsonText, pos));
+    if (colon === -1) return undefined;
+    searchFrom = colon + 1;
+  }
+  const openBrace = jsonText.indexOf('{', searchFrom);
+  if (openBrace === -1) return undefined;
+  const closeBrace = matchBrace(jsonText, openBrace);
+  if (closeBrace === -1) return undefined;
+  let contentEnd = closeBrace;
+  while (contentEnd > openBrace + 1 && /\s/.test(jsonText[contentEnd - 1])) contentEnd--;
+  return { openBrace, closeBrace, contentEnd };
+}
+
+function matchBrace(text, open) {
+  let depth = 0;
+  let quote = false;
+  let escaped = false;
+  for (let i = open; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (escaped) escaped = false;
+      else if (ch === '\\') escaped = true;
+      else if (ch === '"') quote = false;
+      continue;
+    }
+    if (ch === '"') quote = true;
+    else if (ch === '{') depth++;
+    else if (ch === '}' && --depth === 0) return i;
+  }
+  return -1;
+}
+
+function detectIndentUnit(jsonText) {
+  const match = jsonText.match(/\n([ \t]+)\S/);
+  return match ? match[1] : '  ';
+}
+
+function buildNestedProperty(parts, value, indent, unit) {
+  const keyStr = JSON.stringify(parts[0]);
+  if (parts.length === 1) return indent + keyStr + ': ' + JSON.stringify(value);
+  return indent + keyStr + ': {\n' + buildNestedProperty(parts.slice(1), value, indent + unit, unit) + '\n' + indent + '}';
+}
+
 
 export function parseTsLocaleModule(text, fileName = 'index.ts') {
   const result = {};

package/server/index.js

@@ -2,19 +2,25 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL, fileURLToPath } from 'node:url';
-import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, MarkupKind } from 'vscode-languageserver/node.js';
+import { createConnection, TextDocuments, ProposedFeatures, TextDocumentSyncKind, MarkupKind, CodeActionKind } from 'vscode-languageserver/node.js';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import {
   flattenLocale,
   buildHoverMarkdown,
   getDiagnostics,
+  getLocaleParamDiagnostics,
+  getParamCodeActions,
+  insertNestedJsonKey,
   getCompletions,
   getCompletionPrefix,
   keyAtPosition,
   parseTsLocaleModule,
   collectLocaleKeyTargets,
+  localeKeyAtPosition,
+  findCodeKeyRanges,
   getInlayHints,
   normalizeI18nLensConfig,
+  mergeI18nLensConfig,
   resolveConfigPath,
   CONFIG_RELATIVE_PATH,
   didWatchedFileChange,
@@ -25,6 +31,7 @@ import {
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
 let workspaceRoot = process.cwd();
+let zedSettingsConfig = {};
 let config = normalizeI18nLensConfig();
 let watchedConfigPath;
 const watchedLocalePaths = new Set();
@@ -37,9 +44,10 @@ const reloadDebounceMs = 100;
 
 connection.onInitialize((params) => {
   workspaceRoot = params.workspaceFolders?.[0]?.uri ? fileURLToPath(params.workspaceFolders[0].uri) : (params.rootUri ? fileURLToPath(params.rootUri) : process.cwd());
+  zedSettingsConfig = normalizeIncomingSettings(params.initializationOptions);
   loadConfig();
   watchConfigFile();
-  return { capabilities: { textDocumentSync: TextDocumentSyncKind.Incremental, hoverProvider: true, completionProvider: { triggerCharacters: ['.', '"', "'"] }, definitionProvider: true, inlayHintProvider: true } };
+  return { capabilities: { textDocumentSync: TextDocumentSyncKind.Incremental, hoverProvider: true, completionProvider: { triggerCharacters: ['.', '"', "'"] }, definitionProvider: true, referencesProvider: true, inlayHintProvider: true, codeActionProvider: true } };
 });
 
 connection.onInitialized(() => {
@@ -58,6 +66,11 @@ documents.onDidOpen((event) => {
 documents.onDidChangeContent((event) => validate(event.document));
 documents.onDidSave(() => scheduleProjectReload());
 
+connection.onDidChangeConfiguration((params) => {
+  zedSettingsConfig = normalizeIncomingSettings(params.settings);
+  scheduleProjectReload();
+});
+
 connection.onHover((params) => {
   const doc = documents.get(params.textDocument.uri);
   if (!doc) return null;
@@ -72,6 +85,7 @@ connection.onHover((params) => {
 });
 
 connection.onCompletion((params) => {
+  if (!isSourceFile(params.textDocument.uri)) return [];
   const doc = documents.get(params.textDocument.uri);
   const context = getProjectContext(params.textDocument.uri);
   const { locales } = loadLocalesForContext(context);
@@ -80,6 +94,7 @@ connection.onCompletion((params) => {
 });
 
 connection.languages.inlayHint.on((params) => {
+  if (!isSourceFile(params.textDocument.uri)) return [];
   const doc = documents.get(params.textDocument.uri);
   if (!doc) return [];
   const context = getProjectContext(params.textDocument.uri);
@@ -103,6 +118,91 @@ connection.onDefinition((params) => {
   return locations.length ? locations : null;
 });
 
+connection.onReferences((params) => {
+  const uri = params.textDocument.uri;
+  const context = getProjectContext(uri);
+  const key = resolveKeyAtPosition(uri, params.position, context);
+  if (!key) return null;
+
+  const locations = collectCodeReferences(context, key);
+  if (params.context?.includeDeclaration) {
+    const { locales, localeTexts } = loadLocalesForContext(context);
+    const keyTokenLength = key.split('.').at(-1).length + 2;
+    for (const { filePath, position } of collectLocaleKeyTargets(locales, key, localeTexts, context.config.defaultLocale)) {
+      locations.push({
+        uri: pathToFileURL(filePath).toString(),
+        range: { start: position, end: { line: position.line, character: position.character + keyTokenLength } },
+      });
+    }
+  }
+  return locations.length ? locations : null;
+});
+
+connection.onCodeAction((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  const diagnostics = params.context.diagnostics || [];
+  const actions = [];
+  if (doc) {
+    for (const action of getParamCodeActions(doc.getText(), diagnostics)) {
+      actions.push({
+        title: action.title,
+        kind: CodeActionKind.QuickFix,
+        diagnostics: [action.diagnostic],
+        edit: { changes: { [params.textDocument.uri]: [action.edit] } },
+      });
+    }
+  }
+  actions.push(...getCreateKeyActions(diagnostics, getProjectContext(params.textDocument.uri)));
+  return actions;
+});
+
+// Quick fix for a "missing i18n key" diagnostic: create the key (empty value) in
+// every locale file that lacks it, as a cross-file workspace edit. Only single
+// flat JSON locale files are supported; nested/TS locales are skipped.
+function getCreateKeyActions(diagnostics, context) {
+  const { locales, localeTexts } = loadLocalesForContext(context);
+  const actions = [];
+  for (const diagnostic of diagnostics) {
+    const key = diagnostic.data?.key;
+    const missingLocales = diagnostic.data?.missingLocales;
+    if (!key || !Array.isArray(missingLocales) || missingLocales.length === 0) continue;
+
+    const changes = {};
+    for (const name of missingLocales) {
+      const filePath = flatLocaleFile(locales[name]);
+      if (!filePath) continue;
+      const text = localeTexts[filePath] ?? readFileSafe(filePath);
+      if (text === undefined) continue;
+      const newText = insertNestedJsonKey(text, key, '');
+      if (newText === undefined) continue;
+      changes[pathToFileURL(filePath).toString()] = [fullDocumentEdit(text, newText)];
+    }
+
+    const fileCount = Object.keys(changes).length;
+    if (fileCount === 0) continue;
+    actions.push({
+      title: `Create i18n key "${key}" in ${fileCount} locale file(s)`,
+      kind: CodeActionKind.QuickFix,
+      diagnostics: [diagnostic],
+      edit: { changes },
+    });
+  }
+  return actions;
+}
+
+// A locale backed by a single flat .json file (not a nested directory locale).
+function flatLocaleFile(locale) {
+  if (!locale || !/\.json$/i.test(locale.path || '')) return undefined;
+  const files = locale.files?.length ? locale.files : [locale.path];
+  return files.length === 1 && files[0] === locale.path ? locale.path : undefined;
+}
+
+function fullDocumentEdit(oldText, newText) {
+  const lines = oldText.split('\n');
+  const endLine = lines.length - 1;
+  return { range: { start: { line: 0, character: 0 }, end: { line: endLine, character: lines[endLine].length } }, newText };
+}
+
 function getProjectContext(uri) {
   loadConfigIfChanged();
   const filePath = uri ? fileURLToPath(uri) : workspaceRoot;
@@ -178,27 +278,105 @@ function loadConfigIfChanged() {
 
 function loadConfig() {
   const configPath = resolveConfigPath(workspaceRoot);
+  const settingsConfig = zedSettingsConfig;
   configMtimeMs = fs.existsSync(configPath) ? fs.statSync(configPath).mtimeMs : 0;
   if (!configMtimeMs) {
-    config = normalizeI18nLensConfig();
+    config = normalizeI18nLensConfig(settingsConfig);
     return;
   }
   try {
-    config = normalizeI18nLensConfig(JSON.parse(fs.readFileSync(configPath, 'utf8')));
+    const fileConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    config = normalizeI18nLensConfig(mergeI18nLensConfig(settingsConfig, fileConfig));
   } catch (error) {
     connection.console.warn('Failed to load ' + CONFIG_RELATIVE_PATH + ': ' + error.message);
-    config = normalizeI18nLensConfig();
+    config = normalizeI18nLensConfig(settingsConfig);
   }
 }
 
+function normalizeIncomingSettings(value) {
+  if (!value || typeof value !== 'object') return {};
+  return value['i18n-lens'] && typeof value['i18n-lens'] === 'object' ? value['i18n-lens'] : value;
+}
+
 function validate(document) {
-  if (!isSourceFile(document.uri)) return;
   const context = getProjectContext(document.uri);
   const { locales } = loadLocalesForContext(context);
-  connection.sendDiagnostics({ uri: document.uri, diagnostics: getDiagnostics(document.getText(), locales) });
+  if (isSourceFile(document.uri)) {
+    connection.sendDiagnostics({ uri: document.uri, diagnostics: getDiagnostics(document.getText(), locales) });
+    return;
+  }
+  const locale = findLocaleForFile(locales, fileURLToPath(document.uri));
+  if (!locale) return;
+  connection.sendDiagnostics({ uri: document.uri, diagnostics: getLocaleParamDiagnostics(locale, fileURLToPath(document.uri), document.getText(), locales) });
 }
 function isSourceFile(uri) { return /\.(vue|tsx?|jsx?)$/i.test(uri); }
 
+const IGNORED_SCAN_DIRS = new Set(['node_modules', 'dist', 'build', 'out', 'coverage', 'vendor', '.output', '.next', '.nuxt', '.cache']);
+const MAX_SCAN_FILES = 5000;
+
+// Resolve the i18n key under `position`, whether the caret sits on a t()/keypath
+// usage in source code or on a key inside a locale JSON/TS file.
+function resolveKeyAtPosition(uri, position, context) {
+  const filePath = fileURLToPath(uri);
+  const text = documents.get(uri)?.getText() ?? readFileSafe(filePath);
+  if (!text) return undefined;
+  if (isSourceFile(uri)) return keyAtPosition(text, position)?.key;
+  const { locales } = loadLocalesForContext(context);
+  const locale = findLocaleForFile(locales, filePath);
+  return locale ? localeKeyAtPosition(locale, filePath, text, position) : undefined;
+}
+
+function findLocaleForFile(locales, filePath) {
+  const target = path.resolve(filePath);
+  for (const locale of Object.values(locales)) {
+    const files = locale.files?.length ? locale.files : (locale.path ? [locale.path] : []);
+    if (files.some((file) => path.resolve(file) === target)) return locale;
+  }
+  return undefined;
+}
+
+// Every source-code usage of `key` within the project/package root. Prefers the
+// in-memory text of open (possibly unsaved) documents over the on-disk copy.
+function collectCodeReferences(context, key) {
+  const openTextByPath = new Map();
+  for (const doc of documents.all()) {
+    try { openTextByPath.set(path.resolve(fileURLToPath(doc.uri)), doc.getText()); } catch { /* non-file uri */ }
+  }
+  const locations = [];
+  for (const filePath of collectSourceFiles(context.root)) {
+    const text = openTextByPath.get(path.resolve(filePath)) ?? readFileSafe(filePath);
+    if (!text) continue;
+    for (const range of findCodeKeyRanges(text, key)) {
+      locations.push({ uri: pathToFileURL(filePath).toString(), range });
+    }
+  }
+  return locations;
+}
+
+function collectSourceFiles(root) {
+  const files = [];
+  const stack = [root];
+  while (stack.length && files.length < MAX_SCAN_FILES) {
+    const dir = stack.pop();
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith('.') || IGNORED_SCAN_DIRS.has(entry.name)) continue;
+        stack.push(full);
+      } else if (isSourceFile(entry.name)) {
+        files.push(full);
+      }
+    }
+  }
+  return files;
+}
+
+function readFileSafe(filePath) {
+  try { return fs.readFileSync(filePath, 'utf8'); } catch { return undefined; }
+}
+
 function getAllConfiguredContexts() {
   loadConfigIfChanged();
   return [resolveProjectContext(workspaceRoot, workspaceRoot, config), ...config.packages.map((pkg) => ({