@nudojs/service 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# @nudojs/service
+
+## 0.1.0
+
+### Minor Changes
+
+- Conceptual design and basic implementation.
+
+### Patch Changes
+
+- Updated dependencies
+  - nudo@0.1.0
+  - @nudojs/core@0.1.0
+  - @nudojs/parser@0.1.0

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+import { Node } from '@babel/types';
+import { TypeValue } from '@nudojs/core';
+
+type SourceLocation = {
+    start: {
+        line: number;
+        column: number;
+    };
+    end: {
+        line: number;
+        column: number;
+    };
+};
+type DiagnosticSeverity = "error" | "warning" | "info";
+type DiagnosticTag = "unnecessary";
+type Diagnostic = {
+    range: SourceLocation;
+    severity: DiagnosticSeverity;
+    message: string;
+    tags?: DiagnosticTag[];
+};
+type CaseResult = {
+    name: string;
+    args: TypeValue[];
+    result: TypeValue;
+    throws: TypeValue;
+    throwLoc?: SourceLocation;
+};
+type FunctionAnalysis = {
+    name: string;
+    loc: SourceLocation;
+    cases: CaseResult[];
+    combined?: TypeValue;
+    assertionErrors?: string[];
+};
+type BindingInfo = {
+    type: TypeValue;
+    loc?: SourceLocation;
+};
+type CaseHint = {
+    line: number;
+    label: string;
+    ok: boolean;
+};
+type AnalysisResult = {
+    functions: FunctionAnalysis[];
+    diagnostics: Diagnostic[];
+    bindings: Map<string, BindingInfo>;
+    nodeTypeMap: Map<Node, TypeValue>;
+    caseHints: CaseHint[];
+};
+type CompletionItem = {
+    label: string;
+    kind: "property" | "method" | "variable";
+    detail?: string;
+};
+declare function analyzeFile(filePath: string, source: string, activeCases?: Map<string, number>): AnalysisResult;
+type CaseInfo = {
+    functionName: string;
+    caseName: string;
+    caseIndex: number;
+};
+declare function getCasesForFile(filePath: string, source: string): {
+    functionName: string;
+    cases: {
+        name: string;
+        index: number;
+    }[];
+    loc: SourceLocation;
+}[];
+declare function getTypeAtPosition(filePath: string, source: string, line: number, column: number, activeCases?: Map<string, number>): TypeValue | null;
+declare function getCompletionsAtPosition(filePath: string, source: string, line: number, column: number): CompletionItem[];
+
+declare function typeValueToTSType(tv: TypeValue): string;
+declare function generateDts(result: AnalysisResult): string;
+
+export { type AnalysisResult, type BindingInfo, type CaseHint, type CaseInfo, type CaseResult, type CompletionItem, type Diagnostic, type DiagnosticSeverity, type DiagnosticTag, type FunctionAnalysis, type SourceLocation, analyzeFile, generateDts, getCasesForFile, getCompletionsAtPosition, getTypeAtPosition, typeValueToTSType };

package/dist/index.js

@@ -0,0 +1,523 @@
+// src/analyzer.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve, dirname } from "path";
+import traverse from "@babel/traverse";
+import {
+  T,
+  typeValueToString,
+  simplifyUnion,
+  createEnvironment,
+  isSubtypeOf
+} from "@nudojs/core";
+import { parse, extractDirectives, parseTypeValueExpr } from "@nudojs/parser";
+import {
+  evaluateFunction,
+  evaluateFunctionFull,
+  evaluateProgram,
+  setModuleResolver,
+  setCurrentFileDir,
+  resetMemo,
+  getUnreachableRanges,
+  resetUnreachableRanges,
+  setNodeTypeCollector
+} from "@nudojs/cli/evaluator";
+function resolveModule(source, fromDir) {
+  const extensions = [".js", ".ts", ".mjs"];
+  const basePath = resolve(fromDir, source);
+  for (const ext of ["", ...extensions]) {
+    const candidate = basePath + ext;
+    if (existsSync(candidate)) {
+      const src = readFileSync(candidate, "utf-8");
+      return { ast: parse(src), filePath: candidate };
+    }
+  }
+  return null;
+}
+function applyMocks(directives, env, filePath) {
+  for (const d of directives) {
+    if (d.kind !== "mock") continue;
+    if (d.expression) {
+      env.bind(d.name, parseTypeValueExpr(d.expression));
+    } else if (d.fromPath) {
+      const mockPath = resolve(dirname(filePath), d.fromPath);
+      const mockSource = readFileSync(mockPath, "utf-8");
+      const mockAst = parse(mockSource);
+      const mockEnv = createEnvironment();
+      evaluateProgram(mockAst, mockEnv);
+      const mockVal = mockEnv.lookup(d.name);
+      env.bind(d.name, mockVal);
+    }
+  }
+}
+function locFromNode(node) {
+  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 }
+  };
+}
+function analyzeFile(filePath, source, activeCases) {
+  const ast = parse(source);
+  const functions = extractDirectives(ast);
+  const diagnostics = [];
+  const bindings = /* @__PURE__ */ new Map();
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  const functionResults = [];
+  const caseHints = [];
+  resetMemo();
+  resetUnreachableRanges();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname(filePath));
+  const globalEnv = createEnvironment();
+  evaluateProgram(ast, globalEnv);
+  const unreachableRanges = getUnreachableRanges();
+  for (const ur of unreachableRanges) {
+    diagnostics.push({
+      range: ur,
+      severity: "info",
+      message: "Unreachable code",
+      tags: ["unnecessary"]
+    });
+  }
+  collectBindings(ast, globalEnv, bindings);
+  for (const fn of functions) {
+    applyMocks(fn.directives, globalEnv, filePath);
+    const isPure = fn.directives.some((d) => d.kind === "pure");
+    const skipDirective = fn.directives.find((d) => d.kind === "skip");
+    const returnsDirective = fn.directives.find((d) => d.kind === "returns");
+    const fnLoc = locFromNode(fn.node);
+    const analysis = { name: fn.name, loc: fnLoc, cases: [] };
+    if (skipDirective && skipDirective.kind === "skip") {
+      if (skipDirective.returns) {
+        analysis.combined = skipDirective.returns;
+      }
+      functionResults.push(analysis);
+      continue;
+    }
+    if (isPure) {
+      const fnVal = globalEnv.has(fn.name) ? globalEnv.lookup(fn.name) : null;
+      if (fnVal && fnVal.kind === "function") {
+        fnVal._memoize = fn.name;
+      }
+    }
+    const caseDirectives = fn.directives.filter((d) => d.kind === "case");
+    const activeCaseIdx = activeCases?.get(fn.name) ?? 0;
+    for (let ci = 0; ci < caseDirectives.length; ci++) {
+      const directive = caseDirectives[ci];
+      resetUnreachableRanges();
+      const fullResult = evaluateFunctionFull(fn.node, directive.args, globalEnv);
+      const caseUnreachable = [...getUnreachableRanges()];
+      analysis.cases.push({
+        name: directive.name,
+        args: directive.args,
+        result: fullResult.value,
+        throws: fullResult.throws,
+        throwLoc: fullResult.throwLoc
+      });
+      if (directive.commentLine) {
+        const hasThrow = fullResult.throws.kind !== "never";
+        const resultStr = fullResult.value.kind !== "never" ? typeValueToString(fullResult.value) : "";
+        const throwStr = hasThrow ? `throws ${typeValueToString(fullResult.throws)}` : "";
+        const label = [resultStr, throwStr].filter(Boolean).join(" ");
+        const hintLabel = `=> ${label}`;
+        let ok = true;
+        if (directive.expected) {
+          ok = isSubtypeOf(fullResult.value, directive.expected);
+          if (!ok) {
+            diagnostics.push({
+              range: { start: { line: directive.commentLine, column: 0 }, end: { line: directive.commentLine, column: 999 } },
+              severity: "error",
+              message: `Case "${directive.name}": expected ${typeValueToString(directive.expected)}, got ${typeValueToString(fullResult.value)}`
+            });
+          }
+        }
+        caseHints.push({ line: directive.commentLine, label: hintLabel, ok });
+      }
+      const isActive = ci === Math.min(activeCaseIdx, caseDirectives.length - 1);
+      if (isActive) {
+        if (fullResult.throws.kind !== "never") {
+          const throwRange = fullResult.throwLoc ?? fnLoc;
+          diagnostics.push({
+            range: throwRange,
+            severity: "warning",
+            message: `Function "${fn.name}" case "${directive.name}" may throw: ${typeValueToString(fullResult.throws)}`
+          });
+        }
+        for (const ur of caseUnreachable) {
+          diagnostics.push({
+            range: ur,
+            severity: "info",
+            message: "Unreachable code",
+            tags: ["unnecessary"]
+          });
+        }
+      }
+    }
+    if (analysis.cases.length > 1) {
+      analysis.combined = simplifyUnion(analysis.cases.map((c) => c.result));
+    } else if (analysis.cases.length === 1) {
+      analysis.combined = analysis.cases[0].result;
+    }
+    if (returnsDirective && returnsDirective.kind === "returns") {
+      analysis.assertionErrors = [];
+      for (const directive of caseDirectives) {
+        const result = evaluateFunction(fn.node, directive.args, globalEnv);
+        const matches = isSubtypeOf(result, returnsDirective.expected);
+        if (!matches) {
+          const msg = `@nudo:returns assertion failed for case "${directive.name}": expected ${typeValueToString(returnsDirective.expected)}, got ${typeValueToString(result)}`;
+          analysis.assertionErrors.push(msg);
+          diagnostics.push({
+            range: fnLoc,
+            severity: "error",
+            message: msg
+          });
+        }
+      }
+    }
+    functionResults.push(analysis);
+  }
+  buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
+  setModuleResolver(null);
+  return {
+    functions: functionResults,
+    diagnostics,
+    bindings,
+    nodeTypeMap,
+    caseHints
+  };
+}
+function collectBindings(ast, env, bindings) {
+  if (ast.type !== "File") return;
+  for (const stmt of ast.program.body) {
+    if (stmt.type === "FunctionDeclaration" && stmt.id) {
+      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
+      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
+    }
+    if (stmt.type === "VariableDeclaration") {
+      for (const decl of stmt.declarations) {
+        if (decl.id.type === "Identifier") {
+          const val = env.has(decl.id.name) ? env.lookup(decl.id.name) : T.unknown;
+          bindings.set(decl.id.name, { type: val, loc: locFromNode(decl) });
+        }
+      }
+    }
+    if (stmt.type === "ClassDeclaration" && stmt.id) {
+      const val = env.has(stmt.id.name) ? env.lookup(stmt.id.name) : T.unknown;
+      bindings.set(stmt.id.name, { type: val, loc: locFromNode(stmt) });
+    }
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      collectBindings({ type: "File", program: { type: "Program", body: [stmt.declaration] } }, env, bindings);
+    }
+  }
+}
+function buildNodeTypeMap(ast, env, nodeTypeMap) {
+  const traverseFn = typeof traverse === "function" ? traverse : traverse.default;
+  try {
+    traverseFn(ast, {
+      enter(path) {
+        const node = path.node;
+        try {
+          if (node.type === "Identifier" && node.name !== "undefined" && path.parentPath?.node.type !== "FunctionDeclaration" && path.parentPath?.node.type !== "VariableDeclarator") {
+            if (env.has(node.name)) {
+              nodeTypeMap.set(node, env.lookup(node.name));
+            }
+          }
+          if (node.type === "NumericLiteral") {
+            nodeTypeMap.set(node, T.literal(node.value));
+          }
+          if (node.type === "StringLiteral") {
+            nodeTypeMap.set(node, T.literal(node.value));
+          }
+          if (node.type === "BooleanLiteral") {
+            nodeTypeMap.set(node, T.literal(node.value));
+          }
+          if (node.type === "NullLiteral") {
+            nodeTypeMap.set(node, T.null);
+          }
+        } catch {
+        }
+      }
+    });
+  } catch {
+  }
+}
+function getCasesForFile(filePath, source) {
+  const ast = parse(source);
+  const functions = extractDirectives(ast);
+  return functions.map((fn) => {
+    const cases = fn.directives.filter((d) => d.kind === "case").map((d, i) => ({ name: d.name, index: i }));
+    return { functionName: fn.name, cases, loc: locFromNode(fn.node) };
+  });
+}
+function getTypeAtPosition(filePath, source, line, column, activeCases) {
+  const ast = parse(source);
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname(filePath));
+  const globalEnv = createEnvironment();
+  evaluateProgram(ast, globalEnv);
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  buildNodeTypeMap(ast, globalEnv, nodeTypeMap);
+  const functions = extractDirectives(ast);
+  const enclosingFn = findEnclosingFunction(functions, line);
+  if (enclosingFn) {
+    const caseDirectives = enclosingFn.directives.filter((d) => d.kind === "case");
+    if (caseDirectives.length > 0) {
+      const caseIndex = activeCases?.get(enclosingFn.name) ?? 0;
+      const directive = caseDirectives[Math.min(caseIndex, caseDirectives.length - 1)];
+      const fnNodeTypeMap = /* @__PURE__ */ new Map();
+      setNodeTypeCollector((node, tv) => fnNodeTypeMap.set(node, tv));
+      evaluateFunctionFull(enclosingFn.node, directive.args, globalEnv);
+      setNodeTypeCollector(null);
+      for (const [node, tv] of fnNodeTypeMap) {
+        nodeTypeMap.set(node, tv);
+      }
+    }
+  }
+  setModuleResolver(null);
+  return findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column);
+}
+function findEnclosingFunction(functions, line) {
+  for (const fn of functions) {
+    const loc = fn.node.loc;
+    if (!loc) continue;
+    if (loc.start.line <= line && loc.end.line >= line) {
+      return fn;
+    }
+  }
+  return null;
+}
+function findBestTypeAtPosition(nodeTypeMap, globalEnv, ast, line, column) {
+  let bestMatch = null;
+  let bestSize = Infinity;
+  for (const [node, tv] of nodeTypeMap) {
+    const loc = node.loc;
+    if (!loc) continue;
+    if (loc.start.line <= line && loc.end.line >= line && (loc.start.line < line || loc.start.column <= column) && (loc.end.line > line || loc.end.column >= column)) {
+      const size = (loc.end.line - loc.start.line) * 1e4 + (loc.end.column - loc.start.column);
+      if (size < bestSize) {
+        bestSize = size;
+        bestMatch = tv;
+      }
+    }
+  }
+  if (!bestMatch) {
+    const identAtPos = findIdentifierAtPosition(ast, line, column);
+    if (identAtPos && globalEnv.has(identAtPos)) {
+      bestMatch = globalEnv.lookup(identAtPos);
+    }
+  }
+  return bestMatch;
+}
+function findIdentifierAtPosition(ast, line, column) {
+  let found = null;
+  const traverseFn = typeof traverse === "function" ? traverse : traverse.default;
+  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 {
+  }
+  return found;
+}
+function getCompletionsAtPosition(filePath, source, line, column) {
+  const textBefore = getTextBeforePosition(source, line, column);
+  const dotMatch = textBefore.match(/(\w+)\.\s*\w*$/);
+  if (!dotMatch) return getVariableCompletions(filePath, source);
+  const objName = dotMatch[1];
+  const safeSource = sanitizeSourceForParsing(source);
+  let ast;
+  try {
+    ast = parse(safeSource);
+  } catch {
+    try {
+      ast = parse(source);
+    } catch {
+      return [];
+    }
+  }
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname(filePath));
+  const globalEnv = createEnvironment();
+  evaluateProgram(ast, globalEnv);
+  if (!globalEnv.has(objName)) {
+    setModuleResolver(null);
+    return [];
+  }
+  const objType = globalEnv.lookup(objName);
+  const completions = getCompletionsForType(objType);
+  setModuleResolver(null);
+  return completions;
+}
+function sanitizeSourceForParsing(source) {
+  return source.replace(/(\w+)\.\s*$/gm, "$1._ ");
+}
+function getTextBeforePosition(source, line, column) {
+  const lines = source.split("\n");
+  if (line < 1 || line > lines.length) return "";
+  return lines[line - 1].slice(0, column);
+}
+function getVariableCompletions(filePath, source) {
+  const ast = parse(source);
+  resetMemo();
+  setModuleResolver(resolveModule);
+  setCurrentFileDir(dirname(filePath));
+  const globalEnv = createEnvironment();
+  evaluateProgram(ast, globalEnv);
+  const ownBindings = globalEnv.getOwnBindings();
+  const completions = [];
+  for (const [name, tv] of Object.entries(ownBindings)) {
+    if (name.startsWith("__export_")) continue;
+    completions.push({
+      label: name,
+      kind: tv.kind === "function" ? "method" : "variable",
+      detail: typeValueToString(tv)
+    });
+  }
+  setModuleResolver(null);
+  return completions;
+}
+function getCompletionsForType(tv) {
+  const completions = [];
+  if (tv.kind === "object") {
+    for (const [key, val] of Object.entries(tv.properties)) {
+      completions.push({
+        label: key,
+        kind: val.kind === "function" ? "method" : "property",
+        detail: typeValueToString(val)
+      });
+    }
+    return completions;
+  }
+  if (tv.kind === "instance") {
+    for (const [key, val] of Object.entries(tv.properties)) {
+      completions.push({
+        label: key,
+        kind: val.kind === "function" ? "method" : "property",
+        detail: typeValueToString(val)
+      });
+    }
+    return completions;
+  }
+  if (tv.kind === "array" || tv.kind === "tuple") {
+    const arrayMethods = [
+      { label: "map", detail: "map(callback)" },
+      { label: "filter", detail: "filter(callback)" },
+      { label: "reduce", detail: "reduce(callback, init)" },
+      { label: "find", detail: "find(callback)" },
+      { label: "some", detail: "some(callback)" },
+      { label: "every", detail: "every(callback)" },
+      { label: "forEach", detail: "forEach(callback)" },
+      { label: "flatMap", detail: "flatMap(callback)" },
+      { label: "includes", detail: "includes(value)" },
+      { label: "indexOf", detail: "indexOf(value)" },
+      { label: "join", detail: "join(separator)" },
+      { label: "slice", detail: "slice(start, end)" },
+      { label: "concat", detail: "concat(other)" },
+      { label: "push", detail: "push(value)" },
+      { label: "length", detail: tv.kind === "tuple" ? `${tv.elements.length}` : "number" }
+    ];
+    for (const m of arrayMethods) {
+      completions.push({ label: m.label, kind: "method", detail: m.detail });
+    }
+    return completions;
+  }
+  if (tv.kind === "promise") {
+    completions.push({ label: "then", kind: "method", detail: "then(callback)" });
+    completions.push({ label: "catch", kind: "method", detail: "catch(callback)" });
+    completions.push({ label: "finally", kind: "method", detail: "finally(callback)" });
+    return completions;
+  }
+  if (tv.kind === "primitive" && tv.type === "string") {
+    const stringMethods = ["toUpperCase", "toLowerCase", "trim", "split", "slice", "includes", "indexOf", "replace", "startsWith", "endsWith", "charAt", "length"];
+    for (const m of stringMethods) {
+      completions.push({ label: m, kind: "method", detail: `string.${m}` });
+    }
+    return completions;
+  }
+  return completions;
+}
+
+// src/dts-generator.ts
+function typeValueToTSType(tv) {
+  switch (tv.kind) {
+    case "literal": {
+      const v = tv.value;
+      if (v === null) return "null";
+      if (v === void 0) return "undefined";
+      if (typeof v === "string") return JSON.stringify(v);
+      if (typeof v === "boolean") return String(v);
+      return String(v);
+    }
+    case "primitive":
+      return tv.type;
+    case "object": {
+      const entries = Object.entries(tv.properties);
+      if (entries.length === 0) return "{}";
+      const inner = entries.map(([k, v]) => `${k}: ${typeValueToTSType(v)}`).join("; ");
+      return `{ ${inner} }`;
+    }
+    case "array":
+      return `${wrapComplexType(tv.element)}[]`;
+    case "tuple": {
+      const inner = tv.elements.map(typeValueToTSType).join(", ");
+      return `[${inner}]`;
+    }
+    case "function": {
+      const params = tv.params.map((p, i) => `${p}: unknown`).join(", ");
+      return `(${params}) => unknown`;
+    }
+    case "promise":
+      return `Promise<${typeValueToTSType(tv.value)}>`;
+    case "instance":
+      return tv.className;
+    case "union":
+      return tv.members.map(typeValueToTSType).join(" | ");
+    case "never":
+      return "never";
+    case "unknown":
+      return "unknown";
+  }
+}
+function wrapComplexType(tv) {
+  const ts = typeValueToTSType(tv);
+  if (tv.kind === "union") return `(${ts})`;
+  return ts;
+}
+function generateDts(result) {
+  const lines = [];
+  for (const fn of result.functions) {
+    if (fn.cases.length === 0 && fn.combined) {
+      lines.push(`export declare function ${fn.name}(...args: unknown[]): ${typeValueToTSType(fn.combined)};`);
+      continue;
+    }
+    if (fn.cases.length === 1) {
+      const c = fn.cases[0];
+      const params = c.args.map((a, i) => `arg${i}: ${typeValueToTSType(a)}`).join(", ");
+      const ret = typeValueToTSType(c.result);
+      lines.push(`export declare function ${fn.name}(${params}): ${ret};`);
+      continue;
+    }
+    for (const c of fn.cases) {
+      const params = c.args.map((a, i) => `arg${i}: ${typeValueToTSType(a)}`).join(", ");
+      const ret = typeValueToTSType(c.result);
+      lines.push(`export declare function ${fn.name}(${params}): ${ret};`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+export {
+  analyzeFile,
+  generateDts,
+  getCasesForFile,
+  getCompletionsAtPosition,
+  getTypeAtPosition,
+  typeValueToTSType
+};

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@nudojs/service",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "src/index.ts",
+  "dependencies": {
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@nudojs/core": "0.1.0",
+    "@nudojs/parser": "0.1.0",
+    "@nudojs/cli": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}