aifastdb-devplan 1.5.0 → 1.6.2

package/dist/visualize/graph-canvas/renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/renderer.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAEH,8CA8xBC;AA9xBD,SAAgB,iBAAiB;IAC/B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4xBR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/spatial-index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * SpatialIndex — 内联 R-tree 空间索引 (无外部依赖)
+ *
+ * 轻量级 R-tree 实现，支持:
+ * - bulk insert (STR 批量构建)
+ * - viewport search (矩形范围查询)
+ * - point query (hit-test)
+ * - 动态 insert/remove/update
+ *
+ * 基于简化版 rbush 算法，优化为图谱节点场景。
+ */
+export declare function getSpatialIndexScript(): string;
+//# sourceMappingURL=spatial-index.d.ts.map

package/dist/visualize/graph-canvas/spatial-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-index.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/spatial-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,wBAAgB,qBAAqB,IAAI,MAAM,CAkd9C"}

package/dist/visualize/graph-canvas/spatial-index.js

@@ -0,0 +1,482 @@
+"use strict";
+/**
+ * SpatialIndex — 内联 R-tree 空间索引 (无外部依赖)
+ *
+ * 轻量级 R-tree 实现，支持:
+ * - bulk insert (STR 批量构建)
+ * - viewport search (矩形范围查询)
+ * - point query (hit-test)
+ * - 动态 insert/remove/update
+ *
+ * 基于简化版 rbush 算法，优化为图谱节点场景。
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpatialIndexScript = getSpatialIndexScript;
+function getSpatialIndexScript() {
+    return `
+// ============================================================================
+// SpatialIndex — Lightweight R-tree for viewport culling & hit-test
+// ============================================================================
+
+/**
+ * Minimal R-tree implementation optimized for graph nodes.
+ * Supports bulk load, search, point query, insert, remove.
+ */
+function SpatialIndex() {
+  this._maxEntries = 16;   // max children per node
+  this._minEntries = 4;    // min children per node (for split)
+  this._root = this._createNode([]);
+  this._nodeIdToItem = {};  // nodeId → leaf item (for O(1) remove/update)
+
+  // Edge spatial index — separate R-tree for edges
+  this._edgeRoot = this._createNode([]);
+  this._edgeIdToItem = {};  // edgeId → leaf item
+}
+
+// ── Node structure ────────────────────────────────────────────────────────
+SpatialIndex.prototype._createNode = function(children) {
+  return {
+    children: children,
+    height: 1,     // 1 = leaf
+    leaf: true,
+    minX: Infinity,
+    minY: Infinity,
+    maxX: -Infinity,
+    maxY: -Infinity,
+  };
+};
+
+// ── Build from nodes (bulk load) ──────────────────────────────────────────
+
+/**
+ * Build the R-tree from all graph nodes.
+ * Uses Sort-Tile-Recursive (STR) bulk loading for optimal tree structure.
+ * @param {Array} nodes — [{id, x, y, _radius, ...}, ...]
+ */
+SpatialIndex.prototype.buildFromNodes = function(nodes) {
+  this._nodeIdToItem = {};
+  if (!nodes || nodes.length === 0) {
+    this._root = this._createNode([]);
+    return;
+  }
+
+  // Create leaf items with AABB
+  var items = [];
+  for (var i = 0; i < nodes.length; i++) {
+    var n = nodes[i];
+    var r = n._radius || 10;
+    var item = {
+      minX: n.x - r,
+      minY: n.y - r,
+      maxX: n.x + r,
+      maxY: n.y + r,
+      _nodeId: n.id,
+      _node: n,
+    };
+    n._aabb = item; // back-reference
+    items.push(item);
+    this._nodeIdToItem[n.id] = item;
+  }
+
+  // Build tree using STR bulk loading
+  this._root = this._buildSTR(items, 0, items.length - 1, 0);
+};
+
+SpatialIndex.prototype._buildSTR = function(items, left, right, level) {
+  var N = right - left + 1;
+  var M = this._maxEntries;
+
+  if (N <= M) {
+    // Fits in one leaf node
+    var node = this._createNode(items.slice(left, right + 1));
+    this._calcBBox(node);
+    return node;
+  }
+
+  // Sort by X, then divide into vertical slices
+  if (level % 2 === 0) {
+    items.sort(function(a, b) { return a.minX - b.minX; });
+  } else {
+    items.sort(function(a, b) { return a.minY - b.minY; });
+  }
+
+  var S = Math.ceil(N / M);
+  var children = [];
+
+  for (var i = left; i <= right; i += S) {
+    var end = Math.min(i + S - 1, right);
+    if (end - i + 1 <= M) {
+      var child = this._createNode(items.slice(i, end + 1));
+      this._calcBBox(child);
+      children.push(child);
+    } else {
+      children.push(this._buildSTR(items, i, end, level + 1));
+    }
+  }
+
+  var node = this._createNode(children);
+  node.leaf = false;
+  node.height = children[0].height + 1;
+  this._calcBBox(node);
+  return node;
+};
+
+SpatialIndex.prototype._calcBBox = function(node) {
+  var children = node.children;
+  node.minX = Infinity;
+  node.minY = Infinity;
+  node.maxX = -Infinity;
+  node.maxY = -Infinity;
+  for (var i = 0; i < children.length; i++) {
+    var c = children[i];
+    if (c.minX < node.minX) node.minX = c.minX;
+    if (c.minY < node.minY) node.minY = c.minY;
+    if (c.maxX > node.maxX) node.maxX = c.maxX;
+    if (c.maxY > node.maxY) node.maxY = c.maxY;
+  }
+};
+
+// ── Search (viewport query) ──────────────────────────────────────────────
+
+/**
+ * Find all items intersecting the given AABB.
+ * @param {{minX, minY, maxX, maxY}} bbox
+ * @returns {Array} array of items with _nodeId and _node references
+ */
+SpatialIndex.prototype.search = function(bbox) {
+  var result = [];
+  this._searchNode(this._root, bbox, result);
+  return result;
+};
+
+SpatialIndex.prototype._searchNode = function(node, bbox, result) {
+  if (!this._intersects(node, bbox)) return;
+
+  var children = node.children;
+  if (node.leaf) {
+    for (var i = 0; i < children.length; i++) {
+      if (this._intersects(children[i], bbox)) {
+        result.push(children[i]);
+      }
+    }
+  } else {
+    for (var i = 0; i < children.length; i++) {
+      this._searchNode(children[i], bbox, result);
+    }
+  }
+};
+
+SpatialIndex.prototype._intersects = function(a, b) {
+  return a.minX <= b.maxX && a.maxX >= b.minX &&
+         a.minY <= b.maxY && a.maxY >= b.minY;
+};
+
+// ── Point Query (hit-test) ───────────────────────────────────────────────
+
+/**
+ * Find all items containing the given point.
+ * @param {number} x - World X
+ * @param {number} y - World Y
+ * @returns {Array} items at this point
+ */
+SpatialIndex.prototype.pointQuery = function(x, y) {
+  var point = { minX: x, minY: y, maxX: x, maxY: y };
+  return this.search(point);
+};
+
+// ── Dynamic updates ──────────────────────────────────────────────────────
+
+/**
+ * Update a node's position in the spatial index.
+ * @param {Object} node — graph node with .id, .x, .y, ._radius
+ */
+SpatialIndex.prototype.updateNode = function(node) {
+  var item = this._nodeIdToItem[node.id];
+  if (!item) return;
+  var r = node._radius || 10;
+  item.minX = node.x - r;
+  item.minY = node.y - r;
+  item.maxX = node.x + r;
+  item.maxY = node.y + r;
+  node._aabb = item;
+  // Note: for optimal performance with frequent updates (e.g., during layout),
+  // we defer tree rebalancing. The tree stays valid but suboptimal.
+  // Call rebuildFromNodes() when layout stabilizes.
+  this._markAncestorsDirty();
+};
+
+SpatialIndex.prototype._markAncestorsDirty = function() {
+  // Simple approach: recalculate root bbox (propagation optimization deferred)
+  this._calcBBoxRecursive(this._root);
+};
+
+SpatialIndex.prototype._calcBBoxRecursive = function(node) {
+  if (node.leaf) {
+    this._calcBBox(node);
+    return;
+  }
+  for (var i = 0; i < node.children.length; i++) {
+    this._calcBBoxRecursive(node.children[i]);
+  }
+  this._calcBBox(node);
+};
+
+/**
+ * Remove a node from the spatial index.
+ */
+SpatialIndex.prototype.removeNode = function(nodeId) {
+  var item = this._nodeIdToItem[nodeId];
+  if (!item) return;
+  this._removeItem(this._root, item);
+  delete this._nodeIdToItem[nodeId];
+};
+
+SpatialIndex.prototype._removeItem = function(node, item) {
+  if (node.leaf) {
+    var idx = node.children.indexOf(item);
+    if (idx >= 0) {
+      node.children.splice(idx, 1);
+      this._calcBBox(node);
+      return true;
+    }
+    return false;
+  }
+  for (var i = 0; i < node.children.length; i++) {
+    if (this._intersects(node.children[i], item)) {
+      if (this._removeItem(node.children[i], item)) {
+        if (node.children[i].children.length === 0) {
+          node.children.splice(i, 1);
+        }
+        this._calcBBox(node);
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+/**
+ * Rebuild the tree (call after many updates/removes for optimal performance).
+ */
+SpatialIndex.prototype.rebuild = function(nodes) {
+  this.buildFromNodes(nodes);
+};
+
+/**
+ * Get the total number of items in the index.
+ */
+SpatialIndex.prototype.size = function() {
+  return Object.keys(this._nodeIdToItem).length;
+};
+
+// ============================================================================
+// Edge Spatial Index — R-tree for edges (AABB = bounding box of from→to)
+// ============================================================================
+
+/**
+ * Build the edge R-tree from all edges.
+ * Edge AABB = bounding box of (fromNode, toNode) positions.
+ * @param {Array} edges — [{id, from, to, ...}, ...]
+ * @param {Object} nodeMap — { nodeId → node }
+ */
+SpatialIndex.prototype.buildEdgeIndex = function(edges, nodeMap) {
+  this._edgeIdToItem = {};
+  if (!edges || edges.length === 0) {
+    this._edgeRoot = this._createNode([]);
+    return;
+  }
+
+  var items = [];
+  for (var i = 0; i < edges.length; i++) {
+    var e = edges[i];
+    var fromNode = nodeMap[e.from];
+    var toNode = nodeMap[e.to];
+    if (!fromNode || !toNode) continue;
+
+    var item = this._calcEdgeAABB(e, fromNode, toNode);
+    items.push(item);
+    this._edgeIdToItem[e.id] = item;
+  }
+
+  if (items.length === 0) {
+    this._edgeRoot = this._createNode([]);
+    return;
+  }
+
+  this._edgeRoot = this._buildSTR(items, 0, items.length - 1, 0);
+};
+
+/**
+ * Calculate AABB for an edge based on its endpoint node positions.
+ */
+SpatialIndex.prototype._calcEdgeAABB = function(edge, fromNode, toNode) {
+  var pad = 2; // small padding for line width
+  var minX = Math.min(fromNode.x, toNode.x) - pad;
+  var minY = Math.min(fromNode.y, toNode.y) - pad;
+  var maxX = Math.max(fromNode.x, toNode.x) + pad;
+  var maxY = Math.max(fromNode.y, toNode.y) + pad;
+  return {
+    minX: minX,
+    minY: minY,
+    maxX: maxX,
+    maxY: maxY,
+    _edgeId: edge.id,
+    _edge: edge,
+  };
+};
+
+/**
+ * Search for edges whose AABB intersects the given bounding box.
+ * @param {{minX, minY, maxX, maxY}} bbox
+ * @returns {Array} items with _edgeId and _edge references
+ */
+SpatialIndex.prototype.searchEdges = function(bbox) {
+  var result = [];
+  this._searchNode(this._edgeRoot, bbox, result);
+  return result;
+};
+
+/**
+ * Update edge AABBs when a node moves.
+ * @param {string} nodeId — the node that moved
+ * @param {Object} nodeEdges — { nodeId → [edge, ...] } adjacency list
+ * @param {Object} nodeMap — { nodeId → node }
+ */
+SpatialIndex.prototype.updateEdgesForNode = function(nodeId, nodeEdges, nodeMap) {
+  var edges = nodeEdges[nodeId] || [];
+  for (var i = 0; i < edges.length; i++) {
+    var e = edges[i];
+    var item = this._edgeIdToItem[e.id];
+    if (!item) continue;
+    var fromNode = nodeMap[e.from];
+    var toNode = nodeMap[e.to];
+    if (!fromNode || !toNode) continue;
+    var pad = 2;
+    item.minX = Math.min(fromNode.x, toNode.x) - pad;
+    item.minY = Math.min(fromNode.y, toNode.y) - pad;
+    item.maxX = Math.max(fromNode.x, toNode.x) + pad;
+    item.maxY = Math.max(fromNode.y, toNode.y) + pad;
+  }
+  // Propagate changes up (simple approach)
+  this._calcBBoxRecursive(this._edgeRoot);
+};
+
+/**
+ * Get the number of edges in the edge index.
+ */
+SpatialIndex.prototype.edgeSize = function() {
+  return Object.keys(this._edgeIdToItem).length;
+};
+
+// ============================================================================
+// Incremental Insert (Phase-8C) — add single items without full rebuild
+// ============================================================================
+
+/**
+ * Insert a single node into the R-tree incrementally.
+ * Uses simple insertion into the best-fit leaf.
+ * @param {Object} node — graph node with .id, .x, .y, ._radius
+ */
+SpatialIndex.prototype.insertNode = function(node) {
+  var r = node._radius || 10;
+  var item = {
+    minX: node.x - r,
+    minY: node.y - r,
+    maxX: node.x + r,
+    maxY: node.y + r,
+    _nodeId: node.id,
+    _node: node,
+  };
+  node._aabb = item;
+  this._nodeIdToItem[node.id] = item;
+  this._insertItem(this._root, item);
+};
+
+/**
+ * Insert a single edge into the edge R-tree incrementally.
+ * @param {Object} edge — graph edge
+ * @param {Object} fromNode — source node
+ * @param {Object} toNode — target node
+ */
+SpatialIndex.prototype.insertEdge = function(edge, fromNode, toNode) {
+  var item = this._calcEdgeAABB(edge, fromNode, toNode);
+  this._edgeIdToItem[edge.id] = item;
+  this._insertItem(this._edgeRoot, item);
+};
+
+/**
+ * Insert an item into an R-tree node (simple greedy insert).
+ * Finds the leaf with minimum area enlargement and adds the item.
+ */
+SpatialIndex.prototype._insertItem = function(root, item) {
+  var node = root;
+
+  // Traverse to find best leaf
+  while (!node.leaf) {
+    var bestChild = null;
+    var bestEnlargement = Infinity;
+    var bestArea = Infinity;
+
+    for (var i = 0; i < node.children.length; i++) {
+      var child = node.children[i];
+      var area = this._area(child);
+      var enlargement = this._enlargedArea(child, item) - area;
+
+      if (enlargement < bestEnlargement || (enlargement === bestEnlargement && area < bestArea)) {
+        bestEnlargement = enlargement;
+        bestArea = area;
+        bestChild = child;
+      }
+    }
+    node = bestChild;
+  }
+
+  // Add to leaf
+  node.children.push(item);
+
+  // Split if needed
+  if (node.children.length > this._maxEntries) {
+    this._splitNode(node);
+  }
+
+  // Update bounding boxes up the tree
+  this._calcBBoxRecursive(root);
+};
+
+SpatialIndex.prototype._area = function(node) {
+  return (node.maxX - node.minX) * (node.maxY - node.minY);
+};
+
+SpatialIndex.prototype._enlargedArea = function(node, item) {
+  var minX = Math.min(node.minX, item.minX);
+  var minY = Math.min(node.minY, item.minY);
+  var maxX = Math.max(node.maxX, item.maxX);
+  var maxY = Math.max(node.maxY, item.maxY);
+  return (maxX - minX) * (maxY - minY);
+};
+
+/**
+ * Split an overfull leaf into two halves (simple median split).
+ */
+SpatialIndex.prototype._splitNode = function(node) {
+  var items = node.children;
+  // Sort by center X
+  items.sort(function(a, b) {
+    return (a.minX + a.maxX) - (b.minX + b.maxX);
+  });
+  var mid = Math.ceil(items.length / 2);
+  node.children = items.slice(0, mid);
+  this._calcBBox(node);
+  // The remaining items need to go into a sibling —
+  // for simplicity, just keep them in the same node but in a new child
+  // This is a simplified split; full R-tree split would restructure parent
+  // For incremental adds, this is sufficient; periodic rebuild() restores optimal structure
+  var overflow = items.slice(mid);
+  for (var i = 0; i < overflow.length; i++) {
+    node.children.push(overflow[i]);
+  }
+  this._calcBBox(node);
+};
+`;
+}
+//# sourceMappingURL=spatial-index.js.map

package/dist/visualize/graph-canvas/spatial-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spatial-index.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/spatial-index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;AAEH,sDAkdC;AAldD,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgdR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/styles.d.ts

@@ -0,0 +1,11 @@
+/**
+ * StyleManager — DevPlan 节点/边样式系统
+ *
+ * 迁移自 vis-network 的样式规则:
+ * - 5 种节点类型样式 (project/module/main-task/sub-task/document)
+ * - 4 种状态颜色 (completed/in_progress/pending/cancelled)
+ * - 动态大小规则 (基于度数 sqrt 曲线)
+ * - 6 种边类型样式
+ */
+export declare function getStylesScript(): string;
+//# sourceMappingURL=styles.d.ts.map

package/dist/visualize/graph-canvas/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/styles.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,wBAAgB,eAAe,IAAI,MAAM,CA0IxC"}

package/dist/visualize/graph-canvas/styles.js

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * StyleManager — DevPlan 节点/边样式系统
+ *
+ * 迁移自 vis-network 的样式规则:
+ * - 5 种节点类型样式 (project/module/main-task/sub-task/document)
+ * - 4 种状态颜色 (completed/in_progress/pending/cancelled)
+ * - 动态大小规则 (基于度数 sqrt 曲线)
+ * - 6 种边类型样式
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStylesScript = getStylesScript;
+function getStylesScript() {
+    return `
+// ============================================================================
+// StyleManager — Node & Edge Styles
+// ============================================================================
+
+function StyleManager() {
+  // 从统一配置加载颜色 (如果 getUnifiedNodeStyle 可用)
+  var _uni = (typeof getUnifiedNodeStyle === 'function') ? getUnifiedNodeStyle() : null;
+
+  // Status colors
+  this.STATUS_COLORS = _uni ? _uni.statusGeneric : {
+    completed:   { bg: '#059669', border: '#047857', font: '#d1fae5' },
+    in_progress: { bg: '#7c3aed', border: '#6d28d9', font: '#ddd6fe' },
+    pending:     { bg: '#4b5563', border: '#374151', font: '#d1d5db' },
+    cancelled:   { bg: '#92400e', border: '#78350f', font: '#fde68a' },
+  };
+
+  // 统一样式缓存 (供 getNodeStyle 使用)
+  this._uniStyle = _uni;
+
+  // Node sizing rules by type
+  this.NODE_SIZE_RULES = {
+    'project':   { min: 35, max: 65, baseFont: 16, maxFont: 22, scale: 3.5 },
+    'module':    { min: 20, max: 45, baseFont: 12, maxFont: 16, scale: 2.8 },
+    'main-task': { min: 14, max: 38, baseFont: 11, maxFont: 15, scale: 2.2 },
+    'sub-task':  { min: 7,  max: 18, baseFont: 8,  maxFont: 11, scale: 1.5 },
+    'document':  { min: 12, max: 30, baseFont: 9,  maxFont: 13, scale: 1.8 },
+  };
+
+  // Node type shapes
+  this.NODE_SHAPES = {
+    'project': 'star',
+    'module': 'diamond',
+    'main-task': 'circle',
+    'sub-task': 'circle',
+    'document': 'box',
+  };
+
+  // Node type colors (for non-status-based types) — 从统一配置读取
+  this.NODE_COLORS = _uni ? {
+    'project': _uni.project,
+    'module':  _uni.module,
+    'document': _uni.document,
+  } : {
+    'project': { bg: '#f59e0b', border: '#d97706', font: '#fff' },
+    'module':  { bg: '#ff6600', border: '#cc5200', font: '#fff3e0' },
+    'document': { bg: '#2563eb', border: '#1d4ed8', font: '#dbeafe' },
+  };
+
+  // Edge styles by label
+  this.EDGE_STYLES = {
+    'has_main_task':  { width: 2, color: '#4b5563', highlightColor: '#93c5fd', dashes: null, arrows: true },
+    'has_sub_task':   { width: 1, color: '#4b5563', highlightColor: '#818cf8', dashes: null, arrows: true },
+    'has_document':   { width: 1, color: '#4b5563', highlightColor: '#60a5fa', dashes: [5, 5], arrows: true },
+    'module_has_task':{ width: 1.5, color: '#4b5563', highlightColor: '#ff8533', dashes: [2, 4], arrows: true },
+    'task_has_doc':   { width: 1.5, color: '#4b5563', highlightColor: '#f59e0b', dashes: [4, 3], arrows: true },
+    'doc_has_child':  { width: 1.5, color: '#4b5563', highlightColor: '#c084fc', dashes: [6, 3], arrows: true },
+  };
+
+  this.EDGE_DEFAULT = { width: 1, color: '#4b5563', highlightColor: '#9ca3af', dashes: null, arrows: false };
+}
+
+/**
+ * Compute node size and font size based on type and degree.
+ */
+StyleManager.prototype._calcNodeSize = function(type, degree) {
+  var rule = this.NODE_SIZE_RULES[type] || { min: 10, max: 22, baseFont: 10, maxFont: 13, scale: 1.0 };
+  var size = rule.min + rule.scale * Math.sqrt(degree || 0);
+  size = Math.max(rule.min, Math.min(size, rule.max));
+  var sizeRatio = (size - rule.min) / (rule.max - rule.min || 1);
+  var fontSize = Math.round(rule.baseFont + sizeRatio * (rule.maxFont - rule.baseFont));
+  return { size: Math.round(size), fontSize: fontSize };
+};
+
+/**
+ * Get style for a node.
+ * @param {Object} node
+ * @returns {Object} { shape, radius, bgColor, borderColor, borderWidth, fontColor, fontSize }
+ */
+StyleManager.prototype.getNodeStyle = function(node) {
+  var type = node.type || 'default';
+  var props = node.properties || {};
+  var status = props.status || 'pending';
+  var degree = node.degree || 0;
+
+  var ns = this._calcNodeSize(type, degree);
+  var shape = this.NODE_SHAPES[type] || 'circle';
+
+  // Determine colors — 从统一配置读取
+  var colors;
+  if (type === 'project' || type === 'module' || type === 'document') {
+    colors = this.NODE_COLORS[type] || this.STATUS_COLORS.pending;
+  } else if (type === 'main-task') {
+    // 主任务: 从统一配置读取状态颜色
+    var _mt = this._uniStyle ? this._uniStyle.mainTask : null;
+    colors = (_mt && _mt[status]) || (_mt && _mt.pending) || this.STATUS_COLORS[status] || this.STATUS_COLORS.pending;
+  } else {
+    // 子任务: 从统一配置读取状态颜色 (completed=亮绿色)
+    var _st = this._uniStyle ? this._uniStyle.subTask : null;
+    colors = (_st && _st[status]) || (_st && _st.pending) || this.STATUS_COLORS[status] || this.STATUS_COLORS.pending;
+  }
+
+  return {
+    shape: shape,
+    radius: ns.size,
+    bgColor: colors.bg,
+    borderColor: colors.border,
+    borderWidth: type === 'project' ? 3 : (type === 'sub-task' ? 1 : 2),
+    fontColor: colors.font,
+    fontSize: ns.fontSize,
+  };
+};
+
+/**
+ * Get style for an edge.
+ * @param {Object} edge
+ * @returns {Object} { width, color, highlightColor, dashes, arrows }
+ */
+StyleManager.prototype.getEdgeStyle = function(edge) {
+  var label = edge.label || edge._label || '';
+  return this.EDGE_STYLES[label] || this.EDGE_DEFAULT;
+};
+
+/**
+ * Apply styles to all nodes and edges (batch).
+ */
+StyleManager.prototype.applyAllStyles = function(nodes, edges) {
+  for (var i = 0; i < nodes.length; i++) {
+    var style = this.getNodeStyle(nodes[i]);
+    nodes[i]._style = style;
+    nodes[i]._radius = style.radius;
+  }
+  for (var i = 0; i < edges.length; i++) {
+    edges[i]._style = this.getEdgeStyle(edges[i]);
+  }
+};
+`;
+}
+//# sourceMappingURL=styles.js.map

package/dist/visualize/graph-canvas/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sourceRoot":"","sources":["../../../src/visualize/graph-canvas/styles.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG;;AAEH,0CA0IC;AA1ID,SAAgB,eAAe;IAC7B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwIR,CAAC;AACF,CAAC"}

package/dist/visualize/graph-canvas/viewport.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ViewportManager — 平移/缩放/手势 + 世界↔屏幕坐标变换
+ *
+ * 管理 2D 视口变换矩阵:
+ * screenX = worldX * scale + offsetX
+ * screenY = worldY * scale + offsetY
+ *
+ * 支持:
+ * - 鼠标拖拽平移
+ * - 滚轮缩放 (以鼠标位置为中心)
+ * - 触摸双指缩放
+ * - fit() 自适应视口
+ * - zoomTo() 定位到特定坐标
+ * - 惯性平移 (inertia)
+ */
+export declare function getViewportScript(): string;
+//# sourceMappingURL=viewport.d.ts.map