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

package/dist/commands/narrative/utils.d.ts

@@ -0,0 +1,69 @@
+import type { NarrativeTemplate, OtelEvent } from '@principal-ai/principal-view-core';
+export interface ExecutionData {
+    metadata?: {
+        status?: string;
+        testName?: string;
+        sessionId?: string;
+        startTime?: number;
+        endTime?: number;
+    };
+    spans: Array<{
+        id: string;
+        name: string;
+        startTime?: number;
+        endTime?: number;
+        duration?: number;
+        status?: 'OK' | 'ERROR';
+        attributes?: Record<string, unknown>;
+        events: Array<{
+            time: number;
+            name: string;
+            attributes: Record<string, unknown>;
+        }>;
+    }>;
+}
+/**
+ * Load a narrative template from a file
+ */
+export declare function loadNarrative(filePath: string): Promise<NarrativeTemplate>;
+/**
+ * Load execution data from a .otel.json file
+ */
+export declare function loadExecution(filePath: string): Promise<ExecutionData>;
+/**
+ * Convert execution data to OtelEvent array format expected by narrative APIs
+ */
+export declare function executionToEvents(execution: ExecutionData): OtelEvent[];
+/**
+ * Resolve a file path relative to a base directory
+ */
+export declare function resolvePath(filePath: string, baseDir?: string): string;
+/**
+ * Format a timestamp as human-readable date/time
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Format duration in milliseconds
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Group attributes by prefix (e.g., 'auth.method' -> 'auth')
+ */
+export declare function groupAttributesByPrefix(attributes: Record<string, unknown>): Record<string, Record<string, unknown>>;
+/**
+ * Filter attributes by pattern (supports glob-like patterns)
+ */
+export declare function filterAttributes(attributes: Record<string, unknown>, pattern: string): Record<string, unknown>;
+/**
+ * Count events by type/name
+ */
+export declare function countEventsByType(events: OtelEvent[]): Map<string, number>;
+/**
+ * Format attribute value for display
+ */
+export declare function formatValue(value: unknown): string;
+/**
+ * Capitalize first letter of a string
+ */
+export declare function capitalize(str: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/commands/narrative/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commands/narrative/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAEtF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,EAAE;QACT,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;IACF,KAAK,EAAE,KAAK,CAAC;QACX,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,IAAI,GAAG,OAAO,CAAC;QACxB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACrC,MAAM,EAAE,KAAK,CAAC;YACZ,IAAI,EAAE,MAAM,CAAC;YACb,IAAI,EAAE,MAAM,CAAC;YACb,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;SACrC,CAAC,CAAC;KACJ,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAUhF;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAU5E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,aAAa,GAAG,SAAS,EAAE,CAmBvE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAKtE;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAWzD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMjD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAoBzC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,OAAO,EAAE,MAAM,GACd,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAazB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAS1E;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAclD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE9C"}

package/dist/commands/narrative/utils.js

@@ -0,0 +1,158 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+/**
+ * Load a narrative template from a file
+ */
+export async function loadNarrative(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Narrative file not found: ${filePath}`);
+        }
+        throw new Error(`Failed to parse narrative file: ${error.message}`);
+    }
+}
+/**
+ * Load execution data from a .otel.json file
+ */
+export async function loadExecution(filePath) {
+    try {
+        const content = await readFile(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`Execution file not found: ${filePath}`);
+        }
+        throw new Error(`Failed to parse execution file: ${error.message}`);
+    }
+}
+/**
+ * Convert execution data to OtelEvent array format expected by narrative APIs
+ */
+export function executionToEvents(execution) {
+    const events = [];
+    for (const span of execution.spans) {
+        for (const event of span.events) {
+            events.push({
+                name: event.name,
+                timestamp: event.time,
+                type: 'log',
+                attributes: {
+                    ...event.attributes,
+                    'span.id': span.id,
+                    'span.name': span.name,
+                },
+            });
+        }
+    }
+    return events;
+}
+/**
+ * Resolve a file path relative to a base directory
+ */
+export function resolvePath(filePath, baseDir) {
+    if (baseDir) {
+        return resolve(baseDir, filePath);
+    }
+    return resolve(filePath);
+}
+/**
+ * Format a timestamp as human-readable date/time
+ */
+export function formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+        hour12: false,
+    });
+}
+/**
+ * Format duration in milliseconds
+ */
+export function formatDuration(ms) {
+    if (ms < 1000) {
+        return `${ms}ms`;
+    }
+    const seconds = (ms / 1000).toFixed(1);
+    return `${seconds}s`;
+}
+/**
+ * Group attributes by prefix (e.g., 'auth.method' -> 'auth')
+ */
+export function groupAttributesByPrefix(attributes) {
+    const grouped = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        const parts = key.split('.');
+        if (parts.length > 1) {
+            const prefix = parts[0];
+            if (!grouped[prefix]) {
+                grouped[prefix] = {};
+            }
+            grouped[prefix][key] = value;
+        }
+        else {
+            if (!grouped['Other']) {
+                grouped['Other'] = {};
+            }
+            grouped['Other'][key] = value;
+        }
+    }
+    return grouped;
+}
+/**
+ * Filter attributes by pattern (supports glob-like patterns)
+ */
+export function filterAttributes(attributes, pattern) {
+    const regex = new RegExp('^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*') + '$');
+    const filtered = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (regex.test(key)) {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
+/**
+ * Count events by type/name
+ */
+export function countEventsByType(events) {
+    const counts = new Map();
+    for (const event of events) {
+        const count = counts.get(event.name) || 0;
+        counts.set(event.name, count + 1);
+    }
+    return counts;
+}
+/**
+ * Format attribute value for display
+ */
+export function formatValue(value) {
+    if (typeof value === 'string') {
+        return `"${value}"`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+        return String(value);
+    }
+    if (value === null || value === undefined) {
+        return 'null';
+    }
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    return String(value);
+}
+/**
+ * Capitalize first letter of a string
+ */
+export function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

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

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function createValidateCommand(): Command;
+//# sourceMappingURL=validate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/commands/narrative/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,qBAAqB,IAAI,OAAO,CA6J/C"}

package/dist/commands/narrative/validate.js

@@ -0,0 +1,135 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { resolve, dirname } from 'node:path';
+import { NarrativeValidator } from '@principal-ai/principal-view-core';
+import { loadNarrative, resolvePath } from './utils.js';
+export function createValidateCommand() {
+    const command = new Command('validate');
+    command
+        .description('Validate narrative template syntax, schema, and references')
+        .argument('<file>', 'Path to .narrative.json file')
+        .option('--canvas <path>', 'Override canvas file path for validation')
+        .option('--json', 'Output violations as JSON')
+        .option('-q, --quiet', 'Only show errors, suppress warnings')
+        .option('-d, --dir <path>', 'Project directory (default: cwd)')
+        .action(async (file, options) => {
+        try {
+            const baseDir = options.dir || process.cwd();
+            const narrativePath = resolvePath(file, baseDir);
+            // Load narrative
+            const narrative = await loadNarrative(narrativePath);
+            // Resolve canvas path
+            let canvasPath;
+            if (options.canvas) {
+                canvasPath = resolvePath(options.canvas, baseDir);
+            }
+            else if (narrative.canvas) {
+                const narrativeDir = dirname(narrativePath);
+                canvasPath = resolve(narrativeDir, narrative.canvas);
+            }
+            // Create validator
+            const validator = new NarrativeValidator();
+            // Validate
+            const context = {
+                narrative,
+                narrativePath,
+                canvasPath,
+                basePath: baseDir,
+            };
+            const result = await validator.validate(context);
+            // Filter violations if quiet mode
+            const violations = options.quiet
+                ? result.violations.filter((v) => v.severity === 'error')
+                : result.violations;
+            const errors = violations.filter((v) => v.severity === 'error');
+            const warnings = violations.filter((v) => v.severity === 'warn');
+            // Output
+            if (options.json) {
+                const output = {
+                    file: file,
+                    valid: errors.length === 0,
+                    violations: violations.map((v) => ({
+                        severity: v.severity,
+                        ruleId: v.ruleId,
+                        file: v.file,
+                        path: v.path,
+                        message: v.message,
+                        impact: v.impact,
+                        suggestion: v.suggestion,
+                        fixable: v.fixable,
+                    })),
+                    summary: {
+                        errors: errors.length,
+                        warnings: warnings.length,
+                        scenarioCount: narrative.scenarios.length,
+                        hasDefault: narrative.scenarios.some((s) => s.condition.default),
+                    },
+                };
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                // Text output
+                console.log(chalk.bold(`\nValidating: ${file}\n`));
+                if (errors.length === 0 && warnings.length === 0) {
+                    console.log(chalk.green('✓'), 'Schema validation passed');
+                    console.log(chalk.green('✓'), `${narrative.scenarios.length} scenarios found`);
+                    const hasDefault = narrative.scenarios.some((s) => s.condition.default);
+                    console.log(chalk.green('✓'), hasDefault ? 'Default scenario present' : 'No default scenario');
+                    const priorities = narrative.scenarios.map((s) => s.priority);
+                    const allUnique = new Set(priorities).size === priorities.length;
+                    console.log(chalk.green('✓'), allUnique ? 'All priorities unique' : 'Duplicate priorities found');
+                    if (canvasPath) {
+                        console.log(chalk.green('✓'), `Canvas: ${narrative.canvas || canvasPath} ✓`);
+                    }
+                }
+                else {
+                    // Show violations
+                    for (const violation of violations) {
+                        const icon = violation.severity === 'error' ? chalk.red('✗') : chalk.yellow('⚠');
+                        const severity = violation.severity === 'error'
+                            ? chalk.red('Error')
+                            : chalk.yellow('Warning');
+                        console.log(`\n${icon} ${severity}: ${violation.message}`);
+                        if (violation.path) {
+                            console.log(chalk.gray(`  Location: ${violation.path}`));
+                        }
+                        if (violation.impact) {
+                            console.log(chalk.gray(`  Impact: ${violation.impact}`));
+                        }
+                        if (violation.suggestion) {
+                            console.log(chalk.cyan(`  Suggestion: ${violation.suggestion}`));
+                        }
+                    }
+                }
+                // Summary
+                console.log(chalk.bold('\nSummary:'));
+                if (errors.length > 0) {
+                    console.log(chalk.red(`  • ${errors.length} error(s)`));
+                }
+                else {
+                    console.log(chalk.green('  • 0 errors'));
+                }
+                if (warnings.length > 0) {
+                    console.log(chalk.yellow(`  • ${warnings.length} warning(s)`));
+                }
+                else if (!options.quiet) {
+                    console.log(chalk.green('  • 0 warnings'));
+                }
+                console.log(chalk.gray(`  • ${narrative.scenarios.length} scenario(s)`));
+                if (canvasPath) {
+                    console.log(chalk.gray(`  • Canvas: ${narrative.canvas || canvasPath}`));
+                }
+                console.log();
+            }
+            // Exit with error code if validation failed
+            if (errors.length > 0) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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';
+/**
+ * Create the validate-execution command
+ */
+export declare function createValidateExecutionCommand(): Command;
+//# sourceMappingURL=validate-execution.d.ts.map

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;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqJpC;;GAEG;AACH,wBAAgB,8BAA8B,IAAI,OAAO,CA8GxD"}

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