@elevasis/sdk 1.20.2 → 1.22.0

package/dist/node/index.d.ts

@@ -5,19 +5,17 @@ interface KnowledgeCodegenNode {
     title: string;
     summary: string;
     icon?: string;
+    sourceFilePath?: string;
     body: string;
     links: {
         nodeId: string;
     }[];
-    skills: string[];
-    domain?: string;
     ownerIds: string[];
     updatedAt: string;
 }
 interface GenerateKnowledgeNodesOptions {
     sourceDir: string;
     outputPath: string;
-    graphSkillsOutputPath?: string;
     knowledgeFlagsOutputPath?: string;
     knowledgeFlagsCliCommand?: string;
     typeImportPath?: string;

package/dist/node/index.js

@@ -4,6 +4,22 @@ import { compile } from '@mdx-js/mdx';
 import remarkGfm from 'remark-gfm';
 
 // src/knowledge-codegen.ts
+function targetFromNodeId(nodeId) {
+  const [kind, ...idParts] = nodeId.split(":");
+  return {
+    kind,
+    id: idParts.join(":")
+  };
+}
+function canonicalizeKnowledgeNodeLinks(node) {
+  return {
+    ...node,
+    links: node.links.map((link) => ({
+      target: targetFromNodeId(link.nodeId),
+      nodeId: link.nodeId
+    }))
+  };
+}
 function listMdxFiles(directory) {
   return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
     const path = join(directory, entry.name);
@@ -128,6 +144,18 @@ var ROUTING_STOPWORDS = /* @__PURE__ */ new Set([
 function toRegistryPath(path) {
   return path.replace(/\\/g, "/");
 }
+function sourceBaseFromLabel(sourceLabel) {
+  if (!sourceLabel) return void 0;
+  const normalized = toRegistryPath(sourceLabel).replace(/\/+$/, "");
+  const globIndex = normalized.indexOf("*");
+  if (globIndex === -1) return normalized;
+  return normalized.slice(0, globIndex).replace(/\/+$/, "");
+}
+function toSourceFilePath(sourceLabel, relativePath) {
+  const normalizedRelativePath = toRegistryPath(relativePath);
+  const sourceBase = sourceBaseFromLabel(sourceLabel);
+  return sourceBase ? `${sourceBase}/${normalizedRelativePath}` : normalizedRelativePath;
+}
 function slugify(value) {
   return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
 }
@@ -161,24 +189,20 @@ function nodeRoutingTerms(node, sourcePath, limit) {
       node.title,
       node.summary,
       node.body,
-      node.domain ?? "",
       sourcePath,
-      ...node.links.map((link) => link.nodeId),
-      ...node.skills
+      ...node.links.map((link) => link.nodeId)
     ),
     limit
   );
 }
 function nodeTags(node, sourcePath) {
   return uniqueSorted([
-    ...node.domain ? [node.domain] : [],
     node.kind,
     ...tokenizeRoutingText(
       node.title,
       node.summary,
       sourcePath,
-      ...node.links.map((link) => link.nodeId),
-      ...node.skills
+      ...node.links.map((link) => link.nodeId)
     ).map(slugify).filter((term) => term && !ROUTING_STOPWORDS.has(term) && (term.length >= 3 || term === "ai")).slice(0, 20)
   ]);
 }
@@ -205,58 +229,30 @@ function readKnowledgeNodeMdx(filePath) {
     icon: optionalString(frontmatter, "icon", filePath),
     body,
     links: optionalStringArray(frontmatter, "links", filePath).map((nodeId) => ({ nodeId })),
-    skills: optionalStringArray(frontmatter, "skills", filePath),
-    domain: optionalString(frontmatter, "domain", filePath),
     ownerIds: optionalStringArray(frontmatter, "ownerIds", filePath),
     updatedAt: assertString(frontmatter, "updatedAt", filePath)
   };
 }
-function generateGraphSkillsRegistry(nodes) {
-  const domains = {};
-  for (const node of nodes) {
-    if (!node.domain) continue;
-    const domain = domains[node.domain] ?? { skills: [], nodes: [] };
-    const skills = [...new Set(node.skills)].sort((a, b) => a.localeCompare(b));
-    domain.nodes.push({
-      id: node.id,
-      title: node.title,
-      kind: node.kind,
-      skills
-    });
-    domain.skills = [.../* @__PURE__ */ new Set([...domain.skills, ...skills])].sort((a, b) => a.localeCompare(b));
-    domains[node.domain] = domain;
-  }
-  for (const domain of Object.values(domains)) {
-    domain.nodes.sort((a, b) => a.id.localeCompare(b.id));
-  }
-  return {
-    generatedBy: "generate-knowledge-nodes",
-    domains: Object.fromEntries(Object.entries(domains).sort(([a], [b]) => a.localeCompare(b)))
-  };
-}
 function generateKnowledgeFlagRegistry(nodes, sourcePaths = {}, options = {}) {
   const routes = /* @__PURE__ */ new Map();
   for (const node of nodes) {
-    const routeKey = node.domain ?? `kind-${node.kind}`;
+    const routeKey = `kind-${node.kind}`;
     const flag = `--${slugify(routeKey)}`;
     const sourcePath = toRegistryPath(sourcePaths[node.id] ?? "");
     const routingTerms = nodeRoutingTerms(node, sourcePath, 24);
     const tags = nodeTags(node, sourcePath);
-    const skills = uniqueSorted(node.skills);
     const cliBindings = readCommandForNode(node, options.cliCommand);
     const route = routes.get(flag) ?? {
       flag,
       label: toTitle(routeKey),
-      ...node.domain ? { domain: node.domain } : { kind: node.kind },
+      kind: node.kind,
       tags: [],
       queryTerms: [],
-      skills: [],
       cliBindings: [],
       nodes: []
     };
     route.tags = uniqueSorted([...route.tags, ...tags]);
     route.queryTerms = rankedTerms([...route.queryTerms, ...routingTerms], 40);
-    route.skills = uniqueSorted([...route.skills, ...skills]);
     route.cliBindings = [...route.cliBindings, ...cliBindings].filter(
       (binding, index, bindings) => bindings.findIndex((candidate) => candidate.command === binding.command) === index
     );
@@ -264,12 +260,10 @@ function generateKnowledgeFlagRegistry(nodes, sourcePaths = {}, options = {}) {
       id: node.id,
       title: node.title,
       kind: node.kind,
-      ...node.domain ? { domain: node.domain } : {},
       sourcePath,
       tags,
       routingTerms,
       links: node.links.map((link) => link.nodeId),
-      skills,
       cliBindings
     });
     routes.set(flag, route);
@@ -317,7 +311,7 @@ function generateKnowledgeNodesTs(options) {
     `// Source: ${options.sourceLabel ?? "knowledge/nodes/**/*.mdx"}`,
     "",
     ...typeImport,
-    `export const ${exportedName} = ${JSON.stringify(options.nodes, null, 2)}${typeSatisfies}`,
+    `export const ${exportedName} = ${JSON.stringify(options.nodes.map(canonicalizeKnowledgeNodeLinks), null, 2)}${typeSatisfies}`,
     ""
   ].join("\n");
 }
@@ -325,7 +319,13 @@ function generateKnowledgeNodes(options) {
   const files = listMdxFiles(options.sourceDir).sort(
     (a, b) => relative(options.sourceDir, a).localeCompare(relative(options.sourceDir, b))
   );
-  const nodes = files.map(readKnowledgeNodeMdx);
+  const nodes = files.map((file) => {
+    const relativePath = relative(options.sourceDir, file);
+    return {
+      ...readKnowledgeNodeMdx(file),
+      sourceFilePath: toSourceFilePath(options.sourceLabel, relativePath)
+    };
+  });
   const sourcePaths = Object.fromEntries(
     files.map((file, index) => [nodes[index].id, toRegistryPath(relative(options.sourceDir, file))])
   );
@@ -345,15 +345,6 @@ function generateKnowledgeNodes(options) {
     }),
     "utf8"
   );
-  if (options.graphSkillsOutputPath) {
-    mkdirSync(dirname(options.graphSkillsOutputPath), { recursive: true });
-    writeFileSync(
-      options.graphSkillsOutputPath,
-      `${JSON.stringify(generateGraphSkillsRegistry(nodes), null, 2)}
-`,
-      "utf8"
-    );
-  }
   if (options.knowledgeFlagsOutputPath) {
     mkdirSync(dirname(options.knowledgeFlagsOutputPath), { recursive: true });
     writeFileSync(