@principal-ai/principal-view-cli 0.3.3 → 0.3.4

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate-execution.d.ts","sourceRoot":"","sources":["../../src/commands/validate-execution.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqJpC;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CAwGxD"}

package/dist/commands/validate-execution.js

@@ -0,0 +1,223 @@
+/**
+ * Validate execution files command
+ *
+ * Validates .otel.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 (.otel.json)')
+        .argument('[files...]', 'Files or glob patterns to validate (defaults to **/__executions__/**/*.otel.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 .otel.json files in __executions__ directories
+                patterns = [
+                    '**/__executions__/*.otel.json',
+                    '.principal-views/__executions__/*.otel.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

@@ -0,0 +1,6 @@
+/**
+ * Validate command - Validate .canvas configuration files
+ */
+import { Command } from 'commander';
+export declare function createValidateCommand(): Command;
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +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;AA0sCpC,wBAAgB,qBAAqB,IAAI,OAAO,CAiI/C"}