@lotargo/memory_plugin 1.5.3 → 1.6.0

package/mcp-server/cli/handlers/engine_actions.js

@@ -115,6 +115,47 @@ export async function handleEngineAction(value, config) {
       }
       break;
     }
+    case "vector_dim": {
+      const dimItems = [
+        { label: "0 - Auto (Detect from Model)", value: 0, info: "Use the vector dimension produced by the embedding model (Recommended)" },
+        { label: "384", value: 384, info: "MiniLM-L6 / multilingual-e5-small" },
+        { label: "512", value: 512, info: "Compact embedding models" },
+        { label: "768", value: 768, info: "e5-large / bge-base / MiniLM-L12" },
+        { label: "1024", value: 1024, info: "bge-m3 / modern multilingual models" },
+        { label: "1536", value: 1536, info: "OpenAI text-embedding-3-small (for compatible local models)" },
+        { label: "3072", value: 3072, info: "OpenAI text-embedding-3-large (for compatible local models)" },
+        { label: "Custom Dimension...", value: "custom", info: "Specify any dimension not listed here" },
+      ];
+      const currentDim = config.vectorDimension || 0;
+      const initialDimIdx = Math.max(0, dimItems.findIndex((i) => i.value === currentDim));
+
+      const subRes = await selectSimpleMenu({
+        title: "SELECT VECTOR DIMENSION",
+        subtitle: "Force a fixed embedding size (pads/truncates model output for consistent matching)",
+        items: dimItems,
+        initialIndex: initialDimIdx,
+      });
+
+      if (subRes.action === "select") {
+        let chosenDim = subRes.value;
+        if (subRes.value === "custom") {
+          const inputRes = await readTextInput("Enter Vector Dimension (positive integer)", "768");
+          if (inputRes.action === "submit" && inputRes.value) {
+            const parsed = Number.parseInt(inputRes.value, 10);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+              console.log(`\x1b[31mInvalid dimension: "${inputRes.value}". Expected a positive integer.\x1b[0m`);
+              await waitForEnter();
+              break;
+            }
+            chosenDim = parsed;
+          } else {
+            break;
+          }
+        }
+        updateConfig({ vectorDimension: chosenDim });
+      }
+      break;
+    }
     case "batch_size": {
       const batchItems = [
         { label: "Batch Size 1 (Single Item)", value: 1, info: "Process micro-chunks strictly 1 by 1" },

package/mcp-server/cli/handlers/storage_actions.js

@@ -34,6 +34,7 @@ import {
   readTextInput,
   promptText,
   waitForEnter,
+  downloadModelWithProgress,
 } from "../ui.js";
 
 export async function handleStorageAction(value, config, stats) {
@@ -556,6 +557,63 @@ export async function handleStorageAction(value, config, stats) {
       }
       break;
     }
+    case "reindex_embeddings": {
+      const db = await getDatabase();
+      const chunkCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM micro_chunks").get();
+      const chunkCount = chunkCountRow ? chunkCountRow.cnt : 0;
+      const docCountRow = await db.prepare("SELECT COUNT(*) as cnt FROM documents").get();
+      const docCount = docCountRow ? docCountRow.cnt : 0;
+
+      if (chunkCount === 0) {
+        console.clear();
+        console.log("\n  [*] No micro-chunks to re-index. Ingest documents first.\n");
+        await waitForEnter();
+        break;
+      }
+
+      const dimLabel = config.vectorDimension > 0 ? `${config.vectorDimension}` : "AUTO";
+      console.clear();
+      console.log(`\n  \x1b[1m\x1b[37mRE-EMBED KNOWLEDGE BASE\x1b[0m\n`);
+      console.log(`  Model:     ${config.embeddingModel}`);
+      console.log(`  Dimension: ${dimLabel}`);
+      console.log(`  Documents: ${docCount}`);
+      console.log(`  Chunks:    ${chunkCount}`);
+      console.log("\n  Re-embeds ALL stored vectors with the active model & dimension.");
+      console.log("  Facts, fact-doc links, FTS index & graph edges are preserved.\n");
+
+      const confirmRes = await selectSimpleMenu({
+        title: "CONFIRM RE-INDEX",
+        items: [
+          {
+            label: "[CONFIRM] Re-Embed All Documents",
+            value: "confirm",
+            info: "Loads/downloads the model if needed, then re-embeds every chunk with the active configuration",
+          },
+          { label: "< Cancel / Back", value: "cancel" },
+        ],
+      });
+      if (!(confirmRes.action === "select" && confirmRes.value === "confirm")) break;
+
+      try {
+        const { reindexEmbeddings } = await import("../../ingest/pipeline.js");
+        await downloadModelWithProgress(config.embeddingModel, "embedding");
+        console.log(`\n  [REINDEX] Re-embedding ${chunkCount} chunks...\n`);
+        const res = await reindexEmbeddings({
+          progressCallback: (p) => {
+            process.stdout.write(`\r  Progress: ${p.done}/${p.total} chunks`);
+          },
+        });
+        process.stdout.write("\n");
+        console.log(`\n  \x1b[32m[OK] Re-index complete!\x1b[0m`);
+        console.log(`  Chunks re-embedded: ${res.reindexed}`);
+        console.log(`  Documents affected: ${res.documentsAffected}`);
+        console.log(`  Model: ${res.model} | Dimension: ${res.dimension || "AUTO"}\n`);
+      } catch (err) {
+        console.error(`  \x1b[31m[ERROR] Re-index failed: ${err.message}\x1b[0m\n`);
+      }
+      await waitForEnter();
+      break;
+    }
     case "export_snapshot": {
       const { exportSnapshot } = await import("../../admin/snapshot.js");
       const defaultPath = join(MEMORY_DIR, "exports", `rag_snapshot_${Date.now()}.json.gz`);

package/mcp-server/cli/secret_input.js

@@ -0,0 +1,44 @@
+import { createInterface } from "node:readline";
+
+// Reading a token from argv leaks it into `ps`, Task Manager, shell history and
+// CI logs. Preferred order: environment variable -> stdin prompt -> argv (warned).
+export async function resolveSecret({ argvValue, envKeys = [], promptLabel = "Token", interactive = true }) {
+  for (const key of envKeys) {
+    const v = process.env[key];
+    if (v && String(v).trim()) return String(v).trim();
+  }
+
+  if (argvValue && String(argvValue).trim()) {
+    console.error(
+      `  [WARN] Passing a secret on the command line exposes it to the process list and shell history. ` +
+        `Prefer ${envKeys[0] || "an environment variable"} or the interactive prompt.`
+    );
+    return String(argvValue).trim();
+  }
+
+  if (!interactive || !process.stdin.isTTY) return null;
+  return await readHiddenLine(`${promptLabel}: `);
+}
+
+// Read a line from stdin without echoing it back to the terminal.
+export function readHiddenLine(prompt) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const onData = (char) => {
+      const s = String(char);
+      if (s === "\n" || s === "\r" || s === "\u0004") {
+        process.stdin.removeListener("data", onData);
+        return;
+      }
+      process.stdout.write("\x1b[2K\x1b[200D" + prompt + "*".repeat(rl.line.length));
+    };
+    process.stdout.write(prompt);
+    process.stdin.on("data", onData);
+    rl.question("", (answer) => {
+      process.stdin.removeListener("data", onData);
+      rl.close();
+      process.stdout.write("\n");
+      resolve(String(answer || "").trim());
+    });
+  });
+}