@nudojs/service 0.2.1 → 0.3.0

package/src/index.ts

@@ -19,6 +19,8 @@ export {
   type CallRecord,
   getTypeAtPosition,
   getTypeAtPositionAsync,
+  getHoverAtPosition,
+  type HoverInfo,
   getCompletionsAtPosition,
   getCasesForFile,
   buildModuleGraph,
@@ -27,6 +29,105 @@ export {
   topoSortDirty,
 } from "./analyzer.ts";
 
+export { collectAbsInlays, type AbsInlay } from "@nudojs/core";
+
+export {
+  serializeInferJson,
+  type InferJson,
+  type InferJsonCase,
+  type InferJsonFunction,
+} from "./infer-json.ts";
+
+export { isNudoTargetPath } from "./target-path.ts";
+export { defaultLoadModule, type LoadModule } from "./load-module.ts";
+export {
+  collectStaticImports,
+  analyzeExportsFromSource,
+  collectDependencySpecs,
+  type ModuleExports,
+} from "./static-imports.ts";
+export {
+  harvestPackage,
+  collectDtsFromEntry,
+  formatHarvestSummary,
+  lookupHarvested,
+  resolvePackageRoot,
+  type PackageHarvest,
+} from "./harvest-package.ts";
+export {
+  barePackageName,
+  collectBarePackages,
+  autoHarvestModules,
+  harvestPackageCached,
+  clearHarvestCache,
+} from "./harvest-auto.ts";
+export {
+  evalAbsModuleGraph,
+  evalProgramAbsWithModules,
+  collectAbsBindingsFromGraph,
+  defaultAbsLoadModule,
+  clearAbsModuleCache,
+  evictAbsModuleCacheFiles,
+  type AbsModuleGraphResult,
+  type AbsGraphOptions,
+  type AbsModuleLoadIssue,
+  type AbsModuleCacheEntry,
+} from "./abs-modules-graph.ts";
+export {
+  harvestToAbsModules,
+  packageHarvestToAbsModules,
+  bareSpecToAbsModules,
+  harvestedValueToAbs,
+} from "./harvest-to-abs.ts";
+export {
+  isBPathCapable,
+  tryRunBPath,
+  tryBPathCall,
+  tryBPathCallFull,
+  clearBPathCache,
+  evictBPathCacheForFiles,
+  collectBPathReplacements,
+  collectEnvGlobals,
+  collectEnvModules,
+  type BPathRunResult,
+} from "./bpath-run.ts";
+export {
+  clearAnalysisFileCache,
+  getAnalysisFileCacheSize,
+  evictAnalysisFileCacheForFiles,
+} from "./analysis-file-cache.ts";
+export {
+  clearFnAnalysisCache,
+  evictFnAnalysisCacheForFiles,
+} from "./fn-analysis-cache.ts";
+export {
+  evictAnalysisCachesForFiles,
+  clearAnalysisSessionCaches,
+  resetAllAnalysisCaches,
+} from "./session-cache.ts";
+export { envValueToAbs } from "./env-to-abs.ts";
+export type { BMemberDiag } from "@nudojs/core";
+
+export {
+  collectBPathDiagnostics,
+  type BPathDiagnostics,
+  type BPathUnreachable,
+  type BPathBuiltinUnknown,
+} from "./bpath-diagnostics.ts";
+export {
+  harvestNodeTypes,
+  summarizeNodeEnv,
+  type NodeEnvResult,
+} from "./harvest-node.ts";
+
+export {
+  buildSemanticTokens,
+  encodeSemanticTokens,
+  SEMANTIC_TOKEN_TYPES,
+  SEMANTIC_TOKEN_MODIFIERS,
+  type SemanticToken,
+} from "./semantic-tokens.ts";
+
 export {
   typeValueToTSType,
   generateDts,
@@ -34,7 +135,7 @@ export {
 } from "./dts-generator.ts";
 
 export { typeValueToZodSchema } from "./schema-generator.ts";
-export { generateGuardFunction } from "./guard-generator.ts";
+export { generateGuardFunction, generateGuardFunctionFromAbs } from "./guard-generator.ts";
 
 export {
   serializeCaseArg,
@@ -45,3 +146,5 @@ export {
   type EmitSkipReason,
   type EmitResult,
 } from "./case-emitter.ts";
+
+export { mockDirectivesToAbsSeeds, type AbsMockSeeds } from "./mock-abs.ts";

package/src/infer-json.ts

@@ -0,0 +1,137 @@
+/**
+ * `nudo infer --json` 稳定契约 v1（CI / Agent）。
+ *
+ * 字段只增不改语义：
+ * - ext_*：TypeValue 投影字符串（有损，兼容）
+ * - intension.abs*：无损 Abs 展示（主线）
+ */
+
+import { typeValueToString, type TypeValue } from "@nudojs/core";
+import type { AnalysisResult, CaseResult, FunctionAnalysis, SourceLocation } from "./analyzer.ts";
+
+export type InferJsonCase = {
+  name: string;
+  /** TypeValue 投影（有损外延） */
+  args: string[];
+  result: string;
+  throws: string | null;
+  source: string | null;
+  aggregatedFrom?: number;
+  /** 无损内涵（Abs）；无则省略 */
+  intension?: {
+    display?: string;
+    abs?: string;
+    absMultiline?: string;
+    term?: string;
+    pred?: string;
+    conf?: string;
+  };
+};
+
+export type InferJsonFunction = {
+  name: string;
+  loc: SourceLocation;
+  entryOnly: boolean;
+  noDeclaration?: boolean;
+  cases: InferJsonCase[];
+  combined?: string;
+};
+
+export type InferJson = {
+  version: 1;
+  file: string;
+  summary: {
+    functions: number;
+    externalFunctions: number;
+    cases: number;
+    diagnostics: number;
+  };
+  functions: InferJsonFunction[];
+  externalFunctions?: Array<{
+    name: string;
+    fromModule?: string;
+    cases: InferJsonCase[];
+  }>;
+  diagnostics: Array<{
+    range: SourceLocation;
+    severity: string;
+    message: string;
+    code?: string;
+    suggestions?: string[];
+    tags?: string[];
+    origin?: { line: number; column: number };
+  }>;
+};
+
+function mapCase(c: CaseResult): InferJsonCase {
+  const out: InferJsonCase = {
+    name: c.name,
+    args: c.args.map((a: TypeValue) => typeValueToString(a)),
+    result: typeValueToString(c.result),
+    throws: c.throws.kind !== "never" ? typeValueToString(c.throws) : null,
+    source: c.source ?? null,
+  };
+  if (c.aggregatedFrom !== undefined) out.aggregatedFrom = c.aggregatedFrom;
+  if (c.intension) {
+    const i = c.intension;
+    out.intension = {
+      ...(i.display !== undefined ? { display: i.display } : {}),
+      ...(i.abs !== undefined ? { abs: i.abs } : {}),
+      ...(i.absMultiline !== undefined ? { absMultiline: i.absMultiline } : {}),
+      ...(i.term !== undefined ? { term: i.term } : {}),
+      ...(i.pred !== undefined ? { pred: i.pred } : {}),
+      ...(i.conf !== undefined ? { conf: i.conf } : {}),
+    };
+  }
+  return out;
+}
+
+function mapFunction(f: FunctionAnalysis): InferJsonFunction {
+  const out: InferJsonFunction = {
+    name: f.name,
+    loc: f.loc,
+    entryOnly: f.entryOnly ?? false,
+    cases: f.cases.map(mapCase),
+  };
+  if (f.noDeclaration) out.noDeclaration = true;
+  if (f.combined) out.combined = typeValueToString(f.combined);
+  return out;
+}
+
+export function serializeInferJson(
+  result: AnalysisResult,
+  file: string,
+): InferJson {
+  const functions = result.functions.map(mapFunction);
+  const external = result.externalFunctions?.map((f) => ({
+    name: f.name,
+    fromModule: f.fromModule,
+    cases: f.cases.map(mapCase),
+  }));
+  const caseCount =
+    functions.reduce((n, f) => n + f.cases.length, 0) +
+    (external ?? []).reduce((n, f) => n + f.cases.length, 0);
+
+  const json: InferJson = {
+    version: 1,
+    file,
+    summary: {
+      functions: functions.length,
+      externalFunctions: external?.length ?? 0,
+      cases: caseCount,
+      diagnostics: result.diagnostics.length,
+    },
+    functions,
+    diagnostics: result.diagnostics.map((d) => ({
+      range: d.range,
+      severity: d.severity,
+      message: d.message,
+      ...(d.code !== undefined ? { code: d.code } : {}),
+      ...(d.suggestions ? { suggestions: d.suggestions } : {}),
+      ...(d.tags ? { tags: d.tags } : {}),
+      ...(d.origin ? { origin: d.origin } : {}),
+    })),
+  };
+  if (external) json.externalFunctions = external;
+  return json;
+}

package/src/load-module.ts

@@ -0,0 +1,34 @@
+/**
+ * 相对/绝对 specifier → 模块源码。
+ * CLI / LSP / vite / check 共用同一扩展名表，避免门禁结果分叉。
+ */
+
+import { existsSync, statSync, readFileSync } from "node:fs";
+import { dirname, resolve, join } from "node:path";
+
+export type LoadModule = (spec: string, fromFile: string) => string | undefined;
+
+/** 默认 loadModule：支持 .js/.mjs/.ts 与 index 入口 */
+export function defaultLoadModule(spec: string, fromFile: string): string | undefined {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return undefined;
+  try {
+    const base = dirname(resolve(fromFile));
+    const p = resolve(base, spec);
+    for (const cand of [
+      p,
+      `${p}.js`,
+      `${p}.mjs`,
+      `${p}.ts`,
+      join(p, "index.js"),
+      join(p, "index.mjs"),
+      join(p, "index.ts"),
+    ]) {
+      if (existsSync(cand) && !statSync(cand).isDirectory()) {
+        return readFileSync(cand, "utf-8");
+      }
+    }
+    return undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/mock-abs.ts

@@ -0,0 +1,275 @@
+/**
+ * @nudo:mock / sinon 指令 → Abs seed（供 evalProgramAbs）。
+ * host 层：依赖 parser 指令形态；core 只吃 seedVars/seedFns。
+ */
+
+import type { Node } from "@babel/types";
+import type { FunctionWithDirectives } from "@nudojs/parser";
+import type { MockHelper, TypeValue } from "@nudojs/core";
+import {
+  type Abs,
+  absFunction,
+  emptyEnv,
+  typeValueToAbs,
+  abs as makeAbs,
+  confJoin,
+  unknown as absUnknown,
+  litValue,
+  formatAbs,
+  getFnImpl,
+  typeValueToString,
+} from "@nudojs/core";
+
+/**
+ * mock 依赖结果 conf 不得高于 mock。
+ * 必须保留同一对象身份：absFunction 的 impl 挂在 WeakMap 上，
+ * makeAbs 新建对象会丢掉 body/apply。
+ */
+function markMockConf(a: Abs): Abs {
+  a.conf = confJoin(a.conf, "mock");
+  return a;
+}
+
+/** Structural content key for mock body AST (callsFake etc.). */
+function astContentKey(n: unknown, depth = 0): string {
+  if (n == null || depth > 24) return "";
+  if (typeof n !== "object") return String(n);
+  if (Array.isArray(n)) return n.map((x) => astContentKey(x, depth + 1)).join(",");
+  const obj = n as Record<string, unknown>;
+  const type = typeof obj.type === "string" ? obj.type : "";
+  const parts: string[] = [type];
+  for (const key of ["name", "value", "raw", "operator", "computed"]) {
+    const v = obj[key];
+    if (v !== undefined && (typeof v !== "object" || v === null)) parts.push(`${key}=${String(v)}`);
+  }
+  for (const key of Object.keys(obj)) {
+    if (
+      key === "loc" ||
+      key === "start" ||
+      key === "end" ||
+      key === "leadingComments" ||
+      key === "trailingComments" ||
+      key === "innerComments" ||
+      key === "type" ||
+      key === "name" ||
+      key === "value" ||
+      key === "raw" ||
+      key === "operator" ||
+      key === "computed"
+    ) {
+      continue;
+    }
+    const v = obj[key];
+    if (v && typeof v === "object") parts.push(`${key}:{${astContentKey(v, depth + 1)}}`);
+  }
+  return parts.join("|");
+}
+
+function stampFingerprint(a: Abs, fp: string): Abs {
+  const impl = getFnImpl(a);
+  if (impl) impl.fingerprint = fp;
+  return a;
+}
+
+/** 用常量 Abs 造 mock 函数：调用即返回该值（结果 conf 标 mock） */
+function constantMockFn(result: Abs): Abs {
+  const marked = markMockConf(result);
+  const mockEnv = emptyEnv();
+  const retName = "__nudo_mock_ret";
+  mockEnv.vars.set(retName, marked);
+  const body = {
+    type: "BlockStatement",
+    body: [
+      {
+        type: "ReturnStatement",
+        argument: { type: "Identifier", name: retName },
+      },
+    ],
+  } as unknown as Node;
+  let retKey: string;
+  try {
+    retKey = formatAbs(marked);
+  } catch {
+    retKey = "?";
+  }
+  return stampFingerprint(
+    markMockConf(absFunction(["...args"], { body, env: mockEnv })),
+    `ret=${retKey}`,
+  );
+}
+
+/**
+ * withArgs 实参匹配（与 mock-helpers.mockArgMatches 同语义）：
+ * - 字面量声明要求实参同值字面量
+ * - primitive 声明接受同源字面量
+ */
+function absArgMatches(declared: TypeValue, actual: Abs | undefined): boolean {
+  if (!actual) return false;
+  const declaredAbs = typeValueToAbs(declared);
+  // 同 shape + 同字面量
+  const av = litValue(actual);
+  const dv = litValue(declaredAbs);
+  if (dv !== undefined) {
+    return av !== undefined && Object.is(av, dv);
+  }
+  // declared 是 primitive（如 T.number）：接受同源字面量或同 prim
+  if (declared.kind === "primitive") {
+    if (actual.shape.k === "prim") return actual.shape.type === declared.type;
+    if (av !== undefined) {
+      const t = typeof av;
+      return (
+        (declared.type === "number" && t === "number") ||
+        (declared.type === "string" && t === "string") ||
+        (declared.type === "boolean" && t === "boolean") ||
+        (declared.type === "bigint" && t === "bigint")
+      );
+    }
+  }
+  // unknown 声明不视为可证明匹配
+  return false;
+}
+
+function dispatchMockFn(defaultReturn: Abs, cases?: { args: TypeValue[]; returnValue: TypeValue }[]): Abs {
+  if (!cases?.length) return constantMockFn(defaultReturn);
+  const caseAbs = cases.map((c) => ({
+    declared: c.args,
+    result: markMockConf(typeValueToAbs(c.returnValue)),
+  }));
+  const dummyBody = {
+    type: "BlockStatement",
+    body: [{ type: "ReturnStatement", argument: null }],
+  } as unknown as Node;
+  const markedDefault = markMockConf(defaultReturn);
+  let defaultKey: string;
+  try {
+    defaultKey = formatAbs(markedDefault);
+  } catch {
+    defaultKey = "?";
+  }
+  const caseKey = cases
+    .map(
+      (c) =>
+        `${c.args.map((a) => typeValueToString(a)).join(",")}->${typeValueToString(c.returnValue)}`,
+    )
+    .join("|");
+  return stampFingerprint(
+    markMockConf(
+      absFunction(["...args"], {
+        body: dummyBody,
+        env: emptyEnv(),
+        apply: (args: Abs[]): Abs => {
+          for (const c of caseAbs) {
+            if (c.declared.every((d, i) => absArgMatches(d, args[i]))) {
+              return c.result;
+            }
+          }
+          return markedDefault;
+        },
+      }),
+    ),
+    `dispatch=default=${defaultKey};cases=${caseKey}`,
+  );
+}
+
+function absFromMockHelper(h: MockHelper): Abs {
+  if (h.callsFakeImpl && h.callsFakeImpl.kind === "function") {
+    const fn = h.callsFakeImpl;
+    const body = fn.body as Node;
+    return stampFingerprint(
+      absFunction(fn.params, { body, async: false }),
+      `fake=${fn.params.join(",")}:${astContentKey(body)}`,
+    );
+  }
+
+  let defaultReturn: Abs;
+  if (h.resolvedValue) {
+    defaultReturn = makeAbs(
+      { k: "eff", eff: "promise", inner: typeValueToAbs(h.resolvedValue) },
+      undefined,
+      undefined,
+      "path",
+    );
+  } else if (h.rejectedValue) {
+    defaultReturn = makeAbs({ k: "never" }, undefined, undefined, "exact");
+  } else if (h.returnValue) {
+    defaultReturn = typeValueToAbs(h.returnValue);
+  } else if (h.onFirstCallValue) {
+    // 与 TypeValue 路径一致：无 returnValue 时 onFirstCall 作默认返回
+    defaultReturn = typeValueToAbs(h.onFirstCallValue);
+  } else {
+    defaultReturn = absUnknown;
+  }
+
+  return dispatchMockFn(defaultReturn, h.withArgsCases);
+}
+
+function absFromSinon(sinonExpr: {
+  type: string;
+  returnValue?: TypeValue;
+  resolvedValue?: TypeValue;
+  rejectedValue?: TypeValue;
+}): Abs {
+  if (sinonExpr.resolvedValue) {
+    return constantMockFn(
+      makeAbs(
+        { k: "eff", eff: "promise", inner: typeValueToAbs(sinonExpr.resolvedValue) },
+        undefined,
+        undefined,
+        "path",
+      ),
+    );
+  }
+  if (sinonExpr.rejectedValue) {
+    return constantMockFn(makeAbs({ k: "never" }, undefined, undefined, "exact"));
+  }
+  if (sinonExpr.returnValue) {
+    return constantMockFn(typeValueToAbs(sinonExpr.returnValue));
+  }
+  return constantMockFn(absUnknown);
+}
+
+export type AbsMockSeeds = {
+  seedVars: Record<string, Abs>;
+  seedFns: Record<string, { params: string[]; body: Node; async?: boolean; fingerprint?: string }>;
+};
+
+/**
+ * B 路径注入用：seedVars + seedFns 统一为 Abs 函数绑定。
+ * arrowFn mock 落在 seedFns（AST body，供 ast-eval），B 路径的
+ * envGlobals 注入只吃 Abs——不合并会把 mock 丢掉，函数体内的调用
+ * 会落到真实原生函数（如 fetch 拿 Abs 当 URL，直接崩）。
+ */
+export function mockSeedsToAbsMocks(seeds: AbsMockSeeds): Record<string, Abs> {
+  const out: Record<string, Abs> = { ...seeds.seedVars };
+  for (const [name, fn] of Object.entries(seeds.seedFns)) {
+    out[name] = absFunction(fn.params, { body: fn.body, async: fn.async ?? false });
+  }
+  return out;
+}
+
+/** 从函数上的 @nudo:mock 指令收集 Abs seed */
+export function mockDirectivesToAbsSeeds(
+  functions: Array<{ directives: FunctionWithDirectives["directives"] }>,
+): AbsMockSeeds {
+  const seedVars: Record<string, Abs> = {};
+  const seedFns: AbsMockSeeds["seedFns"] = {};
+  for (const fn of functions) {
+    for (const d of fn.directives) {
+      if (d.kind !== "mock") continue;
+      if (d.arrowFn) {
+        const body = d.arrowFn.body as Node;
+        seedFns[d.name] = {
+          params: d.arrowFn.params,
+          body,
+          async: false,
+          fingerprint: `fake=${d.arrowFn.params.join(",")}:${astContentKey(body)}`,
+        };
+      } else if (d.nudoMock) {
+        seedVars[d.name] = markMockConf(absFromMockHelper(d.nudoMock));
+      } else if (d.sinonExpr) {
+        seedVars[d.name] = markMockConf(absFromSinon(d.sinonExpr));
+      }
+    }
+  }
+  return { seedVars, seedFns };
+}