@graphmemory/server 1.1.0

package/dist/lib/parsers/docs.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFile = parseFile;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const codeblock_1 = require("../../lib/parsers/codeblock");
+// Parse a markdown file into chunks split by headings
+async function parseFile(content, absolutePath, projectDir, chunkDepth) {
+    const fileId = path_1.default.relative(projectDir, absolutePath);
+    const lines = content.split('\n');
+    const rawChunks = [];
+    let current = {
+        level: 1,
+        title: extractFileTitle(content, absolutePath),
+        lines: [],
+    };
+    for (const line of lines) {
+        const heading = matchHeading(line, chunkDepth);
+        if (heading) {
+            rawChunks.push(current);
+            current = { level: heading.level, title: heading.title, lines: [line] };
+        }
+        else {
+            current.lines.push(line);
+        }
+    }
+    rawChunks.push(current);
+    // Build Chunk objects
+    const seenIds = new Set();
+    const textChunks = rawChunks
+        .filter(c => c.lines.join('\n').trim() || c.level === 1)
+        .map(c => {
+        const chunkContent = c.lines.join('\n').trim();
+        const baseId = c.level === 1 ? fileId : `${fileId}::${c.title}`;
+        let id = baseId;
+        let counter = 2;
+        while (seenIds.has(id))
+            id = `${baseId}::${counter++}`;
+        seenIds.add(id);
+        return {
+            id,
+            fileId,
+            title: c.title,
+            content: chunkContent,
+            level: c.level,
+            links: extractLinks(chunkContent, absolutePath, projectDir),
+            embedding: [], // filled later by embedder
+            symbols: [],
+        };
+    });
+    return await spliceCodeBlocks(textChunks, seenIds);
+}
+// --- code block extraction ---
+const FENCE_RE = /^(`{3,}|~{3,})(\S*)\s*\n([\s\S]*?)^\1\s*$/gm;
+async function spliceCodeBlocks(chunks, seenIds) {
+    const result = [];
+    for (const chunk of chunks) {
+        // Skip chunks that are already code blocks (shouldn't happen, but guard)
+        if (chunk.language !== undefined) {
+            result.push(chunk);
+            continue;
+        }
+        const codeBlocks = [];
+        let match;
+        FENCE_RE.lastIndex = 0;
+        while ((match = FENCE_RE.exec(chunk.content)) !== null) {
+            const lang = match[2].toLowerCase();
+            const code = match[3].trimEnd();
+            if (code)
+                codeBlocks.push({ language: lang, code, index: match.index });
+        }
+        result.push(chunk);
+        // Create child chunks for each code block
+        let codeIdx = 0;
+        for (const cb of codeBlocks) {
+            codeIdx++;
+            const baseId = `${chunk.id}::code-${codeIdx}`;
+            let id = baseId;
+            let counter = 2;
+            while (seenIds.has(id))
+                id = `${baseId}::${counter++}`;
+            seenIds.add(id);
+            const lang = cb.language || undefined;
+            const symbols = lang ? await (0, codeblock_1.extractSymbols)(cb.code, lang) : [];
+            result.push({
+                id,
+                fileId: chunk.fileId,
+                title: lang || 'code',
+                content: cb.code,
+                level: chunk.level + 1,
+                links: [],
+                embedding: [],
+                language: lang,
+                symbols,
+            });
+        }
+    }
+    return result;
+}
+// --- helpers ---
+function matchHeading(line, maxDepth) {
+    const match = line.match(/^(#{1,6})\s+(.+)$/);
+    if (!match)
+        return null;
+    const level = match[1].length;
+    if (level < 2 || level > maxDepth)
+        return null; // # is file title, not a chunk split
+    return { level, title: match[2].trim() };
+}
+function extractFileTitle(content, filePath) {
+    const match = content.match(/^#\s+(.+)$/m);
+    if (match)
+        return match[1].trim();
+    return path_1.default.basename(filePath, '.md');
+}
+function extractLinks(content, fromFile, projectDir) {
+    const results = new Set();
+    const fileDir = path_1.default.dirname(fromFile);
+    // [text](./path.md)
+    const mdLinks = content.matchAll(/\[[^\]]*\]\(([^)#\s]+)/g);
+    for (const [, href] of mdLinks) {
+        if (isExternal(href))
+            continue;
+        const resolved = path_1.default.resolve(fileDir, href);
+        const fileId = toFileId(resolved, projectDir);
+        if (fileId)
+            results.add(fileId);
+    }
+    // [[wiki link]] or [[wiki link|alias]]
+    const wikiLinks = content.matchAll(/\[\[([^\]|]+)(?:\|[^\]]+)?\]\]/g);
+    for (const [, name] of wikiLinks) {
+        const resolved = findWikiFile(name.trim(), projectDir);
+        if (!resolved)
+            continue;
+        const fileId = toFileId(resolved, projectDir); // same guard as md links
+        if (fileId)
+            results.add(fileId);
+    }
+    return [...results];
+}
+// Reject anything that looks like an external URL
+function isExternal(href) {
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:\/\//.test(href) // http://, ftp://, mailto://, etc.
+        || href.startsWith('//') // protocol-relative //cdn.example.com
+        || href.startsWith('data:') // data URIs
+        || href.startsWith('mailto:');
+}
+function toFileId(absolutePath, projectDir) {
+    const rel = path_1.default.relative(projectDir, absolutePath);
+    if (rel.startsWith('..') || path_1.default.isAbsolute(rel))
+        return null;
+    if (fs_1.default.existsSync(absolutePath))
+        return rel;
+    // try adding .md
+    const withMd = absolutePath + '.md';
+    if (fs_1.default.existsSync(withMd))
+        return path_1.default.relative(projectDir, withMd);
+    return null;
+}
+function findWikiFile(name, projectDir) {
+    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;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTypescript = exports.initParser = exports.listLanguages = exports.getMapper = exports.parseSource = exports.isLanguageSupported = exports.registerLanguage = void 0;
+var registry_1 = require("./registry");
+Object.defineProperty(exports, "registerLanguage", { enumerable: true, get: function () { return registry_1.registerLanguage; } });
+Object.defineProperty(exports, "isLanguageSupported", { enumerable: true, get: function () { return registry_1.isLanguageSupported; } });
+Object.defineProperty(exports, "parseSource", { enumerable: true, get: function () { return registry_1.parseSource; } });
+Object.defineProperty(exports, "getMapper", { enumerable: true, get: function () { return registry_1.getMapper; } });
+Object.defineProperty(exports, "listLanguages", { enumerable: true, get: function () { return registry_1.listLanguages; } });
+Object.defineProperty(exports, "initParser", { enumerable: true, get: function () { return registry_1.initParser; } });
+var typescript_1 = require("./typescript");
+Object.defineProperty(exports, "registerTypescript", { enumerable: true, get: function () { return typescript_1.registerTypescript; } });
+// Auto-register built-in languages on import
+const typescript_2 = require("./typescript");
+(0, typescript_2.registerTypescript)();

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initParser = initParser;
+exports.registerLanguage = registerLanguage;
+exports.isLanguageSupported = isLanguageSupported;
+exports.parseSource = parseSource;
+exports.getMapper = getMapper;
+exports.listLanguages = listLanguages;
+const path_1 = __importDefault(require("path"));
+/** Map from language name (matching file-lang.ts names) to entry. */
+const languages = new Map();
+/** WASM directory containing grammar .wasm files */
+const WASM_DIR = path_1.default.join(path_1.default.dirname(require.resolve('@vscode/tree-sitter-wasm/package.json')), 'wasm');
+let _initPromise = null;
+/** web-tree-sitter module (lazy loaded) */
+let _wts = null;
+/** Initialize the WASM parser runtime. Must be called before parsing. */
+async function initParser() {
+    if (_wts)
+        return;
+    if (_initPromise)
+        return _initPromise;
+    _initPromise = (async () => {
+        _wts = require('web-tree-sitter');
+        await _wts.Parser.init();
+    })();
+    return _initPromise;
+}
+/** Register a language (sync — only stores metadata). */
+function registerLanguage(name, wasmFile, mapper) {
+    languages.set(name, { wasmFile, language: null, mapper });
+}
+/** Load a language WASM if not already loaded. */
+async function loadLanguage(entry) {
+    if (entry.language)
+        return entry.language;
+    await initParser();
+    const wasmPath = path_1.default.join(WASM_DIR, entry.wasmFile);
+    entry.language = await _wts.Language.load(wasmPath);
+    return entry.language;
+}
+/** Check if a language is registered. */
+function isLanguageSupported(languageName) {
+    return languages.has(languageName);
+}
+/** Parse source code with the appropriate language grammar. Returns root node or null. */
+async function parseSource(code, languageName) {
+    const entry = languages.get(languageName);
+    if (!entry)
+        return null;
+    await initParser();
+    const lang = await loadLanguage(entry);
+    const parser = new _wts.Parser();
+    parser.setLanguage(lang);
+    const tree = parser.parse(code);
+    return tree?.rootNode ?? null;
+}
+/** Get the mapper for a language. Returns undefined for unsupported languages. */
+function getMapper(languageName) {
+    return languages.get(languageName)?.mapper;
+}
+/** List all registered language names. */
+function listLanguages() {
+    return [...languages.keys()];
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,306 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTypescript = registerTypescript;
+const registry_1 = require("./registry");
+/** Get the previous named sibling that is a JSDoc comment. */
+function getDocComment(node) {
+    let prev = node.previousSibling;
+    while (prev && prev.type === 'comment' && !prev.text.startsWith('/**')) {
+        prev = prev.previousSibling;
+    }
+    if (prev && prev.type === 'comment' && prev.text.startsWith('/**')) {
+        return prev.text.trim();
+    }
+    return '';
+}
+/** Build a signature: first line of the node text (truncated to 200 chars). */
+function buildSignature(node) {
+    const text = node.text ?? '';
+    const firstLine = text.split('\n')[0].trim();
+    return firstLine.length > 200 ? firstLine.slice(0, 200) + '…' : firstLine;
+}
+/** Build the full body text for a symbol. Includes JSDoc + node text. */
+function buildBody(node, docComment) {
+    if (docComment) {
+        return docComment + '\n' + node.text;
+    }
+    return node.text ?? '';
+}
+/** Build a signature that includes the JSDoc first line if present. */
+function buildFullSignature(node, docComment) {
+    if (docComment) {
+        const firstDocLine = docComment.split('\n')[0].trim();
+        return firstDocLine;
+    }
+    return buildSignature(node);
+}
+/** Check if a node is inside an export_statement. */
+function isExported(node) {
+    const parent = node.parent;
+    return parent?.type === 'export_statement';
+}
+/** Get the wrapping export_statement if this node is exported, otherwise return the node itself. */
+function getOuterNode(node) {
+    const parent = node.parent;
+    if (parent?.type === 'export_statement')
+        return parent;
+    return node;
+}
+/** Convert tree-sitter 0-based row to 1-based line number. */
+function startLine(node) {
+    return (node.startPosition?.row ?? 0) + 1;
+}
+function endLine(node) {
+    return (node.endPosition?.row ?? 0) + 1;
+}
+// ---------------------------------------------------------------------------
+// Symbol extraction
+// ---------------------------------------------------------------------------
+function extractClassSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    const body = node.childForFieldName('body');
+    // Extract methods
+    const children = [];
+    if (body) {
+        for (const member of body.namedChildren) {
+            if (member.type === 'method_definition') {
+                const methodName = member.childForFieldName('name')?.text ?? '';
+                if (!methodName)
+                    continue;
+                const methodDoc = getDocComment(member);
+                children.push({
+                    name: methodName,
+                    kind: 'method',
+                    signature: buildSignature(member),
+                    docComment: methodDoc,
+                    body: buildBody(member, methodDoc),
+                    startLine: startLine(member),
+                    endLine: endLine(member),
+                    isExported: false,
+                });
+            }
+        }
+    }
+    return {
+        name,
+        kind: 'class',
+        signature: buildFullSignature(outer, doc),
+        docComment: doc,
+        body: buildBody(outer, doc),
+        startLine: startLine(outer),
+        endLine: endLine(outer),
+        isExported: isExported(node),
+        children,
+    };
+}
+function extractFunctionSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    return {
+        name,
+        kind: 'function',
+        signature: buildFullSignature(outer, doc),
+        docComment: doc,
+        body: buildBody(outer, doc),
+        startLine: startLine(outer),
+        endLine: endLine(outer),
+        isExported: isExported(node),
+    };
+}
+function extractInterfaceSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    return {
+        name,
+        kind: 'interface',
+        signature: buildFullSignature(outer, doc),
+        docComment: doc,
+        body: buildBody(outer, doc),
+        startLine: startLine(outer),
+        endLine: endLine(outer),
+        isExported: isExported(node),
+    };
+}
+function extractTypeAliasSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    return {
+        name,
+        kind: 'type',
+        signature: buildFullSignature(outer, doc),
+        docComment: doc,
+        body: buildBody(outer, doc),
+        startLine: startLine(outer),
+        endLine: endLine(outer),
+        isExported: isExported(node),
+    };
+}
+function extractEnumSymbol(node) {
+    const outer = getOuterNode(node);
+    const doc = getDocComment(outer);
+    const name = node.childForFieldName('name')?.text ?? '';
+    return {
+        name,
+        kind: 'enum',
+        signature: buildFullSignature(outer, doc),
+        docComment: doc,
+        body: buildBody(outer, doc),
+        startLine: startLine(outer),
+        endLine: endLine(outer),
+        isExported: isExported(node),
+    };
+}
+function extractVariableSymbols(node, exported) {
+    const outer = exported ? node.parent : node;
+    const doc = getDocComment(outer);
+    const symbols = [];
+    // Find all variable_declarator children
+    for (const child of node.namedChildren) {
+        if (child.type === 'variable_declarator') {
+            const name = child.childForFieldName('name')?.text ?? '';
+            if (!name)
+                continue;
+            const value = child.childForFieldName('value');
+            const isArrow = value?.type === 'arrow_function' || value?.type === 'function_expression';
+            symbols.push({
+                name,
+                kind: isArrow ? 'function' : 'variable',
+                signature: buildFullSignature(outer, doc),
+                docComment: doc,
+                body: buildBody(outer, doc),
+                startLine: startLine(outer),
+                endLine: endLine(outer),
+                isExported: exported,
+            });
+        }
+    }
+    return symbols;
+}
+// ---------------------------------------------------------------------------
+// Main mapper
+// ---------------------------------------------------------------------------
+function processTopLevel(node) {
+    switch (node.type) {
+        case 'function_declaration': {
+            const name = node.childForFieldName('name')?.text;
+            if (!name)
+                return [];
+            return [extractFunctionSymbol(node)];
+        }
+        case 'class_declaration': {
+            const name = node.childForFieldName('name')?.text;
+            if (!name)
+                return [];
+            return [extractClassSymbol(node)];
+        }
+        case 'interface_declaration': {
+            return [extractInterfaceSymbol(node)];
+        }
+        case 'type_alias_declaration': {
+            return [extractTypeAliasSymbol(node)];
+        }
+        case 'enum_declaration': {
+            return [extractEnumSymbol(node)];
+        }
+        case 'lexical_declaration':
+        case 'variable_declaration': {
+            return extractVariableSymbols(node, isExported(node));
+        }
+        case 'export_statement': {
+            // Unwrap: export_statement wraps the actual declaration
+            for (const child of node.namedChildren) {
+                if (child.type === 'comment')
+                    continue;
+                const results = processTopLevel(child);
+                if (results.length > 0)
+                    return results;
+            }
+            return [];
+        }
+        default:
+            return [];
+    }
+}
+const typescriptMapper = {
+    extractSymbols(rootNode) {
+        const symbols = [];
+        for (const child of rootNode.children) {
+            symbols.push(...processTopLevel(child));
+        }
+        return symbols;
+    },
+    extractEdges(rootNode) {
+        const edges = [];
+        function findClasses(node) {
+            if (node.type === 'class_declaration') {
+                const className = node.childForFieldName('name')?.text;
+                if (!className)
+                    return;
+                // Look for class_heritage
+                for (const child of node.namedChildren) {
+                    if (child.type === 'class_heritage') {
+                        for (const clause of child.namedChildren) {
+                            if (clause.type === 'extends_clause') {
+                                // First named child is the base class
+                                for (const c of clause.namedChildren) {
+                                    if (c.type === 'identifier' || c.type === 'type_identifier') {
+                                        edges.push({ fromName: className, toName: c.text, kind: 'extends' });
+                                        break;
+                                    }
+                                }
+                            }
+                            if (clause.type === 'implements_clause') {
+                                for (const c of clause.namedChildren) {
+                                    if (c.type === 'type_identifier' || c.type === 'identifier') {
+                                        edges.push({ fromName: className, toName: c.text, kind: 'implements' });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            for (const child of node.children) {
+                findClasses(child);
+            }
+        }
+        findClasses(rootNode);
+        return edges;
+    },
+    extractImports(rootNode) {
+        const imports = [];
+        for (const child of rootNode.children) {
+            if (child.type === 'import_statement') {
+                const source = child.childForFieldName('source');
+                if (source) {
+                    // Remove quotes from string literal
+                    const specifier = source.text.replace(/^['"]|['"]$/g, '');
+                    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+                        imports.push({ specifier });
+                    }
+                }
+            }
+        }
+        return imports;
+    },
+};
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+let _registered = false;
+function registerTypescript() {
+    if (_registered)
+        return;
+    _registered = true;
+    // TypeScript and TSX share the same mapper
+    (0, registry_1.registerLanguage)('typescript', 'tree-sitter-typescript.wasm', typescriptMapper);
+    (0, registry_1.registerLanguage)('tsx', 'tree-sitter-tsx.wasm', typescriptMapper);
+    // JavaScript and JSX use the same mapper (TS is a superset)
+    (0, registry_1.registerLanguage)('javascript', 'tree-sitter-javascript.wasm', typescriptMapper);
+    (0, registry_1.registerLanguage)('jsx', 'tree-sitter-javascript.wasm', typescriptMapper);
+}