rag-v1

import {
  type ChatMessage,
  type PromptPreprocessorController,
} from "@lmstudio/sdk";
import { configSchematics } from "./config.js";
import * as fs from "fs/promises";
import * as path from "path";

const FINAL_MEMORY_PATH = "D:/bido/2026/final_memory";

export async function preprocess(
  ctl: PromptPreprocessorController,
  userMessage: ChatMessage
) {
  const userPrompt = userMessage.getText();

  try {
    const stats = await fs.stat(FINAL_MEMORY_PATH);
    if (!stats.isDirectory()) {
      return userMessage;
    }
  } catch {
    return userMessage;
  }

  const processed = await searchAndInjectMemory(ctl, userPrompt);
  if (processed !== userPrompt) {
    userMessage.replaceText(processed);
  }

  return userMessage;
}

function cosineSimilarity(a: number[], b: number[]): number {
  if (!a || !b || a.length !== b.length || a.length === 0) return 0;
  
  let dot = 0, normA = 0, normB = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    normA += a[i] * a[i];
    normB += b[i] * b[i];
  }
  
  if (normA === 0 || normB === 0) return 0;
  return dot / (Math.sqrt(normA) * (Math.sqrt(normB) + 1e-9));
}

async function searchAndInjectMemory(
  ctl: PromptPreprocessorController,
  originalUserPrompt: string
): Promise<string> {
  const pluginConfig = ctl.getPluginConfig(configSchematics);
  const retrievalLimit = pluginConfig.get("retrievalLimit") || 3;
  const threshold = pluginConfig.get("retrievalAffinityThreshold") || 0.5;

  const status = ctl.createStatus({
    status: "loading",
    text: "🧠 Loading embedding model for memory retrieval...",
  });

  try {
    const model = await ctl.client.embedding.model(
      "nomic-ai/nomic-embed-text-v1.5-GGUF",
      { signal: ctl.abortSignal }
    );

    status.setState({ status: "loading", text: "📤 Embedding your query..." });
    const embedResult = await model.embed(originalUserPrompt);
    const userEmbedding = embedResult.embedding;

    status.setState({ status: "loading", text: "🔍 Searching memory nodes..." });

    const files = await fs.readdir(FINAL_MEMORY_PATH);
    let allNodes: any[] = [];

    for (const file of files) {
      if (!file.endsWith(".json") || file === "template.json") continue;
      try {
        const content = await fs.readFile(path.join(FINAL_MEMORY_PATH, file), "utf-8");
        const data = JSON.parse(content);
        if (data.nodes && Array.isArray(data.nodes)) {
          allNodes = allNodes.concat(data.nodes);
        }
      } catch (e) {
        ctl.debug(`Error parsing ${file}: ${e}`);
      }
    }

    if (allNodes.length === 0) {
      status.setState({ status: "canceled", text: "No memory nodes found." });
      return originalUserPrompt;
    }

    const results = allNodes
      .filter((node) => node.embedding && Array.isArray(node.embedding) && node.embedding.length > 0)
      .map((node) => ({ ...node, similarity: cosineSimilarity(userEmbedding, node.embedding) }))
      .filter((r) => r.similarity >= threshold)
      .sort((a, b) => b.similarity - a.similarity)
      .slice(0, retrievalLimit);

    if (results.length === 0) {
      status.setState({ status: "canceled", text: `No memories above threshold (${threshold}).` });
      return originalUserPrompt;
    }

    status.setState({
      status: "done",
      text: `✅ Retrieved ${results.length} memory pointers (${(results[0].similarity * 100).toFixed(1)}% top match).`,
    });

    // ─── بناء رسالة المؤشرات ───
    let injectedContent = `📌 **مؤشرات ذاكرة (ليست نصوصاً كاملة):**\n\n`;

    results.forEach((r, idx) => {
      injectedContent += `═══════════════════════════════════════════════\n`;
      injectedContent += `**${idx + 1}. ${r.title || "بدون عنوان"}**\n`;
      injectedContent += `📂 **الملف**: ${r.filePath || r.conversation_id || "غير معروف"}\n`;
      injectedContent += `🔗 **الصلة**: ${(r.similarity * 100).toFixed(1)}%\n\n`;
      
      if (r.summary) {
        injectedContent += `📝 **خلاصة**: ${r.summary}\n\n`;
      }
      
      if (r.key_ideas && r.key_ideas.length > 0) {
        injectedContent += `💡 **أفكار**: ${r.key_ideas.slice(0, 3).join("، ")}\n\n`;
      }
      
      if (r.decisions && r.decisions.length > 0) {
        injectedContent += `✅ **قرارات**: ${r.decisions.slice(0, 2).join("، ")}\n\n`;
      }
    });

    injectedContent += `═══════════════════════════════════════════════\n`;
    injectedContent += `\n🔍 **تعليمات:**\n`;
    injectedContent += `- هذه مجرد **مؤشرات**، وليست نصوصاً كاملة.\n`;
    injectedContent += `- استخدم أدواتك (eagleEye، readFile، memory_recall، semantic_search) للغوص في التفاصيل عند الحاجة.\n\n`;
    injectedContent += `---\n\n`;
    injectedContent += `**رسالة المستخدم:**\n${originalUserPrompt}`;

    return injectedContent;
    
  } catch (err: any) {
    ctl.debug("Error during memory retrieval", err);
    status.setState({ status: "canceled", text: `❌ Error: ${err.message}` });
    return originalUserPrompt;
  }
}