@principal-ai/principal-view-cli 0.1.20 → 0.1.22

package/dist/commands/hooks.js

@@ -113,7 +113,7 @@ function addVVHook(repoPath) {
     const vvContent = getVVHookContent();
     if (existsSync(hookPath)) {
         // Append to existing hook
-        let existingContent = readFileSync(hookPath, 'utf8');
+        const existingContent = readFileSync(hookPath, 'utf8');
         // Check if already has PV hook
         if (existingContent.includes(VV_HOOK_MARKER)) {
             return;

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

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/commands/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2UpC,wBAAgB,mBAAmB,IAAI,OAAO,CA0B7C"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/commands/schema.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8UpC,wBAAgB,mBAAmB,IAAI,OAAO,CA0B7C"}

package/dist/commands/schema.js

@@ -96,10 +96,10 @@ ${chalk.bold('Required Fields:')}
   ${chalk.green('id')}          ${chalk.dim('string')}   Unique identifier
   ${chalk.green('fromNode')}    ${chalk.dim('string')}   Source node ID
   ${chalk.green('toNode')}      ${chalk.dim('string')}   Target node ID
-
-${chalk.bold('Optional Fields:')}
   ${chalk.green('fromSide')}    ${chalk.dim('string')}   Side of source: top, right, bottom, left
   ${chalk.green('toSide')}      ${chalk.dim('string')}   Side of target: top, right, bottom, left
+
+${chalk.bold('Optional Fields:')}
   ${chalk.green('fromEnd')}     ${chalk.dim('string')}   Source endpoint: none, arrow
   ${chalk.green('toEnd')}       ${chalk.dim('string')}   Target endpoint: none, arrow (default)
   ${chalk.green('color')}       ${chalk.dim('string')}   Edge color (hex or preset)
@@ -109,6 +109,7 @@ ${chalk.bold('PV Edge Extension:')}
   ${chalk.dim('{')}
     ${chalk.green('"id"')}: "edge-1",
     ${chalk.green('"fromNode"')}: "api", ${chalk.green('"toNode"')}: "db",
+    ${chalk.green('"fromSide"')}: "right", ${chalk.green('"toSide"')}: "left",
     ${chalk.green('"pv"')}: {
       ${chalk.yellow('"edgeType"')}: "query"  ${chalk.dim('// Must be defined in vv.edgeTypes')}
     }
@@ -286,6 +287,8 @@ ${chalk.dim('─'.repeat(50))}
       "id": "api-to-db",
       "fromNode": "api",
       "toNode": "db",
+      "fromSide": "right",
+      "toSide": "left",
       "pv": { "edgeType": "query" }
     }
   ],

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;AA26BpC,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;AA4iCpC,wBAAgB,qBAAqB,IAAI,OAAO,CAsH/C"}

package/dist/commands/validate.js

@@ -51,6 +51,8 @@ function validateLibrary(library) {
             if (compDef && typeof compDef === 'object') {
                 const comp = compDef;
                 checkUnknownFields(comp, ALLOWED_LIBRARY_FIELDS.nodeComponent, `nodeComponents.${compId}`, issues);
+                // Validate icon name format (must be PascalCase for Lucide icons)
+                validateIconName(comp.icon, `nodeComponents.${compId}.icon`, issues);
                 // Check nested fields
                 if (comp.size && typeof comp.size === 'object') {
                     checkUnknownFields(comp.size, ALLOWED_LIBRARY_FIELDS.nodeComponentSize, `nodeComponents.${compId}.size`, issues);
@@ -59,6 +61,9 @@ function validateLibrary(library) {
                     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);
+                            // Validate state icon name format
+                            const state = stateDef;
+                            validateIconName(state.icon, `nodeComponents.${compId}.states.${stateId}.icon`, issues);
                         }
                     }
                 }
@@ -121,6 +126,55 @@ const STANDARD_CANVAS_TYPES = ['text', 'group', 'file', 'link'];
  */
 const VALID_NODE_SHAPES = ['circle', 'rectangle', 'hexagon', 'diamond', 'custom'];
 // ============================================================================
+// Icon Validation
+// ============================================================================
+/**
+ * Convert kebab-case to PascalCase
+ * e.g., "file-text" -> "FileText", "alert-circle" -> "AlertCircle"
+ */
+function kebabToPascalCase(str) {
+    return str
+        .split('-')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join('');
+}
+/**
+ * Check if a string looks like kebab-case (has hyphens and lowercase)
+ */
+function isKebabCase(str) {
+    return str.includes('-') && str === str.toLowerCase();
+}
+/**
+ * Validate an icon name and return issues if invalid
+ * Icons should be in PascalCase (e.g., "FileText", "Database", "AlertCircle")
+ */
+function validateIconName(iconValue, path, issues) {
+    if (typeof iconValue !== 'string' || !iconValue) {
+        return; // No icon specified, that's fine
+    }
+    // Check if it looks like kebab-case
+    if (isKebabCase(iconValue)) {
+        const suggested = kebabToPascalCase(iconValue);
+        issues.push({
+            type: 'error',
+            message: `Invalid icon name "${iconValue}" - icons must be in PascalCase`,
+            path,
+            suggestion: `Use "${suggested}" instead of "${iconValue}"`,
+        });
+        return;
+    }
+    // Check if first character is lowercase (common mistake)
+    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,
+            suggestion: `Use "${suggested}" instead of "${iconValue}"`,
+        });
+    }
+}
+// ============================================================================
 // Allowed Fields Definitions
 // ============================================================================
 /**
@@ -353,6 +407,9 @@ function validateCanvas(canvas, filePath, library) {
             for (const [typeId, typeDef] of Object.entries(pv.nodeTypes)) {
                 if (typeDef && typeof typeDef === 'object') {
                     checkUnknownFields(typeDef, ALLOWED_CANVAS_FIELDS.pvNodeType, `pv.nodeTypes.${typeId}`, issues);
+                    // Validate icon name format
+                    const nodeType = typeDef;
+                    validateIconName(nodeType.icon, `pv.nodeTypes.${typeId}.icon`, issues);
                 }
             }
         }
@@ -515,11 +572,16 @@ function validateCanvas(canvas, filePath, library) {
                 const nodePv = n.pv;
                 // Check unknown fields in node pv extension
                 checkUnknownFields(nodePv, ALLOWED_CANVAS_FIELDS.nodePv, `${nodePath}.pv`, issues);
+                // Validate icon name format (must be PascalCase for Lucide icons)
+                validateIconName(nodePv.icon, `${nodePath}.pv.icon`, issues);
                 // Check nested pv fields
                 if (nodePv.states && typeof nodePv.states === 'object') {
                     for (const [stateId, stateDef] of Object.entries(nodePv.states)) {
                         if (stateDef && typeof stateDef === 'object') {
                             checkUnknownFields(stateDef, ALLOWED_CANVAS_FIELDS.nodePvState, `${nodePath}.pv.states.${stateId}`, issues);
+                            // Validate state icon name format
+                            const state = stateDef;
+                            validateIconName(state.icon, `${nodePath}.pv.states.${stateId}.icon`, issues);
                         }
                     }
                 }
@@ -628,6 +690,62 @@ function validateCanvas(canvas, filePath, library) {
                     path: `${edgePath}.toNode`,
                 });
             }
+            // Validate fromSide and toSide are present and valid
+            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(', ')}`,
+                });
+            }
+            // Validate pv extension is present with edgeType
+            if (!e.pv || typeof e.pv !== 'object') {
+                issues.push({
+                    type: 'error',
+                    message: `Edge "${edgeLabel}" must have a "pv" extension with edgeType`,
+                    path: `${edgePath}.pv`,
+                    suggestion: 'Add: "pv": { "edgeType": "your-edge-type" }',
+                });
+            }
+            else {
+                const edgePv = e.pv;
+                if (typeof edgePv.edgeType !== 'string' || !edgePv.edgeType) {
+                    issues.push({
+                        type: 'error',
+                        message: `Edge "${edgeLabel}" must have a "pv.edgeType" field`,
+                        path: `${edgePath}.pv.edgeType`,
+                        suggestion: allDefinedEdgeTypes.length > 0
+                            ? `Available types: ${allDefinedEdgeTypes.join(', ')}`
+                            : 'Define edge types in canvas pv.edgeTypes or library.yaml edgeComponents',
+                    });
+                }
+            }
             // Validate edge pv extension fields
             if (e.pv && typeof e.pv === 'object') {
                 const edgePv = e.pv;

package/dist/index.cjs

@@ -13490,6 +13490,7 @@ function validateLibrary(library) {
           `nodeComponents.${compId}`,
           issues
         );
+        validateIconName(comp.icon, `nodeComponents.${compId}.icon`, issues);
         if (comp.size && typeof comp.size === "object") {
           checkUnknownFields(
             comp.size,
@@ -13509,6 +13510,8 @@ function validateLibrary(library) {
                 `nodeComponents.${compId}.states.${stateId}`,
                 issues
               );
+              const state = stateDef;
+              validateIconName(state.icon, `nodeComponents.${compId}.states.${stateId}.icon`, issues);
             }
           }
         }
@@ -13603,6 +13606,36 @@ 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"],
@@ -13817,6 +13850,8 @@ function validateCanvas(canvas, filePath, library) {
             `pv.nodeTypes.${typeId}`,
             issues
           );
+          const nodeType = typeDef;
+          validateIconName(nodeType.icon, `pv.nodeTypes.${typeId}.icon`, issues);
         }
       }
     }
@@ -13981,6 +14016,7 @@ 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
@@ -13992,6 +14028,8 @@ function validateCanvas(canvas, filePath, library) {
                 `${nodePath2}.pv.states.${stateId}`,
                 issues
               );
+              const state = stateDef;
+              validateIconName(state.icon, `${nodePath2}.pv.states.${stateId}.icon`, issues);
             }
           }
         }
@@ -14107,6 +14145,55 @@ function validateCanvas(canvas, filePath, library) {
           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") {
+        issues.push({
+          type: "error",
+          message: `Edge "${edgeLabel}" must have a "pv" extension with edgeType`,
+          path: `${edgePath}.pv`,
+          suggestion: 'Add: "pv": { "edgeType": "your-edge-type" }'
+        });
+      } else {
+        const edgePv = e.pv;
+        if (typeof edgePv.edgeType !== "string" || !edgePv.edgeType) {
+          issues.push({
+            type: "error",
+            message: `Edge "${edgeLabel}" must have a "pv.edgeType" field`,
+            path: `${edgePath}.pv.edgeType`,
+            suggestion: allDefinedEdgeTypes.length > 0 ? `Available types: ${allDefinedEdgeTypes.join(", ")}` : "Define edge types in canvas pv.edgeTypes or library.yaml edgeComponents"
+          });
+        }
+      }
       if (e.pv && typeof e.pv === "object") {
         const edgePv = e.pv;
         checkUnknownFields(edgePv, ALLOWED_CANVAS_FIELDS.edgePv, `${edgePath}.pv`, issues);
@@ -14695,10 +14782,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)
@@ -14708,6 +14795,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")}
     }
@@ -14889,6 +14977,8 @@ ${source_default.dim("\u2500".repeat(50))}
       "id": "api-to-db",
       "fromNode": "api",
       "toNode": "db",
+      "fromSide": "right",
+      "toSide": "left",
       "pv": { "edgeType": "query" }
     }
   ],
@@ -15264,7 +15354,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;
     }
@@ -15842,7 +15932,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",