@unified-product-graph/cloud-server 0.9.15 → 0.9.17

package/dist/index.js

@@ -1332,6 +1332,59 @@ 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";
+import { assembleTree } from "@unified-product-graph/sdk";
+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 +2137,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 +2414,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 +2427,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 +4297,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 +5323,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,