@elevasis/sdk 1.19.0 → 1.20.0

package/dist/node/index.d.ts

@@ -18,6 +18,7 @@ interface GenerateKnowledgeNodesOptions {
     sourceDir: string;
     outputPath: string;
     graphSkillsOutputPath?: string;
+    knowledgeFlagsOutputPath?: string;
     typeImportPath?: string;
     exportedName?: string;
     sourceLabel?: string;

package/dist/node/index.js

@@ -68,6 +68,132 @@ function optionalStringArray(frontmatter, key, filePath) {
   }
   return value.map((entry) => entry.trim()).filter(Boolean);
 }
+var ROUTING_STOPWORDS = /* @__PURE__ */ new Set([
+  "about",
+  "after",
+  "again",
+  "against",
+  "all",
+  "also",
+  "and",
+  "any",
+  "are",
+  "before",
+  "but",
+  "can",
+  "cannot",
+  "could",
+  "for",
+  "from",
+  "has",
+  "have",
+  "how",
+  "into",
+  "its",
+  "may",
+  "more",
+  "must",
+  "not",
+  "now",
+  "off",
+  "one",
+  "only",
+  "our",
+  "out",
+  "over",
+  "per",
+  "run",
+  "same",
+  "should",
+  "than",
+  "that",
+  "the",
+  "their",
+  "then",
+  "there",
+  "this",
+  "through",
+  "use",
+  "uses",
+  "using",
+  "when",
+  "where",
+  "with",
+  "workflow",
+  "workflows",
+  "would",
+  "you",
+  "your"
+]);
+function toRegistryPath(path) {
+  return path.replace(/\\/g, "/");
+}
+function slugify(value) {
+  return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toTitle(value) {
+  return value.split(/[-:\s]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function tokenizeRoutingText(...values) {
+  return values.join(" ").toLowerCase().replace(/```[\s\S]*?```/g, " ").replace(/[\\/]/g, " ").match(/[a-z0-9]+(?:[.-][a-z0-9]+)*/g)?.flatMap((token) => {
+    const expanded = token.includes(".") ? [token, ...token.split(".")] : [token];
+    return expanded.flatMap((entry) => entry.includes("-") ? [entry, ...entry.split("-")] : [entry]);
+  }) ?? [];
+}
+function rankedTerms(values, limit) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const token = slugify(value);
+    if (!token || ROUTING_STOPWORDS.has(token)) continue;
+    if (token.length < 3 && token !== "ai") continue;
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  return [...counts.entries()].sort(([termA, countA], [termB, countB]) => countB - countA || termA.localeCompare(termB)).slice(0, limit).map(([term]) => term);
+}
+function uniqueSorted(values) {
+  return [...new Set(values.filter(Boolean))].sort((a, b) => a.localeCompare(b));
+}
+function nodeRoutingTerms(node, sourcePath, limit) {
+  return rankedTerms(
+    tokenizeRoutingText(
+      node.id,
+      node.kind,
+      node.title,
+      node.summary,
+      node.body,
+      node.domain ?? "",
+      sourcePath,
+      ...node.links.map((link) => link.nodeId),
+      ...node.skills
+    ),
+    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
+    ).map(slugify).filter((term) => term && !ROUTING_STOPWORDS.has(term) && (term.length >= 3 || term === "ai")).slice(0, 20)
+  ]);
+}
+function readCommandForNode(node) {
+  return [
+    {
+      command: `pnpm exec elevasis knowledge:cat ${node.id}`,
+      description: `Read ${node.title}`
+    },
+    {
+      command: `pnpm exec elevasis knowledge:ls /by-kind/${node.kind}`,
+      description: `List ${node.kind} knowledge nodes`
+    }
+  ];
+}
 function readKnowledgeNodeMdx(filePath) {
   const raw = readFileSync(filePath, "utf8");
   const { frontmatter, body } = parseFrontmatter(raw, filePath);
@@ -108,6 +234,79 @@ function generateGraphSkillsRegistry(nodes) {
     domains: Object.fromEntries(Object.entries(domains).sort(([a], [b]) => a.localeCompare(b)))
   };
 }
+function generateKnowledgeFlagRegistry(nodes, sourcePaths = {}) {
+  const routes = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const routeKey = node.domain ?? `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);
+    const route = routes.get(flag) ?? {
+      flag,
+      label: toTitle(routeKey),
+      ...node.domain ? { domain: node.domain } : { 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
+    );
+    route.nodes.push({
+      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);
+  }
+  const sortedRoutes = [...routes.values()].sort((a, b) => a.flag.localeCompare(b.flag));
+  const aliasCandidates = sortedRoutes.flatMap((route) => {
+    const aliasTerms = uniqueSorted([
+      route.flag.replace(/^--/, ""),
+      route.label.toLowerCase(),
+      ...route.tags.slice(0, 12),
+      ...route.queryTerms.slice(0, 12)
+    ]);
+    return aliasTerms.map((alias) => [alias, route.flag]);
+  });
+  const aliasCounts = aliasCandidates.reduce((counts, [alias]) => {
+    counts.set(alias, (counts.get(alias) ?? 0) + 1);
+    return counts;
+  }, /* @__PURE__ */ new Map());
+  const aliases = Object.fromEntries(
+    aliasCandidates.filter(([alias]) => aliasCounts.get(alias) === 1).sort(([aliasA], [aliasB]) => aliasA.localeCompare(aliasB))
+  );
+  return {
+    generatedBy: "generate-knowledge-nodes",
+    routingMode: "deterministic-keyword",
+    flags: Object.fromEntries(
+      sortedRoutes.map((route) => [
+        route.flag,
+        {
+          ...route,
+          cliBindings: route.cliBindings.sort((a, b) => a.command.localeCompare(b.command)),
+          nodes: route.nodes.sort((a, b) => a.id.localeCompare(b.id))
+        }
+      ])
+    ),
+    aliases
+  };
+}
 function generateKnowledgeNodesTs(options) {
   const exportedName = options.exportedName ?? "mdxKnowledgeNodes";
   const typeImport = options.typeImportPath ? [`import type { OrgKnowledgeNode } from '${options.typeImportPath}'`, ""] : [];
@@ -127,6 +326,9 @@ function generateKnowledgeNodes(options) {
     (a, b) => relative(options.sourceDir, a).localeCompare(relative(options.sourceDir, b))
   );
   const nodes = files.map(readKnowledgeNodeMdx);
+  const sourcePaths = Object.fromEntries(
+    files.map((file, index) => [nodes[index].id, toRegistryPath(relative(options.sourceDir, file))])
+  );
   const ids = /* @__PURE__ */ new Set();
   for (const node of nodes) {
     if (ids.has(node.id)) throw new Error(`[knowledge-node-codegen] Duplicate knowledge node id: ${node.id}`);
@@ -148,6 +350,15 @@ function generateKnowledgeNodes(options) {
     writeFileSync(
       options.graphSkillsOutputPath,
       `${JSON.stringify(generateGraphSkillsRegistry(nodes), null, 2)}
+`,
+      "utf8"
+    );
+  }
+  if (options.knowledgeFlagsOutputPath) {
+    mkdirSync(dirname(options.knowledgeFlagsOutputPath), { recursive: true });
+    writeFileSync(
+      options.knowledgeFlagsOutputPath,
+      `${JSON.stringify(generateKnowledgeFlagRegistry(nodes, sourcePaths), null, 2)}
 `,
       "utf8"
     );
@@ -188,7 +399,7 @@ function stripToPlainText(body) {
 var BODIES_HEADER = [
   "// @generated by generate-knowledge-bodies -- DO NOT EDIT",
   "// Regenerate: pnpm scaffold:sync",
-  "// Source: packages/elevasis-core/src/organization-model.ts",
+  "// Source: packages/elevasis-core/src/organization-model/index.ts",
   "",
   "import { Fragment, jsx, jsxs } from 'react/jsx-runtime'",
   "import type { ComponentType } from 'react'",
@@ -236,7 +447,7 @@ async function generateKnowledgeBodies(nodes) {
     const bodiesTsx2 = [
       "// @generated by generate-knowledge-bodies -- DO NOT EDIT",
       "// Regenerate: pnpm scaffold:sync",
-      "// Source: packages/elevasis-core/src/organization-model.ts",
+      "// Source: packages/elevasis-core/src/organization-model/index.ts",
       "",
       "import type { ComponentType } from 'react'",
       "",