@nexrall/code-core 1.3.1 → 1.4.1

package/dist/tools/tsLangService.js

@@ -0,0 +1,282 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTsLike = isTsLike;
+exports.tsGoToDefinition = tsGoToDefinition;
+exports.tsFindReferences = tsFindReferences;
+exports.tsGetHover = tsGetHover;
+exports.tsServiceAvailable = tsServiceAvailable;
+exports._resetTsServiceCache = _resetTsServiceCache;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const module_1 = require("module");
+// ─── Real semantic navigation for TS/JS (GAP A) ───────────────────────────────
+//
+// The VS Code extension serves go_to_definition / find_references / get_hover
+// through the editor's language server. The CLI had NO semantic layer — only the
+// regex-based symbol scanner (symbols.ts), which can list top-level declarations
+// but cannot resolve "where is THIS reference defined" or "who calls X" with type
+// awareness. For the dominant case (TypeScript / JavaScript projects) we can close
+// that gap by driving the TypeScript compiler's own LanguageService in-process.
+//
+// Design constraints:
+//   • `typescript` is heavy (~10MB). We do NOT bundle it — it's marked `external`
+//     in the CLI/VS Code esbuild configs and resolved LAZILY at runtime.
+//   • We prefer the USER PROJECT's own typescript (node_modules) so results match
+//     the version/config they build with; fall back to ours; degrade to a clear
+//     message if neither resolves (the regex tools still work as a floor).
+//   • One LanguageService per workspace root, cached, with an incrementing file
+//     version map so edits during a session are picked up on the next call.
+const TS_EXTS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts']);
+function isTsLike(filePath) {
+    return TS_EXTS.has(path.extname(filePath).toLowerCase());
+}
+let _tsResolveTried = false;
+let _ts = null;
+/** Lazily load the `typescript` module — user project's copy first, then ours. */
+function loadTs(workDir) {
+    if (_tsResolveTried)
+        return _ts;
+    _tsResolveTried = true;
+    const candidates = [];
+    // 1. User project copy: resolve from the workspace root.
+    try {
+        const req = (0, module_1.createRequire)(path.join(workDir, 'package.json'));
+        candidates.push(req.resolve('typescript'));
+    }
+    catch { /* no local copy */ }
+    // 2. Our own dependency (dev/runtime).
+    try {
+        candidates.push(require.resolve('typescript'));
+    }
+    catch { /* ignore */ }
+    for (const c of candidates) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            _ts = require(c);
+            if (_ts && typeof _ts.createLanguageService === 'function')
+                return _ts;
+        }
+        catch { /* try next */ }
+    }
+    _ts = null;
+    return null;
+}
+const _services = new Map();
+function getService(workDir) {
+    const cached = _services.get(workDir);
+    if (cached)
+        return cached;
+    const ts = loadTs(workDir);
+    if (!ts)
+        return null;
+    const versions = new Map();
+    const snapshots = new Map();
+    const readSource = (fileName) => {
+        const cachedSrc = snapshots.get(fileName);
+        if (cachedSrc !== undefined)
+            return cachedSrc;
+        try {
+            const src = fs.readFileSync(fileName, 'utf-8');
+            snapshots.set(fileName, src);
+            return src;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    // Seed compiler options from the project's tsconfig if present.
+    let options = { allowJs: true, checkJs: false, target: 99 /* ESNext */, module: 99 };
+    try {
+        const cfgPath = ts.findConfigFile(workDir, ts.sys.fileExists, 'tsconfig.json');
+        if (cfgPath) {
+            const parsed = ts.readConfigFile(cfgPath, ts.sys.readFile);
+            const conf = ts.parseJsonConfigFileContent(parsed.config ?? {}, ts.sys, path.dirname(cfgPath));
+            if (conf.options)
+                options = { ...conf.options, allowJs: true };
+        }
+    }
+    catch { /* use defaults */ }
+    const host = {
+        getScriptFileNames: () => Array.from(versions.keys()),
+        getScriptVersion: (f) => String(versions.get(f) ?? 0),
+        getScriptSnapshot: (f) => {
+            const src = readSource(f);
+            return src === undefined ? undefined : ts.ScriptSnapshot.fromString(src);
+        },
+        getCurrentDirectory: () => workDir,
+        getCompilationSettings: () => options,
+        getDefaultLibFileName: (o) => ts.getDefaultLibFilePath(o),
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        readDirectory: ts.sys.readDirectory,
+        directoryExists: ts.sys.directoryExists,
+        getDirectories: ts.sys.getDirectories,
+    };
+    const service = ts.createLanguageService(host, ts.createDocumentRegistry());
+    const svc = { ts, service, root: workDir, versions, snapshots };
+    _services.set(workDir, svc);
+    return svc;
+}
+/** Register/refresh a file in the service, re-reading from disk (picks up edits). */
+function ensureFile(svc, absPath) {
+    try {
+        const src = fs.readFileSync(absPath, 'utf-8');
+        const prev = svc.snapshots.get(absPath);
+        if (prev !== src) {
+            svc.snapshots.set(absPath, src);
+            svc.versions.set(absPath, (svc.versions.get(absPath) ?? 0) + 1);
+        }
+        else if (!svc.versions.has(absPath)) {
+            svc.versions.set(absPath, 1);
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Convert 1-based line + character to a 0-based offset in `source`. */
+function posToOffset(source, line, character) {
+    const lines = source.split('\n');
+    let offset = 0;
+    for (let i = 0; i < line - 1 && i < lines.length; i++)
+        offset += lines[i].length + 1;
+    return offset + Math.max(0, character - 1);
+}
+/** Convert a 0-based offset back to 1-based line + character. */
+function offsetToPos(source, offset) {
+    let line = 1;
+    let last = 0;
+    for (let i = 0; i < offset && i < source.length; i++) {
+        if (source[i] === '\n') {
+            line++;
+            last = i + 1;
+        }
+    }
+    return { line, character: offset - last + 1 };
+}
+function relOf(root, abs) {
+    const r = path.relative(root, abs);
+    return r.startsWith('..') ? abs : r;
+}
+/** go_to_definition — resolve the symbol at (line, character) to its declaration(s). */
+function tsGoToDefinition(deps) {
+    const svc = getService(deps.workDir);
+    if (!svc)
+        return null; // caller falls back to regex
+    if (!ensureFile(svc, deps.filePath))
+        return { error: `Cannot read ${deps.filePath}` };
+    const source = svc.snapshots.get(deps.filePath) ?? '';
+    const offset = posToOffset(source, deps.line, deps.character);
+    let defs;
+    try {
+        defs = svc.service.getDefinitionAtPosition(deps.filePath, offset);
+    }
+    catch (e) {
+        return { error: `Language service error: ${e.message}` };
+    }
+    if (!defs || defs.length === 0)
+        return { output: 'No definition found at that position.' };
+    const out = defs.map((d) => {
+        const src = svc.snapshots.get(d.fileName) ?? (fs.existsSync(d.fileName) ? fs.readFileSync(d.fileName, 'utf-8') : '');
+        const pos = offsetToPos(src, d.textSpan.start);
+        return `${relOf(svc.root, d.fileName)}:${pos.line}:${pos.character}  ${d.kind ?? ''} ${d.name ?? ''}`.trimEnd();
+    });
+    return { output: `Definition(s):\n${out.join('\n')}` };
+}
+/** find_references — every usage of the symbol at (line, character) across the project. */
+function tsFindReferences(deps) {
+    const svc = getService(deps.workDir);
+    if (!svc)
+        return null;
+    if (!ensureFile(svc, deps.filePath))
+        return { error: `Cannot read ${deps.filePath}` };
+    const source = svc.snapshots.get(deps.filePath) ?? '';
+    const offset = posToOffset(source, deps.line, deps.character);
+    let refs;
+    try {
+        refs = svc.service.getReferencesAtPosition(deps.filePath, offset);
+    }
+    catch (e) {
+        return { error: `Language service error: ${e.message}` };
+    }
+    if (!refs || refs.length === 0)
+        return { output: 'No references found.' };
+    const lines = [];
+    for (const r of refs) {
+        if (r.isDefinition && deps.includeDeclaration === false)
+            continue;
+        const src = svc.snapshots.get(r.fileName) ?? (fs.existsSync(r.fileName) ? fs.readFileSync(r.fileName, 'utf-8') : '');
+        const pos = offsetToPos(src, r.textSpan.start);
+        const lineText = (src.split('\n')[pos.line - 1] ?? '').trim().slice(0, 120);
+        lines.push(`${relOf(svc.root, r.fileName)}:${pos.line}:${pos.character}${r.isDefinition ? ' [def]' : ''}  ${lineText}`);
+    }
+    return { output: `${lines.length} reference(s):\n${lines.join('\n')}` };
+}
+/** get_hover — the inferred type + doc for the symbol at (line, character). */
+function tsGetHover(deps) {
+    const svc = getService(deps.workDir);
+    if (!svc)
+        return null;
+    if (!ensureFile(svc, deps.filePath))
+        return { error: `Cannot read ${deps.filePath}` };
+    const source = svc.snapshots.get(deps.filePath) ?? '';
+    const offset = posToOffset(source, deps.line, deps.character);
+    let info;
+    try {
+        info = svc.service.getQuickInfoAtPosition(deps.filePath, offset);
+    }
+    catch (e) {
+        return { error: `Language service error: ${e.message}` };
+    }
+    if (!info)
+        return { output: 'No type information at that position.' };
+    const ts = svc.ts;
+    const sig = info.displayParts ? ts.displayPartsToString(info.displayParts) : '';
+    const doc = info.documentation ? ts.displayPartsToString(info.documentation) : '';
+    return { output: doc ? `${sig}\n\n${doc}` : sig || 'No type information.' };
+}
+/** Test/diagnostic helper: is a real TS language service available for this workspace? */
+function tsServiceAvailable(workDir) {
+    return getService(workDir) !== null;
+}
+/** Reset cached services + module resolution (tests only). */
+function _resetTsServiceCache() {
+    _services.clear();
+    _tsResolveTried = false;
+    _ts = null;
+}
+//# sourceMappingURL=tsLangService.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",