hyacinth-ai 0.9.6

package/dist/tools/xref/parser.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 文件解析器接口与注册中心。
+ *
+ * 每种语言可以有多个解析器（按优先级排序）：
+ *   - TsParser: TypeScript/JavaScript AST 解析（调用 ts.createSourceFile）
+ *   - TsRegexParser: 当 TS compiler 不可用时的正则回退
+ *   - PyParser: Python 正则解析
+ *   - GenericParser: 通用括号匹配回退
+ */
+import type { ParsedFile } from './schema.js';
+export interface FileParser {
+    /** 解析器名称（用于日志） */
+    readonly name: string;
+    /** 支持的文件扩展名 */
+    readonly extensions: string[];
+    /** 解析单个文件 */
+    parseFile(filePath: string): Promise<ParsedFile>;
+}
+/**
+ * ParserRegistry — 按文件扩展名选择最佳解析器。
+ */
+export declare class ParserRegistry {
+    private parsers;
+    register(parser: FileParser): void;
+    /** 获取适合该文件的解析器（按注册顺序，优先返回第一个匹配） */
+    getParser(filePath: string): FileParser | null;
+    /** 获取所有已注册的扩展名 */
+    getAllExtensions(): string[];
+}
+/**
+ * 创建默认的解析器注册中心（尝试加载 TS parser，失败则使用正则回退）。
+ */
+export declare function createParserRegistry(): Promise<ParserRegistry>;
+//# sourceMappingURL=parser.d.ts.map

package/dist/tools/xref/parser.js

@@ -0,0 +1,64 @@
+/**
+ * 文件解析器接口与注册中心。
+ *
+ * 每种语言可以有多个解析器（按优先级排序）：
+ *   - TsParser: TypeScript/JavaScript AST 解析（调用 ts.createSourceFile）
+ *   - TsRegexParser: 当 TS compiler 不可用时的正则回退
+ *   - PyParser: Python 正则解析
+ *   - GenericParser: 通用括号匹配回退
+ */
+import path from 'node:path';
+/**
+ * ParserRegistry — 按文件扩展名选择最佳解析器。
+ */
+export class ParserRegistry {
+    parsers = [];
+    register(parser) {
+        this.parsers.push(parser);
+    }
+    /** 获取适合该文件的解析器（按注册顺序，优先返回第一个匹配） */
+    getParser(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        for (const parser of this.parsers) {
+            if (parser.extensions.includes(ext))
+                return parser;
+        }
+        return null;
+    }
+    /** 获取所有已注册的扩展名 */
+    getAllExtensions() {
+        return [...new Set(this.parsers.flatMap(p => p.extensions))];
+    }
+}
+/**
+ * 创建默认的解析器注册中心（尝试加载 TS parser，失败则使用正则回退）。
+ */
+export async function createParserRegistry() {
+    const registry = new ParserRegistry();
+    // 尝试加载 TypeScript AST 解析器
+    try {
+        const { TsParser } = await import('./ts-parser.js');
+        registry.register(new TsParser());
+    }
+    catch {
+        // TypeScript 不可用，使用正则回退
+        try {
+            const { TsRegexParser } = await import('./regex-parser.js');
+            registry.register(new TsRegexParser());
+        }
+        catch {
+            // 忽略
+        }
+    }
+    // 正则回退解析器（总是可用）
+    try {
+        const { PyParser, GenericParser } = await import('./regex-parser.js');
+        registry.register(new PyParser());
+        registry.register(new GenericParser());
+    }
+    catch {
+        // 忽略
+    }
+    return registry;
+}
+//# sourceMappingURL=parser.js.map

package/dist/tools/xref/regex-parser.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 正则回退解析器 — 当 TypeScript 编译器 API 不可用时使用。
+ *
+ * 覆盖：
+ *   - TsRegexParser: TypeScript/JavaScript (正则版)
+ *   - PyParser:       Python
+ *   - GenericParser:  通用括号匹配（C/Go/Rust/Java 等）
+ */
+import type { FileParser } from './parser.js';
+import type { ParsedFile } from './schema.js';
+export declare class TsRegexParser implements FileParser {
+    readonly name = "ts-regex";
+    readonly extensions: string[];
+    parseFile(filePath: string): Promise<ParsedFile>;
+}
+export declare class PyParser implements FileParser {
+    readonly name = "py-regex";
+    readonly extensions: string[];
+    parseFile(filePath: string): Promise<ParsedFile>;
+}
+export declare class GenericParser implements FileParser {
+    readonly name = "generic-regex";
+    readonly extensions: string[];
+    parseFile(filePath: string): Promise<ParsedFile>;
+}
+//# sourceMappingURL=regex-parser.d.ts.map

package/dist/tools/xref/regex-parser.js

@@ -0,0 +1,446 @@
+/**
+ * 正则回退解析器 — 当 TypeScript 编译器 API 不可用时使用。
+ *
+ * 覆盖：
+ *   - TsRegexParser: TypeScript/JavaScript (正则版)
+ *   - PyParser:       Python
+ *   - GenericParser:  通用括号匹配（C/Go/Rust/Java 等）
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+// ── 通用工具 ──────────────────────────────────────────────────────────
+const JS_KEYWORDS = new Set([
+    'if', 'else', 'for', 'while', 'do', 'switch', 'case', 'break', 'continue',
+    'return', 'throw', 'try', 'catch', 'finally', 'new', 'typeof', 'instanceof',
+    'void', 'delete', 'in', 'of', 'async', 'await', 'yield', 'static', 'get', 'set',
+    'import', 'export', 'from', 'as', 'class', 'function', 'const', 'let', 'var',
+    'interface', 'type', 'extends', 'implements', 'abstract', 'override',
+    'public', 'private', 'protected', 'readonly', 'declare',
+    'true', 'false', 'null', 'undefined', 'this', 'super',
+    'console', 'require', 'process', 'global',
+    'parseInt', 'parseFloat', 'isNaN', 'JSON', 'Math',
+    'Object', 'Array', 'String', 'Number', 'Boolean', 'Promise', 'Map', 'Set',
+    'Error', 'Date', 'RegExp', 'Symbol', 'parseInt', 'setTimeout', 'setInterval',
+]);
+function isKeyword(name) {
+    return JS_KEYWORDS.has(name) || name.length <= 1;
+}
+// ── TsRegexParser: TS/JS 正则回退 ─────────────────────────────────────
+export class TsRegexParser {
+    name = 'ts-regex';
+    extensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.mts', '.cts'];
+    async parseFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const hash = crypto.createHash('md5').update(content).digest('hex').slice(0, 12);
+        const lines = content.split('\n');
+        const ext = path.extname(filePath).toLowerCase();
+        const symbols = [];
+        const refs = [];
+        const imports = [];
+        // ── 解析 import 语句 ──
+        const importRegex = /import\s+(?:type\s+)?(?:\{([^}]*)\}|\*\s+as\s+(\w+)|(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+        for (const m of content.matchAll(importRegex)) {
+            const modulePath = m[4];
+            const syms = [];
+            if (m[1])
+                syms.push(...m[1].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean));
+            if (m[2])
+                syms.push(m[2]);
+            if (m[3])
+                syms.push(m[3]);
+            if (modulePath.startsWith('.')) {
+                imports.push({ to_path: modulePath, symbols: syms, import_type: 'static' });
+            }
+        }
+        // require
+        const requireRegex = /(?:const|let|var)\s+(?:\{([^}]*)\}|(\w+))\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+        for (const m of content.matchAll(requireRegex)) {
+            const modulePath = m[3];
+            const syms = [];
+            if (m[1])
+                syms.push(...m[1].split(',').map(s => s.trim()).filter(Boolean));
+            if (m[2])
+                syms.push(m[2]);
+            if (modulePath.startsWith('.')) {
+                imports.push({ to_path: modulePath, symbols: syms, import_type: 'require' });
+            }
+        }
+        // ── 解析函数/类/变量定义 ──
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const lineNum = i + 1;
+            const trimmed = line.trim();
+            // export function / async function / function
+            let m = trimmed.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+            if (m) {
+                symbols.push({
+                    name: m[1], kind: 'function', line: lineNum, col: line.indexOf(m[1]),
+                    signature: trimmed, is_exported: trimmed.startsWith('export'),
+                });
+                continue;
+            }
+            // export class / class
+            m = trimmed.match(/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/);
+            if (m) {
+                const extendsMatch = trimmed.match(/extends\s+([\w.,\s]+?)(?:\s*\{|\s*$)/);
+                symbols.push({
+                    name: m[1], kind: 'class', line: lineNum, col: line.indexOf(m[1]),
+                    signature: trimmed, is_exported: trimmed.startsWith('export'),
+                });
+                if (extendsMatch) {
+                    for (const parent of extendsMatch[1].split(',')) {
+                        const pName = parent.trim();
+                        if (pName)
+                            refs.push({ symbol_name: pName, line: lineNum, col: line.indexOf(pName), kind: 'inherit', context: trimmed });
+                    }
+                }
+                continue;
+            }
+            // export interface
+            m = trimmed.match(/^(?:export\s+)?interface\s+(\w+)/);
+            if (m) {
+                symbols.push({
+                    name: m[1], kind: 'interface', line: lineNum, col: line.indexOf(m[1]),
+                    signature: trimmed, is_exported: trimmed.startsWith('export'),
+                });
+                continue;
+            }
+            // export type
+            m = trimmed.match(/^(?:export\s+)?type\s+(\w+)/);
+            if (m) {
+                symbols.push({
+                    name: m[1], kind: 'type', line: lineNum, col: line.indexOf(m[1]),
+                    signature: trimmed, is_exported: trimmed.startsWith('export'),
+                });
+                continue;
+            }
+            // export enum
+            m = trimmed.match(/^(?:export\s+)?enum\s+(\w+)/);
+            if (m) {
+                symbols.push({
+                    name: m[1], kind: 'enum', line: lineNum, col: line.indexOf(m[1]),
+                    signature: trimmed, is_exported: trimmed.startsWith('export'),
+                });
+                continue;
+            }
+            // const/let/var with arrow function or function expression
+            m = trimmed.match(/^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[:=]/);
+            if (m) {
+                const isArrow = /(?:=\s*(?:async\s*)?\([^)]*\)\s*=>|=\s*(?:async\s+)?function\b)/.test(trimmed);
+                const isExported = trimmed.startsWith('export');
+                symbols.push({
+                    name: m[1],
+                    kind: isArrow ? 'arrow' : 'variable',
+                    line: lineNum,
+                    col: line.indexOf(m[1]),
+                    signature: trimmed,
+                    is_exported: isExported,
+                });
+                continue;
+            }
+        }
+        // ── 解析调用引用 ──
+        const callRegex = /(?:(\w+)\.)?(\w+)\s*\(/g;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (/^\s*(?:\/\/|\*|\/\*|import|export)/.test(line.trim()))
+                continue;
+            for (const cm of line.matchAll(callRegex)) {
+                const name = cm[2];
+                if (isKeyword(name))
+                    continue;
+                refs.push({
+                    symbol_name: name,
+                    line: i + 1,
+                    col: cm.index ?? 0,
+                    kind: 'call',
+                    context: line.trim().slice(0, 120),
+                });
+            }
+            // new expressions
+            for (const nm of line.matchAll(/new\s+(\w+)/g)) {
+                if (!isKeyword(nm[1])) {
+                    refs.push({
+                        symbol_name: nm[1],
+                        line: i + 1,
+                        col: nm.index ?? 0,
+                        kind: 'new',
+                        context: line.trim().slice(0, 120),
+                    });
+                }
+            }
+        }
+        return {
+            path: filePath,
+            language: ext === '.ts' || ext === '.tsx' ? 'typescript' : 'javascript',
+            symbols, refs, imports, hash,
+        };
+    }
+}
+// ── PyParser: Python 正则解析 ─────────────────────────────────────────
+export class PyParser {
+    name = 'py-regex';
+    extensions = ['.py', '.pyi', '.pyx'];
+    async parseFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const hash = crypto.createHash('md5').update(content).digest('hex').slice(0, 12);
+        const lines = content.split('\n');
+        const symbols = [];
+        const refs = [];
+        const imports = [];
+        // ── import 语句 ──
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            // from .xxx import yyy
+            let m = trimmed.match(/^from\s+(\.\S+)\s+import\s+(.+)/);
+            if (m) {
+                const toPath = m[1];
+                const syms = m[2].split(',').map(s => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+                imports.push({ to_path: toPath, symbols: syms, import_type: 'static' });
+                continue;
+            }
+            // import xxx (non-relative, record for symbol search)
+            m = trimmed.match(/^import\s+(\S+)/);
+            if (m && !m[1].startsWith('.')) {
+                // 标准库或第三方，只记录符号
+                const imported = m[1].split(',')[0].trim();
+                symbols.push({
+                    name: imported, kind: 'variable', line: i + 1, col: 7,
+                    signature: trimmed, is_exported: false,
+                });
+                continue;
+            }
+        }
+        // ── 函数/类定义 ──
+        for (let i = 0; i < lines.length; i++) {
+            const trimmed = lines[i].trim();
+            const lineNum = i + 1;
+            // async def / def
+            let m = trimmed.match(/^(?:async\s+)?def\s+(\w+)/);
+            if (m) {
+                symbols.push({
+                    name: m[1], kind: 'function', line: lineNum, col: trimmed.indexOf(m[1]),
+                    signature: trimmed.split(':')[0].trim(), is_exported: !trimmed.startsWith('_'),
+                });
+                continue;
+            }
+            // class
+            m = trimmed.match(/^class\s+(\w+)/);
+            if (m) {
+                const extendsMatch = trimmed.match(/\(([^)]+)\)/);
+                symbols.push({
+                    name: m[1], kind: 'class', line: lineNum, col: trimmed.indexOf(m[1]),
+                    signature: trimmed.split(':')[0].trim(), is_exported: !trimmed.startsWith('_'),
+                });
+                if (extendsMatch) {
+                    for (const parent of extendsMatch[1].split(',')) {
+                        const pName = parent.trim();
+                        if (pName && pName !== 'object') {
+                            refs.push({ symbol_name: pName, line: lineNum, col: trimmed.indexOf(pName), kind: 'inherit', context: trimmed });
+                        }
+                    }
+                }
+                continue;
+            }
+        }
+        // ── 调用引用 ──
+        const callRegex = /(?:(\w+)\.)?(\w+)\s*\(/g;
+        const pyBuiltins = new Set([
+            'print', 'len', 'range', 'type', 'int', 'str', 'float', 'bool', 'list', 'dict',
+            'set', 'tuple', 'open', 'isinstance', 'hasattr', 'getattr', 'setattr', 'super',
+            'enumerate', 'zip', 'map', 'filter', 'sorted', 'reversed', 'any', 'all', 'sum',
+            'min', 'max', 'abs', 'round', 'input', 'next', 'iter', 'id', 'dir', 'vars',
+            'staticmethod', 'classmethod', 'property', 'Exception', 'ValueError', 'TypeError',
+            'self', 'cls', 'True', 'False', 'None',
+        ]);
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (/^\s*(?:#|from\s|import\s)/.test(line.trim()))
+                continue;
+            for (const cm of line.matchAll(callRegex)) {
+                const name = cm[2];
+                if (pyBuiltins.has(name) || name.length <= 1 || name[0] === '_')
+                    continue;
+                refs.push({
+                    symbol_name: name,
+                    line: i + 1,
+                    col: cm.index ?? 0,
+                    kind: 'call',
+                    context: line.trim().slice(0, 120),
+                });
+            }
+        }
+        return {
+            path: filePath,
+            language: 'python',
+            symbols, refs, imports, hash,
+        };
+    }
+}
+// ── GenericParser: C/Go/Rust/Java 等 ──────────────────────────────────
+export class GenericParser {
+    name = 'generic-regex';
+    extensions = ['.go', '.rs', '.c', '.h', '.cpp', '.hpp', '.java', '.kt', '.swift'];
+    async parseFile(filePath) {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const hash = crypto.createHash('md5').update(content).digest('hex').slice(0, 12);
+        const lines = content.split('\n');
+        const ext = path.extname(filePath).toLowerCase();
+        const langMap = {
+            '.go': 'go', '.rs': 'rust', '.c': 'c', '.h': 'c',
+            '.cpp': 'cpp', '.hpp': 'cpp', '.java': 'java', '.kt': 'kotlin', '.swift': 'swift',
+        };
+        const language = langMap[ext] ?? 'unknown';
+        const symbols = [];
+        const refs = [];
+        const imports = [];
+        // ── Go ──
+        if (ext === '.go') {
+            for (let i = 0; i < lines.length; i++) {
+                const t = lines[i].trim();
+                const lineNum = i + 1;
+                // import
+                let m = t.match(/^"(\.\S+)"/);
+                if (m) {
+                    imports.push({ to_path: m[1].slice(1, -1), symbols: [], import_type: 'static' });
+                    continue;
+                }
+                // func
+                m = t.match(/^func\s+(?:\(\s*\w+\s+\*?\w+\s*\)\s*)?(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'function', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: /^[A-Z]/.test(m[1]) });
+                    continue;
+                }
+                // type struct / interface
+                m = t.match(/^type\s+(\w+)\s+(struct|interface)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'class', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: /^[A-Z]/.test(m[1]) });
+                    continue;
+                }
+            }
+            // calls
+            for (let i = 0; i < lines.length; i++) {
+                if (/^\s*(?:\/\/|import)/.test(lines[i].trim()))
+                    continue;
+                for (const cm of lines[i].matchAll(/(?:(\w+)\.)?(\w+)\s*\(/g)) {
+                    if (!isKeyword(cm[2])) {
+                        refs.push({ symbol_name: cm[2], line: i + 1, col: cm.index ?? 0, kind: 'call', context: lines[i].trim().slice(0, 120) });
+                    }
+                }
+            }
+        }
+        // ── Rust ──
+        if (ext === '.rs') {
+            for (let i = 0; i < lines.length; i++) {
+                const t = lines[i].trim();
+                const lineNum = i + 1;
+                let m = t.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'function', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: t.startsWith('pub') });
+                    continue;
+                }
+                m = t.match(/^(?:pub\s+)?(?:async\s+)?unsafe\s+fn\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'function', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: t.startsWith('pub') });
+                    continue;
+                }
+                m = t.match(/^(?:pub\s+)?struct\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'class', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: t.startsWith('pub') });
+                    continue;
+                }
+                m = t.match(/^(?:pub\s+)?trait\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'interface', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: t.startsWith('pub') });
+                    continue;
+                }
+            }
+            for (let i = 0; i < lines.length; i++) {
+                if (/^\s*(?:\/\/|\/\/!)/.test(lines[i].trim()))
+                    continue;
+                for (const cm of lines[i].matchAll(/(?:(\w+)::)?(\w+)\s*[(!<]/g)) {
+                    if (!isKeyword(cm[2])) {
+                        refs.push({ symbol_name: cm[2], line: i + 1, col: cm.index ?? 0, kind: 'call', context: lines[i].trim().slice(0, 120) });
+                    }
+                }
+            }
+        }
+        // ── C/C++ ──
+        if (ext === '.c' || ext === '.h' || ext === '.cpp' || ext === '.hpp') {
+            for (let i = 0; i < lines.length; i++) {
+                const t = lines[i].trim();
+                const lineNum = i + 1;
+                // #include (记录为 import)
+                let m = t.match(/^#include\s+"([^"]+)"/);
+                if (m) {
+                    imports.push({ to_path: m[1], symbols: [], import_type: 'static' });
+                    continue;
+                }
+                // function definition (return_type name(...))
+                m = t.match(/^(?:static\s+|inline\s+|virtual\s+|extern\s+)*(?:\w+(?:\s*\*)*\s+)+(\w+)\s*\([^)]*\)\s*(?:const\s*)?\{?/);
+                if (m && !['if', 'while', 'for', 'switch', 'return'].includes(m[1])) {
+                    symbols.push({ name: m[1], kind: 'function', line: lineNum, col: t.indexOf(m[1]), signature: t.split('{')[0]?.trim() ?? t, is_exported: false });
+                    continue;
+                }
+                // class/struct
+                m = t.match(/^(?:class|struct)\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'class', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: false });
+                    continue;
+                }
+            }
+            for (let i = 0; i < lines.length; i++) {
+                if (/^\s*(?:\/\/|\/\*|\*|#)/.test(lines[i].trim()))
+                    continue;
+                for (const cm of lines[i].matchAll(/(?:(\w+)(?:->|\.))?(\w+)\s*\(/g)) {
+                    if (!isKeyword(cm[2])) {
+                        refs.push({ symbol_name: cm[2], line: i + 1, col: cm.index ?? 0, kind: 'call', context: lines[i].trim().slice(0, 120) });
+                    }
+                }
+            }
+        }
+        // ── Java ──
+        if (ext === '.java') {
+            for (let i = 0; i < lines.length; i++) {
+                const t = lines[i].trim();
+                const lineNum = i + 1;
+                // class/interface
+                let m = t.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+|abstract\s+|final\s+)*(?:class|interface)\s+(\w+)/);
+                if (m) {
+                    symbols.push({ name: m[1], kind: 'class', line: lineNum, col: t.indexOf(m[1]), signature: t, is_exported: t.startsWith('public') });
+                    continue;
+                }
+                // method
+                m = t.match(/^(?:public\s+|private\s+|protected\s+)?(?:static\s+|abstract\s+|final\s+|synchronized\s+)*(?:\w+(?:<[^>]*>)?\s+)+(\w+)\s*\(/);
+                if (m && !['if', 'while', 'for', 'switch', 'return', 'throw', 'try', 'catch'].includes(m[1])) {
+                    symbols.push({
+                        name: m[1], kind: 'method', line: lineNum, col: t.indexOf(m[1]),
+                        signature: t.split('{')[0]?.trim() ?? t, is_exported: t.startsWith('public'),
+                    });
+                    continue;
+                }
+            }
+            for (let i = 0; i < lines.length; i++) {
+                if (/^\s*(?:\/\/|\/\*|\*)/.test(lines[i].trim()))
+                    continue;
+                for (const cm of lines[i].matchAll(/(?:(\w+)\.)?(\w+)\s*\(/g)) {
+                    if (!isKeyword(cm[2])) {
+                        refs.push({ symbol_name: cm[2], line: i + 1, col: cm.index ?? 0, kind: 'call', context: lines[i].trim().slice(0, 120) });
+                    }
+                }
+                for (const nm of lines[i].matchAll(/new\s+(\w+)/g)) {
+                    if (!isKeyword(nm[1])) {
+                        refs.push({ symbol_name: nm[1], line: i + 1, col: nm.index ?? 0, kind: 'new', context: lines[i].trim().slice(0, 120) });
+                    }
+                }
+            }
+        }
+        return {
+            path: filePath,
+            language,
+            symbols, refs, imports, hash,
+        };
+    }
+}
+//# sourceMappingURL=regex-parser.js.map

package/dist/tools/xref/schema.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 交叉引用索引 — 类型定义与 SQLite Schema。
+ *
+ * 数据模型：
+ *   files   → 已索引的源文件
+ *   symbols → 符号定义（函数/类/接口/变量等）
+ *   refs    → 符号引用（调用/实例化/读取/继承/导入）
+ *   imports → 文件间导入依赖
+ *   meta    → 元数据（构建时间、项目根目录等）
+ */
+export interface XrefSymbol {
+    id: number;
+    name: string;
+    kind: SymbolKind;
+    file_id: number;
+    line: number;
+    col: number;
+    signature: string | null;
+    is_exported: boolean;
+    parent_name: string | null;
+}
+export interface XrefRef {
+    id: number;
+    symbol_name: string;
+    file_id: number;
+    line: number;
+    col: number;
+    kind: RefKind;
+    context: string | null;
+    caller_name: string | null;
+}
+export interface XrefImport {
+    id: number;
+    from_file_id: number;
+    to_file_id: number;
+    symbols: string[];
+    import_type: 'static' | 'dynamic' | 'require';
+}
+export interface XrefFile {
+    id: number;
+    path: string;
+    language: string;
+    hash: string | null;
+    last_parsed_at: string | null;
+}
+export type SymbolKind = 'function' | 'method' | 'arrow' | 'class' | 'interface' | 'type' | 'enum' | 'variable' | 'parameter' | 'property';
+export type RefKind = 'call' | 'new' | 'read' | 'write' | 'import' | 'inherit' | 'export';
+export type QueryAction = 'refs' | 'defs' | 'callers' | 'callees' | 'deps' | 'dependents' | 'hierarchy' | 'impact' | 'trace' | 'symbol_search';
+export interface QueryParams {
+    action: QueryAction;
+    symbol?: string;
+    file?: string;
+    depth?: number;
+    format?: 'text' | 'json';
+    kind?: SymbolKind;
+}
+export interface BuildStats {
+    files: number;
+    symbols: number;
+    refs: number;
+    imports: number;
+    duration_ms: number;
+    language_breakdown: Record<string, number>;
+}
+export interface ParsedSymbol {
+    name: string;
+    kind: SymbolKind;
+    line: number;
+    col: number;
+    signature?: string;
+    is_exported: boolean;
+    parent_name?: string;
+}
+export interface ParsedRef {
+    symbol_name: string;
+    line: number;
+    col: number;
+    kind: RefKind;
+    context?: string;
+    caller_name?: string;
+}
+export interface ParsedImport {
+    to_path: string;
+    symbols: string[];
+    import_type: 'static' | 'dynamic' | 'require';
+}
+export interface ParsedFile {
+    path: string;
+    language: string;
+    symbols: ParsedSymbol[];
+    refs: ParsedRef[];
+    imports: ParsedImport[];
+    hash: string;
+}
+export type GraphFormat = 'text' | 'mermaid' | 'graphviz';
+export interface GraphOptions {
+    format: GraphFormat;
+    symbol?: string;
+    file?: string;
+    max_depth?: number;
+    direction?: 'callers' | 'callees' | 'both';
+}
+export declare const SCHEMA_DDL = "\nCREATE TABLE IF NOT EXISTS files (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    path TEXT UNIQUE NOT NULL,\n    language TEXT NOT NULL,\n    hash TEXT,\n    last_parsed_at TEXT\n);\n\nCREATE TABLE IF NOT EXISTS symbols (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    name TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL DEFAULT 0,\n    signature TEXT,\n    is_exported INTEGER NOT NULL DEFAULT 0,\n    parent_name TEXT\n);\n\nCREATE TABLE IF NOT EXISTS refs (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    symbol_name TEXT NOT NULL,\n    file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL DEFAULT 0,\n    kind TEXT NOT NULL,\n    context TEXT,\n    caller_name TEXT\n);\n\nCREATE TABLE IF NOT EXISTS imports (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    from_file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,\n    to_file_id INTEGER NOT NULL REFERENCES files(id) ON DELETE CASCADE,\n    symbols TEXT DEFAULT '[]',\n    import_type TEXT DEFAULT 'static'\n);\n\nCREATE TABLE IF NOT EXISTS meta (\n    key TEXT PRIMARY KEY,\n    value TEXT\n);\n\n-- \u67E5\u8BE2\u52A0\u901F\nCREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);\nCREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file_id);\nCREATE INDEX IF NOT EXISTS idx_symbols_kind ON symbols(kind);\nCREATE INDEX IF NOT EXISTS idx_refs_symbol ON refs(symbol_name);\nCREATE INDEX IF NOT EXISTS idx_refs_file ON refs(file_id);\nCREATE INDEX IF NOT EXISTS idx_refs_kind ON refs(kind);\nCREATE INDEX IF NOT EXISTS idx_refs_caller ON refs(caller_name);\nCREATE INDEX IF NOT EXISTS idx_imports_from ON imports(from_file_id);\nCREATE INDEX IF NOT EXISTS idx_imports_to ON imports(to_file_id);\n";
+//# sourceMappingURL=schema.d.ts.map