@principal-ai/principal-view-cli 0.1.25 → 0.1.26

package/dist/commands/validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgjCpC,wBAAgB,qBAAqB,IAAI,OAAO,CAsH/C"}
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../src/commands/validate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4nCpC,wBAAgB,qBAAqB,IAAI,OAAO,CAsH/C"}

package/dist/commands/validate.js

@@ -229,6 +229,7 @@ const ALLOWED_CANVAS_FIELDS = {
         'name',
         'description',
         'otel',
+        'events',
         'shape',
         'icon',
         'fill',
@@ -345,6 +346,51 @@ function findSimilarField(field, allowedFields) {
     }
     return null;
 }
+/**
+ * Check if a canvas has OTEL-related features
+ * Returns true if the canvas contains any of:
+ * 1. Nodes with pv.otel extension (kind, category)
+ * 2. Event schemas (pv.events with validation)
+ * 3. Canvas scope/audit config (OTEL log routing)
+ * 4. Resource matching for OTEL logs
+ */
+function hasOtelFeatures(canvas) {
+    if (!canvas || typeof canvas !== 'object') {
+        return false;
+    }
+    const c = canvas;
+    // Check for canvas-level scope or audit config
+    if (c.pv && typeof c.pv === 'object') {
+        const pv = c.pv;
+        if (pv.scope !== undefined || pv.audit !== undefined) {
+            return true;
+        }
+    }
+    // Check nodes for OTEL features
+    if (Array.isArray(c.nodes)) {
+        for (const node of c.nodes) {
+            if (node && typeof node === 'object') {
+                const n = node;
+                if (n.pv && typeof n.pv === 'object') {
+                    const nodePv = n.pv;
+                    // Check for pv.otel extension
+                    if (nodePv.otel !== undefined) {
+                        return true;
+                    }
+                    // Check for event schemas (pv.events)
+                    if (nodePv.events !== undefined) {
+                        return true;
+                    }
+                    // Check for resourceMatch (OTEL log routing)
+                    if (nodePv.resourceMatch !== undefined) {
+                        return true;
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
 /**
  * Validate an ExtendedCanvas object with strict validation
  *
@@ -791,6 +837,23 @@ function validateCanvas(canvas, filePath, library) {
             }
         });
     }
+    // Validate OTEL canvas naming convention
+    const hasOtel = hasOtelFeatures(canvas);
+    const isOtelCanvas = filePath.endsWith('.otel.canvas');
+    if (hasOtel && !isOtelCanvas) {
+        issues.push({
+            type: 'error',
+            message: 'Canvas contains OTEL features but does not use .otel.canvas naming convention',
+            suggestion: 'Rename file to use .otel.canvas extension (e.g., "graph-name.otel.canvas")',
+        });
+    }
+    else if (!hasOtel && isOtelCanvas) {
+        issues.push({
+            type: 'warning',
+            message: 'Canvas uses .otel.canvas naming but does not contain any OTEL features',
+            suggestion: 'Either add OTEL features (pv.otel, pv.events, pv.scope, pv.audit, resourceMatch) or rename to .canvas',
+        });
+    }
     return issues;
 }
 /**

package/dist/index.cjs

@@ -13688,6 +13688,7 @@ var ALLOWED_CANVAS_FIELDS = {
     "name",
     "description",
     "otel",
+    "events",
     "shape",
     "icon",
     "fill",
@@ -13790,6 +13791,38 @@ function findSimilarField(field, allowedFields) {
   }
   return null;
 }
+function hasOtelFeatures(canvas) {
+  if (!canvas || typeof canvas !== "object") {
+    return false;
+  }
+  const c = canvas;
+  if (c.pv && typeof c.pv === "object") {
+    const pv = c.pv;
+    if (pv.scope !== void 0 || pv.audit !== void 0) {
+      return true;
+    }
+  }
+  if (Array.isArray(c.nodes)) {
+    for (const node of c.nodes) {
+      if (node && typeof node === "object") {
+        const n = node;
+        if (n.pv && typeof n.pv === "object") {
+          const nodePv = n.pv;
+          if (nodePv.otel !== void 0) {
+            return true;
+          }
+          if (nodePv.events !== void 0) {
+            return true;
+          }
+          if (nodePv.resourceMatch !== void 0) {
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
 function validateCanvas(canvas, filePath, library) {
   const issues = [];
   if (!canvas || typeof canvas !== "object") {
@@ -14256,6 +14289,21 @@ function validateCanvas(canvas, filePath, library) {
       }
     });
   }
+  const hasOtel = hasOtelFeatures(canvas);
+  const isOtelCanvas = filePath.endsWith(".otel.canvas");
+  if (hasOtel && !isOtelCanvas) {
+    issues.push({
+      type: "error",
+      message: "Canvas contains OTEL features but does not use .otel.canvas naming convention",
+      suggestion: 'Rename file to use .otel.canvas extension (e.g., "graph-name.otel.canvas")'
+    });
+  } else if (!hasOtel && isOtelCanvas) {
+    issues.push({
+      type: "warning",
+      message: "Canvas uses .otel.canvas naming but does not contain any OTEL features",
+      suggestion: "Either add OTEL features (pv.otel, pv.events, pv.scope, pv.audit, resourceMatch) or rename to .canvas"
+    });
+  }
   return issues;
 }
 function validateFile(filePath, library) {
@@ -15547,6 +15595,212 @@ function createCreateCommand() {
 var import_node_fs10 = require("node:fs");
 var import_node_path11 = require("node:path");
 
+// ../core/dist/codegen/type-generator.js
+var TypeScriptGenerator = class {
+  constructor() {
+    this.language = "typescript";
+  }
+  generate(canvas, options) {
+    const opts = {
+      readonly: options?.style?.readonly ?? false,
+      strictNullChecks: options?.style?.strictNullChecks ?? true,
+      includeDocComments: options?.style?.includeDocComments ?? true,
+      namespace: options?.namespace
+    };
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * Generated types from canvas: ${canvas.pv?.name || "Untitled"}`);
+    lines.push(" *");
+    lines.push(" * DO NOT EDIT MANUALLY - This file is auto-generated");
+    lines.push(" * Generated by @principal-ai/principal-view-core");
+    lines.push(" *");
+    lines.push(` * Canvas: ${canvas.pv?.description || "No description"}`);
+    lines.push(` * Version: ${canvas.pv?.version || "1.0.0"}`);
+    lines.push(" */");
+    lines.push("");
+    if (opts.namespace) {
+      lines.push(`export namespace ${opts.namespace} {`);
+    }
+    if (canvas.nodes) {
+      for (const node of canvas.nodes) {
+        if (node.pv?.events) {
+          lines.push(...this.generateNodeTypes(node.id, node.pv.events, opts));
+          lines.push("");
+        }
+      }
+    }
+    lines.push(...this.generateEventNameUnion(canvas, opts));
+    lines.push("");
+    lines.push(...this.generateEmitterTypes(canvas, opts));
+    if (opts.namespace) {
+      lines.push("}");
+    }
+    const code = lines.join("\n");
+    const filename = this.generateFilename(canvas);
+    return {
+      code,
+      extension: "ts",
+      filename
+    };
+  }
+  generateNodeTypes(nodeId, events, opts) {
+    const lines = [];
+    const typeName = this.nodeIdToTypeName(nodeId);
+    if (opts.includeDocComments) {
+      lines.push(`/**`);
+      lines.push(` * Event types for node: ${nodeId}`);
+      lines.push(` */`);
+    }
+    lines.push(`export namespace ${typeName} {`);
+    for (const [eventName, eventSchema] of Object.entries(events)) {
+      lines.push(...this.generateEventInterface(eventName, eventSchema, opts));
+      lines.push("");
+    }
+    const eventNames = Object.keys(events);
+    const interfaceNames = eventNames.map((name) => this.eventNameToTypeName(name));
+    lines.push("  /**");
+    lines.push(`   * Union of all event types for ${nodeId}`);
+    lines.push("   */");
+    lines.push(`  export type Event = ${interfaceNames.join(" | ")};`);
+    lines.push("");
+    lines.push("  /**");
+    lines.push(`   * Literal union of event names for ${nodeId}`);
+    lines.push("   */");
+    lines.push(`  export type EventName = ${eventNames.map((n) => `'${n}'`).join(" | ")};`);
+    lines.push("}");
+    return lines;
+  }
+  generateEventInterface(eventName, schema2, opts) {
+    const lines = [];
+    const interfaceName = this.eventNameToTypeName(eventName);
+    const readonly = opts.readonly ? "readonly " : "";
+    if (opts.includeDocComments) {
+      lines.push("  /**");
+      lines.push(`   * ${schema2.description}`);
+      lines.push("   */");
+    }
+    lines.push(`  export interface ${interfaceName} {`);
+    lines.push(`    ${readonly}name: '${eventName}';`);
+    lines.push(`    ${readonly}attributes: {`);
+    for (const [fieldName, fieldSchema] of Object.entries(schema2.attributes)) {
+      const optional = !fieldSchema.required && opts.strictNullChecks ? "?" : "";
+      const type2 = this.fieldTypeToTsType(fieldSchema);
+      if (opts.includeDocComments && fieldSchema.description) {
+        lines.push(`      /** ${fieldSchema.description} */`);
+      }
+      lines.push(`      ${readonly}'${fieldName}'${optional}: ${type2};`);
+    }
+    lines.push("    };");
+    lines.push("  }");
+    return lines;
+  }
+  generateEventNameUnion(canvas, opts) {
+    const lines = [];
+    const allEventNames = /* @__PURE__ */ new Set();
+    if (canvas.nodes) {
+      for (const node of canvas.nodes) {
+        if (node.pv?.events) {
+          Object.keys(node.pv.events).forEach((name) => allEventNames.add(name));
+        }
+      }
+    }
+    if (allEventNames.size === 0) {
+      return lines;
+    }
+    if (opts.includeDocComments) {
+      lines.push("/**");
+      lines.push(" * Union of all event names in the canvas");
+      lines.push(" */");
+    }
+    lines.push(`export type AllEventNames = ${Array.from(allEventNames).map((n) => `'${n}'`).join(" | ")};`);
+    return lines;
+  }
+  generateEmitterTypes(canvas, opts) {
+    const lines = [];
+    if (opts.includeDocComments) {
+      lines.push("/**");
+      lines.push(" * Type-safe event emitter for a specific node");
+      lines.push(" *");
+      lines.push(" * @example");
+      lines.push(" * ```typescript");
+      lines.push(" * const emit: NodeEmitter<GraphConverter.EventName, GraphConverter.Event> = ...");
+      lines.push(" * emit('conversion.started', {");
+      lines.push(" *   name: 'conversion.started',");
+      lines.push(" *   attributes: { ... }");
+      lines.push(" * });");
+      lines.push(" * ```");
+      lines.push(" */");
+    }
+    lines.push("export type NodeEmitter<");
+    lines.push("  TEventName extends string,");
+    lines.push("  TEvent extends { name: TEventName; attributes: Record<string, any> }");
+    lines.push("> = (event: TEvent) => void;");
+    lines.push("");
+    if (opts.includeDocComments) {
+      lines.push("/**");
+      lines.push(" * Type-safe event emitter by event name");
+      lines.push(" *");
+      lines.push(" * @example");
+      lines.push(" * ```typescript");
+      lines.push(" * const emit: NodeEmitterByName<GraphConverter.Event> = ...");
+      lines.push(" * emit('conversion.started', {");
+      lines.push(" *   'config.nodeTypes': 2,");
+      lines.push(" *   'config.edgeTypes': 1");
+      lines.push(" * });");
+      lines.push(" * ```");
+      lines.push(" */");
+    }
+    lines.push("export type NodeEmitterByName<");
+    lines.push("  TEvent extends { name: string; attributes: Record<string, any> }");
+    lines.push("> = <TName extends TEvent['name']>(");
+    lines.push("  eventName: TName,");
+    lines.push("  attributes: Extract<TEvent, { name: TName }>['attributes']");
+    lines.push(") => void;");
+    return lines;
+  }
+  nodeIdToTypeName(nodeId) {
+    return nodeId.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  }
+  eventNameToTypeName(eventName) {
+    return eventName.split(".").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  }
+  fieldTypeToTsType(fieldSchema) {
+    switch (fieldSchema.type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "array":
+        return "any[]";
+      case "object":
+        return "Record<string, any>";
+      default:
+        return "any";
+    }
+  }
+  generateFilename(canvas) {
+    const name = canvas.pv?.name || "canvas";
+    const kebab = name.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+    return `${kebab}.types.ts`;
+  }
+};
+var generatorRegistry = {
+  generators: /* @__PURE__ */ new Map([
+    ["typescript", new TypeScriptGenerator()]
+  ]),
+  register(generator) {
+    this.generators.set(generator.language, generator);
+  },
+  get(language) {
+    return this.generators.get(language);
+  },
+  list() {
+    return Array.from(this.generators.keys());
+  }
+};
+
 // ../core/dist/utils/YamlParser.js
 function parseYaml(content, filename) {
   try {