@principal-ai/principal-view-cli 0.1.29 → 0.1.31

package/dist/commands/validate-execution.js

@@ -0,0 +1,230 @@
+/**
+ * Validate execution files command
+ *
+ * Validates .spans.json, .execution.json, .otel.json, and .events.json files
+ * to ensure they conform to the expected ExecutionData structure.
+ */
+import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { resolve, relative } from 'node:path';
+import chalk from 'chalk';
+import { globby } from 'globby';
+import { createExecutionValidator } from '@principal-ai/principal-view-core';
+/**
+ * Load and parse an execution file
+ */
+function loadExecutionFile(filePath) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+}
+/**
+ * Format validation results for console output
+ */
+function formatConsoleOutput(results, options) {
+    const lines = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    for (const { file, result } of results) {
+        totalErrors += result.errors.length;
+        totalWarnings += result.warnings.length;
+        // If quiet mode, only show files with issues
+        if (options.quiet && result.valid && result.warnings.length === 0) {
+            continue;
+        }
+        // Show file status
+        if (result.valid && result.warnings.length === 0) {
+            lines.push(chalk.green(`✓ ${file}`));
+        }
+        else if (result.valid && result.warnings.length > 0) {
+            lines.push(chalk.yellow(`⚠ ${file}`));
+        }
+        else {
+            lines.push(chalk.red(`✗ ${file}`));
+        }
+        // Show errors
+        if (result.errors.length > 0) {
+            lines.push('');
+            result.errors.forEach((error) => {
+                lines.push(chalk.red(`  ERROR: ${error.path}`));
+                lines.push(`    ${error.message}`);
+                if (error.suggestion) {
+                    lines.push(chalk.dim(`    → ${error.suggestion}`));
+                }
+            });
+            lines.push('');
+        }
+        // Show warnings
+        if (result.warnings.length > 0) {
+            lines.push('');
+            result.warnings.forEach((warning) => {
+                lines.push(chalk.yellow(`  WARN: ${warning.path}`));
+                lines.push(`    ${warning.message}`);
+                if (warning.suggestion) {
+                    lines.push(chalk.dim(`    → ${warning.suggestion}`));
+                }
+            });
+            lines.push('');
+        }
+    }
+    // Summary
+    lines.push('');
+    if (totalErrors === 0 && totalWarnings === 0) {
+        lines.push(chalk.green(`✓ All ${results.length} file${results.length === 1 ? '' : 's'} passed validation`));
+    }
+    else {
+        const parts = [];
+        if (totalErrors > 0) {
+            parts.push(chalk.red(`${totalErrors} error${totalErrors === 1 ? '' : 's'}`));
+        }
+        if (totalWarnings > 0) {
+            parts.push(chalk.yellow(`${totalWarnings} warning${totalWarnings === 1 ? '' : 's'}`));
+        }
+        lines.push(`✖ ${parts.join(', ')} found in ${results.length} file${results.length === 1 ? '' : 's'}`);
+    }
+    return {
+        output: lines.join('\n'),
+        hasErrors: totalErrors > 0,
+    };
+}
+/**
+ * Format validation results as JSON
+ */
+function formatJsonOutput(results) {
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    const files = results.map(({ file, result }) => {
+        totalErrors += result.errors.length;
+        totalWarnings += result.warnings.length;
+        return {
+            file,
+            valid: result.valid,
+            errorCount: result.errors.length,
+            warningCount: result.warnings.length,
+            errors: result.errors,
+            warnings: result.warnings,
+        };
+    });
+    return {
+        files,
+        summary: {
+            totalFiles: files.length,
+            totalErrors,
+            totalWarnings,
+            validFiles: files.filter((f) => f.valid).length,
+            invalidFiles: files.filter((f) => !f.valid).length,
+        },
+    };
+}
+/**
+ * Create the validate-execution command
+ */
+export function createValidateExecutionCommand() {
+    const command = new Command('validate-execution');
+    command
+        .description('Validate execution files (.spans.json, .execution.json, .otel.json, .events.json)')
+        .argument('[files...]', 'Files or glob patterns to validate (defaults to **/__executions__/**/*.json)')
+        .option('--json', 'Output results as JSON')
+        .option('-q, --quiet', 'Only show files with errors or warnings')
+        .action(async (files, options) => {
+        try {
+            const cwd = process.cwd();
+            const validator = createExecutionValidator();
+            // Determine files to validate
+            let patterns;
+            if (files.length > 0) {
+                patterns = files;
+            }
+            else {
+                // Default: find all execution files in __executions__ directories
+                patterns = [
+                    '**/__executions__/*.spans.json',
+                    '**/__executions__/*.execution.json',
+                    '**/__executions__/*.otel.json',
+                    '**/__executions__/*.events.json',
+                    '.principal-views/__executions__/*.spans.json',
+                    '.principal-views/__executions__/*.execution.json',
+                    '.principal-views/__executions__/*.otel.json',
+                    '.principal-views/__executions__/*.events.json',
+                ];
+            }
+            // Find matching files
+            const matchedFiles = await globby(patterns, {
+                ignore: ['**/node_modules/**'],
+                absolute: false,
+            });
+            if (matchedFiles.length === 0) {
+                if (options.json) {
+                    console.log(JSON.stringify({
+                        files: [],
+                        summary: {
+                            totalFiles: 0,
+                            totalErrors: 0,
+                            totalWarnings: 0,
+                            validFiles: 0,
+                            invalidFiles: 0,
+                        },
+                    }));
+                }
+                else {
+                    console.log(chalk.yellow('No execution files found matching the specified patterns.'));
+                    console.log(chalk.dim(`Patterns searched: ${patterns.join(', ')}`));
+                }
+                return;
+            }
+            // Validate each file
+            const results = [];
+            for (const filePath of matchedFiles) {
+                const absolutePath = resolve(cwd, filePath);
+                const relativePath = relative(cwd, absolutePath);
+                try {
+                    const data = loadExecutionFile(absolutePath);
+                    const result = validator.validate(data, relativePath);
+                    results.push({ file: relativePath, result });
+                }
+                catch (error) {
+                    // Parse error
+                    results.push({
+                        file: relativePath,
+                        result: {
+                            valid: false,
+                            errors: [
+                                {
+                                    path: relativePath,
+                                    message: error.message,
+                                    severity: 'error',
+                                },
+                            ],
+                            warnings: [],
+                        },
+                    });
+                }
+            }
+            // Output results
+            if (options.json) {
+                console.log(JSON.stringify(formatJsonOutput(results), null, 2));
+            }
+            else {
+                const { output, hasErrors } = formatConsoleOutput(results, options);
+                console.log(output);
+                if (hasErrors) {
+                    process.exit(1);
+                }
+            }
+        }
+        catch (error) {
+            if (options.json) {
+                console.log(JSON.stringify({ error: error.message }));
+            }
+            else {
+                console.error(chalk.red('Error:'), error.message);
+            }
+            process.exit(1);
+        }
+    });
+    return command;
+}

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

package/dist/commands/validate.js

@@ -121,10 +121,6 @@ function validateLibrary(library) {
  * Standard JSON Canvas node types that don't require pv metadata
  */
 const STANDARD_CANVAS_TYPES = ['text', 'group', 'file', 'link'];
-/**
- * Valid node shapes for pv.shape
- */
-const VALID_NODE_SHAPES = ['circle', 'rectangle', 'hexagon', 'diamond', 'custom'];
 // ============================================================================
 // Icon Validation
 // ============================================================================

package/dist/index.js

@@ -6,6 +6,7 @@
  */
 import { Command } from 'commander';
 import { createValidateCommand } from './commands/validate.js';
+import { createValidateExecutionCommand } from './commands/validate-execution.js';
 import { createInitCommand } from './commands/init.js';
 import { createListCommand } from './commands/list.js';
 import { createSchemaCommand } from './commands/schema.js';
@@ -14,6 +15,7 @@ import { createHooksCommand } from './commands/hooks.js';
 import { createCreateCommand } from './commands/create.js';
 import { createLintCommand } from './commands/lint.js';
 import { createCoverageCommand } from './commands/coverage.js';
+import { createNarrativeCommand } from './commands/narrative/index.js';
 // Version is injected at build time via package.json
 const VERSION = '0.1.28';
 const program = new Command();
@@ -25,12 +27,14 @@ program
 program.addCommand(createInitCommand());
 program.addCommand(createCreateCommand());
 program.addCommand(createValidateCommand());
+program.addCommand(createValidateExecutionCommand());
 program.addCommand(createLintCommand());
 program.addCommand(createListCommand());
 program.addCommand(createSchemaCommand());
 program.addCommand(createDoctorCommand());
 program.addCommand(createHooksCommand());
 program.addCommand(createCoverageCommand());
+program.addCommand(createNarrativeCommand());
 // Parse command line arguments
 program.parse(process.argv);
 // Show help if no command provided

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principal-ai/principal-view-cli",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "description": "Principal View CLI - Validate and manage .canvas configuration files",
   "main": "dist/index.cjs",
   "types": "dist/index.d.ts",
@@ -34,11 +34,12 @@
   "dependencies": {
     "chalk": "5.6.2",
     "commander": "14.0.2",
+    "glob": "^13.0.0",
     "globby": "16.0.0",
     "js-yaml": "4.1.1"
   },
   "devDependencies": {
-    "@principal-ai/principal-view-core": "^0.7.5",
+    "@principal-ai/principal-view-core": "0.7.12",
     "@types/js-yaml": "4.0.9",
     "@types/node": "22.10.1",
     "esbuild": "0.24.0",