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

package/README.md

@@ -37,6 +37,7 @@ vv validate --json             # Output as JSON
 ```
 
 **Validation checks:**
+
 - Required `vv` extension with name and version
 - All nodes have required fields (id, type, x, y, width, height)
 - Custom node types must have `vv.nodeType` and valid `vv.shape`
@@ -96,18 +97,22 @@ Canvas files follow the [JSON Canvas](https://jsoncanvas.org/) specification wit
 ### Node Types
 
 **Standard types** (no additional metadata required):
+
 - `text` - Text content
 - `group` - Container for other nodes
 - `file` - File reference
 - `link` - URL link
 
 **Custom types** require `vv` extension:
+
 ```json
 {
   "id": "node-1",
   "type": "custom",
-  "x": 0, "y": 0,
-  "width": 200, "height": 100,
+  "x": 0,
+  "y": 0,
+  "width": 200,
+  "height": 100,
   "vv": {
     "nodeType": "service",
     "shape": "rectangle"

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+KpC,wBAAgB,mBAAmB,IAAI,OAAO,CAgK7C"}
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAmLpC,wBAAgB,mBAAmB,IAAI,OAAO,CAsK7C"}

package/dist/commands/doctor.js

@@ -184,21 +184,21 @@ export function createDoctorCommand() {
             // Filter issues based on options
             const filterIssues = (issues) => {
                 if (options.errorsOnly) {
-                    return issues.filter(i => i.type === 'error');
+                    return issues.filter((i) => i.type === 'error');
                 }
                 if (options.quiet) {
-                    return issues.filter(i => i.type === 'error' || i.type === 'warning');
+                    return issues.filter((i) => i.type === 'error' || i.type === 'warning');
                 }
                 return issues;
             };
             // Count issues
-            const allIssues = results.flatMap(r => filterIssues(r.issues));
-            const errorCount = allIssues.filter(i => i.type === 'error').length;
-            const warningCount = allIssues.filter(i => i.type === 'warning').length;
+            const allIssues = results.flatMap((r) => filterIssues(r.issues));
+            const errorCount = allIssues.filter((i) => i.type === 'error').length;
+            const warningCount = allIssues.filter((i) => i.type === 'warning').length;
             // Output results
             if (options.json) {
                 console.log(JSON.stringify({
-                    results: results.map(r => ({
+                    results: results.map((r) => ({
                         ...r,
                         issues: filterIssues(r.issues),
                     })),
@@ -221,7 +221,7 @@ export function createDoctorCommand() {
                         continue;
                     }
                     if (issues.length > 0) {
-                        const hasErrors = issues.some(i => i.type === 'error');
+                        const hasErrors = issues.some((i) => i.type === 'error');
                         const icon = hasErrors ? chalk.red('✗') : chalk.yellow('⚠');
                         console.log(`${icon} ${result.configFile}` + chalk.dim(` (${result.configName})`));
                         for (const issue of issues) {

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

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0NpC,wBAAgB,kBAAkB,IAAI,OAAO,CA6F5C"}
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/commands/hooks.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA4NpC,wBAAgB,kBAAkB,IAAI,OAAO,CA+F5C"}

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

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkIpC,wBAAgB,iBAAiB,IAAI,OAAO,CAoK3C"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAkIpC,wBAAgB,iBAAiB,IAAI,OAAO,CA6L3C"}

package/dist/commands/init.js

@@ -198,12 +198,14 @@ edgeComponents: {}
                             if (existsSync(preCommitFile)) {
                                 // Check if our hook is already in the file
                                 const existingContent = readFileSync(preCommitFile, 'utf8');
-                                if (existingContent.includes('principal-view-cli lint') || existingContent.includes('privu lint')) {
+                                if (existingContent.includes('principal-view-cli lint') ||
+                                    existingContent.includes('privu lint')) {
                                     console.log(chalk.yellow(`Husky pre-commit hook already includes principal view linting`));
                                 }
                                 else {
                                     // Append our lint command to existing pre-commit
-                                    const updatedContent = existingContent.trimEnd() + '\n\n# Run principal view linting\nnpx @principal-ai/principal-view-cli lint --quiet\n';
+                                    const updatedContent = existingContent.trimEnd() +
+                                        '\n\n# Run principal view linting\nnpx @principal-ai/principal-view-cli lint --quiet\n';
                                     writeFileSync(preCommitFile, updatedContent);
                                     console.log(chalk.green(`Updated Husky pre-commit hook with principal view linting`));
                                     huskySetup = true;

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

@@ -1 +1 @@
-{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/commands/lint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8PpC,wBAAgB,iBAAiB,IAAI,OAAO,CA8K3C"}
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../src/commands/lint.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0PpC,wBAAgB,iBAAiB,IAAI,OAAO,CA8L3C"}

package/dist/commands/lint.js

@@ -14,11 +14,7 @@ import { createDefaultRulesEngine, validatePrivuConfig, mergeConfigs, getDefault
 /**
  * Config file names in resolution order
  */
-const CONFIG_FILE_NAMES = [
-    '.privurc.yaml',
-    '.privurc.yml',
-    '.privurc.json',
-];
+const CONFIG_FILE_NAMES = ['.privurc.yaml', '.privurc.yml', '.privurc.json'];
 /**
  * Find and load privurc config file
  */
@@ -277,7 +273,11 @@ export function createLintCommand() {
                 patterns = privuConfig.include;
             }
             else {
-                patterns = ['.principal-views/**/*.yaml', '.principal-views/**/*.yml', '.principal-views/**/*.json'];
+                patterns = [
+                    '.principal-views/**/*.yaml',
+                    '.principal-views/**/*.yml',
+                    '.principal-views/**/*.json',
+                ];
             }
             // Find matching files
             const matchedFiles = await globby(patterns, {
@@ -294,7 +294,10 @@ export 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(chalk.yellow('No configuration files found matching the specified patterns.'));
@@ -323,14 +326,16 @@ export function createLintCommand() {
                 if (!loaded) {
                     // File couldn't be loaded - report as error
                     results.set(relativePath, {
-                        violations: [{
+                        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,

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;AA2TpC,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;AA2UpC,wBAAgB,mBAAmB,IAAI,OAAO,CA0B7C"}

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

package/dist/commands/validate.js

@@ -17,13 +17,13 @@ function loadLibrary(principalViewsDir) {
         if (existsSync(libraryPath)) {
             try {
                 const content = readFileSync(libraryPath, 'utf8');
-                const library = fileName.endsWith('.json')
-                    ? JSON.parse(content)
-                    : yaml.load(content);
+                const library = fileName.endsWith('.json') ? JSON.parse(content) : yaml.load(content);
                 if (library && typeof library === 'object') {
                     return {
-                        nodeComponents: library.nodeComponents || {},
-                        edgeComponents: library.edgeComponents || {},
+                        nodeComponents: library.nodeComponents ||
+                            {},
+                        edgeComponents: library.edgeComponents ||
+                            {},
                         raw: library,
                         path: libraryPath,
                     };
@@ -129,12 +129,27 @@ const VALID_NODE_SHAPES = ['circle', 'rectangle', 'hexagon', 'diamond', 'custom'
 const 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
@@ -145,13 +160,36 @@ const 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'],
@@ -161,13 +199,35 @@ const ALLOWED_CANVAS_FIELDS = {
  */
 const 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'],
@@ -323,7 +383,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;
@@ -347,23 +411,72 @@ function validateCanvas(canvas, filePath, library) {
             // Custom types can have any base fields
             checkUnknownFields(n, allowedNodeFields, nodePath, issues);
             if (typeof n.id !== 'string' || !n.id) {
-                issues.push({ type: 'error', message: `Node at index ${index} must have a string "id"`, path: `${nodePath}.id` });
+                issues.push({
+                    type: 'error',
+                    message: `Node at index ${index} must have a string "id"`,
+                    path: `${nodePath}.id`,
+                });
             }
             if (typeof n.type !== 'string') {
-                issues.push({ type: 'error', message: `Node "${nodeLabel}" must have a string "type"`, path: `${nodePath}.type` });
+                issues.push({
+                    type: 'error',
+                    message: `Node "${nodeLabel}" must have a string "type"`,
+                    path: `${nodePath}.type`,
+                });
             }
             if (typeof n.x !== 'number') {
-                issues.push({ type: 'error', message: `Node "${nodeLabel}" must have a numeric "x" position`, path: `${nodePath}.x` });
+                issues.push({
+                    type: 'error',
+                    message: `Node "${nodeLabel}" must have a numeric "x" position`,
+                    path: `${nodePath}.x`,
+                });
             }
             if (typeof n.y !== 'number') {
-                issues.push({ type: 'error', message: `Node "${nodeLabel}" must have a numeric "y" position`, path: `${nodePath}.y` });
+                issues.push({
+                    type: 'error',
+                    message: `Node "${nodeLabel}" must have a numeric "y" position`,
+                    path: `${nodePath}.y`,
+                });
             }
             // Width and height are now REQUIRED (was warning)
             if (typeof n.width !== 'number') {
-                issues.push({ type: 'error', message: `Node "${nodeLabel}" must have a numeric "width"`, path: `${nodePath}.width` });
+                issues.push({
+                    type: 'error',
+                    message: `Node "${nodeLabel}" must have a numeric "width"`,
+                    path: `${nodePath}.width`,
+                });
             }
             if (typeof n.height !== 'number') {
-                issues.push({ type: 'error', message: `Node "${nodeLabel}" must have a numeric "height"`, path: `${nodePath}.height` });
+                issues.push({
+                    type: 'error',
+                    message: `Node "${nodeLabel}" must have a numeric "height"`,
+                    path: `${nodePath}.height`,
+                });
+            }
+            // Validate required fields for standard canvas types
+            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: `${nodePath}.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: `${nodePath}.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: `${nodePath}.url`,
+                    suggestion: 'Add a "url" field with a URL, or change the node type',
+                });
             }
             // Validate node type - must be standard canvas type OR have pv metadata
             const isStandardType = STANDARD_CANVAS_TYPES.includes(nodeType);
@@ -386,7 +499,8 @@ function validateCanvas(canvas, filePath, library) {
                             path: `nodes[${index}].pv.nodeType`,
                         });
                     }
-                    if (typeof nodePv.shape !== 'string' || !VALID_NODE_SHAPES.includes(nodePv.shape)) {
+                    if (typeof nodePv.shape !== 'string' ||
+                        !VALID_NODE_SHAPES.includes(nodePv.shape)) {
                         issues.push({
                             type: 'error',
                             message: `Node "${n.id || index}" must have a valid "pv.shape"`,
@@ -464,10 +578,14 @@ function validateCanvas(canvas, filePath, library) {
         issues.push({ type: 'error', message: '"edges" must be an array if present' });
     }
     else if (Array.isArray(c.edges)) {
-        const nodeIds = new Set(c.nodes?.map(n => n.id) || []);
+        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;
@@ -476,19 +594,39 @@ function validateCanvas(canvas, filePath, library) {
             // Check unknown fields on edge
             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`,
+                });
             }
             // Validate edge pv extension fields
             if (e.pv && typeof e.pv === 'object') {
@@ -558,7 +696,7 @@ function validateFile(filePath, library) {
         const content = readFileSync(absolutePath, 'utf8');
         const canvas = JSON.parse(content);
         const issues = validateCanvas(canvas, relativePath, library);
-        const hasErrors = issues.some(i => i.type === 'error');
+        const hasErrors = issues.some((i) => i.type === 'error');
         return {
             file: relativePath,
             isValid: !hasErrors,
@@ -607,7 +745,7 @@ export function createValidateCommand() {
             let libraryResult = null;
             if (library && Object.keys(library.raw).length > 0) {
                 const libraryIssues = validateLibrary(library);
-                const libraryHasErrors = libraryIssues.some(i => i.type === 'error');
+                const libraryHasErrors = libraryIssues.some((i) => i.type === 'error');
                 libraryResult = {
                     file: relative(process.cwd(), library.path),
                     isValid: !libraryHasErrors,
@@ -615,10 +753,10 @@ export function createValidateCommand() {
                 };
             }
             // Validate all canvas files
-            const results = matchedFiles.map(f => validateFile(f, library));
+            const results = matchedFiles.map((f) => validateFile(f, library));
             // Combine results
             const allResults = libraryResult ? [libraryResult, ...results] : results;
-            const validCount = allResults.filter(r => r.isValid).length;
+            const validCount = allResults.filter((r) => r.isValid).length;
             const invalidCount = allResults.length - validCount;
             // Output results
             if (options.json) {
@@ -629,16 +767,18 @@ export function createValidateCommand() {
             }
             else {
                 if (!options.quiet) {
-                    const fileCount = libraryResult ? `${results.length} canvas file(s) + library` : `${results.length} canvas file(s)`;
+                    const fileCount = libraryResult
+                        ? `${results.length} canvas file(s) + library`
+                        : `${results.length} canvas file(s)`;
                     console.log(chalk.bold(`\nValidating ${fileCount}...\n`));
                 }
                 for (const result of allResults) {
                     if (result.isValid) {
                         if (!options.quiet) {
                             console.log(chalk.green(`✓ ${result.file}`));
-                            const warnings = result.issues.filter(i => i.type === 'warning');
+                            const warnings = result.issues.filter((i) => i.type === 'warning');
                             if (warnings.length > 0) {
-                                warnings.forEach(w => {
+                                warnings.forEach((w) => {
                                     console.log(chalk.yellow(`  ⚠ ${w.message}`));
                                 });
                             }
@@ -646,7 +786,7 @@ export function createValidateCommand() {
                     }
                     else {
                         console.log(chalk.red(`✗ ${result.file}`));
-                        result.issues.forEach(issue => {
+                        result.issues.forEach((issue) => {
                             const icon = issue.type === 'error' ? '✗' : '⚠';
                             const color = issue.type === 'error' ? chalk.red : chalk.yellow;
                             console.log(color(`  ${icon} ${issue.message}`));