dsh-codegraph-visualizer 0.1.0 → 0.3.0

package/dist/TreeSitterAdapter-C-EWy8br.js

@@ -0,0 +1,631 @@
+import { EdgeId, NodeId } from "./types-BUDxI_00.js";
+import { TREE_SITTER } from "./constants-CQq93l3e.js";
+import { scoped } from "./Logger-DUIJSeNu.js";
+import { inferLayerFromPath } from "./layerUtils-DDm-EsaD.js";
+import { IMPORT_STATEMENT_TYPES, applyTodoMarkers, collectHeritageTargets, extractImportSources, extractSymbolName, maybeCollectCallSite } from "./treeSitterExtractors-B1ybKNrC.js";
+import { createRequire } from "node:module";
+
+//#region src/adapters/TreeSitterAdapter.ts
+const log = scoped("tree-sitter-adapter");
+/**
+* 同步探测「本宿主上是否**存在** AST 分析通道」——给能力位 `astSource` 用
+* （`src/host/prerequisites.ts` 登记探针，`src/host/routes.ts` 接线）。
+*
+* ## 为什么不能直接用 `adapter.isAvailable()`
+*
+* `isAvailable()` 的语义是「解析器**已经**初始化」（`parserCtor !== null`），而初始化发生在
+* 第一次 `parseFile()`/`parseToAst()` 里的 `await this.init()`。插件 `apply()` 时还没有任何
+* 文件被解析过，于是它在**启动后的一整段时间里恒为 false** —— 用它当能力位会让 `/status`
+* 在一个完全正常的宿主上报告「AST 通道不可用」，那是与 `builtin: true` 相反方向但同样虚假的
+* 叙事。能力位回答的是「这条通道存在吗」，不是「它此刻已热了吗」。
+*
+* ## 判据是两条真实探针的**析取**，没有第三条字面量
+*
+*   1. `isAvailable()` —— 已初始化（最强证据，进程生命周期后段基本恒真）；
+*   2. 运行时模块**可解析** —— `web-tree-sitter`（解析器）与 `tree-sitter-wasm`（语法 wasm）
+*      都能被 Node 解析到。缺依赖、装坏、profile 里漏装都会让它变 false。
+*
+* ## 诚实边界
+*
+* 本探针**不能**证明语法 wasm 真的能加载（那是异步 `Language.load()` 的事）。它证明的是
+* 「这两个包在这台宿主上存在」。这个窄化的失败面是刻意接受的：它比 `true` 严格更强
+* （字面量 `true` 在任何安装状态下都为真），而要做到「真的能加载」就必须把
+* `checkPrerequisites` 改成 async，代价是 20 余处同步调用点。
+* 非 Node 环境（理论上不该发生：本适配器只在宿主进程运行）直接返回 `false`。
+*/
+function isTreeSitterRuntimePresent() {
+	if (typeof process === "undefined" || !process.versions?.node) return false;
+	try {
+		const req = createRequire(import.meta.url);
+		req.resolve("web-tree-sitter");
+		req.resolve("tree-sitter-wasm");
+		return true;
+	} catch (e) {
+		log.debug("tree-sitter runtime not resolvable", { error: e });
+		return false;
+	}
+}
+const SUPPORTED_LANGUAGES = [
+	"typescript",
+	"javascript",
+	"python",
+	"java",
+	"rust",
+	"go"
+];
+/**
+* Grammar a file is parsed with. `.tsx` needs the JSX-aware `tsx` build: with the plain
+* `typescript` grammar a component containing `<div>…</div>` produces ERROR nodes and the JSX
+* arrow component is swallowed by the error node, so its symbol never reaches the graph
+* (measured: `hasError: true`, 2 ERROR nodes, 0 arrow functions, vs clean parse with `tsx`).
+* `tree-sitter-wasm` ships both grammars.
+*/
+const GRAMMARS = [...SUPPORTED_LANGUAGES, "tsx"];
+/** Logical language a grammar belongs to — what `detectLanguage` reports (`.tsx` is TypeScript). */
+const LANGUAGE_BY_GRAMMAR = {
+	typescript: "typescript",
+	javascript: "javascript",
+	python: "python",
+	java: "java",
+	rust: "rust",
+	go: "go",
+	tsx: "typescript"
+};
+/** Grammar per file extension — `.tsx` must not fall back to the plain `typescript` grammar. */
+const GRAMMAR_BY_EXTENSION = {
+	".ts": "typescript",
+	".tsx": "tsx",
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".py": "python",
+	".java": "java",
+	".rs": "rust",
+	".go": "go"
+};
+/**
+* Node type → graph symbol kind, **per grammar**. Previously this was one flat set shared by all
+* grammars, which was guesswork: it listed types no supported grammar emits (`struct_declaration`,
+* `const_declaration`) while missing real ones, so Rust functions never reached the graph
+* (`function_item` was absent) and TypeScript variables were labelled `<variable_declaration>`
+* (the *wrapper* was listed instead of `variable_declarator`, the node that actually carries the
+* name).
+*
+* Every entry below was measured against the shipped grammars by
+* `.cycles/probe-grammar-node-types.mjs` (all samples parse with `hasError: false`). A type is
+* listed only when the grammar emits it **and** `extractName` yields a real label for it — a
+* `name` field, a `type` field (`impl_item`), or an identifier child (`assignment`,
+* `let_declaration`). Declaration wrappers are deliberately absent because they carry no name of
+* their own and would enter the graph as `<lexical_declaration>`-style noise:
+* `lexical_declaration`, `variable_declaration`, `var_declaration`, `short_var_declaration`,
+* `type_declaration`, `field_declaration`, plus the `*_body` / `*_type` container nodes.
+*/
+const SYMBOL_NODE_TYPES = (() => {
+	const js = {
+		function_declaration: "function",
+		method_definition: "function",
+		arrow_function: "function",
+		class_declaration: "class",
+		variable_declarator: "variable"
+	};
+	return {
+		typescript: {
+			...js,
+			interface_declaration: "class",
+			enum_declaration: "class",
+			type_alias_declaration: "class"
+		},
+		tsx: {
+			...js,
+			interface_declaration: "class",
+			enum_declaration: "class",
+			type_alias_declaration: "class"
+		},
+		javascript: js,
+		python: {
+			function_definition: "function",
+			class_definition: "class",
+			assignment: "variable"
+		},
+		java: {
+			method_declaration: "function",
+			constructor_declaration: "function",
+			class_declaration: "class",
+			interface_declaration: "class",
+			enum_declaration: "class",
+			variable_declarator: "variable"
+		},
+		rust: {
+			function_item: "function",
+			function_signature_item: "function",
+			closure_expression: "function",
+			struct_item: "class",
+			enum_item: "class",
+			trait_item: "class",
+			impl_item: "class",
+			let_declaration: "variable",
+			const_item: "variable",
+			static_item: "variable"
+		},
+		go: {
+			function_declaration: "function",
+			method_declaration: "function",
+			method_elem: "function",
+			type_spec: "class",
+			type_alias: "class",
+			var_spec: "variable",
+			const_spec: "variable"
+		}
+	};
+})();
+function symbolKindFor(grammar, nodeType) {
+	return SYMBOL_NODE_TYPES[grammar][nodeType] ?? null;
+}
+const COMMENT_NODE_TYPES = new Set([
+	"comment",
+	"line_comment",
+	"block_comment"
+]);
+const TODO_PATTERNS = /\b(TODO|FIXME|HACK|XXX|BUG)\b/g;
+var TreeSitterAdapter = class TreeSitterAdapter {
+	source = "tree-sitter";
+	parserCtor = null;
+	/**
+	* One parser per grammar. A single shared parser with `setLanguage` swapped per file is not safe:
+	* `ensureLanguageLoaded` awaits, so a mixed-language batch (`Promise.all` in `batchScan`) could
+	* apply another file's grammar between the await and the parse. Separate instances make the
+	* language a property of the parser instead of mutable shared state.
+	*/
+	parsers = new Map();
+	languages = new Map();
+	pendingGrammarLoads = new Map();
+	initAttempts = 0;
+	static MAX_INIT_ATTEMPTS = 3;
+	async init() {
+		if (this.parserCtor) return;
+		if (this.initAttempts >= TreeSitterAdapter.MAX_INIT_ATTEMPTS) {
+			log.warn(`TreeSitter init skipped after ${this.initAttempts} failed attempts`);
+			return;
+		}
+		this.initAttempts++;
+		try {
+			const { Parser } = await import("web-tree-sitter");
+			await Parser.init();
+			this.parserCtor = Parser;
+			this.initAttempts = 0;
+			log.info("TreeSitter parser initialized");
+		} catch (e) {
+			log.warn(`Failed to init TreeSitter (attempt ${this.initAttempts}/${TreeSitterAdapter.MAX_INIT_ATTEMPTS})`, e);
+		}
+	}
+	isAvailable() {
+		return this.parserCtor !== null;
+	}
+	getSupportedLanguages() {
+		return SUPPORTED_LANGUAGES;
+	}
+	/** Logical language for a file, or null when the extension is not supported. */
+	detectLanguage(filePath) {
+		const grammar = this.detectGrammar(filePath);
+		return grammar ? LANGUAGE_BY_GRAMMAR[grammar] : null;
+	}
+	/**
+	* Grammar to parse a file with. Longest matching extension wins, so the lookup cannot depend on
+	* the declaration order of `GRAMMAR_BY_EXTENSION`.
+	*/
+	detectGrammar(filePath) {
+		let best = null;
+		let bestLength = 0;
+		for (const [ext, grammar] of Object.entries(GRAMMAR_BY_EXTENSION)) if (ext.length > bestLength && filePath.endsWith(ext)) {
+			best = grammar;
+			bestLength = ext.length;
+		}
+		return best;
+	}
+	/**
+	* Parser for a grammar, loading its wasm once. Concurrent requests for the same grammar share one
+	* in-flight load, so a batch never downloads/compiles the same grammar twice.
+	*/
+	async ensureParser(grammar) {
+		const ready = this.parsers.get(grammar);
+		if (ready) return ready;
+		const inFlight = this.pendingGrammarLoads.get(grammar);
+		if (inFlight) return inFlight;
+		const pending = (async () => {
+			const ctor = this.parserCtor;
+			if (!ctor) return null;
+			try {
+				const language = await this.loadLanguageWasm(grammar);
+				const parser = new ctor();
+				parser.setLanguage(language);
+				this.languages.set(grammar, language);
+				this.parsers.set(grammar, parser);
+				return parser;
+			} catch (e) {
+				log.warn(`Failed to load grammar: ${grammar}`, e);
+				return null;
+			} finally {
+				this.pendingGrammarLoads.delete(grammar);
+			}
+		})();
+		this.pendingGrammarLoads.set(grammar, pending);
+		return pending;
+	}
+	async parseFile(filePath, content) {
+		if (!this.parserCtor) {
+			await this.init();
+			if (!this.parserCtor) return {
+				nodes: [],
+				edges: [],
+				source: "tree-sitter",
+				timestamp: Date.now(),
+				error: "Parser not initialized"
+			};
+		}
+		const grammar = this.detectGrammar(filePath);
+		if (!grammar) return {
+			nodes: [],
+			edges: [],
+			source: "tree-sitter",
+			timestamp: Date.now(),
+			error: `Unsupported file: ${filePath}`
+		};
+		const parser = await this.ensureParser(grammar);
+		if (!parser) return {
+			nodes: [],
+			edges: [],
+			source: "tree-sitter",
+			timestamp: Date.now(),
+			error: `Failed to load ${grammar}`
+		};
+		try {
+			const tree = parser.parse(content);
+			const { nodes, edges, importSources, callSites } = this.extractSymbols(tree.rootNode, filePath, grammar);
+			tree.delete();
+			return {
+				nodes,
+				edges,
+				source: "tree-sitter",
+				timestamp: Date.now(),
+				importsByFile: importSources.length > 0 ? new Map([[filePath, importSources]]) : void 0,
+				callSitesByFile: callSites.length > 0 ? new Map([[filePath, callSites]]) : void 0
+			};
+		} catch (e) {
+			log.warn("parseFile failed", {
+				filePath,
+				error: e
+			});
+			return {
+				nodes: [],
+				edges: [],
+				source: "tree-sitter",
+				timestamp: Date.now(),
+				error: String(e)
+			};
+		}
+	}
+	async batchScan(files) {
+		if (!this.parserCtor) {
+			await this.init();
+			if (!this.parserCtor) return {
+				nodes: [],
+				edges: [],
+				source: "tree-sitter",
+				timestamp: Date.now(),
+				error: "Parser not initialized"
+			};
+		}
+		const allNodes = [];
+		const allEdges = [];
+		const errors = [];
+		/** 文件 → 该文件 import 的模块名（cycle-129 · T1；消费方 FileSystemAdapter 解析成边）。 */
+		const importsByFile = new Map();
+		/** 文件 → 该文件的调用点（T2；消费方 FileSystemAdapter 解析成 `call` 边）。 */
+		const callSitesByFile = new Map();
+		for (let i = 0; i < files.length; i += TREE_SITTER.BATCH_SIZE) {
+			const batch = files.slice(i, i + TREE_SITTER.BATCH_SIZE);
+			const results = await Promise.all(batch.map(async (file) => {
+				const grammar = this.detectGrammar(file.filePath);
+				if (!grammar) return null;
+				const parser = await this.ensureParser(grammar);
+				if (!parser) return null;
+				try {
+					const tree = parser.parse(file.content);
+					const { nodes, edges, importSources, callSites } = this.extractSymbols(tree.rootNode, file.filePath, grammar);
+					tree.delete();
+					return {
+						nodes,
+						edges,
+						filePath: file.filePath,
+						importSources,
+						callSites
+					};
+				} catch (e) {
+					errors.push(`${file.filePath}: ${String(e)}`);
+					return null;
+				}
+			}));
+			for (const result of results) if (result) {
+				allNodes.push(...result.nodes);
+				allEdges.push(...result.edges);
+				if (result.importSources.length > 0) importsByFile.set(result.filePath, result.importSources);
+				callSitesByFile.set(result.filePath, result.callSites);
+			}
+		}
+		log.info(`batchScan: ${files.length} files, ${allNodes.length} nodes, ${allEdges.length} edges, ${errors.length} errors, import-modules ${importsByFile.size} files, call-sites ${callSitesByFile.size} files`);
+		return {
+			nodes: allNodes,
+			edges: allEdges,
+			source: "tree-sitter",
+			timestamp: Date.now(),
+			importsByFile,
+			callSitesByFile,
+			...errors.length > 0 ? { error: errors.join("; ") } : {}
+		};
+	}
+	async loadLanguageWasm(grammar) {
+		const wasmFile = `tree-sitter-${grammar}.wasm`;
+		const { Language } = await import("web-tree-sitter");
+		const candidates = [];
+		if (typeof process !== "undefined" && process.versions?.node) try {
+			const { getWasmPath } = await import("tree-sitter-wasm");
+			candidates.push(getWasmPath(grammar));
+		} catch (e) {
+			log.debug("tree-sitter-wasm not available", { error: e });
+		}
+		candidates.push(wasmFile);
+		for (const path of candidates) try {
+			return await Language.load(path);
+		} catch (e) {
+			log.debug("candidate path failed", {
+				path,
+				error: e
+			});
+		}
+		throw new Error(`Cannot load ${wasmFile} from any candidate path`);
+	}
+	extractSymbols(rootNode, filePath, grammar) {
+		const nodes = [];
+		const edges = [];
+		const visited = new Set();
+		const nodeMap = new Map();
+		const importSources = [];
+		const callSites = [];
+		const extractName = extractSymbolName;
+		const makeId = (node, label) => `${filePath}:${label}:${node.startPosition.row}`;
+		/**
+		* 提取一个 class/interface 声明节点的全部继承目标（cycle-123）。
+		*
+		* 两种语法形态（tree-sitter-typescript 实测，见测试 fixture）：
+		* - `extends_type_clause`：interface 的 extends（直接子节点，`type_identifier` 列表），
+		*   子节点序列为 [extends, ident, ',', ident, ...]；
+		* - `class_heritage`：class 的 extends/implements 容器，内含 `extends_clause`
+		*   （`extends` + type 列表）与 `implements_clause`（`implements` + type 列表）。
+		* - Rust 的 `impl_item` 无继承语义（trait impl 不是继承），不提取。
+		* - Python 的 `class_definition` 用 `argument_list` 表达基类（tree-sitter-python
+		*   的 `superclasses` 字段），一并覆盖（kind 判定走 clause 名单）。
+		*
+		* 返回 `clauseKind`（extends/implements）用于边类型映射：`extends → 'extend'`、
+		* `implements → 'implement'`（与上游 codegraph 的 kind 语义一致）。
+		* 目标统一返回占位 id 策略（消费方造 `${filePath}:<type>:<name>`），由
+		* merger 按 label 归并——避免遍历时序依赖（子符号可能尚未入 nodeMap）。
+		*/
+		/**
+		* import 模块源提取（cycle-129 · T1：原生依赖图的缺口）。
+		*
+		* import_statement（TS/JS）与 import_declaration（Python/Java/Rust use）的
+		* `source` 字段持有模块名字符串。此前 walk 只把 import 节点收成 module 节点
+		* （symbolKindFor 命中 `import_statement: 'module'`），模块字符串被丢弃——
+		* 原生图永远没有 `import` 边，依赖视图（dependencies view）在原生通道上是
+		* 空的。本函数返回去重后的模块名列表（同一模块多次 import 只记一条的输入）。
+		*
+		* 语法形态（各 grammar 实测）：
+		* - TS/JS `import_statement`：`source` 字段是 string 节点（含引号，剥掉）；
+		* - Python `import_statement` / `import_from_statement`：module_name /
+		*   `dotted_name`（无引号）；`relative_import`（from . import x）跳过——
+		*   相对层级语义留待后续（登记为缺口）；
+		* - Rust `use_declaration`：`argument` 字段（scoped_identifier 树），取
+		*   整段文本按 `::` 保留（Rust 路径语义与文件路径不直接对应，消费方
+		*   解析不到就跳过——与「解析不到就跳过」的总策略一致）。
+		* - Java `import_declaration`：`scoped_identifier`/`package` 文本（点分名）。
+		*
+		* 刻意**不在这里解析成文件路径**：模块名 → 文件的映射需要 workspace 上下文
+		* （扩展名歧义、index 解析、tsconfig paths），由 FileSystemAdapter（T2）
+		* 统一裁决——适配器保持「语法事实收集者」，不做语义猜测。
+		*/
+		const walk = (rootNode$1) => {
+			const stack = [{
+				node: rootNode$1,
+				parentId: void 0
+			}];
+			while (stack.length > 0) {
+				const { node, parentId } = stack.pop();
+				if (!node) continue;
+				const nodeType = node.type;
+				if (IMPORT_STATEMENT_TYPES.has(nodeType)) {
+					const sources = extractImportSources(node);
+					if (sources.length > 0) importSources.push(...sources);
+				}
+				const callSite = maybeCollectCallSite(node, nodeType, parentId, parentId ? nodeMap.get(parentId)?.type : void 0);
+				if (callSite) callSites.push(callSite);
+				let graphType = null;
+				const symbolKind = symbolKindFor(grammar, nodeType);
+				if (symbolKind) graphType = symbolKind;
+				let currentParentId = parentId;
+				if (graphType) {
+					const label = extractName(node);
+					const id = makeId(node, label);
+					if (!visited.has(id)) {
+						visited.add(id);
+						const graphNode = {
+							id: NodeId(id),
+							label,
+							type: graphType,
+							filePath,
+							lineNumber: node.startPosition.row + 1,
+							properties: {
+								source: "tree-sitter",
+								nodeType
+							},
+							...parentId ? { parentId: NodeId(parentId) } : {},
+							layer: inferLayerFromPath(filePath)
+						};
+						nodes.push(graphNode);
+						nodeMap.set(id, graphNode);
+						const heritageTargets = collectHeritageTargets(node);
+						if (heritageTargets.length > 0) for (const { clauseKind, targetName } of heritageTargets) {
+							const edgeType = clauseKind === "extends" ? "extend" : "implement";
+							const targetId = NodeId(`${filePath}:<type>:${targetName}`);
+							const selfId = NodeId(id);
+							if (targetName === label) continue;
+							edges.push({
+								id: EdgeId(`tsedge:${id}->${targetId}`),
+								source: selfId,
+								target: targetId,
+								type: edgeType,
+								properties: {
+									edgeOrigin: "ast",
+									edgeLocatable: false,
+									targetName,
+									line: node.startPosition.row + 1
+								}
+							});
+						}
+						if (parentId) {
+							const line = node.startPosition.row + 1;
+							edges.push({
+								id: EdgeId(`tsedge:${parentId}->${id}`),
+								source: NodeId(parentId),
+								target: NodeId(id),
+								type: "contains",
+								properties: {
+									edgeOrigin: "ast",
+									edgeLocatable: true,
+									line
+								}
+							});
+						}
+					}
+					currentParentId = id;
+				}
+				if (COMMENT_NODE_TYPES.has(nodeType)) {
+					const parentNode = parentId ? nodeMap.get(parentId) : void 0;
+					const matches = node.text.match(TODO_PATTERNS);
+					if (parentNode && matches) applyTodoMarkers(parentNode, matches);
+				}
+				for (let i = (node.childCount || 0) - 1; i >= 0; i--) {
+					const child = node.child(i);
+					if (child) stack.push({
+						node: child,
+						parentId: currentParentId
+					});
+				}
+			}
+		};
+		walk(rootNode);
+		return {
+			nodes,
+			edges,
+			importSources: [...new Set(importSources)],
+			callSites
+		};
+	}
+	async parseToAst(filePath, content) {
+		if (!this.parserCtor) {
+			await this.init();
+			if (!this.parserCtor) {
+				log.warn("parseToAst: parser not initialized after init()");
+				return null;
+			}
+		}
+		const grammar = this.detectGrammar(filePath);
+		if (!grammar) {
+			log.warn(`parseToAst: unsupported file extension: ${filePath}`);
+			return null;
+		}
+		const parser = await this.ensureParser(grammar);
+		if (!parser) {
+			log.warn(`parseToAst: failed to load grammar ${grammar}`);
+			return null;
+		}
+		try {
+			const tree = parser.parse(content);
+			const astRoot = this.convertToAstNode(tree.rootNode);
+			tree.delete();
+			return astRoot;
+		} catch (e) {
+			log.warn(`parseToAst: parse failed for ${filePath}:`, e);
+			return null;
+		}
+	}
+	convertToAstNode(rootNode) {
+		const result = {
+			type: rootNode.type,
+			text: rootNode.text,
+			startPosition: {
+				row: rootNode.startPosition.row,
+				column: rootNode.startPosition.column
+			},
+			endPosition: {
+				row: rootNode.endPosition.row,
+				column: rootNode.endPosition.column
+			},
+			children: []
+		};
+		const stack = [];
+		for (let i = (rootNode.childCount || 0) - 1; i >= 0; i--) {
+			const child = rootNode.child(i);
+			if (child) stack.push({
+				tsNode: child,
+				astParent: result
+			});
+		}
+		while (stack.length > 0) {
+			const { tsNode, astParent } = stack.pop();
+			const astNode = {
+				type: tsNode.type,
+				text: tsNode.text,
+				startPosition: {
+					row: tsNode.startPosition.row,
+					column: tsNode.startPosition.column
+				},
+				endPosition: {
+					row: tsNode.endPosition.row,
+					column: tsNode.endPosition.column
+				},
+				children: []
+			};
+			astParent.children.push(astNode);
+			for (let i = (tsNode.childCount || 0) - 1; i >= 0; i--) {
+				const child = tsNode.child(i);
+				if (child) stack.push({
+					tsNode: child,
+					astParent: astNode
+				});
+			}
+		}
+		return result;
+	}
+	destroy() {
+		for (const parser of this.parsers.values()) try {
+			parser.delete();
+		} catch (e) {
+			log.debug("parser cleanup failed", { error: e });
+		}
+		for (const language of this.languages.values()) try {
+			language.delete?.();
+		} catch (e) {
+			log.debug("language cleanup failed", { error: e });
+		}
+		this.parsers.clear();
+		this.languages.clear();
+		this.pendingGrammarLoads.clear();
+		this.parserCtor = null;
+		this.initAttempts = 0;
+	}
+};
+
+//#endregion
+export { TreeSitterAdapter, isTreeSitterRuntimePresent };
+//# sourceMappingURL=TreeSitterAdapter-C-EWy8br.js.map