@principal-ai/principal-view-cli 0.1.19 → 0.1.21

package/dist/index.cjs

@@ -13484,31 +13484,68 @@ function validateLibrary(library) {
     for (const [compId, compDef] of Object.entries(lib.nodeComponents)) {
       if (compDef && typeof compDef === "object") {
         const comp = compDef;
-        checkUnknownFields(comp, ALLOWED_LIBRARY_FIELDS.nodeComponent, `nodeComponents.${compId}`, issues);
+        checkUnknownFields(
+          comp,
+          ALLOWED_LIBRARY_FIELDS.nodeComponent,
+          `nodeComponents.${compId}`,
+          issues
+        );
+        validateIconName(comp.icon, `nodeComponents.${compId}.icon`, issues);
         if (comp.size && typeof comp.size === "object") {
-          checkUnknownFields(comp.size, ALLOWED_LIBRARY_FIELDS.nodeComponentSize, `nodeComponents.${compId}.size`, issues);
+          checkUnknownFields(
+            comp.size,
+            ALLOWED_LIBRARY_FIELDS.nodeComponentSize,
+            `nodeComponents.${compId}.size`,
+            issues
+          );
         }
         if (comp.states && typeof comp.states === "object") {
-          for (const [stateId, stateDef] of Object.entries(comp.states)) {
+          for (const [stateId, stateDef] of Object.entries(
+            comp.states
+          )) {
             if (stateDef && typeof stateDef === "object") {
-              checkUnknownFields(stateDef, ALLOWED_LIBRARY_FIELDS.nodeComponentState, `nodeComponents.${compId}.states.${stateId}`, issues);
+              checkUnknownFields(
+                stateDef,
+                ALLOWED_LIBRARY_FIELDS.nodeComponentState,
+                `nodeComponents.${compId}.states.${stateId}`,
+                issues
+              );
+              const state = stateDef;
+              validateIconName(state.icon, `nodeComponents.${compId}.states.${stateId}.icon`, issues);
             }
           }
         }
         if (comp.dataSchema && typeof comp.dataSchema === "object") {
-          for (const [fieldName, fieldDef] of Object.entries(comp.dataSchema)) {
+          for (const [fieldName, fieldDef] of Object.entries(
+            comp.dataSchema
+          )) {
             if (fieldDef && typeof fieldDef === "object") {
-              checkUnknownFields(fieldDef, ALLOWED_LIBRARY_FIELDS.nodeComponentDataSchemaField, `nodeComponents.${compId}.dataSchema.${fieldName}`, issues);
+              checkUnknownFields(
+                fieldDef,
+                ALLOWED_LIBRARY_FIELDS.nodeComponentDataSchemaField,
+                `nodeComponents.${compId}.dataSchema.${fieldName}`,
+                issues
+              );
             }
           }
         }
         if (comp.layout && typeof comp.layout === "object") {
-          checkUnknownFields(comp.layout, ALLOWED_LIBRARY_FIELDS.nodeComponentLayout, `nodeComponents.${compId}.layout`, issues);
+          checkUnknownFields(
+            comp.layout,
+            ALLOWED_LIBRARY_FIELDS.nodeComponentLayout,
+            `nodeComponents.${compId}.layout`,
+            issues
+          );
         }
         if (Array.isArray(comp.actions)) {
           comp.actions.forEach((action, actionIndex) => {
             if (action && typeof action === "object") {
-              checkUnknownFields(action, ALLOWED_LIBRARY_FIELDS.nodeComponentAction, `nodeComponents.${compId}.actions[${actionIndex}]`, issues);
+              checkUnknownFields(
+                action,
+                ALLOWED_LIBRARY_FIELDS.nodeComponentAction,
+                `nodeComponents.${compId}.actions[${actionIndex}]`,
+                issues
+              );
             }
           });
         }
@@ -13519,12 +13556,27 @@ function validateLibrary(library) {
     for (const [compId, compDef] of Object.entries(lib.edgeComponents)) {
       if (compDef && typeof compDef === "object") {
         const comp = compDef;
-        checkUnknownFields(comp, ALLOWED_LIBRARY_FIELDS.edgeComponent, `edgeComponents.${compId}`, issues);
+        checkUnknownFields(
+          comp,
+          ALLOWED_LIBRARY_FIELDS.edgeComponent,
+          `edgeComponents.${compId}`,
+          issues
+        );
         if (comp.animation && typeof comp.animation === "object") {
-          checkUnknownFields(comp.animation, ALLOWED_LIBRARY_FIELDS.edgeComponentAnimation, `edgeComponents.${compId}.animation`, issues);
+          checkUnknownFields(
+            comp.animation,
+            ALLOWED_LIBRARY_FIELDS.edgeComponentAnimation,
+            `edgeComponents.${compId}.animation`,
+            issues
+          );
         }
         if (comp.label && typeof comp.label === "object") {
-          checkUnknownFields(comp.label, ALLOWED_LIBRARY_FIELDS.edgeComponentLabel, `edgeComponents.${compId}.label`, issues);
+          checkUnknownFields(
+            comp.label,
+            ALLOWED_LIBRARY_FIELDS.edgeComponentLabel,
+            `edgeComponents.${compId}.label`,
+            issues
+          );
         }
       }
     }
@@ -13533,9 +13585,19 @@ function validateLibrary(library) {
     lib.connectionRules.forEach((rule, ruleIndex) => {
       if (rule && typeof rule === "object") {
         const r = rule;
-        checkUnknownFields(r, ALLOWED_LIBRARY_FIELDS.connectionRule, `connectionRules[${ruleIndex}]`, issues);
+        checkUnknownFields(
+          r,
+          ALLOWED_LIBRARY_FIELDS.connectionRule,
+          `connectionRules[${ruleIndex}]`,
+          issues
+        );
         if (r.constraints && typeof r.constraints === "object") {
-          checkUnknownFields(r.constraints, ALLOWED_LIBRARY_FIELDS.connectionRuleConstraints, `connectionRules[${ruleIndex}].constraints`, issues);
+          checkUnknownFields(
+            r.constraints,
+            ALLOWED_LIBRARY_FIELDS.connectionRuleConstraints,
+            `connectionRules[${ruleIndex}].constraints`,
+            issues
+          );
         }
       }
     });
@@ -13544,15 +13606,60 @@ function validateLibrary(library) {
 }
 var STANDARD_CANVAS_TYPES = ["text", "group", "file", "link"];
 var VALID_NODE_SHAPES = ["circle", "rectangle", "hexagon", "diamond", "custom"];
+function kebabToPascalCase(str2) {
+  return str2.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+}
+function isKebabCase(str2) {
+  return str2.includes("-") && str2 === str2.toLowerCase();
+}
+function validateIconName(iconValue, path4, issues) {
+  if (typeof iconValue !== "string" || !iconValue) {
+    return;
+  }
+  if (isKebabCase(iconValue)) {
+    const suggested = kebabToPascalCase(iconValue);
+    issues.push({
+      type: "error",
+      message: `Invalid icon name "${iconValue}" - icons must be in PascalCase`,
+      path: path4,
+      suggestion: `Use "${suggested}" instead of "${iconValue}"`
+    });
+    return;
+  }
+  if (iconValue[0] === iconValue[0].toLowerCase() && iconValue[0] !== iconValue[0].toUpperCase()) {
+    const suggested = iconValue.charAt(0).toUpperCase() + iconValue.slice(1);
+    issues.push({
+      type: "error",
+      message: `Invalid icon name "${iconValue}" - icons must start with uppercase`,
+      path: path4,
+      suggestion: `Use "${suggested}" instead of "${iconValue}"`
+    });
+  }
+}
 var ALLOWED_CANVAS_FIELDS = {
   root: ["nodes", "edges", "pv"],
   pv: ["version", "name", "description", "nodeTypes", "edgeTypes", "pathConfig", "display"],
-  pvPathConfig: ["projectRoot", "captureSource", "enableActionPatterns", "logLevel", "ignoreUnsourced"],
+  pvPathConfig: [
+    "projectRoot",
+    "captureSource",
+    "enableActionPatterns",
+    "logLevel",
+    "ignoreUnsourced"
+  ],
   pvDisplay: ["layout", "theme", "animations"],
   pvDisplayTheme: ["primary", "success", "warning", "danger", "info"],
   pvDisplayAnimations: ["enabled", "speed"],
   pvNodeType: ["label", "description", "color", "icon", "shape"],
-  pvEdgeType: ["label", "style", "color", "width", "directed", "animation", "labelConfig", "activatedBy"],
+  pvEdgeType: [
+    "label",
+    "style",
+    "color",
+    "width",
+    "directed",
+    "animation",
+    "labelConfig",
+    "activatedBy"
+  ],
   pvEdgeTypeAnimation: ["type", "duration", "color"],
   pvEdgeTypeLabelConfig: ["field", "position"],
   // Base node fields from JSON Canvas spec
@@ -13563,26 +13670,71 @@ var ALLOWED_CANVAS_FIELDS = {
   nodeLink: ["url"],
   nodeGroup: ["label", "background", "backgroundStyle"],
   // Node pv extension
-  nodePv: ["nodeType", "description", "shape", "icon", "fill", "stroke", "states", "sources", "actions", "dataSchema", "layout"],
+  nodePv: [
+    "nodeType",
+    "description",
+    "shape",
+    "icon",
+    "fill",
+    "stroke",
+    "states",
+    "sources",
+    "actions",
+    "dataSchema",
+    "layout"
+  ],
   nodePvState: ["color", "icon", "label"],
   nodePvAction: ["pattern", "event", "state", "metadata", "triggerEdges"],
   nodePvDataSchemaField: ["type", "required", "displayInLabel"],
   nodePvLayout: ["layer", "cluster"],
   // Edge fields
-  edge: ["id", "fromNode", "toNode", "fromSide", "toSide", "fromEnd", "toEnd", "color", "label", "pv"],
+  edge: [
+    "id",
+    "fromNode",
+    "toNode",
+    "fromSide",
+    "toSide",
+    "fromEnd",
+    "toEnd",
+    "color",
+    "label",
+    "pv"
+  ],
   edgePv: ["edgeType", "style", "width", "animation", "activatedBy"],
   edgePvAnimation: ["type", "duration", "color"],
   edgePvActivatedBy: ["action", "animation", "direction", "duration"]
 };
 var ALLOWED_LIBRARY_FIELDS = {
   root: ["version", "name", "description", "nodeComponents", "edgeComponents", "connectionRules"],
-  nodeComponent: ["description", "tags", "defaultLabel", "shape", "icon", "color", "size", "states", "sources", "actions", "dataSchema", "layout"],
+  nodeComponent: [
+    "description",
+    "tags",
+    "defaultLabel",
+    "shape",
+    "icon",
+    "color",
+    "size",
+    "states",
+    "sources",
+    "actions",
+    "dataSchema",
+    "layout"
+  ],
   nodeComponentSize: ["width", "height"],
   nodeComponentState: ["color", "icon", "label"],
   nodeComponentAction: ["pattern", "event", "state", "metadata", "triggerEdges"],
   nodeComponentDataSchemaField: ["type", "required", "displayInLabel", "label", "displayInInfo"],
   nodeComponentLayout: ["layer", "cluster"],
-  edgeComponent: ["description", "tags", "style", "color", "width", "directed", "animation", "label"],
+  edgeComponent: [
+    "description",
+    "tags",
+    "style",
+    "color",
+    "width",
+    "directed",
+    "animation",
+    "label"
+  ],
   edgeComponentAnimation: ["type", "duration", "color"],
   edgeComponentLabel: ["field", "position"],
   connectionRule: ["from", "to", "via", "constraints"],
@@ -13661,23 +13813,45 @@ function validateCanvas(canvas, filePath, library) {
       });
     }
     if (pv.pathConfig && typeof pv.pathConfig === "object") {
-      checkUnknownFields(pv.pathConfig, ALLOWED_CANVAS_FIELDS.pvPathConfig, "pv.pathConfig", issues);
+      checkUnknownFields(
+        pv.pathConfig,
+        ALLOWED_CANVAS_FIELDS.pvPathConfig,
+        "pv.pathConfig",
+        issues
+      );
     }
     if (pv.display && typeof pv.display === "object") {
       const display = pv.display;
       checkUnknownFields(display, ALLOWED_CANVAS_FIELDS.pvDisplay, "pv.display", issues);
       if (display.theme && typeof display.theme === "object") {
-        checkUnknownFields(display.theme, ALLOWED_CANVAS_FIELDS.pvDisplayTheme, "pv.display.theme", issues);
+        checkUnknownFields(
+          display.theme,
+          ALLOWED_CANVAS_FIELDS.pvDisplayTheme,
+          "pv.display.theme",
+          issues
+        );
       }
       if (display.animations && typeof display.animations === "object") {
-        checkUnknownFields(display.animations, ALLOWED_CANVAS_FIELDS.pvDisplayAnimations, "pv.display.animations", issues);
+        checkUnknownFields(
+          display.animations,
+          ALLOWED_CANVAS_FIELDS.pvDisplayAnimations,
+          "pv.display.animations",
+          issues
+        );
       }
     }
     if (pv.nodeTypes && typeof pv.nodeTypes === "object") {
       canvasNodeTypes = Object.keys(pv.nodeTypes);
       for (const [typeId, typeDef] of Object.entries(pv.nodeTypes)) {
         if (typeDef && typeof typeDef === "object") {
-          checkUnknownFields(typeDef, ALLOWED_CANVAS_FIELDS.pvNodeType, `pv.nodeTypes.${typeId}`, issues);
+          checkUnknownFields(
+            typeDef,
+            ALLOWED_CANVAS_FIELDS.pvNodeType,
+            `pv.nodeTypes.${typeId}`,
+            issues
+          );
+          const nodeType = typeDef;
+          validateIconName(nodeType.icon, `pv.nodeTypes.${typeId}.icon`, issues);
         }
       }
     }
@@ -13686,12 +13860,27 @@ function validateCanvas(canvas, filePath, library) {
       for (const [typeId, typeDef] of Object.entries(pv.edgeTypes)) {
         if (typeDef && typeof typeDef === "object") {
           const edgeTypeDef = typeDef;
-          checkUnknownFields(edgeTypeDef, ALLOWED_CANVAS_FIELDS.pvEdgeType, `pv.edgeTypes.${typeId}`, issues);
+          checkUnknownFields(
+            edgeTypeDef,
+            ALLOWED_CANVAS_FIELDS.pvEdgeType,
+            `pv.edgeTypes.${typeId}`,
+            issues
+          );
           if (edgeTypeDef.animation && typeof edgeTypeDef.animation === "object") {
-            checkUnknownFields(edgeTypeDef.animation, ALLOWED_CANVAS_FIELDS.pvEdgeTypeAnimation, `pv.edgeTypes.${typeId}.animation`, issues);
+            checkUnknownFields(
+              edgeTypeDef.animation,
+              ALLOWED_CANVAS_FIELDS.pvEdgeTypeAnimation,
+              `pv.edgeTypes.${typeId}.animation`,
+              issues
+            );
           }
           if (edgeTypeDef.labelConfig && typeof edgeTypeDef.labelConfig === "object") {
-            checkUnknownFields(edgeTypeDef.labelConfig, ALLOWED_CANVAS_FIELDS.pvEdgeTypeLabelConfig, `pv.edgeTypes.${typeId}.labelConfig`, issues);
+            checkUnknownFields(
+              edgeTypeDef.labelConfig,
+              ALLOWED_CANVAS_FIELDS.pvEdgeTypeLabelConfig,
+              `pv.edgeTypes.${typeId}.labelConfig`,
+              issues
+            );
           }
         }
       }
@@ -13704,7 +13893,11 @@ function validateCanvas(canvas, filePath, library) {
   } else {
     c.nodes.forEach((node, index) => {
       if (!node || typeof node !== "object") {
-        issues.push({ type: "error", message: `Node at index ${index} must be an object`, path: `nodes[${index}]` });
+        issues.push({
+          type: "error",
+          message: `Node at index ${index} must be an object`,
+          path: `nodes[${index}]`
+        });
         return;
       }
       const n = node;
@@ -13723,31 +13916,83 @@ function validateCanvas(canvas, filePath, library) {
       }
       checkUnknownFields(n, allowedNodeFields, nodePath2, issues);
       if (typeof n.id !== "string" || !n.id) {
-        issues.push({ type: "error", message: `Node at index ${index} must have a string "id"`, path: `${nodePath2}.id` });
+        issues.push({
+          type: "error",
+          message: `Node at index ${index} must have a string "id"`,
+          path: `${nodePath2}.id`
+        });
       }
       if (typeof n.type !== "string") {
-        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a string "type"`, path: `${nodePath2}.type` });
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" must have a string "type"`,
+          path: `${nodePath2}.type`
+        });
       }
       if (typeof n.x !== "number") {
-        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "x" position`, path: `${nodePath2}.x` });
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" must have a numeric "x" position`,
+          path: `${nodePath2}.x`
+        });
       }
       if (typeof n.y !== "number") {
-        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "y" position`, path: `${nodePath2}.y` });
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" must have a numeric "y" position`,
+          path: `${nodePath2}.y`
+        });
       }
       if (typeof n.width !== "number") {
-        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "width"`, path: `${nodePath2}.width` });
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" must have a numeric "width"`,
+          path: `${nodePath2}.width`
+        });
       }
       if (typeof n.height !== "number") {
-        issues.push({ type: "error", message: `Node "${nodeLabel}" must have a numeric "height"`, path: `${nodePath2}.height` });
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" must have a numeric "height"`,
+          path: `${nodePath2}.height`
+        });
+      }
+      if (nodeType === "text" && (typeof n.text !== "string" || !n.text)) {
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" has type "text" but is missing required "text" field`,
+          path: `${nodePath2}.text`,
+          suggestion: 'Add a "text" field with markdown content, or change the node type'
+        });
+      }
+      if (nodeType === "file" && (typeof n.file !== "string" || !n.file)) {
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" has type "file" but is missing required "file" field`,
+          path: `${nodePath2}.file`,
+          suggestion: 'Add a "file" field with a file path, or change the node type'
+        });
+      }
+      if (nodeType === "link" && (typeof n.url !== "string" || !n.url)) {
+        issues.push({
+          type: "error",
+          message: `Node "${nodeLabel}" has type "link" but is missing required "url" field`,
+          path: `${nodePath2}.url`,
+          suggestion: 'Add a "url" field with a URL, or change the node type'
+        });
       }
-      const isStandardType = STANDARD_CANVAS_TYPES.includes(nodeType);
+      const isStandardType = STANDARD_CANVAS_TYPES.includes(
+        nodeType
+      );
       if (!isStandardType) {
         if (!n.pv || typeof n.pv !== "object") {
           issues.push({
             type: "error",
             message: `Node "${n.id || index}" uses custom type "${nodeType}" but has no "pv" extension`,
             path: `nodes[${index}].pv`,
-            suggestion: `Use a standard type (${STANDARD_CANVAS_TYPES.join(", ")}) or add pv.nodeType and pv.shape`
+            suggestion: `Use a standard type (${STANDARD_CANVAS_TYPES.join(
+              ", "
+            )}) or add pv.nodeType and pv.shape`
           });
         } else {
           const nodePv = n.pv;
@@ -13771,27 +14016,54 @@ function validateCanvas(canvas, filePath, library) {
       if (n.pv && typeof n.pv === "object") {
         const nodePv = n.pv;
         checkUnknownFields(nodePv, ALLOWED_CANVAS_FIELDS.nodePv, `${nodePath2}.pv`, issues);
+        validateIconName(nodePv.icon, `${nodePath2}.pv.icon`, issues);
         if (nodePv.states && typeof nodePv.states === "object") {
-          for (const [stateId, stateDef] of Object.entries(nodePv.states)) {
+          for (const [stateId, stateDef] of Object.entries(
+            nodePv.states
+          )) {
             if (stateDef && typeof stateDef === "object") {
-              checkUnknownFields(stateDef, ALLOWED_CANVAS_FIELDS.nodePvState, `${nodePath2}.pv.states.${stateId}`, issues);
+              checkUnknownFields(
+                stateDef,
+                ALLOWED_CANVAS_FIELDS.nodePvState,
+                `${nodePath2}.pv.states.${stateId}`,
+                issues
+              );
+              const state = stateDef;
+              validateIconName(state.icon, `${nodePath2}.pv.states.${stateId}.icon`, issues);
             }
           }
         }
         if (nodePv.dataSchema && typeof nodePv.dataSchema === "object") {
-          for (const [fieldName, fieldDef] of Object.entries(nodePv.dataSchema)) {
+          for (const [fieldName, fieldDef] of Object.entries(
+            nodePv.dataSchema
+          )) {
             if (fieldDef && typeof fieldDef === "object") {
-              checkUnknownFields(fieldDef, ALLOWED_CANVAS_FIELDS.nodePvDataSchemaField, `${nodePath2}.pv.dataSchema.${fieldName}`, issues);
+              checkUnknownFields(
+                fieldDef,
+                ALLOWED_CANVAS_FIELDS.nodePvDataSchemaField,
+                `${nodePath2}.pv.dataSchema.${fieldName}`,
+                issues
+              );
             }
           }
         }
         if (nodePv.layout && typeof nodePv.layout === "object") {
-          checkUnknownFields(nodePv.layout, ALLOWED_CANVAS_FIELDS.nodePvLayout, `${nodePath2}.pv.layout`, issues);
+          checkUnknownFields(
+            nodePv.layout,
+            ALLOWED_CANVAS_FIELDS.nodePvLayout,
+            `${nodePath2}.pv.layout`,
+            issues
+          );
         }
         if (Array.isArray(nodePv.actions)) {
           nodePv.actions.forEach((action, actionIndex) => {
             if (action && typeof action === "object") {
-              checkUnknownFields(action, ALLOWED_CANVAS_FIELDS.nodePvAction, `${nodePath2}.pv.actions[${actionIndex}]`, issues);
+              checkUnknownFields(
+                action,
+                ALLOWED_CANVAS_FIELDS.nodePvAction,
+                `${nodePath2}.pv.actions[${actionIndex}]`,
+                issues
+              );
             }
           });
         }
@@ -13829,7 +14101,11 @@ function validateCanvas(canvas, filePath, library) {
     const nodeIds = new Set(c.nodes?.map((n) => n.id) || []);
     c.edges.forEach((edge, index) => {
       if (!edge || typeof edge !== "object") {
-        issues.push({ type: "error", message: `Edge at index ${index} must be an object`, path: `edges[${index}]` });
+        issues.push({
+          type: "error",
+          message: `Edge at index ${index} must be an object`,
+          path: `edges[${index}]`
+        });
         return;
       }
       const e = edge;
@@ -13837,28 +14113,89 @@ function validateCanvas(canvas, filePath, library) {
       const edgeLabel = e.id || index;
       checkUnknownFields(e, ALLOWED_CANVAS_FIELDS.edge, edgePath, issues);
       if (typeof e.id !== "string" || !e.id) {
-        issues.push({ type: "error", message: `Edge at index ${index} must have a string "id"`, path: `${edgePath}.id` });
+        issues.push({
+          type: "error",
+          message: `Edge at index ${index} must have a string "id"`,
+          path: `${edgePath}.id`
+        });
       }
       if (typeof e.fromNode !== "string") {
-        issues.push({ type: "error", message: `Edge "${edgeLabel}" must have a string "fromNode"`, path: `${edgePath}.fromNode` });
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" must have a string "fromNode"`,
+          path: `${edgePath}.fromNode`
+        });
       } else if (!nodeIds.has(e.fromNode)) {
-        issues.push({ type: "error", message: `Edge "${edgeLabel}" references unknown node "${e.fromNode}"`, path: `${edgePath}.fromNode` });
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" references unknown node "${e.fromNode}"`,
+          path: `${edgePath}.fromNode`
+        });
       }
       if (typeof e.toNode !== "string") {
-        issues.push({ type: "error", message: `Edge "${edgeLabel}" must have a string "toNode"`, path: `${edgePath}.toNode` });
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" must have a string "toNode"`,
+          path: `${edgePath}.toNode`
+        });
       } else if (!nodeIds.has(e.toNode)) {
-        issues.push({ type: "error", message: `Edge "${edgeLabel}" references unknown node "${e.toNode}"`, path: `${edgePath}.toNode` });
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" references unknown node "${e.toNode}"`,
+          path: `${edgePath}.toNode`
+        });
+      }
+      const VALID_SIDES = ["top", "right", "bottom", "left"];
+      if (typeof e.fromSide !== "string") {
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" must have a "fromSide" field`,
+          path: `${edgePath}.fromSide`,
+          suggestion: `Specify which side of the source node the edge starts from: ${VALID_SIDES.join(", ")}`
+        });
+      } else if (!VALID_SIDES.includes(e.fromSide)) {
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" has invalid fromSide "${e.fromSide}"`,
+          path: `${edgePath}.fromSide`,
+          suggestion: `Valid values: ${VALID_SIDES.join(", ")}`
+        });
+      }
+      if (typeof e.toSide !== "string") {
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" must have a "toSide" field`,
+          path: `${edgePath}.toSide`,
+          suggestion: `Specify which side of the target node the edge connects to: ${VALID_SIDES.join(", ")}`
+        });
+      } else if (!VALID_SIDES.includes(e.toSide)) {
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" has invalid toSide "${e.toSide}"`,
+          path: `${edgePath}.toSide`,
+          suggestion: `Valid values: ${VALID_SIDES.join(", ")}`
+        });
       }
       if (e.pv && typeof e.pv === "object") {
         const edgePv = e.pv;
         checkUnknownFields(edgePv, ALLOWED_CANVAS_FIELDS.edgePv, `${edgePath}.pv`, issues);
         if (edgePv.animation && typeof edgePv.animation === "object") {
-          checkUnknownFields(edgePv.animation, ALLOWED_CANVAS_FIELDS.edgePvAnimation, `${edgePath}.pv.animation`, issues);
+          checkUnknownFields(
+            edgePv.animation,
+            ALLOWED_CANVAS_FIELDS.edgePvAnimation,
+            `${edgePath}.pv.animation`,
+            issues
+          );
         }
         if (Array.isArray(edgePv.activatedBy)) {
           edgePv.activatedBy.forEach((trigger, triggerIndex) => {
             if (trigger && typeof trigger === "object") {
-              checkUnknownFields(trigger, ALLOWED_CANVAS_FIELDS.edgePvActivatedBy, `${edgePath}.pv.activatedBy[${triggerIndex}]`, issues);
+              checkUnknownFields(
+                trigger,
+                ALLOWED_CANVAS_FIELDS.edgePvActivatedBy,
+                `${edgePath}.pv.activatedBy[${triggerIndex}]`,
+                issues
+              );
             }
           });
         }
@@ -13923,7 +14260,10 @@ function validateFile(filePath, library) {
 }
 function createValidateCommand() {
   const command = new Command("validate");
-  command.description("Validate .canvas configuration files").argument("[files...]", "Files or glob patterns to validate (defaults to .principal-views/*.canvas)").option("-q, --quiet", "Only output errors").option("--json", "Output results as JSON").action(async (files, options) => {
+  command.description("Validate .canvas configuration files").argument(
+    "[files...]",
+    "Files or glob patterns to validate (defaults to .principal-views/*.canvas)"
+  ).option("-q, --quiet", "Only output errors").option("--json", "Output results as JSON").action(async (files, options) => {
     try {
       const patterns = files.length > 0 ? files : [".principal-views/*.canvas"];
       const matchedFiles = await globby(patterns, {
@@ -13956,10 +14296,16 @@ function createValidateCommand() {
       const validCount = allResults.filter((r) => r.isValid).length;
       const invalidCount = allResults.length - validCount;
       if (options.json) {
-        console.log(JSON.stringify({
-          files: allResults,
-          summary: { total: allResults.length, valid: validCount, invalid: invalidCount }
-        }, null, 2));
+        console.log(
+          JSON.stringify(
+            {
+              files: allResults,
+              summary: { total: allResults.length, valid: validCount, invalid: invalidCount }
+            },
+            null,
+            2
+          )
+        );
       } else {
         if (!options.quiet) {
           const fileCount = libraryResult ? `${results.length} canvas file(s) + library` : `${results.length} canvas file(s)`;
@@ -13994,7 +14340,9 @@ Validating ${fileCount}...
         if (invalidCount === 0) {
           console.log(source_default.green(`\u2713 All ${validCount} file(s) are valid`));
         } else {
-          console.log(source_default.red(`\u2717 ${invalidCount} of ${allResults.length} file(s) failed validation`));
+          console.log(
+            source_default.red(`\u2717 ${invalidCount} of ${allResults.length} file(s) failed validation`)
+          );
           process.exit(1);
         }
       }
@@ -14109,7 +14457,9 @@ function createInitCommand() {
         console.log(source_default.green(`Created directory: .principal-views/`));
       }
       if ((0, import_node_fs5.existsSync)(canvasFile) && !options.force) {
-        console.log(source_default.yellow(`Canvas file already exists: .principal-views/${options.name}.canvas`));
+        console.log(
+          source_default.yellow(`Canvas file already exists: .principal-views/${options.name}.canvas`)
+        );
       } else {
         (0, import_node_fs5.writeFileSync)(canvasFile, JSON.stringify(TEMPLATE_CANVAS, null, 2));
         console.log(source_default.green(`Created canvas file: .principal-views/${options.name}.canvas`));
@@ -14150,11 +14500,15 @@ edgeComponents: {}
               if ((0, import_node_fs5.existsSync)(preCommitFile)) {
                 const existingContent = (0, import_node_fs5.readFileSync)(preCommitFile, "utf8");
                 if (existingContent.includes("principal-view-cli lint") || existingContent.includes("privu lint")) {
-                  console.log(source_default.yellow(`Husky pre-commit hook already includes principal view linting`));
+                  console.log(
+                    source_default.yellow(`Husky pre-commit hook already includes principal view linting`)
+                  );
                 } else {
                   const updatedContent = existingContent.trimEnd() + "\n\n# Run principal view linting\nnpx @principal-ai/principal-view-cli lint --quiet\n";
                   (0, import_node_fs5.writeFileSync)(preCommitFile, updatedContent);
-                  console.log(source_default.green(`Updated Husky pre-commit hook with principal view linting`));
+                  console.log(
+                    source_default.green(`Updated Husky pre-commit hook with principal view linting`)
+                  );
                   huskySetup = true;
                 }
               } else {
@@ -14184,8 +14538,16 @@ edgeComponents: {}
                   console.log(source_default.green(`Installed Husky and created pre-commit hook`));
                   huskySetup = true;
                 } catch (installError) {
-                  console.log(source_default.yellow(`Could not install Husky automatically: ${installError.message}`));
-                  console.log(source_default.dim(`  You can install it manually: ${pm} add --dev husky && npx husky init`));
+                  console.log(
+                    source_default.yellow(
+                      `Could not install Husky automatically: ${installError.message}`
+                    )
+                  );
+                  console.log(
+                    source_default.dim(
+                      `  You can install it manually: ${pm} add --dev husky && npx husky init`
+                    )
+                  );
                 }
               }
             }
@@ -14196,8 +14558,12 @@ edgeComponents: {}
       console.log(source_default.bold("Setup complete!"));
       console.log("");
       console.log(source_default.bold("Files created:"));
-      console.log(`  \u2022 ${source_default.cyan(".principal-views/library.yaml")} - Component library definitions`);
-      console.log(`  \u2022 ${source_default.cyan(`.principal-views/${options.name}.canvas`)} - Graph canvas file`);
+      console.log(
+        `  \u2022 ${source_default.cyan(".principal-views/library.yaml")} - Component library definitions`
+      );
+      console.log(
+        `  \u2022 ${source_default.cyan(`.principal-views/${options.name}.canvas`)} - Graph canvas file`
+      );
       if (options.lintConfig !== false) {
         console.log(`  \u2022 ${source_default.cyan(".privurc.yaml")} - Lint configuration`);
       }
@@ -14207,7 +14573,9 @@ edgeComponents: {}
       console.log("");
       console.log(source_default.bold("Next steps:"));
       console.log(`  1. Define components in ${source_default.cyan(".principal-views/library.yaml")}`);
-      console.log(`  2. Build your graph in ${source_default.cyan(`.principal-views/${options.name}.canvas`)}`);
+      console.log(
+        `  2. Build your graph in ${source_default.cyan(`.principal-views/${options.name}.canvas`)}`
+      );
       console.log(`  3. Run ${source_default.cyan("privu lint")} to validate your configuration`);
       if (huskySetup) {
         console.log(`  4. Commits will now automatically lint .principal-views files`);
@@ -14303,11 +14671,21 @@ with standard canvas tools like Obsidian.
 ${source_default.bold("Required Structure:")}
 ${source_default.dim("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")}
 ${source_default.dim("\u2502")} {                                               ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}   ${source_default.green('"nodes"')}: [...],    ${source_default.dim("// Required: array of nodes")}  ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}   ${source_default.green('"edges"')}: [...],    ${source_default.dim("// Optional: array of edges")}  ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}   ${source_default.green('"pv"')}: {            ${source_default.dim("// Required: PV extension")}    ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}     ${source_default.yellow('"name"')}: "...",   ${source_default.dim("// Required: graph name")}      ${source_default.dim("\u2502")}
-${source_default.dim("\u2502")}     ${source_default.yellow('"version"')}: "..." ${source_default.dim("// Required: schema version")}  ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}   ${source_default.green('"nodes"')}: [...],    ${source_default.dim(
+    "// Required: array of nodes"
+  )}  ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}   ${source_default.green('"edges"')}: [...],    ${source_default.dim(
+    "// Optional: array of edges"
+  )}  ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}   ${source_default.green('"pv"')}: {            ${source_default.dim(
+    "// Required: PV extension"
+  )}    ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}     ${source_default.yellow('"name"')}: "...",   ${source_default.dim(
+    "// Required: graph name"
+  )}      ${source_default.dim("\u2502")}
+${source_default.dim("\u2502")}     ${source_default.yellow('"version"')}: "..." ${source_default.dim(
+    "// Required: schema version"
+  )}  ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")}   }                                             ${source_default.dim("\u2502")}
 ${source_default.dim("\u2502")} }                                               ${source_default.dim("\u2502")}
 ${source_default.dim("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518")}
@@ -14338,7 +14716,9 @@ ${source_default.bold("Standard Node Types:")}
               Requires: ${source_default.dim("text")} (string)
 
   ${source_default.yellow("group")}     Visual container for other nodes
-              Optional: ${source_default.dim("label")}, ${source_default.dim("background")}, ${source_default.dim("backgroundStyle")}
+              Optional: ${source_default.dim("label")}, ${source_default.dim("background")}, ${source_default.dim(
+    "backgroundStyle"
+  )}
 
   ${source_default.yellow("file")}      Reference to external file
               Requires: ${source_default.dim("file")} (path string)
@@ -14384,10 +14764,10 @@ ${source_default.bold("Required Fields:")}
   ${source_default.green("id")}          ${source_default.dim("string")}   Unique identifier
   ${source_default.green("fromNode")}    ${source_default.dim("string")}   Source node ID
   ${source_default.green("toNode")}      ${source_default.dim("string")}   Target node ID
-
-${source_default.bold("Optional Fields:")}
   ${source_default.green("fromSide")}    ${source_default.dim("string")}   Side of source: top, right, bottom, left
   ${source_default.green("toSide")}      ${source_default.dim("string")}   Side of target: top, right, bottom, left
+
+${source_default.bold("Optional Fields:")}
   ${source_default.green("fromEnd")}     ${source_default.dim("string")}   Source endpoint: none, arrow
   ${source_default.green("toEnd")}       ${source_default.dim("string")}   Target endpoint: none, arrow (default)
   ${source_default.green("color")}       ${source_default.dim("string")}   Edge color (hex or preset)
@@ -14397,6 +14777,7 @@ ${source_default.bold("PV Edge Extension:")}
   ${source_default.dim("{")}
     ${source_default.green('"id"')}: "edge-1",
     ${source_default.green('"fromNode"')}: "api", ${source_default.green('"toNode"')}: "db",
+    ${source_default.green('"fromSide"')}: "right", ${source_default.green('"toSide"')}: "left",
     ${source_default.green('"pv"')}: {
       ${source_default.yellow('"edgeType"')}: "query"  ${source_default.dim("// Must be defined in vv.edgeTypes")}
     }
@@ -14409,7 +14790,9 @@ ${source_default.bold("Defining Edge Types (in canvas vv):")}
       "version": "1.0.0",
       ${source_default.yellow('"edgeTypes"')}: {
         "query": {
-          ${source_default.cyan('"style"')}: "solid",       ${source_default.dim("// solid, dashed, dotted, animated")}
+          ${source_default.cyan('"style"')}: "solid",       ${source_default.dim(
+    "// solid, dashed, dotted, animated"
+  )}
           ${source_default.cyan('"color"')}: "#64748b",     ${source_default.dim("// Hex color")}
           ${source_default.cyan('"width"')}: 2,             ${source_default.dim("// Line width in pixels")}
           ${source_default.cyan('"directed"')}: true,       ${source_default.dim("// Show arrow")}
@@ -14463,7 +14846,9 @@ ${source_default.bold("Node-Level pv (for custom types):")}
       ${source_default.yellow('"nodeType"')}: "service",        ${source_default.dim("// Required: Type identifier")}
       ${source_default.yellow('"shape"')}: "rectangle",         ${source_default.dim("// Required: Visual shape")}
       ${source_default.cyan('"fill"')}: "#3b82f6",             ${source_default.dim("// Optional: Fill color (hex)")}
-      ${source_default.cyan('"stroke"')}: "#1d4ed8",           ${source_default.dim("// Optional: Border color (hex)")}
+      ${source_default.cyan('"stroke"')}: "#1d4ed8",           ${source_default.dim(
+    "// Optional: Border color (hex)"
+  )}
       ${source_default.cyan('"icon"')}: "Server",              ${source_default.dim("// Optional: Lucide icon name")}
       ${source_default.cyan('"sources"')}: ["src/**/*.ts"],    ${source_default.dim("// Optional: Source patterns")}
       ${source_default.cyan('"states"')}: {                    ${source_default.dim("// Optional: State definitions")}
@@ -14574,6 +14959,8 @@ ${source_default.dim("\u2500".repeat(50))}
       "id": "api-to-db",
       "fromNode": "api",
       "toNode": "db",
+      "fromSide": "right",
+      "toSide": "left",
       "pv": { "edgeType": "query" }
     }
   ],
@@ -14705,7 +15092,9 @@ async function checkConfig(configPath, projectRoot) {
               type: "warning",
               configFile: relativePath,
               nodeType: nodeTypeName,
-              message: `Config may be stale: "${newestFile}" was modified ${formatTimeDiff(timeDiff)} after the config`,
+              message: `Config may be stale: "${newestFile}" was modified ${formatTimeDiff(
+                timeDiff
+              )} after the config`,
               details: `Pattern: ${pattern} (matched ${matchedFiles.length} file${matchedFiles.length > 1 ? "s" : ""})`
             });
           }
@@ -14729,7 +15118,9 @@ function createDoctorCommand() {
       const vgcDir = (0, import_node_path8.resolve)(projectRoot, ".principal-views");
       if (!(0, import_node_fs7.existsSync)(vgcDir)) {
         if (options.json) {
-          console.log(JSON.stringify({ error: "No .principal-views directory found", results: [] }));
+          console.log(
+            JSON.stringify({ error: "No .principal-views directory found", results: [] })
+          );
         } else {
           console.log(source_default.yellow("No .principal-views directory found."));
           console.log(source_default.dim('Run "privu init" to create a configuration.'));
@@ -14743,7 +15134,9 @@ function createDoctorCommand() {
       });
       if (configFiles.length === 0) {
         if (options.json) {
-          console.log(JSON.stringify({ error: "No config files found in .principal-views", results: [] }));
+          console.log(
+            JSON.stringify({ error: "No config files found in .principal-views", results: [] })
+          );
         } else {
           console.log(source_default.yellow("No configuration files found in .principal-views/"));
         }
@@ -14803,7 +15196,9 @@ Checking ${results.length} configuration file(s)...
         for (const result of results) {
           const issues = filterIssues(result.issues);
           if (issues.length === 0 && !options.quiet && !options.errorsOnly) {
-            console.log(source_default.green(`\u2713 ${result.configFile}`) + source_default.dim(` (${result.configName})`));
+            console.log(
+              source_default.green(`\u2713 ${result.configFile}`) + source_default.dim(` (${result.configName})`)
+            );
             continue;
           }
           if (issues.length > 0) {
@@ -14923,7 +15318,9 @@ function initializeHusky(repoPath) {
       }
       console.log("\u2705 Husky installed and initialized");
     } catch (error) {
-      throw new Error(`Failed to initialize husky: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `Failed to initialize husky: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 }
@@ -14939,7 +15336,7 @@ function addVVHook(repoPath) {
   const hookPath = (0, import_node_path9.join)(repoPath, HUSKY_DIR, PRE_COMMIT_HOOK);
   const vvContent = getVVHookContent();
   if ((0, import_node_fs8.existsSync)(hookPath)) {
-    let existingContent = (0, import_node_fs8.readFileSync)(hookPath, "utf8");
+    const existingContent = (0, import_node_fs8.readFileSync)(hookPath, "utf8");
     if (existingContent.includes(VV_HOOK_MARKER)) {
       return;
     }
@@ -15055,7 +15452,9 @@ function createHooksCommand() {
         console.log(source_default.bold("\nPrincipal View Hooks Status\n"));
         console.log(`Repository: ${repoPath}`);
         console.log(`Husky: ${source_default.green("installed")}`);
-        console.log(`PV Hooks: ${hasHook ? source_default.green("configured") : source_default.yellow("not configured")}`);
+        console.log(
+          `PV Hooks: ${hasHook ? source_default.green("configured") : source_default.yellow("not configured")}`
+        );
         if (hasHook) {
           console.log("\nUse --remove to remove or --check to verify");
         } else {
@@ -15079,7 +15478,10 @@ var TEMPLATE_CANVAS2 = {
 };
 function createCreateCommand() {
   const command = new Command("create");
-  command.description("Create a new canvas file in the .principal-views folder").requiredOption("-n, --name <name>", 'Name for the canvas file (e.g., "cache-sync-architecture")').option("-f, --force", "Overwrite existing file").action(async (options) => {
+  command.description("Create a new canvas file in the .principal-views folder").requiredOption(
+    "-n, --name <name>",
+    'Name for the canvas file (e.g., "cache-sync-architecture")'
+  ).option("-f, --force", "Overwrite existing file").action(async (options) => {
     try {
       const vgcDir = (0, import_node_path10.join)(process.cwd(), ".principal-views");
       const canvasFile = (0, import_node_path10.join)(vgcDir, `${options.name}.canvas`);
@@ -15088,7 +15490,9 @@ function createCreateCommand() {
         console.log(source_default.green(`Created directory: .principal-views/`));
       }
       if ((0, import_node_fs9.existsSync)(canvasFile) && !options.force) {
-        console.error(source_default.red(`Error: Canvas file already exists: .principal-views/${options.name}.canvas`));
+        console.error(
+          source_default.red(`Error: Canvas file already exists: .principal-views/${options.name}.canvas`)
+        );
         console.log(source_default.yellow(`Use ${source_default.cyan("--force")} to overwrite`));
         process.exit(1);
       }
@@ -15096,7 +15500,9 @@ function createCreateCommand() {
       console.log(source_default.green(`\u2713 Created canvas file: .principal-views/${options.name}.canvas`));
       console.log("");
       console.log(source_default.bold("Next steps:"));
-      console.log(`  1. Open ${source_default.cyan(`.principal-views/${options.name}.canvas`)} in your editor`);
+      console.log(
+        `  1. Open ${source_default.cyan(`.principal-views/${options.name}.canvas`)} in your editor`
+      );
       console.log(`  2. Add nodes and edges to define your architecture`);
       console.log(`  3. Run ${source_default.cyan("privu validate")} to check your configuration`);
       console.log(`  4. Run ${source_default.cyan("privu doctor")} to verify source mappings`);
@@ -15508,7 +15914,11 @@ function createRulesEngine(rules) {
 }
 
 // ../core/dist/rules/config.js
-var DEFAULT_INCLUDE_PATTERNS = [".principal-views/**/*.yaml", ".principal-views/**/*.yml", ".principal-views/**/*.json"];
+var DEFAULT_INCLUDE_PATTERNS = [
+  ".principal-views/**/*.yaml",
+  ".principal-views/**/*.yml",
+  ".principal-views/**/*.json"
+];
 var DEFAULT_EXCLUDE_PATTERNS = ["**/node_modules/**", "**/*.test.*"];
 var VALID_SEVERITIES = [
   "off",
@@ -17174,11 +17584,7 @@ function createDefaultRulesEngine() {
 }
 
 // src/commands/lint.ts
-var CONFIG_FILE_NAMES2 = [
-  ".privurc.yaml",
-  ".privurc.yml",
-  ".privurc.json"
-];
+var CONFIG_FILE_NAMES2 = [".privurc.yaml", ".privurc.yml", ".privurc.json"];
 function findConfig(startDir) {
   let currentDir = (0, import_node_path11.resolve)(startDir);
   while (true) {
@@ -17334,7 +17740,10 @@ function formatJsonOutput(results) {
 }
 function createLintCommand() {
   const command = new Command("lint");
-  command.description("Lint graph configuration files").argument("[files...]", "Files or glob patterns to lint (defaults to .principal-views/**/*.yaml)").option("-c, --config <path>", "Path to config file").option("--library <path>", "Path to component library file").option("-q, --quiet", "Only output errors").option("--json", "Output results as JSON").option("--rule <rules...>", "Only run specific rules").option("--ignore-rule <rules...>", "Skip specific rules").action(async (files, options) => {
+  command.description("Lint graph configuration files").argument(
+    "[files...]",
+    "Files or glob patterns to lint (defaults to .principal-views/**/*.yaml)"
+  ).option("-c, --config <path>", "Path to config file").option("--library <path>", "Path to component library file").option("-q, --quiet", "Only output errors").option("--json", "Output results as JSON").option("--rule <rules...>", "Only run specific rules").option("--ignore-rule <rules...>", "Skip specific rules").action(async (files, options) => {
     try {
       const cwd = process.cwd();
       let privuConfig = getDefaultConfig();
@@ -17382,7 +17791,11 @@ function createLintCommand() {
       } else if (privuConfig.include && privuConfig.include.length > 0) {
         patterns = privuConfig.include;
       } else {
-        patterns = [".principal-views/**/*.yaml", ".principal-views/**/*.yml", ".principal-views/**/*.json"];
+        patterns = [
+          ".principal-views/**/*.yaml",
+          ".principal-views/**/*.yml",
+          ".principal-views/**/*.json"
+        ];
       }
       const matchedFiles = await globby(patterns, {
         ignore: privuConfig.exclude || ["**/node_modules/**"],
@@ -17397,9 +17810,16 @@ function createLintCommand() {
       });
       if (configFiles.length === 0) {
         if (options.json) {
-          console.log(JSON.stringify({ files: [], summary: { totalFiles: 0, totalErrors: 0, totalWarnings: 0, totalFixable: 0 } }));
+          console.log(
+            JSON.stringify({
+              files: [],
+              summary: { totalFiles: 0, totalErrors: 0, totalWarnings: 0, totalFixable: 0 }
+            })
+          );
         } else {
-          console.log(source_default.yellow("No configuration files found matching the specified patterns."));
+          console.log(
+            source_default.yellow("No configuration files found matching the specified patterns.")
+          );
           console.log(source_default.dim(`Patterns searched: ${patterns.join(", ")}`));
         }
         return;
@@ -17421,14 +17841,16 @@ function createLintCommand() {
         const loaded = loadGraphConfig(absolutePath);
         if (!loaded) {
           results.set(relativePath, {
-            violations: [{
-              ruleId: "parse-error",
-              severity: "error",
-              file: relativePath,
-              message: `Could not parse file: ${filePath}`,
-              impact: "File cannot be validated",
-              fixable: false
-            }],
+            violations: [
+              {
+                ruleId: "parse-error",
+                severity: "error",
+                file: relativePath,
+                message: `Could not parse file: ${filePath}`,
+                impact: "File cannot be validated",
+                fixable: false
+              }
+            ],
             errorCount: 1,
             warningCount: 0,
             fixableCount: 0,