@elevasis/sdk 1.15.1 → 1.16.0

package/dist/index.js

@@ -37,11 +37,105 @@ var ToolingError = class extends ExecutionError {
     this.details = details;
   }
 };
+z.string().uuid();
+z.string().trim().min(1).max(1e3);
+z.enum(["agent", "workflow"]);
+z.enum(["agent", "workflow", "scheduler", "api"]);
+z.string().trim().toLowerCase().min(1, "Credential name required").max(100, "Credential name too long (max 100 chars)").regex(
+  /^[a-z0-9]+(-[a-z0-9]+)+$/,
+  "Credential name must be lowercase letters, numbers, and hyphens in format: service-environment (e.g., gmail-prod, attio-dev)"
+);
+z.enum(["google-sheets", "dropbox"]);
+z.string().min(10, "Authorization code too short").max(1e3, "Authorization code too long");
+z.string().min(10, "State parameter too short").max(2048, "State parameter too long");
+z.string().trim().transform((str) => str.replace(/[<>'"]/g, ""));
+var EmailSchema = z.string().email();
+z.string().url();
+z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  offset: z.coerce.number().int().min(0).default(0)
+});
+z.string().datetime();
+z.object({
+  startDate: z.string().datetime(),
+  endDate: z.string().datetime()
+});
+var ORGANIZATION_MODEL_ICON_TOKENS = [
+  "nav.dashboard",
+  "nav.sales",
+  "nav.crm",
+  "nav.lead-gen",
+  "nav.projects",
+  "nav.operations",
+  "nav.monitoring",
+  "nav.knowledge",
+  "nav.settings",
+  "nav.admin",
+  "nav.archive",
+  "knowledge.playbook",
+  "knowledge.strategy",
+  "knowledge.reference",
+  "feature.dashboard",
+  "feature.sales",
+  "feature.crm",
+  "feature.finance",
+  "feature.lead-gen",
+  "feature.platform",
+  "feature.projects",
+  "feature.operations",
+  "feature.knowledge",
+  "feature.monitoring",
+  "feature.settings",
+  "feature.admin",
+  "feature.archive",
+  "feature.seo",
+  "resource.agent",
+  "resource.workflow",
+  "resource.integration",
+  "resource.database",
+  "resource.user",
+  "resource.team",
+  "integration.gmail",
+  "integration.google-sheets",
+  "integration.attio",
+  "surface.dashboard",
+  "surface.overview",
+  "surface.command-view",
+  "surface.command-queue",
+  "surface.pipeline",
+  "surface.lists",
+  "surface.resources",
+  "surface.settings",
+  "status.success",
+  "status.error",
+  "status.warning",
+  "status.info",
+  "status.pending",
+  "action.approve",
+  "action.reject",
+  "action.retry",
+  "action.edit",
+  "action.view",
+  "action.launch",
+  "action.message",
+  "action.escalate",
+  "action.promote",
+  "action.submit",
+  "action.email"
+];
+var CustomIconTokenSchema = z.string().trim().max(80).regex(/^custom\.[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "Custom icon tokens must start with custom.");
+var OrganizationModelBuiltinIconTokenSchema = z.enum(ORGANIZATION_MODEL_ICON_TOKENS);
+var OrganizationModelIconTokenSchema = z.union([
+  OrganizationModelBuiltinIconTokenSchema,
+  CustomIconTokenSchema
+]);
+
+// ../core/src/organization-model/domains/shared.ts
 var ModelIdSchema = z.string().trim().min(1).max(100).regex(/^[a-z0-9]+(?:[-._][a-z0-9]+)*$/, "IDs must be lowercase and use -, _, or . separators");
 var LabelSchema = z.string().trim().min(1).max(120);
 var DescriptionSchema = z.string().trim().min(1).max(2e3);
 var ColorTokenSchema = z.string().trim().min(1).max(50);
-var IconNameSchema = z.string().trim().min(1).max(80);
+var IconNameSchema = OrganizationModelIconTokenSchema;
 z.string().trim().startsWith("/").max(300);
 var ReferenceIdsSchema = z.array(ModelIdSchema).default([]);
 var DisplayMetadataSchema = z.object({
@@ -3694,48 +3788,6 @@ var ResourceRegistry = class {
     }
     return cache.commandView;
   }
-  /**
-   * List resources that have UI interfaces configured
-   * Used by Execution Runner Catalog UI
-   *
-   * @param organizationName - Organization name
-   * @param environment - Optional environment filter ('dev' or 'prod')
-   * @returns Array of resources with interfaces
-   */
-  listExecutable(organizationName, environment) {
-    const cache = this.serializedCache.get(organizationName);
-    if (!cache) {
-      return [];
-    }
-    const results = [];
-    cache.definitions.workflows.forEach((serializedWorkflow, resourceId) => {
-      if (!serializedWorkflow.interface) return;
-      if (environment && serializedWorkflow.config.status !== environment) return;
-      results.push({
-        resourceId,
-        resourceName: serializedWorkflow.config.name,
-        resourceType: "workflow",
-        description: serializedWorkflow.config.description,
-        status: serializedWorkflow.config.status,
-        version: serializedWorkflow.config.version,
-        interface: serializedWorkflow.interface
-      });
-    });
-    cache.definitions.agents.forEach((serializedAgent, resourceId) => {
-      if (!serializedAgent.interface) return;
-      if (environment && serializedAgent.config.status !== environment) return;
-      results.push({
-        resourceId,
-        resourceName: serializedAgent.config.name,
-        resourceType: "agent",
-        description: serializedAgent.config.description,
-        status: serializedAgent.config.status,
-        version: serializedAgent.config.version,
-        interface: serializedAgent.interface
-      });
-    });
-    return results;
-  }
 };
 var StageChangeEventSchema = z.object({
   type: z.literal("stage_change"),
@@ -3942,4 +3994,4 @@ function isOurReplyAction(deal) {
   return (deal.ownership ?? getDealOwnership(deal)) === "us";
 }
 
-export { ActivityEventSchema, DEFAULT_CRM_ACTIONS, ExecutionError, RegistryValidationError, ResourceRegistry, StepType, ToolingError, deriveActions };
+export { ActivityEventSchema, DEFAULT_CRM_ACTIONS, EmailSchema, ExecutionError, RegistryValidationError, ResourceRegistry, StepType, ToolingError, deriveActions };

package/dist/node/index.d.ts

@@ -0,0 +1,69 @@
+type KnowledgeKind = 'playbook' | 'strategy' | 'reference';
+interface KnowledgeCodegenNode {
+    id: string;
+    kind: KnowledgeKind;
+    title: string;
+    summary: string;
+    icon?: string;
+    body: string;
+    links: {
+        nodeId: string;
+    }[];
+    ownerIds: string[];
+    updatedAt: string;
+}
+interface GenerateKnowledgeNodesOptions {
+    sourceDir: string;
+    outputPath: string;
+    typeImportPath?: string;
+    exportedName?: string;
+    sourceLabel?: string;
+}
+interface GenerateKnowledgeNodesResult {
+    nodes: KnowledgeCodegenNode[];
+    outputPath: string;
+}
+declare function readKnowledgeNodeMdx(filePath: string): KnowledgeCodegenNode;
+declare function generateKnowledgeNodesTs(options: {
+    nodes: KnowledgeCodegenNode[];
+    typeImportPath?: string;
+    exportedName?: string;
+    sourceLabel?: string;
+}): string;
+declare function generateKnowledgeNodes(options: GenerateKnowledgeNodesOptions): GenerateKnowledgeNodesResult;
+
+interface KnowledgeNodeInput {
+    id: string;
+    kind: string;
+    title: string;
+    summary: string;
+    body: string;
+}
+interface KnowledgeSearchEntry {
+    id: string;
+    title: string;
+    summary: string;
+    bodyText: string;
+}
+interface CodegenResult {
+    bodiesTsx: string;
+    searchIndex: KnowledgeSearchEntry[];
+}
+/**
+ * Compiles knowledge nodes into generated file contents.
+ * Pure function: same input -> same output. No file I/O.
+ */
+declare function generateKnowledgeBodies(nodes: KnowledgeNodeInput[]): Promise<CodegenResult>;
+
+interface ResolvedKnowledgeLayout {
+    mode: 'monorepo' | 'external';
+    projectRoot: string;
+    omSourcePath: string;
+    mdxNodesDir: string;
+    generatedDir: string;
+    watchPaths: string[];
+}
+declare function runKnowledgeCodegen(layout: ResolvedKnowledgeLayout): Promise<void>;
+
+export { generateKnowledgeBodies, generateKnowledgeNodes, generateKnowledgeNodesTs, readKnowledgeNodeMdx, runKnowledgeCodegen };
+export type { CodegenResult, GenerateKnowledgeNodesOptions, GenerateKnowledgeNodesResult, KnowledgeCodegenNode, KnowledgeKind, KnowledgeNodeInput, KnowledgeSearchEntry, ResolvedKnowledgeLayout };

package/dist/node/index.js

@@ -0,0 +1,273 @@
+import { readFileSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { relative, dirname, resolve, join, extname } from 'path';
+import { compile } from '@mdx-js/mdx';
+import remarkGfm from 'remark-gfm';
+
+// src/knowledge-codegen.ts
+function listMdxFiles(directory) {
+  return readdirSync(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) return listMdxFiles(path);
+    return entry.isFile() && extname(entry.name) === ".mdx" ? [path] : [];
+  });
+}
+function parseScalar(value) {
+  const trimmed = value.trim();
+  const quoted = trimmed.match(/^['"]([\s\S]*)['"]$/);
+  return quoted ? quoted[1] : trimmed;
+}
+function parseFrontmatter(raw, filePath) {
+  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!match) throw new Error(`[knowledge-node-codegen] Missing frontmatter in ${filePath}`);
+  const frontmatter = {};
+  const lines = match[1].split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.trim()) continue;
+    const pair = line.match(/^([A-Za-z][A-Za-z0-9]*):(?:\s*(.*))?$/);
+    if (!pair) throw new Error(`[knowledge-node-codegen] Invalid frontmatter line in ${filePath}: ${line}`);
+    const key = pair[1];
+    const inlineValue = pair[2]?.trim() ?? "";
+    if (inlineValue) {
+      frontmatter[key] = parseScalar(inlineValue);
+      continue;
+    }
+    const values = [];
+    while (index + 1 < lines.length && /^\s+-\s+/.test(lines[index + 1])) {
+      index += 1;
+      values.push(parseScalar(lines[index].replace(/^\s+-\s+/, "")));
+    }
+    frontmatter[key] = values;
+  }
+  return { frontmatter, body: match[2].trim() };
+}
+function assertString(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter requires string "${key}"`);
+  }
+  return value.trim();
+}
+function optionalString(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter "${key}" must be a nonempty string`);
+  }
+  return value.trim();
+}
+function assertKind(value, filePath) {
+  if (value === "playbook" || value === "strategy" || value === "reference") return value;
+  throw new Error(`[knowledge-node-codegen] ${filePath} has invalid kind "${value}"`);
+}
+function optionalStringArray(frontmatter, key, filePath) {
+  const value = frontmatter[key];
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Error(`[knowledge-node-codegen] ${filePath} frontmatter "${key}" must be a string array`);
+  }
+  return value.map((entry) => entry.trim()).filter(Boolean);
+}
+function readKnowledgeNodeMdx(filePath) {
+  const raw = readFileSync(filePath, "utf8");
+  const { frontmatter, body } = parseFrontmatter(raw, filePath);
+  return {
+    id: assertString(frontmatter, "id", filePath),
+    kind: assertKind(assertString(frontmatter, "kind", filePath), filePath),
+    title: assertString(frontmatter, "title", filePath),
+    summary: assertString(frontmatter, "description", filePath),
+    icon: optionalString(frontmatter, "icon", filePath),
+    body,
+    links: optionalStringArray(frontmatter, "links", filePath).map((nodeId) => ({ nodeId })),
+    ownerIds: optionalStringArray(frontmatter, "ownerIds", filePath),
+    updatedAt: assertString(frontmatter, "updatedAt", filePath)
+  };
+}
+function generateKnowledgeNodesTs(options) {
+  const exportedName = options.exportedName ?? "mdxKnowledgeNodes";
+  const typeImport = options.typeImportPath ? [`import type { OrgKnowledgeNode } from '${options.typeImportPath}'`, ""] : [];
+  const typeSatisfies = options.typeImportPath ? " satisfies OrgKnowledgeNode[]" : "";
+  return [
+    "// @generated by generate-knowledge-nodes -- DO NOT EDIT",
+    "// Regenerate: elevasis-sdk knowledge:generate",
+    `// Source: ${options.sourceLabel ?? "knowledge/nodes/**/*.mdx"}`,
+    "",
+    ...typeImport,
+    `export const ${exportedName} = ${JSON.stringify(options.nodes, null, 2)}${typeSatisfies}`,
+    ""
+  ].join("\n");
+}
+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 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}`);
+    ids.add(node.id);
+  }
+  mkdirSync(dirname(options.outputPath), { recursive: true });
+  writeFileSync(
+    options.outputPath,
+    generateKnowledgeNodesTs({
+      nodes,
+      typeImportPath: options.typeImportPath,
+      exportedName: options.exportedName,
+      sourceLabel: options.sourceLabel
+    }),
+    "utf8"
+  );
+  return { nodes, outputPath: options.outputPath };
+}
+var ALLOWED_COMPONENTS = /* @__PURE__ */ new Set(["Card", "Cards", "Step", "Steps", "Callout", "Tab", "Tabs"]);
+function extractCustomComponents(compiledCode) {
+  const found = /* @__PURE__ */ new Set();
+  const destructurePattern = /\{([^}]+)\}\s*=\s*_components/g;
+  let match;
+  while ((match = destructurePattern.exec(compiledCode)) !== null) {
+    for (const part of match[1].split(",")) {
+      const name = part.trim().split(":")[0].trim();
+      if (name && /^[A-Z]/.test(name)) {
+        found.add(name);
+      }
+    }
+  }
+  return [...found];
+}
+function validateComponents(nodeId, compiledCode) {
+  const components = extractCustomComponents(compiledCode);
+  const unknown = components.filter((c) => !ALLOWED_COMPONENTS.has(c));
+  if (unknown.length > 0) {
+    throw new Error(
+      `[knowledge-codegen] node "${nodeId}" uses unknown JSX component(s): ${unknown.join(", ")}.
+Allowed components: ${[...ALLOWED_COMPONENTS].join(", ")}.
+To add a component:
+  1. Add it to ALLOWED_COMPONENTS in packages/sdk/src/node/knowledge-bodies-codegen.ts
+  2. Add it to the runtime KnowledgeMDXProvider allowlist (Wave 3d)`
+    );
+  }
+}
+function stripToPlainText(body) {
+  return body.replace(/^(import|export)\s+.+$/gm, "").replace(/<[A-Z][^>]*>/g, "").replace(/<\/[A-Z][^>]*>/g, "").replace(/^#{1,6}\s+/gm, "").replace(/[*_`~]/g, "").replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\n{3,}/g, "\n\n").trim();
+}
+var BODIES_HEADER = [
+  "// @generated by generate-knowledge-bodies -- DO NOT EDIT",
+  "// Regenerate: pnpm scaffold:sync",
+  "// Source: packages/elevasis-core/src/organization-model.ts",
+  "",
+  "import { Fragment, jsx, jsxs } from 'react/jsx-runtime'",
+  "import type { ComponentType } from 'react'",
+  ""
+].join("\n");
+var FACTORY_BLOCK = [
+  "// ---------------------------------------------------------------------------",
+  "// Inline compiled MDX component factory",
+  "// ---------------------------------------------------------------------------",
+  "",
+  "type MDXRuntime = {",
+  "  Fragment: typeof Fragment",
+  "  jsx: typeof jsx",
+  "  jsxs: typeof jsxs",
+  "}",
+  "",
+  "type KnowledgeBodyProps = {",
+  "  components?: Record<string, ComponentType>",
+  "}",
+  "",
+  "/**",
+  " * Wraps a compiled MDX function-body string into a React component.",
+  " * The function-body format from @mdx-js/mdx expects arguments[0]",
+  " * to be { Fragment, jsx, jsxs } from react/jsx-runtime.",
+  " */",
+  "function makeKnowledgeComponent(fnBody: string): ComponentType<KnowledgeBodyProps> {",
+  "  // eslint-disable-next-line @typescript-eslint/no-implied-eval",
+  "  const factory = new Function(fnBody) as (runtime: MDXRuntime) => { default: ComponentType }",
+  "  return function KnowledgeBody(props: KnowledgeBodyProps) {",
+  "    const runtime = { Fragment, jsx, jsxs, ...props } as unknown as MDXRuntime",
+  "    const mod = factory(runtime)",
+  "    const Content = mod.default",
+  "    return Content ? jsx(Content as ComponentType<KnowledgeBodyProps>, props) : null",
+  "  }",
+  "}",
+  ""
+].join("\n");
+var MAP_HEADER = [
+  "// ---------------------------------------------------------------------------",
+  "// Generated map: node id -> compiled React component",
+  "// ---------------------------------------------------------------------------",
+  ""
+].join("\n");
+async function generateKnowledgeBodies(nodes) {
+  if (nodes.length === 0) {
+    const bodiesTsx2 = [
+      "// @generated by generate-knowledge-bodies -- DO NOT EDIT",
+      "// Regenerate: pnpm scaffold:sync",
+      "// Source: packages/elevasis-core/src/organization-model.ts",
+      "",
+      "import type { ComponentType } from 'react'",
+      "",
+      "export const KNOWLEDGE_BODIES: Record<",
+      "  string,",
+      "  ComponentType<{ components?: Record<string, ComponentType> }>",
+      "> = {}",
+      ""
+    ].join("\n");
+    return { bodiesTsx: bodiesTsx2, searchIndex: [] };
+  }
+  const nodeComments = [];
+  const mapEntries = [];
+  const searchIndex = [];
+  for (const node of nodes) {
+    if (/^(import|export)\s+/m.test(node.body)) {
+      throw new Error(
+        `[knowledge-codegen] node "${node.id}" body contains import/export statements, which are not allowed in Phase 1 MDX bodies.`
+      );
+    }
+    const compiled = await compile(node.body, {
+      outputFormat: "function-body",
+      jsx: false,
+      remarkPlugins: [remarkGfm]
+    });
+    const fnBodyCode = String(compiled);
+    validateComponents(node.id, fnBodyCode);
+    const bodyText = stripToPlainText(node.body);
+    searchIndex.push({ id: node.id, title: node.title, summary: node.summary, bodyText });
+    nodeComments.push(`// Node: ${node.id} (${node.kind})`);
+    mapEntries.push(`  '${node.id}': makeKnowledgeComponent(${JSON.stringify(fnBodyCode)})`);
+  }
+  const mapBlock = `export const KNOWLEDGE_BODIES: Record<string, ComponentType<KnowledgeBodyProps>> = {
+` + mapEntries.join(",\n") + "\n}\n";
+  const bodiesTsx = BODIES_HEADER + FACTORY_BLOCK + MAP_HEADER + (nodeComments.length > 0 ? nodeComments.join("\n") + "\n\n" : "") + mapBlock;
+  return { bodiesTsx, searchIndex };
+}
+async function runKnowledgeCodegen(layout) {
+  let nodes;
+  if (layout.mode === "monorepo") {
+    const omSpecifier = "@repo/elevasis-core/organization-model";
+    const om = await import(
+      /* @vite-ignore */
+      omSpecifier
+    );
+    nodes = om.canonicalOrganizationModel.knowledge.nodes;
+  } else {
+    const outputPath = resolve(layout.generatedDir, "nodes.ts");
+    const result = generateKnowledgeNodes({
+      sourceDir: layout.mdxNodesDir,
+      outputPath,
+      typeImportPath: "@elevasis/core/organization-model",
+      exportedName: "mdxKnowledgeNodes"
+    });
+    nodes = result.nodes;
+  }
+  const { bodiesTsx, searchIndex } = await generateKnowledgeBodies(nodes);
+  mkdirSync(layout.generatedDir, { recursive: true });
+  writeFileSync(resolve(layout.generatedDir, "knowledge-bodies.tsx"), bodiesTsx, "utf8");
+  writeFileSync(
+    resolve(layout.generatedDir, "knowledge-search-index.json"),
+    JSON.stringify(searchIndex, null, 2) + "\n",
+    "utf8"
+  );
+}
+
+export { generateKnowledgeBodies, generateKnowledgeNodes, generateKnowledgeNodesTs, readKnowledgeNodeMdx, runKnowledgeCodegen };