@datasynx/agentic-ai-cartography 2.5.0 → 2.6.0

package/dist/index.cjs

@@ -149,6 +149,7 @@ __export(src_exports, {
   diffTopology: () => diffTopology,
   edgesToConnections: () => edgesToConnections,
   enrichCosts: () => enrichCosts,
+  entitiesToYaml: () => entitiesToYaml,
   evaluateCheck: () => evaluateCheck,
   evaluateRule: () => evaluateRule,
   evidenceLine: () => evidenceLine,
@@ -278,6 +279,7 @@ __export(src_exports, {
   startApi: () => startApi,
   stripSensitive: () => stripSensitive,
   timingSafeEqual: () => timingSafeEqual,
+  toBackstageEntities: () => toBackstageEntities,
   validateScanner: () => validateScanner,
   vscodeDeeplink: () => vscodeDeeplink,
   zodToJsonSchema: () => zodToJsonSchema
@@ -4690,6 +4692,9 @@ var SqliteQueryBackend = class {
   node(ctx, id, sessionId) {
     return this.db.getNode(this.resolveSession(ctx, sessionId), id);
   }
+  edges(ctx, sessionId) {
+    return this.db.getEdges(this.resolveSession(ctx, sessionId));
+  }
   dependencies(ctx, id, q, sessionId) {
     const sid = this.resolveSession(ctx, sessionId);
     return this.db.getDependencies(sid, id, {
@@ -5932,7 +5937,7 @@ async function resolveNlQuery(db, sessionId, search, raw, opts) {
 
 // src/mcp/server.ts
 var SERVER_NAME = "cartography";
-var SERVER_VERSION = "2.5.0";
+var SERVER_VERSION = "2.6.0";
 var SERVICE_TYPES = NODE_TYPE_GROUPS.web;
 var DATA_TYPES = NODE_TYPE_GROUPS.data;
 var lexicalSearch = async (db, sessionId, query, opts) => db.searchNodes(sessionId, query, { types: opts.types, limit: opts.limit }).map((node) => ({ node }));
@@ -7465,6 +7470,54 @@ function headerValue(req, name) {
   return v;
 }
 
+// src/backstage.ts
+var COMPONENT_TYPES = ["web_service", "container", "pod"];
+function sanitize(id) {
+  return id.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function toBackstageEntities(nodes, edges, opts = {}) {
+  const owner = opts.org ?? "unknown";
+  return nodes.map((node) => {
+    const kind = COMPONENT_TYPES.includes(node.type) ? "Component" : node.type === "api_endpoint" ? "API" : "Resource";
+    const dependsOn = edges.filter((e) => e.sourceId === node.id).map((e) => `resource:default/${sanitize(e.targetId)}`);
+    return {
+      apiVersion: "backstage.io/v1alpha1",
+      kind,
+      metadata: {
+        name: sanitize(node.id),
+        annotations: {
+          "cartography/discovered-at": node.discoveredAt,
+          "cartography/confidence": String(node.confidence)
+        }
+      },
+      spec: {
+        type: node.type,
+        lifecycle: "production",
+        owner: node.owner ?? owner,
+        ...dependsOn.length > 0 ? { dependsOn } : {}
+      }
+    };
+  });
+}
+function entitiesToYaml(entities) {
+  return entities.map((e) => {
+    const lines = [
+      `apiVersion: ${e.apiVersion}`,
+      `kind: ${e.kind}`,
+      `metadata:`,
+      `  name: ${e.metadata.name}`,
+      `  annotations:`,
+      ...Object.entries(e.metadata.annotations).map(([k, v]) => `    ${k}: "${v}"`),
+      `spec:`,
+      `  type: ${e.spec.type}`,
+      `  lifecycle: ${e.spec.lifecycle}`,
+      `  owner: ${e.spec.owner}`,
+      ...e.spec.dependsOn && e.spec.dependsOn.length > 0 ? ["  dependsOn:", ...e.spec.dependsOn.map((d) => `    - ${d}`)] : []
+    ];
+    return lines.join("\n");
+  }).join("\n---\n");
+}
+
 // src/api/schemas.ts
 var import_zod8 = require("zod");
 var DIRECTIONS = ["downstream", "upstream", "both"];
@@ -7600,6 +7653,21 @@ var ErrorResponse = import_zod8.z.object({
   error: import_zod8.z.string(),
   code: import_zod8.z.string().optional()
 });
+var BackstageEntitySchema = import_zod8.z.object({
+  apiVersion: import_zod8.z.literal("backstage.io/v1alpha1"),
+  kind: import_zod8.z.enum(["Component", "API", "Resource"]),
+  metadata: import_zod8.z.object({
+    name: import_zod8.z.string(),
+    annotations: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.string())
+  }),
+  spec: import_zod8.z.object({
+    type: import_zod8.z.string(),
+    lifecycle: import_zod8.z.string(),
+    owner: import_zod8.z.string(),
+    dependsOn: import_zod8.z.array(import_zod8.z.string()).optional()
+  })
+});
+var BackstageCatalogResponse = import_zod8.z.object({ entities: import_zod8.z.array(BackstageEntitySchema) });
 var API_SCHEMAS = {
   Node: NodeSchema2,
   Edge: EdgeSchema2,
@@ -7611,10 +7679,13 @@ var API_SCHEMAS = {
   Session: SessionSchema,
   Sessions: SessionsResponse,
   Health: HealthResponse,
-  Error: ErrorResponse
+  Error: ErrorResponse,
+  BackstageEntity: BackstageEntitySchema,
+  BackstageCatalog: BackstageCatalogResponse
 };
 
 // src/api/rest.ts
+var BACKSTAGE_NODE_CAP = 1e3;
 function toApiNode(n) {
   const out = { id: n.id, type: n.type, name: n.name, confidence: n.confidence, tags: n.tags };
   if (n.domain !== void 0) out["domain"] = n.domain;
@@ -7749,6 +7820,14 @@ function handleHealth(ctx, d) {
   const h = d.backend.health(ctx);
   return ok(validateOut(HealthResponse, { status: "ok", version: d.version, store: h.store, sessions: h.sessions }));
 }
+function handleBackstageCatalog(ctx, d) {
+  return guard(() => {
+    const page = d.backend.nodes(ctx, { limit: BACKSTAGE_NODE_CAP });
+    const edges = d.backend.edges(ctx);
+    const entities = toBackstageEntities(page.nodes, edges, { org: ctx.tenant });
+    return ok(validateOut(BackstageCatalogResponse, { entities }));
+  });
+}
 
 // src/api/openapi.ts
 function defOf(schema) {
@@ -7905,6 +7984,13 @@ function buildOpenApiDocument(opts) {
           parameters: [TENANT_PARAM],
           responses: { "200": ok2("Sessions", "Sessions"), ...errorResponses() }
         }
+      },
+      "/v1/backstage/catalog": {
+        get: {
+          summary: "The tenant topology as Backstage catalog entities (live data source, 4.6)",
+          parameters: [SESSION_PARAM, TENANT_PARAM],
+          responses: { "200": ok2("BackstageCatalog", "Backstage catalog entities"), ...errorResponses() }
+        }
       }
     }
   };
@@ -8419,6 +8505,8 @@ function dispatchRest(ctx, path, url, deps) {
       return handleDiff(ctx, url, deps);
     case "/v1/sessions":
       return handleSessions(ctx, deps);
+    case "/v1/backstage/catalog":
+      return handleBackstageCatalog(ctx, deps);
     default: {
       const m = DEPENDENCIES_RE.exec(path);
       if (m) return handleDependencies(ctx, decodeURIComponent(m[1]), url, deps);
@@ -9925,7 +10013,7 @@ var MERMAID_CLASSES = {
   saas_tool: "fill:#2a1a2a,stroke:#9a3a9a,color:#daf",
   unknown: "fill:#2a2a2a,stroke:#5a5a5a,color:#aaa"
 };
-function sanitize(id) {
+function sanitize2(id) {
   return id.replace(/[^a-zA-Z0-9_]/g, "_");
 }
 function nodeLabel(node) {
@@ -9967,14 +10055,14 @@ function generateTopologyMermaid(nodes, edges) {
     const label = LAYER_LABELS[layerKey] ?? layerKey;
     lines.push(`    subgraph ${layerKey}["${label}"]`);
     for (const node of layerNodes) {
-      lines.push(`      ${sanitize(node.id)}${nodeLabel(node)}:::${node.type.replace(/_/g, "")}`);
+      lines.push(`      ${sanitize2(node.id)}${nodeLabel(node)}:::${node.type.replace(/_/g, "")}`);
     }
     lines.push("    end");
     lines.push("");
   }
   for (const edge of edges) {
-    const src = sanitize(edge.sourceId);
-    const tgt = sanitize(edge.targetId);
+    const src = sanitize2(edge.sourceId);
+    const tgt = sanitize2(edge.targetId);
     const label = EDGE_LABELS[edge.relationship] ?? edge.relationship;
     const arrow = edge.confidence < 0.6 ? `-. "${label}" .->` : `-->|"${label}"|`;
     lines.push(`    ${src} ${arrow} ${tgt}`);
@@ -10000,12 +10088,12 @@ function generateDependencyMermaid(nodes, edges) {
   }
   lines.push("");
   for (const node of usedNodes) {
-    lines.push(`    ${sanitize(node.id)}${nodeLabel(node)}:::${node.type.replace(/_/g, "")}`);
+    lines.push(`    ${sanitize2(node.id)}${nodeLabel(node)}:::${node.type.replace(/_/g, "")}`);
   }
   lines.push("");
   for (const edge of depEdges) {
     const label = EDGE_LABELS[edge.relationship] ?? edge.relationship;
-    lines.push(`    ${sanitize(edge.sourceId)} -->|"${label}"| ${sanitize(edge.targetId)}`);
+    lines.push(`    ${sanitize2(edge.sourceId)} -->|"${label}"| ${sanitize2(edge.targetId)}`);
   }
   return lines.join("\n");
 }
@@ -10056,44 +10144,21 @@ function generateDiffMermaid(diff) {
     ensureEndpoint(e.targetId);
   }
   for (const { node, cls, suffix } of entries.values()) {
-    lines.push(`    ${sanitize(node.id)}${diffNodeLabel(node, suffix)}:::${cls}`);
+    lines.push(`    ${sanitize2(node.id)}${diffNodeLabel(node, suffix)}:::${cls}`);
   }
   lines.push("");
   for (const e of diff.edges.added) {
     const label = EDGE_LABELS[e.relationship] ?? e.relationship;
-    lines.push(`    ${sanitize(e.sourceId)} ==>|"+ ${label}"| ${sanitize(e.targetId)}`);
+    lines.push(`    ${sanitize2(e.sourceId)} ==>|"+ ${label}"| ${sanitize2(e.targetId)}`);
   }
   for (const e of diff.edges.removed) {
     const label = EDGE_LABELS[e.relationship] ?? e.relationship;
-    lines.push(`    ${sanitize(e.sourceId)} -.->|"- ${label}"| ${sanitize(e.targetId)}`);
+    lines.push(`    ${sanitize2(e.sourceId)} -.->|"- ${label}"| ${sanitize2(e.targetId)}`);
   }
   return lines.join("\n");
 }
 function exportBackstageYAML(nodes, edges, org) {
-  const owner = org ?? "unknown";
-  const docs = [];
-  for (const node of nodes) {
-    const isComponent = ["web_service", "container", "pod"].includes(node.type);
-    const isAPI = node.type === "api_endpoint";
-    const kind = isComponent ? "Component" : isAPI ? "API" : "Resource";
-    const deps = edges.filter((e) => e.sourceId === node.id).map((e) => `    - resource:default/${sanitize(e.targetId)}`);
-    const doc = [
-      `apiVersion: backstage.io/v1alpha1`,
-      `kind: ${kind}`,
-      `metadata:`,
-      `  name: ${sanitize(node.id)}`,
-      `  annotations:`,
-      `    cartography/discovered-at: "${node.discoveredAt}"`,
-      `    cartography/confidence: "${node.confidence}"`,
-      `spec:`,
-      `  type: ${node.type}`,
-      `  lifecycle: production`,
-      `  owner: ${node.owner ?? owner}`,
-      ...deps.length > 0 ? ["  dependsOn:", ...deps] : []
-    ].join("\n");
-    docs.push(doc);
-  }
-  return docs.join("\n---\n");
+  return entitiesToYaml(toBackstageEntities(nodes, edges, org !== void 0 ? { org } : {}));
 }
 function exportJSON(db, sessionId) {
   const nodes = db.getNodes(sessionId);
@@ -11898,6 +11963,7 @@ function checkClaudePrerequisites() {
   diffTopology,
   edgesToConnections,
   enrichCosts,
+  entitiesToYaml,
   evaluateCheck,
   evaluateRule,
   evidenceLine,
@@ -12027,6 +12093,7 @@ function checkClaudePrerequisites() {
   startApi,
   stripSensitive,
   timingSafeEqual,
+  toBackstageEntities,
   validateScanner,
   vscodeDeeplink,
   zodToJsonSchema