@unified-product-graph/cloud-server 0.9.14 → 0.9.16

package/dist/index.js

@@ -998,6 +998,148 @@ function textError(s) {
   return { content: [{ type: "text", text: s }], isError: true };
 }
 
+// ../upg-mcp-tooling/dist/tree-assemble.js
+var DEFAULT_MAX_NODES = 400;
+function shell(reader, id, includeProps) {
+  const n = reader.getNode(id);
+  if (!n)
+    return void 0;
+  const node = { id: n.id, type: n.type, title: n.title, children: [] };
+  if (n.status)
+    node.status = n.status;
+  if (includeProps && includeProps.length > 0 && n.properties) {
+    const picked = {};
+    for (const k of includeProps) {
+      if (k in n.properties)
+        picked[k] = n.properties[k];
+    }
+    if (Object.keys(picked).length > 0)
+      node.properties = picked;
+  }
+  return node;
+}
+function childrenOf(reader, nodeId2, childTypes) {
+  if (childTypes.length === 0)
+    return [];
+  const allow = new Set(childTypes);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of reader.getEdgesForNode(nodeId2)) {
+    if (e.source !== nodeId2)
+      continue;
+    if (seen.has(e.target))
+      continue;
+    const t = reader.getNode(e.target);
+    if (t && allow.has(t.type)) {
+      out.push(e.target);
+      seen.add(e.target);
+    }
+  }
+  return out;
+}
+function assembleTree(reader, pattern, opts) {
+  const maxNodes = Math.min(Math.max(opts.max_nodes ?? DEFAULT_MAX_NODES, 1), 2e3);
+  const maxDepth = Math.min(Math.max(opts.depth ?? pattern.natural_depth, 1), 12);
+  const includeProps = opts.include_properties;
+  const buildFrom = (rootIds, anchorType) => {
+    const visited = /* @__PURE__ */ new Set();
+    const gaps = [];
+    let nodes = 0;
+    let levels = 0;
+    let truncated = false;
+    let childCount = 0;
+    const expand = (node, depth) => {
+      if (depth > levels)
+        levels = depth;
+      const childTypes = pattern.child_map[node.type] ?? [];
+      if (depth >= maxDepth) {
+        if (childTypes.length > 0 && childrenOf(reader, node.id, childTypes).length > 0)
+          truncated = true;
+        return;
+      }
+      const childIds = childrenOf(reader, node.id, childTypes);
+      if (childTypes.length > 0 && childIds.length === 0) {
+        gaps.push({ node_id: node.id, type: node.type, title: node.title, missing: childTypes });
+        return;
+      }
+      for (const cid of childIds) {
+        if (visited.has(cid))
+          continue;
+        if (nodes >= maxNodes) {
+          truncated = true;
+          return;
+        }
+        const child = shell(reader, cid, includeProps);
+        if (!child)
+          continue;
+        visited.add(cid);
+        nodes++;
+        childCount++;
+        node.children.push(child);
+        expand(child, depth + 1);
+      }
+    };
+    const roots = [];
+    for (const rid of rootIds) {
+      if (visited.has(rid))
+        continue;
+      if (nodes >= maxNodes) {
+        truncated = true;
+        break;
+      }
+      const root = shell(reader, rid, includeProps);
+      if (!root)
+        continue;
+      visited.add(rid);
+      nodes++;
+      roots.push(root);
+      expand(root, 1);
+    }
+    return { anchorType, roots, nodes, levels, truncated, gaps, childCount };
+  };
+  if (opts.from_id) {
+    const n = reader.getNode(opts.from_id);
+    const anchorType = n?.type ?? pattern.anchor_type;
+    const b = buildFrom([opts.from_id], anchorType);
+    return {
+      pattern: pattern.id,
+      framework_id: pattern.framework_id,
+      anchor_type: pattern.anchor_type,
+      anchor_used: anchorType,
+      roots: b.roots,
+      stats: { nodes: b.nodes, levels: b.levels, truncated: b.truncated },
+      gaps: b.gaps
+    };
+  }
+  const candidates = [pattern.anchor_type, ...pattern.fallback_anchors];
+  const idsOfType = (type) => reader.getAllNodes().filter((n) => n.type === type).map((n) => n.id);
+  let chosen;
+  for (const cand of candidates) {
+    const rootIds = idsOfType(cand);
+    if (rootIds.length === 0)
+      continue;
+    const b = buildFrom(rootIds, cand);
+    chosen = b;
+    if (b.childCount > 0)
+      break;
+  }
+  if (!chosen) {
+    chosen = { anchorType: pattern.anchor_type, roots: [], nodes: 0, levels: 0, truncated: false, gaps: [], childCount: 0 };
+  }
+  const result = {
+    pattern: pattern.id,
+    framework_id: pattern.framework_id,
+    anchor_type: pattern.anchor_type,
+    anchor_used: chosen.anchorType,
+    roots: chosen.roots,
+    stats: { nodes: chosen.nodes, levels: chosen.levels, truncated: chosen.truncated },
+    gaps: chosen.gaps
+  };
+  if (chosen.anchorType !== pattern.anchor_type)
+    result.anchor_resolved_from = pattern.anchor_type;
+  return result;
+}
+
 // ../upg-mcp-tooling/dist/catalog.js
 import { UPG_EDGE_CATALOG, UPG_PROPERTY_SCHEMA, getDomainForType, getGuideForDomain, getLifecycleForType, getPropertySchema, resolveEntityType, UnknownEntityTypeError } from "@unified-product-graph/core";
 function buildEntitySchema(rawType, options = {}) {
@@ -1332,6 +1474,58 @@ var getChanges = async (args, { store }) => {
   return text(JSON.stringify({ changes: filtered, total: filtered.length }, null, 2));
 };
 
+// src/tools/tree.ts
+import { getTreePattern, UPG_TREE_PATTERNS } from "@unified-product-graph/core";
+var getTree = async (args, { store }) => {
+  if (!args.product_id) return textError("Missing required parameter: product_id");
+  const productId = args.product_id;
+  const patternId = args.pattern;
+  if (!patternId) {
+    return textError(
+      `Missing required parameter: pattern. One of: ${UPG_TREE_PATTERNS.map((p) => p.id).join(", ")}.`
+    );
+  }
+  const pattern = getTreePattern(patternId);
+  if (!pattern) {
+    return textError(
+      `Unknown tree pattern: "${patternId}". Valid patterns: ${UPG_TREE_PATTERNS.map((p) => p.id).join(", ")}.`
+    );
+  }
+  const includeProperties = Array.isArray(args.include_properties) ? args.include_properties : void 0;
+  const allNodes = await store.getAllNodes(productId);
+  const allEdges = await store.getAllEdges(productId);
+  const nodeById = new Map(allNodes.map((n) => [n.id, n]));
+  const edgesByNode = /* @__PURE__ */ new Map();
+  for (const e of allEdges) {
+    let src = edgesByNode.get(e.source);
+    if (!src) {
+      src = [];
+      edgesByNode.set(e.source, src);
+    }
+    src.push(e);
+    if (e.target !== e.source) {
+      let tgt = edgesByNode.get(e.target);
+      if (!tgt) {
+        tgt = [];
+        edgesByNode.set(e.target, tgt);
+      }
+      tgt.push(e);
+    }
+  }
+  const reader = {
+    getNode: (id) => nodeById.get(id),
+    getAllNodes: () => allNodes,
+    getEdgesForNode: (id) => edgesByNode.get(id) ?? []
+  };
+  const result = assembleTree(reader, pattern, {
+    from_id: args.from_id,
+    depth: args.depth,
+    include_properties: includeProperties,
+    max_nodes: args.max_nodes
+  });
+  return text(JSON.stringify(result, null, 2));
+};
+
 // src/tools/nodes.ts
 import { getLifecycleForType as getLifecycleForType2, resolveEntityType as resolveEntityType2, UnknownEntityTypeError as UnknownEntityTypeError2 } from "@unified-product-graph/core";
 import {
@@ -2084,6 +2278,9 @@ import {
   UPG_REGIONS,
   UPG_REGION_MAP,
   UPG_REGION_COUNT,
+  UPG_AREA_TAXONOMY,
+  getCoverageKeysForRegion,
+  getBusinessAreasForRegion,
   UPG_LENSES,
   UPG_TYPE_LABELS,
   UPG_TYPE_LABELS_MAP,
@@ -2358,10 +2555,12 @@ var listRegions = () => {
     composes_atomic_domains: r.composes_atomic_domains,
     entity_count: r.entities.length,
     intra_edge_count: r.intra_edges.length,
-    boundary_edge_count: r.boundary_edges.length
+    boundary_edge_count: r.boundary_edges.length,
+    coverage_keys: getCoverageKeysForRegion(r.id),
+    business_areas: getBusinessAreasForRegion(r.id)
   }));
   return text(
-    JSON.stringify({ count: UPG_REGION_COUNT, regions }, null, 2)
+    JSON.stringify({ count: UPG_REGION_COUNT, regions, area_taxonomy: UPG_AREA_TAXONOMY }, null, 2)
   );
 };
 var getRegion = (args) => {
@@ -2369,7 +2568,11 @@ var getRegion = (args) => {
   if (!id) return textError("Missing required parameter: id");
   const region = UPG_REGION_MAP[id];
   if (!region) return textError(`Unknown region id: ${id}`);
-  return text(JSON.stringify(region, null, 2));
+  return text(JSON.stringify({
+    ...region,
+    coverage_keys: getCoverageKeysForRegion(id),
+    business_areas: getBusinessAreasForRegion(id)
+  }, null, 2));
 };
 var getRegionForEntity = (args) => {
   const entityType = args.entity_type;
@@ -4235,6 +4438,46 @@ var TOOL_DEFINITIONS = [
       ]
     }
   },
+  {
+    "name": "get_tree",
+    "description": "Assemble a canonical tree pattern (ost, okr, user, product, validation, strategy, feature_areas) from the product graph. Walks the pattern's type-driven child map over the live graph (drift-proof, follows whatever edge wired each parent to a child of the expected type), roots at the pattern anchor with fallback, and reports structural gaps. Returns nested data, not rendered text.",
+    "inputSchema": {
+      "type": "object",
+      "properties": {
+        "product_id": {
+          "type": "string",
+          "description": "The product ID"
+        },
+        "pattern": {
+          "type": "string",
+          "description": "Tree pattern id: ost, okr, user, product, validation, strategy, feature_areas"
+        },
+        "from_id": {
+          "type": "string",
+          "description": "Explicit root node id. Defaults to the pattern's canonical anchor type."
+        },
+        "depth": {
+          "type": "number",
+          "description": "Max levels. Defaults to the pattern's natural depth."
+        },
+        "include_properties": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Node property keys to inline on each tree node."
+        },
+        "max_nodes": {
+          "type": "number",
+          "description": "Cap on assembled nodes. The tree is summarised (stats.truncated) rather than silently cut."
+        }
+      },
+      "required": [
+        "product_id",
+        "pattern"
+      ]
+    }
+  },
   {
     "name": "get_graph_digest",
     "description": "Pre-computed graph analytics: counts, health metrics, chain completeness, business area coverage, lifecycle balance. ~500 tokens vs ~5-8K for equivalent manual fetches.",
@@ -5221,6 +5464,7 @@ var HANDLERS = {
   get_product_context: getProductContext,
   get_graph_digest: getGraphDigest,
   query,
+  get_tree: getTree,
   get_changes: getChanges,
   list_nodes: listNodes,
   export_upg_document: exportUpgDocument,