legal-markdown-js/dist/extensions/pipeline/pipeline-manager.d.ts

Node.js implementation of LegalMarkdown for processing legal documents with markdown and YAML - Complete feature parity with Ruby version

/**
 * Pipeline Manager for Legal Markdown Processing
 *
 * This module provides the core pipeline management system for Legal Markdown
 * processing. It orchestrates the execution of multiple processing steps in a
 * configurable, observable, and fault-tolerant manner.
 *
 * Features:
 * - Step-by-step processing with dependency management
 * - Comprehensive error handling and recovery
 * - Performance monitoring and metrics collection
 * - Field tracking integration
 * - Event-driven architecture with listeners
 * - Configurable execution strategies
 * - Fallback mechanisms for reliability
 * - Debug and profiling capabilities
 *
 * @example
 * ```typescript
 * import { PipelineManager } from './pipeline-manager';
 * import { ConsolePipelineLogger } from './pipeline-logger';
 *
 * const logger = new ConsolePipelineLogger({ level: 'debug' });
 * const pipeline = new PipelineManager(logger);
 *
 * // Register steps
 * pipeline.registerStep({
 *   name: 'mixins',
 *   processor: new MixinProcessor(),
 *   order: 7,
 *   enabled: true
 * });
 *
 * // Execute pipeline
 * const result = await pipeline.execute(content, metadata, options);
 * ```
 *
 * @module
 */
import { PipelineStep, PipelineResult, ProcessingError, PipelineConfig, PipelineState, PipelineExecutionOptions, PipelineEventListener } from './types';
import { PipelineLogger } from './pipeline-logger';
/**
 * Central pipeline manager for orchestrating Legal Markdown processing
 *
 * The PipelineManager coordinates the execution of multiple processing steps,
 * providing comprehensive monitoring, error handling, and performance tracking.
 * It serves as the backbone for the new Legal Markdown processing architecture.
 *
 * @class PipelineManager
 * @example
 * ```typescript
 * const pipeline = new PipelineManager();
 *
 * // Configure steps
 * pipeline.registerStep({
 *   name: 'yaml-parsing',
 *   processor: new YamlProcessor(),
 *   order: 1,
 *   enabled: true
 * });
 *
 * pipeline.registerStep({
 *   name: 'mixins',
 *   processor: new MixinProcessor(),
 *   order: 7,
 *   enabled: true,
 *   dependencies: ['yaml-parsing']
 * });
 *
 * // Execute with options
 * const result = await pipeline.execute(content, metadata, {
 *   legalMarkdownOptions: { enableFieldTracking: true },
 *   enableStepProfiling: true
 * });
 *
 * console.log(`Processed ${result.content.length} characters`);
 * console.log(`Tracked ${result.fieldReport?.total} fields`);
 * ```
 */
export declare class PipelineManager {
    private steps;
    private logger;
    private listeners;
    private state;
    /**
     * Creates a new PipelineManager instance
     *
     * @param logger - Optional logger for pipeline events (defaults to console logger in development)
     * @param config - Optional initial configuration
     */
    constructor(logger?: PipelineLogger, config?: Partial<PipelineConfig>);
    /**
     * Register a processing step with the pipeline
     *
     * @param step - The pipeline step configuration
     * @throws {Error} If step name is already registered or invalid
     * @example
     * ```typescript
     * pipeline.registerStep({
     *   name: 'custom-processor',
     *   processor: new CustomProcessor(),
     *   order: 10,
     *   enabled: true,
     *   dependencies: ['mixins'],
     *   timeout: 5000,
     *   description: 'Custom document processing'
     * });
     * ```
     */
    registerStep(step: PipelineStep): void;
    /**
     * Unregister a processing step from the pipeline
     *
     * @param stepName - Name of the step to remove
     * @returns True if step was found and removed
     */
    unregisterStep(stepName: string): boolean;
    /**
     * Get information about a registered step
     *
     * @param stepName - Name of the step to query
     * @returns Step configuration or undefined if not found
     */
    getStep(stepName: string): PipelineStep | undefined;
    /**
     * Get all registered steps ordered by execution order
     *
     * @returns Array of steps sorted by order
     */
    getSteps(): PipelineStep[];
    /**
     * Add an event listener for pipeline events
     *
     * @param listener - Event listener implementation
     * @example
     * ```typescript
     * pipeline.addListener({
     *   onStepStart: (stepName) => console.log(`Starting ${stepName}`),
     *   onStepComplete: (result) => console.log(`Completed ${result.stepName}`),
     *   onPipelineComplete: (result) => console.log('Pipeline finished')
     * });
     * ```
     */
    addListener(listener: PipelineEventListener): void;
    /**
     * Remove an event listener
     *
     * @param listener - Listener to remove
     * @returns True if listener was found and removed
     */
    removeListener(listener: PipelineEventListener): boolean;
    /**
     * Execute the complete processing pipeline
     *
     * This is the main entry point for pipeline execution. It processes the content
     * through all registered steps in the correct order, handling dependencies,
     * errors, and performance tracking.
     *
     * @param content - The document content to process
     * @param metadata - Document metadata (YAML front matter, etc.)
     * @param options - Execution options and Legal Markdown options
     * @returns Promise resolving to complete pipeline result
     * @throws {Error} For critical pipeline failures
     * @example
     * ```typescript
     * const result = await pipeline.execute(
     *   '# Document\n\n{{client.name}} agreement...',
     *   { client: { name: 'Acme Corp' } },
     *   {
     *     legalMarkdownOptions: {
     *       enableFieldTracking: true,
     *       enableFieldTrackingInMarkdown: true
     *     },
     *     enableStepProfiling: true
     *   }
     * );
     *
     * if (result.success) {
     *   console.log('Processing completed successfully');
     *   console.log(`Final content: ${result.content.length} characters`);
     * } else {
     *   console.error('Processing failed:', result.errors);
     * }
     * ```
     */
    execute(content: string, metadata: Record<string, any>, options: PipelineExecutionOptions): Promise<PipelineResult>;
    /**
     * Abort pipeline execution
     *
     * @param reason - Reason for aborting
     */
    abort(reason?: string): void;
    /**
     * Get current pipeline state
     *
     * @returns Current pipeline state
     */
    getState(): Readonly<PipelineState>;
    /**
     * Validate pipeline configuration
     *
     * @param options - Execution options to validate
     * @returns Array of validation errors (empty if valid)
     */
    validateConfiguration(options: PipelineExecutionOptions): ProcessingError[];
    private createDefaultLogger;
    private initializeState;
    private buildPipelineConfig;
    private getExecutionOrder;
    private shouldExecuteStep;
    private executeStep;
    private executeWithTimeout;
    private checkDependencies;
    private topologicalSort;
    private detectCircularDependencies;
    private generateFieldReport;
    private collectExportedFiles;
    private updateContentHistory;
    private createProcessingError;
    private createGenericError;
    private emitEvent;
}
//# sourceMappingURL=pipeline-manager.d.ts.map