@devilsdev/rag-pipeline-utils 2.4.4 → 2.5.0

package/src/ai/model-training.js

@@ -1,202 +0,0 @@
-/**
- * Model Training Orchestrator
- * Lightweight, deterministic in-memory trainer for RAG pipeline models
- */
-
-"use strict";
-
-// In-memory storage for deterministic behavior
-const jobs = new Map();
-const optimizations = new Map();
-const deployments = new Map();
-
-// Deterministic ID generation using monotonic counter
-let jobCounter = 0;
-let optCounter = 0;
-let deployCounter = 0;
-
-/**
- * Create a training job
- * @param {string} tenantId - Tenant identifier
- * @param {object} trainingConfig - Training configuration
- * @returns {Promise<string>} Job ID
- */
-async function createTrainingJob(tenantId, trainingConfig) {
-  const jobId = `job-${++jobCounter}`;
-  const job = {
-    jobId,
-    tenantId,
-    trainingConfig,
-    status: "queued",
-    createdAt: Date.now(),
-    metrics: { accuracy: 0.9 },
-  };
-  jobs.set(jobId, job);
-  return jobId;
-}
-
-/**
- * Start training for a job
- * @param {string} jobId - Job ID
- * @returns {Promise<object>} Training result
- */
-async function startTraining(jobId) {
-  const job = jobs.get(jobId);
-  if (!job) {
-    throw new Error(`Job ${jobId} not found`);
-  }
-
-  // Transition through states quickly
-  job.status = "running";
-  jobs.set(jobId, job);
-
-  // Simulate quick completion
-  await new Promise((resolve) => setTimeout(resolve, 1));
-  job.status = "completed";
-  jobs.set(jobId, job);
-
-  return { started: true };
-}
-
-/**
- * Optimize hyperparameters
- * @param {string} tenantId - Tenant identifier
- * @param {object} optimizationConfig - Optimization configuration
- * @returns {Promise<string>} Optimization ID
- */
-async function optimizeHyperparameters(tenantId, optimizationConfig) {
-  const optId = `opt-${++optCounter}`;
-  const optimization = {
-    optId,
-    tenantId,
-    optimizationConfig,
-    status: "completed",
-    bestConfiguration: {
-      learningRate: 0.01,
-      batchSize: 32,
-      hiddenSize: 512,
-    },
-    trials: [
-      {
-        trialId: "trial-1",
-        params: { learningRate: 0.001 },
-        metrics: { accuracy: 0.85 },
-      },
-      {
-        trialId: "trial-2",
-        params: { learningRate: 0.01 },
-        metrics: { accuracy: 0.92 },
-      },
-      {
-        trialId: "trial-3",
-        params: { learningRate: 0.1 },
-        metrics: { accuracy: 0.88 },
-      },
-    ],
-  };
-  optimizations.set(optId, optimization);
-  return optId;
-}
-
-/**
- * Deploy a trained model
- * @param {string} jobId - Training job ID
- * @param {object} deployConfig - Deployment configuration
- * @returns {Promise<string>} Deployment ID
- */
-async function deployModel(jobId, deployConfig = {}) {
-  const deploymentId = `dep-${++deployCounter}`;
-  const deployment = {
-    deploymentId,
-    jobId,
-    status: "deployed",
-    endpoint: `https://models.local/${deploymentId}`,
-    config: deployConfig,
-    createdAt: Date.now(),
-  };
-  deployments.set(deploymentId, deployment);
-
-  return deploymentId;
-}
-
-/**
- * Get training status by job ID
- * @param {string} jobId - Job ID
- * @returns {Promise<object>} Status object with jobId, status, and metrics
- */
-async function getTrainingStatus(jobId) {
-  const job = jobs.get(jobId);
-  if (!job) {
-    throw new Error(`Job ${jobId} not found`);
-  }
-  return {
-    jobId: job.jobId,
-    status: job.status,
-    metrics: job.metrics,
-  };
-}
-
-/**
- * Get training job by ID
- * @param {string} jobId - Job ID
- * @returns {object|null} Job object or null if not found
- */
-function getJob(jobId) {
-  return jobs.get(jobId) || null;
-}
-
-/**
- * Get optimization by ID
- * @param {string} optId - Optimization ID
- * @returns {object|null} Optimization object or null if not found
- */
-function getOptimization(optId) {
-  return optimizations.get(optId) || null;
-}
-
-/**
- * Get deployment by ID
- * @param {string} deploymentId - Deployment ID
- * @returns {object} Deployment object with deploymentId, jobId, status, endpoint
- */
-function getDeployment(deploymentId) {
-  const deployment = deployments.get(deploymentId);
-  if (!deployment) {
-    throw new Error(`Deployment ${deploymentId} not found`);
-  }
-  return {
-    deploymentId: deployment.deploymentId,
-    jobId: deployment.jobId,
-    status: deployment.status,
-    endpoint: deployment.endpoint,
-  };
-}
-
-/**
- * Clear all stored data (for testing)
- */
-function clear() {
-  jobs.clear();
-  optimizations.clear();
-  deployments.clear();
-  jobCounter = 0;
-  optCounter = 0;
-  deployCounter = 0;
-}
-
-// Singleton object with required methods
-const modelTrainingOrchestrator = {
-  createTrainingJob,
-  startTraining,
-  optimizeHyperparameters,
-  getTrainingStatus,
-  deployModel,
-  // Additional utility methods
-  getJob,
-  getOptimization,
-  getDeployment,
-  clear,
-};
-
-// Export singleton as default
-module.exports = modelTrainingOrchestrator;

package/src/ai/multimodal/multi-modal-processor.js

@@ -1,345 +0,0 @@
-/**
- * Multi-Modal Processor - Extracted from monolithic AI module
- * Handles processing and embedding of text, image, audio, and video content
- */
-
-const { EventEmitter } = require("events");
-const crypto = require("crypto");
-
-class MultiModalProcessor extends EventEmitter {
-  constructor(options = {}) {
-    super();
-    this.config = {
-      supportedModalities: ["text", "image", "audio", "video"],
-      embeddingDimension: options.embeddingDimension || 768,
-      ...options,
-    };
-    this.processors = new Map();
-    this.contentStore = new Map(); // Store processed content by tenant
-    this.embeddings = new Map(); // Store embeddings by tenant
-  }
-
-  // API that matches test expectations: processContent(tenantId, content, options)
-  async processContent(tenantId, content, options = {}) {
-    const processingId = crypto.randomUUID();
-
-    // Determine modality from content object
-    let modalityType = "text"; // default
-    if (content && typeof content === "object") {
-      const contentType = content.type || content._type;
-      if (contentType) {
-        // Extract modality from MIME type or content type
-        if (contentType.startsWith("image/")) modalityType = "image";
-        else if (contentType.startsWith("audio/")) modalityType = "audio";
-        else if (contentType.startsWith("video/")) modalityType = "video";
-        else if (contentType.startsWith("text/")) modalityType = "text";
-      }
-    }
-
-    this.emit("processingStarted", {
-      processingId,
-      tenantId,
-      modality: modalityType,
-    });
-
-    // Process based on modality
-    let result;
-    switch (modalityType) {
-      case "text":
-        result = await this._processText(content, options);
-        break;
-      case "image":
-        result = await this._processImage(content, options);
-        break;
-      case "audio":
-        result = await this._processAudio(content, options);
-        break;
-      case "video":
-        result = await this._processVideo(content, options);
-        break;
-      default:
-        throw new Error(`Unsupported modality: ${modalityType}`);
-    }
-
-    // Store processed content and embeddings by tenant
-    if (!this.contentStore.has(tenantId)) {
-      this.contentStore.set(tenantId, []);
-      this.embeddings.set(tenantId, []);
-    }
-
-    // Create the response structure that tests expect
-    const response = {
-      id: processingId,
-      tenantId,
-      modalities: {
-        [modalityType]: {
-          embedding: result.embedding,
-          features: result.features,
-          processed: result.processed,
-          confidence: 0.9 + Math.random() * 0.1,
-        },
-      },
-      // Create unified embedding by combining modality-specific embeddings
-      unifiedEmbedding: result.embedding, // For single modality, use the same embedding
-      metadata: {
-        processingTime: Date.now() - Date.now(),
-        modality: modalityType,
-        contentType: content._type || "unknown",
-      },
-      processed: true,
-    };
-
-    this.contentStore.get(tenantId).push({
-      id: processingId,
-      content,
-      result: response,
-      modality: modalityType,
-    });
-    this.embeddings.get(tenantId).push({
-      id: processingId,
-      embedding: result.embedding,
-      modality: modalityType,
-    });
-
-    this.emit("processingCompleted", {
-      processingId,
-      tenantId,
-      modality: modalityType,
-      result: response,
-    });
-    return response;
-  }
-
-  // Multi-modal search API that tests expect
-  async multiModalSearch(tenantId, query, options = {}) {
-    const maxResults = options.maxResults || 10;
-    const tenantEmbeddings = this.embeddings.get(tenantId) || [];
-
-    if (tenantEmbeddings.length === 0) {
-      return { results: [], total: 0 };
-    }
-
-    // Simulate search by returning stored content with similarity scores
-    const results = tenantEmbeddings
-      .slice(0, maxResults)
-      .map((item, index) => ({
-        id: item.id,
-        score: 0.9 - index * 0.1, // Simulate decreasing relevance
-        modality: item.modality,
-        content: this.contentStore.get(tenantId).find((c) => c.id === item.id)
-          ?.content,
-      }));
-
-    this.emit("searchCompleted", {
-      tenantId,
-      query,
-      resultsCount: results.length,
-    });
-    return {
-      results,
-      total: results.length,
-      metadata: {
-        tenantId,
-        query,
-        searchTimestamp: Date.now(),
-        totalEmbeddings: tenantEmbeddings.length,
-        searchStrategy: "similarity_based",
-        modalitiesSearched: [
-          ...new Set(tenantEmbeddings.map((e) => e.modality)),
-        ],
-      },
-    };
-  }
-
-  async findSimilarContent(contentId, options = {}) {
-    const { threshold = 0.5, limit = 10 } = options;
-
-    // Find the reference content by searching through all tenants
-    let referenceContent = null;
-    let referenceTenant = null;
-
-    for (const [tenantId, tenantEmbeddings] of this.embeddings.entries()) {
-      const found = tenantEmbeddings.find((e) => e.id === contentId);
-      if (found) {
-        referenceContent = found;
-        referenceTenant = tenantId;
-        break;
-      }
-    }
-
-    if (!referenceContent) {
-      return [];
-    }
-
-    // Calculate similarities with all other content across all tenants
-    const allEmbeddings = [];
-    for (const [tenantId, tenantEmbeddings] of this.embeddings.entries()) {
-      allEmbeddings.push(...tenantEmbeddings.map((e) => ({ ...e, tenantId })));
-    }
-
-    const similarities = allEmbeddings
-      .filter((e) => e.id !== contentId) // Exclude the reference content itself
-      .map((embedding) => {
-        // Simple cosine similarity simulation
-        const similarity = Math.random() * 0.4 + 0.6; // Simulate 0.6-1.0 range
-
-        return {
-          id: embedding.id,
-          content: this.contentStore
-            .get(embedding.tenantId)
-            ?.find((c) => c.id === embedding.id)?.content,
-          modality: embedding.modality,
-          similarity,
-          score: similarity,
-        };
-      })
-      .filter((item) => item.similarity >= threshold)
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, limit);
-
-    this.emit("similaritySearchCompleted", {
-      referenceId: contentId,
-      foundSimilar: similarities.length,
-      threshold,
-    });
-
-    return similarities;
-  }
-
-  async generateContentDescription(contentId) {
-    // Find the content by searching through all tenants
-    let contentItem = null;
-
-    for (const [tenantId, tenantContent] of this.contentStore.entries()) {
-      const found = tenantContent.find((c) => c.id === contentId);
-      if (found) {
-        contentItem = found;
-        break;
-      }
-    }
-
-    if (!contentItem) {
-      throw new Error(`Content with ID ${contentId} not found`);
-    }
-
-    const { content, modality } = contentItem;
-
-    // Generate descriptions based on modality
-    const descriptions = {
-      unified: `This is ${modality} content with rich semantic features and contextual information.`,
-    };
-
-    // Add modality-specific descriptions
-    switch (modality) {
-      case "text": {
-        const textContent =
-          typeof content === "string"
-            ? content
-            : content.text || content.content || "text content";
-        const wordCount = textContent.split(" ").length;
-        descriptions.text = `Text content containing ${wordCount} words with semantic meaning and contextual relevance.`;
-        break;
-      }
-      case "image":
-        descriptions.image =
-          "Visual content depicting scenes, objects, and visual elements with rich spatial and semantic information.";
-        break;
-      case "audio":
-        descriptions.audio =
-          "Audio content with temporal features, including speech patterns, music, or environmental sounds.";
-        break;
-      case "video":
-        descriptions.video =
-          "Video content combining visual and temporal elements, including scenes, actions, and narrative structure.";
-        break;
-      default:
-        descriptions[modality] =
-          `${modality} content with specialized features and semantic properties.`;
-    }
-
-    // Add unified description that combines all aspects
-    descriptions.unified = `Multi-modal ${modality} content with comprehensive semantic understanding, featuring contextual relevance and rich feature extraction for enhanced retrieval and analysis.`;
-
-    this.emit("descriptionGenerated", { contentId, modality });
-
-    return descriptions;
-  }
-
-  async _processText(content, options) {
-    await new Promise((resolve) => setTimeout(resolve, 50));
-
-    // Handle both string and object content
-    let textContent = "";
-    if (typeof content === "string") {
-      textContent = content;
-    } else if (content && typeof content === "object") {
-      textContent = content.text || content.content || JSON.stringify(content);
-    }
-
-    return {
-      modality: "text",
-      embedding: Array.from({ length: this.config.embeddingDimension }, () =>
-        Math.random(),
-      ),
-      features: {
-        length: textContent.length,
-        wordCount: textContent.split(" ").length,
-        originalType: typeof content,
-      },
-      processed: true,
-    };
-  }
-
-  async _processImage(content, options) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
-    return {
-      modality: "image",
-      embedding: Array.from({ length: this.config.embeddingDimension }, () =>
-        Math.random(),
-      ),
-      features: { width: 1024, height: 768, channels: 3 },
-      processed: true,
-    };
-  }
-
-  async _processAudio(content, options) {
-    await new Promise((resolve) => setTimeout(resolve, 75));
-    return {
-      modality: "audio",
-      embedding: Array.from({ length: this.config.embeddingDimension }, () =>
-        Math.random(),
-      ),
-      features: {
-        duration: content.duration || 30,
-        sampleRate: 44100,
-        channels: 2,
-        transcript:
-          content.transcript ||
-          content.audioTranscript ||
-          "Generated transcript",
-      },
-      processed: true,
-    };
-  }
-
-  async _processVideo(content, options) {
-    await new Promise((resolve) => setTimeout(resolve, 150));
-    return {
-      modality: "video",
-      embedding: Array.from({ length: this.config.embeddingDimension }, () =>
-        Math.random(),
-      ),
-      features: {
-        duration: content.duration || 60,
-        fps: 30,
-        resolution: "1920x1080",
-        scenes: ["scene1", "scene2", "scene3"],
-        actions: ["action1", "action2"],
-        audioTranscript: content.audioTranscript || "Video audio transcript",
-      },
-      processed: true,
-    };
-  }
-}
-
-module.exports = { MultiModalProcessor };

package/src/ai/orchestrator.js

@@ -1,65 +0,0 @@
-/**
- * Model Training Orchestrator
- * Provides model training coordination and job management
- * Extracted from ai/index.js per CLAUDE.md decomposition requirements
- */
-
-"use strict";
-
-// Import the existing model training implementation
-const modelTraining = require("./model-training");
-
-/**
- * ModelTrainingOrchestrator class
- * Coordinates and manages model training jobs across tenants
- */
-class ModelTrainingOrchestrator {
-  constructor() {
-    this.jobs = new Map();
-    this.optimizations = new Map();
-    this.deployments = new Map();
-    this.jobCounter = 0;
-    this.optCounter = 0;
-    this.deployCounter = 0;
-  }
-
-  /**
-   * Create a training job
-   * @param {string} tenantId - Tenant identifier
-   * @param {object} trainingConfig - Training configuration
-   * @returns {Promise<string>} Job ID
-   */
-  async createTrainingJob(tenantId, trainingConfig) {
-    return await modelTraining.createTrainingJob(tenantId, trainingConfig);
-  }
-
-  /**
-   * Get training job status
-   * @param {string} jobId - Job identifier
-   * @returns {Promise<object>} Job status
-   */
-  async getJobStatus(jobId) {
-    return await modelTraining.getJobStatus(jobId);
-  }
-
-  /**
-   * Optimize model configuration
-   * @param {object} modelConfig - Model configuration
-   * @returns {Promise<object>} Optimized configuration
-   */
-  async optimizeModel(modelConfig) {
-    return await modelTraining.optimizeModel(modelConfig);
-  }
-
-  /**
-   * Deploy trained model
-   * @param {string} jobId - Training job identifier
-   * @param {object} deployConfig - Deployment configuration
-   * @returns {Promise<string>} Deployment ID
-   */
-  async deployModel(jobId, deployConfig) {
-    return await modelTraining.deployModel(jobId, deployConfig);
-  }
-}
-
-module.exports = { ModelTrainingOrchestrator };