modular-studio 1.0.5 → 1.1.0

package/dist-server/src/graph/db.js

@@ -0,0 +1,241 @@
+/**
+ * Context Graph — SQLite Storage
+ *
+ * Local-first graph storage with FTS5 for symbol search.
+ * Uses sql.js (WASM SQLite) for browser compatibility.
+ */
+// ── Schema ────────────────────────────────────────────────────────────────────
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS file_nodes (
+  id TEXT PRIMARY KEY,
+  path TEXT NOT NULL UNIQUE,
+  language TEXT NOT NULL,
+  last_modified INTEGER NOT NULL,
+  content_hash TEXT NOT NULL,
+  tokens INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_id TEXT NOT NULL REFERENCES file_nodes(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  signature TEXT,
+  line_start INTEGER NOT NULL,
+  line_end INTEGER NOT NULL,
+  is_exported INTEGER NOT NULL DEFAULT 0,
+  doc TEXT,
+  tokens INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS relations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_file TEXT NOT NULL REFERENCES file_nodes(id) ON DELETE CASCADE,
+  source_symbol TEXT,
+  target_file TEXT NOT NULL REFERENCES file_nodes(id) ON DELETE CASCADE,
+  target_symbol TEXT,
+  kind TEXT NOT NULL,
+  weight REAL NOT NULL DEFAULT 1.0,
+  metadata_json TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_relations_source ON relations(source_file);
+CREATE INDEX IF NOT EXISTS idx_relations_target ON relations(target_file);
+CREATE INDEX IF NOT EXISTS idx_relations_kind ON relations(kind);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);
+CREATE INDEX IF NOT EXISTS idx_file_nodes_path ON file_nodes(path);
+`;
+// ── In-Memory Implementation ──────────────────────────────────────────────────
+// Uses plain Maps for fast access. Can be backed by SQLite for persistence.
+export class GraphDB {
+    nodes = new Map();
+    relations = [];
+    symbolsByFile = new Map();
+    symbolNameIndex = new Map(); // name → file IDs
+    outgoing = new Map();
+    incoming = new Map();
+    /** Get the SQL schema for SQLite persistence */
+    static getSchema() { return SCHEMA; }
+    // ── Node Operations ──────────────────────────────────────────────────────
+    upsertNode(node) {
+        this.nodes.set(node.id, node);
+        this.symbolsByFile.set(node.id, node.symbols);
+        // Update symbol name index
+        for (const sym of node.symbols) {
+            let files = this.symbolNameIndex.get(sym.name);
+            if (!files) {
+                files = new Set();
+                this.symbolNameIndex.set(sym.name, files);
+            }
+            files.add(node.id);
+        }
+    }
+    getNode(id) {
+        return this.nodes.get(id);
+    }
+    getNodeByPath(path) {
+        for (const node of this.nodes.values()) {
+            if (node.path === path)
+                return node;
+        }
+        return undefined;
+    }
+    removeNode(id) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return;
+        // Remove from symbol index
+        for (const sym of node.symbols) {
+            const files = this.symbolNameIndex.get(sym.name);
+            if (files) {
+                files.delete(id);
+                if (files.size === 0)
+                    this.symbolNameIndex.delete(sym.name);
+            }
+        }
+        // Remove relations
+        this.relations = this.relations.filter(r => r.sourceFile !== id && r.targetFile !== id);
+        this.outgoing.delete(id);
+        this.incoming.delete(id);
+        this.rebuildRelationIndexes();
+        this.symbolsByFile.delete(id);
+        this.nodes.delete(id);
+    }
+    getAllNodes() {
+        return Array.from(this.nodes.values());
+    }
+    getNodeCount() {
+        return this.nodes.size;
+    }
+    // ── Relation Operations ───────────────────────────────────────────────────
+    addRelation(rel) {
+        // Deduplicate: same source+target+kind
+        const exists = this.relations.some(r => r.sourceFile === rel.sourceFile &&
+            r.targetFile === rel.targetFile &&
+            r.kind === rel.kind &&
+            r.sourceSymbol === rel.sourceSymbol &&
+            r.targetSymbol === rel.targetSymbol);
+        if (exists)
+            return;
+        this.relations.push(rel);
+        // Update indexes
+        const out = this.outgoing.get(rel.sourceFile) ?? [];
+        out.push(rel);
+        this.outgoing.set(rel.sourceFile, out);
+        const inc = this.incoming.get(rel.targetFile) ?? [];
+        inc.push(rel);
+        this.incoming.set(rel.targetFile, inc);
+    }
+    addRelations(rels) {
+        for (const r of rels)
+            this.addRelation(r);
+    }
+    removeRelationsForSource(fileId) {
+        const before = this.relations.length;
+        this.relations = this.relations.filter(r => r.sourceFile !== fileId);
+        this.rebuildRelationIndexes();
+        return before - this.relations.length;
+    }
+    getOutgoing(fileId) {
+        return this.outgoing.get(fileId) ?? [];
+    }
+    getIncoming(fileId) {
+        return this.incoming.get(fileId) ?? [];
+    }
+    getAllRelations() {
+        return this.relations;
+    }
+    getRelationCount() {
+        return this.relations.length;
+    }
+    // ── Symbol Lookup ─────────────────────────────────────────────────────────
+    findFilesBySymbol(symbolName) {
+        const fileIds = this.symbolNameIndex.get(symbolName);
+        if (!fileIds)
+            return [];
+        return Array.from(fileIds)
+            .map(id => this.nodes.get(id))
+            .filter((n) => n !== undefined);
+    }
+    searchSymbols(query) {
+        const q = query.toLowerCase();
+        const results = [];
+        for (const [fileId, symbols] of this.symbolsByFile) {
+            for (const sym of symbols) {
+                if (sym.name.toLowerCase().includes(q)) {
+                    const file = this.nodes.get(fileId);
+                    if (file)
+                        results.push({ symbol: sym, file });
+                }
+            }
+        }
+        return results.sort((a, b) => {
+            // Exact match first, then prefix, then contains
+            const aExact = a.symbol.name.toLowerCase() === q ? 0 : 1;
+            const bExact = b.symbol.name.toLowerCase() === q ? 0 : 1;
+            if (aExact !== bExact)
+                return aExact - bExact;
+            const aPrefix = a.symbol.name.toLowerCase().startsWith(q) ? 0 : 1;
+            const bPrefix = b.symbol.name.toLowerCase().startsWith(q) ? 0 : 1;
+            return aPrefix - bPrefix;
+        });
+    }
+    getSymbolIndex() {
+        const index = new Map();
+        for (const [name, fileIds] of this.symbolNameIndex) {
+            const files = Array.from(fileIds)
+                .map(id => this.nodes.get(id))
+                .filter((n) => n !== undefined);
+            if (files.length > 0)
+                index.set(name, files);
+        }
+        return index;
+    }
+    // ── Graph Assembly ────────────────────────────────────────────────────────
+    toContextGraph(rootPath) {
+        return {
+            nodes: new Map(this.nodes),
+            relations: [...this.relations],
+            outgoing: new Map(this.outgoing.entries()),
+            incoming: new Map(this.incoming.entries()),
+            symbolIndex: this.getSymbolIndex(),
+            rootPath,
+            lastFullScan: Date.now(),
+            version: 1,
+        };
+    }
+    // ── Stats ─────────────────────────────────────────────────────────────────
+    getStats() {
+        let symbolCount = 0;
+        for (const syms of this.symbolsByFile.values())
+            symbolCount += syms.length;
+        return {
+            nodes: this.nodes.size,
+            symbols: symbolCount,
+            relations: this.relations.length,
+        };
+    }
+    // ── Internal ──────────────────────────────────────────────────────────────
+    rebuildRelationIndexes() {
+        this.outgoing.clear();
+        this.incoming.clear();
+        for (const rel of this.relations) {
+            const out = this.outgoing.get(rel.sourceFile) ?? [];
+            out.push(rel);
+            this.outgoing.set(rel.sourceFile, out);
+            const inc = this.incoming.get(rel.targetFile) ?? [];
+            inc.push(rel);
+            this.incoming.set(rel.targetFile, inc);
+        }
+    }
+    /** Clear all data */
+    clear() {
+        this.nodes.clear();
+        this.relations = [];
+        this.symbolsByFile.clear();
+        this.symbolNameIndex.clear();
+        this.outgoing.clear();
+        this.incoming.clear();
+    }
+}

package/dist-server/src/graph/extractors/code.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Code Relation Extractor — TypeScript / Python
+ *
+ * Extracts: imports, calls, extends, implements, uses_type, tested_by, tests
+ * Regex-based (no Tree-sitter) — matches existing codeIndexer philosophy.
+ */
+import type { FileNode, Relation } from '../types.js';
+/**
+ * Extract all relations from a code file.
+ */
+export declare function extractCodeRelations(file: FileNode, allNodes: FileNode[], content: string): Relation[];
+//# sourceMappingURL=code.d.ts.map

package/dist-server/src/graph/extractors/code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../../../../src/graph/extractors/code.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAA2B,MAAM,aAAa,CAAC;AAuF/E;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAAE,EACpB,OAAO,EAAE,MAAM,GACd,QAAQ,EAAE,CA4KZ"}

package/dist-server/src/graph/extractors/code.js

@@ -0,0 +1,239 @@
+/**
+ * Code Relation Extractor — TypeScript / Python
+ *
+ * Extracts: imports, calls, extends, implements, uses_type, tested_by, tests
+ * Regex-based (no Tree-sitter) — matches existing codeIndexer philosophy.
+ */
+// ── Import Patterns ───────────────────────────────────────────────────────────
+const TS_IMPORT_RE = /import\s+(?:(?:type\s+)?(?:\{[^}]*\}|\*\s+as\s+\w+|\w+)(?:\s*,\s*(?:\{[^}]*\}|\*\s+as\s+\w+|\w+))*\s+from\s+)?['"]([^'"]+)['"]/g;
+const TS_REQUIRE_RE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const TS_DYNAMIC_IMPORT_RE = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+const PY_FROM_IMPORT_RE = /^from\s+([\w.]+)\s+import\b/gm;
+const PY_IMPORT_RE = /^import\s+([\w.]+)/gm;
+// ── Inheritance Patterns ──────────────────────────────────────────────────────
+const TS_EXTENDS_RE = /class\s+\w+(?:<[^>]*>)?\s+extends\s+(\w+)/g;
+const TS_IMPLEMENTS_RE = /class\s+\w+(?:<[^>]*>)?\s+(?:extends\s+\w+(?:<[^>]*>)?\s+)?implements\s+([\w,\s]+)/g;
+const PY_CLASS_INHERIT_RE = /class\s+\w+\(([^)]+)\)/g;
+// ── Test Detection ────────────────────────────────────────────────────────────
+const TEST_FILE_PATTERNS = [
+    /\.test\.[tj]sx?$/,
+    /\.spec\.[tj]sx?$/,
+    /__tests__\//,
+    /test_[\w]+\.py$/,
+    /[\w]+_test\.py$/,
+];
+const TEST_CONTENT_MARKERS = /\b(describe|it|test|expect|assert|def test_|class Test)\b/;
+const COMMON_IDENTIFIERS = new Set([
+    'get', 'set', 'map', 'filter', 'reduce', 'find', 'forEach', 'push', 'pop',
+    'shift', 'unshift', 'slice', 'splice', 'concat', 'join', 'split', 'trim',
+    'toString', 'valueOf', 'hasOwnProperty', 'keys', 'values', 'entries',
+    'then', 'catch', 'finally', 'resolve', 'reject', 'log', 'error', 'warn',
+    'next', 'done', 'run', 'start', 'stop', 'open', 'close', 'read', 'write',
+    'init', 'reset', 'clear', 'update', 'delete', 'create', 'remove', 'add',
+    'length', 'size', 'name', 'type', 'value', 'data', 'result', 'status',
+    'self', 'cls', 'super', 'this', 'print', 'len', 'range', 'str', 'int',
+]);
+/**
+ * Resolve a relative import path to match against known file paths.
+ * Normalizes: './utils/helper' → 'utils/helper'
+ */
+function normalizeImportPath(importPath, sourceDir) {
+    if (importPath.startsWith('.')) {
+        const parts = sourceDir.split('/');
+        for (const segment of importPath.split('/')) {
+            if (segment === '.')
+                continue;
+            if (segment === '..') {
+                parts.pop();
+                continue;
+            }
+            parts.push(segment);
+        }
+        return parts.join('/');
+    }
+    return importPath;
+}
+/**
+ * Try to match an import path to a FileNode.
+ */
+function resolveImportTarget(importPath, sourceFile, allNodes) {
+    const sourceDir = sourceFile.path.split('/').slice(0, -1).join('/');
+    const normalized = normalizeImportPath(importPath, sourceDir);
+    // Try exact match, then with extensions
+    const candidates = [
+        normalized,
+        normalized + '.ts', normalized + '.tsx',
+        normalized + '.js', normalized + '.jsx',
+        normalized + '.py',
+        normalized + '/index.ts', normalized + '/index.js',
+        normalized + '/index.tsx',
+    ];
+    for (const candidate of candidates) {
+        const match = allNodes.find(n => n.path === candidate || n.path.endsWith('/' + candidate));
+        if (match)
+            return match;
+    }
+    return undefined;
+}
+/**
+ * Extract all relations from a code file.
+ */
+export function extractCodeRelations(file, allNodes, content) {
+    const relations = [];
+    if (file.language !== 'typescript' && file.language !== 'python') {
+        return relations;
+    }
+    // ── Imports ────────────────────────────────────────────────────────────────
+    const importPatterns = file.language === 'typescript'
+        ? [TS_IMPORT_RE, TS_REQUIRE_RE, TS_DYNAMIC_IMPORT_RE]
+        : [PY_FROM_IMPORT_RE, PY_IMPORT_RE];
+    for (const pattern of importPatterns) {
+        pattern.lastIndex = 0;
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            const importPath = match[1];
+            if (!importPath)
+                continue;
+            // Skip node_modules / external packages
+            if (!importPath.startsWith('.') && !importPath.startsWith('/') && file.language === 'typescript')
+                continue;
+            const target = resolveImportTarget(importPath, file, allNodes);
+            if (target && target.id !== file.id) {
+                const isDynamic = pattern === TS_DYNAMIC_IMPORT_RE;
+                relations.push({
+                    sourceFile: file.id,
+                    targetFile: target.id,
+                    kind: 'imports',
+                    weight: isDynamic ? 0.7 : 1.0,
+                });
+            }
+        }
+    }
+    // ── Extends / Implements ───────────────────────────────────────────────────
+    const inheritancePatterns = file.language === 'typescript'
+        ? [
+            { re: TS_EXTENDS_RE, kind: 'extends' },
+            { re: TS_IMPLEMENTS_RE, kind: 'implements' },
+        ]
+        : [{ re: PY_CLASS_INHERIT_RE, kind: 'extends' }];
+    for (const { re, kind } of inheritancePatterns) {
+        re.lastIndex = 0;
+        let match;
+        while ((match = re.exec(content)) !== null) {
+            const names = match[1].split(',').map(s => s.trim()).filter(Boolean);
+            for (const name of names) {
+                if (name === 'object' || name === 'Object')
+                    continue;
+                const targetFiles = allNodes.filter(n => n.id !== file.id &&
+                    n.symbols.some(s => s.name === name && s.isExported));
+                for (const target of targetFiles) {
+                    relations.push({
+                        sourceFile: file.id,
+                        sourceSymbol: undefined,
+                        targetFile: target.id,
+                        targetSymbol: name,
+                        kind,
+                        weight: 0.9,
+                    });
+                }
+            }
+        }
+    }
+    // ── Calls ──────────────────────────────────────────────────────────────────
+    // Build index of all exported symbols across all files (excluding this file)
+    const exportedSymbols = new Map();
+    for (const node of allNodes) {
+        if (node.id === file.id)
+            continue;
+        for (const sym of node.symbols) {
+            if (!sym.isExported)
+                continue;
+            if (sym.kind !== 'function' && sym.kind !== 'const' && sym.kind !== 'class')
+                continue;
+            const arr = exportedSymbols.get(sym.name) ?? [];
+            arr.push({ file: node, symbol: sym });
+            exportedSymbols.set(sym.name, arr);
+        }
+    }
+    // Scan for function calls: identifier followed by (
+    const CALL_RE = /\b(\w+)\s*\(/g;
+    CALL_RE.lastIndex = 0;
+    let callMatch;
+    const seenCalls = new Set();
+    while ((callMatch = CALL_RE.exec(content)) !== null) {
+        const name = callMatch[1];
+        if (!name || COMMON_IDENTIFIERS.has(name))
+            continue;
+        if (name.length < 3)
+            continue;
+        if (/^[A-Z_]+$/.test(name))
+            continue; // ALL_CAPS constants
+        if (/^(if|for|while|switch|catch|return|new|throw|typeof|instanceof|void|delete|await|async)$/.test(name))
+            continue;
+        const targets = exportedSymbols.get(name);
+        if (!targets)
+            continue;
+        for (const { file: targetFile } of targets) {
+            const key = `${file.id}→${targetFile.id}:${name}`;
+            if (seenCalls.has(key))
+                continue;
+            seenCalls.add(key);
+            // Only count if we actually import from that file
+            const hasImport = relations.some(r => r.sourceFile === file.id && r.targetFile === targetFile.id && r.kind === 'imports');
+            relations.push({
+                sourceFile: file.id,
+                targetFile: targetFile.id,
+                sourceSymbol: undefined,
+                targetSymbol: name,
+                kind: 'calls',
+                weight: hasImport ? 0.9 : 0.5,
+            });
+        }
+    }
+    // ── Test Relations ─────────────────────────────────────────────────────────
+    const isTestFile = TEST_FILE_PATTERNS.some(p => p.test(file.path)) ||
+        TEST_CONTENT_MARKERS.test(content);
+    if (isTestFile) {
+        // Find source files this test imports
+        for (const rel of relations) {
+            if (rel.kind === 'imports') {
+                const target = allNodes.find(n => n.id === rel.targetFile);
+                if (target && !TEST_FILE_PATTERNS.some(p => p.test(target.path))) {
+                    relations.push({
+                        sourceFile: file.id,
+                        targetFile: target.id,
+                        kind: 'tests',
+                        weight: 1.0,
+                    });
+                    relations.push({
+                        sourceFile: target.id,
+                        targetFile: file.id,
+                        kind: 'tested_by',
+                        weight: 1.0,
+                    });
+                }
+            }
+        }
+        // Also match by filename convention: payment.test.ts → payment.ts
+        const baseName = file.path
+            .replace(/\.test\.[tj]sx?$/, '')
+            .replace(/\.spec\.[tj]sx?$/, '')
+            .replace(/__tests__\//, '');
+        for (const node of allNodes) {
+            if (node.id === file.id)
+                continue;
+            const nodeName = node.path.replace(/\.[^.]+$/, '');
+            if (nodeName === baseName || node.path === baseName + '.ts' || node.path === baseName + '.tsx') {
+                if (!relations.some(r => r.sourceFile === file.id && r.targetFile === node.id && r.kind === 'tests')) {
+                    relations.push({
+                        sourceFile: file.id, targetFile: node.id, kind: 'tests', weight: 0.8,
+                    });
+                    relations.push({
+                        sourceFile: node.id, targetFile: file.id, kind: 'tested_by', weight: 0.8,
+                    });
+                }
+            }
+        }
+    }
+    return relations;
+}

package/dist-server/src/graph/extractors/cross-type.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cross-Type Relation Extractor
+ *
+ * Extracts: documents
+ * Bridges markdown docs ↔ code files based on directory co-location and
+ * explicit backtick mentions.
+ */
+import type { FileNode, Relation } from '../types.js';
+/**
+ * Extract cross-type relations from any file.
+ *
+ * Rule 1: README.md → 'documents' all code files in the same directory (weight 0.7)
+ * Rule 2: Backtick `filename.ext` mentions → 'documents' the referenced file (weight 0.6)
+ */
+export declare function extractCrossTypeRelations(node: FileNode, allNodes: FileNode[], content: string): Relation[];
+//# sourceMappingURL=cross-type.d.ts.map

package/dist-server/src/graph/extractors/cross-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-type.d.ts","sourceRoot":"","sources":["../../../../src/graph/extractors/cross-type.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAsBtD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAAE,EACpB,OAAO,EAAE,MAAM,GACd,QAAQ,EAAE,CA6CZ"}

package/dist-server/src/graph/extractors/cross-type.js

@@ -0,0 +1,67 @@
+/**
+ * Cross-Type Relation Extractor
+ *
+ * Extracts: documents
+ * Bridges markdown docs ↔ code files based on directory co-location and
+ * explicit backtick mentions.
+ */
+// ── Patterns ──────────────────────────────────────────────────────────────────
+// Backtick-quoted token that looks like a filename (has an extension)
+const BACKTICK_FILE_RE = /`([^`\n\r\s][^`\n\r]*?\.(?:ts|tsx|js|jsx|py|md|json|yaml|yml))`/g;
+// File extensions that represent actual source/config files (not common words)
+const CODE_EXT_RE = /\.(?:ts|tsx|js|jsx|py)$/;
+// ── Helpers ───────────────────────────────────────────────────────────────────
+function dirOf(path) {
+    return path.split('/').slice(0, -1).join('/');
+}
+function baseNameOf(path) {
+    return path.split('/').pop() ?? '';
+}
+// ── Main Extractor ────────────────────────────────────────────────────────────
+/**
+ * Extract cross-type relations from any file.
+ *
+ * Rule 1: README.md → 'documents' all code files in the same directory (weight 0.7)
+ * Rule 2: Backtick `filename.ext` mentions → 'documents' the referenced file (weight 0.6)
+ */
+export function extractCrossTypeRelations(node, allNodes, content) {
+    const relations = [];
+    const nodeDir = dirOf(node.path);
+    const seen = new Set();
+    function addDocs(targetId, weight) {
+        const key = `${node.id}→${targetId}:documents`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        relations.push({ sourceFile: node.id, targetFile: targetId, kind: 'documents', weight });
+    }
+    // ── Rule 1: README documents sibling code files ───────────────────────────
+    const fileName = baseNameOf(node.path).toLowerCase();
+    if (fileName === 'readme.md') {
+        for (const other of allNodes) {
+            if (other.id === node.id)
+                continue;
+            if (dirOf(other.path) !== nodeDir)
+                continue;
+            if (!CODE_EXT_RE.test(other.path))
+                continue;
+            addDocs(other.id, 0.7);
+        }
+    }
+    // ── Rule 2: Backtick-quoted filename mentions ─────────────────────────────
+    BACKTICK_FILE_RE.lastIndex = 0;
+    let match;
+    while ((match = BACKTICK_FILE_RE.exec(content)) !== null) {
+        const raw = match[1].trim();
+        if (!raw || /\s/.test(raw))
+            continue; // skip if contains spaces
+        // Match against known nodes: by exact path, path suffix, or basename
+        const target = allNodes.find(n => n.id !== node.id && (n.path === raw ||
+            n.path.endsWith('/' + raw) ||
+            baseNameOf(n.path) === raw));
+        if (!target)
+            continue;
+        addDocs(target.id, 0.6);
+    }
+    return relations;
+}

package/dist-server/src/graph/extractors/markdown.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Markdown Relation Extractor
+ *
+ * Extracts: links_to, references, supersedes, continues, defined_in, depends_on
+ */
+import type { FileNode, Relation } from '../types.js';
+/**
+ * Collect all defined terms across markdown files.
+ * Returns: Map<term (lowercase), { file, originalTerm }>
+ */
+export declare function collectDefinedTerms(mdNodes: FileNode[]): Map<string, {
+    file: FileNode;
+    term: string;
+}>;
+/**
+ * Extract all relations from a markdown file.
+ */
+export declare function extractMarkdownRelations(file: FileNode, allNodes: FileNode[], content: string): Relation[];
+/**
+ * Extract markdown symbols (headings + defined terms) for FileNode.symbols.
+ */
+export declare function extractMarkdownSymbols(content: string): Array<{
+    name: string;
+    kind: 'heading' | 'definition';
+    lineStart: number;
+    lineEnd: number;
+    isExported: boolean;
+}>;
+//# sourceMappingURL=markdown.d.ts.map

package/dist-server/src/graph/extractors/markdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../../src/graph/extractors/markdown.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAkEtD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,QAAQ,EAAE,GAClB,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAkB/C;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,QAAQ,EAAE,EACpB,OAAO,EAAE,MAAM,GACd,QAAQ,EAAE,CAyHZ;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,GAAG,YAAY,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC,CAwCD"}