@ngockhoale/ukit 2.6.7 → 2.6.8

package/src/core/codeintel/semanticProvider.js

@@ -0,0 +1,235 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { getArtifactPath, INDEX_ARTIFACTS } from '../../index/paths.js';
+import { createEdge, NullSemanticProvider } from './providers.js';
+
+const NO_CAPS = Object.freeze({ defs: false, refs: false, types: false });
+const ALL_CAPS = Object.freeze({ defs: true, refs: true, types: true });
+const DEFAULT_LIMIT = 50;
+const MAX_FILES = 200;
+const SEMANTIC_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts']);
+
+function defaultLoader() {
+  return import('typescript');
+}
+
+function isSemanticFile(filePath) {
+  return typeof filePath === 'string' && SEMANTIC_EXTS.has(path.extname(filePath));
+}
+
+/**
+ * SemanticProvider backed by the TypeScript language service, loaded via an
+ * injectable async loader (default: dynamic `import('typescript')`). When the
+ * loader fails — package absent, throw, any reason — the provider degrades to
+ * `available()===false`, `resolve()→null`, all-false capabilities. Never throws.
+ */
+export class TypeScriptSemanticProvider {
+  constructor({ projectRoot = process.cwd(), loader = defaultLoader } = {}) {
+    this.name = 'typescript-semantic';
+    this.projectRoot = projectRoot;
+    this._loader = loader;
+    this._probe = null;
+    this._caps = NO_CAPS;
+  }
+
+  #probeTs() {
+    if (!this._probe) {
+      this._probe = Promise.resolve()
+        .then(() => this._loader())
+        .then((ts) => {
+          this._caps = ts ? ALL_CAPS : NO_CAPS;
+          return ts ?? null;
+        })
+        .catch(() => {
+          this._caps = NO_CAPS;
+          return null;
+        });
+    }
+    return this._probe;
+  }
+
+  async available() {
+    return (await this.#probeTs()) !== null;
+  }
+
+  capabilities() {
+    return { ...this._caps };
+  }
+
+  /**
+   * ctx = { file?, mode?: 'definition'|'references'|'both', limit?, snapshot? }
+   * → edge[] (createEdge shape) | null when unavailable or on any failure.
+   */
+  async resolve(symbol, ctx = {}) {
+    try {
+      const ts = await this.#probeTs();
+      if (!ts || typeof symbol !== 'string' || symbol.length === 0) {
+        return null;
+      }
+      const safeCtx = ctx && typeof ctx === 'object' ? ctx : {};
+      const mode = safeCtx.mode ?? 'both';
+      const limit = Number.isInteger(safeCtx.limit) && safeCtx.limit > 0 ? safeCtx.limit : DEFAULT_LIMIT;
+      const files = this.#boundedFiles(safeCtx);
+      if (files.length === 0) {
+        return [];
+      }
+      return this.#resolveWith(ts, symbol, files, mode, limit, safeCtx.snapshot ?? null);
+    } catch {
+      return null;
+    }
+  }
+
+  #boundedFiles(ctx) {
+    if (isSemanticFile(ctx.file)) {
+      return [path.resolve(this.projectRoot, ctx.file)];
+    }
+    try {
+      const filesPath = getArtifactPath(this.projectRoot, INDEX_ARTIFACTS.files);
+      const raw = JSON.parse(fs.readFileSync(filesPath, 'utf8'));
+      const list = Array.isArray(raw) ? raw : (raw.files ?? []);
+      return list
+        .map((entry) => (typeof entry === 'string' ? entry : entry?.filePath ?? entry?.path))
+        .filter(isSemanticFile)
+        .slice(0, MAX_FILES)
+        .map((file) => path.resolve(this.projectRoot, file));
+    } catch {
+      return [];
+    }
+  }
+
+  #resolveWith(ts, symbol, files, mode, limit, snapshot) {
+    const sources = new Map();
+    const readSource = (fileName) => {
+      if (!sources.has(fileName)) {
+        try {
+          sources.set(fileName, fs.readFileSync(fileName, 'utf8'));
+        } catch {
+          sources.set(fileName, null);
+        }
+      }
+      return sources.get(fileName);
+    };
+
+    const host = {
+      getScriptFileNames: () => files,
+      getScriptVersion: () => '1',
+      getScriptSnapshot: (fileName) => {
+        const text = readSource(fileName);
+        if (text === null) {
+          return undefined;
+        }
+        return ts.ScriptSnapshot?.fromString ? ts.ScriptSnapshot.fromString(text) : text;
+      },
+      getCurrentDirectory: () => this.projectRoot,
+      getCompilationSettings: () => ({ allowJs: true, checkJs: false }),
+      getDefaultLibFileName: () => 'lib.d.ts',
+      readFile: (fileName) => readSource(fileName) ?? undefined,
+      fileExists: (fileName) => readSource(fileName) !== null,
+    };
+
+    let service = null;
+    const edges = [];
+    const seen = new Set();
+    const pushEdge = (kind, fileName, start) => {
+      if (edges.length >= limit) {
+        return;
+      }
+      const source = readSource(fileName);
+      const line = source === null ? 0 : lineOf(source, start);
+      const key = `${kind}:${fileName}:${start}`;
+      if (seen.has(key)) {
+        return;
+      }
+      seen.add(key);
+      edges.push(createEdge({
+        from: symbol,
+        to: `${fileName}:${line}`,
+        kind,
+        confidence: 1,
+        provider: this.name,
+        evidence: 'typescript-ls',
+        snapshot,
+      }));
+    };
+
+    try {
+      service = ts.createLanguageService(host);
+      const wantsDefs = mode === 'definition' || mode === 'both';
+      const wantsRefs = mode === 'references' || mode === 'both';
+      for (const fileName of files) {
+        if (edges.length >= limit) {
+          break;
+        }
+        const source = readSource(fileName);
+        if (source === null) {
+          continue;
+        }
+        for (const pos of occurrencesOf(source, symbol)) {
+          if (edges.length >= limit) {
+            break;
+          }
+          if (wantsDefs && typeof service.getDefinitionAtPosition === 'function') {
+            for (const entry of service.getDefinitionAtPosition(fileName, pos) ?? []) {
+              if (entry?.fileName && entry?.textSpan) {
+                pushEdge('def', entry.fileName, entry.textSpan.start);
+              }
+            }
+          }
+          if (wantsRefs && typeof service.findReferences === 'function') {
+            for (const group of service.findReferences(fileName, pos) ?? []) {
+              for (const entry of group?.references ?? []) {
+                if (entry?.fileName && entry?.textSpan) {
+                  pushEdge('ref', entry.fileName, entry.textSpan.start);
+                }
+              }
+            }
+          }
+        }
+      }
+    } finally {
+      try {
+        service?.dispose?.();
+      } catch {
+        // dispose is best-effort
+      }
+    }
+    return edges;
+  }
+}
+
+function occurrencesOf(source, symbol) {
+  const positions = [];
+  const pattern = new RegExp(`\\b${symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'g');
+  let match;
+  while ((match = pattern.exec(source)) !== null && positions.length < 50) {
+    positions.push(match.index);
+  }
+  return positions;
+}
+
+function lineOf(source, offset) {
+  let line = 1;
+  for (let i = 0; i < offset && i < source.length; i += 1) {
+    if (source[i] === '\n') {
+      line += 1;
+    }
+  }
+  return line;
+}
+
+/**
+ * Factory honoring `config.codeIntel.providers.semantic`:
+ *   'typescript' (or 'auto' when typescript resolves) → TypeScriptSemanticProvider
+ *   anything else / missing ('null' default)         → NullSemanticProvider
+ */
+export function createSemanticProvider({ projectRoot = process.cwd(), config = {}, loader } = {}) {
+  const setting = config?.codeIntel?.providers?.semantic ?? 'null';
+  if (setting === 'typescript' || setting === 'auto') {
+    return new TypeScriptSemanticProvider({
+      projectRoot,
+      loader: loader ?? defaultLoader,
+    });
+  }
+  return new NullSemanticProvider();
+}