@devilsdev/rag-pipeline-utils 2.6.2 → 2.7.0

package/dist/types/dag/dag-engine.d.ts

@@ -2,8 +2,21 @@ export class DAG {
     nodes: Map<any, any>;
     scheduler: ExecutionScheduler;
     errorContext: ErrorContext;
-    addNode(id: any, _fn: any, options?: {}): DAGNode;
-    connect(fromId: any, toId: any): void;
+    /**
+     * Adds a node. A source node receives the seed; a node with one input
+     * receives that node's result, and with several, an array of them.
+     * @param {string} id - Unique node id
+     * @param {function(*): *} fn - The node's work; may be async
+     * @param {Object} [options]
+     * @returns {DAGNode} The node; set `optional` or `retry` on it to change how failures are handled
+     */
+    addNode(id: string, _fn: any, options?: any): DAGNode;
+    /**
+     * Adds an edge: `toId` runs after `fromId` and receives its result.
+     * @param {string} fromId
+     * @param {string} toId
+     */
+    connect(fromId: string, toId: string): void;
     /**
      * Parse and normalize execute parameters
      * @param {any} seedOrOptions - Seed data or options object

package/dist/types/dev/dev-server.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Development Server
+ *
+ * Integrates hot reloading with a development workflow
+ */
+export class DevServer extends EventEmitter<[never]> {
+    constructor(options?: {});
+    options: {
+        port: any;
+        host: any;
+        watchPaths: any;
+        maxBodyBytes: any;
+        query: any;
+        configPath: any;
+        verbose: boolean;
+        autoReload: boolean;
+        notifyOnReload: boolean;
+        pluginRegistry: any;
+        pipeline: any;
+    };
+    hotReload: import("./hot-reload").HotReloadManager;
+    isRunning: boolean;
+    startTime: number;
+    /**
+     * Setup hot reload event handlers
+     *
+     * @private
+     */
+    private _setupHotReloadHandlers;
+    /**
+     * Start the development server
+     *
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    port: any;
+    /**
+     * Stop the development server
+     *
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Get server status
+     *
+     * @returns {object} Server status
+     */
+    getStatus(): object;
+    /**
+     * Get statistics dashboard
+     *
+     * @returns {string} Formatted statistics
+     */
+    getStatistics(): string;
+    /**
+     * Manually trigger a reload
+     *
+     * @param {string} filePath - File path to reload
+     * @param {string} type - Type ('plugin' or 'config')
+     * @returns {Promise<void>}
+     */
+    /** @returns {string} Base URL of the running server */
+    get url(): string;
+    /**
+     * Route a request. Only GET /health and POST /query exist.
+     * @private
+     */
+    private _handleRequest;
+    /** @private */
+    private _isLoopbackHostHeader;
+    /**
+     * Answer with the custom `query` option, or the pipeline described by the
+     * config file (reloaded per request, so config edits apply immediately).
+     * @private
+     */
+    private _runQuery;
+    /** @private */
+    private _readJson;
+    /** @private */
+    private _send;
+    /**
+     * Reloads a plugin or the config now, as if the file had changed.
+     * @param {string} filePath
+     * @param {'plugin'|'config'} [type='plugin']
+     * @returns {Promise<void>}
+     */
+    triggerReload(filePath: string, type?: "plugin" | "config"): Promise<void>;
+    /**
+     * Register a lifecycle hook
+     *
+     * @param {string} hookName - Hook name
+     * @param {Function} callback - Hook callback
+     */
+    registerHook(hookName: string, callback: Function): void;
+    /**
+     * Unregister a lifecycle hook
+     *
+     * @param {string} hookName - Hook name
+     * @param {Function} callback - Hook callback
+     */
+    unregisterHook(hookName: string, callback: Function): void;
+    /**
+     * Log message
+     *
+     * @private
+     * @param {string} message - Log message
+     * @param {string} level - Log level
+     */
+    private _log;
+    /**
+     * Send notification
+     *
+     * @private
+     * @param {string} message - Notification message
+     * @param {string} type - Notification type
+     */
+    private _notify;
+    /**
+     * Format duration
+     *
+     * @private
+     * @param {number} ms - Duration in milliseconds
+     * @returns {string} Formatted duration
+     */
+    private _formatDuration;
+}
+/**
+ * Create development server
+ *
+ * @param {object} options - Server options
+ * @returns {DevServer} Development server instance
+ */
+export function createDevServer(options?: object): DevServer;
+import { EventEmitter } from "events";
+import http = require("http");

package/dist/types/dev/hot-reload.d.ts

@@ -0,0 +1,226 @@
+/**
+ * chokidar 4 removed glob support, so glob strings in `ignored` were treated
+ * as literal paths and matched nothing. Convert them to one matcher function.
+ *
+ * @param {Array<string|RegExp|Function>} patterns
+ * @returns {(filePath: string) => boolean}
+ */
+export function toIgnoreMatcher(patterns: Array<string | RegExp | Function>): (filePath: string) => boolean;
+/**
+ * Hot Reload Manager
+ *
+ * Manages file watching and hot reloading of plugins and configuration.
+ */
+export class HotReloadManager extends EventEmitter<[never]> {
+    constructor(options?: {});
+    options: {
+        enabled: boolean;
+        watchPaths: any;
+        configPath: any;
+        debounceDelay: any;
+        preserveState: boolean;
+        verbose: any;
+        ignorePatterns: any;
+    };
+    watchers: any[];
+    pluginRegistry: any;
+    reloadQueue: Map<any, any>;
+    debounceTimers: Map<any, any>;
+    pluginState: Map<any, any>;
+    reloadHistory: any[];
+    isReloading: boolean;
+    stats: {
+        totalReloads: number;
+        successfulReloads: number;
+        failedReloads: number;
+        configReloads: number;
+        pluginReloads: number;
+        averageReloadTime: number;
+    };
+    hooks: {
+        beforeReload: any[];
+        afterReload: any[];
+        onError: any[];
+        onStatePreserve: any[];
+        onStateRestore: any[];
+    };
+    /**
+     * Start watching for file changes
+     *
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Stop watching for file changes
+     *
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Watch plugin files
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private _watchPlugins;
+    /**
+     * Watch configuration file
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private _watchConfig;
+    /**
+     * Handle plugin file change
+     *
+     * @private
+     * @param {string} filePath - Changed file path
+     */
+    private _handlePluginChange;
+    /**
+     * Handle configuration change
+     *
+     * @private
+     */
+    private _handleConfigChange;
+    /**
+     * Reload a plugin
+     *
+     * @private
+     * @param {string} filePath - Plugin file path
+     * @returns {Promise<void>}
+     */
+    private _reloadPlugin;
+    /**
+     * Reload configuration
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private _reloadConfig;
+    /**
+     * Handle plugin removal
+     *
+     * @private
+     * @param {string} filePath - Removed plugin path
+     */
+    private _handlePluginRemoval;
+    /**
+     * Preserve plugin state before reload
+     *
+     * @private
+     * @param {string} filePath - Plugin file path
+     * @returns {Promise<any>} Preserved state
+     */
+    private _preservePluginState;
+    /**
+     * Restore plugin state after reload
+     *
+     * @private
+     * @param {object} plugin - Reloaded plugin
+     * @param {any} state - Preserved state
+     * @returns {Promise<void>}
+     */
+    private _restorePluginState;
+    /**
+     * Update plugin registry with reloaded plugin
+     *
+     * @private
+     * @param {string} filePath - Plugin file path
+     * @param {object} plugin - Reloaded plugin
+     * @returns {Promise<void>}
+     */
+    private _updatePluginRegistry;
+    /**
+     * Process queued reloads
+     *
+     * @private
+     * @returns {Promise<void>}
+     */
+    private _processReloadQueue;
+    /**
+     * Execute lifecycle hooks
+     *
+     * @private
+     * @param {string} hookName - Hook name
+     * @param {object} data - Hook data
+     * @returns {Promise<void>}
+     */
+    private _executeHooks;
+    /**
+     * Record reload in history
+     *
+     * @private
+     * @param {object} record - Reload record
+     */
+    private _recordReload;
+    /**
+     * Update average reload time
+     *
+     * @private
+     * @param {number} duration - Reload duration
+     */
+    private _updateAverageReloadTime;
+    /**
+     * Handle errors
+     *
+     * @private
+     * @param {string} message - Error message
+     * @param {Error} error - Error object
+     */
+    private _handleError;
+    /**
+     * Log message
+     *
+     * @private
+     * @param {string} message - Log message
+     * @param {boolean} isError - Whether this is an error
+     */
+    private _log;
+    /**
+     * Register a lifecycle hook
+     *
+     * @param {string} hookName - Hook name (beforeReload, afterReload, onError, etc.)
+     * @param {Function} callback - Hook callback
+     */
+    registerHook(hookName: string, callback: Function): void;
+    /**
+     * Unregister a lifecycle hook
+     *
+     * @param {string} hookName - Hook name
+     * @param {Function} callback - Hook callback
+     */
+    unregisterHook(hookName: string, callback: Function): void;
+    /**
+     * Get reload statistics
+     *
+     * @returns {object} Reload statistics
+     */
+    getStats(): object;
+    /**
+     * Get reload history
+     *
+     * @returns {Array<object>} Reload history
+     */
+    getHistory(): Array<object>;
+    /**
+     * Clear reload history
+     */
+    clearHistory(): void;
+    /**
+     * Manually trigger a reload
+     *
+     * @param {string} filePath - File path to reload
+     * @param {string} type - Type ('plugin' or 'config')
+     * @returns {Promise<void>}
+     */
+    triggerReload(filePath: string, type?: string): Promise<void>;
+}
+/**
+ * Create hot reload manager
+ *
+ * @param {object} options - Manager options
+ * @returns {HotReloadManager} Hot reload manager instance
+ */
+export function createHotReloadManager(options?: object): HotReloadManager;
+import { EventEmitter } from "events";

package/dist/types/ecosystem/plugin-analytics-dashboard.d.ts

@@ -0,0 +1,141 @@
+export class PluginAnalyticsDashboard extends EventEmitter<[never]> {
+    constructor(_options?: {});
+    _config: {
+        port: any;
+        dataDir: any;
+        refreshInterval: any;
+        retentionDays: any;
+    };
+    metrics: Map<any, any>;
+    realTimeData: Map<any, any>;
+    subscribers: Set<any>;
+    /**
+     * Initialize metric collectors
+     */
+    initializeMetrics(): void;
+    /**
+     * Start collecting analytics data
+     */
+    startDataCollection(): void;
+    /**
+     * Record plugin installation
+     */
+    recordInstallation(pluginId: any, version: any, metadata?: {}): void;
+    /**
+     * Record plugin search
+     */
+    recordSearch(query: any, results: any, latency: any): void;
+    /**
+     * Record plugin rating
+     */
+    recordRating(pluginId: any, rating: any, review?: any): void;
+    /**
+     * Record security scan
+     */
+    recordSecurityScan(pluginId: any, result: any): void;
+    /**
+     * Record certification request
+     */
+    recordCertification(pluginId: any, level: any, result: any): void;
+    /**
+     * Get dashboard data
+     */
+    getDashboardData(): {
+        timestamp: number;
+        metrics: any;
+        recentActivity: any[];
+        timeSeriesData: {
+            installs: any[];
+            searches: any[];
+            ratings: any[];
+            securityScans: any[];
+        };
+        topPlugins: any[];
+        performanceSummary: {
+            avgInstallTime: number;
+            p95InstallTime: any;
+            avgSearchLatency: number;
+            p95SearchLatency: any;
+        };
+        securityOverview: {
+            totalScans: number;
+            riskDistribution: {
+                low: number;
+                medium: number;
+                high: number;
+            };
+            totalIssues: number;
+            avgIssuesPerScan: number;
+        };
+        summary: {
+            totalInstalls: any;
+            totalSearches: any;
+            activePlugins: any;
+            certifiedPlugins: any;
+            avgRating: number;
+            securityScore: number;
+        };
+    };
+    /**
+     * Generate time series data for charts
+     */
+    generateTimeSeriesData(): {
+        installs: any[];
+        searches: any[];
+        ratings: any[];
+        securityScans: any[];
+    };
+    /**
+     * Get top performing plugins
+     */
+    getTopPlugins(): any[];
+    /**
+     * Get performance summary
+     */
+    getPerformanceSummary(): {
+        avgInstallTime: number;
+        p95InstallTime: any;
+        avgSearchLatency: number;
+        p95SearchLatency: any;
+    };
+    /**
+     * Get security overview
+     */
+    getSecurityOverview(): {
+        totalScans: number;
+        riskDistribution: {
+            low: number;
+            medium: number;
+            high: number;
+        };
+        totalIssues: number;
+        avgIssuesPerScan: number;
+    };
+    /**
+     * Generate HTML dashboard
+     */
+    generateHTMLDashboard(): Promise<string>;
+    _generateHTMLHead(): string;
+    _generateHTMLStyles(): string;
+    _generateHTMLBody(data: any): string;
+    _generateDashboardHeader(data: any): string;
+    _generateMetricsGrid(data: any): string;
+    _generateChartsSection(): string;
+    _generateActivityFeed(data: any): string;
+    _generateHTMLScripts(data: any): string;
+    _generateActivityChartScript(data: any): string;
+    _generateTopPluginsChartScript(data: any): string;
+    incrementMetric(name: any, amount?: number): void;
+    recordHistogram(name: any, value: any): void;
+    calculateAverageRating(): number;
+    calculateSecurityScore(): number;
+    calculatePercentile(values: any, percentile: any): any;
+    getActivityStatus(activity: any): "error" | "warning" | "success";
+    formatActivityDescription(activity: any): string;
+    collectMetrics(): Promise<void>;
+    updateRealTimeData(): void;
+    notifySubscribers(): void;
+    cleanupOldData(): Promise<void>;
+    subscribe(callback: any): () => boolean;
+}
+import { EventEmitter } from "events";

package/dist/types/ecosystem/plugin-hub.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Client for a plugin hub registry: search, inspect, install, publish and
+ * rate plugins.
+ */
+export class PluginHub extends EventEmitter<[never]> {
+    constructor(_options?: {});
+    _config: {
+        registryUrl: any;
+        localCacheDir: any;
+        apiKey: any;
+        userAgent: any;
+        timeout: any;
+        maxRetries: any;
+        fetch: any;
+    };
+    _fetch: any;
+    cache: Map<any, any>;
+    analytics: PluginAnalytics;
+    sandbox: PluginSandbox;
+    /**
+     * Search plugins in the community hub
+     */
+    searchPlugins(query: any, _options?: {}): Promise<{
+        results: any;
+        total: any;
+        hasMore: any;
+        facets: any;
+    }>;
+    /**
+     * Get detailed plugin information
+     */
+    getPluginInfo(pluginId: any): Promise<any>;
+    /**
+     * Install plugin from the hub
+     */
+    /**
+     * Download a plugin from the registry and install it into a project
+     * (see ecosystem/plugin-installer.js): sha256 verified against the
+     * registry, static security scan (high-risk findings block unless
+     * allowRisky), stage contract check, files kept inside
+     * <project>/.rag/plugins, and `plugins.<stage>.<name>` added to the config.
+     *
+     * @param {string} pluginId - Registry plugin id
+     * @param {string} [version='latest']
+     * @param {object} [_options]
+     * @param {string} [_options.configPath='.ragrc.json'] - Config to register the plugin in
+     * @param {boolean} [_options.requireCertified] - Refuse plugins the registry marks uncertified
+     * @param {string} [_options.stage] - Overrides package.json ragPipeline.stage
+     * @param {string} [_options.name] - Overrides package.json ragPipeline.name
+     * @param {boolean} [_options.force] - Replace an installed plugin
+     * @param {boolean} [_options.allowRisky] - Install despite high-risk findings
+     */
+    installPlugin(pluginId: string, version?: string, _options?: {
+        configPath?: string;
+        requireCertified?: boolean;
+        stage?: string;
+        name?: string;
+        force?: boolean;
+        allowRisky?: boolean;
+    }): Promise<any>;
+    /**
+     * Publish plugin to the hub
+     */
+    publishPlugin(pluginPath: any, _options?: {}): Promise<any>;
+    /**
+     * Rate and review a plugin
+     */
+    ratePlugin(pluginId: any, rating: any, review?: any): Promise<any>;
+    /**
+     * Get plugin reviews and ratings
+     */
+    getPluginReviews(pluginId: any, _options?: {}): Promise<any>;
+    /**
+     * Get trending plugins
+     */
+    getTrendingPlugins(_options?: {}): Promise<any>;
+    /**
+     * Get user's installed plugins
+     */
+    /**
+     * Plugins registered in a project's config (see plugin-installer
+     * listInstalledPlugins).
+     * @param {string} [configPath='.ragrc.json']
+     */
+    getInstalledPlugins(configPath?: string): Promise<{
+        stage: string;
+        name: string;
+        entry: string;
+        version: string | null;
+        installed: boolean;
+        inPipeline: boolean;
+        exists: boolean;
+    }[]>;
+    _makeRequest(method: any, endpoint: any, params?: {}): Promise<any>;
+    _normalizePluginInfo(plugin: any): {
+        id: any;
+        name: any;
+        version: any;
+        description: any;
+        author: any;
+        category: any;
+        tags: any;
+        rating: any;
+        reviewCount: any;
+        downloadCount: any;
+        certified: any;
+        certificationId: any;
+        verifiedPublisher: any;
+        lastUpdated: any;
+        createdAt: any;
+        homepage: any;
+        repository: any;
+        license: any;
+        dependencies: any;
+        compatibility: any;
+        screenshots: any;
+        documentation: any;
+        checksums: any;
+    };
+    _getDownloadUrl(pluginId: any, version: any): Promise<any>;
+    _downloadPlugin(url: any): Promise<any>;
+    _verifyPluginIntegrity(data: any, checksums: any): Promise<void>;
+    _validatePluginForPublish(pluginPath: any): Promise<any>;
+    _packagePlugin(pluginPath: any, pluginInfo: any): Promise<{
+        metadata: any;
+        files: any[];
+    }>;
+    _uploadPlugin(packageData: any, _options: any): Promise<any>;
+    _getInstalledVersion(pluginId: any, configPath?: string): Promise<string>;
+}
+export class PluginAnalytics {
+    constructor(_config: any);
+    _config: any;
+    _fetch: any;
+    events: any[];
+    flushInterval: NodeJS.Timeout;
+    trackSearch(query: any, resultCount: any): void;
+    trackPluginView(pluginId: any): void;
+    trackInstallation(pluginId: any, version: any, result: any): void;
+    trackReview(pluginId: any, rating: any): void;
+    getLastUsed(pluginId: any): Promise<number>;
+    _track(type: any, data: any): void;
+    _flush(): Promise<void>;
+    _getSessionId(): `${string}-${string}-${string}-${string}-${string}`;
+    sessionId: `${string}-${string}-${string}-${string}-${string}`;
+}
+export class PluginSandbox {
+    constructor(_config: any);
+    _config: any;
+    scanPlugin(pluginInfo: any): Promise<{
+        risk: string;
+        issues: any[];
+        recommendations: string[];
+    }>;
+    installPlugin(_pluginData: any, _options: any): Promise<any>;
+    _isSuspiciousDependency(dep: any): boolean;
+    _isHighRiskPermission(permission: any): boolean;
+    _generateRecommendations(risks: any, warnings: any): string[];
+    _runInSandbox(_sandboxId: any, fn: any, _options: any): Promise<any>;
+}
+import { EventEmitter } from "events";