@o-lang/semantic-doc-search 1.1.1 → 1.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/semantic-doc-search",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "O-Lang semantic document search resolver with vector embeddings",
   "main": "src/index.js",
   "exports": {

package/src/adapters/inMemoryAdapter.js

@@ -1,11 +1,50 @@
 const VectorAdapter = require("./VectorAdapter");
 const capabilities = require("./vectorCapabilities");
+const fs = require("fs");
+const path = require("path");
+
+// ✅ SINGLETON store — persists across all requests in the same process
+// This ensures vectors ingested in one request are available in the next
+const GLOBAL_STORE = [];
+
+// ✅ Persist store to disk so vectors survive server restarts
+const STORE_PATH = path.join(process.cwd(), "vector-store.json");
+
+function loadStore() {
+  try {
+    if (fs.existsSync(STORE_PATH)) {
+      const data = JSON.parse(fs.readFileSync(STORE_PATH, "utf8"));
+      if (Array.isArray(data) && data.length > 0) {
+        GLOBAL_STORE.push(...data);
+        console.log(`[InMemoryAdapter] ✅ Loaded ${data.length} vectors from disk`);
+      }
+    }
+  } catch (e) {
+    console.warn("[InMemoryAdapter] Could not load vector store from disk:", e.message);
+  }
+}
+
+function saveStore() {
+  try {
+    fs.writeFileSync(STORE_PATH, JSON.stringify(GLOBAL_STORE, null, 2));
+  } catch (e) {
+    console.warn("[InMemoryAdapter] Could not save vector store to disk:", e.message);
+  }
+}
+
+// Load persisted vectors once when the module is first required
+let _loaded = false;
+if (!_loaded) {
+  loadStore();
+  _loaded = true;
+}
 
 class InMemoryAdapter extends VectorAdapter {
   constructor(config = {}) {
     super({ ...config, backend: "memory" });
     this.dimension = config.dimension || 384;
-    this.store = [];
+    // ✅ Use singleton store instead of new empty array
+    this.store = GLOBAL_STORE;
   }
 
   static capabilities() {
@@ -14,13 +53,23 @@ class InMemoryAdapter extends VectorAdapter {
 
   async upsert({ id, vector, content, source, metadata = {} }) {
     this.validateVector(vector);
-    this.store.push({ id, vector, content, source, metadata });
-     console.log("💾 Stored vector for:", id, "store size:", this.store.length);
+
+    // ✅ Deduplicate by id — replace if exists
+    const existingIndex = this.store.findIndex(item => item.id === id);
+    if (existingIndex >= 0) {
+      this.store[existingIndex] = { id, vector, content, source, metadata };
+    } else {
+      this.store.push({ id, vector, content, source, metadata });
+    }
+
+    // ✅ Persist to disk after every upsert
+    saveStore();
+    console.log("💾 Stored vector for:", id, "| store size:", this.store.length);
   }
 
   async query(vector, { topK = 5 } = {}) {
     this.validateVector(vector);
-     console.log("🔍 Querying store with", this.store.length, "vectors");
+    console.log("🔍 Querying store with", this.store.length, "vectors");
     return this.store
       .map(doc => ({
         ...doc,
@@ -41,4 +90,4 @@ function cosineSimilarity(a, b) {
   return dot / (Math.sqrt(na) * Math.sqrt(nb));
 }
 
-module.exports = InMemoryAdapter;
+module.exports = InMemoryAdapter;

package/src/resolver.js

@@ -46,11 +46,13 @@ async function resolver(action, context = {}) {
 
   // Extract ALL quoted args from action string
   const args = [...action.matchAll(/"([^"]*)"/g)].map(m => m[1]);
-  
+
   const vectorStore = VectorRouter.create(context);
   const getEmbedFn = await embedder({ dimension: 384 });
-  const useCache = !!context.POSTGRES_URL || !!context.REDIS_URL;
-  const cache = useCache ? loadCache() : {};
+
+  // ✅ Always use cache for local persistence — no Postgres/Redis required
+  const useCache = true;
+  const cache = loadCache();
 
   // =====================================================
   // ✅ INGEST: 1 arg = doc_root
@@ -71,7 +73,7 @@ async function resolver(action, context = {}) {
           const text = sanitizeTextForEmbedding(chunks[i]);
           if (!text) continue;
           const hash = hashText(text);
-          if (useCache && cache[hash]) continue;
+          if (cache[hash]) continue; // skip already-ingested chunks
           const rawVector = await getEmbedFn(text);
           await vectorStore.upsert({
             id: `${file}:${i}`,
@@ -79,13 +81,15 @@ async function resolver(action, context = {}) {
             content: text,
             source: `file:${file}`,
           });
-          if (useCache) cache[hash] = true;
+          cache[hash] = true;
           inserted++;
         }
       }
     }
-    if (useCache) saveCache(cache);
+
+    saveCache(cache);
     if (vectorStore.close) await vectorStore.close();
+    console.log(`[vector.search] ✅ Ingested ${inserted} chunks from ${ingestRoot}`);
     return { inserted, doc_root: ingestRoot };
   }
 
@@ -110,6 +114,6 @@ async function resolver(action, context = {}) {
 
 // ✅ Must match workflow's "Allow resolvers: - vector.search"
 resolver.resolverName = "vector.search";
-resolver.version = "1.0.42";
+resolver.version = "1.0.43";
 
-module.exports = resolver;
+module.exports = resolver;