dsh-code-server-app 0.3.59 → 0.3.63

package/assets/extensions/dshcs-editor-bridge/extension.js

@@ -38,6 +38,17 @@ const {
   createClient,
 } = require('./lib/bridge-client.js');
 const { createProjector } = require('./lib/context-model.js');
+const {
+  FIM_DEBOUNCE_DEFAULT_MS,
+  shouldRequest,
+  buildPayload,
+  fingerprint,
+  createCompletionCache,
+  formatTokens,
+  describeFimUsage,
+  matchDisabledGlob,
+  toSingleLine,
+} = require('./lib/fim-completion.js');
 const { chooseOldSide, createDiffCache, describeChange } = require('./lib/diff-model.js');
 
 /** 状态栏项(仅在桥连通时显示)。 */
@@ -65,6 +76,119 @@ const diffTextStore = new Map();
 /** 同一个文件的 diff tab 不重复开。 */
 const openDiffTabs = new Map();
 
+// ---------------------------------------------------------------- FIM(幽灵)补全:实验性
+//
+// 这条能力**只在宿主说 enabled=true 时才注册 provider**(宿主的 /sync 每趟都带上来),
+// 所以"设置里没开"不会让编辑器每敲一个字就发一次注定被拒的请求。
+//
+// 三条与宿主一致的分工:
+//   - **该不该问**在这里判(纯逻辑 shouldRequest):不值得问的位置根本不发请求 ——
+//     实测模型在被问到"不该补的地方"时会硬凑(2/2),所以判据必须前置;
+//   - **问什么**在这里裁(窗口内的前后文),宿主侧再兜一层同样的上限;
+//   - **问过没有**用本地缓存答(相同前后文 + 语言)。
+/** 宿主报来的 FIM 状态与用量({enabled:false} 表示设置里没开)。 */
+let fimSnapshot = { enabled: false };
+/** 已注册的 provider disposer(null = 未注册)。 */
+let fimProvider = null;
+/** 扩展上下文(activate 里赋值):provider 需要在轮询里注册/注销,而轮询拿不到 context 参数。 */
+let extensionContext = null;
+/** 前后文 → 补全文本 的有界缓存。 */
+const fimCache = createCompletionCache();
+
+/** 取消感知的停顿:打字过程中的请求全丢掉(宿主侧也有速率闸,但那是最后一道)。
+ *  停顿毫秒数由设置在宿主侧提供(0.3.62),每趟 /sync 带上来;拿不到就用默认值。 */
+async function fimWait(token) {
+  const configured = Number.isFinite(fimSnapshot.debounceMs) ? fimSnapshot.debounceMs : FIM_DEBOUNCE_DEFAULT_MS;
+  const deadline = Date.now() + configured;
+  while (Date.now() < deadline) {
+    if (token.isCancellationRequested === true) return false;
+    // 40ms 一跳:足够细,且不会为一次补全拉起一串定时器。
+    await new Promise((resolve) => setTimeout(resolve, 40));
+  }
+  return token.isCancellationRequested !== true;
+}
+
+/** 取光标前后的窗口(只按行取,不把整份文档摸一遍 —— 大文件上每次击键都 getText() 是灾难)。 */
+function fimWindows(document, position) {
+  const startLine = Math.max(0, position.line - 120);
+  const endLine = Math.min(document.lineCount - 1, position.line + 40);
+  const prefixText = document.getText(new vscode.Range(new vscode.Position(startLine, 0), position));
+  const afterEnd = document.lineAt(endLine).range.end;
+  const suffixText = document.getText(new vscode.Range(position, afterEnd));
+  const lineTextBefore = document.lineAt(position.line).text.slice(0, position.character);
+  return { prefixText, suffixText, lineTextBefore };
+}
+
+/** 内联补全 provider。返回 null = 这次不补(与"补一个空串"是两回事)。 */
+function createFimProvider() {
+  return {
+    async provideInlineCompletionItems(document, position, _context, token) {
+      if (fimSnapshot.enabled !== true) return null;
+      const editor = vscode.window.activeTextEditor;
+      const windows = fimWindows(document, position);
+      const decision = shouldRequest({
+        selectionEmpty: editor === undefined || editor === null ? true : editor.selection.isEmpty,
+        scheme: document.uri.scheme,
+        lineCount: document.lineCount,
+        prefixText: windows.prefixText,
+        suffixText: windows.suffixText,
+        lineTextBefore: windows.lineTextBefore,
+      });
+      if (decision.ask !== true) return null;
+      const payload = buildPayload({
+        prefixText: windows.prefixText,
+        suffixText: windows.suffixText,
+        language: document.languageId,
+        path: document.uri.scheme === 'file' ? document.uri.fsPath : document.uri.toString(),
+      });
+      // 按 glob 禁用(0.3.62):**在发请求之前**判 —— 这是这一层存在的主要理由(不花冤枉钱)。
+      // 宿主侧还会再判一次(服务端那道),所以即使这里漏了也不会真的发出去。
+      const blocked = matchDisabledGlob(payload.path, fimSnapshot.disableGlobs);
+      if (blocked !== null) return null;
+      const key = fingerprint(payload.prompt, payload.suffix, payload.language);
+      const cached = fimCache.get(key);
+      if (cached !== null) {
+        return cached === '' ? null : [new vscode.InlineCompletionItem(cached, new vscode.Range(position, position))];
+      }
+      if ((await fimWait(token)) !== true) return null;
+      if (client === null || client.isDormant()) return null;
+      if (typeof client.complete !== 'function') return null;
+      const result = await client.complete(payload);
+      if (token.isCancellationRequested === true) return null;
+      if (result.ok !== true) {
+        if (result.status !== 409 && result.status !== 429) log(`补全失败:${result.error ?? '未知'}(status=${result.status ?? 0})`);
+        return null;
+      }
+      // 多行关掉时宿主已经裁过一道;这里再裁一次是防"宿主版本比扩展旧"(随包分发的静态文件可能不同步)。
+      const raw = typeof result.text === 'string' ? result.text : '';
+      const text = fimSnapshot.multiline === false ? toSingleLine(raw) : raw;
+      fimCache.set(key, text);
+      if (text.trim() === '') return null; // 模型说"这里不用补"是合法回答
+      log(`补全 ${text.length} 字符(${result.ms ?? '?'}ms,缓存${result.usage?.cacheReadTokens ?? 0} tok)`);
+      return [new vscode.InlineCompletionItem(text, new vscode.Range(position, position))];
+    },
+  };
+}
+
+/** 按宿主状态注册/注销 provider(状态翻转时才动)。 */
+function syncFimProvider() {
+  const want = fimSnapshot.enabled === true;
+  if (want && fimProvider === null) {
+    fimProvider = vscode.languages.registerInlineCompletionItemProvider({ pattern: '**' }, createFimProvider());
+    if (extensionContext !== null) extensionContext.subscriptions.push(fimProvider);
+    log('FIM 补全(实验性)已启用:开始提供内联补全');
+  } else if (!want && fimProvider !== null) {
+    try {
+      fimProvider.dispose();
+    } catch {
+      // 已被 VS Code 回收
+    }
+    fimProvider = null;
+    fimCache.clear();
+    log('FIM 补全已关闭:不再提供内联补全');
+  }
+}
+
 /** 把"改动前的文本"登记进 store,返回它的 docId。 */
 function registerDiffText(text) {
   const docId = crypto.createHash('sha256').update(text ?? '').digest('hex');
@@ -404,6 +528,13 @@ async function pollOnce() {
     await handleEvent(event);
   }
   if ((result.events ?? []).length > 0) client.persist();
+  // FIM(实验性):宿主每趟带状态与用量上来。只在**翻转**时注册/注销 provider,
+  // 但状态栏每趟都刷 —— 用户要看到的是"这轮补全花了多少 token",它一直在变。
+  const nextFim = result.fim !== null && typeof result.fim === 'object' ? result.fim : { enabled: false };
+  const wasEnabled = fimSnapshot.enabled === true;
+  fimSnapshot = nextFim;
+  if ((nextFim.enabled === true) !== wasEnabled) syncFimProvider();
+  updateStatusBar();
   // 能力探测(0.3.24):宿主证明"DSH 页面里的对话框活着"⇒ 右键提问走 ask-open 事件。
   // 0.3.59 起这是**唯一**的提问 UI(编辑器里的 webview 面板已退役):探测不到就只弹一条提示,
   // 绝不退回到一扇用户看不见的窗。
@@ -430,8 +561,23 @@ function startPolling(context) {
 function updateStatusBar() {
   if (statusBar === null) return;
   if (connected && client !== null && client.config !== null) {
-    statusBar.text = '$(plug) DSH';
-    statusBar.tooltip = `编辑器桥已连接:${client.config.pipe}\n上次轮询:${lastPollAt === 0 ? '—' : new Date(lastPollAt).toLocaleTimeString()}\n点击查看日志`;
+    // FIM(实验性)开着时,状态栏多一格 token 计数 —— 这条链路的调用**不进 DSH 的计量**
+    // (一次性调用不是 loop 请求,不进会话日志 ⇒ token-meter 看不到它),所以这里是用户唯一能看到
+    // "补全花了多少"的地方(设置卡里也有同样一份,见 README)。
+    const fimOn = fimSnapshot !== null && fimSnapshot.enabled === true;
+    const used = fimOn ? Number(fimSnapshot.totalTokens ?? 0) : 0;
+    statusBar.text = fimOn
+      ? (used > 0 ? `$(plug) DSH $(zap) ${formatTokens(used)}` : '$(plug) DSH $(zap)')
+      : '$(plug) DSH';
+    const lines = [
+      `编辑器桥已连接:${client.config.pipe}`,
+      `上次轮询:${lastPollAt === 0 ? '—' : new Date(lastPollAt).toLocaleTimeString()}`,
+      '',
+      ...describeFimUsage(fimSnapshot),
+      '',
+      '点击查看日志',
+    ];
+    statusBar.tooltip = lines.join('\n');
     statusBar.command = 'dsh-code-server.showBridgeLog';
     statusBar.show();
   } else {
@@ -523,6 +669,7 @@ function showBridgeLog() {
 // ---------------------------------------------------------------- 激活
 
 function activate(context) {
+  extensionContext = context;
   output = vscode.window.createOutputChannel('DSH Editor Bridge');
   context.subscriptions.push(output);
 

package/assets/extensions/dshcs-editor-bridge/lib/bridge-client.js

@@ -35,6 +35,9 @@ const STATE_FILENAME = 'extension-state.json';
 // 请求超时(0.2.8 起 8s):3s 在实测里太紧 —— 对话流快照一大,宿主序列化就要几秒,
 // 超时会让扩展**丢整份响应**(包括 approvals),表现就是"授权卡片一直不出现"。
 const REQUEST_TIMEOUT_MS = 8000;
+/** 补全请求的超时:**独立且更短**。宿主侧自己在 4s 放弃,这里给 6s 只是别先于宿主超时 ——
+ *  补全的价值在"比你打字快",8s 那个值对它毫无意义,而挂住的请求会挡住下一次补全。 */
+const COMPLETE_TIMEOUT_MS = 6000;
 /** 轮询间隔:host 侧事件只是"去看一眼这个文件"的提示,600ms 足够且几乎无开销。 */
 const POLL_INTERVAL_MS = 600;
 /** 宿主配置重读间隔(端点/令牌轮换后最多这么久恢复)。 */
@@ -292,6 +295,9 @@ function createClient(options) {
           ok: true,
           events,
           askDialog: body !== null && body.askDialog === true,
+          // FIM(实验性)状态与用量:宿主每趟都带上来,扩展据此决定"要不要注册补全 provider"
+          // 以及状态栏上那串数字怎么显示。没开时是 {enabled:false}(不是 null)。
+          fim: body !== null && typeof body.fim === 'object' && body.fim !== null ? body.fim : { enabled: false },
         };
       } catch (error) {
         return { ok: false, error: error.message, status: error.status, code: error.code };
@@ -328,11 +334,40 @@ function createClient(options) {
         return null;
       }
     },
+    /**
+     * 求一次 FIM(幽灵)补全(实验性)。
+     *
+     * **不抛**:补全失败是常态(没开、太快、模型抽风),抛异常会让 provider 每次都写错误日志。
+     * 返回值统一是 `{ok, text?, usage?, ms?, error?, status?}` —— 调用方只看 `ok`。
+     * 超时是独立的短超时(宿主侧 4s 就放弃了,这里给到 6s 只是别先于宿主超时)。
+     */
+    async complete(payload) {
+      try {
+        const body = await requestImpl({
+          socketPath: (refreshConfig(true) ?? {}).pipe,
+          path: `${BRIDGE_BASE}/complete`,
+          method: 'POST',
+          headers: { [TOKEN_HEADER]: config === null ? '' : config.token, 'content-type': 'application/json' },
+          body: JSON.stringify(payload),
+          timeoutMs: COMPLETE_TIMEOUT_MS,
+        });
+        if (body === null || typeof body !== 'object') return { ok: false, error: '空响应' };
+        const status = body.status === undefined ? 0 : body.status;
+        if (status < 200 || status >= 300) {
+          const reason = body.json !== null && typeof body.json.error === 'string' ? body.json.error : `HTTP ${status}`;
+          return { ok: false, error: reason, status };
+        }
+        const json = body.json === null || typeof body.json !== 'object' ? {} : body.json;
+        if (json.ok !== true) return { ok: false, error: typeof json.error === 'string' ? json.error : '宿主未返回补全', status };
+        return { ok: true, text: typeof json.text === 'string' ? json.text : '', usage: json.usage ?? null, ms: json.ms ?? null };
+      } catch (error) {
+        return { ok: false, error: error && error.message ? error.message : String(error), status: error && error.status };
+      }
+    },
     /** 把游标落盘(实例重启后不重复播报旧事件)。 */
     persist() {
       return writeState(extensionsDir, { since, pid: config === null ? null : config.pid });
-    },
-    /** 从磁盘恢复游标(实例没换才生效)。 */
+    },    /** 从磁盘恢复游标(实例没换才生效)。 */
     restore() {
       const saved = readState(extensionsDir);
       if (config !== null && saved.pid === config.pid) since = saved.since;
@@ -351,6 +386,7 @@ module.exports = {
   POLL_INTERVAL_MS,
   CONFIG_REREAD_MS,
   REQUEST_TIMEOUT_MS,
+  COMPLETE_TIMEOUT_MS,
   BridgeError,
   isBridgeEndpoint,
   defaultExtensionsDir,

package/assets/extensions/dshcs-editor-bridge/lib/fim-completion.js

@@ -0,0 +1,264 @@
+// dshcs-editor-bridge / lib/fim-completion.js —— 纯逻辑:FIM 补全的请求决策与载荷构造
+//
+// 来源与许可:本文件**为独立实现,不含 continuedev/continue 的源码**;其门控/窗口/缓存的设计与
+// 设置项划分**参考**了该项目(Apache License 2.0, Copyright 2023 Continue)。详见 `THIRD_PARTY_NOTICES.md`。
+//
+// **不 require('vscode')**:入参都是纯文本/数字,所以能在没有 VS Code 的环境里单测
+// (scripts/test-fim.mjs 就是这么用的)。与编辑器交互的部分在 extension.js(glue)里。
+//
+// 这个文件回答三个问题(顺序就是补全一次要过的三关):
+//   1. **该不该问**(`shouldRequest`)—— 模型在被问到"不该补的地方"时会硬凑(实测 2/2),
+//      所以"不值得问"必须在**发请求之前**判掉,而不是拿到回答再丢;
+//   2. **问什么**(`buildPayload`)—— 只送光标附近的窗口,不是整份文件;
+//   3. **问过没有**(`createCompletionCache`)—— 同样的前后文重复问是纯浪费(实测 temperature=0
+//      下两次回答逐字相同 ⇒ 缓存命中率会很高)。
+//
+// 窗口常量与宿主侧 `lib/fim-adapter.mjs` **同名同值**:扩展是随包分发的静态文件、不能 import
+// 宿主代码,所以一致性靠 scripts/test-fim.mjs 的断言钉住(与 bridge-client.js 的桥常量同一套做法)。
+
+'use strict';
+
+/** 与宿主 lib/fim-adapter.mjs 保持一致(改一边就要改另一边,测试会拦)。 */
+const FIM_MAX_PREFIX_CHARS = 6000;
+const FIM_MAX_SUFFIX_CHARS = 2000;
+const FIM_MAX_PREFIX_LINES = 120;
+const FIM_MAX_SUFFIX_LINES = 40;
+
+/** 停顿多久才真的发请求(毫秒)。打字过程中的请求全是浪费,而且会被宿主的速率闸挡掉。 */
+const FIM_DEBOUNCE_MS = 250;
+
+/** 超过这个行数的文档不参与补全(大文件里补全的收益低;用行数而不是字符数是为了避免
+ *  每次击键都 `document.getText()` 把整份文档摸一遍)。 */
+const FIM_MAX_DOCUMENT_LINES = 20000;
+
+/** 缓存条目上限与有效期(键 = 前后文指纹;命中直接给结果,不再问模型)。 */
+const FIM_CACHE_MAX = 24;
+const FIM_CACHE_TTL_MS = 120000;
+
+/** 把文本裁到窗口内(与宿主侧 `trimWindow` 同语义:字符与行数取先到者)。 */
+function trimWindow(text, maxChars, maxLines, fromEnd) {
+  if (typeof text !== 'string' || text === '') return '';
+  let out = text;
+  if (maxLines > 0) {
+    const split = out.split('\n');
+    if (split.length > maxLines) out = (fromEnd ? split.slice(split.length - maxLines) : split.slice(0, maxLines)).join('\n');
+  }
+  if (maxChars > 0 && out.length > maxChars) out = fromEnd ? out.slice(out.length - maxChars) : out.slice(0, maxChars);
+  return out;
+}
+
+/**
+ * 该不该为这次光标位置请求补全。
+ *
+ * 判据都是"**便宜且不会错判**"的那些 —— 宁可不补,也不要补错(补错一次,用户就关掉它)。
+ *
+ * @param {{selectionEmpty: boolean, scheme: string, lineCount: number,
+ *          prefixText: string, suffixText: string, lineTextBefore: string}} input
+ * @returns {{ask: boolean, reason: string}}
+ */
+function shouldRequest(input) {
+  const value = input === null || input === undefined ? {} : input;
+  if (value.selectionEmpty !== true) return { ask: false, reason: '有选区(用户在选中内容,不是在打字)' };
+  if (value.scheme !== 'file') return { ask: false, reason: `非文件文档(${value.scheme ?? '未知'})` };
+  if (!(Number.isFinite(value.lineCount) && value.lineCount > 0)) return { ask: false, reason: '空文档' };
+  if (value.lineCount > FIM_MAX_DOCUMENT_LINES) return { ask: false, reason: '文档过大' };
+  if (typeof value.prefixText !== 'string' || typeof value.suffixText !== 'string') return { ask: false, reason: '拿不到前后文' };
+  // 光标前整行都是空白、且前面也没有内容 ⇒ 没什么可续的(新建的空文件、文件开头按回车)。
+  if (typeof value.lineTextBefore === 'string' && value.lineTextBefore.trim() === '') {
+    if (value.prefixText.trim() === '' && value.suffixText.trim() === '') return { ask: false, reason: '空上下文' };
+  }
+  return { ask: true, reason: 'ok' };
+}
+
+/** 前后文的指纹(缓存键):只看窗口内的内容,与路径/语言一起构成键。 */
+function fingerprint(prefix, suffix, language) {
+  const text = `${language ?? ''}\u0000${prefix ?? ''}\u0000${suffix ?? ''}`;
+  let hash = 2166136261;
+  for (let i = 0; i < text.length; i += 1) {
+    hash ^= text.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return `${text.length}:${(hash >>> 0).toString(36)}`;
+}
+
+/**
+ * 构造发往宿主的载荷(只含窗口内的前后文)。
+ * @returns {{prompt: string, suffix: string, language: string, path: string}}
+ */
+function buildPayload({ prefixText, suffixText, language, path }) {
+  return {
+    prompt: trimWindow(prefixText ?? '', FIM_MAX_PREFIX_CHARS, FIM_MAX_PREFIX_LINES, true),
+    suffix: trimWindow(suffixText ?? '', FIM_MAX_SUFFIX_CHARS, FIM_MAX_SUFFIX_LINES, false),
+    language: typeof language === 'string' ? language : '',
+    path: typeof path === 'string' ? path : '',
+  };
+}
+
+/** 有界 + 带 TTL 的结果缓存。 */
+function createCompletionCache({ max = FIM_CACHE_MAX, ttlMs = FIM_CACHE_TTL_MS, now = () => Date.now() } = {}) {
+  const store = new Map();
+  return {
+    get(key) {
+      const hit = store.get(key);
+      if (hit === undefined) return null;
+      if (now() - hit.at > ttlMs) {
+        store.delete(key);
+        return null;
+      }
+      store.delete(key);
+      store.set(key, hit);
+      return hit.text;
+    },
+    set(key, text) {
+      if (typeof key !== 'string' || key === '' || typeof text !== 'string') return false;
+      store.delete(key);
+      store.set(key, { text, at: now() });
+      while (store.size > max) {
+        const oldest = store.keys().next();
+        if (oldest.done === true) break;
+        store.delete(oldest.value);
+      }
+      return true;
+    },
+    size() {
+      return store.size;
+    },
+    clear() {
+      store.clear();
+    },
+  };
+}
+
+/** 数字 → 状态栏用短串(1.2k / 12k / 1.2M)。 */
+function formatTokens(n) {
+  if (!Number.isFinite(n) || n <= 0) return '0';
+  if (n < 1000) return String(Math.round(n));
+  if (n < 10000) return `${(n / 1000).toFixed(1)}k`;
+  if (n < 1000000) return `${Math.round(n / 1000)}k`;
+  return `${(n / 1000000).toFixed(1)}M`;
+}
+
+/** 状态栏 tooltip 里那段 FIM 说明(纯字符串组装,便于单测)。 */
+function describeFimUsage(fim) {
+  if (fim === null || typeof fim !== 'object') return [];
+  if (fim.enabled !== true) return ['FIM 补全:已关闭(设置里可开,实验性)'];
+  const lines = [
+    `FIM 补全(实验性):已开启${fim.available === false ? ` —— 不可用:${fim.reason ?? '原因未知'}` : ''}`,
+    `调用 ${fim.calls ?? 0} 次(成功 ${fim.ok ?? 0}/失败 ${fim.failed ?? 0})`,
+    `输入 ${formatTokens(fim.inputTokens)} tok · 输出 ${formatTokens(fim.outputTokens)} tok · 缓存命中 ${formatTokens(fim.cacheReadTokens)} tok`,
+    `停顿 ${Number.isFinite(fim.debounceMs) ? Math.round(fim.debounceMs) : FIM_DEBOUNCE_DEFAULT_MS}ms · `
+      + `${fim.multiline === false ? '仅单行' : '允许多行'}`
+      + `${Array.isArray(fim.disableGlobs) && fim.disableGlobs.length > 0 ? ` · 禁用 ${fim.disableGlobs.length} 条 glob` : ''}`,
+  ];
+  if (Number.isFinite(fim.lastMs)) lines.push(`最近一次 ${Math.round(fim.lastMs)}ms`);
+  if (typeof fim.lastError === 'string' && fim.lastError !== '') lines.push(`最近错误:${fim.lastError}`);
+  return lines;
+}
+
+// ---------------------------------------------------------------- 与宿主同语义的两件小事
+//
+// 为什么在这里**再实现一遍**:扩展是随包分发的静态文件,不能 import 宿主代码(ESM/CJS + 树内外),
+// 而这两个判据必须在"发请求之前/收响应之后"本地生效 —— 一致性由 scripts/test-fim.mjs 用同一组
+// 语料对两边做等价断言(与桥常量、窗口常量同一套做法)。
+
+/** 与宿主 lib/fim-adapter.mjs 的 FIM_DEBOUNCE_DEFAULT_MS 同值(宿主会在 /sync 里给实际值)。 */
+const FIM_DEBOUNCE_DEFAULT_MS = 250;
+
+/** 解析 glob 清单(与宿主 compileGlobList 同语义)。 */
+function compileGlobList(text) {
+  if (typeof text !== 'string' || text.trim() === '') return [];
+  const seen = new Set();
+  const out = [];
+  for (const raw of text.split(/[;,\s]+/)) {
+    const item = raw.trim().replace(/\\/g, '/').replace(/^\.\//, '');
+    if (item === '' || seen.has(item)) continue;
+    seen.add(item);
+    out.push(item);
+  }
+  return out;
+}
+
+/** glob → 正则(与宿主 globToRegExp 同语义:`*` 不跨目录、`**` 跨目录、不含 `/` 只匹配文件名)。 */
+function globToRegExp(glob) {
+  let g = typeof glob === 'string' ? glob.trim().replace(/\\/g, '/').replace(/^\.\//, '') : '';
+  if (g === '') return null;
+  if (g.endsWith('/')) g += '**';
+  const anchored = g.includes('/');
+  let out = '';
+  for (let i = 0; i < g.length; i += 1) {
+    const ch = g[i];
+    if (ch === '*') {
+      if (g[i + 1] === '*') {
+        if (g[i + 2] === '/') {
+          out += '(?:.*/)?';
+          i += 2;
+        } else {
+          out += '.*';
+          i += 1;
+        }
+      } else {
+        out += '[^/]*';
+      }
+    } else if (ch === '?') {
+      out += '[^/]';
+    } else {
+      out += ch.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+  }
+  return { re: new RegExp(`^${out}$`), anchored };
+}
+
+/** 路径是否命中禁用清单(返回命中的模式或 null)。
+ *  含 `/` 的模式按**完整路径与各层尾段**各试一次(与宿主 lib/fim-adapter.mjs 同语义:
+ *  用户写 `vendor/**` 的直觉是"任何层级下的 vendor",而绝对路径永远以 `/` 或盘符开头)。 */
+function matchDisabledGlob(filePath, globs) {
+  if (typeof filePath !== 'string' || filePath === '') return null;
+  const list = Array.isArray(globs) ? globs : compileGlobList(globs);
+  if (list.length === 0) return null;
+  const full = filePath.replace(/\\/g, '/');
+  const slash = full.lastIndexOf('/');
+  const base = slash === -1 ? full : full.slice(slash + 1);
+  for (const glob of list) {
+    const parsed = globToRegExp(glob);
+    if (parsed === null) continue;
+    if (!parsed.anchored) {
+      if (parsed.re.test(base)) return glob;
+      continue;
+    }
+    if (parsed.re.test(full)) return glob;
+    for (let i = full.indexOf('/'); i !== -1; i = full.indexOf('/', i + 1)) {
+      if (parsed.re.test(full.slice(i + 1))) return glob;
+    }
+  }
+  return null;
+}
+
+/** 只保留第一行(宿主在关掉多行时也会做;这里是第二道)。 */
+function toSingleLine(text) {
+  if (typeof text !== 'string' || text === '') return '';
+  const first = text.split('\n')[0];
+  return first.trim() === '' ? '' : first;
+}
+
+module.exports = {
+  FIM_MAX_PREFIX_CHARS,
+  FIM_MAX_SUFFIX_CHARS,
+  FIM_MAX_PREFIX_LINES,
+  FIM_MAX_SUFFIX_LINES,
+  FIM_DEBOUNCE_MS,
+  FIM_DEBOUNCE_DEFAULT_MS,
+  FIM_MAX_DOCUMENT_LINES,
+  FIM_CACHE_MAX,
+  FIM_CACHE_TTL_MS,
+  trimWindow,
+  shouldRequest,
+  fingerprint,
+  buildPayload,
+  createCompletionCache,
+  formatTokens,
+  describeFimUsage,
+  compileGlobList,
+  globToRegExp,
+  matchDisabledGlob,
+  toSingleLine,
+};

package/assets/extensions/dshcs-editor-bridge/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dshcs-editor-bridge",
   "displayName": "DSH Editor Bridge",
-  "description": "只读地把编辑器状态(未保存缓冲区、诊断、活动选区)提供给 DSH;右键提问打开 DSH 页面里的悬浮对话对话框(0.3.59 起是唯一路径:面板在插件客户端半部,正文/思考/上下文都用页面模块表里的官方渲染器,并可就地回答授权请求;拿不到对话框心跳时只给一条提示)。由 dsh-code-server-app 插件安装,可禁用。",
-  "version": "0.2.18",
+  "description": "对工作区只读地把编辑器状态(未保存缓冲区、诊断、活动选区)提供给 DSH(不写文件、不执行命令);右键提问打开 DSH 页面里的悬浮对话对话框(0.3.59 起是唯一路径:面板在插件客户端半部,正文/思考/上下文都用页面模块表里的官方渲染器,并可就地回答授权请求;拿不到对话框心跳时只给一条提示)。由 dsh-code-server-app 插件安装,可禁用。另有**实验性**的 FIM 内联补全(灰字续写):默认关闭,在插件设置卡里开启;关闭时本扩展连 provider 都不注册,不会发出任何补全请求。",
+  "version": "0.2.20",
   "publisher": "dsh-code-server-app",
   "license": "MIT",
   "private": true,

package/lib/bridge.mjs

@@ -31,11 +31,14 @@
  *
  * ## 安全不变量(改这个文件之前先读这几条)
  *
- * 1. **`BRIDGE_BASE`(`/code-server-bridge`)命名空间**只有四条路由,而且**全部只读**:
+ * 1. **`BRIDGE_BASE`(`/code-server-bridge`)命名空间**是**四条只读路由 + 一条有界的模型调用**:
  *    `/health`(无鉴权探活)、`/sync`(上报编辑器状态 + 取事件)、`/old`(取写前原文快照)、
- *    `/event`(上报意图,如"请宿主打开对话框")。这里**不允许**出现写文件、改文档、执行命令、
+ *    `/event`(上报意图,如"请宿主打开对话框"),以及 **`/complete`**(0.3.61,**实验性 FIM 补全**):
+ *    它把光标前后的两段文本交给模型换回一段补全文本 —— **仍然不写文件、不执行命令**,
+ *    而且默认关(设置里开启前一律 403),有速率/并发/长度/超时上限(见 lib/index.js 的
+ *    handleBridgeComplete 与 lib/fim-adapter.mjs)。这里**不允许**出现写文件、改文档、执行命令、
  *    拉起进程的路由 —— `bridge.json` 里那个令牌对本机同用户进程可读,爆炸半径必须封在
- *    "泄露编辑器里的信息",绝不能变成任意文件写 / 任意命令执行。
+ *    "泄露编辑器里的信息 + 替用户花一点补全 token",绝不能变成任意文件写 / 任意命令执行。
  *    提问与授权答复不走这里:它们在 DSH 同源的 `/api/code-server/ask/*` 上,调用方是 DSH 页面里的
  *    插件客户端(吃 DSH 自己的 cookie/Origin 校验)。
  * 2. **授权答复的四条约束**(在 `/api/code-server/ask/approve` 上,缺一条就等于开了任意命令执行的后门,