@devilsdev/rag-pipeline-utils 2.6.1 → 2.7.0

package/dist/types/config/enhanced-ragrc-schema.d.ts

@@ -0,0 +1,648 @@
+/**
+ * Validate .ragrc.json configuration (single source of truth)
+ * @param {object} config - Configuration to validate
+ * @returns {{ valid: boolean, errors?: any[], normalized?: object }}
+ */
+export function validateRagrc(config: object): {
+    valid: boolean;
+    errors?: any[];
+    normalized?: object;
+};
+import { normalizeConfig } from "./normalize-config";
+/**
+ * Build the canonical .ragrc.json schema
+ * @returns {object} JSON Schema object
+ */
+export function buildRagrcJsonSchema(): object;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use validateRagrc instead
+ */
+export function validateEnhancedRagrcSchema(config: any): {
+    valid: boolean;
+    errors: any[];
+    legacy: boolean;
+};
+/**
+ * Convert legacy _config to enhanced format
+ * @param {object} legacyConfig - Legacy configuration
+ * @returns {object} Enhanced configuration
+ */
+export function convertLegacyConfig(legacyConfig: object): object;
+/**
+ * Normalize plugin specification to object format
+ * @param {string|object} spec - Plugin specification
+ * @returns {object} Normalized specification
+ */
+export function normalizePluginSpec(spec: string | object): object;
+/**
+ * Extract plugin dependencies from configuration
+ * @param {object} _config - Enhanced configuration
+ * @returns {Array<{type: string, name: string, spec: object}>}
+ */
+export function extractPluginDependencies(config: any): Array<{
+    type: string;
+    name: string;
+    spec: object;
+}>;
+/**
+ * Validate plugin configuration consistency
+ * @param {object} config - Configuration to validate
+ * @returns {{ valid: boolean, issues: Array<string> }}
+ */
+export function validateConfigConsistency(config: object): {
+    valid: boolean;
+    issues: Array<string>;
+};
+export namespace enhancedRagrcSchema {
+    export let type: string;
+    export let required: string[];
+    export namespace properties {
+        export namespace plugins {
+            let type_1: string;
+            export { type_1 as type };
+            let required_1: string[];
+            export { required_1 as required };
+            export namespace properties_1 {
+                export { pluginGroupSchema as loader };
+                export { pluginGroupSchema as embedder };
+                export { pluginGroupSchema as retriever };
+                export { pluginGroupSchema as llm };
+                export { pluginGroupSchema as reranker };
+            }
+            export { properties_1 as properties };
+            export let additionalProperties: boolean;
+        }
+        export { registryConfigSchema as registry };
+        export namespace pipeline {
+            let type_2: string;
+            export { type_2 as type };
+            export namespace properties_2 {
+                namespace stages {
+                    let type_3: string;
+                    export { type_3 as type };
+                    export namespace items {
+                        let type_4: string;
+                        export { type_4 as type };
+                        let _enum: string[];
+                        export { _enum as enum };
+                    }
+                    let _default: string[];
+                    export { _default as default };
+                    export let description: string;
+                }
+                namespace middleware {
+                    let type_5: string;
+                    export { type_5 as type };
+                    export namespace items_1 {
+                        let type_6: string;
+                        export { type_6 as type };
+                        let required_2: string[];
+                        export { required_2 as required };
+                        export namespace properties_3 {
+                            namespace name {
+                                let type_7: string;
+                                export { type_7 as type };
+                            }
+                            namespace _config {
+                                let type_8: string;
+                                export { type_8 as type };
+                            }
+                            namespace enabled {
+                                let type_9: string;
+                                export { type_9 as type };
+                                let _default_1: boolean;
+                                export { _default_1 as default };
+                            }
+                        }
+                        export { properties_3 as properties };
+                    }
+                    export { items_1 as items };
+                    let description_1: string;
+                    export { description_1 as description };
+                }
+                namespace retries {
+                    let type_10: string;
+                    export { type_10 as type };
+                    export namespace properties_4 {
+                        export namespace enabled_1 {
+                            let type_11: string;
+                            export { type_11 as type };
+                            let _default_2: boolean;
+                            export { _default_2 as default };
+                        }
+                        export { enabled_1 as enabled };
+                        export namespace maxAttempts {
+                            let type_12: string;
+                            export { type_12 as type };
+                            let _default_3: number;
+                            export { _default_3 as default };
+                        }
+                        export namespace backoff {
+                            let type_13: string;
+                            export { type_13 as type };
+                            let _enum_1: string[];
+                            export { _enum_1 as enum };
+                            let _default_4: string;
+                            export { _default_4 as default };
+                        }
+                    }
+                    export { properties_4 as properties };
+                }
+                namespace timeout {
+                    let type_14: string;
+                    export { type_14 as type };
+                    let description_2: string;
+                    export { description_2 as description };
+                }
+            }
+            export { properties_2 as properties };
+            let additionalProperties_1: boolean;
+            export { additionalProperties_1 as additionalProperties };
+        }
+        export namespace performance {
+            let type_15: string;
+            export { type_15 as type };
+            export namespace properties_5 {
+                namespace parallel {
+                    let type_16: string;
+                    export { type_16 as type };
+                    export namespace properties_6 {
+                        export namespace enabled_2 {
+                            let type_17: string;
+                            export { type_17 as type };
+                            let _default_5: boolean;
+                            export { _default_5 as default };
+                        }
+                        export { enabled_2 as enabled };
+                        export namespace maxConcurrency {
+                            let type_18: string;
+                            export { type_18 as type };
+                            let _default_6: number;
+                            export { _default_6 as default };
+                        }
+                        export namespace batchSize {
+                            let type_19: string;
+                            export { type_19 as type };
+                            let _default_7: number;
+                            export { _default_7 as default };
+                        }
+                    }
+                    export { properties_6 as properties };
+                }
+                namespace streaming {
+                    let type_20: string;
+                    export { type_20 as type };
+                    export namespace properties_7 {
+                        export namespace enabled_3 {
+                            let type_21: string;
+                            export { type_21 as type };
+                            let _default_8: boolean;
+                            export { _default_8 as default };
+                        }
+                        export { enabled_3 as enabled };
+                        export namespace maxMemoryMB {
+                            let type_22: string;
+                            export { type_22 as type };
+                            let _default_9: number;
+                            export { _default_9 as default };
+                        }
+                        export namespace bufferSize {
+                            let type_23: string;
+                            export { type_23 as type };
+                            let _default_10: number;
+                            export { _default_10 as default };
+                        }
+                    }
+                    export { properties_7 as properties };
+                }
+                namespace caching {
+                    let type_24: string;
+                    export { type_24 as type };
+                    export namespace properties_8 {
+                        export namespace enabled_4 {
+                            let type_25: string;
+                            export { type_25 as type };
+                            let _default_11: boolean;
+                            export { _default_11 as default };
+                        }
+                        export { enabled_4 as enabled };
+                        export namespace ttl {
+                            let type_26: string;
+                            export { type_26 as type };
+                            let _default_12: number;
+                            export { _default_12 as default };
+                        }
+                        export namespace maxSize {
+                            let type_27: string;
+                            export { type_27 as type };
+                            let _default_13: number;
+                            export { _default_13 as default };
+                        }
+                    }
+                    export { properties_8 as properties };
+                }
+            }
+            export { properties_5 as properties };
+            let additionalProperties_2: boolean;
+            export { additionalProperties_2 as additionalProperties };
+        }
+        export namespace observability {
+            let type_28: string;
+            export { type_28 as type };
+            export namespace properties_9 {
+                namespace logging {
+                    let type_29: string;
+                    export { type_29 as type };
+                    export namespace properties_10 {
+                        namespace level {
+                            let type_30: string;
+                            export { type_30 as type };
+                            let _enum_2: string[];
+                            export { _enum_2 as enum };
+                            let _default_14: string;
+                            export { _default_14 as default };
+                        }
+                        namespace structured {
+                            let type_31: string;
+                            export { type_31 as type };
+                            let _default_15: boolean;
+                            export { _default_15 as default };
+                        }
+                        namespace events {
+                            let type_32: string;
+                            export { type_32 as type };
+                            let _default_16: boolean;
+                            export { _default_16 as default };
+                        }
+                    }
+                    export { properties_10 as properties };
+                }
+                namespace tracing {
+                    let type_33: string;
+                    export { type_33 as type };
+                    export namespace properties_11 {
+                        export namespace enabled_5 {
+                            let type_34: string;
+                            export { type_34 as type };
+                            let _default_17: boolean;
+                            export { _default_17 as default };
+                        }
+                        export { enabled_5 as enabled };
+                        export namespace exportUrl {
+                            let type_35: string;
+                            export { type_35 as type };
+                            export let format: string;
+                        }
+                        export namespace sampleRate {
+                            let type_36: string;
+                            export { type_36 as type };
+                            export let minimum: number;
+                            export let maximum: number;
+                            let _default_18: number;
+                            export { _default_18 as default };
+                        }
+                    }
+                    export { properties_11 as properties };
+                }
+                namespace metrics {
+                    let type_37: string;
+                    export { type_37 as type };
+                    export namespace properties_12 {
+                        export namespace enabled_6 {
+                            let type_38: string;
+                            export { type_38 as type };
+                            let _default_19: boolean;
+                            export { _default_19 as default };
+                        }
+                        export { enabled_6 as enabled };
+                        export namespace exportUrl_1 {
+                            let type_39: string;
+                            export { type_39 as type };
+                            let format_1: string;
+                            export { format_1 as format };
+                        }
+                        export { exportUrl_1 as exportUrl };
+                        export namespace interval {
+                            let type_40: string;
+                            export { type_40 as type };
+                            let _default_20: number;
+                            export { _default_20 as default };
+                        }
+                    }
+                    export { properties_12 as properties };
+                }
+            }
+            export { properties_9 as properties };
+            let additionalProperties_3: boolean;
+            export { additionalProperties_3 as additionalProperties };
+        }
+        export namespace environments {
+            let type_41: string;
+            export { type_41 as type };
+            export namespace additionalProperties_4 {
+                let type_42: string;
+                export { type_42 as type };
+                let description_3: string;
+                export { description_3 as description };
+            }
+            export { additionalProperties_4 as additionalProperties };
+        }
+        export namespace metadata {
+            let type_43: string;
+            export { type_43 as type };
+            export namespace properties_13 {
+                export namespace name_1 {
+                    let type_44: string;
+                    export { type_44 as type };
+                    let description_4: string;
+                    export { description_4 as description };
+                }
+                export { name_1 as name };
+                export namespace version {
+                    let type_45: string;
+                    export { type_45 as type };
+                    let description_5: string;
+                    export { description_5 as description };
+                }
+                export namespace description_6 {
+                    let type_46: string;
+                    export { type_46 as type };
+                    let description_7: string;
+                    export { description_7 as description };
+                }
+                export { description_6 as description };
+                export namespace author {
+                    let type_47: string;
+                    export { type_47 as type };
+                    let description_8: string;
+                    export { description_8 as description };
+                }
+                export namespace tags {
+                    let type_48: string;
+                    export { type_48 as type };
+                    export namespace items_2 {
+                        let type_49: string;
+                        export { type_49 as type };
+                    }
+                    export { items_2 as items };
+                    let description_9: string;
+                    export { description_9 as description };
+                }
+            }
+            export { properties_13 as properties };
+            let additionalProperties_5: boolean;
+            export { additionalProperties_5 as additionalProperties };
+        }
+        export namespace namespace {
+            let type_50: string;
+            export { type_50 as type };
+            let description_10: string;
+            export { description_10 as description };
+        }
+    }
+    let additionalProperties_6: boolean;
+    export { additionalProperties_6 as additionalProperties };
+}
+export namespace legacyRagrcSchema {
+    let type_51: string;
+    export { type_51 as type };
+    let required_3: string[];
+    export { required_3 as required };
+    export namespace properties_14 {
+        export namespace loader {
+            let type_52: string;
+            export { type_52 as type };
+            export let minProperties: number;
+            export namespace additionalProperties_7 {
+                let type_53: string;
+                export { type_53 as type };
+            }
+            export { additionalProperties_7 as additionalProperties };
+        }
+        export namespace embedder {
+            let type_54: string;
+            export { type_54 as type };
+            let minProperties_1: number;
+            export { minProperties_1 as minProperties };
+            export namespace additionalProperties_8 {
+                let type_55: string;
+                export { type_55 as type };
+            }
+            export { additionalProperties_8 as additionalProperties };
+        }
+        export namespace retriever {
+            let type_56: string;
+            export { type_56 as type };
+            let minProperties_2: number;
+            export { minProperties_2 as minProperties };
+            export namespace additionalProperties_9 {
+                let type_57: string;
+                export { type_57 as type };
+            }
+            export { additionalProperties_9 as additionalProperties };
+        }
+        export namespace llm {
+            let type_58: string;
+            export { type_58 as type };
+            let minProperties_3: number;
+            export { minProperties_3 as minProperties };
+            export namespace additionalProperties_10 {
+                let type_59: string;
+                export { type_59 as type };
+            }
+            export { additionalProperties_10 as additionalProperties };
+        }
+        export namespace reranker {
+            let type_60: string;
+            export { type_60 as type };
+            export namespace additionalProperties_11 {
+                let type_61: string;
+                export { type_61 as type };
+            }
+            export { additionalProperties_11 as additionalProperties };
+        }
+        export namespace namespace_1 {
+            let type_62: string;
+            export { type_62 as type };
+            export let minLength: number;
+        }
+        export { namespace_1 as namespace };
+        export namespace pipeline_1 {
+            let type_63: string;
+            export { type_63 as type };
+            export namespace items_3 {
+                let type_64: string;
+                export { type_64 as type };
+                let _enum_3: string[];
+                export { _enum_3 as enum };
+            }
+            export { items_3 as items };
+            export let minItems: number;
+            export let uniqueItems: boolean;
+        }
+        export { pipeline_1 as pipeline };
+    }
+    export { properties_14 as properties };
+    let additionalProperties_12: boolean;
+    export { additionalProperties_12 as additionalProperties };
+}
+declare namespace pluginGroupSchema {
+    let type_65: string;
+    export { type_65 as type };
+    let minProperties_4: number;
+    export { minProperties_4 as minProperties };
+    export { pluginSpecSchema as additionalProperties };
+    let description_11: string;
+    export { description_11 as description };
+}
+declare namespace registryConfigSchema {
+    let type_66: string;
+    export { type_66 as type };
+    export namespace properties_15 {
+        export namespace urls {
+            let type_67: string;
+            export { type_67 as type };
+            export namespace items_4 {
+                let type_68: string;
+                export { type_68 as type };
+                let format_2: string;
+                export { format_2 as format };
+            }
+            export { items_4 as items };
+            let description_12: string;
+            export { description_12 as description };
+        }
+        export namespace cache {
+            let type_69: string;
+            export { type_69 as type };
+            export namespace properties_16 {
+                export namespace enabled_7 {
+                    let type_70: string;
+                    export { type_70 as type };
+                    let _default_21: boolean;
+                    export { _default_21 as default };
+                }
+                export { enabled_7 as enabled };
+                export namespace ttl_1 {
+                    let type_71: string;
+                    export { type_71 as type };
+                    let _default_22: number;
+                    export { _default_22 as default };
+                    let description_13: string;
+                    export { description_13 as description };
+                }
+                export { ttl_1 as ttl };
+                export namespace directory {
+                    let type_72: string;
+                    export { type_72 as type };
+                    let description_14: string;
+                    export { description_14 as description };
+                }
+            }
+            export { properties_16 as properties };
+            let additionalProperties_13: boolean;
+            export { additionalProperties_13 as additionalProperties };
+        }
+        export namespace auth {
+            let type_73: string;
+            export { type_73 as type };
+            export namespace properties_17 {
+                namespace token {
+                    let type_74: string;
+                    export { type_74 as type };
+                    let description_15: string;
+                    export { description_15 as description };
+                }
+                namespace username {
+                    let type_75: string;
+                    export { type_75 as type };
+                    let description_16: string;
+                    export { description_16 as description };
+                }
+                namespace password {
+                    let type_76: string;
+                    export { type_76 as type };
+                    let description_17: string;
+                    export { description_17 as description };
+                }
+            }
+            export { properties_17 as properties };
+            let additionalProperties_14: boolean;
+            export { additionalProperties_14 as additionalProperties };
+        }
+        export namespace timeout_1 {
+            let type_77: string;
+            export { type_77 as type };
+            let _default_23: number;
+            export { _default_23 as default };
+            let description_18: string;
+            export { description_18 as description };
+        }
+        export { timeout_1 as timeout };
+        export namespace retries_1 {
+            let type_78: string;
+            export { type_78 as type };
+            let _default_24: number;
+            export { _default_24 as default };
+            let description_19: string;
+            export { description_19 as description };
+        }
+        export { retries_1 as retries };
+    }
+    export { properties_15 as properties };
+    let additionalProperties_15: boolean;
+    export { additionalProperties_15 as additionalProperties };
+}
+declare namespace pluginSpecSchema {
+    let oneOf: ({
+        type: string;
+        required?: undefined;
+        properties?: undefined;
+        additionalProperties?: undefined;
+    } | {
+        type: string;
+        required: string[];
+        properties: {
+            name: {
+                type: string;
+                pattern: string;
+                description: string;
+            };
+            version: {
+                type: string;
+                description: string;
+            };
+            source: {
+                type: string;
+                enum: string[];
+                default: string;
+                description: string;
+            };
+            url: {
+                type: string;
+                format: string;
+                description: string;
+            };
+            path: {
+                type: string;
+                description: string;
+            };
+            config: {
+                type: string;
+                description: string;
+            };
+            enabled: {
+                type: string;
+                default: boolean;
+                description: string;
+            };
+            fallback: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: boolean;
+    })[];
+}
+export { normalizeConfig };

package/dist/types/config/load-config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Load and validate a RAG configuration file.
+ * @param {string} [cwd=process.cwd()] - Directory to resolve the config from
+ * @returns {object} Validated configuration object
+ */
+/**
+ * Load and validate .ragrc.json.
+ *
+ * @param {string} [location=process.cwd()] - A directory containing
+ *   .ragrc.json, or the path of a config file (any name ending in .json)
+ * @returns {object} Normalized configuration
+ */
+export function loadRagConfig(location?: string): object;
+/**
+ * @param {string} [location=process.cwd()] - Directory or config file path
+ * @returns {string} Absolute path of the config file
+ */
+export function resolveConfigPath(location?: string): string;

package/dist/types/config/normalize-config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Configuration Normalization - Unifies config shape and validation
+ * Handles pipeline object/array conversion and default namespace assignment
+ */
+export function normalizeConfig(cfg: any): {
+    namespace: any;
+    metadata: any;
+    pipeline: any;
+};