@principal-ai/principal-studio-cli 0.35.3

package/dist/commands/workflow/implementation.d.ts

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

package/dist/commands/workflow/implementation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/implementation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,wBAAgB,2BAA2B,IAAI,OAAO,CAyDrD"}

package/dist/commands/workflow/implementation.js

@@ -0,0 +1,51 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+export function createImplementationCommand() {
+    const command = new Command('implementation');
+    command
+        .description('Guide for implementing telemetry from workflow definitions')
+        .action(() => {
+        console.log(chalk.bold('\nWorkflow Implementation Guide'));
+        console.log(chalk.bold('=============================\n'));
+        console.log('A workflow.json defines how to instrument a single operation (span) in your code.\n');
+        console.log(chalk.cyan.bold('SPAN (Workflow Level)'));
+        console.log('  The workflow itself represents one span - the traced operation.');
+        console.log('  - workflow.name      → span name');
+        console.log('  - workflow.canvas    → the architectural context\n');
+        console.log(chalk.cyan.bold('EVENTS (Scenario Level)'));
+        console.log('  Each scenario represents an event that can occur during the span.');
+        console.log('  - scenario.name              → event name');
+        console.log('  - scenario.template.events   → attributes to capture\n');
+        console.log(chalk.dim('Example mapping:'));
+        console.log(chalk.dim('  workflow: "user-checkout"     →  span: "user-checkout"'));
+        console.log(chalk.dim('  scenario: "payment-processed" →  event on that span'));
+        console.log(chalk.dim('  scenario: "payment-failed"    →  event on that span\n'));
+        console.log(chalk.yellow.bold('In your code:'));
+        console.log('  1. Start the span when the operation begins');
+        console.log('  2. Add events as scenarios occur');
+        console.log('  3. End the span when the operation completes\n');
+        console.log(chalk.green.bold('Example (OpenTelemetry JS):'));
+        console.log(chalk.dim(`
+  const span = tracer.startSpan('user-checkout');
+
+  // When payment succeeds:
+  span.addEvent('payment-processed', {
+    'payment.amount': amount,
+    'payment.method': method,
+  });
+
+  // When payment fails:
+  span.addEvent('payment-failed', {
+    'error.message': error.message,
+  });
+
+  span.end();
+`));
+        console.log(chalk.bold('Key Concepts:'));
+        console.log('  - One workflow = one span (the operation being traced)');
+        console.log('  - Multiple scenarios = multiple possible events on that span');
+        console.log('  - Event attributes come from scenario.template.events');
+        console.log('  - Node pv.status tracks implementation progress (draft → approved → implemented)\n');
+    });
+    return command;
+}

package/dist/commands/workflow/index.d.ts

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

package/dist/commands/workflow/index.d.ts.map

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

package/dist/commands/workflow/index.js

@@ -0,0 +1,19 @@
+import { Command } from 'commander';
+import { createValidateCommand } from './validate.js';
+import { createInspectCommand } from './inspect.js';
+import { createRenderCommand } from './render.js';
+import { createTestCommand } from './test.js';
+import { createListCommand } from './list.js';
+import { createImplementationCommand } from './implementation.js';
+export function createWorkflowCommand() {
+    const command = new Command('workflow');
+    command
+        .description('Validate, test, and debug workflow templates')
+        .addCommand(createValidateCommand())
+        .addCommand(createInspectCommand())
+        .addCommand(createRenderCommand())
+        .addCommand(createTestCommand())
+        .addCommand(createListCommand())
+        .addCommand(createImplementationCommand());
+    return command;
+}

package/dist/commands/workflow/inspect.d.ts

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

package/dist/commands/workflow/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuBpC,wBAAgB,oBAAoB,IAAI,OAAO,CAiJ9C"}

package/dist/commands/workflow/inspect.js

@@ -0,0 +1,123 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { computeAggregates } from '@principal-ai/subsystems-core';
+import { loadExecution, executionToEvents, resolvePath, formatTimestamp, formatDuration, groupAttributesByPrefix, filterAttributes, countEventsByType, formatValue, capitalize, } from './utils.js';
+export function createInspectCommand() {
+    const command = new Command('inspect');
+    command
+        .description('Inspect execution file and show available attributes for templates')
+        .argument('<execution>', 'Path to .otel.json execution file')
+        .option('--events', 'Show all events')
+        .option('--aggregates', 'Show computed aggregates (default)', true)
+        .option('--json', 'Output as JSON')
+        .option('--filter <pattern>', 'Filter attributes by pattern (e.g., auth.*)')
+        .action(async (execution, options) => {
+        try {
+            const executionPath = resolvePath(execution);
+            // Load execution
+            const executionData = await loadExecution(executionPath);
+            const events = executionToEvents(executionData);
+            // Compute aggregates
+            const aggregates = computeAggregates(events);
+            // Apply filter if provided
+            const filteredAggregates = options.filter
+                ? filterAttributes(aggregates, options.filter)
+                : aggregates;
+            // Count events by type
+            const eventCounts = countEventsByType(events);
+            // Calculate time range
+            const timestamps = events.map((e) => typeof e.timestamp === 'string' ? parseInt(e.timestamp, 10) : e.timestamp);
+            const minTime = Math.min(...timestamps);
+            const maxTime = Math.max(...timestamps);
+            const duration = maxTime - minTime;
+            if (options.json) {
+                const output = {
+                    file: execution,
+                    summary: {
+                        eventCount: events.length,
+                        spanCount: executionData.spans.length,
+                        timeRange: {
+                            start: minTime,
+                            end: maxTime,
+                            duration: duration,
+                        },
+                        status: executionData.metadata?.status || 'UNKNOWN',
+                        scope: executionData.metadata?.scopeName || null,
+                        scopeVersion: executionData.metadata?.scopeVersion || null,
+                        serviceName: executionData.metadata?.serviceName || null,
+                    },
+                    eventTypes: Array.from(eventCounts.entries()).map(([name, count]) => ({
+                        name,
+                        count,
+                    })),
+                    attributes: filteredAggregates,
+                };
+                if (options.events) {
+                    output.events = events.map((e) => ({
+                        name: e.name,
+                        timestamp: e.timestamp,
+                        attributes: e.attributes,
+                    }));
+                }
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                // Text output
+                console.log(chalk.bold(`\nInspecting: ${execution}\n`));
+                // Execution Summary
+                console.log(chalk.bold('Execution Summary:'));
+                console.log('━'.repeat(60));
+                console.log(chalk.gray('  • Total Events:'), events.length);
+                console.log(chalk.gray('  • Total Spans:'), executionData.spans.length);
+                console.log(chalk.gray('  • Time Range:'), `${formatTimestamp(minTime)} → ${formatTimestamp(maxTime)} (${formatDuration(duration)})`);
+                const status = executionData.metadata?.status || 'UNKNOWN';
+                const statusColor = status === 'OK' ? chalk.green : chalk.red;
+                console.log(chalk.gray('  • Status:'), statusColor(status));
+                // Show scope information
+                const scopeName = executionData.metadata?.scopeName;
+                const scopeVersion = executionData.metadata?.scopeVersion;
+                const serviceName = executionData.metadata?.serviceName;
+                if (serviceName) {
+                    console.log(chalk.gray('  • Service:'), serviceName);
+                }
+                if (scopeName) {
+                    const scopeDisplay = scopeVersion ? `${scopeName}@${scopeVersion}` : scopeName;
+                    console.log(chalk.gray('  • Scope:'), scopeDisplay);
+                }
+                // Event Types
+                console.log(chalk.bold('\nEvent Types:'));
+                console.log('━'.repeat(60));
+                for (const [name, count] of eventCounts) {
+                    console.log(chalk.gray('  •'), `${name} (${count})`);
+                }
+                // Available Attributes
+                console.log(chalk.bold('\nAvailable Attributes (for templates):'));
+                console.log('━'.repeat(60));
+                const grouped = groupAttributesByPrefix(filteredAggregates);
+                for (const [prefix, attrs] of Object.entries(grouped)) {
+                    console.log(chalk.bold(`\n${capitalize(prefix)}:`));
+                    for (const [key, value] of Object.entries(attrs)) {
+                        console.log(chalk.gray('  •'), `${key}: ${formatValue(value)}`);
+                    }
+                }
+                // Show events if requested
+                if (options.events) {
+                    console.log(chalk.bold('\nEvents:'));
+                    console.log('━'.repeat(60));
+                    for (const event of events) {
+                        console.log(chalk.cyan(`\n[${formatTimestamp(typeof event.timestamp === 'string' ? parseInt(event.timestamp, 10) : event.timestamp)}]`), chalk.bold(event.name));
+                        for (const [key, value] of Object.entries(event.attributes || {})) {
+                            console.log(chalk.gray('  •'), `${key}: ${formatValue(value)}`);
+                        }
+                    }
+                }
+                console.log();
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/commands/workflow/list.d.ts

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

package/dist/commands/workflow/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,iBAAiB,IAAI,OAAO,CAsG3C"}

package/dist/commands/workflow/list.js

@@ -0,0 +1,95 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { access } from 'node:fs/promises';
+import { resolve, dirname, join } from 'node:path';
+import { globby } from 'globby';
+import { loadWorkflow } from './utils.js';
+export function createListCommand() {
+    const command = new Command('list');
+    command
+        .description('List all workflow files in project')
+        .argument('[dir]', 'Directory to search (default: .principal-views/)')
+        .option('--json', 'Output as JSON')
+        .option('--show-canvas', 'Show linked canvas files')
+        .action(async (dir, options) => {
+        try {
+            const searchDir = dir || '.principal-views';
+            const searchPath = resolve(process.cwd(), searchDir);
+            // Find all .workflow.json files
+            const files = await globby('**/*.workflow.json', {
+                cwd: searchPath,
+                ignore: ['node_modules/**', '.git/**', '__executions__/**'],
+            });
+            // Load each workflow and check canvas existence
+            const workflows = await Promise.all(files.map(async (file) => {
+                const fullPath = join(searchPath, file);
+                const workflow = await loadWorkflow(fullPath);
+                let canvasExists;
+                if (options.showCanvas && workflow.canvas) {
+                    const workflowDir = dirname(fullPath);
+                    const canvasPath = resolve(workflowDir, workflow.canvas);
+                    try {
+                        await access(canvasPath);
+                        canvasExists = true;
+                    }
+                    catch {
+                        canvasExists = false;
+                    }
+                }
+                return {
+                    file: join(searchDir, file),
+                    canvas: workflow.canvas,
+                    canvasExists,
+                    scenarioCount: workflow.scenarios.length,
+                    name: workflow.name,
+                };
+            }));
+            if (options.json) {
+                const output = {
+                    searchDir,
+                    count: workflows.length,
+                    workflows: workflows.map((n) => ({
+                        file: n.file,
+                        name: n.name,
+                        canvas: n.canvas,
+                        canvasExists: n.canvasExists,
+                        scenarios: n.scenarioCount,
+                    })),
+                };
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                console.log(chalk.bold('\nWorkflow Templates:'));
+                console.log('━'.repeat(60));
+                if (workflows.length === 0) {
+                    console.log(chalk.yellow(`\nNo workflow templates found in ${searchDir}`));
+                    console.log();
+                    return;
+                }
+                for (const workflow of workflows) {
+                    console.log(chalk.bold(`\n${workflow.file}`));
+                    if (workflow.name) {
+                        console.log(chalk.gray(`  Name: ${workflow.name}`));
+                    }
+                    if (options.showCanvas && workflow.canvas) {
+                        const status = workflow.canvasExists
+                            ? chalk.green('✓')
+                            : chalk.red('✗');
+                        console.log(chalk.gray(`  Canvas: ${workflow.canvas} ${status}`));
+                    }
+                    else if (workflow.canvas) {
+                        console.log(chalk.gray(`  Canvas: ${workflow.canvas}`));
+                    }
+                    console.log(chalk.gray(`  Scenarios: ${workflow.scenarioCount}`));
+                }
+                console.log(chalk.bold(`\nFound ${workflows.length} workflow template(s)`));
+                console.log();
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/commands/workflow/render.d.ts

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

package/dist/commands/workflow/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,mBAAmB,IAAI,OAAO,CAqG7C"}

package/dist/commands/workflow/render.js

@@ -0,0 +1,88 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { renderWorkflow } from '@principal-ai/subsystems-core';
+import { loadWorkflow, loadExecution, executionToEvents, resolvePath, } from './utils.js';
+export function createRenderCommand() {
+    const command = new Command('render');
+    command
+        .description('Render workflow template using execution data')
+        .argument('<workflow>', 'Path to .workflow.json file')
+        .argument('<execution>', 'Path to .otel.json execution file')
+        .option('--scenario <id>', 'Force specific scenario (skip auto-selection)')
+        .option('--json', 'Output structured result as JSON')
+        .option('--format <format>', 'Output format: text (default), markdown, json', 'text')
+        .option('--show-metadata', 'Include rendering metadata in output')
+        .action(async (workflowPath, executionPath, options) => {
+        try {
+            const workflow = await loadWorkflow(resolvePath(workflowPath));
+            const executionData = await loadExecution(resolvePath(executionPath));
+            const events = executionToEvents(executionData);
+            // Render workflow
+            const result = renderWorkflow(workflow, events);
+            // Get the selected scenario from the result
+            const selectedScenario = workflow.scenarios.find((s) => s.id === result.scenarioId);
+            // Force scenario if specified
+            if (options.scenario) {
+                const scenario = workflow.scenarios.find((s) => s.id === options.scenario);
+                if (!scenario) {
+                    throw new Error(`Scenario not found: ${options.scenario}`);
+                }
+                // Note: This would require a way to force scenario in renderWorkflow API
+                // For now, we'll just validate the scenario exists
+            }
+            if (options.json) {
+                const output = {
+                    workflow: workflowPath,
+                    execution: executionPath,
+                    scenario: {
+                        id: selectedScenario?.id,
+                        priority: selectedScenario?.priority,
+                        matched: true,
+                    },
+                    text: result.text,
+                };
+                if (options.showMetadata) {
+                    output.metadata = result.metadata;
+                }
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                // Text output
+                if (!options.format || options.format === 'text') {
+                    console.log(chalk.gray(`Rendering: ${workflowPath}`));
+                    console.log(chalk.gray(`Execution: ${executionPath}`));
+                    if (selectedScenario) {
+                        console.log(chalk.gray(`Scenario: ${selectedScenario.id} (priority: ${selectedScenario.priority})`));
+                    }
+                    console.log();
+                    console.log('━'.repeat(60));
+                    console.log();
+                    console.log(result.text);
+                    console.log();
+                    console.log('━'.repeat(60));
+                    if (options.showMetadata && result.metadata) {
+                        console.log();
+                        console.log(chalk.bold('Metadata:'));
+                        console.log(chalk.gray('  • Event Count:'), result.metadata.eventCount);
+                        console.log(chalk.gray('  • Span Count:'), result.metadata.spanCount);
+                        if (result.metadata.timeRange) {
+                            console.log(chalk.gray('  • Time Range:'), `${result.metadata.timeRange.start} → ${result.metadata.timeRange.end}`);
+                        }
+                    }
+                    console.log();
+                }
+                else if (options.format === 'markdown') {
+                    console.log(result.text);
+                }
+                else if (options.format === 'json') {
+                    console.log(JSON.stringify({ text: result.text }, null, 2));
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

package/dist/commands/workflow/test.d.ts

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

package/dist/commands/workflow/test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,iBAAiB,IAAI,OAAO,CA+K3C"}

package/dist/commands/workflow/test.js

@@ -0,0 +1,141 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { selectScenario, computeAggregates } from '@principal-ai/subsystems-core';
+import { loadWorkflow, loadExecution, executionToEvents, resolvePath, formatValue, } from './utils.js';
+export function createTestCommand() {
+    const command = new Command('test');
+    command
+        .description('Test scenario matching and show why scenarios match or don\'t match')
+        .argument('<workflow>', 'Path to .workflow.json file')
+        .argument('<execution>', 'Path to .otel.json execution file')
+        .option('--show-all', 'Show all scenarios (not just matches)')
+        .option('--show-aggregates', 'Display computed aggregates')
+        .option('--json', 'Output as JSON')
+        .action(async (workflowPath, executionPath, options) => {
+        try {
+            const workflow = await loadWorkflow(resolvePath(workflowPath));
+            const executionData = await loadExecution(resolvePath(executionPath));
+            const events = executionToEvents(executionData);
+            // Compute aggregates
+            const aggregates = computeAggregates(events);
+            // Select the winning scenario using enhanced matching
+            const matchResult = selectScenario(workflow, events);
+            if (options.json) {
+                const output = {
+                    workflow: workflowPath,
+                    execution: executionPath,
+                    fullMatches: matchResult.fullMatches.map((m) => ({
+                        id: m.scenario.id,
+                        priority: m.scenario.priority,
+                        matchPercentage: m.matchPercentage,
+                        matchedEventCount: m.matchedEventCount,
+                        totalRequiredEvents: m.totalRequiredEvents,
+                        matchedEventNames: m.matchedEventNames,
+                        missingEventNames: m.missingEventNames,
+                    })),
+                    partialMatches: matchResult.partialMatches.map((m) => ({
+                        id: m.scenario.id,
+                        priority: m.scenario.priority,
+                        matchPercentage: m.matchPercentage,
+                        matchedEventCount: m.matchedEventCount,
+                        totalRequiredEvents: m.totalRequiredEvents,
+                        matchedEventNames: m.matchedEventNames,
+                        missingEventNames: m.missingEventNames,
+                    })),
+                    recommendedScenario: matchResult.recommendedScenario
+                        ? {
+                            id: matchResult.recommendedScenario.scenario.id,
+                            priority: matchResult.recommendedScenario.scenario.priority,
+                            matchPercentage: matchResult.recommendedScenario.matchPercentage,
+                            isFullMatch: matchResult.recommendedScenario.isFullMatch,
+                        }
+                        : null,
+                    totalTraceEvents: matchResult.totalTraceEvents,
+                    totalScenariosEvaluated: matchResult.totalScenariosEvaluated,
+                    aggregates: options.showAggregates ? aggregates : undefined,
+                };
+                console.log(JSON.stringify(output, null, 2));
+            }
+            else {
+                // Text output
+                console.log(chalk.bold(`\nTesting: ${workflowPath}`));
+                console.log(chalk.gray(`Execution: ${executionPath}`));
+                console.log(chalk.gray(`Total Events: ${matchResult.totalTraceEvents}, Scenarios Evaluated: ${matchResult.totalScenariosEvaluated}\n`));
+                console.log(chalk.bold('Scenario Matching Results:'));
+                console.log('━'.repeat(60));
+                // Show full matches
+                if (matchResult.fullMatches.length > 0) {
+                    console.log(chalk.green.bold('\n✓ FULL MATCHES (100% coverage):'));
+                    for (const match of matchResult.fullMatches) {
+                        console.log(`\n  ${chalk.bold(match.scenario.id)} ${chalk.gray(`(priority: ${match.scenario.priority})`)}`);
+                        console.log(`  • Matched: ${match.matchedEventCount}/${match.totalRequiredEvents} events`);
+                        for (const eventName of match.matchedEventNames) {
+                            console.log(`    ${chalk.green('✓')} ${eventName}`);
+                        }
+                    }
+                }
+                else if (matchResult.partialMatches.length > 0) {
+                    console.log(chalk.yellow.bold('\n⚠ PARTIAL MATCHES:'));
+                    // Show top 5 partial matches
+                    const displayCount = options.showAll
+                        ? matchResult.partialMatches.length
+                        : Math.min(5, matchResult.partialMatches.length);
+                    for (const match of matchResult.partialMatches.slice(0, displayCount)) {
+                        const percentColor = match.matchPercentage >= 75
+                            ? chalk.yellow
+                            : match.matchPercentage >= 50
+                                ? chalk.yellowBright
+                                : chalk.gray;
+                        console.log(`\n  ${chalk.bold(match.scenario.id)} ${percentColor(`(${match.matchPercentage.toFixed(1)}%)`)} ${chalk.gray(`priority: ${match.scenario.priority}`)}`);
+                        console.log(`  • Matched: ${match.matchedEventCount}/${match.totalRequiredEvents}`);
+                        if (match.matchedEventNames.length > 0) {
+                            console.log(chalk.gray('    Matched:'));
+                            for (const eventName of match.matchedEventNames) {
+                                console.log(`      ${chalk.green('✓')} ${eventName}`);
+                            }
+                        }
+                        if (match.missingEventNames.length > 0) {
+                            console.log(chalk.gray('    Missing:'));
+                            for (const eventName of match.missingEventNames) {
+                                console.log(`      ${chalk.red('✗')} ${eventName}`);
+                            }
+                        }
+                    }
+                    if (!options.showAll &&
+                        matchResult.partialMatches.length > displayCount) {
+                        console.log(chalk.gray(`\n  ... and ${matchResult.partialMatches.length - displayCount} more partial matches (use --show-all to see all)`));
+                    }
+                }
+                else {
+                    console.log(chalk.red('\n✗ No scenarios matched'));
+                }
+                console.log('\n' + '━'.repeat(60));
+                if (matchResult.recommendedScenario) {
+                    const isFullMatch = matchResult.recommendedScenario.isFullMatch;
+                    const matchType = isFullMatch ? 'Full Match' : 'Partial Match';
+                    const percentage = matchResult.recommendedScenario.matchPercentage.toFixed(1);
+                    console.log(chalk.bold('\nRecommended Scenario:'), chalk.cyan(`${matchResult.recommendedScenario.scenario.id} (${matchType}, ${percentage}%)`));
+                }
+                else {
+                    console.log(chalk.yellow('\nNo scenario selected'));
+                }
+                if (options.showAggregates) {
+                    console.log(chalk.bold('\nComputed Aggregates:'));
+                    for (const [key, value] of Object.entries(aggregates)) {
+                        console.log(chalk.gray('  •'), `${key}: ${formatValue(value)}`);
+                    }
+                }
+                console.log();
+            }
+            // Exit with error if no scenario matched
+            if (!matchResult.recommendedScenario) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red('Error:'), error.message);
+            process.exit(1);
+        }
+    });
+    return command;
+}

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

@@ -0,0 +1,49 @@
+import type { WorkflowTemplate, OtelEvent } from '@principal-ai/subsystems-core';
+import { type ExecutionData } from '@principal-ai/subsystems-core';
+/**
+ * Load a workflow template from a file
+ */
+export declare function loadWorkflow(filePath: string): Promise<WorkflowTemplate>;
+/**
+ * Load execution data from a .otel.json file
+ *
+ * Automatically handles OTLP standard format conversion via ExecutionValidator.
+ */
+export declare function loadExecution(filePath: string): Promise<ExecutionData>;
+/**
+ * Convert execution data to OtelEvent array format expected by workflow 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/workflow/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAEvF;;GAEG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAU9E;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAc5E;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"}