dsh-codegraph-visualizer 0.1.1 → 0.3.1

package/dist/codeGraphRows-C7hqu35E.js

@@ -0,0 +1,246 @@
+import { EdgeId, NodeId } from "./types-BUDxI_00.js";
+import { CODEGRAPH_ADAPTER } from "./constants-CQq93l3e.js";
+import { inferLayerFromPath } from "./layerUtils-DDm-EsaD.js";
+
+//#region src/adapters/codeGraphRows.ts
+/**
+
+* edges 行的共享 SELECT 列清单（不含 WHERE/ORDER BY，调用方按需拼接）。
+
+*
+
+* 单一来源的理由：8 处 `SELECT … FROM edges` 曾各自手写列清单——cycle-119 就是因为
+
+* 「读侧漏了 `metadata` 列」而 `'top-k-weight'` 契约空转两轮。列变了改一处，
+
+* 各读取面跟着编译期报错（解构不存在的键）而不是静默丢数据。
+
+*/
+const EDGE_ROW_COLUMNS = "id, source, target, kind, metadata, line";
+/**
+
+* 从 `metadata` JSON 文本解析置信度（[0,1] 数值），任何不合法形态返回 `undefined`。
+
+*
+
+* 为什么不 throw：单行 metadata 损坏不该让整页边读取失败（validateEdgeRows 的
+
+* 「跳过坏行」是同一哲学）；也不该把 0.9 解析成 `undefined` 再被 `?? 1` 兜底成
+
+* 「完全可信」——所以越界值与缺失值**同型**（undefined），消费侧用
+
+* `weight === undefined` 显式分支，没有 `?? 默认值` 的静默兜底路径。
+
+*/
+function parseEdgeConfidence(metadata) {
+	if (typeof metadata !== "string" || metadata.length === 0) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(metadata);
+	} catch {
+		return void 0;
+	}
+	if (typeof parsed !== "object" || parsed === null) return void 0;
+	const confidence = parsed.confidence;
+	if (typeof confidence !== "number" || !Number.isFinite(confidence)) return void 0;
+	if (confidence < 0 || confidence > 1) return void 0;
+	return confidence;
+}
+const NODE_KIND_MAP = {
+	function: "function",
+	method: "function",
+	class: "class",
+	interface: "interface",
+	type_alias: "type",
+	constant: "variable",
+	variable: "variable",
+	property: "variable",
+	file: "module",
+	import: "module",
+	module: "module"
+};
+const EDGE_KIND_MAP = {
+	call: "call",
+	calls: "call",
+	import: "import",
+	imports: "import",
+	extend: "extend",
+	extends: "extend",
+	implement: "implement",
+	implements: "implement",
+	contains: "contains",
+	dependency: "dependency",
+	depends: "dependency"
+};
+const FILTERED_EDGE_KINDS = new Set(["uses_var", "func_imports_local"]);
+const NOISE_PATH_SEGMENTS = [
+	"node_modules",
+	".git",
+	"vendor",
+	"__pycache__",
+	".venv",
+	"dist",
+	"build",
+	".next",
+	".nuxt",
+	".cache",
+	".turbo",
+	"coverage",
+	".pytest_cache",
+	".cycles",
+	".codegraph-visualizer"
+];
+function isNoisePath(filePath) {
+	const segments = filePath.split(/[\\/]/);
+	for (const seg of NOISE_PATH_SEGMENTS) if (segments.includes(seg)) return true;
+	return false;
+}
+/** 导出噪音段列表——供 SQL 侧预过滤（readTopLevelNodesFromDb 的 LIMIT 前过滤）。 */
+const NOISE_PATH_SEGMENTS_EXPORT = NOISE_PATH_SEGMENTS;
+/**
+
+* 索引行 → 图节点。这是**唯一**的节点映射实现：全量路径（`toAdapterResult`）与增量路径
+
+* （`buildIncrementalUpdate`）都必须走这里，否则两条路径产出的节点形状会漂移。
+
+*
+
+* 父节点按**每个节点自己的 `file_path`** 解析（`kind` 为 file/module/import 的节点本身没有父），
+
+* 而不是整批共用一个父 id —— 增量定向读会一次拿回多个文件的节点，整批单父会把它们全挂到同一个
+
+* 文件下。
+
+*
+
+* `source` 给出时给 `properties.__source` 打标记，取值必须与 `GraphDataMerger.merge` 用的一致；
+
+* 增量路径必须打（它要和已经过 merger 的 `current` 逐字段比对），全量路径不打（merger 会打，
+
+* 打了也只是重复覆盖同一个值，但会让 adapter 的原始输出测试多出一个字段）。
+
+*/
+function mapRowsToGraphNodes(dbNodes, source) {
+	const fileNodeIds = new Map();
+	for (const n of dbNodes) if (n.kind === "file" || n.kind === "module") fileNodeIds.set(n.file_path, n.id);
+	return dbNodes.filter((n) => n.name && n.file_path && !isNoisePath(n.file_path)).map((n) => {
+		const parentId = n.kind !== "file" && n.kind !== "module" && n.kind !== "import" ? fileNodeIds.get(n.file_path) ?? void 0 : void 0;
+		return {
+			id: NodeId(n.id),
+			label: n.name,
+			type: mapNodeKind(n.kind),
+			filePath: n.file_path,
+			lineNumber: n.start_line ?? 1,
+			properties: {
+				kind: n.kind,
+				...n.signature ? { signature: n.signature } : {},
+				...n.docstring ? { docstring: n.docstring } : {},
+				exported: n.is_exported === 1,
+				...source ? { __source: source } : {}
+			},
+			...parentId ? { parentId: NodeId(parentId) } : {},
+			layer: inferLayerFromPath(n.file_path)
+		};
+	});
+}
+/**
+
+* 索引行 → 图边。同样是唯一的边映射实现，全量/增量两条路径共用。
+
+*
+
+* 三条过滤规则必须和全量路径完全一致，否则增量路径会把全量路径早已丢弃的边重新塞回图里：
+
+* 两端都必须存在于 `validNodeIds`、丢弃自环、丢弃 `FILTERED_EDGE_KINDS`，最后按**每个来源**
+
+* 截断到 import 上限条 import 边。
+
+*
+
+* 截断前先按边 id 升序排序：全量路径的边来自 `ORDER BY id` 的分页读，增量路径的边来自
+
+* 分批 IN 查询（SQL 不保证顺序），不排序的话同一个来源保留下来的 20 条会不一样。
+
+*
+
+* `keptImportIds` 是增量路径必须提供的东西，也是这里唯一不显然的地方。一次定向读只拿回**某个
+
+* 来源的部分** import 边：改动的是 `b.ts` 时，`a.ts -> b.ts` 这条边会因为"目标在改动集合内"被
+
+* 返回，但 `a.ts` 自己的 57 条 import 里哪些进了前 20 名，局部集合根本看不出来。若只对局部集合
+
+* 数到 20，这条本应被全量路径丢弃的边就会当成新边加进图里（实测本仓库多出 10 条）。
+
+*
+
+* 因此截断要在"当前图里该来源已保留的 import 边 id" ∪ "本次读回的 import 边 id" 上做：边 id 随
+
+* 插入单调递增，所以两者的并集按 id 排序后取前 `cap` 条，就是全量路径会保留的那一批。来源在改动
+
+* 集合内时局部集合本就是完整的（并集不变）；来源不在改动集合内时，当前图里已有 20 条、新边的 id
+
+* 更大，自然落选 —— 这正是想要的结论。
+
+*/
+function mapRowsToGraphEdges(dbEdges, validNodeIds, opts = {}) {
+	const importCap = opts.importCap ?? CODEGRAPH_ADAPTER.MAX_IMPORTS_PER_SOURCE;
+	const kept = dbEdges.filter((e) => validNodeIds.has(e.source) && validNodeIds.has(e.target) && e.source !== e.target && !FILTERED_EDGE_KINDS.has(e.kind)).sort((a, b) => a.id - b.id);
+	const importIdsBySource = new Map();
+	for (const e of kept) {
+		if (mapEdgeKind(e.kind) !== "import") continue;
+		const list = importIdsBySource.get(e.source);
+		if (list) list.push(e.id);
+		else importIdsBySource.set(e.source, [e.id]);
+	}
+	const admittedImportIds = new Set();
+	for (const [src, ids] of importIdsBySource) {
+		const merged = [...new Set([...opts.keptImportIds?.get(src) ?? [], ...ids])].sort((a, b) => a - b);
+		for (const id of merged.slice(0, importCap)) admittedImportIds.add(id);
+	}
+	const edges = [];
+	for (const e of kept) {
+		if (mapEdgeKind(e.kind) === "import" && !admittedImportIds.has(e.id)) continue;
+		const locatable = typeof e.line === "number";
+		edges.push({
+			id: EdgeId(String(e.id)),
+			source: NodeId(e.source),
+			target: NodeId(e.target),
+			type: mapEdgeKind(e.kind),
+			properties: {
+				...locatable ? { line: e.line } : {},
+				...opts.source ? { __source: opts.source } : {},
+				edgeOrigin: "db",
+				edgeLocatable: locatable,
+				rawKind: e.kind
+			},
+			...parseEdgeConfidence(e.metadata) !== void 0 ? { weight: parseEdgeConfidence(e.metadata) } : {}
+		});
+	}
+	return edges;
+}
+function mapNodeKind(kind) {
+	return NODE_KIND_MAP[kind] ?? "module";
+}
+function mapEdgeKind(kind) {
+	return EDGE_KIND_MAP[kind] ?? "dependency";
+}
+/**
+
+* Normalize a repo-relative path for comparison against the index's own `file_path` values.
+
+*
+
+* The watcher reports platform separators while the indexer stores whatever it was handed, so the
+
+* two forms have to be reconciled before any lookup. Callers that need both spellings should ask
+
+* for them explicitly rather than relying on the index to pick one.
+
+*/
+function normalizeRepoPath(filePath) {
+	return filePath.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+
+//#endregion
+export { EDGE_ROW_COLUMNS, FILTERED_EDGE_KINDS, NOISE_PATH_SEGMENTS_EXPORT, isNoisePath, mapEdgeKind, mapNodeKind, mapRowsToGraphEdges, mapRowsToGraphNodes, normalizeRepoPath, parseEdgeConfidence };
+//# sourceMappingURL=codeGraphRows-C7hqu35E.js.map

package/dist/codeGraphRows-C7hqu35E.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codeGraphRows-C7hqu35E.js","names":["metadata: string | null | undefined","parsed: unknown","NODE_KIND_MAP: Record<string, GraphNode['type']>","EDGE_KIND_MAP: Record<string, GraphEdge['type']>","filePath: string","dbNodes: DbNodeRow[]","source?: DataSourceType","dbEdges: DbEdgeRow[]","validNodeIds: Set<string>","opts: { source?: DataSourceType; importCap?: number; keptImportIds?: Map<string, number[]> }","edges: GraphEdge[]","kind: string"],"sources":["../src/adapters/codeGraphRows.ts"],"sourcesContent":["/**\r\n * codegraph.db 索引行 → 图节点/图边的**唯一**映射层（cycle-110 Q7 行为等价提取）。\r\n *\r\n * 抽取契约（这里是语义最重的一块，改动前必须逐条确认）：\r\n *   · `mapRowsToGraphNodes` / `mapRowsToGraphEdges` 是全量与增量两条取数路径**共用**的映射实现，\r\n *     任何一侧另写一份都会让两条路径产出的形状漂移（历史缺陷）。本文件是它们的唯一住址。\r\n *   · 父节点按**每个节点自己的 `file_path`** 解析（`kind` 为 file/module/import 的节点无父），\r\n *     不允许整批共用一个父 id。\r\n *   · 边的三条过滤规则（两端都在 `validNodeIds`、去自环、丢 `FILTERED_EDGE_KINDS`）与\r\n *     import 上限截断必须完全一致；截断前按边 id 升序排序，否则分批 IN 查询的顺序差异会改变保留集合。\r\n *   · `edgeOrigin` / `edgeLocatable` / `rawKind` 只写**可证明**的事实：上游 edges 表没有\r\n *     confidence 列，因此这里绝不产出 EXTRACTED/INFERRED 之类凭空推断的取值。\r\n *\r\n * 本文件无模块级可变状态（三张 Map 都是常量表），因此可以安全地按需重复 import。\r\n */\r\nimport type { GraphNode, GraphEdge, DataSourceType } from '../types/index.ts';\r\nimport { NodeId, EdgeId } from '../types/index.ts';\r\nimport { inferLayerFromPath } from '../shared/layerUtils.ts';\r\nimport { CODEGRAPH_ADAPTER } from '../shared/constants.ts';\r\n\r\n// ---- codegraph.db schema (upstream @colbymchenry/codegraph) ----------------\r\n\r\nexport interface DbNodeRow {\r\n  id: string;\r\n  kind: string;\r\n  name: string;\r\n  file_path: string;\r\n  start_line: number;\r\n  signature: string | null;\r\n  docstring: string | null;\r\n  is_exported: number;\r\n}\r\n\r\nexport interface DbEdgeRow {\r\n  id: number;\r\n  source: string;\r\n  target: string;\r\n  kind: string;\r\n  /**\r\n   * 上游 `edges.metadata` 列（JSON 文本，可空）。cycle-119 weight 数据面：\r\n   * `{\"confidence\":0.9,\"resolvedBy\":\"exact-match\"}` 是实测形态（本仓 .codegraph\r\n   * 6,556 条非空 / 10,869 条边）。解析为 `weight` 的规则见 {@link parseEdgeConfidence}：\r\n   * **保守降级**——列缺失 / 非 JSON / 非数 / 越界 [0,1] 一律不产出 weight，\r\n   * 宁可回到「无权重、DFS 序截断」，也不喂给 `'top-k-weight'` 一个编造的置信值。\r\n   */\r\n  metadata: string | null;\r\n  line: number | null;\r\n}\r\n\r\n/**\r\n * edges 行的共享 SELECT 列清单（不含 WHERE/ORDER BY，调用方按需拼接）。\r\n *\r\n * 单一来源的理由：8 处 `SELECT … FROM edges` 曾各自手写列清单——cycle-119 就是因为\r\n * 「读侧漏了 `metadata` 列」而 `'top-k-weight'` 契约空转两轮。列变了改一处，\r\n * 各读取面跟着编译期报错（解构不存在的键）而不是静默丢数据。\r\n */\r\nexport const EDGE_ROW_COLUMNS = 'id, source, target, kind, metadata, line' as const;\r\n\r\n/**\r\n * 从 `metadata` JSON 文本解析置信度（[0,1] 数值），任何不合法形态返回 `undefined`。\r\n *\r\n * 为什么不 throw：单行 metadata 损坏不该让整页边读取失败（validateEdgeRows 的\r\n * 「跳过坏行」是同一哲学）；也不该把 0.9 解析成 `undefined` 再被 `?? 1` 兜底成\r\n * 「完全可信」——所以越界值与缺失值**同型**（undefined），消费侧用\r\n * `weight === undefined` 显式分支，没有 `?? 默认值` 的静默兜底路径。\r\n */\r\nexport function parseEdgeConfidence(metadata: string | null | undefined): number | undefined {\r\n  if (typeof metadata !== 'string' || metadata.length === 0) return undefined;\r\n  let parsed: unknown;\r\n  try {\r\n    parsed = JSON.parse(metadata);\r\n  } catch {\r\n    return undefined;\r\n  }\r\n  if (typeof parsed !== 'object' || parsed === null) return undefined;\r\n  const confidence = (parsed as Record<string, unknown>).confidence;\r\n  if (typeof confidence !== 'number' || !Number.isFinite(confidence)) return undefined;\r\n  if (confidence < 0 || confidence > 1) return undefined;\r\n  return confidence;\r\n}\r\n\r\nconst NODE_KIND_MAP: Record<string, GraphNode['type']> = {\r\n  function: 'function',\r\n  method: 'function',\r\n  class: 'class',\r\n  interface: 'interface',\r\n  type_alias: 'type',\r\n  constant: 'variable',\r\n  variable: 'variable',\r\n  property: 'variable',\r\n  file: 'module',\r\n  import: 'module',\r\n  module: 'module',\r\n};\r\n\r\nconst EDGE_KIND_MAP: Record<string, GraphEdge['type']> = {\r\n  call: 'call',\r\n  calls: 'call',\r\n  import: 'import',\r\n  imports: 'import',\r\n  extend: 'extend',\r\n  extends: 'extend',\r\n  implement: 'implement',\r\n  implements: 'implement',\r\n  contains: 'contains',\r\n  dependency: 'dependency',\r\n  depends: 'dependency',\r\n};\r\n\r\nexport const FILTERED_EDGE_KINDS = new Set([\r\n  'uses_var',\r\n  'func_imports_local',\r\n]);\r\n\r\nconst NOISE_PATH_SEGMENTS = [\r\n  'node_modules', '.git', 'vendor', '__pycache__', '.venv', 'dist', 'build',\r\n  '.next', '.nuxt', '.cache', '.turbo', 'coverage', '.pytest_cache',\r\n  // cycle-141：.cycles/ 是 AI 迭代循环的归档目录（测试报告、规划文档、\r\n  // 审计日志等），不是源码。不加入噪音列表会导致 bootstrap 的 LIMIT 50\r\n  // 选出的顶层节点全是 .cycles/ 内容（字母序 . < s），用户看到的图谱\r\n  // 只有归档目录而没有 src/ 源码。\r\n  '.cycles',\r\n  // cycle-141：.codegraph-visualizer/ 是插件自己的索引目录，不应出现在图谱中。\r\n  '.codegraph-visualizer',\r\n];\r\n\r\nexport function isNoisePath(filePath: string): boolean {\r\n  const segments = filePath.split(/[\\\\/]/);\r\n  for (const seg of NOISE_PATH_SEGMENTS) {\r\n    if (segments.includes(seg)) return true;\r\n  }\r\n  return false;\r\n}\r\n\r\n/** 导出噪音段列表——供 SQL 侧预过滤（readTopLevelNodesFromDb 的 LIMIT 前过滤）。 */\r\nexport const NOISE_PATH_SEGMENTS_EXPORT = NOISE_PATH_SEGMENTS;\r\n\r\n/**\r\n * 索引行 → 图节点。这是**唯一**的节点映射实现：全量路径（`toAdapterResult`）与增量路径\r\n * （`buildIncrementalUpdate`）都必须走这里，否则两条路径产出的节点形状会漂移。\r\n *\r\n * 父节点按**每个节点自己的 `file_path`** 解析（`kind` 为 file/module/import 的节点本身没有父），\r\n * 而不是整批共用一个父 id —— 增量定向读会一次拿回多个文件的节点，整批单父会把它们全挂到同一个\r\n * 文件下。\r\n *\r\n * `source` 给出时给 `properties.__source` 打标记，取值必须与 `GraphDataMerger.merge` 用的一致；\r\n * 增量路径必须打（它要和已经过 merger 的 `current` 逐字段比对），全量路径不打（merger 会打，\r\n * 打了也只是重复覆盖同一个值，但会让 adapter 的原始输出测试多出一个字段）。\r\n */\r\nexport function mapRowsToGraphNodes(dbNodes: DbNodeRow[], source?: DataSourceType): GraphNode[] {\r\n  const fileNodeIds = new Map<string, string>();\r\n  for (const n of dbNodes) {\r\n    if (n.kind === 'file' || n.kind === 'module') {\r\n      fileNodeIds.set(n.file_path, n.id);\r\n    }\r\n  }\r\n\r\n  return dbNodes\r\n    .filter((n) => n.name && n.file_path && !isNoisePath(n.file_path))\r\n    .map((n) => {\r\n      const parentId = (n.kind !== 'file' && n.kind !== 'module' && n.kind !== 'import')\r\n        ? fileNodeIds.get(n.file_path) ?? undefined\r\n        : undefined;\r\n      return {\r\n        id: NodeId(n.id),\r\n        label: n.name,\r\n        type: mapNodeKind(n.kind),\r\n        filePath: n.file_path,\r\n        lineNumber: n.start_line ?? 1,\r\n        properties: {\r\n          kind: n.kind,\r\n          ...(n.signature ? { signature: n.signature } : {}),\r\n          ...(n.docstring ? { docstring: n.docstring } : {}),\r\n          exported: n.is_exported === 1,\r\n          ...(source ? { __source: source } : {}),\r\n        },\r\n        ...(parentId ? { parentId: NodeId(parentId) } : {}),\r\n        layer: inferLayerFromPath(n.file_path),\r\n      };\r\n    });\r\n}\r\n\r\n/**\r\n * 索引行 → 图边。同样是唯一的边映射实现，全量/增量两条路径共用。\r\n *\r\n * 三条过滤规则必须和全量路径完全一致，否则增量路径会把全量路径早已丢弃的边重新塞回图里：\r\n * 两端都必须存在于 `validNodeIds`、丢弃自环、丢弃 `FILTERED_EDGE_KINDS`，最后按**每个来源**\r\n * 截断到 import 上限条 import 边。\r\n *\r\n * 截断前先按边 id 升序排序：全量路径的边来自 `ORDER BY id` 的分页读，增量路径的边来自\r\n * 分批 IN 查询（SQL 不保证顺序），不排序的话同一个来源保留下来的 20 条会不一样。\r\n *\r\n * `keptImportIds` 是增量路径必须提供的东西，也是这里唯一不显然的地方。一次定向读只拿回**某个\r\n * 来源的部分** import 边：改动的是 `b.ts` 时，`a.ts -> b.ts` 这条边会因为\"目标在改动集合内\"被\r\n * 返回，但 `a.ts` 自己的 57 条 import 里哪些进了前 20 名，局部集合根本看不出来。若只对局部集合\r\n * 数到 20，这条本应被全量路径丢弃的边就会当成新边加进图里（实测本仓库多出 10 条）。\r\n *\r\n * 因此截断要在\"当前图里该来源已保留的 import 边 id\" ∪ \"本次读回的 import 边 id\" 上做：边 id 随\r\n * 插入单调递增，所以两者的并集按 id 排序后取前 `cap` 条，就是全量路径会保留的那一批。来源在改动\r\n * 集合内时局部集合本就是完整的（并集不变）；来源不在改动集合内时，当前图里已有 20 条、新边的 id\r\n * 更大，自然落选 —— 这正是想要的结论。\r\n */\r\nexport function mapRowsToGraphEdges(\r\n  dbEdges: DbEdgeRow[],\r\n  validNodeIds: Set<string>,\r\n  opts: { source?: DataSourceType; importCap?: number; keptImportIds?: Map<string, number[]> } = {},\r\n): GraphEdge[] {\r\n  const importCap = opts.importCap ?? CODEGRAPH_ADAPTER.MAX_IMPORTS_PER_SOURCE;\r\n  const kept = dbEdges\r\n    .filter((e) =>\r\n      validNodeIds.has(e.source) && validNodeIds.has(e.target) &&\r\n      e.source !== e.target &&\r\n      !FILTERED_EDGE_KINDS.has(e.kind))\r\n    .sort((a, b) => a.id - b.id);\r\n\r\n  const importIdsBySource = new Map<string, number[]>();\r\n  for (const e of kept) {\r\n    if (mapEdgeKind(e.kind) !== 'import') continue;\r\n    const list = importIdsBySource.get(e.source);\r\n    if (list) list.push(e.id);\r\n    else importIdsBySource.set(e.source, [e.id]);\r\n  }\r\n\r\n  const admittedImportIds = new Set<number>();\r\n  for (const [src, ids] of importIdsBySource) {\r\n    const merged = [...new Set([...(opts.keptImportIds?.get(src) ?? []), ...ids])].sort((a, b) => a - b);\r\n    for (const id of merged.slice(0, importCap)) admittedImportIds.add(id);\r\n  }\r\n\r\n  const edges: GraphEdge[] = [];\r\n  for (const e of kept) {\r\n    if (mapEdgeKind(e.kind) === 'import' && !admittedImportIds.has(e.id)) continue;\r\n    // 边来源归因：只写**可证明**的三件事，不写置信度。\r\n    //\r\n    // 上游 `codegraph.db` 的 edges 表只有 `id/source/target/kind/line`，**没有 confidence 列**\r\n    // （`DbEdgeRow` 是本文件对它的逐字段转写）。因此这里刻意**不**产出 `EXTRACTED`/`INFERRED`\r\n    // 之类的取值 —— 那会是凭空编造的证据。能证明的只有：\r\n    //   - `edgeOrigin: 'db'`：这条边来自 SQLite 索引的 edges 行。`ast` 档位（同一条 `contains`\r\n    //     边由语法树父子关系直接给出）现在由 `TreeSitterAdapter` 生产（cycle-111 P1-N4）。\r\n    //     两个档位互斥：本文件只写 `db`，**不冒充** `ast`；\r\n    //   - `edgeLocatable`：这一行有没有 `line`。有 line 才能回溯到源码位置，`null` 只能信其存在；\r\n    //   - `rawKind`：被 `EDGE_KIND_MAP` 压平**之前**的上游 kind。`type` 已经丢失了这个信息\r\n    //     （未知 kind 一律压成 `dependency`），而冲突裁决需要区分\"具体关系\"与兜底值。\r\n    // 消费者必须以 `type` 判断关系语义，`rawKind` 只用于归因与裁决（两者可能不一致，\r\n    // 例如 `uses_var` 在过滤前被丢弃，而 `calls` 会压平成 `call`）。\r\n    const locatable = typeof e.line === 'number';\r\n    edges.push({\r\n      id: EdgeId(String(e.id)),\r\n      source: NodeId(e.source),\r\n      target: NodeId(e.target),\r\n      type: mapEdgeKind(e.kind),\r\n      properties: {\r\n        ...(locatable ? { line: e.line } : {}),\r\n        ...(opts.source ? { __source: opts.source } : {}),\r\n        edgeOrigin: 'db',\r\n        edgeLocatable: locatable,\r\n        rawKind: e.kind,\r\n      },\r\n      // cycle-119 weight 数据面（§62.6 #4 / X-07 数据侧）：`edges.metadata.confidence`\r\n      // → `GraphEdge.weight`。解析失败/越界/缺失 → undefined → 键不产出（保守降级：\r\n      // 消费侧 `'top-k-weight'` 见到无权重边按 DFS 序兜底，绝不把编造值当真）。\r\n      // 注意：weight 在 GraphEdge 顶层而不在 properties 里——`graphFingerprint` 对\r\n      // 两者都计入哈希（指纹影响见交付清单的 re-fingerprint 披露），但 XuanjiAdapter\r\n      // 的 `xjEdge` 与 GraphologyAdapter 只读顶层 `edge.weight`。\r\n      ...(parseEdgeConfidence(e.metadata) !== undefined\r\n        ? { weight: parseEdgeConfidence(e.metadata) }\r\n        : {}),\r\n    });\r\n  }\r\n  return edges;\r\n}\r\n\r\nexport function mapNodeKind(kind: string): GraphNode['type'] {\r\n  return NODE_KIND_MAP[kind] ?? 'module';\r\n}\r\n\r\nexport function mapEdgeKind(kind: string): GraphEdge['type'] {\r\n  return EDGE_KIND_MAP[kind] ?? 'dependency';\r\n}\r\n\r\n/**\r\n * Normalize a repo-relative path for comparison against the index's own `file_path` values.\r\n *\r\n * The watcher reports platform separators while the indexer stores whatever it was handed, so the\r\n * two forms have to be reconciled before any lookup. Callers that need both spellings should ask\r\n * for them explicitly rather than relying on the index to pick one.\r\n */\r\nexport function normalizeRepoPath(filePath: string): string {\r\n  return filePath.replace(/\\\\/g, '/').replace(/^\\.\\//, '');\r\n}\r\n"],"mappings":"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"}

package/dist/constants-CQq93l3e.js

@@ -0,0 +1,399 @@
+//#region src/shared/constants.ts
+/**
+
+* The layout worker has to be fetched over HTTP because a browser Worker cannot be given an
+
+* in-memory module. The plugin's own host serves it, so the client and the host share this one
+
+* path: the client builds the Worker URL from it and the host registers the route for it.
+
+*
+
+* `ARTIFACT` is the file the build produces; `tests/unit/workerContract.test.ts` keeps the two in
+
+* step, because a route that serves nothing (or a client that asks for a path nobody registered)
+
+* is silent at runtime: layouts just fall back to the main thread.
+
+*/
+const LAYOUT_WORKER = {
+	ROUTE_PATH: "/api/v1/codegraph/worker/layoutWorker.js",
+	ARTIFACT: "dist/client/worker/layoutWorker.js",
+	SOURCE_ENTRY: "src/client/worker/layoutWorker.ts"
+};
+const PATH_FINDER = { MAX_NODES_FOR_BFS: 5e4 };
+const API = {
+	DEFAULT_TIMEOUT_MS: 3e4,
+	RATE_LIMIT_WINDOW_MS: 6e4,
+	RATE_LIMIT_DEFAULT: 60,
+	RATE_LIMIT_HEAVY: 10,
+	RATE_LIMIT_MAP_MAX: 1e4,
+	SCAN_TIMEOUT_MS: 6e4,
+	DATA_RESPONSE_MAX_BYTES: 5 * 1024 * 1024,
+	DATA_RESPONSE_SLIM_NODES: 500,
+	INVOKE_DEFAULT_TIMEOUT_MS: 5e3
+};
+const HEALTH_SCORE = {
+	WEIGHT_COUPLING: .25,
+	WEIGHT_COHESION: .25,
+	WEIGHT_CYCLIC: .3,
+	WEIGHT_MODULARITY: .2,
+	DEFAULT_MAX_MODULE_DEPTH: 3
+};
+const LAYOUT = {
+	DENSITY_FACTOR_SMALL: 1.5,
+	DENSITY_FACTOR_MEDIUM: 1,
+	DENSITY_FACTOR_LARGE: .7,
+	SMALL_NODE_THRESHOLD: 50,
+	MEDIUM_NODE_THRESHOLD: 200,
+	LARGE_NODE_THRESHOLD: 500,
+	VERY_LARGE_NODE_THRESHOLD: 2e3,
+	LAYOUT_SAMPLE_SIZE: 200,
+	COSE_NUM_ITER: 2500,
+	COSE_LARGE_NUM_ITER: 15e3,
+	MAX_RANK_SEP: 80,
+	MIN_RANK_SEP: 30,
+	MIN_NODE_SPACING: 20,
+	SMALL_SPACING_FACTOR: 1.2,
+	MEDIUM_SPACING_FACTOR: 1,
+	LARGE_SPACING_FACTOR: .8,
+	SMALL_NODE_COUNT_THRESHOLD: 100,
+	MEDIUM_NODE_COUNT_THRESHOLD: 300,
+	INCREMENTAL_RADIUS_BASE: 100,
+	GRID_FALLBACK_NODE_THRESHOLD: 5e3,
+	OVERLAP_MAX_ITERATIONS: 15,
+	OVERLAP_SKIP_THRESHOLD: 5e3,
+	OVERLAP_CELL_SIZE_MULTIPLIER: 4,
+	GOLDEN_ANGLE: Math.PI * (3 - Math.sqrt(5)),
+	OVERLAP_PUSH_COEFFICIENT: .15,
+	OVERLAP_MIN_PUSH: 2,
+	FCOSE_LARGE_NODE_THRESHOLD: 5e3,
+	FCOSE_LARGE_NUM_ITER: 1e3,
+	FCOSE_LARGE_QUALITY: "draft",
+	NODE_REPULSE_MAX: 2e4
+};
+const MCP = {
+	MAX_MESSAGE_LENGTH: 10 * 1024 * 1024,
+	MAX_IMPACT_RESULTS: 500
+};
+const CACHE = { GRAPH_CACHE_LIMIT: 8 };
+const BOOTSTRAP = {
+	TOP_LEVEL_NODE_LIMIT: 50,
+	CHILDREN_PAGE_SIZE: 50
+};
+const SYMBOL_AST = {
+	MAX_NODES: 800,
+	MAX_SOURCE_LINES: 1500
+};
+const FILE_OUTLINE = { MAX_SYMBOLS: 800 };
+const SQLITE = { MAX_IN_PARAMS: 900 };
+const EDGES_AGGREGATION = {
+	THRESHOLD: 20,
+	PAGE_SIZE: 500
+};
+const VALIDATION = {
+	MAX_PATH_LENGTH: 4096,
+	MAX_GIT_REF_LENGTH: 256,
+	MAX_FILEPATH_LENGTH: 512
+};
+const AST = {
+	MAX_CONTENT_BYTES: 512 * 1024,
+	MAX_TREE_SITTER_CONTENT_BYTES: 512 * 1024
+};
+const WATCHER = {
+	MAX_RETRIES: 3,
+	RETRY_BASE_DELAY_MS: 1e3
+};
+/** Structural-fingerprint incremental detection (P0-6). Bump VERSION when the canonical record
+
+* shape changes, so previously stored snapshot hashes are not mistaken for current ones. */
+const FINGERPRINT = {
+	VERSION: 1,
+	SNAPSHOT_KEEP: 3
+};
+/** Targeted (file-scoped) graph refresh driven by the watcher (P2-21). */
+const INCREMENTAL = {
+	MAX_CHANGED_FILES: 50,
+	MAX_FILE_BATCH: 200
+};
+/**
+
+* `/manage/metrics` 的采样边界（cycle-141，P0 可用性）。
+
+*
+
+* ## 节点与边必须**各自**设上界
+
+*
+
+* 旧实现的循环条件只界节点（`allDbNodes.length < 10000`），边侧完全没有界：只要节点数
+
+* 没到上限，循环就把**全库边**读进内存。代码图谱的边数通常是节点数的 2–5 倍，一个
+
+* 9 千节点 / 4 万边的仓库就足以让这条路由 OOM。节点与边是**同一处内存护栏的两半**，
+
+* 缺一即回到旧缺陷——所以这里两个上界缺一不可。
+
+*
+
+* ## 边界只影响「读多少」，不影响「算得对不对」
+
+*
+
+* 触到上界时路由如实披露 `truncated: true` 与 `nodesTotal/edgesTotal`，客户端据此知道
+
+* 这不是全量图。上界不是精度承诺，是可用性护栏。
+
+*/
+const METRICS = {
+	MAX_NODES: 1e4,
+	MAX_EDGES: 5e4,
+	PAGE_SIZE: 500
+};
+const TOOL_MESSAGES = {
+	NO_PATH_FOUND: {
+		en: "No path found between the specified symbols.",
+		zh: "未找到指定符号之间的路径。"
+	},
+	PATH_PATTERN_FAILED: {
+		en: "Path pattern evaluation failed.",
+		zh: "路径模式求值失败。"
+	},
+	GRAPH_TOO_LARGE_FOR_PATH: {
+		en: "Graph too large (>50000 nodes) for path finding. Try filtering first.",
+		zh: "图谱过大（>50000 节点），无法进行路径查找。请先尝试筛选。"
+	},
+	PATH_FOUND: {
+		en: "Path found",
+		zh: "路径已找到"
+	},
+	HOPS: {
+		en: "hops",
+		zh: "跳"
+	},
+	INSUFFICIENT_DATA: {
+		en: "Insufficient data for health scoring.",
+		zh: "数据不足，无法进行健康评分。"
+	},
+	NO_VIOLATIONS: {
+		en: "No rule violations detected.",
+		zh: "未检测到规则违规。"
+	},
+	RULE_VIOLATIONS: {
+		en: "rule violations:",
+		zh: "条规则违规："
+	},
+	NO_CYCLES: {
+		en: "No dependency cycles detected.",
+		zh: "未检测到依赖环。"
+	}
+};
+const ERROR_CODES = {
+	PATH_NOT_ALLOWED: "PATH_NOT_ALLOWED",
+	WORKSPACE_PATH_NOT_ALLOWED: "WORKSPACE_PATH_NOT_ALLOWED",
+	SYMLINK_ESCAPE: "SYMLINK_ESCAPE",
+	NO_WORKSPACE_PATH: "NO_WORKSPACE_PATH",
+	PATH_OUTSIDE_WORKSPACE: "PATH_OUTSIDE_WORKSPACE",
+	SCAN_FAILED: "SCAN_FAILED",
+	INIT_FAILED: "INIT_FAILED",
+	WATCH_TOGGLE_FAILED: "WATCH_TOGGLE_FAILED",
+	WATCH_SETUP_FAILED: "WATCH_SETUP_FAILED",
+	INTERNAL_ERROR: "INTERNAL_ERROR",
+	COMMITS_REQUIRED: "COMMITS_REQUIRED",
+	INVALID_GIT_REF: "INVALID_GIT_REF",
+	GRAPH_DIFF_FAILED: "GRAPH_DIFF_FAILED",
+	FILEPATH_REQUIRED: "FILEPATH_REQUIRED",
+	FILE_TOO_LARGE: "FILE_TOO_LARGE",
+	AST_PARSE_FAILED: "AST_PARSE_FAILED",
+	FILEPATH_AND_CONTENT_REQUIRED: "FILEPATH_AND_CONTENT_REQUIRED",
+	INVALID_FILEPATH: "INVALID_FILEPATH",
+	CONTENT_TOO_LARGE: "CONTENT_TOO_LARGE",
+	METHOD_NOT_ALLOWED: "METHOD_NOT_ALLOWED",
+	RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+	SYMBOL_NOT_FOUND: "SYMBOL_NOT_FOUND",
+	BODY_TOO_LARGE: "BODY_TOO_LARGE",
+	INVALID_JSON_BODY: "INVALID_JSON_BODY",
+	INVALID_CONFIG: "INVALID_CONFIG",
+	INDEX_NOT_FOUND: "INDEX_NOT_FOUND",
+	DELETE_FAILED: "DELETE_FAILED",
+	METRICS_FAILED: "METRICS_FAILED",
+	SYNC_FAILED: "SYNC_FAILED"
+};
+const ERROR_MESSAGES = {
+	PATH_NOT_ALLOWED: {
+		en: "Path not allowed",
+		zh: "路径不允许访问"
+	},
+	WORKSPACE_PATH_NOT_ALLOWED: {
+		en: "Workspace path not allowed",
+		zh: "工作区路径不允许访问"
+	},
+	SYMLINK_ESCAPE: {
+		en: "Access denied: symlink escape",
+		zh: "访问被拒绝：符号链接逃逸"
+	},
+	NO_WORKSPACE_PATH: {
+		en: "No workspace path configured",
+		zh: "未配置工作区路径"
+	},
+	PATH_OUTSIDE_WORKSPACE: {
+		en: "Access denied: path outside workspace",
+		zh: "访问被拒绝：路径超出工作区范围"
+	},
+	SCAN_FAILED: {
+		en: "Scan failed — check codegraph installation",
+		zh: "扫描失败 — 请检查 codegraph 安装"
+	},
+	INIT_FAILED: {
+		en: "Initialization failed — is dsh-codegraph installed?",
+		zh: "初始化失败 — dsh-codegraph 是否已安装？"
+	},
+	WATCH_TOGGLE_FAILED: {
+		en: "Watch toggle failed",
+		zh: "监听切换失败"
+	},
+	WATCH_SETUP_FAILED: {
+		en: "Watch setup failed after retries",
+		zh: "监听设置在重试后失败"
+	},
+	INTERNAL_ERROR: {
+		en: "Internal server error",
+		zh: "服务器内部错误"
+	},
+	COMMITS_REQUIRED: {
+		en: "from and to commits are required",
+		zh: "需要 from 和 to 提交参数"
+	},
+	INVALID_GIT_REF: {
+		en: "Invalid git ref format",
+		zh: "无效的 Git 引用格式"
+	},
+	GRAPH_DIFF_FAILED: {
+		en: "Graph diff failed — check git refs",
+		zh: "图谱差异计算失败 — 请检查 Git 引用"
+	},
+	FILEPATH_REQUIRED: {
+		en: "filePath is required",
+		zh: "filePath 参数为必填"
+	},
+	FILE_TOO_LARGE: {
+		en: "File too large for AST parsing",
+		zh: "文件过大，无法进行 AST 解析"
+	},
+	AST_PARSE_FAILED: {
+		en: "AST parsing failed",
+		zh: "AST 解析失败"
+	},
+	FILEPATH_AND_CONTENT_REQUIRED: {
+		en: "filePath and content are required",
+		zh: "filePath 和 content 参数为必填"
+	},
+	INVALID_FILEPATH: {
+		en: "Invalid filePath",
+		zh: "无效的 filePath"
+	},
+	CONTENT_TOO_LARGE: {
+		en: "Content too large for tree-sitter parsing",
+		zh: "内容过大，无法进行 tree-sitter 解析"
+	},
+	METHOD_NOT_ALLOWED: {
+		en: "Method not allowed",
+		zh: "请求方法不被允许"
+	},
+	RATE_LIMIT_EXCEEDED: {
+		en: "Rate limit exceeded",
+		zh: "请求频率超限"
+	},
+	SYMBOL_NOT_FOUND: {
+		en: "Symbol not found",
+		zh: "未找到符号"
+	},
+	BODY_TOO_LARGE: {
+		en: "Request body too large",
+		zh: "请求体过大"
+	},
+	INVALID_JSON_BODY: {
+		en: "Invalid JSON body: expected object",
+		zh: "无效的 JSON 请求体：应为对象"
+	},
+	INVALID_CONFIG: {
+		en: "Invalid configuration",
+		zh: "无效的配置"
+	},
+	INDEX_NOT_FOUND: {
+		en: "Index not found",
+		zh: "未找到索引"
+	},
+	DELETE_FAILED: {
+		en: "Failed to delete index",
+		zh: "删除索引失败"
+	},
+	METRICS_FAILED: {
+		en: "Graph metrics computation failed",
+		zh: "图指标计算失败"
+	},
+	SYNC_FAILED: {
+		en: "Upstream sync failed",
+		zh: "上游同步失败"
+	}
+};
+const IMPORT = { MAX_PASTE_BYTES: 10 * 1024 * 1024 };
+const DIFF_ENGINE = { MAX_DEEP_EQUAL_DEPTH: 50 };
+const FILE_SYSTEM = { MAX_FILES: 500 };
+const CODEGRAPH_ADAPTER = { MAX_IMPORTS_PER_SOURCE: 20 };
+const TREE_SITTER = { BATCH_SIZE: 20 };
+const INDEXED_DB = {
+	DB_VERSION: 2,
+	TTL: {
+		CLUSTER_MS: 30 * 60 * 1e3,
+		DIAGRAM_MS: 60 * 60 * 1e3,
+		OUTLINE_MS: 24 * 60 * 60 * 1e3,
+		AST_MS: 24 * 60 * 60 * 1e3,
+		EDGES_MS: 30 * 60 * 1e3
+	},
+	CAPACITY: {
+		HIGH_WATERMARK: .85,
+		LOW_WATERMARK: .7
+	},
+	BATCH: { MAX_ENTRIES: 500 }
+};
+const LOGGER = { RING_SIZE: 200 };
+/**
+
+* 运行时层预算（cycle-88，P2-1 三层独立面板）。
+
+*
+
+* 验收原文 `docs/图谱按需加载.md:196-200` 的第三层一行：
+
+* 「运行时层 | Trace、日志、性能排查 | 独立面板，按时间窗口、请求 ID、Trace ID 加载
+
+* | 单次时间窗口 ≤ 5 分钟或 1000 条」，并在 `:265` 复述为
+
+* 「运行时层单次时间窗口 ≤ 5 分钟或 1000 条」。
+
+*
+
+* 两个上限是**同一层预算的两个维度**，取交集而不是并集：窗口先裁掉过老的数据，
+
+* 再按条数截断，于是「最近 5 分钟」与「最多 1000 条」同时成立。若只实现其中一个，
+
+* 高频日志场景仍能一次渲染上百万条——正是风险 9（`:243-246` 节点爆炸）想避免的。
+
+*
+
+* `MAX_ENTRIES` 刻意与 `LOGGER.RING_SIZE`（200）区分：环形缓冲是**保留**策略，
+
+* 这里是**单次展示**策略，两者不能互相替代（缓冲可能远大于一次要看的量）。
+
+*/
+const RUNTIME = {
+	WINDOW_MS: 5 * 60 * 1e3,
+	MAX_ENTRIES: 1e3,
+	PREVIEW_ENTRIES: 50,
+	MAX_METRICS: 100
+};
+
+//#endregion
+export { API, AST, BOOTSTRAP, CACHE, CODEGRAPH_ADAPTER, DIFF_ENGINE, EDGES_AGGREGATION, ERROR_CODES, ERROR_MESSAGES, FILE_OUTLINE, FILE_SYSTEM, FINGERPRINT, HEALTH_SCORE, INCREMENTAL, LAYOUT_WORKER, LOGGER, MCP, METRICS, PATH_FINDER, SQLITE, SYMBOL_AST, TOOL_MESSAGES, TREE_SITTER, VALIDATION, WATCHER };
+//# sourceMappingURL=constants-CQq93l3e.js.map