@nudojs/lsp 0.3.0 → 0.4.0

package/src/server.ts

@@ -19,8 +19,12 @@ import { TextDocument } from "vscode-languageserver-textdocument";
 import { typeValueToString } from "@nudojs/core";
 import {
   getTypeAtPosition,
+  getHoverAtPosition,
   getCompletionsAtPosition,
   getCasesForFile,
+  buildSemanticTokens,
+  isNudoTargetPath,
+  collectAbsInlays,
 } from "@nudojs/service";
 import { parse } from "@nudojs/parser";
 import { buildSymbolTable, findDefinition, findReferences, findIdentifierAtPosition } from "./symbols.ts";
@@ -30,7 +34,9 @@ import {
   evictModuleGraphCacheEntries,
   forgetValidatedFile,
   getCachedOrAnalyze,
+  handleNudoDepFileChanged,
   hasNudoDirectives,
+  lspLoadModule,
   toLspDiagnostic,
   uriToFilePath,
   validateText,
@@ -41,6 +47,9 @@ import {
   suggestCase,
   trace,
   whatIf,
+  checkTool,
+  hoverTool,
+  inferTool,
   type AgentToolDeps,
   type AgentToolResult,
 } from "./agent-tools.ts";
@@ -49,6 +58,9 @@ const NUDO_COMMANDS = [
   "nudo.whatIf",
   "nudo.suggestCase",
   "nudo.trace",
+  "nudo.check",
+  "nudo.hover",
+  "nudo.infer",
   "nudo.selectCase",
   "nudo.getActiveCases",
 ] as const;
@@ -159,16 +171,29 @@ export function registerWatchedFilesListener(listener: (uris: string[]) => void)
  * 清空其已发布诊断，并把被清理的 uri 列表广播给监听器。
  * 打开中的文件跳过——其内容由编辑流负责，外部删除会被编辑器以 didOpen/didChange 覆盖。
  */
+function isNudoDepPath(filePath: string): boolean {
+  return /\.nudo\.(js|mjs|ts)$/.test(filePath);
+}
+
 function handleWatchedFilesChanges(changes: readonly FileEvent[], isOpen: (uri: string) => boolean): string[] {
   const gone: string[] = [];
+  const nudoTouched: string[] = [];
   for (const change of changes) {
-    if (change.type !== FileChangeType.Deleted) continue;
-    if (isOpen(change.uri)) continue;
-    gone.push(change.uri);
-    forgetValidatedFile(uriToFilePath(change.uri));
-    activeCases.delete(change.uri);
-    nudoFileCache.delete(change.uri);
-    connection.sendDiagnostics({ uri: change.uri, diagnostics: [] });
+    const filePath = uriToFilePath(change.uri);
+    if (change.type === FileChangeType.Deleted) {
+      if (isOpen(change.uri)) continue;
+      gone.push(change.uri);
+      forgetValidatedFile(filePath);
+      activeCases.delete(change.uri);
+      nudoFileCache.delete(change.uri);
+      connection.sendDiagnostics({ uri: change.uri, diagnostics: [] });
+      if (isNudoDepPath(filePath)) nudoTouched.push(filePath);
+      continue;
+    }
+    // Create/Change：契约模板变更 → 定向逐出 L0 + 重检打开中的父文件
+    if (isNudoDepPath(filePath)) {
+      nudoTouched.push(filePath);
+    }
   }
   if (gone.length > 0) {
     // 拷贝后再遍历：监听器内注销自身不应影响本轮广播
@@ -180,6 +205,12 @@ function handleWatchedFilesChanges(changes: readonly FileEvent[], isOpen: (uri:
       }
     }
   }
+  if (nudoTouched.length > 0) {
+    const deps = validationDeps();
+    for (const p of nudoTouched) {
+      void handleNudoDepFileChanged(p, deps).catch(() => {});
+    }
+  }
   return gone;
 }
 
@@ -224,13 +255,30 @@ connection.onHover((params) => {
   const cases = getActiveCasesForUri(params.textDocument.uri);
 
   try {
-    const tv = getTypeAtPosition(filePath, source, line, column, cases);
-    if (!tv) return null;
-
+    const hover = getHoverAtPosition(filePath, source, line, column, cases);
+    if (!hover) return null;
+
+    const lines: string[] = [];
+    // 无损 Abs 优先（类型即计算本体）
+    if (hover.absMultiline) {
+      lines.push("```nudo", hover.absMultiline, "```");
+    } else if (hover.abs) {
+      lines.push("```nudo", hover.abs, "```");
+    }
+    if (hover.intension && hover.intension !== hover.abs) {
+      lines.push("```nudo", hover.intension, "```");
+    }
+    // 外延 TypeValue 仅作对照，且与内涵不同时才显示
+    if (hover.typeText && hover.typeText !== hover.intension && hover.typeText !== hover.abs) {
+      lines.push("```nudo", `ext: ${hover.typeText}`, "```");
+    }
+    if (lines.length === 0) {
+      lines.push("```nudo", hover.typeText, "```");
+    }
     return {
       contents: {
         kind: MarkupKind.Markdown,
-        value: `\`\`\`nudo\n${typeValueToString(tv)}\n\`\`\``,
+        value: lines.join("\n"),
       },
     };
   } catch {
@@ -331,6 +379,28 @@ connection.languages.inlayHint.on((params) => {
       });
     }
 
+    // Abs inlay：参数约束 + 返回 term/pred（类型即计算，无损）
+    try {
+      for (const abs of collectAbsInlays(source, {
+        loadModule: lspLoadModule,
+        fromFile: filePath,
+      })) {
+        const lineIdx = abs.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length) continue;
+        hints.push({
+          position: { line: lineIdx, character: abs.character },
+          label: abs.label,
+          kind:
+            abs.kind === "parameter"
+              ? InlayHintKind.Parameter
+              : InlayHintKind.Type,
+          paddingLeft: true,
+        });
+      }
+    } catch {
+      // Abs inlay 失败不影响 caseHints
+    }
+
     return hints;
   } catch {
     return [];
@@ -456,15 +526,6 @@ connection.onCodeAction((params) => {
         },
       });
     }
-
-    if (diag.code === "nudo-assertion-failed") {
-      actions.push({
-        title: "Update @nudo:returns to match inferred type",
-        kind: "quickfix",
-        diagnostics: [diag],
-        isPreferred: false,
-      });
-    }
   }
 
   return actions;
@@ -557,8 +618,12 @@ connection.languages.semanticTokens.on((params) => {
   if (!document) return { data: [] };
   if (!isNudoFile(params.textDocument.uri)) return { data: [] };
 
-  // For now, return empty tokens - can be enhanced later
-  return { data: [] };
+  try {
+    const filePath = uriToFilePath(document.uri);
+    return { data: buildSemanticTokens(filePath, document.getText()) };
+  } catch {
+    return { data: [] };
+  }
 });
 
 /** Resolve a `uri`- or `file`-identified target to the uri key used by activeCases/documents. */
@@ -612,6 +677,12 @@ function dispatchNudoCommand(command: string, arg: Record<string, unknown>) {
       return suggestCase(arg as Parameters<typeof suggestCase>[0], agentToolDeps);
     case "nudo.trace":
       return trace(arg as Parameters<typeof trace>[0], agentToolDeps);
+    case "nudo.check":
+      return checkTool(arg as Parameters<typeof checkTool>[0], agentToolDeps);
+    case "nudo.hover":
+      return hoverTool(arg as Parameters<typeof hoverTool>[0], agentToolDeps);
+    case "nudo.infer":
+      return inferTool(arg as Parameters<typeof inferTool>[0], agentToolDeps);
     case "nudo.selectCase":
       return handleSelectCase(arg as Parameters<typeof handleSelectCase>[0]);
     case "nudo.getActiveCases":
@@ -637,6 +708,9 @@ function dispatchAgentRequest(command: string, params: Record<string, unknown>):
 connection.onRequest("nudo/whatIf", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.whatIf", params));
 connection.onRequest("nudo/suggestCase", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.suggestCase", params));
 connection.onRequest("nudo/trace", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.trace", params));
+connection.onRequest("nudo/check", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.check", params));
+connection.onRequest("nudo/hover", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.hover", params));
+connection.onRequest("nudo/infer", (params: Record<string, unknown>) => dispatchAgentRequest("nudo.infer", params));
 
 connection.languages.diagnostics.on((params) => {
   const document = documents.get(params.textDocument.uri);
@@ -658,7 +732,9 @@ connection.languages.diagnostics.on((params) => {
 const nudoFileCache = new Map<string, boolean>();
 
 function isNudoFile(uri: string): boolean {
-  if (!uri.endsWith(".js") && !uri.endsWith(".ts") && !uri.endsWith(".mjs")) return false;
+  // 推断目标判定收敛到 service 层（TaskA 提供）：.js/.mjs/.ts 为目标，
+  // .d.ts（类型声明，harvester 输入）与 .tsx/.jsx 等一律排除
+  if (!isNudoTargetPath(uriToFilePath(uri))) return false;
   const cached = nudoFileCache.get(uri);
   if (cached !== undefined) return cached;
   const doc = documents.get(uri);

package/src/validation.ts

@@ -4,16 +4,31 @@
  * connection. server.ts wires these functions to `connection` / `documents`;
  * tests wire them to fakes.
  */
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { dirname, resolve as resolvePath, join } from "node:path";
 import {
   analyzeFile,
   analyzeFileAsync,
   buildModuleGraph,
   computeDirtySet,
+  defaultLoadModule,
+  clearAnalysisSessionCaches,
+  evictAbsModuleCacheFiles,
+  evictBPathCacheForFiles,
+  evictAnalysisFileCacheForFiles,
+  evictFnAnalysisCacheForFiles,
   type AnalysisResult,
   type Diagnostic as JsDiagnostic,
   type DiagnosticSeverity as JsDiagSeverity,
   type ModuleGraphCache,
 } from "@nudojs/service";
+import {
+  checkSource,
+  pTrue,
+  evictGeneralizeMemoForPaths,
+  evictCheckSourceMemoForPaths,
+  extractNudoImports,
+} from "@nudojs/core";
 import {
   DiagnosticSeverity,
   DiagnosticTag,
@@ -35,11 +50,76 @@ export const knownFiles = new Set<string>();
  */
 export const moduleGraphCache: ModuleGraphCache = new Map();
 
+/**
+ * `*.nudo.js` → 父分析文件（含 `@nudo:import` 的 .js/.ts）。
+ * 供 watched-files 变更时定向重检打开中的父缓冲。
+ */
+export const nudoDepParents = new Map<string, Set<string>>();
+
+function normPath(p: string): string {
+  return p.replace(/\\/g, "/");
+}
+
+/** 每次 validate 后刷新：parent 的全部 @nudo:import 边 */
+export function registerNudoImportDeps(filePath: string, source: string): void {
+  const parent = normPath(resolvePath(filePath));
+  for (const set of nudoDepParents.values()) {
+    set.delete(parent);
+  }
+  const imports = extractNudoImports(source);
+  for (const imp of imports) {
+    if (!imp.spec.startsWith(".") && !imp.spec.startsWith("/")) continue;
+    const dep = normPath(resolvePath(dirname(filePath), imp.spec));
+    let set = nudoDepParents.get(dep);
+    if (!set) {
+      set = new Set();
+      nudoDepParents.set(dep, set);
+    }
+    set.add(parent);
+  }
+}
+
+/**
+ * `*.nudo.js` 创建/变更：定向逐出 L0 memo 中依赖该文件的条目，
+ * 并重检打开中的父文件（propagate=false，不级联）。
+ */
+export async function handleNudoDepFileChanged(
+  nudoPath: string,
+  deps: ValidateTextDeps,
+): Promise<void> {
+  const p = normPath(resolvePath(nudoPath));
+  evictGeneralizeMemoForPaths([p]);
+  evictCheckSourceMemoForPaths([p]);
+  const parents = nudoDepParents.get(p);
+  if (!parents || parents.size === 0) return;
+  const parentList = [...parents];
+  // 父文件源码未变但依赖内容变了：整文件 check / B-path / AnalysisResult / fn-cache 都可能陈旧
+  evictBPathCacheForFiles(parentList);
+  evictAnalysisFileCacheForFiles(parentList);
+  evictFnAnalysisCacheForFiles(parentList);
+  for (const parent of parentList) {
+    const doc = deps.getOpenDocumentByPath?.(parent);
+    if (!doc) continue;
+    await validateText(
+      parent,
+      doc.uri,
+      doc.getText(),
+      doc.version,
+      deps,
+      false,
+    );
+  }
+}
+
 /** Test hook — resets module-level session state. */
 export function clearValidationState(): void {
   analysisCache.clear();
   knownFiles.clear();
   moduleGraphCache.clear();
+  nudoDepParents.clear();
+  // service+core 会话 memo 全清（B-path / analysis-file / fn-analysis /
+  // abs-module / generalize L0 / check 整文件 / nudo-module exec）
+  clearAnalysisSessionCaches();
 }
 
 /**
@@ -48,8 +128,12 @@ export function clearValidationState(): void {
  * 仅关闭（文件仍在磁盘上）不走这里，关闭文件仍可作为依赖图节点参与脏传播。
  */
 export function forgetValidatedFile(filePath: string): void {
+  const parent = normPath(resolvePath(filePath));
   knownFiles.delete(filePath);
   analysisCache.delete(filePath);
+  for (const set of nudoDepParents.values()) {
+    set.delete(parent);
+  }
 }
 
 /**
@@ -57,13 +141,17 @@ export function forgetValidatedFile(filePath: string): void {
  * 把「被删除且不在打开集」的 uri 列表广播到这里（uri→filePath 复用 uriToFilePath）。
  * 已删除文件的条目只剩内存驻留价值——同名重建文件若 mtime/size 恰好撞上旧值，
  * 会复用陈旧边集得出错误 dirty 集，因此删除时立即逐出。
+ * Abs 依赖模块导出缓存（abs-modules-graph）同口径逐出：虽然 stat 失效自愈，
+ * 但删除文件的内存驻留条目应随会话清理释放。
  */
 export function evictModuleGraphCacheEntries(uris: string[]): void {
-  for (const uri of uris) moduleGraphCache.delete(uriToFilePath(uri));
+  const paths = uris.map(uriToFilePath);
+  for (const p of paths) moduleGraphCache.delete(p);
+  evictAbsModuleCacheFiles(paths);
 }
 
 export function hasNudoDirectives(source: string): boolean {
-  return /@nudo:(case|mock|pure|skip|sample|returns|env|mock-module|as|replace)\b/.test(source);
+  return /@nudo:(case|mock|pure|skip|sample|refine|import|env|mock-module|as|replace)\b/.test(source);
 }
 
 export function uriToFilePath(uri: string): string {
@@ -140,6 +228,60 @@ export function toLspDiagnostic(d: JsDiagnostic, uri: string): LspDiagnostic {
   return diag;
 }
 
+/** CLI 与 LSP 共用的相对 require 解析（service defaultLoadModule） */
+export function lspLoadModule(spec: string, fromFile: string): string | undefined {
+  return defaultLoadModule(spec, fromFile);
+}
+
+/**
+ * Abs check → LSP diagnostics（主通道：约束蕴含，非 TS assignability）。
+ */
+export function checkToLspDiagnostics(
+  filePath: string,
+  source: string,
+  loadModule?: (spec: string, fromFile: string) => string | undefined,
+): LspDiagnostic[] {
+  try {
+    const report = checkSource(filePath, source, pTrue, {
+      loadModule: loadModule ?? lspLoadModule,
+      fromFile: filePath,
+    });
+    return report.issues
+      .filter((i) => i.severity === "error" || i.severity === "warning")
+      .map((i) => {
+        const line = (i.line ?? 1) - 1;
+        const col = i.column ?? 0;
+        const parts = [i.message];
+        if (i.actual) parts.push(`actual: ${i.actual}`);
+        if (i.expected) parts.push(`expected: ${i.expected}`);
+        if (i.suggestion) parts.push(i.suggestion);
+        return {
+          severity:
+            i.severity === "error"
+              ? DiagnosticSeverity.Error
+              : i.severity === "warning"
+                ? DiagnosticSeverity.Warning
+                : DiagnosticSeverity.Information,
+          range: {
+            start: { line, character: col },
+            end: { line, character: col + 1 },
+          },
+          message: parts.join(" · "),
+          source: "nudo-check",
+          code: i.code,
+          data: {
+            actual: i.actual,
+            expected: i.expected,
+            fn: i.fn,
+            suggestions: i.suggestion ? [i.suggestion] : [],
+          },
+        } satisfies LspDiagnostic;
+      });
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Analyze one document (async so path-based `@nudo:env` files preload),
  * publish diagnostics, refresh the analysis cache, and — when `propagate` —
@@ -177,7 +319,12 @@ export async function validateText(
 
   analysisCache.set(filePath, { version, result });
   knownFiles.add(filePath);
-  deps.sendDiagnostics({ uri, diagnostics: result.diagnostics.map((d) => toLspDiagnostic(d, uri)) });
+  registerNudoImportDeps(filePath, text);
+
+  // Abs check 主通道 + evaluator 诊断
+  const checkDiags = checkToLspDiagnostics(filePath, text);
+  const evalDiags = result.diagnostics.map((d) => toLspDiagnostic(d, uri));
+  deps.sendDiagnostics({ uri, diagnostics: [...checkDiags, ...evalDiags] });
 
   if (!propagate || !deps.getOpenDocumentByPath) return;
 
@@ -192,6 +339,10 @@ export async function validateText(
     if (dirtyPath === filePath) continue;
     const doc = deps.getOpenDocumentByPath(dirtyPath);
     if (!doc) continue;
+    // 依赖内容变了但父文件源码未变：整文件 AnalysisResult / B-path / fn-cache 键不含 dep 指纹
+    evictBPathCacheForFiles([dirtyPath]);
+    evictAnalysisFileCacheForFiles([dirtyPath]);
+    evictFnAnalysisCacheForFiles([dirtyPath]);
     await validateText(dirtyPath, doc.uri, doc.getText(), doc.version, deps, false);
   }
 }