@nudojs/lsp 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @nudojs/lsp
 
+## 0.4.0
+
+### Minor Changes
+
+- 5786fa5: Promote the B-path (transpile + in-process Abs runtime) to the primary evaluation path for capable sources.
+
+  - Module graph now supports relative imports, bare-package harvest, default/namespace imports, re-exports, `export *`, require, cycle/depth/missing guards, and env modules (`path` / `node:path` etc.).
+  - Diagnostics, `@nudo:env` / mock injection, `call@` / `entry@` provenance, method-missing, unknown-recv, generators, classes, async/await, optional chaining, and destructuring run through B.
+  - When B hosts a file, `evaluateProgram` is skipped so TypeValue no longer double-reports.
+  - CLI `check` / `types` / `test` accept directories; check uses an Abs-only gate.
+  - LSP hover / `getTypeAtPosition` on capable files read the Abs node table; `*.nudo.js` edits evict L0 and recheck open parents.
+  - Public core surface now re-exports the algebra API (`Abs`, check, generalize, exec, bridge, `parseSource`, `stripTypes`).
+
+### Patch Changes
+
+- Updated dependencies [5786fa5]
+- Updated dependencies [5786fa5]
+- Updated dependencies [5786fa5]
+  - @nudojs/core@0.3.0
+  - @nudojs/service@0.3.0
+  - @nudojs/parser@0.3.0
+
 ## 0.3.0
 
 ### Minor Changes

package/agent-skill/SKILL.md

@@ -33,41 +33,40 @@ All commands are available as `workspace/executeCommand` (dot form) and as custo
 
 | Command (request alias) | Arguments (JSON) | Returns |
 |---|---|---|
-| `nudo.whatIf` (`nudo/whatIf`) | `{ "file": "src/app.js", "bindings": [{ "name": "x", "type": "string" }], "target": "y" }` | Text: the inferred type of `target` **under the assumed bindings** — e.g. `Type of "y": string \| number` |
+| `nudo.whatIf` (`nudo/whatIf`) | `{ "file": "src/config.js", "bindings": [{ "name": "raw", "type": "string" }], "target": "size" }` | Text: the inferred type of `target` **under the assumed bindings** — e.g. `Type of "size": number`; bindings match top-level declarations only |
 | `nudo.trace` (`nudo/trace`) | `{ "file": "src/app.js", "functionName": "parse" }` | Text: one line per case, e.g. `Input: (T.string) => Output: number` |
 | `nudo.suggestCase` (`nudo/suggestCase`) | `{ "file": "src/app.js", "functionName": "parse" }` | Text: paste-ready `@nudo:case` directives when every case is call-site synthesized, e.g. `Function "parse" has 2 synthesized case(s); suggested directives:`; otherwise the current case count, e.g. `Function "parse" already has 3 case(s)`, or a suggested `@nudo:case` directive |
 | `nudo.selectCase` (`nudo/selectCase`) | `{ "file": "src/app.js", "functionName": "parse", "caseIndex": 1 }` | `{ "success": true }` — switches the active case (affects hover/diagnostics until changed back) |
 | `nudo.getActiveCases` (`nudo/getActiveCases`) | `{ "file": "src/app.js" }` | `{ "parse": 1, "greet": 0 }` — active case index per function |
 
-Diagnostics (failed `@nudo:returns` assertions, unreachable code, …) are available as LSP diagnostics — push (`textDocument/publishDiagnostics`) and pull (`textDocument/diagnostic`).
+Diagnostics (failed `@nudo:refine` assertions, unreachable code, …) are available as LSP diagnostics — push (`textDocument/publishDiagnostics`) and pull (`textDocument/diagnostic`).
 
 ## What-if workflow
 
-The signature move: hypothesize a type for one binding, observe what another binding becomes — without editing any source.
+The signature move: hypothesize a type for a top-level binding, observe what another binding becomes — without editing any source.
 
 ```js
-// src/app.js
-function normalize(x) {
-  const trimmed = x.trim();
-  const y = Number(trimmed);
-  return y;
-}
+// src/config.js
+const raw = readInput();
+const size = raw.length;
 ```
 
-Assume `x` is a string, ask what `y` is:
+Assume `raw` is a string, ask what `size` is:
 
 ```json
 {
   "command": "nudo.whatIf",
   "arguments": [{
-    "file": "src/app.js",
-    "bindings": [{ "name": "x", "type": "string" }],
-    "target": "y"
+    "file": "src/config.js",
+    "bindings": [{ "name": "raw", "type": "string" }],
+    "target": "size"
   }]
 }
 ```
 
-→ `Type of "y": number`. Then flip the hypothesis (`"type": "string | null"`) and re-ask to see how the code's guard branches change the result. Use this to preview refactors, validate an API's return type before calling it, or check that a fix actually narrows a type.
+→ `Type of "size": number`. Then flip the hypothesis (`"type": "string | null"`) and re-ask: the same `size` now reports `unknown`, because the null arm can propagate through `.length`. Use this to preview refactors, validate an API's return type before calling it, or compare how alternative type assumptions ripple through downstream code.
+
+Bindings only match **top-level declarations** (`const`/`let`/`var`/`function`) in the file. A function parameter name does not resolve — you get `Type of "...": unknown` plus `Bindings not applied (no top-level declaration found): x` in the reply.
 
 ## Type expression syntax
 

package/dist/server.js

@@ -43396,11 +43396,14 @@ import {
   InlayHintKind
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { typeValueToString as typeValueToString2 } from "@nudojs/core";
 import {
   getTypeAtPosition,
+  getHoverAtPosition as getHoverAtPosition2,
   getCompletionsAtPosition,
-  getCasesForFile
+  getCasesForFile,
+  buildSemanticTokens,
+  isNudoTargetPath,
+  collectAbsInlays as collectAbsInlays2
 } from "@nudojs/service";
 import { parse as parse2 } from "@nudojs/parser";
 
@@ -43491,32 +43494,33 @@ function findIdentifierAtPosition(ast, line, column) {
 }
 
 // src/semantic-tokens.ts
-var TOKEN_TYPES = [
-  "function",
-  "variable",
-  "parameter",
-  "property",
-  "type",
-  "keyword",
-  "string",
-  "number",
-  "comment",
-  "decorator"
-];
-var TOKEN_MODIFIERS = [
-  "declaration",
-  "readonly",
-  "deprecated",
-  "unreachable"
-];
+import {
+  SEMANTIC_TOKEN_TYPES,
+  SEMANTIC_TOKEN_MODIFIERS,
+  encodeSemanticTokens
+} from "@nudojs/service";
 
 // src/validation.ts
+import { dirname, resolve as resolvePath } from "path";
 import {
   analyzeFile,
   analyzeFileAsync,
   buildModuleGraph,
-  computeDirtySet
+  computeDirtySet,
+  defaultLoadModule,
+  clearAnalysisSessionCaches,
+  evictAbsModuleCacheFiles,
+  evictBPathCacheForFiles,
+  evictAnalysisFileCacheForFiles,
+  evictFnAnalysisCacheForFiles
 } from "@nudojs/service";
+import {
+  checkSource,
+  pTrue,
+  evictGeneralizeMemoForPaths,
+  evictCheckSourceMemoForPaths,
+  extractNudoImports
+} from "@nudojs/core";
 import {
   DiagnosticSeverity,
   DiagnosticTag
@@ -43524,15 +43528,65 @@ import {
 var analysisCache = /* @__PURE__ */ new Map();
 var knownFiles = /* @__PURE__ */ new Set();
 var moduleGraphCache = /* @__PURE__ */ new Map();
+var nudoDepParents = /* @__PURE__ */ new Map();
+function normPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function registerNudoImportDeps(filePath, source) {
+  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 = /* @__PURE__ */ new Set();
+      nudoDepParents.set(dep, set);
+    }
+    set.add(parent);
+  }
+}
+async function handleNudoDepFileChanged(nudoPath, deps) {
+  const p = normPath(resolvePath(nudoPath));
+  evictGeneralizeMemoForPaths([p]);
+  evictCheckSourceMemoForPaths([p]);
+  const parents = nudoDepParents.get(p);
+  if (!parents || parents.size === 0) return;
+  const parentList = [...parents];
+  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
+    );
+  }
+}
 function forgetValidatedFile(filePath) {
+  const parent = normPath(resolvePath(filePath));
   knownFiles.delete(filePath);
   analysisCache.delete(filePath);
+  for (const set of nudoDepParents.values()) {
+    set.delete(parent);
+  }
 }
 function evictModuleGraphCacheEntries(uris) {
-  for (const uri of uris) moduleGraphCache.delete(uriToFilePath(uri));
+  const paths = uris.map(uriToFilePath);
+  for (const p of paths) moduleGraphCache.delete(p);
+  evictAbsModuleCacheFiles(paths);
 }
 function hasNudoDirectives(source) {
-  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);
 }
 function uriToFilePath(uri) {
   return uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
@@ -43578,6 +43632,43 @@ function toLspDiagnostic(d, uri) {
   }
   return diag;
 }
+function lspLoadModule(spec, fromFile) {
+  return defaultLoadModule(spec, fromFile);
+}
+function checkToLspDiagnostics(filePath, source, loadModule) {
+  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(" \xB7 "),
+        source: "nudo-check",
+        code: i.code,
+        data: {
+          actual: i.actual,
+          expected: i.expected,
+          fn: i.fn,
+          suggestions: i.suggestion ? [i.suggestion] : []
+        }
+      };
+    });
+  } catch {
+    return [];
+  }
+}
 async function validateText(filePath, uri, text, version, deps, propagate = false) {
   if (deps.isNudoUri && !deps.isNudoUri(uri)) {
     deps.sendDiagnostics({ uri, diagnostics: [] });
@@ -43600,7 +43691,10 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
   }
   analysisCache.set(filePath, { version, result });
   knownFiles.add(filePath);
-  deps.sendDiagnostics({ uri, diagnostics: result.diagnostics.map((d) => toLspDiagnostic(d, uri)) });
+  registerNudoImportDeps(filePath, text);
+  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;
   let dependents;
   try {
@@ -43612,6 +43706,9 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
     if (dirtyPath === filePath) continue;
     const doc = deps.getOpenDocumentByPath(dirtyPath);
     if (!doc) continue;
+    evictBPathCacheForFiles([dirtyPath]);
+    evictAnalysisFileCacheForFiles([dirtyPath]);
+    evictFnAnalysisCacheForFiles([dirtyPath]);
     await validateText(dirtyPath, doc.uri, doc.getText(), doc.version, deps, false);
   }
 }
@@ -43619,9 +43716,15 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
 // src/agent-tools.ts
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { analyzeFile as analyzeFile2, buildCaseDirective } from "@nudojs/service";
+import {
+  analyzeFile as analyzeFile2,
+  buildCaseDirective,
+  getHoverAtPosition,
+  collectAbsInlays,
+  serializeInferJson
+} from "@nudojs/service";
 import { parse } from "@nudojs/parser";
-import { T, typeValueToString } from "@nudojs/core";
+import { T, typeValueToString, checkSource as checkSource2, serializeCheckJson, pTrue as pTrue2 } from "@nudojs/core";
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
@@ -43736,6 +43839,106 @@ function readSource(filePath, deps = {}) {
 function analysisError(err) {
   return textResult(`Error: ${err.message}`);
 }
+function checkTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const report = checkSource2(filePath, source, pTrue2, {
+      loadModule: params.loadModule ?? lspLoadModule,
+      fromFile: filePath
+    });
+    const json = serializeCheckJson(report);
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines = [
+      json.ok ? "nudo check OK" : "nudo check FAILED",
+      `${json.summary.errors} error \xB7 ${json.summary.warnings} warning \xB7 ${json.summary.functions} fn`
+    ];
+    for (const i of json.issues) {
+      if (i.severity === "info") continue;
+      const loc = i.line != null ? ` L${i.line}` : "";
+      lines.push(`[${i.severity}]${loc} ${i.message}`);
+      if (i.actual) lines.push(`  actual:   ${i.actual}`);
+      if (i.expected) lines.push(`  expected: ${i.expected}`);
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+function hoverTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const hover = getHoverAtPosition(filePath, source, params.line, params.column);
+    const payload = {
+      file: filePath,
+      line: params.line,
+      column: params.column,
+      abs: hover?.abs ?? null,
+      absMultiline: hover?.absMultiline ?? null,
+      intension: hover?.intension ?? null,
+      /** 有损外延，仅对照 */
+      ext: hover?.typeText ?? null
+    };
+    if (params.includeInlays) {
+      payload.inlays = collectAbsInlays(source, {
+        loadModule: params.loadModule ?? lspLoadModule,
+        fromFile: filePath
+      });
+    }
+    return textResult(JSON.stringify(payload, null, 2));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+function inferTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const result = analyzeFile2(filePath, source);
+    let json = serializeInferJson(result, filePath);
+    if (params.functions && params.functions.length > 0) {
+      const keep = new Set(params.functions);
+      const filtered = json.functions.filter((f) => keep.has(f.name));
+      let cases = 0;
+      for (const f of filtered) {
+        cases += f.cases?.length ?? 0;
+      }
+      const summary = {
+        ...json.summary,
+        functions: filtered.length,
+        cases
+      };
+      json = { ...json, functions: filtered, summary };
+    }
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines = [
+      `nudo infer  ${json.file}`,
+      `${json.summary.functions} fn \xB7 ${json.summary.cases} case \xB7 ${json.summary.diagnostics} diag`
+    ];
+    for (const f of json.functions) {
+      lines.push("");
+      lines.push(`${f.name}${f.entryOnly ? "  [entry-only]" : ""}`);
+      for (const c of f.cases) {
+        const args = c.args.join(", ");
+        lines.push(`  ${c.name}: (${args}) => ${c.result}`);
+        if (c.intension?.abs) lines.push(`    abs: ${c.intension.abs}`);
+        else if (c.intension?.display) lines.push(`    intension: ${c.intension.display}`);
+      }
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
 function whatIf(params, deps = {}) {
   try {
     const filePath = normalizeFilePath(params.file);
@@ -43820,6 +44023,9 @@ var NUDO_COMMANDS = [
   "nudo.whatIf",
   "nudo.suggestCase",
   "nudo.trace",
+  "nudo.check",
+  "nudo.hover",
+  "nudo.infer",
   "nudo.selectCase",
   "nudo.getActiveCases"
 ];
@@ -43857,8 +44063,8 @@ connection.onInitialize((_params) => ({
     semanticTokensProvider: {
       full: true,
       legend: {
-        tokenTypes: [...TOKEN_TYPES],
-        tokenModifiers: [...TOKEN_MODIFIERS]
+        tokenTypes: [...SEMANTIC_TOKEN_TYPES],
+        tokenModifiers: [...SEMANTIC_TOKEN_MODIFIERS]
       }
     },
     executeCommandProvider: {
@@ -43906,16 +44112,27 @@ function registerWatchedFilesListener(listener) {
     if (idx >= 0) watchedFilesListeners.splice(idx, 1);
   };
 }
+function isNudoDepPath(filePath) {
+  return /\.nudo\.(js|mjs|ts)$/.test(filePath);
+}
 function handleWatchedFilesChanges(changes, isOpen) {
   const gone = [];
+  const nudoTouched = [];
   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;
+    }
+    if (isNudoDepPath(filePath)) {
+      nudoTouched.push(filePath);
+    }
   }
   if (gone.length > 0) {
     for (const listener of [...watchedFilesListeners]) {
@@ -43925,6 +44142,13 @@ function handleWatchedFilesChanges(changes, isOpen) {
       }
     }
   }
+  if (nudoTouched.length > 0) {
+    const deps = validationDeps();
+    for (const p of nudoTouched) {
+      void handleNudoDepFileChanged(p, deps).catch(() => {
+      });
+    }
+  }
   return gone;
 }
 connection.onDidChangeWatchedFiles(
@@ -43959,14 +44183,27 @@ connection.onHover((params) => {
   const column = params.position.character;
   const cases = getActiveCasesForUri(params.textDocument.uri);
   try {
-    const tv = getTypeAtPosition(filePath, source, line, column, cases);
-    if (!tv) return null;
+    const hover = getHoverAtPosition2(filePath, source, line, column, cases);
+    if (!hover) return null;
+    const lines = [];
+    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, "```");
+    }
+    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
-${typeValueToString2(tv)}
-\`\`\``
+        value: lines.join("\n")
       }
     };
   } catch {
@@ -44048,6 +44285,22 @@ connection.languages.inlayHint.on((params) => {
         paddingLeft: true
       });
     }
+    try {
+      for (const abs of collectAbsInlays2(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 {
+    }
     return hints;
   } catch {
     return [];
@@ -44153,14 +44406,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;
 });
@@ -44239,7 +44484,12 @@ connection.languages.semanticTokens.on((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return { data: [] };
   if (!isNudoFile(params.textDocument.uri)) return { data: [] };
-  return { data: [] };
+  try {
+    const filePath = uriToFilePath(document2.uri);
+    return { data: buildSemanticTokens(filePath, document2.getText()) };
+  } catch {
+    return { data: [] };
+  }
 });
 function uriForFileOrUri(params) {
   if (params.uri) return params.uri;
@@ -44281,6 +44531,12 @@ function dispatchNudoCommand(command, arg) {
       return suggestCase(arg, agentToolDeps);
     case "nudo.trace":
       return trace(arg, agentToolDeps);
+    case "nudo.check":
+      return checkTool(arg, agentToolDeps);
+    case "nudo.hover":
+      return hoverTool(arg, agentToolDeps);
+    case "nudo.infer":
+      return inferTool(arg, agentToolDeps);
     case "nudo.selectCase":
       return handleSelectCase(arg);
     case "nudo.getActiveCases":
@@ -44300,6 +44556,9 @@ function dispatchAgentRequest(command, params) {
 connection.onRequest("nudo/whatIf", (params) => dispatchAgentRequest("nudo.whatIf", params));
 connection.onRequest("nudo/suggestCase", (params) => dispatchAgentRequest("nudo.suggestCase", params));
 connection.onRequest("nudo/trace", (params) => dispatchAgentRequest("nudo.trace", params));
+connection.onRequest("nudo/check", (params) => dispatchAgentRequest("nudo.check", params));
+connection.onRequest("nudo/hover", (params) => dispatchAgentRequest("nudo.hover", params));
+connection.onRequest("nudo/infer", (params) => dispatchAgentRequest("nudo.infer", params));
 connection.languages.diagnostics.on((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return { kind: "full", items: [] };
@@ -44317,7 +44576,7 @@ connection.languages.diagnostics.on((params) => {
 });
 var nudoFileCache = /* @__PURE__ */ new Map();
 function isNudoFile(uri) {
-  if (!uri.endsWith(".js") && !uri.endsWith(".ts") && !uri.endsWith(".mjs")) return false;
+  if (!isNudoTargetPath(uriToFilePath(uri))) return false;
   const cached = nudoFileCache.get(uri);
   if (cached !== void 0) return cached;
   const doc = documents.get(uri);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/lsp",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Language Server Protocol implementation for the Nudo type inference engine",
   "type": "module",
   "license": "MIT",
@@ -27,9 +27,9 @@
   "dependencies": {
     "vscode-languageserver": "^9.0.0",
     "vscode-languageserver-textdocument": "^1.0.0",
-    "@nudojs/service": "0.2.1",
-    "@nudojs/core": "0.2.0",
-    "@nudojs/parser": "0.2.0"
+    "@nudojs/service": "0.3.0",
+    "@nudojs/core": "0.3.0",
+    "@nudojs/parser": "0.3.0"
   },
   "scripts": {
     "build": "tsup src/server.ts --format esm --dts"

package/src/__tests__/agent-check.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "vitest";
+import { checkTool } from "../agent-tools.ts";
+
+const STD = `
+export const positive = number().gt(0);
+export const delay = number().gt(0);
+`;
+
+const src = `
+/// @nudo:import { positive } from "./std.nudo.js"
+/**
+ * @nudo:refine x positive
+ */
+function needsPositive(x) {
+  if (x > 0) return x;
+  return 0;
+}
+needsPositive(-1);
+`;
+
+const loadModule = (spec: string) =>
+  spec.includes("std.nudo") ? STD : undefined;
+
+describe("nudo.check agent tool", () => {
+  it("returns CheckJson v1 in json format", () => {
+    const r = checkTool(
+      { file: "/t/a.js", source: src, format: "json", loadModule },
+      { readFile: () => src },
+    );
+    const parsed = JSON.parse(r.content[0].text);
+    expect(parsed.version).toBe(1);
+    expect(parsed.ok).toBe(false);
+    expect(parsed.issues.some((i: { code: string }) => i.code === "nudo:constraint-violated")).toBe(true);
+  });
+
+  it("text format includes actual/expected", () => {
+    const r = checkTool(
+      { file: "/t/a.js", source: src, loadModule },
+      { readFile: () => src },
+    );
+    const text = r.content[0].text;
+    expect(text).toContain("FAILED");
+    expect(text).toContain("actual");
+    expect(text).toContain("expected");
+    expect(text).toContain('"version": 1');
+  });
+});