@baselineos/studio 0.1.0

package/src/system.ts

@@ -0,0 +1,885 @@
+/**
+ * Baseline Studio System
+ *
+ * The execution and output generation layer of the Baseline Protocol that
+ * orchestrates command execution, manages workflows, and generates
+ * structured output in multiple formats.
+ *
+ * @license Apache-2.0
+ */
+
+import studioSystemConfig from './config/studio-system-config.json' with { type: 'json' };
+import { createHash } from 'crypto';
+
+// ─── Types ──────────────────────────────────────────────────────────
+
+export interface StudioSystemConfig {
+  system: { name: string; version: string; description: string };
+  execution: ExecutionConfig;
+  output: OutputConfig;
+  workflows: WorkflowConfig;
+  performance: PerformanceConfig;
+}
+
+export interface ExecutionConfig {
+  maxConcurrent: number;
+  timeout: number;
+  retryAttempts: number;
+  retryDelay: number;
+}
+
+export interface OutputConfig {
+  formats: string[];
+  defaultFormat: string;
+  prettyPrint: boolean;
+  includeMetadata: boolean;
+}
+
+export interface WorkflowConfig {
+  maxSteps: number;
+  maxDepth: number;
+  enableRollback: boolean;
+  enableCheckpoints: boolean;
+}
+
+export interface PerformanceConfig {
+  enableCaching: boolean;
+  cacheSize: number;
+  cacheTTL: number;
+  enableProfiling: boolean;
+}
+
+export interface StudioCommandResult {
+  success: boolean;
+  command?: string;
+  result?: unknown;
+  output?: string;
+  artifacts?: ArtifactEntry[];
+  manifest?: ArtifactManifest;
+  performance?: unknown;
+  error?: string;
+  details?: string | string[];
+  timestamp?: string;
+}
+
+export interface WorkflowDefinition {
+  name: string;
+  steps: string[];
+}
+
+export interface WorkflowResult {
+  success: boolean;
+  workflow?: string;
+  result?: unknown;
+  steps?: unknown[];
+  artifacts?: ArtifactEntry[];
+  manifest?: ArtifactManifest;
+  performance?: unknown;
+  error?: string;
+  details?: string;
+  timestamp?: string;
+}
+
+export interface ExecutionStats {
+  totalExecuted: number;
+  successful: number;
+  failed: number;
+  averageExecutionTime: number;
+}
+
+export interface CacheEntry {
+  result: unknown;
+  timestamp: number;
+  ttl: number;
+}
+
+export interface TemplateDefinition {
+  id: string;
+  name: string;
+  format: 'text' | 'html' | 'json';
+  template: string;
+  variables?: string[];
+}
+
+export interface ArtifactProvenance {
+  command?: string;
+  workflow?: string;
+  step?: string;
+  context?: Record<string, unknown>;
+  templateId?: string;
+  generatedAt: string;
+}
+
+export interface ArtifactEntry {
+  id: string;
+  type: 'output' | 'manifest' | 'template' | 'artifact';
+  format: string;
+  content: string;
+  hash: string;
+  provenance: ArtifactProvenance;
+}
+
+export interface ArtifactManifest {
+  id: string;
+  createdAt: string;
+  artifacts: ArtifactEntry[];
+  hash: string;
+}
+
+// ─── Execution Engine ───────────────────────────────────────────────
+
+export class ExecutionEngine {
+  private activeCommands = new Map<string, { command: string; startTime: number; status: string }>();
+  private config: ExecutionConfig = { maxConcurrent: 5, timeout: 30000, retryAttempts: 3, retryDelay: 1000 };
+  private stats: ExecutionStats = {
+    totalExecuted: 0,
+    successful: 0,
+    failed: 0,
+    averageExecutionTime: 0,
+  };
+
+  initialize(config: ExecutionConfig): void {
+    this.config = config;
+  }
+
+  async execute(
+    command: string,
+    options: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): Promise<{ success: boolean; commandId: string; result: unknown; performance: unknown; timestamp: string }> {
+    const commandId = `cmd-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+
+    this.activeCommands.set(commandId, { command, startTime: Date.now(), status: 'executing' });
+
+    try {
+      const result = await this.simulateExecution(command, options, context);
+
+      const entry = this.activeCommands.get(commandId);
+      if (entry) entry.status = 'completed';
+
+      this.stats.totalExecuted++;
+      this.stats.successful++;
+
+      return {
+        success: true,
+        commandId,
+        result,
+        performance: this.calculatePerformance(commandId),
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const entry = this.activeCommands.get(commandId);
+      if (entry) entry.status = 'failed';
+
+      this.stats.totalExecuted++;
+      this.stats.failed++;
+      throw error;
+    } finally {
+      this.activeCommands.delete(commandId);
+    }
+  }
+
+  private async simulateExecution(
+    command: string,
+    options: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): Promise<Record<string, unknown>> {
+    return {
+      command,
+      result: `Executed: ${command}`,
+      options,
+      context,
+      executionTime: 0,
+      success: true,
+      timestamp: new Date().toISOString(),
+    };
+  }
+
+  private calculatePerformance(commandId: string): Record<string, unknown> | null {
+    const cmd = this.activeCommands.get(commandId);
+    if (!cmd) return null;
+
+    return {
+      executionTime: Date.now() - cmd.startTime,
+    };
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      status: 'operational',
+      activeCommands: this.activeCommands.size,
+      maxConcurrent: this.config.maxConcurrent,
+      timeout: this.config.timeout,
+      retryAttempts: this.config.retryAttempts,
+      stats: this.stats,
+    };
+  }
+}
+
+// ─── Output Generator ───────────────────────────────────────────────
+
+export class OutputGenerator {
+  private formatters = new Map<string, (result: Record<string, unknown>) => string>();
+  private config: OutputConfig = {
+    formats: ['json', 'yaml', 'text', 'table', 'csv'],
+    defaultFormat: 'text',
+    prettyPrint: true,
+    includeMetadata: true,
+  };
+
+  initialize(config: OutputConfig): void {
+    this.config = config;
+    this.setupFormatters();
+  }
+
+  private setupFormatters(): void {
+    this.formatters.set('json', this.formatJSON.bind(this));
+    this.formatters.set('yaml', this.formatYAML.bind(this));
+    this.formatters.set('text', this.formatText.bind(this));
+    this.formatters.set('table', this.formatTable.bind(this));
+    this.formatters.set('csv', this.formatCSV.bind(this));
+    this.formatters.set('html', this.formatHTML.bind(this));
+  }
+
+  generate(result: Record<string, unknown>, format?: string | null): string {
+    const outputFormat = format || this.config.defaultFormat;
+    const formatter = this.formatters.get(outputFormat);
+
+    if (!formatter) {
+      throw new Error(`Unsupported output format: ${outputFormat}`);
+    }
+
+    return formatter(result);
+  }
+
+  private formatJSON(result: Record<string, unknown>): string {
+    const output: Record<string, unknown> = {
+      success: result.success,
+      command: result.command,
+      result: result.result,
+      timestamp: result.timestamp,
+    };
+
+    if (this.config.includeMetadata) {
+      output.metadata = {
+        format: 'json',
+        generated: new Date().toISOString(),
+        version: '1.0.0',
+      };
+    }
+
+    return this.config.prettyPrint
+      ? JSON.stringify(output, null, 2)
+      : JSON.stringify(output);
+  }
+
+  private formatYAML(result: Record<string, unknown>): string {
+    let output = `success: ${result.success}\n`;
+    output += `command: ${result.command}\n`;
+    output += `result: ${result.result}\n`;
+    output += `timestamp: ${result.timestamp}\n`;
+
+    if (this.config.includeMetadata) {
+      output += `metadata:\n`;
+      output += `  format: yaml\n`;
+      output += `  generated: ${new Date().toISOString()}\n`;
+      output += `  version: 1.0.0\n`;
+    }
+
+    return output;
+  }
+
+  private formatText(result: Record<string, unknown>): string {
+    let output = `Command: ${result.command}\n`;
+    output += `Status: ${result.success ? 'SUCCESS' : 'FAILED'}\n`;
+    output += `Result: ${result.result}\n`;
+    output += `Timestamp: ${result.timestamp}\n`;
+    return output;
+  }
+
+  private formatTable(result: Record<string, unknown>): string {
+    const command = String(result.command || '').padEnd(45);
+    const status = (result.success ? 'SUCCESS' : 'FAILED').padEnd(45);
+
+    let output = '+---------------------------------------------------------+\n';
+    output += '|              COMMAND EXECUTION RESULT                    |\n';
+    output += '+---------------------------------------------------------+\n';
+    output += `| Command    | ${command} |\n`;
+    output += `| Status     | ${status} |\n`;
+    output += '+---------------------------------------------------------+\n';
+
+    return output;
+  }
+
+  private formatCSV(result: Record<string, unknown>): string {
+    let output = 'Command,Status,Result,Timestamp\n';
+    output += `"${result.command}","${result.success ? 'SUCCESS' : 'FAILED'}","${result.result}","${result.timestamp}"\n`;
+    return output;
+  }
+
+  private formatHTML(result: Record<string, unknown>): string {
+    const escaped = JSON.stringify(result, null, this.config.prettyPrint ? 2 : 0)
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;');
+    return `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <title>Baseline Studio Output</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 24px; }
+      pre { background: #f6f8fa; padding: 16px; border-radius: 8px; }
+    </style>
+  </head>
+  <body>
+    <h1>Baseline Studio Output</h1>
+    <pre>${escaped}</pre>
+  </body>
+</html>`;
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      status: 'operational',
+      supportedFormats: this.config.formats,
+      defaultFormat: this.config.defaultFormat,
+      prettyPrint: this.config.prettyPrint,
+      includeMetadata: this.config.includeMetadata,
+    };
+  }
+}
+
+// ─── Workflow Manager ───────────────────────────────────────────────
+
+export class WorkflowManager {
+  private activeWorkflows = new Map<string, { workflow: WorkflowDefinition; startTime: number; status: string; currentStep: number }>();
+  private config: WorkflowConfig = { maxSteps: 100, maxDepth: 10, enableRollback: true, enableCheckpoints: true };
+
+  initialize(config: WorkflowConfig): void {
+    this.config = config;
+  }
+
+  async execute(
+    workflow: WorkflowDefinition,
+    _options: Record<string, unknown>,
+  ): Promise<{ success: boolean; workflowId: string; steps: unknown[]; performance: unknown; timestamp: string }> {
+    const workflowId = `wf-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+
+    this.activeWorkflows.set(workflowId, {
+      workflow,
+      startTime: Date.now(),
+      status: 'executing',
+      currentStep: 0,
+    });
+
+    try {
+      const result = await this.executeWorkflowSteps(workflow, workflowId);
+
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.status = 'completed';
+
+      return {
+        success: true,
+        workflowId,
+        steps: result.steps,
+        performance: result.performance,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.status = 'failed';
+      throw error;
+    } finally {
+      this.activeWorkflows.delete(workflowId);
+    }
+  }
+
+  private async executeWorkflowSteps(
+    workflow: WorkflowDefinition,
+    workflowId: string,
+  ): Promise<{ steps: unknown[]; performance: { totalTime: number; stepsExecuted: number } }> {
+    const steps = workflow.steps || [];
+    const results: unknown[] = [];
+    const startTime = Date.now();
+
+    for (let i = 0; i < steps.length && i < this.config.maxSteps; i++) {
+      const step = steps[i];
+      const stepResult = {
+        stepIndex: i,
+        step,
+        status: 'completed',
+        result: `Step ${i + 1} executed: ${step}`,
+      };
+
+      results.push(stepResult);
+
+      const entry = this.activeWorkflows.get(workflowId);
+      if (entry) entry.currentStep = i + 1;
+    }
+
+    return {
+      steps: results,
+      performance: {
+        totalTime: Date.now() - startTime,
+        stepsExecuted: results.length,
+      },
+    };
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      status: 'operational',
+      activeWorkflows: this.activeWorkflows.size,
+      maxSteps: this.config.maxSteps,
+      maxDepth: this.config.maxDepth,
+      enableRollback: this.config.enableRollback,
+      enableCheckpoints: this.config.enableCheckpoints,
+    };
+  }
+}
+
+// ─── Template Registry ─────────────────────────────────────────────
+
+export class TemplateRegistry {
+  private templates = new Map<string, TemplateDefinition>();
+
+  register(template: TemplateDefinition): void {
+    this.templates.set(template.id, template);
+  }
+
+  get(id: string): TemplateDefinition | undefined {
+    return this.templates.get(id);
+  }
+
+  list(): TemplateDefinition[] {
+    return Array.from(this.templates.values());
+  }
+
+  render(id: string, data: Record<string, unknown>): string {
+    const template = this.templates.get(id);
+    if (!template) {
+      throw new Error(`Template not found: ${id}`);
+    }
+    return this.renderTemplate(template.template, data);
+  }
+
+  private renderTemplate(template: string, data: Record<string, unknown>): string {
+    return template.replace(/\{\{\s*([\w.-]+)\s*\}\}/g, (_match, key: string) => {
+      let value: unknown = data;
+      for (const part of key.split('.')) {
+        if (value && typeof value === 'object') {
+          value = (value as Record<string, unknown>)[part];
+          continue;
+        }
+        value = undefined;
+        break;
+      }
+      return value === undefined || value === null ? '' : String(value);
+    });
+  }
+}
+
+// ─── Manifest Builder ──────────────────────────────────────────────
+
+export class ArtifactManifestBuilder {
+  build(artifacts: ArtifactEntry[]): ArtifactManifest {
+    const hash = sha256(stableStringify(artifacts));
+    return {
+      id: `manifest-${Date.now()}`,
+      createdAt: new Date().toISOString(),
+      artifacts,
+      hash,
+    };
+  }
+}
+
+// ─── Result Processor ───────────────────────────────────────────────
+
+export class ResultProcessor {
+  initialize(): void {
+    // Setup processors
+  }
+
+  process(result: Record<string, unknown>): Record<string, unknown> {
+    let processed = this.validateResult(result);
+    processed = this.transformResult(processed);
+    processed = this.enrichResult(processed);
+    return processed;
+  }
+
+  private validateResult(result: Record<string, unknown>): Record<string, unknown> {
+    let commandResult = result;
+
+    if (
+      result.result &&
+      typeof result.result === 'object' &&
+      (result.result as Record<string, unknown>).command
+    ) {
+      commandResult = result.result as Record<string, unknown>;
+    }
+
+    return commandResult;
+  }
+
+  private transformResult(result: Record<string, unknown>): Record<string, unknown> {
+    return {
+      ...result,
+      processed: true,
+      processedAt: new Date().toISOString(),
+    };
+  }
+
+  private enrichResult(result: Record<string, unknown>): Record<string, unknown> {
+    return {
+      ...result,
+      metadata: {
+        ...(result.metadata as Record<string, unknown> || {}),
+        processor: 'Baseline Studio System',
+        version: '1.0.0',
+      },
+    };
+  }
+}
+
+// ─── Performance Optimizer ──────────────────────────────────────────
+
+export class PerformanceOptimizer {
+  private cache = new Map<string, CacheEntry>();
+  private config: PerformanceConfig = { enableCaching: true, cacheSize: 1000, cacheTTL: 300000, enableProfiling: false };
+  private stats = { cacheHits: 0, cacheMisses: 0, optimizationsApplied: 0 };
+
+  initialize(config: PerformanceConfig): void {
+    this.config = config;
+  }
+
+  optimize(result: Record<string, unknown>): Record<string, unknown> {
+    if (this.config.enableCaching) {
+      this.cacheResult(result);
+    }
+    this.stats.optimizationsApplied++;
+    return result;
+  }
+
+  private cacheResult(result: Record<string, unknown>): void {
+    const key = this.generateCacheKey(result);
+
+    if (this.cache.size >= this.config.cacheSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) this.cache.delete(firstKey);
+    }
+
+    this.cache.set(key, { result, timestamp: Date.now(), ttl: this.config.cacheTTL });
+  }
+
+  private generateCacheKey(result: Record<string, unknown>): string {
+    return `${result.command}-${JSON.stringify(result.options)}`;
+  }
+
+  getCachedResult(command: string, options: Record<string, unknown>): unknown | null {
+    const key = this.generateCacheKey({ command, options });
+    const cached = this.cache.get(key);
+
+    if (cached && Date.now() - cached.timestamp < cached.ttl) {
+      this.stats.cacheHits++;
+      return cached.result;
+    }
+
+    this.stats.cacheMisses++;
+    return null;
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      status: 'operational',
+      enableCaching: this.config.enableCaching,
+      cacheSize: this.cache.size,
+      cacheTTL: this.config.cacheTTL,
+      enableProfiling: this.config.enableProfiling,
+      stats: this.stats,
+    };
+  }
+}
+
+// ─── Baseline Studio System ─────────────────────────────────────────
+
+export class BaselineStudioSystem {
+  private config: StudioSystemConfig;
+  private executionEngine: ExecutionEngine;
+  private outputGenerator: OutputGenerator;
+  private workflowManager: WorkflowManager;
+  private resultProcessor: ResultProcessor;
+  private performanceOptimizer: PerformanceOptimizer;
+  private templateRegistry: TemplateRegistry;
+  private manifestBuilder: ArtifactManifestBuilder;
+
+  constructor() {
+    this.config = this.loadConfiguration();
+    this.executionEngine = new ExecutionEngine();
+    this.outputGenerator = new OutputGenerator();
+    this.workflowManager = new WorkflowManager();
+    this.resultProcessor = new ResultProcessor();
+    this.performanceOptimizer = new PerformanceOptimizer();
+    this.templateRegistry = new TemplateRegistry();
+    this.manifestBuilder = new ArtifactManifestBuilder();
+    this.initializeSystem();
+  }
+
+  private loadConfiguration(): StudioSystemConfig {
+    const cfg = studioSystemConfig as {
+      system?: Record<string, string>;
+      execution?: Record<string, unknown>;
+      output?: Record<string, unknown>;
+      workflows?: Record<string, unknown>;
+      performance?: Record<string, unknown>;
+    };
+
+    const exec = cfg.execution ?? {};
+    const out = cfg.output ?? {};
+    const wf = cfg.workflows ?? {};
+    const perf = cfg.performance ?? {};
+
+    return {
+      system: {
+        name: (cfg.system?.name as string) ?? 'Baseline Studio System',
+        version: (cfg.system?.version as string) ?? '1.0.0',
+        description: (cfg.system?.description as string) ?? 'Execution and output generation layer for Baseline Protocol',
+      },
+      execution: {
+        maxConcurrent: (exec.maxConcurrent as number) ?? 5,
+        timeout: (exec.timeout as number) ?? 30000,
+        retryAttempts: (exec.retryAttempts as number) ?? 3,
+        retryDelay: (exec.retryDelay as number) ?? 1000,
+      },
+      output: {
+        formats: (out.formats as string[]) ?? ['json', 'yaml', 'text', 'table', 'csv'],
+        defaultFormat: (out.defaultFormat as string) ?? 'text',
+        prettyPrint: (out.prettyPrint as boolean) ?? true,
+        includeMetadata: (out.includeMetadata as boolean) ?? true,
+      },
+      workflows: {
+        maxSteps: (wf.maxSteps as number) ?? 100,
+        maxDepth: (wf.maxDepth as number) ?? 10,
+        enableRollback: (wf.enableRollback as boolean) ?? true,
+        enableCheckpoints: (wf.enableCheckpoints as boolean) ?? true,
+      },
+      performance: {
+        enableCaching: (perf.enableCaching as boolean) ?? true,
+        cacheSize: (perf.cacheSize as number) ?? 1000,
+        cacheTTL: (perf.cacheTTL as number) ?? 300000,
+        enableProfiling: (perf.enableProfiling as boolean) ?? false,
+      },
+    };
+  }
+
+  private initializeSystem(): void {
+    this.executionEngine.initialize(this.config.execution);
+    this.outputGenerator.initialize(this.config.output);
+    this.workflowManager.initialize(this.config.workflows);
+    this.resultProcessor.initialize();
+    this.performanceOptimizer.initialize(this.config.performance);
+  }
+
+  async executeCommand(
+    command: string,
+    options: Record<string, unknown> = {},
+    context: Record<string, unknown> = {},
+  ): Promise<StudioCommandResult> {
+    try {
+      const validation = this.validateInput(command, options, context);
+      if (!validation.valid) {
+        return { success: false, error: 'Input validation failed', details: validation.errors };
+      }
+
+      const executionResult = await this.executionEngine.execute(command, options, context);
+      const processedResult = this.resultProcessor.process(executionResult.result as Record<string, unknown>);
+      const output = this.outputGenerator.generate(processedResult, (options.format as string) || null);
+      this.performanceOptimizer.optimize(executionResult.result as Record<string, unknown>);
+
+      const artifacts = this.buildArtifacts({
+        command,
+        output,
+        format: (options.format as string) || this.config.output.defaultFormat,
+        context,
+      });
+      const manifest = this.manifestBuilder.build(artifacts);
+
+      return {
+        success: true,
+        command,
+        result: processedResult,
+        output,
+        artifacts,
+        manifest,
+        performance: executionResult.performance,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: 'Command execution failed',
+        details: msg,
+        timestamp: new Date().toISOString(),
+      };
+    }
+  }
+
+  async executeWorkflow(
+    workflow: WorkflowDefinition,
+    options: Record<string, unknown> = {},
+  ): Promise<WorkflowResult> {
+    try {
+      const workflowResult = await this.workflowManager.execute(workflow, options);
+      const artifacts = this.buildArtifacts({
+        workflow: workflow.name,
+        output: JSON.stringify(workflowResult),
+        format: 'json',
+        context: options,
+      });
+      const manifest = this.manifestBuilder.build(artifacts);
+
+      return {
+        success: true,
+        workflow: workflow.name,
+        result: workflowResult,
+        steps: workflowResult.steps,
+        artifacts,
+        manifest,
+        performance: workflowResult.performance,
+        timestamp: new Date().toISOString(),
+      };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: 'Workflow execution failed',
+        details: msg,
+        workflow: workflow.name,
+      };
+    }
+  }
+
+  private validateInput(
+    command: string,
+    options: Record<string, unknown>,
+    context: Record<string, unknown>,
+  ): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    if (!command || typeof command !== 'string') {
+      errors.push('Command must be a non-empty string');
+    }
+
+    if (
+      options.format &&
+      !this.config.output.formats.includes(options.format as string)
+    ) {
+      errors.push(
+        `Invalid output format: ${options.format}. Valid formats: ${this.config.output.formats.join(', ')}`,
+      );
+    }
+
+    if (
+      context.mode &&
+      !['development', 'production', 'testing', 'maintenance'].includes(context.mode as string)
+    ) {
+      errors.push(`Invalid context mode: ${context.mode}`);
+    }
+
+    return { valid: errors.length === 0, errors };
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      system: this.config.system.name,
+      version: this.config.system.version,
+      execution: this.executionEngine.getStatus(),
+      output: this.outputGenerator.getStatus(),
+      workflows: this.workflowManager.getStatus(),
+      performance: this.performanceOptimizer.getStatus(),
+    };
+  }
+
+  registerTemplate(template: TemplateDefinition): void {
+    this.templateRegistry.register(template);
+  }
+
+  renderTemplate(templateId: string, data: Record<string, unknown>): string {
+    return this.templateRegistry.render(templateId, data);
+  }
+
+  preview(templateId: string, data: Record<string, unknown>, format: 'text' | 'html' | 'json' = 'text'): string {
+    const rendered = this.renderTemplate(templateId, data);
+    if (format === 'json') {
+      return JSON.stringify({ rendered, templateId }, null, 2);
+    }
+    if (format === 'html') {
+      return `<!doctype html><html><body><pre>${rendered}</pre></body></html>`;
+    }
+    return rendered;
+  }
+
+  getExecutionEngine(): ExecutionEngine {
+    return this.executionEngine;
+  }
+
+  getOutputGenerator(): OutputGenerator {
+    return this.outputGenerator;
+  }
+
+  getWorkflowManager(): WorkflowManager {
+    return this.workflowManager;
+  }
+
+  getPerformanceOptimizer(): PerformanceOptimizer {
+    return this.performanceOptimizer;
+  }
+
+  getTemplateRegistry(): TemplateRegistry {
+    return this.templateRegistry;
+  }
+
+  private buildArtifacts(input: {
+    command?: string;
+    workflow?: string;
+    output: string;
+    format: string;
+    context: Record<string, unknown>;
+  }): ArtifactEntry[] {
+    const provenance: ArtifactProvenance = {
+      command: input.command,
+      workflow: input.workflow,
+      context: input.context,
+      generatedAt: new Date().toISOString(),
+    };
+
+    const artifact: ArtifactEntry = {
+      id: `artifact-${Date.now()}`,
+      type: 'output',
+      format: input.format,
+      content: input.output,
+      hash: sha256(stableStringify({ command: input.command, workflow: input.workflow, format: input.format, context: input.context })),
+      provenance,
+    };
+
+    return [artifact];
+  }
+}
+
+// ─── Helpers ───────────────────────────────────────────────────────
+
+function sha256(input: string): string {
+  return createHash('sha256').update(input).digest('hex');
+}
+
+function stableStringify(value: unknown): string {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(',')}]`;
+  }
+  const obj = value as Record<string, unknown>;
+  const keys = Object.keys(obj).sort();
+  const entries = keys.map(key => `"${key}":${stableStringify(obj[key])}`);
+  return `{${entries.join(',')}}`;
+}