@nudojs/lsp 0.1.0 → 0.3.0

package/src/server.ts

@@ -5,26 +5,53 @@ import {
   TextDocumentSyncKind,
   type InitializeParams,
   type InitializeResult,
-  type Diagnostic as LspDiagnostic,
-  DiagnosticSeverity,
-  DiagnosticTag,
   type CompletionItem as LspCompletionItem,
   CompletionItemKind,
   MarkupKind,
   type CodeLens,
   CodeLensRefreshRequest,
+  FileChangeType,
+  type FileEvent,
   type InlayHint,
   InlayHintKind,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { typeValueToString } from "@nudojs/core";
 import {
-  analyzeFile,
   getTypeAtPosition,
   getCompletionsAtPosition,
   getCasesForFile,
-  type DiagnosticSeverity as JsDiagSeverity,
 } from "@nudojs/service";
+import { parse } from "@nudojs/parser";
+import { buildSymbolTable, findDefinition, findReferences, findIdentifierAtPosition } from "./symbols.ts";
+import { TOKEN_TYPES, TOKEN_MODIFIERS } from "./semantic-tokens.ts";
+import {
+  analysisCache,
+  evictModuleGraphCacheEntries,
+  forgetValidatedFile,
+  getCachedOrAnalyze,
+  hasNudoDirectives,
+  toLspDiagnostic,
+  uriToFilePath,
+  validateText,
+  type ValidateTextDeps,
+} from "./validation.ts";
+import {
+  normalizeFilePath,
+  suggestCase,
+  trace,
+  whatIf,
+  type AgentToolDeps,
+  type AgentToolResult,
+} from "./agent-tools.ts";
+
+const NUDO_COMMANDS = [
+  "nudo.whatIf",
+  "nudo.suggestCase",
+  "nudo.trace",
+  "nudo.selectCase",
+  "nudo.getActiveCases",
+] as const;
 
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
@@ -39,12 +66,6 @@ function getActiveCasesForUri(uri: string): Map<string, number> {
   return map;
 }
 
-const severityMap: Record<JsDiagSeverity, DiagnosticSeverity> = {
-  error: DiagnosticSeverity.Error,
-  warning: DiagnosticSeverity.Warning,
-  info: DiagnosticSeverity.Information,
-};
-
 connection.onInitialize((_params: InitializeParams): InitializeResult => ({
   capabilities: {
     textDocumentSync: TextDocumentSyncKind.Full,
@@ -57,11 +78,42 @@ connection.onInitialize((_params: InitializeParams): InitializeResult => ({
       resolveProvider: false,
     },
     inlayHintProvider: true,
+    definitionProvider: true,
+    referencesProvider: true,
+    renameProvider: true,
+    codeActionProvider: {
+      codeActionKinds: ["quickfix"],
+    },
+    signatureHelpProvider: {
+      triggerCharacters: ["(", ","],
+    },
+    semanticTokensProvider: {
+      full: true,
+      legend: {
+        tokenTypes: [...TOKEN_TYPES],
+        tokenModifiers: [...TOKEN_MODIFIERS],
+      },
+    },
+    executeCommandProvider: {
+      commands: [...NUDO_COMMANDS],
+    },
+    diagnosticProvider: {
+      interFileDependencies: false,
+      workspaceDiagnostics: false,
+    },
   },
 }));
 
 let debounceTimers = new Map<string, ReturnType<typeof setTimeout>>();
 
+// 打开即验证：didOpen 不会触发 onDidChangeContent，若不在此主动验证，
+// 新打开的文件要等到首次编辑（300ms 防抖后）或客户端 pull 诊断才有结果。
+// propagate=true 与编辑防抖路径同语义（含对打开依赖项的一次脏传播）。
+documents.onDidOpen((event) => {
+  nudoFileCache.delete(event.document.uri);
+  validateDocument(event.document, true).catch(() => {});
+});
+
 documents.onDidChangeContent((change) => {
   const uri = change.document.uri;
   nudoFileCache.delete(uri);
@@ -72,7 +124,7 @@ documents.onDidChangeContent((change) => {
     uri,
     setTimeout(() => {
       debounceTimers.delete(uri);
-      validateDocument(change.document);
+      validateDocument(change.document, true).catch(() => {});
     }, 300),
   );
 });
@@ -82,51 +134,82 @@ documents.onDidClose((event) => {
   if (timer) clearTimeout(timer);
   debounceTimers.delete(event.document.uri);
   nudoFileCache.delete(event.document.uri);
+  analysisCache.delete(uriToFilePath(event.document.uri));
   connection.sendDiagnostics({ uri: event.document.uri, diagnostics: [] });
 });
 
-function validateDocument(document: TextDocument): void {
-  const uri = document.uri;
-  if (!isNudoFile(uri)) {
-    connection.sendDiagnostics({ uri, diagnostics: [] });
-    return;
-  }
-
-  const filePath = uriToFilePath(uri);
-  const source = document.getText();
-  const cases = getActiveCasesForUri(uri);
+/**
+ * watched-files 删除事件监听器：接收「被删除且不在打开集」的 uri 列表。
+ * 缓存逐出等后续逻辑通过 registerWatchedFilesListener 挂到这里。
+ */
+export const watchedFilesListeners: Array<(uris: string[]) => void> = [];
+
+/** 注册 watched-files 监听器，返回注销函数。 */
+export function registerWatchedFilesListener(listener: (uris: string[]) => void): () => void {
+  watchedFilesListeners.push(listener);
+  return () => {
+    const idx = watchedFilesListeners.indexOf(listener);
+    if (idx >= 0) watchedFilesListeners.splice(idx, 1);
+  };
+}
 
-  try {
-    const result = analyzeFile(filePath, source, cases);
-    const diagnostics: LspDiagnostic[] = result.diagnostics.map((d) => {
-      const diag: LspDiagnostic = {
-        severity: severityMap[d.severity],
-        range: {
-          start: { line: d.range.start.line - 1, character: d.range.start.column },
-          end: { line: d.range.end.line - 1, character: d.range.end.column },
-        },
-        message: d.message,
-        source: "nudo",
-      };
-      if (d.tags?.includes("unnecessary")) {
-        diag.tags = [DiagnosticTag.Unnecessary];
+/**
+ * watched-files 事件核心：对 Deleted 且不在打开集的文件清理会话登记项
+ * （knownFiles/analysisCache 走 forgetValidatedFile，activeCases/nudoFileCache 按 uri），
+ * 清空其已发布诊断，并把被清理的 uri 列表广播给监听器。
+ * 打开中的文件跳过——其内容由编辑流负责，外部删除会被编辑器以 didOpen/didChange 覆盖。
+ */
+function handleWatchedFilesChanges(changes: readonly FileEvent[], isOpen: (uri: string) => boolean): string[] {
+  const gone: 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: [] });
+  }
+  if (gone.length > 0) {
+    // 拷贝后再遍历：监听器内注销自身不应影响本轮广播
+    for (const listener of [...watchedFilesListeners]) {
+      try {
+        listener(gone);
+      } catch {
+        // 单个监听器异常不阻断其余监听器的缓存逐出
       }
-      return diag;
-    });
-    connection.sendDiagnostics({ uri, diagnostics });
-  } catch (err) {
-    connection.sendDiagnostics({
-      uri,
-      diagnostics: [
-        {
-          severity: DiagnosticSeverity.Error,
-          range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
-          message: `Analysis error: ${(err as Error).message}`,
-          source: "nudo",
-        },
-      ],
-    });
+    }
   }
+  return gone;
+}
+
+connection.onDidChangeWatchedFiles((event) =>
+  handleWatchedFilesChanges(event.changes, (uri) => documents.get(uri) !== undefined),
+);
+
+// 模块图边缓存逐出：收到被清理 uri 时逐出 moduleGraphCache 对应 filePath 的条目。
+// 会话级常驻注册，无需持有注销函数。
+registerWatchedFilesListener(evictModuleGraphCacheEntries);
+
+function validationDeps(): ValidateTextDeps {
+  return {
+    sendDiagnostics: (params) => connection.sendDiagnostics(params),
+    isNudoUri: (uri) => isNudoFile(uri),
+    getActiveCases: (uri) => getActiveCasesForUri(uri),
+    getOpenDocumentByPath: (filePath) =>
+      documents.all().find((doc) => uriToFilePath(doc.uri) === filePath),
+  };
+}
+
+function validateDocument(document: TextDocument, propagate = false): Promise<void> {
+  return validateText(
+    uriToFilePath(document.uri),
+    document.uri,
+    document.getText(),
+    document.version,
+    validationDeps(),
+    propagate,
+  );
 }
 
 connection.onHover((params) => {
@@ -232,7 +315,7 @@ connection.languages.inlayHint.on((params) => {
   const lines = source.split("\n");
 
   try {
-    const result = analyzeFile(filePath, source, cases);
+    const result = getCachedOrAnalyze(filePath, source, document.version, cases);
     const hints: InlayHint[] = [];
 
     for (const hint of result.caseHints) {
@@ -254,27 +337,322 @@ connection.languages.inlayHint.on((params) => {
   }
 });
 
-connection.onRequest("nudo/selectCase", (params: { uri: string; functionName: string; caseIndex: number }) => {
-  const cases = getActiveCasesForUri(params.uri);
+connection.onDefinition((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return null;
+  if (!isNudoFile(params.textDocument.uri)) return null;
+
+  const source = document.getText();
+  const ast = parse(source);
+  const table = buildSymbolTable(ast, params.textDocument.uri);
+
+  const line = params.position.line + 1;
+  const column = params.position.character;
+  const identAtPos = findIdentifierAtPosition(ast, line, column);
+  if (!identAtPos) return null;
+
+  const def = findDefinition(table, identAtPos);
+  if (!def) return null;
+
+  return {
+    uri: params.textDocument.uri,
+    range: {
+      start: { line: def.loc.start.line - 1, character: def.loc.start.column },
+      end: { line: def.loc.end.line - 1, character: def.loc.end.column },
+    },
+  };
+});
+
+connection.onReferences((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+  if (!isNudoFile(params.textDocument.uri)) return [];
+
+  const source = document.getText();
+  const ast = parse(source);
+  const table = buildSymbolTable(ast, params.textDocument.uri);
+
+  const line = params.position.line + 1;
+  const column = params.position.character;
+  const identAtPos = findIdentifierAtPosition(ast, line, column);
+  if (!identAtPos) return [];
+
+  const refs = findReferences(table, identAtPos);
+  return refs.map((ref) => ({
+    uri: params.textDocument.uri,
+    range: {
+      start: { line: ref.loc.start.line - 1, character: ref.loc.start.column },
+      end: { line: ref.loc.end.line - 1, character: ref.loc.end.column },
+    },
+  }));
+});
+
+connection.onRenameRequest((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return null;
+  if (!isNudoFile(params.textDocument.uri)) return null;
+
+  const source = document.getText();
+  const ast = parse(source);
+  const table = buildSymbolTable(ast, params.textDocument.uri);
+
+  const line = params.position.line + 1;
+  const column = params.position.character;
+  const identAtPos = findIdentifierAtPosition(ast, line, column);
+  if (!identAtPos) return null;
+
+  const def = findDefinition(table, identAtPos);
+  const refs = findReferences(table, identAtPos);
+
+  const edits = [];
+
+  if (def) {
+    edits.push({
+      range: {
+        start: { line: def.loc.start.line - 1, character: def.loc.start.column },
+        end: { line: def.loc.end.line - 1, character: def.loc.end.column },
+      },
+      newText: params.newName,
+    });
+  }
+
+  for (const ref of refs) {
+    edits.push({
+      range: {
+        start: { line: ref.loc.start.line - 1, character: ref.loc.start.column },
+        end: { line: ref.loc.end.line - 1, character: ref.loc.end.column },
+      },
+      newText: params.newName,
+    });
+  }
+
+  return {
+    changes: {
+      [params.textDocument.uri]: edits,
+    },
+  };
+});
+
+connection.onCodeAction((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+  if (!isNudoFile(params.textDocument.uri)) return [];
+
+  const actions = [];
+
+  for (const diag of params.context.diagnostics) {
+    if (diag.code === "nudo-unreachable") {
+      actions.push({
+        title: "Remove unreachable code",
+        kind: "quickfix",
+        diagnostics: [diag],
+        edit: {
+          changes: {
+            [params.textDocument.uri]: [{
+              range: diag.range,
+              newText: "",
+            }],
+          },
+        },
+      });
+    }
+
+    if (diag.code === "nudo-assertion-failed") {
+      actions.push({
+        title: "Update @nudo:returns to match inferred type",
+        kind: "quickfix",
+        diagnostics: [diag],
+        isPreferred: false,
+      });
+    }
+  }
+
+  return actions;
+});
+
+connection.onSignatureHelp((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return null;
+  if (!isNudoFile(params.textDocument.uri)) return null;
+
+  const filePath = uriToFilePath(params.textDocument.uri);
+  const source = document.getText();
+  const line = params.position.line + 1;
+  const column = params.position.character;
+  const cases = getActiveCasesForUri(params.textDocument.uri);
+
+  try {
+    const ast = parse(source);
+    const callInfo = findEnclosingCall(ast, line, column);
+    if (!callInfo) return null;
+
+    const fnType = getTypeAtPosition(filePath, source, callInfo.calleeLine, callInfo.calleeCol, cases);
+    if (!fnType || fnType.kind !== "function") return null;
+
+    const paramLabels = fnType.params.map((p) => `${p}: unknown`);
+    const activeParam = callInfo.currentParamIndex;
+
+    return {
+      signatures: [{
+        label: `(${paramLabels.join(", ")}) => unknown`,
+        parameters: paramLabels.map((label) => ({ label })),
+        activeParameter: activeParam,
+      }],
+      activeSignature: 0,
+      activeParameter: activeParam,
+    };
+  } catch {
+    return null;
+  }
+});
+
+function findEnclosingCall(ast: any, line: number, column: number): { calleeLine: number; calleeCol: number; currentParamIndex: number } | null {
+  let result: any = null;
+
+  function visit(node: any): void {
+    if (!node || result) return;
+
+    if (node.type === "CallExpression") {
+      const loc = node.loc;
+      if (loc && loc.start.line <= line && loc.end.line >= line) {
+        const calleeLoc = node.callee.loc;
+        if (calleeLoc) {
+          let paramIndex = 0;
+          for (let i = 0; i < node.arguments.length; i++) {
+            const argLoc = node.arguments[i].loc;
+            if (argLoc) {
+              if (argLoc.start.line < line || (argLoc.start.line === line && argLoc.start.column <= column)) {
+                paramIndex = i + 1;
+              }
+            }
+          }
+          result = {
+            calleeLine: calleeLoc.start.line,
+            calleeCol: calleeLoc.start.column,
+            currentParamIndex: Math.min(paramIndex, node.arguments.length),
+          };
+        }
+      }
+    }
+
+    for (const key of Object.keys(node)) {
+      if (key === "type" || key === "loc" || key === "start" || key === "end") continue;
+      const child = node[key];
+      if (Array.isArray(child)) {
+        for (const item of child) {
+          if (item && typeof item === "object" && item.type) visit(item);
+        }
+      } else if (child && typeof child === "object" && child.type) {
+        visit(child);
+      }
+    }
+  }
+
+  visit(ast);
+  return result;
+}
+
+connection.languages.semanticTokens.on((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return { data: [] };
+  if (!isNudoFile(params.textDocument.uri)) return { data: [] };
+
+  // For now, return empty tokens - can be enhanced later
+  return { data: [] };
+});
+
+/** Resolve a `uri`- or `file`-identified target to the uri key used by activeCases/documents. */
+function uriForFileOrUri(params: { uri?: string; file?: string }): string {
+  if (params.uri) return params.uri;
+  const filePath = normalizeFilePath(params.file ?? "");
+  const doc = documents.all().find((d) => uriToFilePath(d.uri) === filePath);
+  return doc ? doc.uri : `file://${filePath}`;
+}
+
+async function handleSelectCase(params: { uri?: string; file?: string; functionName: string; caseIndex: number }) {
+  const uri = uriForFileOrUri(params);
+  const cases = getActiveCasesForUri(uri);
   cases.set(params.functionName, params.caseIndex);
 
-  const document = documents.get(params.uri);
+  const document = documents.get(uri);
   if (document) {
-    validateDocument(document);
+    await validateDocument(document);
   }
 
   connection.sendRequest(CodeLensRefreshRequest.type).catch(() => {});
 
   return { success: true };
-});
+}
 
-connection.onRequest("nudo/getActiveCases", (params: { uri: string }) => {
-  const cases = getActiveCasesForUri(params.uri);
+function handleGetActiveCases(params: { uri?: string; file?: string }) {
+  const cases = getActiveCasesForUri(uriForFileOrUri(params));
   const result: Record<string, number> = {};
   for (const [fn, idx] of cases) {
     result[fn] = idx;
   }
   return result;
+}
+
+const agentToolDeps: AgentToolDeps = {
+  getOpenText: (filePath) => {
+    const doc = documents.all().find((d) => uriToFilePath(d.uri) === filePath);
+    return doc ? { text: doc.getText() } : undefined;
+  },
+};
+
+/**
+ * One dispatch table shared by the executeCommand commands (`nudo.*`) and the
+ * custom request aliases (`nudo/…`) — both channels run the same handlers.
+ */
+function dispatchNudoCommand(command: string, arg: Record<string, unknown>) {
+  switch (command) {
+    case "nudo.whatIf":
+      return whatIf(arg as Parameters<typeof whatIf>[0], agentToolDeps);
+    case "nudo.suggestCase":
+      return suggestCase(arg as Parameters<typeof suggestCase>[0], agentToolDeps);
+    case "nudo.trace":
+      return trace(arg as Parameters<typeof trace>[0], agentToolDeps);
+    case "nudo.selectCase":
+      return handleSelectCase(arg as Parameters<typeof handleSelectCase>[0]);
+    case "nudo.getActiveCases":
+      return handleGetActiveCases(arg as Parameters<typeof handleGetActiveCases>[0]);
+    default:
+      return null;
+  }
+}
+
+connection.onExecuteCommand((params) =>
+  dispatchNudoCommand(params.command, (params.arguments?.[0] as Record<string, unknown>) ?? {}),
+);
+
+connection.onRequest("nudo/selectCase", handleSelectCase);
+
+connection.onRequest("nudo/getActiveCases", handleGetActiveCases);
+
+/** Request aliases share the command handlers; the pinned return type keeps onRequest overload inference happy. */
+function dispatchAgentRequest(command: string, params: Record<string, unknown>): AgentToolResult {
+  return dispatchNudoCommand(command, params) as AgentToolResult;
+}
+
+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.languages.diagnostics.on((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return { kind: "full", items: [] };
+  if (!isNudoFile(params.textDocument.uri)) return { kind: "full", items: [] };
+
+  try {
+    const filePath = uriToFilePath(document.uri);
+    const result = getCachedOrAnalyze(filePath, document.getText(), document.version, getActiveCasesForUri(document.uri));
+    return {
+      kind: "full",
+      items: result.diagnostics.map((d) => toLspDiagnostic(d, document.uri)),
+    };
+  } catch {
+    return { kind: "full", items: [] };
+  }
 });
 
 const nudoFileCache = new Map<string, boolean>();
@@ -290,13 +668,5 @@ function isNudoFile(uri: string): boolean {
   return result;
 }
 
-function hasNudoDirectives(source: string): boolean {
-  return /@nudo:(case|mock|pure|skip|sample|returns)\b/.test(source);
-}
-
-function uriToFilePath(uri: string): string {
-  return uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
-}
-
 documents.listen(connection);
 connection.listen();

package/src/symbols.ts

@@ -0,0 +1,109 @@
+import type { Node } from "@babel/types";
+import traverse from "@babel/traverse";
+import type { SymbolInfo, ReferenceInfo, SymbolTable, SourceLocation } from "@nudojs/service";
+
+function locFromNode(node: Node): SourceLocation {
+  return {
+    start: { line: node.loc?.start.line ?? 1, column: node.loc?.start.column ?? 0 },
+    end: { line: node.loc?.end.line ?? 1, column: node.loc?.end.column ?? 0 },
+  };
+}
+
+export function buildSymbolTable(ast: Node, uri: string): SymbolTable {
+  const definitions = new Map<string, SymbolInfo>();
+  const references: ReferenceInfo[] = [];
+
+  const traverseFn = (typeof traverse === "function" ? traverse : (traverse as any).default) as typeof traverse;
+
+  try {
+    traverseFn(ast, {
+      // Collect definitions
+      FunctionDeclaration(path) {
+        if (path.node.id) {
+          definitions.set(path.node.id.name, {
+            name: path.node.id.name,
+            kind: "function",
+            loc: locFromNode(path.node.id),
+            uri,
+          });
+        }
+      },
+      VariableDeclarator(path) {
+        if (path.node.id.type === "Identifier") {
+          definitions.set(path.node.id.name, {
+            name: path.node.id.name,
+            kind: "variable",
+            loc: locFromNode(path.node.id),
+            uri,
+          });
+        }
+      },
+      ClassDeclaration(path) {
+        if (path.node.id) {
+          definitions.set(path.node.id.name, {
+            name: path.node.id.name,
+            kind: "class",
+            loc: locFromNode(path.node.id),
+            uri,
+          });
+        }
+      },
+      // Collect references
+      Identifier(path) {
+        // Skip definition sites
+        if (path.parentPath?.node.type === "FunctionDeclaration" && path.parentPath.node.id === path.node) return;
+        if (path.parentPath?.node.type === "VariableDeclarator" && path.parentPath.node.id === path.node) return;
+        if (path.parentPath?.node.type === "ClassDeclaration" && path.parentPath.node.id === path.node) return;
+
+        references.push({
+          name: path.node.name,
+          loc: locFromNode(path.node),
+          uri,
+        });
+      },
+    });
+  } catch {
+    // traverse may fail on partial ASTs
+  }
+
+  return { definitions, references };
+}
+
+export function findDefinition(
+  symbolTable: SymbolTable,
+  name: string,
+): SymbolInfo | null {
+  return symbolTable.definitions.get(name) ?? null;
+}
+
+export function findReferences(
+  symbolTable: SymbolTable,
+  name: string,
+): ReferenceInfo[] {
+  return symbolTable.references.filter((r) => r.name === name);
+}
+
+export function findIdentifierAtPosition(ast: Node, line: number, column: number): string | null {
+  let found: string | null = null;
+  const traverseFn = (typeof traverse === "function" ? traverse : (traverse as any).default) as typeof traverse;
+
+  try {
+    traverseFn(ast, {
+      Identifier(path) {
+        const loc = path.node.loc;
+        if (!loc) return;
+        if (
+          loc.start.line === line &&
+          loc.start.column <= column &&
+          loc.end.column >= column
+        ) {
+          found = path.node.name;
+          path.stop();
+        }
+      },
+    });
+  } catch {
+    // ignore
+  }
+  return found;
+}