@graphmemory/server 1.2.0 → 1.3.0

package/dist/lib/parsers/code.js

@@ -3,43 +3,157 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearPathMappingsCache = clearPathMappingsCache;
 exports.parseCodeFile = parseCodeFile;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const languages_1 = require("../../lib/parsers/languages");
 const file_lang_1 = require("../../graphs/file-lang");
+// Strip line and block comments from JSONC, preserving string contents.
+function stripJsoncComments(text) {
+    let result = '';
+    let i = 0;
+    while (i < text.length) {
+        // String literal — copy verbatim
+        if (text[i] === '"') {
+            const start = i++;
+            while (i < text.length && text[i] !== '"') {
+                if (text[i] === '\\')
+                    i++; // skip escaped char
+                i++;
+            }
+            i++; // closing quote
+            result += text.slice(start, i);
+            // Line comment
+        }
+        else if (text[i] === '/' && text[i + 1] === '/') {
+            while (i < text.length && text[i] !== '\n')
+                i++;
+            // Block comment
+        }
+        else if (text[i] === '/' && text[i + 1] === '*') {
+            i += 2;
+            while (i < text.length && !(text[i] === '*' && text[i + 1] === '/'))
+                i++;
+            i += 2;
+        }
+        else {
+            result += text[i++];
+        }
+    }
+    return result;
+}
 // ---------------------------------------------------------------------------
 // Import resolution — replaces ts-morph's getModuleSpecifierSourceFile()
 // ---------------------------------------------------------------------------
 const RESOLVE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'];
-/** Resolve a relative import specifier to an absolute file path, or null. */
-function resolveRelativeImport(fromFile, specifier) {
-    const dir = path_1.default.dirname(fromFile);
-    const base = path_1.default.resolve(dir, specifier);
-    // Exact match (e.g. './foo.ts')
+function hasFile(p) {
+    try {
+        return fs_1.default.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Try resolving a base path with extensions and index files. */
+function tryResolve(base) {
     if (hasFile(base))
         return base;
-    // Try adding extensions (e.g. './foo' → './foo.ts')
     for (const ext of RESOLVE_EXTENSIONS) {
-        const candidate = base + ext;
-        if (hasFile(candidate))
-            return candidate;
+        if (hasFile(base + ext))
+            return base + ext;
     }
-    // Try index files (e.g. './foo' → './foo/index.ts')
     for (const ext of RESOLVE_EXTENSIONS) {
-        const candidate = path_1.default.join(base, 'index' + ext);
-        if (hasFile(candidate))
-            return candidate;
+        const idx = path_1.default.join(base, 'index' + ext);
+        if (hasFile(idx))
+            return idx;
     }
     return null;
 }
-function hasFile(p) {
-    try {
-        return fs_1.default.statSync(p).isFile();
+/** Resolve a relative import specifier to an absolute file path, or null. */
+function resolveRelativeImport(fromFile, specifier) {
+    const dir = path_1.default.dirname(fromFile);
+    return tryResolve(path_1.default.resolve(dir, specifier));
+}
+/** Cache: directory → parsed path mappings (null = no tsconfig found up to root). */
+const _pathMappings = new Map();
+/** Clear cached path mappings (call between projects or on config change). */
+function clearPathMappingsCache() { _pathMappings.clear(); }
+/**
+ * Find the nearest tsconfig.json / jsconfig.json walking up from `dir` to `root`.
+ * Cached per directory — each directory remembers its resolved mappings.
+ */
+function findPathMappings(dir, root) {
+    if (_pathMappings.has(dir))
+        return _pathMappings.get(dir);
+    // Try this directory
+    const result = _parseTsConfig(dir);
+    if (result) {
+        _pathMappings.set(dir, result);
+        return result;
     }
-    catch {
-        return false;
+    // Walk up unless we've reached the project root
+    const parent = path_1.default.dirname(dir);
+    if (dir === root || parent === dir) {
+        _pathMappings.set(dir, null);
+        return null;
+    }
+    const parentResult = findPathMappings(parent, root);
+    _pathMappings.set(dir, parentResult);
+    return parentResult;
+}
+function _parseTsConfig(dir) {
+    for (const name of ['tsconfig.json', 'jsconfig.json']) {
+        const configPath = path_1.default.join(dir, name);
+        if (!hasFile(configPath))
+            continue;
+        try {
+            // Strip JSONC comments while preserving string contents
+            const raw = stripJsoncComments(fs_1.default.readFileSync(configPath, 'utf-8'));
+            const config = JSON.parse(raw);
+            const compilerOptions = config.compilerOptions;
+            if (!compilerOptions?.paths)
+                continue;
+            const baseUrl = compilerOptions.baseUrl
+                ? path_1.default.resolve(dir, compilerOptions.baseUrl)
+                : dir;
+            const mappings = [];
+            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
+                // Pattern like "@/*" → prefix "@/", or "utils/*" → prefix "utils/"
+                const prefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
+                const resolvedTargets = targets
+                    .map(t => {
+                    const target = t.endsWith('/*') ? t.slice(0, -1) : t;
+                    return path_1.default.resolve(baseUrl, target);
+                });
+                mappings.push({ prefix, targets: resolvedTargets });
+            }
+            if (mappings.length > 0)
+                return mappings;
+        }
+        catch {
+            // Malformed config — skip
+        }
+    }
+    return null;
+}
+/** Resolve a path-aliased import (e.g. @/lib/foo) using nearest tsconfig paths. */
+function resolveAliasImport(specifier, fromFile, projectDir) {
+    const fileDir = path_1.default.dirname(fromFile);
+    const mappings = findPathMappings(fileDir, projectDir);
+    if (!mappings)
+        return null;
+    for (const mapping of mappings) {
+        if (specifier.startsWith(mapping.prefix)) {
+            const rest = specifier.slice(mapping.prefix.length);
+            for (const targetDir of mapping.targets) {
+                const resolved = tryResolve(path_1.default.join(targetDir, rest));
+                if (resolved)
+                    return resolved;
+            }
+        }
     }
+    return null;
 }
 // ---------------------------------------------------------------------------
 // Main parser
@@ -62,8 +176,8 @@ async function parseCodeFile(absolutePath, codeDir, mtime) {
         };
     }
     const source = fs_1.default.readFileSync(absolutePath, 'utf-8');
-    const rootNode = await (0, languages_1.parseSource)(source, language);
-    if (!rootNode) {
+    const tree = await (0, languages_1.parseSource)(source, language);
+    if (!tree) {
         return {
             fileId,
             mtime,
@@ -74,17 +188,23 @@ async function parseCodeFile(absolutePath, codeDir, mtime) {
             edges: [],
         };
     }
+    const rootNode = tree.rootNode;
     const mapper = (0, languages_1.getMapper)(language);
-    const symbols = mapper.extractSymbols(rootNode);
-    const edgeInfos = mapper.extractEdges(rootNode);
-    const imports = mapper.extractImports(rootNode);
+    let symbols, edgeInfos, imports, fileDocComment, importSummary, lastLine;
+    try {
+        symbols = mapper.extractSymbols(rootNode);
+        edgeInfos = mapper.extractEdges(rootNode);
+        imports = mapper.extractImports(rootNode);
+        fileDocComment = extractFileDocComment(rootNode);
+        importSummary = buildImportSummary(rootNode);
+        lastLine = (rootNode.endPosition?.row ?? 0) + 1;
+    }
+    finally {
+        tree.delete();
+    }
     const nodes = [];
     const edges = [];
     const fileNodeId = fileId;
-    // --- File root node ---
-    const fileDocComment = extractFileDocComment(rootNode);
-    const importSummary = buildImportSummary(rootNode);
-    const lastLine = (rootNode.endPosition?.row ?? 0) + 1;
     nodes.push({
         id: fileNodeId,
         attrs: makeFileAttrs(fileId, fileDocComment, importSummary, lastLine, mtime),
@@ -147,13 +267,20 @@ async function parseCodeFile(absolutePath, codeDir, mtime) {
     }
     // --- Import edges: file → imported file ---
     for (const imp of imports) {
-        const targetAbsolute = resolveRelativeImport(absolutePath, imp.specifier);
+        let targetAbsolute = null;
+        if (imp.specifier.startsWith('./') || imp.specifier.startsWith('../')) {
+            // Relative import
+            targetAbsolute = resolveRelativeImport(absolutePath, imp.specifier);
+        }
+        else {
+            // Try path alias resolution (e.g. @/lib/foo, ~/utils)
+            targetAbsolute = resolveAliasImport(imp.specifier, absolutePath, codeDir);
+        }
         if (!targetAbsolute)
             continue;
-        const targetRel = path_1.default.relative(codeDir, targetAbsolute);
-        if (targetRel.startsWith('..') || path_1.default.isAbsolute(targetRel))
-            continue;
         const targetFileId = path_1.default.relative(codeDir, targetAbsolute);
+        if (targetFileId.startsWith('..') || path_1.default.isAbsolute(targetFileId))
+            continue;
         if (targetFileId !== fileNodeId) {
             edges.push({
                 from: fileNodeId,

package/dist/lib/parsers/codeblock.js

@@ -6,7 +6,7 @@ const languages_1 = require("../../lib/parsers/languages");
 const TAG_TO_LANGUAGE = {
     ts: 'typescript',
     typescript: 'typescript',
-    tsx: 'typescript',
+    tsx: 'tsx',
     js: 'javascript',
     javascript: 'javascript',
     jsx: 'javascript',
@@ -20,12 +20,17 @@ async function extractSymbols(code, language) {
     if (!lang || !(0, languages_1.isLanguageSupported)(lang))
         return [];
     try {
-        const rootNode = await (0, languages_1.parseSource)(code, lang);
-        if (!rootNode)
+        const tree = await (0, languages_1.parseSource)(code, lang);
+        if (!tree)
             return [];
-        const mapper = (0, languages_1.getMapper)(lang);
-        const symbols = mapper.extractSymbols(rootNode);
-        return symbols.map(s => s.name).filter(Boolean);
+        try {
+            const mapper = (0, languages_1.getMapper)(lang);
+            const symbols = mapper.extractSymbols(tree.rootNode);
+            return symbols.map(s => s.name).filter(Boolean);
+        }
+        finally {
+            tree.delete();
+        }
     }
     catch {
         return [];

package/dist/lib/parsers/docs.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseFile = parseFile;
+exports.clearWikiIndexCache = clearWikiIndexCache;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const codeblock_1 = require("../../lib/parsers/codeblock");
@@ -119,8 +120,10 @@ function extractFileTitle(content, filePath) {
 function extractLinks(content, fromFile, projectDir) {
     const results = new Set();
     const fileDir = path_1.default.dirname(fromFile);
+    // Strip fenced code blocks before extracting links (links inside code are not real references)
+    const textOnly = content.replace(FENCE_RE, '');
     // [text](./path.md)
-    const mdLinks = content.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
+    const mdLinks = textOnly.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
     for (const [, href] of mdLinks) {
         if (isExternal(href))
             continue;
@@ -130,7 +133,7 @@ function extractLinks(content, fromFile, projectDir) {
             results.add(fileId);
     }
     // [[wiki link]] or [[wiki link|alias]]
-    const wikiLinks = content.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+    const wikiLinks = textOnly.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
     for (const [, name] of wikiLinks) {
         const resolved = findWikiFile(name.trim(), projectDir);
         if (!resolved)
@@ -160,40 +163,65 @@ function toFileId(absolutePath, projectDir) {
         return path_1.default.relative(projectDir, withMd);
     return null;
 }
+/**
+ * Cache: projectDir → Map<lowercased basename (without .md), absolute path>.
+ * Built once per project via a single recursive walk, then reused for all wiki link lookups.
+ */
+const _wikiIndex = new Map();
+/** Clear cached wiki link index (call when files change or between projects). */
+function clearWikiIndexCache(projectDir) {
+    if (projectDir)
+        _wikiIndex.delete(projectDir);
+    else
+        _wikiIndex.clear();
+}
+function getWikiIndex(projectDir) {
+    if (_wikiIndex.has(projectDir))
+        return _wikiIndex.get(projectDir);
+    const index = new Map();
+    const MAX_DEPTH = 10;
+    function walk(dir, depth) {
+        if (depth >= MAX_DEPTH)
+            return;
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith('.') || entry.isSymbolicLink())
+                continue;
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(full, depth + 1);
+            }
+            else if (entry.isFile()) {
+                // Index by basename without extension (lowercased)
+                const key = path_1.default.basename(entry.name, path_1.default.extname(entry.name)).toLowerCase();
+                if (!index.has(key))
+                    index.set(key, full);
+                // Also index by full filename (lowercased)
+                const fullKey = entry.name.toLowerCase();
+                if (!index.has(fullKey))
+                    index.set(fullKey, full);
+            }
+        }
+    }
+    walk(projectDir, 0);
+    _wikiIndex.set(projectDir, index);
+    return index;
+}
 function findWikiFile(name, projectDir) {
+    // Direct path check first (fast path)
     const direct = path_1.default.join(projectDir, name);
     if (fs_1.default.existsSync(direct))
         return direct;
     const withMd = direct + '.md';
     if (fs_1.default.existsSync(withMd))
         return withMd;
-    return searchRecursive(name, projectDir);
-}
-const MAX_SEARCH_DEPTH = 10;
-function searchRecursive(name, dir, depth = 0) {
-    if (depth >= MAX_SEARCH_DEPTH)
-        return null;
-    let entries;
-    try {
-        entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return null;
-    }
-    for (const entry of entries) {
-        if (entry.name.startsWith('.'))
-            continue;
-        const full = path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            const found = searchRecursive(name, full, depth + 1);
-            if (found)
-                return found;
-        }
-        else if (entry.isFile()) {
-            if (entry.name === name || entry.name === `${name}.md` || path_1.default.basename(entry.name, '.md') === name) {
-                return full;
-            }
-        }
-    }
-    return null;
+    // Fall back to cached index lookup
+    const index = getWikiIndex(projectDir);
+    return index.get(name.toLowerCase()) ?? index.get(name.toLowerCase() + '.md') ?? null;
 }

package/dist/lib/parsers/languages/registry.js

@@ -48,7 +48,7 @@ function isLanguageSupported(languageName) {
 }
 /** Reusable parser per language (avoids WASM memory leak from creating Parser on every call). */
 const parsers = new Map();
-/** Parse source code with the appropriate language grammar. Returns root node or null. */
+/** Parse source code with the appropriate language grammar. Returns tree (caller must call tree.delete() when done) or null. */
 async function parseSource(code, languageName) {
     const entry = languages.get(languageName);
     if (!entry)
@@ -62,7 +62,7 @@ async function parseSource(code, languageName) {
         parsers.set(languageName, parser);
     }
     const tree = parser.parse(code);
-    return tree?.rootNode ?? null;
+    return tree ?? null;
 }
 /** Get the mapper for a language. Returns undefined for unsupported languages. */
 function getMapper(languageName) {