@elevasis/core 0.16.0 → 0.17.0

package/dist/knowledge/index.js

@@ -0,0 +1,138 @@
+// src/knowledge/queries.ts
+function toGraphNodeId(omNodeId) {
+  return `knowledge:${omNodeId}`;
+}
+function buildKnowledgeSourceIdMap(graph) {
+  const map = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    if (node.kind === "knowledge" && node.sourceId) {
+      map.set(node.id, node.sourceId);
+    }
+  }
+  return map;
+}
+function byFeature(graph, featureId, knowledgeNodes) {
+  const targetGraphNodeId = `feature:${featureId}`;
+  const governingKnowledgeNodeIds = /* @__PURE__ */ new Set();
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.targetId === targetGraphNodeId && edge.sourceId.startsWith("knowledge:")) {
+      governingKnowledgeNodeIds.add(edge.sourceId);
+    }
+  }
+  const sourceIdMap = buildKnowledgeSourceIdMap(graph);
+  const matchingOmIds = /* @__PURE__ */ new Set();
+  for (const graphNodeId of governingKnowledgeNodeIds) {
+    const omId = sourceIdMap.get(graphNodeId);
+    if (omId) matchingOmIds.add(omId);
+  }
+  return knowledgeNodes.filter((n) => matchingOmIds.has(n.id));
+}
+function byKind(_graph, kind, knowledgeNodes) {
+  return knowledgeNodes.filter((n) => n.kind === kind);
+}
+function byOwner(_graph, ownerId, knowledgeNodes) {
+  return knowledgeNodes.filter((n) => n.ownerIds.includes(ownerId));
+}
+function governs(graph, nodeId) {
+  const graphNodeId = nodeId.startsWith("knowledge:") ? nodeId : toGraphNodeId(nodeId);
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.sourceId === graphNodeId) {
+      results.push(edge.targetId);
+    }
+  }
+  return results;
+}
+function governedBy(graph, nodeId) {
+  const targetId = nodeId.startsWith("feature:") || nodeId.startsWith("knowledge:") || nodeId.startsWith("resource:") ? nodeId : `feature:${nodeId}`;
+  const results = [];
+  for (const edge of graph.edges) {
+    if (edge.kind === "governs" && edge.targetId === targetId) {
+      results.push(edge.sourceId);
+    }
+  }
+  return results;
+}
+function parsePath(pathString) {
+  if (!pathString || typeof pathString !== "string") {
+    throw new Error("parsePath: path must be a non-empty string");
+  }
+  if (!pathString.startsWith("/")) {
+    throw new Error(`parsePath: path must start with "/", got: "${pathString}"`);
+  }
+  const normalized = pathString.replace(/\/+$/, "");
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    throw new Error(`parsePath: path resolves to root with no mount: "${pathString}"`);
+  }
+  const [first, ...rest] = segments;
+  if (first === "by-feature") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-feature requires a featureId argument, got: "${pathString}"`);
+    }
+    return { mount: "by-feature", args: [rest.join("/")] };
+  }
+  if (first === "by-kind") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-kind requires a kind argument, got: "${pathString}"`);
+    }
+    return { mount: "by-kind", args: [rest[0]] };
+  }
+  if (first === "by-owner") {
+    if (rest.length === 0) {
+      throw new Error(`parsePath: /by-owner requires an ownerId argument, got: "${pathString}"`);
+    }
+    return { mount: "by-owner", args: [rest.join("/")] };
+  }
+  if (first === "graph") {
+    if (rest.length < 2) {
+      throw new Error(`parsePath: /graph requires <nodeId>/<verb> (governs|governed-by), got: "${pathString}"`);
+    }
+    const graphNodeId = rest.slice(0, -1).join("/");
+    const verb = rest[rest.length - 1];
+    if (verb !== "governs" && verb !== "governed-by") {
+      throw new Error(
+        `parsePath: /graph/<nodeId> verb must be "governs" or "governed-by", got: "${verb}" in "${pathString}"`
+      );
+    }
+    return { mount: "graph", args: [graphNodeId, verb] };
+  }
+  if (segments.length === 1) {
+    return { mount: "node", args: [first] };
+  }
+  throw new Error(
+    `parsePath: unrecognized path pattern "${pathString}". Supported: /by-feature/<id>, /by-kind/<kind>, /by-owner/<id>, /graph/<nodeId>/governs, /graph/<nodeId>/governed-by, /<nodeId>`
+  );
+}
+
+// src/knowledge/format.ts
+function formatText(results) {
+  if (results.length === 0) {
+    return "(no results)";
+  }
+  const kindWidth = Math.max(...results.map((n) => n.kind.length), 8);
+  const idWidth = Math.max(...results.map((n) => n.id.length), 4);
+  const header = `${"KIND".padEnd(kindWidth)}  ${"ID".padEnd(idWidth)}  TITLE`;
+  const divider = "-".repeat(header.length + 20);
+  const rows = results.map((n) => {
+    const summary = n.summary.length > 80 ? n.summary.slice(0, 77) + "..." : n.summary;
+    return `${n.kind.padEnd(kindWidth)}  ${n.id.padEnd(idWidth)}  ${n.title}  \u2014  ${summary}`;
+  });
+  return [header, divider, ...rows].join("\n");
+}
+function formatJson(input) {
+  const envelope = {
+    path: input.path,
+    mount: input.parsed.mount,
+    args: input.parsed.args,
+    results: input.results
+  };
+  return JSON.stringify(envelope, null, 2);
+}
+function formatIdsOnly(results) {
+  if (results.length === 0) return "";
+  const ids = results.map((r) => typeof r === "string" ? r : r.id);
+  return ids.join("\n");
+}
+
+export { byFeature, byKind, byOwner, formatIdsOnly, formatJson, formatText, governedBy, governs, parsePath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elevasis/core",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "license": "MIT",
   "description": "Minimal shared constants across Elevasis monorepo",
   "sideEffects": false,