i18n-lens-language-server 0.8.1 → 0.9.0

package/README.md

@@ -7,12 +7,40 @@ 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 keys missing from every locale file as errors and keys missing from some locales as warnings
+- Diagnostics: report missing keys, missing locale entries, and mismatched interpolation params
+- Quick fixes: add missing interpolation params to supported i18n calls
 - 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
 
+## 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
 
+> **Important:** Inline translations are rendered through Zed's LSP inlay hints. In Zed settings, make sure **Inlay Hints** are enabled and **Inlay Hints: Show Other Hints** is turned on. If **Show Other Hints** is disabled, hover/completion/diagnostics can still work, but inline translation text will not be displayed.
+
 When inlay hints are enabled in Zed, code like this:
 
 ```ts
@@ -25,7 +53,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.
 
@@ -39,10 +67,13 @@ To open a specific language file, use Go to Definition (Ctrl/Cmd+click or F12) o
 
 Diagnostics refresh automatically when loaded locale files or locale directories change, so editing translation files should update warnings/errors without restarting the extension.
 
-Diagnostics distinguish between two missing-key cases:
+Diagnostics distinguish between these cases:
 
 - If a key is missing from every loaded locale, it is reported as an error.
 - 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:
 
@@ -52,25 +83,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"]
     }
   ]
@@ -88,31 +151,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.
@@ -123,7 +186,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",
@@ -180,8 +243,6 @@ On this Windows setup, if `cargo` is not visible inside Git Bash / WSL, use:
 4. Open a Vue/TS/JS project with locale JSON files.
 5. Test hover, completion, diagnostics, definition, and inlay hints.
 
-If inline translations do not appear, check whether inlay hints are enabled in Zed settings.
-
 ### Iterating on the language server
 
 The published npm version can lag behind your working tree. To test local `server/*.js` changes without publishing, pack the current tree and install it into the Zed work directory, then restart the server:
@@ -194,26 +255,4 @@ It runs `npm pack`, installs the tarball into `%LOCALAPPDATA%\Zed\extensions\wor
 
 > To exercise the real install path instead, delete `%LOCALAPPDATA%\Zed\extensions\work\i18n-lens\node_modules` and restart the server — Zed will reinstall the published npm package.
 
-## Releasing
-
-The version is single-sourced across `Cargo.toml`, `extension.toml`, and
-`package.json` (they must all match — the release workflow enforces this). To
-cut a release:
-
-1. Bump `version` in `Cargo.toml`, `extension.toml`, and `package.json`.
-2. Tag and push:
-
-   ```bash
-   git tag v<version>   # e.g. v0.7.0
-   git push origin v<version>
-   ```
-
-   The `.github/workflows/release.yml` workflow then verifies the versions
-   match, runs the tests, and publishes the language server to npm as
-   `i18n-lens-language-server`. This requires an `NPM_TOKEN` repository secret
-   with publish rights.
 
-   To publish manually instead: `npm publish --access public`.
-3. Submit/update the extension in `zed-industries/extensions` (bump the
-   `version` in its `extensions.toml` to match) so Zed picks up the new
-   extension version, which installs the new npm package.

package/package.json

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

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()
@@ -122,11 +134,9 @@ function makeRange(text, start, end) {
 
 export function extractI18nKeys(text) {
   const found = [];
+  collectFunctionCallKeys(text, found);
+  collectFormatMessageKeys(text, found);
   const patterns = [
-    // t/$t/tc/$tc/i18n.t/i18n.tc(...) — function calls, incl. Vue I18n plural tc
-    /(?:\x24tc?|\btc?|\bi18n\.tc?)\(\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
-    // react-intl: formatMessage({ id: "key" }) (id may not be the first prop)
-    /\bformatMessage\s*\(\s*\{[^}]*?\bid\s*:\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
     // <i18n-t keypath="key"> (Vue I18n) and <Trans i18nKey="key"> (react-i18next)
     /\b(?:keypath|i18nKey)\s*=\s*(['"])([A-Za-z0-9_.:-]+)\1/g,
     /\bv-t\s*=\s*"'([A-Za-z0-9_.:-]+)'"/g,
@@ -146,6 +156,143 @@ export function extractI18nKeys(text) {
   return found;
 }
 
+function collectFunctionCallKeys(text, found) {
+  // t/$t/tc/$tc/i18n.t/i18n.tc(...) — function calls, incl. Vue I18n plural tc
+  const re = /(?:\x24tc?|\btc?|\bi18n\.tc?)\s*\(/g;
+  let match;
+  while ((match = re.exec(text))) {
+    const parenOffset = re.lastIndex - 1;
+    const callText = readParens(text, parenOffset);
+    if (!callText) continue;
+    const keyMatch = callText.match(/^\(\s*(['"])([A-Za-z0-9_.:-]+)\1/);
+    if (!keyMatch) continue;
+    const key = keyMatch[2];
+    const start = parenOffset + keyMatch[0].indexOf(key);
+    const end = start + key.length;
+    const args = splitArgsWithOffsets(callText.slice(1, -1));
+    const paramsEdit = getParamsEdit(args.slice(1), parenOffset + 1, parenOffset + callText.length - 1);
+    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit });
+  }
+}
+
+function collectFormatMessageKeys(text, found) {
+  const re = /\bformatMessage\s*\(/g;
+  let match;
+  while ((match = re.exec(text))) {
+    const parenOffset = re.lastIndex - 1;
+    const callText = readParens(text, parenOffset);
+    if (!callText) continue;
+    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;
+    const paramsEdit = getParamsEdit(args.slice(1), parenOffset + 1, parenOffset + callText.length - 1);
+    found.push({ key, range: makeRange(text, start, end), startOffset: start, endOffset: end, providedParams: collectParamNames(args.slice(1)), paramsEdit });
+  }
+}
+
+// Read a balanced (...) starting at `start`.
+function readParens(text, start) {
+  if (text[start] !== '(') return undefined;
+  let depth = 0;
+  let quote = '';
+  let escaped = false;
+  for (let i = start; 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--;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return undefined;
+}
+
+function splitArgs(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(text.slice(start, i).trim()); start = i + 1; }
+  }
+  const last = text.slice(start).trim();
+  if (last) args.push(last);
+  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 = (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);
+    }
+  }
+  return [...params].sort();
+}
+
 export function keyAtPosition(text, position) {
   const offset = positionToOffset(text, position);
   return extractI18nKeys(text).find((item) => item.startOffset <= offset && offset <= item.endOffset);
@@ -221,16 +368,16 @@ export function getDiagnostics(text, locales) {
   const localeEntries = Object.entries(locales);
   if (localeEntries.length === 0) return [];
 
-  return extractI18nKeys(text)
-    .map((item) => {
-      const missingLocales = localeEntries
-        .filter(([, locale]) => !Object.prototype.hasOwnProperty.call(locale.flat, item.key))
-        .map(([name]) => name)
-        .sort();
+  return extractI18nKeys(text).flatMap((item) => {
+    const missingLocales = localeEntries
+      .filter(([, locale]) => !Object.prototype.hasOwnProperty.call(locale.flat, item.key))
+      .map(([name]) => name)
+      .sort();
 
-      if (missingLocales.length === 0) return undefined;
+    const diagnostics = [];
+    if (missingLocales.length > 0) {
       const missingInAllLocales = missingLocales.length === localeEntries.length;
-      return {
+      diagnostics.push({
         severity: missingInAllLocales ? 1 : 2,
         range: item.range,
         message: missingInAllLocales
@@ -238,9 +385,87 @@ export function getDiagnostics(text, locales) {
           : 'Missing i18n key "' + item.key + '" in locales: ' + missingLocales.join(', '),
         source: 'i18n-lens',
         data: { key: item.key, missingLocales, missingInAllLocales },
-      };
-    })
-    .filter(Boolean);
+      });
+    }
+    if (missingLocales.length !== localeEntries.length) diagnostics.push(...getParamDiagnostics(item, localeEntries));
+    return diagnostics;
+  });
+}
+
+function getParamDiagnostics(item, localeEntries) {
+  if (!Array.isArray(item.providedParams)) return [];
+  const required = collectRequiredParams(item.key, localeEntries);
+  const provided = new Set(item.providedParams);
+  const missing = required.filter((n) => !provided.has(n));
+  const unused = item.providedParams.filter((n) => !required.includes(n));
+  const diagnostics = [];
+  if (missing.length > 0)
+    diagnostics.push({ severity: 2, range: item.range, message: 'Missing i18n params for "' + item.key + '": ' + missing.join(', '), source: 'i18n-lens', data: { key: item.key, missingParams: missing } });
+  if (unused.length > 0)
+    diagnostics.push({ severity: 2, range: item.range, message: 'Unused i18n params for "' + item.key + '": ' + unused.join(', '), source: 'i18n-lens', data: { key: item.key, unusedParams: unused } });
+  return diagnostics;
+}
+
+function collectRequiredParams(key, localeEntries) {
+  const params = new Set();
+  for (const [, locale] of localeEntries) {
+    const value = locale.flat[key];
+    if (value === undefined) continue;
+    for (const name of extractPlaceholders(value)) params.add(name);
+  }
+  return [...params].sort();
+}
+
+export function getParamCodeActions(text, diagnostics = []) {
+  const items = extractI18nKeys(text);
+  return diagnostics.flatMap((diagnostic) => {
+    const missingParams = diagnostic.data?.missingParams;
+    if (!Array.isArray(missingParams) || missingParams.length === 0) return [];
+    const item = items.find((candidate) => candidate.key === diagnostic.data?.key && sameRange(candidate.range, diagnostic.range));
+    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 },
+    }];
+  });
+}
+
+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
+  let text = String(value);
+  let cursor = 0;
+  while (cursor < text.length) {
+    const open = text.indexOf('{', cursor);
+    if (open === -1) break;
+    const head = text.slice(open).match(/^\{\s*([A-Za-z_$][\w$]*)\s*,/);
+    if (head) {
+      params.add(head[1]);
+      let depth = 0, i = open;
+      while (i < text.length) {
+        if (text[i] === '{') depth++;
+        else if (text[i] === '}') { depth--; if (depth === 0) break; }
+        i++;
+      }
+      text = text.slice(0, open) + ' '.repeat(i - open + 1) + text.slice(i + 1);
+      cursor = open;
+      continue;
+    }
+    cursor = open + 1;
+  }
+  const re = /\{\s*([A-Za-z_$][\w$]*)\s*\}/g;
+  let m;
+  while ((m = re.exec(text))) params.add(m[1]);
+  return [...params].sort();
 }
 
 export function resolvePreferredLocale(locales, defaultLocale) {

package/server/index.js

@@ -2,12 +2,13 @@
 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,
+  getParamCodeActions,
   getCompletions,
   getCompletionPrefix,
   keyAtPosition,
@@ -15,6 +16,7 @@ import {
   collectLocaleKeyTargets,
   getInlayHints,
   normalizeI18nLensConfig,
+  mergeI18nLensConfig,
   resolveConfigPath,
   CONFIG_RELATIVE_PATH,
   didWatchedFileChange,
@@ -25,6 +27,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 +40,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, inlayHintProvider: true, codeActionProvider: true } };
 });
 
 connection.onInitialized(() => {
@@ -58,6 +62,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;
@@ -103,6 +112,18 @@ connection.onDefinition((params) => {
   return locations.length ? locations : null;
 });
 
+connection.onCodeAction((params) => {
+  const doc = documents.get(params.textDocument.uri);
+  if (!doc) return [];
+  return getParamCodeActions(doc.getText(), params.context.diagnostics)
+    .map((action) => ({
+      title: action.title,
+      kind: CodeActionKind.QuickFix,
+      diagnostics: [action.diagnostic],
+      edit: { changes: { [params.textDocument.uri]: [action.edit] } },
+    }));
+});
+
 function getProjectContext(uri) {
   loadConfigIfChanged();
   const filePath = uri ? fileURLToPath(uri) : workspaceRoot;
@@ -178,19 +199,26 @@ 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);